tilemap-editor 3.2.9__tar.gz → 3.3.0__tar.gz

{tilemap_editor-3.2.9/src/tilemap_editor.egg-info → tilemap_editor-3.3.0}/PKG-INFO

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

{tilemap_editor-3.2.9 → tilemap_editor-3.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "3.2.9"
+version = "3.3.0"
 description = "Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,6 +32,8 @@ py-modules = [
   "editor",
   "event_map",
   "layers",
+  "node_manager",
+  "nodes",
   "tilemap",
   "standalone_filemanager",
   "standalone_image_viewer",

{tilemap_editor-3.2.9 → tilemap_editor-3.3.0}/src/editor.py

@@ -771,23 +771,14 @@ class Editor:
             error_handler.capture(e, context="launch_animation_editor")
 
     def launch_sprite_editor(self):
-        """Launch the sprite editor in a new window."""
-        self.open_file_manager(
-            on_select=self._launch_sprite_editor_with_image,
-            initial_dir=self.data_root,
-            allowed_exts=[".png", ".jpg", ".jpeg"],
-            mode="open",
-        )
-
-    def _launch_sprite_editor_with_image(self, path: Path):
-        """Launch sprite editor subprocess with selected image."""
+        """Launch the sprite editor (blank) in a new window. Use [Open] inside to load sheets."""
         try:
             tile_size = "32x32"
             if hasattr(self.tilemap, "tile_size") and self.tilemap.tile_size:
                 tw, th = self.tilemap.tile_size
                 tile_size = f"{tw}x{th}"
 
-            args = [str(path), "--tile-size", tile_size, "--data-root", str(self.data_root)]
+            args = ["--tile-size", tile_size, "--data-root", str(self.data_root)]
             process = launch_standalone(
                 "plugins.sprite_editor.standalone",
                 args,

{tilemap_editor-3.2.9 → tilemap_editor-3.3.0}/src/plugins/sprite_editor/editor.py

@@ -2,16 +2,16 @@
 SpriteEditor — standalone widget wrapping SpritesheetGrid with editing toolbar.
 
 Toolbar:
-  [Flip X] [Flip Y] [Copy] [Paste] [Undo] [Redo] [Scale...] [Save PNG]
+  [Flip X] [Flip Y] [Copy] [Paste] [Undo] [Redo] [Scale...] [Grid WxH] [Open] [Save PNG]
 """
 
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, List, Optional, Union
 
 import pygame
-from pygame import Rect, Surface
+from pygame import Rect, Surface, SRCALPHA
 
 from widgets.spritesheet_grid import SpritesheetGrid
 from widgets.ui.theme import COLORS
@@ -34,6 +34,8 @@ _BUTTON_ICONS: dict[str, str | None] = {
     "Undo": None,
     "Redo": None,
     "Scale": None,
+    "Grid": None,
+    "Open": None,
     "Save": "save",
 }
 
@@ -42,8 +44,8 @@ class SpriteEditor:
     def __init__(
         self,
         rect: Rect,
-        surface: Surface,
-        tile_size: tuple[int, int],
+        surface: Optional[Surface] = None,
+        tile_size: tuple[int, int] = (32, 32),
         image_path: Optional[Path] = None,
         data_root: Optional[Path] = None,
     ):
@@ -51,9 +53,17 @@ class SpriteEditor:
         self.image_path = image_path
         self._data_root = data_root or (image_path.parent if image_path else Path.cwd())
 
+        # Start blank if no surface provided; track real sheets separately
+        if surface is None:
+            placeholder = Surface((1, 1), SRCALPHA)
+            self._sheet_surfaces: List[Surface] = []
+        else:
+            placeholder = surface
+            self._sheet_surfaces = [surface]
+
         # Grid
         grid_rect = Rect(rect.x, rect.y + TOOLBAR_H, rect.w, rect.h - TOOLBAR_H - STATUS_H)
-        self.grid = SpritesheetGrid(grid_rect, surface, tile_size)
+        self.grid = SpritesheetGrid(grid_rect, placeholder, tile_size)
 
         # Clipboard for copy/paste
         self._clipboard: Dict[int, Surface] = {}
@@ -64,6 +74,11 @@ class SpriteEditor:
         self._scale_text: str = "2.0"
         self._scale_error: Optional[str] = None
 
+        # Grid dialog state
+        self._grid_active: bool = False
+        self._grid_text: str = f"{tile_size[0]}x{tile_size[1]}"
+        self._grid_error: Optional[str] = None
+
         # Save path — never auto-overwrite original
         self._save_path: Optional[Path] = None
 
@@ -81,13 +96,19 @@ class SpriteEditor:
         ty = self.rect.y + (TOOLBAR_H - BTN_H) // 2
         gap = 6
         x = self.rect.x + gap
-        labels = ["Flip X", "Flip Y", "Copy", "Paste", "Undo", "Redo", "Scale", "Save"]
+        labels = ["Flip X", "Flip Y", "Copy", "Paste", "Undo", "Redo", "Scale", "Grid", "Open", "Save"]
         for lbl in labels:
             self._btn_rects[lbl] = Rect(x, ty, BTN_W, BTN_H)
             x += BTN_W + gap
 
     def _get_status_text(self) -> str:
-        parts = [f"Zoom: {self.grid.zoom:.1f}x"]
+        n = len(self._sheet_surfaces)
+        if n == 0:
+            return "  No spritesheets loaded  —  Click [Open] to load one or more sheets"
+        tw, th = self.grid.tile_size
+        parts = [f"Tile: {tw}×{th}  Zoom: {self.grid.zoom:.1f}x"]
+        if n > 1:
+            parts.append(f"Sheets: {n}")
         sel = len(self.grid.selected_indices)
         if sel:
             parts.append(f"Selected: {sel}")
@@ -109,6 +130,9 @@ class SpriteEditor:
         if self._scale_active:
             return self._handle_scale_dialog(event)
 
+        if self._grid_active:
+            return self._handle_grid_dialog(event)
+
         mouse = pygame.mouse.get_pos()
 
         # Keyboard shortcuts
@@ -182,6 +206,15 @@ class SpriteEditor:
             self._scale_text = "2.0"
             self._scale_error = None
             return True
+        elif lbl == "Grid":
+            self._grid_active = True
+            tw, th = self.grid.tile_size
+            self._grid_text = f"{tw}x{th}"
+            self._grid_error = None
+            return True
+        elif lbl == "Open":
+            self._open_add_sheets_dialog()
+            return True
         elif lbl == "Save":
             self._open_save_dialog()
             return True
@@ -213,6 +246,44 @@ class SpriteEditor:
                 return True
         return False
 
+    def _handle_grid_dialog(self, event: pygame.event.Event) -> bool:
+        if event.type == pygame.KEYDOWN:
+            if event.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
+                parts = self._grid_text.lower().split("x")
+                try:
+                    tw = int(parts[0])
+                    th = int(parts[1]) if len(parts) > 1 else tw
+                    if tw < 1 or th < 1:
+                        self._grid_error = "Must be >= 1"
+                    else:
+                        self.grid.set_tile_size(tw, th)
+                        self._grid_active = False
+                        self._grid_error = None
+                except ValueError:
+                    self._grid_error = "Use format: WxH or N"
+                return True
+            elif event.key == pygame.K_ESCAPE:
+                self._grid_active = False
+                self._grid_error = None
+                return True
+            elif event.key == pygame.K_BACKSPACE:
+                self._grid_text = self._grid_text[:-1]
+                return True
+            elif event.unicode and event.unicode in "0123456789xX" and len(self._grid_text) < 10:
+                self._grid_text += event.unicode
+                return True
+        return False
+
+    @staticmethod
+    def _detect_tile_size(surface: Surface) -> tuple[int, int]:
+        w, h = surface.get_size()
+        candidates = [8, 12, 16, 24, 32, 48, 64, 128]
+        best = 8
+        for s in candidates:
+            if w % s == 0 and h % s == 0:
+                best = s
+        return (best, best)
+
     def _open_save_dialog(self) -> None:
         """Open FileManager in save mode to pick a PNG path."""
         from widgets.filemanager import FileManager
@@ -253,6 +324,64 @@ class SpriteEditor:
     def set_save_path(self, path: Path) -> None:
         self._save_path = path
 
+    # ------------------------------------------------------------------
+    # Multi-sheet: stack sheets vertically into one combined surface
+    # ------------------------------------------------------------------
+
+    def _build_combined_surface(self) -> None:
+        """Rebuild the combined surface from all loaded sheets (stacked vertically)."""
+        n = len(self._sheet_surfaces)
+        if n == 0:
+            return
+        if n == 1:
+            self.grid.set_surface(self._sheet_surfaces[0])
+            return
+
+        max_w = max(s.get_width() for s in self._sheet_surfaces)
+        total_h = sum(s.get_height() for s in self._sheet_surfaces)
+        combined = Surface((max_w, total_h), SRCALPHA)
+        combined.fill((0, 0, 0, 0))
+        y = 0
+        for surf in self._sheet_surfaces:
+            combined.blit(surf, (0, y))
+            y += surf.get_height()
+        self.grid.set_surface(combined)
+
+    def _open_add_sheets_dialog(self) -> None:
+        """Open FileManager in multi-select mode to pick one or more sheets."""
+        from widgets.filemanager import FileManager
+
+        fm_rect = self._file_manager_rect()
+        self._file_manager = FileManager(
+            rect=fm_rect,
+            initial_dir=self._data_root,
+            allowed_exts=[".png", ".jpg", ".jpeg", ".bmp", ".gif"],
+            on_select=self._on_add_sheets,
+            mode="open",
+            on_cancel=self._close_file_manager,
+            multi_select=True,
+            data_root=self._data_root,
+        )
+
+    def _on_add_sheets(self, selection: Union[Path, List[Path]]) -> None:
+        if isinstance(selection, Path):
+            selection = [selection]
+        was_empty = len(self._sheet_surfaces) == 0
+        loaded = 0
+        for path in selection:
+            try:
+                surf = pygame.image.load(str(path)).convert_alpha()
+                self._sheet_surfaces.append(surf)
+                loaded += 1
+            except Exception as e:
+                print(f"Failed to load {path.name}: {e}")
+        if loaded:
+            if was_empty:
+                detected = self._detect_tile_size(self._sheet_surfaces[0])
+                self.grid.set_tile_size(*detected)
+            self._build_combined_surface()
+        self._close_file_manager()
+
     # ------------------------------------------------------------------
     # Drawing
     # ------------------------------------------------------------------
@@ -295,6 +424,8 @@ class SpriteEditor:
 
         if self._scale_active:
             self._draw_scale_dialog(screen)
+        if self._grid_active:
+            self._draw_grid_dialog(screen)
 
         # File manager overlay
         if self._file_manager is not None:
@@ -321,3 +452,25 @@ class SpriteEditor:
 
         hint = self._font_sm.render("Enter / Esc", True, COLORS.text_dim)
         screen.blit(hint, (dlg.right - 90, dlg.bottom - 22))
+
+    def _draw_grid_dialog(self, screen: Surface) -> None:
+        dw, dh = 260, 100
+        cx, cy = self.rect.center
+        dlg = Rect(cx - dw // 2, cy - dh // 2, dw, dh)
+        draw_panel(screen, dlg, COLORS.panel, COLORS.border)
+
+        title = self._font.render("Tile Size (WxH)", True, COLORS.text)
+        screen.blit(title, title.get_rect(centerx=dlg.centerx, top=dlg.top + 10))
+
+        inp = Rect(dlg.x + 20, dlg.top + 36, dw - 40, 28)
+        pygame.draw.rect(screen, COLORS.selected, inp, border_radius=4)
+        pygame.draw.rect(screen, COLORS.accent, inp, 2, border_radius=4)
+        txt = self._grid_text + ("|" if (pygame.time.get_ticks() // 400) % 2 else "")
+        screen.blit(self._font_sm.render(txt, True, COLORS.text), (inp.x + 6, inp.y + 5))
+
+        if self._grid_error:
+            err = self._font_sm.render(self._grid_error, True, COLORS.danger)
+            screen.blit(err, (dlg.x + 20, dlg.bottom - 22))
+
+        hint = self._font_sm.render("Enter / Esc", True, COLORS.text_dim)
+        screen.blit(hint, (dlg.right - 90, dlg.bottom - 22))

{tilemap_editor-3.2.9 → tilemap_editor-3.3.0}/src/plugins/sprite_editor/standalone.py

@@ -2,9 +2,9 @@
 Standalone launcher for the Sprite Editor.
 
 Usage:
+    python standalone.py                          # start blank, then click [Open]
     python standalone.py path/to/spritesheet.png
     python standalone.py path/to/spritesheet.png --tile-size 32
-    python standalone.py path/to/spritesheet.png --save output.png
 """
 
 from __future__ import annotations
@@ -47,7 +47,8 @@ def main(argv: list[str] | None = None) -> None:
     sys.excepthook = handle_exception
 
     parser = argparse.ArgumentParser(description="Grid Sprite Editor")
-    parser.add_argument("image", type=str, help="Path to spritesheet image")
+    parser.add_argument("image", type=str, nargs="?", default=None,
+                        help="Path to spritesheet image (optional — start blank)")
     parser.add_argument("--tile-size", type=str, default="32",
                         help="Tile size (e.g. 32 or 32x32)")
     parser.add_argument("--save", type=str, default=None,
@@ -59,30 +60,35 @@ def main(argv: list[str] | None = None) -> None:
 
     args = parser.parse_args(argv)
 
-    image_path = Path(args.image)
-    if not image_path.is_file():
-        print(f"Error: file not found: {image_path}")
-        sys.exit(1)
-
     ts_parts = args.tile_size.lower().split("x")
     tw = int(ts_parts[0])
     th = int(ts_parts[1]) if len(ts_parts) > 1 else tw
 
     window_size = parse_window_size(args.window_size)
-    data_root = Path(args.data_root) if args.data_root else image_path.parent
 
     pygame.init()
     screen = pygame.display.set_mode(window_size, pygame.RESIZABLE)
-    pygame.display.set_caption(f"Sprite Editor - {image_path.name}")
-
-    surface = pygame.image.load(str(image_path)).convert_alpha()
 
-    editor = SpriteEditor(
-        screen.get_rect(), surface, (tw, th),
-        image_path=image_path, data_root=data_root,
-    )
-    if args.save:
-        editor.set_save_path(Path(args.save))
+    if args.image:
+        image_path = Path(args.image)
+        if not image_path.is_file():
+            print(f"Error: file not found: {image_path}")
+            sys.exit(1)
+        data_root = Path(args.data_root) if args.data_root else image_path.parent
+        surface = pygame.image.load(str(image_path)).convert_alpha()
+        pygame.display.set_caption(f"Sprite Editor - {image_path.name}")
+        editor = SpriteEditor(
+            screen.get_rect(), surface, (tw, th),
+            image_path=image_path, data_root=data_root,
+        )
+        if args.save:
+            editor.set_save_path(Path(args.save))
+    else:
+        data_root = Path(args.data_root) if args.data_root else Path.cwd()
+        pygame.display.set_caption("Sprite Editor — blank")
+        editor = SpriteEditor(
+            screen.get_rect(), tile_size=(tw, th), data_root=data_root,
+        )
 
     clock = pygame.time.Clock()
     running = True

{tilemap_editor-3.2.9 → tilemap_editor-3.3.0/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.2.9 → tilemap_editor-3.3.0}/src/tilemap_editor.egg-info/top_level.txt

@@ -3,6 +3,8 @@ constants
 editor
 event_map
 layers
+node_manager
+nodes
 plugins
 standalone_automap
 standalone_error_console

{tilemap_editor-3.2.9 → tilemap_editor-3.3.0}/src/widgets/filemanager.py

@@ -503,6 +503,7 @@ class FileManager:
 
         self.font_main = pygame.font.SysFont("Arial", 14)
         self.font_bold = pygame.font.SysFont("Arial", 14, bold=True)
+        self.font_small = pygame.font.SysFont("Arial", 11)
         self.font_icon = pygame.font.SysFont("Consolas", 20)
 
         self.search_input = InlineTextInput("search", "")
@@ -1606,13 +1607,21 @@ class FileManager:
             pygame.draw.rect(screen, COLORS["border"], bar_rect, border_radius=2)
 
     def _draw_footer(self, screen, rect):
-        sel_txt = "No file selected"
-        if self.selected_index != -1:
+        sel_txt: str
+        if self.multi_select and len(self.selected_indices) > 1:
+            sel_txt = f"{len(self.selected_indices)} files selected"
+        elif self.selected_index != -1:
             sel_txt = self.items[self.selected_index].name
+        else:
+            sel_txt = "No file selected"
 
-        txt_surf = self.font_main.render(sel_txt, True, COLORS["text_dim"])
         if self.mode == "open":
-            screen.blit(txt_surf, (rect.x + 10, rect.y + 17))
+            txt_surf = self.font_main.render(sel_txt, True, COLORS["text_dim"])
+            screen.blit(txt_surf, (rect.x + 10, rect.y + 12))
+            if self.multi_select:
+                hint = "[Ctrl+Click] toggle  [Shift+Click] range  [Open] confirm"
+                hint_surf = self.font_small.render(hint, True, COLORS["text_dim"])
+                screen.blit(hint_surf, (rect.x + 10, rect.y + 28))
 
         btn_w, btn_h = 80, 30
         margin = 10

{tilemap_editor-3.2.9 → tilemap_editor-3.3.0}/src/widgets/tile_selector.py

@@ -46,6 +46,10 @@ class TileSelector:
             x, y + self.top_bar_h, w, h - self.top_bar_h - self.btm_bar_h
         )
         self.tab_scroll_x = 0
+        arrow_h = self.top_bar_h - 4
+        arrow_y = y + (self.top_bar_h - arrow_h) // 2
+        self._tab_arrow_left = Rect(x + 2, arrow_y, 18, arrow_h)
+        self._tab_arrow_right = Rect(x + w - 20, arrow_y, 18, arrow_h)
         self.is_panning = False
         self.pan_start = (0, 0)
         self.pan_start_offset = (0, 0)
@@ -86,6 +90,10 @@ class TileSelector:
         self.btn_collision = Rect(x + w - 105, btn_y, 30, 30)
         self.btn_add = Rect(x + w - 70, btn_y, 30, 30)
         self.btn_rem = Rect(x + w - 35, btn_y, 30, 30)
+        arrow_h = self.top_bar_h - 4
+        arrow_y = y + (self.top_bar_h - arrow_h) // 2
+        self._tab_arrow_left = Rect(x + 2, arrow_y, 18, arrow_h)
+        self._tab_arrow_right = Rect(x + w - 20, arrow_y, 18, arrow_h)
 
     def set_rule_hints(self, hints: Set[int]):
         self.rule_hints = hints
@@ -179,6 +187,13 @@ class TileSelector:
                 return True
 
             if self.rect.collidepoint(mouse_pos) and mouse_pos[1] < self.view_rect.top:
+                # Check arrow buttons first
+                if self._tab_arrow_left.collidepoint(mouse_pos):
+                    self._scroll_tabs(100)
+                    return True
+                if self._tab_arrow_right.collidepoint(mouse_pos):
+                    self._scroll_tabs(-100)
+                    return True
                 self.check_tab_click(mouse_pos)
                 return True
 
@@ -561,8 +576,8 @@ class TileSelector:
     def _get_tab_at_pos(self, pos) -> Optional[int]:
         if not self.tilesets:
             return None
-        tab_w = min(100, self.rect.width // len(self.tilesets))
-        idx = (pos[0] - self.rect.x) // tab_w
+        tab_w = 100
+        idx = (pos[0] - self.rect.x + self.tab_scroll_x) // tab_w
         if 0 <= idx < len(self.tilesets):
             return int(idx)
         return None
@@ -875,14 +890,19 @@ class TileSelector:
         clip = screen.get_clip()
         tab_area = Rect(self.rect.x, self.rect.y, self.rect.width, self.top_bar_h)
         screen.set_clip(tab_area)
+
+        pygame.draw.rect(screen, COLORS.header, tab_area)
+
         tab_w = 100
         total_w = tab_w * len(self.tilesets)
-        if total_w > self.rect.width:
+        has_overflow = total_w > self.rect.width
+        if has_overflow:
             self.tab_scroll_x = max(
                 0, min(self.tab_scroll_x, total_w - self.rect.width)
             )
         else:
             self.tab_scroll_x = 0
+
         for i, ts in enumerate(self.tilesets):
             r = Rect(
                 self.rect.x + i * tab_w - self.tab_scroll_x,
@@ -895,13 +915,25 @@ class TileSelector:
             is_active = i == self.active_idx
             col = COLORS.selected if is_active else COLORS.header
             pygame.draw.rect(screen, col, r)
-            pygame.draw.rect(screen, COLORS.border, r, 1)
+            if not is_active:
+                pygame.draw.line(screen, COLORS.border, r.bottomleft, r.bottomright, 1)
             t = ts.name[:8] + ".." if len(ts.name) > 10 else ts.name
             screen.blit(self.font.render(t, True, COLORS.text), (r.x + 5, r.y + 5))
-            mx, my = pygame.mouse.get_pos()
-            if r.collidepoint(mx, my):
-                self.editor.tooltip.show(ts.name, (mx + 10, my + 10))
-        if total_w > self.rect.width:
+
+        mx, my = pygame.mouse.get_pos()
+        show_arrows = has_overflow and tab_area.collidepoint(mx, my)
+
+        if show_arrows:
+            for arrow_rect, label in [
+                (self._tab_arrow_left, "<"),
+                (self._tab_arrow_right, ">"),
+            ]:
+                pygame.draw.rect(screen, COLORS.selected, arrow_rect)
+                pygame.draw.rect(screen, COLORS.border, arrow_rect, 1)
+                arrow_surf = self.font.render(label, True, COLORS.text)
+                arrow_rect_text = arrow_surf.get_rect(center=arrow_rect.center)
+                screen.blit(arrow_surf, arrow_rect_text)
+
             bar_w = max(30, int(self.rect.width * (self.rect.width / total_w)))
             bar_x = self.rect.x + int(
                 (self.tab_scroll_x / (total_w - self.rect.width))
@@ -909,6 +941,20 @@ class TileSelector:
             )
             bar_rect = Rect(bar_x, self.rect.y + self.top_bar_h - 4, bar_w, 3)
             pygame.draw.rect(screen, COLORS.border_soft, bar_rect, border_radius=2)
+
+        # Tooltip for tab name
+        if tab_area.collidepoint(mx, my) and not (
+            show_arrows and (
+                self._tab_arrow_left.collidepoint(mx, my) or
+                self._tab_arrow_right.collidepoint(mx, my)
+            )
+        ):
+            idx = self._get_tab_at_pos((mx, my))
+            if idx is not None and 0 <= idx < len(self.tilesets):
+                self.editor.tooltip.show(
+                    self.tilesets[idx].name, (mx + 10, my + 10)
+                )
+
         screen.set_clip(clip)
 
     def _scroll_tabs(self, delta: float):