tilemap-editor 3.1.6__tar.gz → 3.1.7__tar.gz

{tilemap_editor-3.1.6/src/tilemap_editor.egg-info → tilemap_editor-3.1.7}/PKG-INFO

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

{tilemap_editor-3.1.6 → tilemap_editor-3.1.7}/pyproject.toml

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

{tilemap_editor-3.1.6 → tilemap_editor-3.1.7}/src/plugins/sprite_animation/editor.py

@@ -24,6 +24,7 @@ from utils.font_manager import font_manager, FontWeight, FontStyle
 from utils.icon_manager import icon_manager
 from utils.project_paths import resolve_project_path
 from utils import error_handler
+from widgets.input import InlineTextInput
 from .clipboard_util import copy_plain_text
 from .frame_picker import FramePicker
 from .models import Animation, AnimationLibrary, AnimationMarker
@@ -178,7 +179,7 @@ class SpriteAnimationEditor:
 
         # Rename state
         self._renaming = False
-        self._rename_text = ""
+        self._rename_input = InlineTextInput("anim_rename", "")
 
         # Toolbar button rects (calculated in draw)
         self._btn_new = Rect(0, 0, 0, 0)
@@ -439,16 +440,13 @@ class SpriteAnimationEditor:
                     return True
                 elif event.key == pygame.K_ESCAPE:
                     self._renaming = False
+                    self._rename_input.is_focused = False
                     return True
-                elif event.key == pygame.K_BACKSPACE:
-                    self._rename_text = self._rename_text[:-1]
-                    return True
-                elif event.unicode and len(self._rename_text) < 30:
-                    self._rename_text += event.unicode
+                elif self._rename_input.handle_event(event, self._font):
                     return True
 
         # Frame width input
-        if self._editing_frame_width:
+        elif self._editing_frame_width:
             if event.type == pygame.KEYDOWN:
                 mods = pygame.key.get_mods()
                 ctrl_held = mods & (pygame.KMOD_LCTRL | pygame.KMOD_RCTRL)
@@ -486,7 +484,7 @@ class SpriteAnimationEditor:
                     return True
 
         # Frame height input
-        if self._editing_frame_height:
+        elif self._editing_frame_height:
             if event.type == pygame.KEYDOWN:
                 mods = pygame.key.get_mods()
                 ctrl_held = mods & (pygame.KMOD_LCTRL | pygame.KMOD_RCTRL)
@@ -523,7 +521,7 @@ class SpriteAnimationEditor:
                     return True
 
         # Offset X input
-        if self._editing_offset_x:
+        elif self._editing_offset_x:
             if event.type == pygame.KEYDOWN:
                 mods = pygame.key.get_mods()
                 ctrl_held = mods & (pygame.KMOD_LCTRL | pygame.KMOD_RCTRL)
@@ -567,7 +565,7 @@ class SpriteAnimationEditor:
                     return True
 
         # Offset Y input
-        if self._editing_offset_y:
+        elif self._editing_offset_y:
             if event.type == pygame.KEYDOWN:
                 mods = pygame.key.get_mods()
                 ctrl_held = mods & (pygame.KMOD_LCTRL | pygame.KMOD_RCTRL)
@@ -693,6 +691,8 @@ class SpriteAnimationEditor:
             if self._btn_frame_width.collidepoint(mouse):
                 self._editing_frame_width = True
                 self._editing_frame_height = False
+                self._editing_offset_x = False
+                self._editing_offset_y = False
                 self._renaming = False
                 return True
 
@@ -832,10 +832,32 @@ class SpriteAnimationEditor:
         )
 
         if self._renaming:
-            display_text = self._rename_text + (
-                "|" if (pygame.time.get_ticks() // 400) % 2 else ""
-            )
-            lbl = self._font.render(display_text, True, (255, 220, 100))
+            if self._renaming:
+                display_name = self._rename_input.text
+                cursor_offset = self._rename_input.cursor_pos
+
+                # Draw selection highlight
+                if self._rename_input.selection_start is not None:
+                    start = min(self._rename_input.selection_start, cursor_offset)
+                    end = max(self._rename_input.selection_start, cursor_offset)
+                    if start != end:
+                        prefix = display_name[:start]
+                        selected = display_name[start:end]
+                        prefix_w = self._font.size(prefix)[0]
+                        select_w = self._font.size(selected)[0]
+                        sel_rect = Rect(
+                            self._btn_anim_selector.x + 4 + prefix_w,
+                            self._btn_anim_selector.y + 5,
+                            select_w,
+                            self._btn_anim_selector.height - 10,
+                        )
+                        pygame.draw.rect(screen, (60, 100, 160), sel_rect)
+
+                # Blinking cursor
+                if (pygame.time.get_ticks() // 400) % 2:
+                    display_name = display_name[:cursor_offset] + "|" + display_name[cursor_offset:]
+
+                lbl = self._font.render(display_name, True, (255, 220, 100))
         else:
             display_name = self._active_anim_name or "(none)"
             if len(display_name) > 16:
@@ -1297,15 +1319,23 @@ class SpriteAnimationEditor:
     def _start_rename(self) -> None:
         if self._active_anim_name:
             self._renaming = True
-            self._rename_text = self._active_anim_name
+            self._rename_input.text = self._active_anim_name
+            self._rename_input.cursor_pos = len(self._active_anim_name)
+            self._rename_input.selection_start = None
+            self._rename_input.is_focused = True
+            self._editing_frame_width = False
+            self._editing_frame_height = False
+            self._editing_offset_x = False
+            self._editing_offset_y = False
             self._dropdown_open = False
 
     def _commit_rename(self) -> None:
-        new_name = self._rename_text.strip()
+        new_name = self._rename_input.text.strip()
         if new_name and self._active_anim_name and new_name != self._active_anim_name:
             if self.library.rename_animation(self._active_anim_name, new_name):
                 self._active_anim_name = new_name
         self._renaming = False
+        self._rename_input.is_focused = False
 
     def _apply_frame_size(self) -> None:
         """Apply the frame size from input fields and update the frame picker."""
@@ -1558,10 +1588,12 @@ class SpriteAnimationEditor:
         if self._btn_meta_key.collidepoint(mouse):
             self._clear_text_editing_focus()
             self._editing_meta_key = True
+            self._editing_meta_value = False
             return True
         if self._btn_meta_value.collidepoint(mouse):
             self._clear_text_editing_focus()
             self._editing_meta_value = True
+            self._editing_meta_key = False
             return True
 
         return True
@@ -1572,6 +1604,8 @@ class SpriteAnimationEditor:
         self._editing_frame_height = False
         self._editing_offset_x = False
         self._editing_offset_y = False
+        self._editing_meta_key = False
+        self._editing_meta_value = False
 
     def _handle_meta_key_keydown(self, event: pygame.event.Event) -> bool:
         if event.key in (pygame.K_RETURN, pygame.K_KP_ENTER, pygame.K_TAB):
@@ -1809,7 +1843,7 @@ class SpriteAnimationEditor:
             print(f"Warning: Could not import FileManager: {e}")
             path = self._default_save_path()
             try:
-                self.library.save(path, base_path=self._project_base_path())
+                self.library.save(path, base_path=path.parent)
                 self._last_saved_path = path
                 print(f"Animations saved to {path}")
             except Exception as e:
@@ -1856,7 +1890,7 @@ class SpriteAnimationEditor:
             try:
                 self.library.save(
                     self._last_saved_path,
-                    base_path=self._project_base_path(),
+                    base_path=self._last_saved_path.parent,
                 )
                 print(f"Animations saved to {self._last_saved_path}")
             except Exception as e:
@@ -1914,7 +1948,7 @@ class SpriteAnimationEditor:
     def _on_save_file_selected(self, path: Path) -> None:
         """Callback when user selects a file to save to."""
         try:
-            self.library.save(path, base_path=self._project_base_path())
+            self.library.save(path, base_path=path.parent)
             self._last_saved_path = path  # Track for quick save
             print(f"Animations saved to {path}")
         except Exception as e:
@@ -2032,14 +2066,12 @@ class SpriteAnimationEditor:
     def _resolve_library_paths(self, json_path: Path) -> None:
         if not self.library.spritesheet_path:
             return
-        base_path = self._project_base_path()
-        if base_path is None:
-            return
+        project_root = self._project_base_path()
         self.library.spritesheet_path = str(
             resolve_project_path(
                 self.library.spritesheet_path,
-                base_path,
-                fallback_roots=[json_path.parent],
+                json_path.parent,
+                fallback_roots=[project_root] if project_root else None,
                 must_exist=True,
             )
         )

{tilemap_editor-3.1.6 → tilemap_editor-3.1.7}/src/plugins/tileset_collision/editor.py

@@ -65,6 +65,13 @@ class TilesetCollisionEditor:
             self._tile_size = tile_size
             self._tileset_name = "No Tileset"
 
+        # Clipboard for copy/paste
+        self._clipboard_polygons: List[List[Tuple[float, float]]] = []
+        self._clipboard_one_way_flags: List[bool] = []
+        self._toast_message: Optional[str] = None
+        self._toast_timer: float = 0.0
+        self._toast_start: int = 0
+
         # Collision library
         self.library = TilesetCollisionLibrary(
             tileset_name=self._tileset_name,
@@ -99,6 +106,7 @@ class TilesetCollisionEditor:
         # Painted tiles list state
         self.painted_tiles_scroll = 0
         self.painted_tiles_hover = -1
+        self._painted_tiles_focused = False
 
         # Collision painter
         self.painter = CollisionPainter(
@@ -127,6 +135,8 @@ class TilesetCollisionEditor:
         buttons_config = [
             {"label": "Save", "action": self._save_collision},
             {"label": "Load", "action": self._load_collision},
+            {"label": "Copy", "action": self._copy_collision},
+            {"label": "Paste", "action": self._paste_collision},
             {"label": "Clear", "action": self._clear_current},
         ]
 
@@ -164,6 +174,29 @@ class TilesetCollisionEditor:
         """Clear collision for selected tiles via toolbar button"""
         self.clear_current_selection()
 
+    def _copy_collision(self) -> None:
+        """Copy collision shapes from current tile to clipboard"""
+        polygons = self.painter.get_polygons()
+        one_way_flags = self.painter.get_one_way_flags()
+        self._clipboard_polygons = [list(p) for p in polygons]
+        self._clipboard_one_way_flags = list(one_way_flags)
+        count = len(self._clipboard_polygons)
+        self._show_toast(f"Copied {count} shape{'s' if count != 1 else ''}")
+
+    def _paste_collision(self) -> None:
+        """Paste collision shapes from clipboard to selected tiles"""
+        if not self._clipboard_polygons:
+            self._show_toast("Clipboard is empty")
+            return
+        self.painter.set_polygons(
+            [list(p) for p in self._clipboard_polygons],
+            list(self._clipboard_one_way_flags),
+        )
+        self._save_tile_collision_for_selection()
+        tile_count = len(self._selected_tiles)
+        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 _position_toolbar_buttons(self) -> None:
         """Position toolbar buttons in the toolbar area"""
         if not hasattr(self, '_toolbar_buttons'):
@@ -332,6 +365,38 @@ class TilesetCollisionEditor:
         """Callback when polygon is modified"""
         self._save_tile_collision_for_selection()
 
+    def _show_toast(self, message: str, duration: float = 2.5) -> None:
+        """Show a temporary status toast on screen"""
+        self._toast_message = message
+        self._toast_timer = duration * 1000.0
+        self._toast_start = pygame.time.get_ticks()
+
+    def _draw_toast(self, screen: Surface) -> None:
+        """Draw the toast message with fade-out"""
+        if self._toast_message is None:
+            return
+
+        elapsed = pygame.time.get_ticks() - self._toast_start
+        remaining = self._toast_timer - elapsed
+        fade_ms = 500.0
+        alpha = 255 if remaining >= fade_ms else max(0, min(255, int((remaining / fade_ms) * 255)))
+        label = self._font.render(self._toast_message, True, (255, 255, 255))
+        padding = 12
+        bg_rect = Rect(
+            self.rect.centerx - label.get_width() // 2 - padding,
+            self.rect.centery - 60,
+            label.get_width() + padding * 2,
+            label.get_height() + padding,
+        )
+
+        bg = pygame.Surface((bg_rect.w, bg_rect.h), pygame.SRCALPHA)
+        bg.fill((0, 0, 0, min(200, alpha)))
+        pygame.draw.rect(bg, (80, 180, 255, alpha), bg.get_rect(), 1)
+        screen.blit(bg, bg_rect)
+
+        label.set_alpha(alpha)
+        screen.blit(label, label.get_rect(center=bg_rect.center))
+
     def clear_current_selection(self) -> None:
         """Clear collision for currently selected tiles"""
         self.painter.set_polygons([], [])
@@ -446,6 +511,7 @@ class TilesetCollisionEditor:
             if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1 and not self._space_held:
                 tile_id = self._get_tile_at_mouse(mouse)
                 if tile_id is not None:
+                    self._painted_tiles_focused = False
                     # Ctrl/Cmd for multi-select
                     mods = pygame.key.get_mods()
                     if mods & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA):
@@ -484,6 +550,7 @@ class TilesetCollisionEditor:
         # Painted tiles list interaction
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
             if self.painted_tiles_rect.collidepoint(mouse):
+                self._painted_tiles_focused = True
                 painted_tiles = sorted(self.library.tiles.keys())
                 rel_y = mouse[1] - self.painted_tiles_rect.y + self.painted_tiles_scroll
                 tile_height = 64
@@ -503,13 +570,22 @@ class TilesetCollisionEditor:
 
         # Keyboard shortcuts
         if event.type == pygame.KEYDOWN:
+            mods = pygame.key.get_mods()
+            ctrl = mods & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA)
+
+            if ctrl:
+                if event.key == pygame.K_c:
+                    self._copy_collision()
+                    return True
+                elif event.key == pygame.K_v:
+                    self._paste_collision()
+                    return True
+
             if event.key == pygame.K_DELETE or event.key == pygame.K_BACKSPACE:
-                if pygame.key.get_mods() & (pygame.KMOD_LSHIFT):
-                    # Shift+Delete: clear current selection
+                if mods & (pygame.KMOD_LSHIFT) or self._painted_tiles_focused:
                     self.clear_current_selection()
                     return True
             elif event.key == pygame.K_h:
-                # H: Recenter tileset view
                 self._recenter_tileset_view()
                 return True
 
@@ -577,6 +653,15 @@ class TilesetCollisionEditor:
         # Draw tileset selector
         self._draw_tileset_selector(screen)
 
+        # Draw toast overlay
+        self._draw_toast(screen)
+
+        # Update toast timer
+        if self._toast_message is not None:
+            elapsed = pygame.time.get_ticks() - self._toast_start
+            if elapsed >= self._toast_timer:
+                self._toast_message = None
+
     def _draw_toolbar(self, screen: Surface) -> None:
         """Draw the toolbar"""
         draw_panel(screen, self.toolbar_rect, COLORS.header, COLORS.border)
@@ -590,18 +675,19 @@ class TilesetCollisionEditor:
         )
         screen.blit(title, (self.toolbar_rect.x + 10, self.toolbar_rect.y + 10))
 
-        # Collision count
+        # Draw toolbar buttons
+        if hasattr(self, '_toolbar_buttons'):
+            self._draw_toolbar_buttons(screen)
+
+        # Collision count (after buttons to avoid overlap)
         collision_count = len(self.library.tiles)
         count_text = self._font_sm.render(
             f"{collision_count} painted",
             True,
             COLORS.text_dim
         )
-        screen.blit(count_text, (self.toolbar_rect.right - count_text.get_width() - 10, self.toolbar_rect.y + 12))
-
-        # Draw toolbar buttons
-        if hasattr(self, '_toolbar_buttons'):
-            self._draw_toolbar_buttons(screen)
+        start_x = self.toolbar_rect.right - (len(self._toolbar_buttons) * 90) - 10
+        screen.blit(count_text, (start_x - count_text.get_width() - 15, self.toolbar_rect.y + 12))
 
     def _draw_painted_tiles_list(self, screen: Surface) -> None:
         """Draw the list of tiles with collision"""
@@ -610,6 +696,9 @@ class TilesetCollisionEditor:
         # Header
         header_text = self._font_sm.render("Painted Tiles", True, COLORS.text)
         screen.blit(header_text, (self.painted_tiles_rect.x + 8, self.painted_tiles_rect.y + 8))
+        if self._painted_tiles_focused:
+            hint = self._font_sm.render("Backspace to clear", True, COLORS.accent)
+            screen.blit(hint, (self.painted_tiles_rect.right - hint.get_width() - 8, self.painted_tiles_rect.y + 8))
 
         clip = screen.get_clip()
         screen.set_clip(self.painted_tiles_rect)

{tilemap_editor-3.1.6 → tilemap_editor-3.1.7/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.1.6 → tilemap_editor-3.1.7}/src/widgets/filemanager.py

@@ -1381,6 +1381,7 @@ class FileManager:
         if not search_text and not self.is_search_focused:
             search_text = "Search files..."
             search_col = COLORS["text_dim"]
+            txt = self.font_main.render(search_text, True, search_col)
         else:
             search_col = COLORS["text_main"]
             if self.is_search_focused:
@@ -1391,12 +1392,14 @@ class FileManager:
                     display_text = prefix + "|" + display_text[cursor_offset:]
                 else:
                     display_text = prefix + " " + display_text[cursor_offset:]
-                txt = self.font_main.render(display_text, True, search_col)
+                txt = self.font_main.render(display_text or " ", True, search_col)
             else:
                 txt = self.font_main.render(search_text, True, search_col)
 
-        txt = self.font_main.render(search_text, True, search_col)
+        clip = screen.get_clip()
+        screen.set_clip(self.search_rect)
         screen.blit(txt, (self.search_rect.x + 8, self.search_rect.y + 4))
+        screen.set_clip(clip)
 
         file_list_rect = self._get_file_list_rect()
         self._draw_file_list(screen, file_list_rect)
@@ -1657,7 +1660,10 @@ class FileManager:
                 else:
                     display_name = prefix + " " + display_name[cursor_offset:]
             txt = self.font_main.render(display_name, True, COLORS["text_main"])
+            clip = screen.get_clip()
+            screen.set_clip(self.save_name_rect)
             screen.blit(txt, (self.save_name_rect.x + 6, self.save_name_rect.y + 6))
+            screen.set_clip(clip)
 
     def _draw_icon_arrow_up(self, surface, cx, cy, color):
         points = [(cx, cy - 5), (cx - 5, cy + 2), (cx + 5, cy + 2)]

{tilemap_editor-3.1.6 → tilemap_editor-3.1.7}/src/widgets/input.py

@@ -269,6 +269,25 @@ class InlineTextInput:
         self.cursor_pos = 0
         self.selection_start = None
 
+    def delete_word_left(self) -> None:
+        """Delete from cursor to the start of the current or previous word."""
+        if self.selection_start is not None:
+            start = min(self.selection_start, self.cursor_pos)
+            end = max(self.selection_start, self.cursor_pos)
+            self.text = self.text[:start] + self.text[end:]
+            self.cursor_pos = start
+            self.selection_start = None
+            return
+        if self.cursor_pos == 0:
+            return
+        idx = self.cursor_pos - 1
+        while idx >= 0 and self.text[idx] == ' ':
+            idx -= 1
+        while idx >= 0 and self.text[idx] != ' ':
+            idx -= 1
+        self.text = self.text[:idx + 1] + self.text[self.cursor_pos:]
+        self.cursor_pos = idx + 1
+
     def handle_event(self, event: pygame.event.Event, font: pygame.font.Font) -> bool:
         if not self.is_focused:
             return False
@@ -281,6 +300,9 @@ class InlineTextInput:
             if ctrl_held and event.key == pygame.K_a:
                 self.select_all()
                 return True
+            if ctrl_held and event.key == pygame.K_BACKSPACE:
+                self.delete_word_left()
+                return True
 
             if event.key == pygame.K_LEFT:
                 self.move_cursor(-1)