tilemap-editor 3.3.10__tar.gz → 4.0.0__tar.gz

{tilemap_editor-3.3.10/src/tilemap_editor.egg-info → tilemap_editor-4.0.0}/PKG-INFO

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

{tilemap_editor-3.3.10 → tilemap_editor-4.0.0}/pyproject.toml

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

{tilemap_editor-3.3.10 → tilemap_editor-4.0.0}/src/editor.py

@@ -37,7 +37,8 @@ from widgets.ui.notification import NotificationManager
 from widgets.ui.property_editor import PropertyEditor
 from widgets.ui.particle_config_dialog import ParticleConfigDialog
 from widgets.ui.tooltip import TooltipManager
-from widgets.ui.theme import get_theme_manager, set_theme, THEMES
+from widgets.ui.theme import COLORS, get_theme_manager, set_theme, THEMES
+from widgets.ui.sidebar_container import SidebarContainer, ToolbarAction
 from utils.log_capture import setup_console_log
 from utils.standalone import launch_standalone
 from utils import error_handler, error_context
@@ -148,6 +149,11 @@ class Editor:
         logger.info(f"Project base_path: {self.base_path}")
         logger.info(f"Data root: {self.data_root}")
 
+        theme_name = self.config.get("theme", "dark")
+        if theme_name in THEMES:
+            set_theme(theme_name)
+            logger.info(f"Applied theme: {theme_name}")
+
         pygame.init()
         pygame.display.set_caption("Pure Pygame Editor")
 
@@ -174,9 +180,8 @@ class Editor:
         self.tilemap = Tilemap(self)
 
         self.selector_w = 300
+        self._tileset_dragging = False
         self.left_panel_w = 380  # Width for the dockable left sidebar
-        self.tileset_h = 300
-        self.layer_h = 150
         self.map_setup_widget: Optional[MapSetup] = None
         self.map_properties_dialog: Optional[MapPropertiesDialog] = None
         self.tileset_widget: Optional[TileSelector] = None
@@ -225,16 +230,20 @@ class Editor:
         self.tilemap.init_size((32, 32), (50, 50))
 
         menu_h = 30
-        self.tileset_widget = TileSelector(
-            self, self.width - self.selector_w, menu_h, self.selector_w, self.tileset_h
-        )
-        self.layer_widget = LayerSelector(
-            self,
-            self.width - self.selector_w,
-            menu_h + self.tileset_h,
-            self.selector_w,
-            self.layer_h,
-        )
+        toolbar_h = 35
+        self.tileset_widget = TileSelector(self, 0, 0, self.selector_w, 100)
+        self.layer_widget = LayerSelector(self, 0, 0, self.selector_w, 100)
+        sidebar_x = self.width - self.selector_w
+        sidebar_h = self.height - menu_h - toolbar_h
+        tileset_actions = [
+            ToolbarAction("E", self.tileset_widget._export_selected_as_png_dialog, "E: Export selection as PNG"),
+            ToolbarAction("C", self.tileset_widget.open_collision_editor, "Edit Collision Shapes"),
+            ToolbarAction("+", self.tileset_widget.request_add_tileset, "Add Tileset"),
+            ToolbarAction("-", self.tileset_widget.remove_tileset, "Remove Tileset"),
+        ]
+        self.sidebar = SidebarContainer(self, Rect(sidebar_x, menu_h + toolbar_h, self.selector_w, sidebar_h))
+        self.sidebar.add_tab("Tilesets", self.tileset_widget, tileset_actions)
+        self.sidebar.add_tab("Layers", self.layer_widget)
         self.tile_grid_widget = TileGrid(
             self,
             Rect(0, menu_h, self.width - self.selector_w, self.height - menu_h - 25),
@@ -557,15 +566,45 @@ class Editor:
             return
 
         try:
-            self.post_map_setup()
+            self.handle_resize(self.width, self.height)
             self.tilemap.apply_map_payload(path, payload_or_error)
         except Exception as e:
             error_handler.capture(e, context="load_map_apply")
+            import traceback
+            traceback.print_exc()
         finally:
             self.loading_state["active"] = False
 
     def post_map_setup(self):
         self.handle_resize(self.width, self.height)
+        if hasattr(self, "tile_grid_widget") and self.tile_grid_widget:
+            self.tile_grid_widget.center_on_map()
+
+    def _update_side_panel_layout(self):
+        menu_h = 30
+        toolbar_h = 35
+        left_offset = self.left_panel_w if self.left_panel_visible else 0
+        
+        min_canvas_w = 200
+        available_w = self.width - left_offset
+        self._effective_selector_w = min(self.selector_w, max(0, available_w - min_canvas_w))
+
+        if hasattr(self, "sidebar") and self.sidebar:
+            self.sidebar.resize(
+                self.width - self._effective_selector_w,
+                menu_h + toolbar_h,
+                self._effective_selector_w,
+                self.height - menu_h - toolbar_h,
+            )
+
+        if hasattr(self, "tile_grid_widget") and self.tile_grid_widget:
+            canvas_w = available_w - self._effective_selector_w
+            self.tile_grid_widget.rect = Rect(
+                left_offset,
+                menu_h + toolbar_h,
+                canvas_w,
+                self.height - (menu_h + toolbar_h) - 25,
+            )
 
     def handle_resize(self, width: int, height: int):
         self.width = width
@@ -574,38 +613,13 @@ class Editor:
         menu_h = 30
         toolbar_h = 35
 
-        # Left sidebar offset
-        left_offset = self.left_panel_w if self.left_panel_visible else 0
-
         if hasattr(self, "menubar") and self.menubar:
             self.menubar.resize(width)
 
         if hasattr(self, "toolbar") and self.toolbar:
             self.toolbar.resize(width)
 
-        if hasattr(self, "tileset_widget") and self.tileset_widget:
-            self.tileset_widget.resize(
-                width - self.selector_w - left_offset,
-                menu_h + toolbar_h,
-                self.selector_w,
-                self.tileset_h,
-            )
-
-        if hasattr(self, "layer_widget") and self.layer_widget:
-            self.layer_widget.resize(
-                width - self.selector_w - left_offset,
-                menu_h + toolbar_h + self.tileset_h,
-                self.selector_w,
-                height - (menu_h + toolbar_h + self.tileset_h),
-            )
-
-        if hasattr(self, "tile_grid_widget") and self.tile_grid_widget:
-            self.tile_grid_widget.rect = Rect(
-                left_offset,
-                menu_h + toolbar_h,
-                width - self.selector_w - left_offset,
-                height - (menu_h + toolbar_h),
-            )
+        self._update_side_panel_layout()
 
         # Update animation panel rect
         if self.left_panel_visible and self.animation_panel:
@@ -673,6 +687,7 @@ class Editor:
                 self.left_panel_visible = True
         else:
             self.left_panel_visible = False
+        self.handle_resize(self.width, self.height)
 
 
     def _init_animation_panel(self):
@@ -713,9 +728,13 @@ class Editor:
 
     def undo(self):
         self.tilemap.undo()
+        if self.tile_grid_widget:
+            self.tile_grid_widget.invalidate_bounds_cache()
 
     def redo(self):
         self.tilemap.redo()
+        if self.tile_grid_widget:
+            self.tile_grid_widget.invalidate_bounds_cache()
 
     def toggle_grid(self):
         if self.tile_grid_widget:
@@ -730,6 +749,17 @@ class Editor:
         new_theme = theme_names[next_idx]
         set_theme(new_theme)
         self.notifications.notify(f"Theme: {new_theme}")
+        
+        settings_file = Path.cwd() / "settings.json"
+        if settings_file.exists():
+            try:
+                with open(settings_file, "r", encoding="utf-8") as f:
+                    config = json.load(f)
+                config["theme"] = new_theme
+                with open(settings_file, "w", encoding="utf-8") as f:
+                    json.dump(config, f, indent=4)
+            except Exception:
+                pass
 
     def launch_external_automap(self):
         if hasattr(self.autotiler, "_launch_external_viewer"):
@@ -1266,15 +1296,34 @@ class Editor:
                     if self.animation_panel.handle_event(event):
                         continue
 
-            # Priority 7: Side panels (layer widget first so rename captures keys)
+            # Priority 6.5: Sidebar resize drag (vertical)
+            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+                mx, my = event.pos
+                edge_x = self.width - self._effective_selector_w
+                if abs(mx - edge_x) < 6:
+                    self._tileset_dragging = True
+                    continue
+            elif event.type == pygame.MOUSEMOTION:
+                mx, my = event.pos
+                edge_x = self.width - self._effective_selector_w
+                if self._tileset_dragging:
+                    new_w = max(150, min(self.width // 2, self.width - mx))
+                    self.selector_w = new_w
+                    self._update_side_panel_layout()
+                    continue
+                near_vertical = abs(mx - edge_x) < 6
+                if near_vertical:
+                    pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_SIZEWE)
+                else:
+                    pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_ARROW)
+            elif event.type == pygame.MOUSEBUTTONUP and event.button == 1:
+                if self._tileset_dragging:
+                    self._tileset_dragging = False
+                    continue
+
+            # Priority 7: Sidebar container
             consumed = False
-            if self.layer_widget and self.layer_widget.handle_event(event):
-                consumed = True
-            if (
-                not consumed
-                and self.tileset_widget
-                and self.tileset_widget.handle_event(event)
-            ):
+            if self.sidebar and self.sidebar.handle_event(event):
                 consumed = True
             
             # Priority 8: Main tile grid (lowest priority)
@@ -1306,10 +1355,13 @@ class Editor:
 
             if self.tile_grid_widget:
                 self.tile_grid_widget.draw(self.screen)
-            if self.tileset_widget:
-                self.tileset_widget.draw(self.screen)
-            if self.layer_widget:
-                self.layer_widget.draw(self.screen)
+            if self.sidebar:
+                self.sidebar.draw(self.screen)
+                edge_x = self.width - self._effective_selector_w
+                handle_rect = Rect(edge_x - 1, 0, 3, self.height)
+                pygame.draw.rect(self.screen, COLORS.border, handle_rect)
+                if self._tileset_dragging:
+                    pygame.draw.rect(self.screen, COLORS.accent, handle_rect)
             
             # Draw autotiler and regex designer with modal overlay
             if self.autotiler:

{tilemap_editor-3.3.10 → tilemap_editor-4.0.0}/src/plugins/sprite_animation/preview.py

@@ -12,11 +12,11 @@ from typing import Callable, List, Optional, Tuple
 import pygame
 from pygame import Rect
 
-from .models import AnimationFrame
-from utils.font_manager import font_manager, FontWeight, FontStyle
+from utils.font_manager import FontStyle, FontWeight, font_manager
 from utils.icon_manager import icon_manager
 
-# ---------------------------------------------------------------------------
+from .models import AnimationFrame
+
 _COLORS = {
     "bg": (25, 27, 30),
     "panel": (35, 38, 44),
@@ -39,7 +39,6 @@ _COLORS = {
 
 HEADER_H = 36
 CONTROLS_H = 32
-# Preview timing vs a 60 Hz editor tick: elapsed += dt_ms * (playback_fps / 60).
 
 
 class AnimationPreview:
@@ -76,7 +75,6 @@ class AnimationPreview:
         self._editing_fps = False
         self._fps_input_rect = Rect(0, 0, 0, 0)
 
-        # Buttons (recalculated in draw)
         self._btn_play = Rect(0, 0, 0, 0)
         self._btn_stop = Rect(0, 0, 0, 0)
         self._btn_loop = Rect(0, 0, 0, 0)
@@ -84,24 +82,21 @@ class AnimationPreview:
         self._btn_prev = Rect(0, 0, 0, 0)
         self._btn_next = Rect(0, 0, 0, 0)
 
-        # Scrubber fraction output (read by timeline)
         self.scrubber_frac: float = 0.0
 
         self._font: Optional[pygame.font.Font] = None
         self._font_sm: Optional[pygame.font.Font] = None
         self._checker: Optional[pygame.Surface] = None
 
-    # ------------------------------------------------------------------
-    # Public
-    # ------------------------------------------------------------------
-
     def set_frames(self, frames: List[AnimationFrame]) -> None:
         self.frames = frames
         self.current_frame = 0
         self._elapsed = 0.0
 
     def set_surface(
-        self, surface: pygame.Surface, tile_size: Optional[Tuple[int, int]] = None
+        self,
+        surface: pygame.Surface,
+        tile_size: Optional[Tuple[int, int]] = None
     ) -> None:
         self.surface = surface
         if tile_size:
@@ -154,10 +149,6 @@ class AnimationPreview:
         self._elapsed = 0.0
         self.scrubber_frac = 0.0
 
-    # ------------------------------------------------------------------
-    # Update (call every frame with dt in milliseconds)
-    # ------------------------------------------------------------------
-
     def update(self, dt_ms: float) -> None:
         if not self.playing or not self.frames:
             return
@@ -178,7 +169,6 @@ class AnimationPreview:
                     break
             cur = self.frames[self.current_frame]
 
-        # Compute scrubber fraction
         total = sum(f.duration_ms for f in self.frames)
         if total > 0:
             elapsed_to_cur = (
@@ -189,21 +179,13 @@ class AnimationPreview:
         else:
             self.scrubber_frac = 0.0
 
-    # ------------------------------------------------------------------
-    # Events
-    # ------------------------------------------------------------------
-
     def handle_event(self, event: pygame.event.Event) -> bool:
         if event.type == pygame.KEYDOWN and self._editing_fps:
             return self._handle_fps_keydown(event)
 
         mouse = pygame.mouse.get_pos()
         if not self.rect.collidepoint(mouse):
-            if (
-                event.type == pygame.MOUSEBUTTONDOWN
-                and event.button == 1
-                and self._editing_fps
-            ):
+            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1 and self._editing_fps:
                 self.commit_fps_input()
             return False
 
@@ -237,7 +219,6 @@ class AnimationPreview:
                 self._step(1)
                 return True
 
-        # Scroll to adjust zoom
         if event.type == pygame.MOUSEWHEEL and self.rect.collidepoint(mouse):
             self._zoom *= 1.15 if event.y > 0 else 0.87
             self._zoom = max(1.0, min(self._zoom, 12.0))
@@ -245,10 +226,6 @@ class AnimationPreview:
 
         return False
 
-    # ------------------------------------------------------------------
-    # Drawing
-    # ------------------------------------------------------------------
-
     def draw(self, screen: pygame.Surface) -> None:
         self._ensure_fonts()
         clip = screen.get_clip()
@@ -257,15 +234,12 @@ class AnimationPreview:
         pygame.draw.rect(screen, _COLORS["panel"], self.rect)
         pygame.draw.rect(screen, _COLORS["border"], self.rect, 1)
 
-        # Header
         hdr = Rect(self.rect.x, self.rect.y, self.rect.w, HEADER_H)
         pygame.draw.rect(screen, _COLORS["header"], hdr)
         title = "Preview"
         if self.frames:
             title += f"  {self.current_frame + 1}/{len(self.frames)}"
-        screen.blit(
-            self._font.render(title, True, _COLORS["text"]), (hdr.x + 6, hdr.y + 2)
-        )
+        screen.blit(self._font.render(title, True, _COLORS["text"]), (hdr.x + 6, hdr.y + 2))
         if self.frames and 0 <= self.current_frame < len(self.frames):
             fr = self.frames[self.current_frame]
             auth = max(0.001, float(self.authoring_fps))
@@ -276,19 +250,15 @@ class AnimationPreview:
                 (hdr.x + 6, hdr.y + 18),
             )
 
-        # Preview area
         preview_y = self.rect.y + HEADER_H
         preview_h = self.rect.h - HEADER_H - CONTROLS_H
         preview_rect = Rect(self.rect.x, preview_y, self.rect.w, preview_h)
 
-        # Checkerboard background
         self._draw_checker(screen, preview_rect)
 
-        # Draw current frame
         if self.frames and 0 <= self.current_frame < len(self.frames):
             frame = self.frames[self.current_frame]
 
-            # Onion skin (previous frame)
             if self.show_onion and self.current_frame > 0:
                 prev_frame = self.frames[self.current_frame - 1]
                 prev_surf = self._extract_tile(prev_frame.variant_id)
@@ -305,7 +275,6 @@ class AnimationPreview:
                     dy = preview_rect.centery - zoomed.get_height() // 2
                     screen.blit(zoomed, (dx, dy))
 
-            # Current frame
             tile_surf = self._extract_tile(frame.variant_id)
             if tile_surf:
                 zw = int(self.tile_size[0] * self._zoom)
@@ -319,7 +288,6 @@ class AnimationPreview:
             no_anim = self._font.render("No frames", True, _COLORS["text_dim"])
             screen.blit(no_anim, no_anim.get_rect(center=preview_rect.center))
 
-        # Controls bar
         ctrl_y = self.rect.bottom - CONTROLS_H
         ctrl_rect = Rect(self.rect.x, ctrl_y, self.rect.w, CONTROLS_H)
         pygame.draw.rect(screen, _COLORS["header"], ctrl_rect)
@@ -328,10 +296,6 @@ class AnimationPreview:
 
         screen.set_clip(clip)
 
-    # ------------------------------------------------------------------
-    # Controls drawing
-    # ------------------------------------------------------------------
-
     def _draw_controls(self, screen: pygame.Surface, ctrl_rect: Rect) -> None:
         mouse = pygame.mouse.get_pos()
         bw, bh = 28, 24
@@ -339,53 +303,43 @@ class AnimationPreview:
         x = ctrl_rect.x + pad
         y = ctrl_rect.y + (ctrl_rect.h - bh) // 2
 
-        # |<< (prev)
         self._btn_prev = Rect(x, y, bw, bh)
         self._draw_btn(screen, self._btn_prev, "", mouse)
         prev_icon = icon_manager.get_icon("skip-back", 12, _COLORS["text"])
         screen.blit(prev_icon, prev_icon.get_rect(center=self._btn_prev.center))
         x += bw + pad
 
-        # Play / Pause
         self._btn_play = Rect(x, y, bw, bh)
         self._draw_btn(screen, self._btn_play, "", mouse, active=self.playing)
-        play_icon = icon_manager.get_icon(
-            "pause" if self.playing else "play", 12, _COLORS["text"]
-        )
+        play_icon = icon_manager.get_icon("pause" if self.playing else "play", 12, _COLORS["text"])
         screen.blit(play_icon, play_icon.get_rect(center=self._btn_play.center))
         x += bw + pad
 
-        # Stop
         self._btn_stop = Rect(x, y, bw, bh)
         self._draw_btn(screen, self._btn_stop, "", mouse)
         stop_icon = icon_manager.get_icon("stop", 12, _COLORS["text"])
         screen.blit(stop_icon, stop_icon.get_rect(center=self._btn_stop.center))
         x += bw + pad
 
-        # >>| (next)
         self._btn_next = Rect(x, y, bw, bh)
         self._draw_btn(screen, self._btn_next, "", mouse)
         next_icon = icon_manager.get_icon("skip-forward", 12, _COLORS["text"])
         screen.blit(next_icon, next_icon.get_rect(center=self._btn_next.center))
         x += bw + pad + 4
 
-        # Loop toggle
         self._btn_loop = Rect(x, y, bw + 4, bh)
         self._draw_btn(screen, self._btn_loop, "", mouse, active=self.loop)
         loop_icon = icon_manager.get_icon("loop", 12, _COLORS["text"])
         screen.blit(loop_icon, loop_icon.get_rect(center=self._btn_loop.center))
         x += bw + pad + 8
 
-        # Playback FPS (editable; timing vs 60 Hz tick — see update())
         fps_tag = self._font_sm.render("FPS", True, _COLORS["text_dim"])
         screen.blit(fps_tag, (x, y + (bh - fps_tag.get_height()) // 2))
         x += fps_tag.get_width() + 3
         self._fps_input_rect = Rect(x, y, 44, bh)
         fps_bg = _COLORS["btn_active"] if self._editing_fps else _COLORS["input_bg"]
         pygame.draw.rect(screen, fps_bg, self._fps_input_rect, border_radius=3)
-        pygame.draw.rect(
-            screen, _COLORS["border"], self._fps_input_rect, 1, border_radius=3
-        )
+        pygame.draw.rect(screen, _COLORS["border"], self._fps_input_rect, 1, border_radius=3)
         shown = self._fps_input_text
         if self._editing_fps and (pygame.time.get_ticks() // 400) % 2:
             shown += "|"
@@ -394,16 +348,13 @@ class AnimationPreview:
         screen.blit(fps_surf, (self._fps_input_rect.x + 4, self._fps_input_rect.y + 5))
         x += 44 + pad
 
-        # Onion skin
         if x + bw + 12 < ctrl_rect.right:
             self._btn_onion = Rect(x, y, bw + 4, bh)
             self._draw_btn(screen, self._btn_onion, "", mouse, active=self.show_onion)
             onion_icon = icon_manager.get_icon("onion", 14, _COLORS["text"])
             screen.blit(onion_icon, onion_icon.get_rect(center=self._btn_onion.center))
 
-    def _draw_btn(
-        self, screen: pygame.Surface, rect: Rect, label: str, mouse, active=False
-    ) -> None:
+    def _draw_btn(self, screen: pygame.Surface, rect: Rect, label: str, mouse, active=False) -> None:
         hover = rect.collidepoint(mouse)
         if active:
             bg = _COLORS["btn_active"]
@@ -416,10 +367,6 @@ class AnimationPreview:
         lbl = self._font_sm.render(label, True, _COLORS["text"])
         screen.blit(lbl, lbl.get_rect(center=rect.center))
 
-    # ------------------------------------------------------------------
-    # Helpers
-    # ------------------------------------------------------------------
-
     def _extract_tile(self, variant_id: int) -> Optional[pygame.Surface]:
         tw, th = self.tile_size
         ox = self.grid_offset_x

{tilemap_editor-3.3.10 → tilemap_editor-4.0.0}/src/plugins/tileset_collision/editor.py

@@ -625,7 +625,7 @@ class TilesetCollisionEditor:
         """Save collision data to file, auto-propagating within auto-tile groups."""
         try:
             self._save_tile_collision_for_selection()
-            self._propagate_collision_to_groups()
+            # self._propagate_collision_to_groups()  # disabled — auto-copies collision to all autotile variants, breaks per-variant shapes
             self.library.save(path)
         except Exception as e:
             error_handler.capture(e, context="save_collision_file")

{tilemap_editor-3.3.10 → tilemap_editor-4.0.0}/src/tilemap.py

@@ -477,8 +477,7 @@ class Tilemap:
         try:
             self.tile_size = deserialize_point(payload["meta"]["tile_size"])
             self.map_size = deserialize_point(payload["meta"].get("map_size", "50;50"))
-            # If the file tells us the map is large, we assume that was intended
-            # But the 'initial' setup might be in meta or we use map_size as base
+
             self.initial_map_size = payload["meta"].get("initial_map_size")
             if self.initial_map_size:
                 self.initial_map_size = deserialize_point(self.initial_map_size)
@@ -488,16 +487,6 @@ class Tilemap:
         except (KeyError, ValueError) as e:
             raise ValueError(f"Error loading map metadata: {e}") from e
 
-        # Restore view state
-        if self.editor.tile_grid_widget:
-            if "zoom_level" in payload["meta"]:
-                self.editor.tile_grid_widget.zoom_level = payload["meta"]["zoom_level"]
-            if "scroll" in payload["meta"]:
-                scroll = deserialize_point(payload["meta"]["scroll"])
-                self.editor.tile_grid_widget.scroll_x = scroll[0]
-                self.editor.tile_grid_widget.scroll_y = scroll[1]
-            self.editor.tile_grid_widget.clamp_view()
-
         resources = payload.get("resources", {})
         tilesets = []
         if isinstance(resources, list):
@@ -669,6 +658,18 @@ class Tilemap:
 
         self.initialized = True
 
+        # Restore view state and invalidate bounds cache after map load
+        if self.editor.tile_grid_widget:
+            if "zoom_level" in payload["meta"]:
+                self.editor.tile_grid_widget.zoom_level = payload["meta"]["zoom_level"]
+            if "scroll" in payload["meta"]:
+                scroll = deserialize_point(payload["meta"]["scroll"])
+                self.editor.tile_grid_widget.scroll_x = scroll[0]
+                self.editor.tile_grid_widget.scroll_y = scroll[1]
+            if hasattr(self.editor.tile_grid_widget, "clamp_scroll"):
+                self.editor.tile_grid_widget.clamp_scroll()
+            self.editor.tile_grid_widget.invalidate_bounds_cache()
+
     def _object_tileset_indices_from_payload(self, payload: dict) -> set[int]:
         """Infer legacy object tileset resources from object-layer references."""
         indices: set[int] = set()

{tilemap_editor-3.3.10 → tilemap_editor-4.0.0}/src/tilemap_editor/settings.py

@@ -25,6 +25,8 @@ def init_settings(generate_main: bool = False) -> None:
             "character": "character_collision"
         },
         "nodes_path": "nodes",
+        "theme": "dark",
+        "themes_list": ["dark", "molokai", "light", "semi_light"],
         "error_handler": {
             "log_path": "errors.log",
             "max_recent_errors": 50,

{tilemap_editor-3.3.10 → tilemap_editor-4.0.0/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.3.10 → tilemap_editor-4.0.0}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -172,12 +172,16 @@ src/widgets/regex_automap_designer.py
 src/widgets/spritesheet_grid.py
 src/widgets/tile_grid.py
 src/widgets/tile_selector.py
+src/widgets/widget_base.py
+src/widgets/ui/button.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
+src/widgets/ui/dialog_base.py
 src/widgets/ui/draw_utils.py
 src/widgets/ui/fileinput.py
+src/widgets/ui/label.py
 src/widgets/ui/layer_type_dialog.py
 src/widgets/ui/menubar.py
 src/widgets/ui/mode_indicator.py
@@ -187,6 +191,8 @@ src/widgets/ui/notification.py
 src/widgets/ui/particle_config_dialog.py
 src/widgets/ui/property_editor.py
 src/widgets/ui/region_selector.py
+src/widgets/ui/scrollbar.py
+src/widgets/ui/sidebar_container.py
 src/widgets/ui/status_bar.py
 src/widgets/ui/theme.py
 src/widgets/ui/tileset_type_dialog.py
@@ -198,6 +204,7 @@ tests/test_collision_layer_sidebar.py
 tests/test_editor_pan_mode.py
 tests/test_project_paths.py
 tests/test_render_scale.py
+tests/test_serialization_regression.py
 tests/test_sprite_animation_editor_grid.py
 tests/test_tile_grid_selection.py
 tests/test_tile_selector_pick.py