tilemap-editor 3.3.3__tar.gz → 3.3.4__tar.gz

{tilemap_editor-3.3.3/src/tilemap_editor.egg-info → tilemap_editor-3.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 3.3.3
+Version: 3.3.4
 Summary: Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-3.3.3 → tilemap_editor-3.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "3.3.3"
+version = "3.3.4"
 description = "Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools"
 readme = "README.md"
 requires-python = ">=3.10"

{tilemap_editor-3.3.3 → tilemap_editor-3.3.4}/src/plugins/sprite_editor/editor.py

@@ -149,6 +149,24 @@ class SpriteEditor:
                     if self.grid.redo():
                         self.grid.selected_indices.clear()
                     return True
+                elif event.key == pygame.K_c:
+                    if self.grid.has_selection():
+                        self._clipboard = self.grid.copy_selected()
+                        self._paste_mode = False
+                        self.grid.paste_preview_idx = -1
+                    return True
+                elif event.key == pygame.K_x:
+                    if self.grid.has_selection():
+                        self._clipboard = self.grid.cut_selected()
+                        self._paste_mode = False
+                        self.grid.paste_preview_idx = -1
+                    return True
+                elif event.key == pygame.K_v:
+                    if self._clipboard:
+                        self._paste_mode = not self._paste_mode
+                        if not self._paste_mode:
+                            self.grid.paste_preview_idx = -1
+                    return True
 
         # Toolbar clicks
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
@@ -156,19 +174,20 @@ class SpriteEditor:
                 if r.collidepoint(mouse):
                     return self._handle_tool(lbl)
 
-        # Paste mode: next grid click pastes
+        # Paste mode: click places (or exits if outside grid)
         if self._paste_mode and event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
             idx = self.grid.index_at_pos(mouse)
             if idx >= 0 and self.grid.rect.collidepoint(mouse):
                 self.grid.paste_at(idx, self._clipboard)
-                self._paste_mode = False
-                self.grid.paste_preview_idx = -1
-                return True
+            self._paste_mode = False
+            self.grid.paste_preview_idx = -1
+            return True
 
-        # Paste preview on hover
+        # Paste preview on hover (consume event to prevent grid overlap)
         if self._paste_mode and event.type == pygame.MOUSEMOTION:
             idx = self.grid.index_at_pos(mouse)
             self.grid.paste_preview_idx = idx if idx >= 0 else -1
+            return True
 
         return self.grid.handle_event(event)
 

{tilemap_editor-3.3.3 → tilemap_editor-3.3.4}/src/plugins/tileset_collision/collision_painter.py

@@ -117,7 +117,8 @@ class CollisionPainter:
         self.snap_to_grid = False
         self.grid_size = 8  # pixels
         self.show_grid = True
-        self.edge_draw_mode = False  # E key - straight line drawing
+        self.show_angle_hints = False  # show angle arcs at vertices
+        self.edge_draw_mode = False  # Ctrl+E - straight line drawing
         self._edge_start: Optional[Tuple[int, int]] = None  # Start point for edge draw
         self._shift_held = False
         
@@ -270,7 +271,66 @@ class CollisionPainter:
     def get_one_way_flags(self) -> List[bool]:
         """Get one-way collision flags for all polygons"""
         return list(self.polygon_one_way)
+
+    def toggle_one_way(self) -> None:
+        """Toggle one-way flag on the selected polygon"""
+        idx = self.selected_polygon_idx
+        if idx is not None and 0 <= idx < len(self.polygon_one_way):
+            self.polygon_one_way[idx] = not self.polygon_one_way[idx]
+            if self.on_polygon_modified:
+                self.on_polygon_modified(idx)
     
+    def _get_interior_angle(
+        self, polygon: List[Tuple[float, float]], idx: int
+    ) -> float:
+        """Compute interior angle (degrees) at polygon vertex idx."""
+        n = len(polygon)
+        if n < 3:
+            return 0.0
+        prev = polygon[(idx - 1) % n]
+        curr = polygon[idx]
+        nxt = polygon[(idx + 1) % n]
+        v1 = (prev[0] - curr[0], prev[1] - curr[1])
+        v2 = (nxt[0] - curr[0], nxt[1] - curr[1])
+        dot = v1[0] * v2[0] + v1[1] * v2[1]
+        mag1 = math.hypot(v1[0], v1[1])
+        mag2 = math.hypot(v2[0], v2[1])
+        if mag1 < 0.001 or mag2 < 0.001:
+            return 0.0
+        cos_a = max(-1.0, min(1.0, dot / (mag1 * mag2)))
+        return math.degrees(math.acos(cos_a))
+
+    def _draw_angle_hint(
+        self,
+        screen: pygame.Surface,
+        screen_pos: Tuple[int, int],
+        angle_deg: float,
+    ) -> None:
+        """Draw a small arc + angle text at a vertex."""
+        if angle_deg <= 0.5 or angle_deg >= 179.5:
+            return
+        arc_radius = 14
+        segments = max(4, int(angle_deg / 10))
+        angle_rad = math.radians(angle_deg)
+        pts = [screen_pos]
+        for i in range(segments + 1):
+            t = -angle_rad * i / segments
+            pts.append((
+                screen_pos[0] + arc_radius * math.cos(t),
+                screen_pos[1] + arc_radius * math.sin(t),
+            ))
+        if len(pts) >= 3:
+            wedge = pygame.Surface(self.rect.size, pygame.SRCALPHA)
+            pygame.draw.polygon(wedge, (*_COLORS["polygon_fill"], 60), pts)
+            screen.blit(wedge, self.rect.topleft)
+        label = self._font_sm.render(f"{angle_deg:.0f}°", True, _COLORS["text"])
+        label_x = screen_pos[0] + 10
+        label_y = screen_pos[1] - label.get_height() - 4
+        bg = pygame.Surface((label.get_width() + 4, label.get_height() + 2), pygame.SRCALPHA)
+        bg.fill((0, 0, 0, 180))
+        screen.blit(bg, (label_x - 2, label_y - 1))
+        screen.blit(label, (label_x, label_y))
+
     def clear_all(self) -> None:
         """Clear all polygons"""
         self.polygons = []
@@ -488,23 +548,26 @@ class CollisionPainter:
         
         # Keyboard shortcuts
         if event.type == pygame.KEYDOWN:
+            mods = pygame.key.get_mods()
+            ctrl = mods & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA)
+
             # Track Shift state for edge draw
             if event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
                 self._shift_held = True
-            
-            # E - toggle edge draw mode
-            elif event.key == pygame.K_e:
+
+            # Ctrl+E - toggle edge draw mode
+            elif ctrl and event.key == pygame.K_e:
                 self.edge_draw_mode = not self.edge_draw_mode
                 if not self.edge_draw_mode:
                     self._edge_start = None
                 return True
-            
+
             # Enter - complete polygon
             elif event.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
                 if len(self.current_polygon) >= 3:
                     self._complete_polygon()
                     return True
-            
+
             # Escape - cancel current polygon or deselect or close help
             elif event.key == pygame.K_ESCAPE:
                 if self.show_help:
@@ -517,44 +580,45 @@ class CollisionPainter:
                     self.selected_polygon_idx = None
                     self.selected_vertex_idx = None
                     return True
-            
-            # Delete - remove selected polygon
+
+            # Delete/Backspace - remove selected polygon or last vertex
             elif event.key in (pygame.K_DELETE, pygame.K_BACKSPACE):
                 if self.selected_polygon_idx is not None:
                     self._delete_polygon(self.selected_polygon_idx)
                     return True
                 elif self.current_polygon:
-                    # Remove last vertex
                     self.current_polygon.pop()
                     return True
-            
-            # G - toggle grid
-            elif event.key == pygame.K_g:
+
+            # Ctrl+G - toggle grid
+            elif ctrl and event.key == pygame.K_g:
                 self.show_grid = not self.show_grid
                 return True
-            
-            # S - toggle snap (only if Ctrl is not held)
-            elif event.key == pygame.K_s:
-                mods = pygame.key.get_mods()
-                ctrl_held = mods & (pygame.KMOD_CTRL | pygame.KMOD_LMETA)
-                if not ctrl_held:
-                    self.snap_to_grid = not self.snap_to_grid
-                    return True
-            
-            # O - toggle one-way collision for selected polygon
-            elif event.key == pygame.K_o:
+
+            # Ctrl+Shift+S - toggle snap (Ctrl+S reserved for save)
+            elif ctrl and event.key == pygame.K_s and (mods & pygame.KMOD_SHIFT):
+                self.snap_to_grid = not self.snap_to_grid
+                return True
+
+            # Ctrl+O - toggle one-way collision for selected polygon
+            elif ctrl and event.key == pygame.K_o:
                 if self.selected_polygon_idx is not None:
                     idx = self.selected_polygon_idx
                     self.polygon_one_way[idx] = not self.polygon_one_way[idx]
                     if self.on_polygon_modified:
                         self.on_polygon_modified(idx)
                     return True
-            
-            # R - reset view
-            elif event.key == pygame.K_r:
+
+            # Ctrl+R - reset view
+            elif ctrl and event.key == pygame.K_r:
                 self._center_view()
                 self.zoom = 2.0
                 return True
+
+            # Ctrl+A - toggle angle hints
+            elif ctrl and event.key == pygame.K_a:
+                self.show_angle_hints = not self.show_angle_hints
+                return True
         
         if event.type == pygame.KEYUP:
             if event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
@@ -744,20 +808,21 @@ class CollisionPainter:
                 ("Right-click / Enter", "Complete polygon"),
                 ("Escape", "Cancel current polygon"),
                 ("Shift (edge mode)", "Constrain to axis"),
-                ("E", "Toggle edge draw mode"),
+                ("Ctrl+E", "Toggle edge draw mode"),
             ]),
             ("SELECTION", [
                 ("Left-click polygon", "Select polygon"),
                 ("Left-click vertex", "Select & drag vertex"),
                 ("Delete / Backspace", "Remove selected polygon"),
-                ("O", "Toggle one-way collision"),
+                ("Ctrl+O", "Toggle one-way collision"),
             ]),
             ("VIEW", [
                 ("Mouse wheel", "Zoom in/out"),
                 ("Middle mouse / Space+LMB", "Pan view"),
-                ("G", "Toggle grid"),
-                ("S", "Toggle snap to grid"),
-                ("R", "Reset view"),
+                ("Ctrl+G", "Toggle grid"),
+                ("Ctrl+Shift+S", "Toggle snap to grid"),
+                ("Ctrl+R", "Reset view"),
+                ("Ctrl+A", "Toggle angle hints"),
             ]),
             ("MISC", [
                 ("Info button (top-right)", "Toggle this help panel"),
@@ -905,6 +970,24 @@ class CollisionPainter:
             radius = VERTEX_HOVER_RADIUS if is_hovered_vertex else VERTEX_RADIUS
             pygame.draw.circle(screen, color, (px, py), radius)
             pygame.draw.circle(screen, (0, 0, 0), (px, py), radius, 1)
+
+        # One-way badge on selected polygon
+        if selected and one_way and len(polygon) >= 3:
+            cx = int(sum(p[0] for p in screen_points) / len(screen_points))
+            cy = int(sum(p[1] for p in screen_points) / len(screen_points))
+            badge = self._font_sm.render("ONE-WAY", True, (255, 255, 255))
+            bx = cx - badge.get_width() // 2
+            by = cy - badge.get_height() // 2
+            bg = pygame.Surface((badge.get_width() + 8, badge.get_height() + 4), pygame.SRCALPHA)
+            bg.fill((_COLORS["one_way"][0], _COLORS["one_way"][1], _COLORS["one_way"][2], 200))
+            screen.blit(bg, (bx - 4, by - 2))
+            screen.blit(badge, (bx, by))
+
+        # Angle hints
+        if self.show_angle_hints:
+            for i, (px, py) in enumerate(screen_points):
+                angle = self._get_interior_angle(polygon, i)
+                self._draw_angle_hint(screen, (px, py), angle)
     
     def _draw_current_polygon(self, screen: pygame.Surface) -> None:
         """Draw the polygon currently being drawn"""
@@ -934,6 +1017,25 @@ class CollisionPainter:
             radius = VERTEX_HOVER_RADIUS if is_first else VERTEX_RADIUS
             pygame.draw.circle(screen, color, (px, py), radius)
             pygame.draw.circle(screen, (0, 0, 0), (px, py), radius, 1)
+
+        # Angle hints for vertices with both neighbors
+        if self.show_angle_hints and len(self.current_polygon) >= 3:
+            for i, (px, py) in enumerate(screen_points):
+                if i == 0 or i == len(screen_points) - 1:
+                    continue
+                poly = self.current_polygon
+                prev = poly[i - 1]
+                curr = poly[i]
+                nxt = poly[i + 1]
+                v1 = (prev[0] - curr[0], prev[1] - curr[1])
+                v2 = (nxt[0] - curr[0], nxt[1] - curr[1])
+                dot = v1[0] * v2[0] + v1[1] * v2[1]
+                mag1 = math.hypot(v1[0], v1[1])
+                mag2 = math.hypot(v2[0], v2[1])
+                if mag1 > 0.001 and mag2 > 0.001:
+                    cos_a = max(-1.0, min(1.0, dot / (mag1 * mag2)))
+                    angle = math.degrees(math.acos(cos_a))
+                    self._draw_angle_hint(screen, (px, py), angle)
     
     def _draw_status(self, screen: pygame.Surface) -> None:
         """Draw status text"""
@@ -949,12 +1051,13 @@ class CollisionPainter:
             one_way = self.polygon_one_way[self.selected_polygon_idx]
             one_way_str = " (ONE-WAY)" if one_way else ""
             lines.append(f"Selected polygon {self.selected_polygon_idx}{one_way_str}")
-            lines.append("Delete to remove, O to toggle one-way")
+            lines.append("Delete to remove, Ctrl+O to toggle one-way")
         else:
             lines.append("Click to add vertices, right-click to complete")
         
-        lines.append(f"Zoom: {self.zoom:.1f}x | Grid: {'ON' if self.show_grid else 'OFF'} (G) | Snap: {'ON' if self.snap_to_grid else 'OFF'} (S)")
-        lines.append(f"Polygons: {len(self.polygons)} | R: reset view")
+        snap_str = f"Snap: {'ON' if self.snap_to_grid else 'OFF'} (Ctrl+Shift+S)"
+        lines.append(f"Zoom: {self.zoom:.1f}x | Grid: {'ON' if self.show_grid else 'OFF'} (Ctrl+G) | {snap_str}")
+        lines.append(f"Polygons: {len(self.polygons)} | Ctrl+R: reset | Ctrl+A: angle hints {'ON' if self.show_angle_hints else 'OFF'}")
         
         y = self.rect.y + 5
         for line in lines:

{tilemap_editor-3.3.3 → tilemap_editor-3.3.4}/src/plugins/tileset_collision/editor.py

@@ -30,6 +30,17 @@ from utils.icon_manager import icon_manager
 from utils.error_handler import error_handler, error_context
 from widgets.ui.theme import COLORS, FONTS
 from widgets.ui.draw_utils import draw_panel, draw_button
+from widgets.ui.checkbox import Checkbox
+
+# Widget panel layout constants
+WP_PADDING_X = 12
+WP_PADDING_Y = 38
+WP_SECTION_HEIGHT = 28
+WP_CHECKBOX_ROW = 30
+WP_GRID_ROW = 36
+WP_GRID_BTN = 28
+WP_GRID_GAP = 68
+WP_TITLE_Y = 10
 
 
 class TilesetCollisionEditor:
@@ -75,6 +86,9 @@ class TilesetCollisionEditor:
         # Auto-tile propagation: group_id -> [variant_ids]
         self._propagation_groups: Dict[str, List[int]] = {}
 
+        # Tiles the user explicitly cleared — propagation won't re-add to these
+        self._user_cleared_tiles: Set[int] = set()
+
         # Collision library
         self.library = TilesetCollisionLibrary(
             tileset_name=self._tileset_name,
@@ -91,6 +105,7 @@ class TilesetCollisionEditor:
         self.toolbar_height = 40
         self.tileset_selector_height = 250  # Resizable
         self.painted_tiles_width = 200
+        self.widget_panel_width = 200
         self._resizing_selector = False
         self._resize_start_y = 0
         self._resize_start_height = 0
@@ -128,6 +143,9 @@ class TilesetCollisionEditor:
         # Toolbar buttons
         self._setup_toolbar_buttons()
 
+        # Widget panel buttons
+        self._setup_widget_buttons()
+
         # Load collision data for first tile
         self._load_tile_collision_for_selection()
 
@@ -151,6 +169,40 @@ class TilesetCollisionEditor:
                 "hovered": False,
             })
 
+    def _setup_widget_buttons(self) -> None:
+        """Setup widget panel buttons"""
+        self._chk_one_way = Checkbox(
+            Rect(0, 0, 0, 0), "One-Way",
+            disabled=True,
+            on_changed=lambda _: self.painter.toggle_one_way(),
+        )
+        self._chk_angle = Checkbox(
+            Rect(0, 0, 0, 0), "Angle Hints",
+            on_changed=lambda v: setattr(self.painter, "show_angle_hints", v),
+        )
+        self._chk_grid = Checkbox(
+            Rect(0, 0, 0, 0), "Grid",
+            checked=True,
+            on_changed=lambda v: setattr(self.painter, "show_grid", v),
+        )
+        self._chk_snap = Checkbox(
+            Rect(0, 0, 0, 0), "Snap to Grid",
+            on_changed=lambda v: setattr(self.painter, "snap_to_grid", v),
+        )
+
+        self._widget_items: List[tuple] = [
+            ("section", "POLYGON"),
+            ("checkbox", self._chk_one_way),
+            ("checkbox", self._chk_angle),
+            ("section", "DISPLAY"),
+            ("checkbox", self._chk_grid),
+            ("section", "GRID SNAP"),
+            ("grid_dec", None),
+            ("grid_val", None),
+            ("grid_inc", None),
+            ("checkbox", self._chk_snap),
+        ]
+
     def _save_collision(self) -> None:
         """Save collision via toolbar button"""
         collision_dir = self._get_collision_dir()
@@ -200,6 +252,64 @@ class TilesetCollisionEditor:
         shape_count = len(self._clipboard_polygons)
         self._show_toast(f"Pasted {shape_count} shape{'s' if shape_count != 1 else ''} to {tile_count} tile{'s' if tile_count != 1 else ''}")
 
+    def _layout_widget_panel(self) -> None:
+        """Pre-compute clickable widget rects (checkbox + grid buttons)"""
+        panel = self.widget_panel_rect
+        px = panel.x + WP_PADDING_X
+        pw = panel.w - WP_PADDING_X * 2
+        y = panel.y + WP_PADDING_Y
+        for kind, data in self._widget_items:
+            if kind == "section":
+                y += WP_SECTION_HEIGHT
+            elif kind == "checkbox":
+                data.rect = Rect(px, y, pw, WP_CHECKBOX_ROW)
+                y += WP_CHECKBOX_ROW
+            elif kind == "grid_dec":
+                self._grid_dec_rect = Rect(px, y, WP_GRID_BTN, WP_GRID_BTN)
+            elif kind == "grid_val":
+                self._grid_val_rect = Rect(px, y, 0, WP_GRID_BTN)
+            elif kind == "grid_inc":
+                self._grid_inc_rect = Rect(px + WP_GRID_GAP, y, WP_GRID_BTN, WP_GRID_BTN)
+                y += WP_GRID_ROW
+
+    def _sync_widget_state(self) -> None:
+        """Sync checkbox states from painter attributes before draw"""
+        p = self.painter
+        self._chk_grid.checked = p.show_grid
+        self._chk_snap.checked = p.snap_to_grid
+        self._chk_angle.checked = p.show_angle_hints
+        sel = p.selected_polygon_idx
+        if sel is not None and 0 <= sel < len(p.polygon_one_way):
+            self._chk_one_way.checked = p.polygon_one_way[sel]
+            self._chk_one_way.disabled = False
+        else:
+            self._chk_one_way.checked = False
+            self._chk_one_way.disabled = True
+
+    def _handle_widget_button_clicks(self, events: List[pygame.event.Event]) -> None:
+        """Handle widget panel button clicks"""
+        self._sync_widget_state()
+        self._layout_widget_panel()
+        painter = self.painter
+        mouse = pygame.mouse.get_pos()
+
+        # Pass click events to checkboxes
+        for event in events:
+            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+                pos = event.pos
+                if self._chk_one_way.handle_event(event):
+                    continue
+                if self._chk_angle.handle_event(event):
+                    continue
+                if self._chk_grid.handle_event(event):
+                    continue
+                if self._chk_snap.handle_event(event):
+                    continue
+                if self._grid_dec_rect.collidepoint(pos):
+                    painter.grid_size = max(1, painter.grid_size - 1)
+                elif self._grid_inc_rect.collidepoint(pos):
+                    painter.grid_size = min(64, painter.grid_size + 1)
+
     def _position_toolbar_buttons(self) -> None:
         """Position toolbar buttons in the toolbar area"""
         if not hasattr(self, '_toolbar_buttons'):
@@ -226,6 +336,68 @@ class TilesetCollisionEditor:
                     if button["rect"].collidepoint(mouse_pos):
                         button["action"]()
 
+    def _draw_widget_panel(self, surface: Surface) -> None:
+        """Draw the widget panel on the right side"""
+        self._sync_widget_state()
+        panel = self.widget_panel_rect
+        pygame.draw.rect(surface, COLORS.panel_alt, panel)
+        pygame.draw.rect(surface, COLORS.border_soft, panel, 1)
+
+        px = panel.x + WP_PADDING_X
+        pw = panel.w - WP_PADDING_X * 2
+        y = panel.y + WP_PADDING_Y
+
+        title = self._font.render("Tools", True, COLORS.text)
+        surface.blit(title, (px, panel.y + WP_TITLE_Y))
+
+        painter = self.painter
+        mouse = pygame.mouse.get_pos()
+
+        for kind, data in self._widget_items:
+            if kind == "section":
+                lbl = self._font_sm.render(data, True, (140, 140, 160))
+                surface.blit(lbl, (px, y + 4))
+                sep_y = y + lbl.get_height() + 8
+                pygame.draw.line(surface, (50, 50, 55), (px, sep_y), (px + pw, sep_y))
+                y += WP_SECTION_HEIGHT
+
+            elif kind == "checkbox":
+                data.rect = Rect(px, y, pw, WP_CHECKBOX_ROW)
+                data.draw(surface)
+                y += WP_CHECKBOX_ROW
+
+            elif kind == "grid_dec":
+                r = Rect(px, y, WP_GRID_BTN, WP_GRID_BTN)
+                self._grid_dec_rect = r
+                hovered = r.collidepoint(mouse)
+                bg = (55, 55, 62) if hovered else (45, 45, 50)
+                pygame.draw.rect(surface, bg, r, border_radius=4)
+                pygame.draw.rect(surface, (65, 65, 72), r, 1, border_radius=4)
+                lbl = self._font_sm.render("-", True, COLORS.text)
+                tx = r.centerx - lbl.get_width() // 2
+                ty = r.centery - lbl.get_height() // 2
+                surface.blit(lbl, (tx, ty))
+
+            elif kind == "grid_val":
+                self._grid_val_rect = Rect(px, y, 0, WP_GRID_BTN)
+                val_surf = self._font_sm.render(str(painter.grid_size), True, COLORS.text)
+                vx = px + WP_GRID_BTN + 8
+                vy = y + (WP_GRID_BTN - val_surf.get_height()) // 2
+                surface.blit(val_surf, (vx, vy))
+
+            elif kind == "grid_inc":
+                r = Rect(px + WP_GRID_GAP, y, WP_GRID_BTN, WP_GRID_BTN)
+                self._grid_inc_rect = r
+                hovered = r.collidepoint(mouse)
+                bg = (55, 55, 62) if hovered else (45, 45, 50)
+                pygame.draw.rect(surface, bg, r, border_radius=4)
+                pygame.draw.rect(surface, (65, 65, 72), r, 1, border_radius=4)
+                lbl = self._font_sm.render("+", True, COLORS.text)
+                tx = r.centerx - lbl.get_width() // 2
+                ty = r.centery - lbl.get_height() // 2
+                surface.blit(lbl, (tx, ty))
+                y += WP_GRID_ROW
+
     def _draw_toolbar_buttons(self, surface: Surface) -> None:
         """Draw toolbar buttons"""
         for button in self._toolbar_buttons:
@@ -272,7 +444,14 @@ class TilesetCollisionEditor:
         self.painter_rect = Rect(
             self.rect.x + self.painted_tiles_width,
             middle_y,
-            self.rect.w - self.painted_tiles_width,
+            self.rect.w - self.painted_tiles_width - self.widget_panel_width,
+            middle_h
+        )
+
+        self.widget_panel_rect = Rect(
+            self.rect.right - self.widget_panel_width,
+            middle_y,
+            self.widget_panel_width,
             middle_h
         )
 
@@ -342,7 +521,11 @@ class TilesetCollisionEditor:
                     del self.library.tiles[tile_id]
                     if self.consumer:
                         self.consumer.on_collision_deleted(tile_id)
+                # Mark as user-cleared so propagation doesn't re-add it
+                self._user_cleared_tiles.add(tile_id)
             else:
+                # User painted collision — remove from cleared set
+                self._user_cleared_tiles.discard(tile_id)
                 # Create collision shapes
                 shapes = [
                     CollisionPolygon(vertices=poly, one_way=one_way)
@@ -471,7 +654,10 @@ class TilesetCollisionEditor:
                 continue
 
             # Propagate to all variants in the group that lack collision
+            # Skip tiles the user explicitly cleared
             for vid in variant_ids:
+                if vid in self._user_cleared_tiles:
+                    continue
                 existing = self.library.tiles.get(vid)
                 if existing is None:
                     self.library.tiles[vid] = TileCollisionData(
@@ -696,6 +882,9 @@ class TilesetCollisionEditor:
         # Draw tileset selector
         self._draw_tileset_selector(screen)
 
+        # Draw widget panel
+        self._draw_widget_panel(screen)
+
         # Draw toast overlay
         self._draw_toast(screen)
 
@@ -924,8 +1113,9 @@ class TilesetCollisionEditor:
 
                 self.handle_event(event)
 
-            # Handle toolbar button clicks
+            # Handle toolbar and widget button clicks
             self._handle_toolbar_button_clicks(events)
+            self._handle_widget_button_clicks(events)
 
             screen.fill((20, 20, 20))
             self.draw(screen)

{tilemap_editor-3.3.3 → tilemap_editor-3.3.4/src/tilemap_editor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 3.3.3
+Version: 3.3.4
 Summary: Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-3.3.3 → tilemap_editor-3.3.4}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -166,6 +166,7 @@ src/widgets/regex_automap_designer.py
 src/widgets/spritesheet_grid.py
 src/widgets/tile_grid.py
 src/widgets/tile_selector.py
+src/widgets/ui/checkbox.py
 src/widgets/ui/collision_layer_mask.py
 src/widgets/ui/collision_layer_sidebar.py
 src/widgets/ui/confirm_dialog.py

{tilemap_editor-3.3.3 → tilemap_editor-3.3.4}/src/widgets/filemanager.py

@@ -333,12 +333,10 @@ class ImagePreview:
             new_height = target_height
             new_width = int(target_height * aspect_ratio)
 
-        source_surface = self.current_image.convert_alpha()
-
         scaled_surface = pygame.transform.smoothscale(
-            source_surface, (new_width, new_height)
+            self.current_image, (new_width, new_height)
         )
-        
+
         self.scaled_cache = scaled_surface
         self.cached_target_size = (target_width, target_height)