tilemap-editor 3.2.4__tar.gz → 3.2.6__tar.gz

{tilemap_editor-3.2.4/src/tilemap_editor.egg-info → tilemap_editor-3.2.6}/PKG-INFO

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

{tilemap_editor-3.2.4 → tilemap_editor-3.2.6}/pyproject.toml

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

{tilemap_editor-3.2.4 → tilemap_editor-3.2.6}/src/editor.py

@@ -27,6 +27,7 @@ from widgets.tile_grid import TileGrid
 from widgets.layer_selector import LayerSelector
 from widgets.ui.fileinput import FilenameInput
 from widgets.ui.tileset_type_dialog import TilesetTypeDialog
+from widgets.ui.confirm_dialog import ConfirmDialog
 from widgets.ui.layer_type_dialog import LayerTypeDialog
 from widgets.ui.menubar import MenuBar
 from widgets.ui.toolbar import Toolbar
@@ -208,6 +209,7 @@ class Editor:
             on_cancel=lambda: None,
         )
         self.tileset_type_dialog = TilesetTypeDialog(editor_rect)
+        self.confirm_dialog = ConfirmDialog(editor_rect)
         self.layer_type_dialog = LayerTypeDialog(editor_rect)
 
         self.menubar = MenuBar(self, self.width, 30)
@@ -542,6 +544,8 @@ class Editor:
 
         if hasattr(self, "tileset_type_dialog") and self.tileset_type_dialog:
             self.tileset_type_dialog.editor_rect = rect_full
+        if hasattr(self, "confirm_dialog") and self.confirm_dialog:
+            self.confirm_dialog.editor_rect = rect_full
         if hasattr(self, "layer_type_dialog") and self.layer_type_dialog:
             self.layer_type_dialog.editor_rect = rect_full
 
@@ -1052,6 +1056,10 @@ class Editor:
                 self.tileset_type_dialog.handle_event(event)
                 continue
 
+            if self.confirm_dialog.active:
+                self.confirm_dialog.handle_event(event)
+                continue
+
             if self.layer_type_dialog.active:
                 self.layer_type_dialog.handle_event(event)
                 continue
@@ -1261,6 +1269,11 @@ class Editor:
                 overlay.fill((0, 0, 0, 150))
                 self.screen.blit(overlay, (0, 0))
                 self.tileset_type_dialog.draw(self.screen)
+            if self.confirm_dialog.active:
+                overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
+                overlay.fill((0, 0, 0, 150))
+                self.screen.blit(overlay, (0, 0))
+                self.confirm_dialog.draw(self.screen)
             if self.layer_type_dialog.active:
                 overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
                 overlay.fill((0, 0, 0, 150))

{tilemap_editor-3.2.4 → tilemap_editor-3.2.6/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.2.4 → tilemap_editor-3.2.6}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -164,6 +164,7 @@ src/widgets/tile_grid.py
 src/widgets/tile_selector.py
 src/widgets/ui/collision_layer_mask.py
 src/widgets/ui/collision_layer_sidebar.py
+src/widgets/ui/confirm_dialog.py
 src/widgets/ui/draw_utils.py
 src/widgets/ui/fileinput.py
 src/widgets/ui/layer_type_dialog.py

{tilemap_editor-3.2.4 → tilemap_editor-3.2.6}/src/widgets/layer_selector.py

@@ -382,13 +382,6 @@ class LayerSelector:
             pygame.draw.rect(screen, color, item_rect)
             pygame.draw.rect(screen, COLORS.border_soft, item_rect, 1)
 
-            if i == self.renaming_layer_idx:
-                pygame.draw.rect(
-                    screen,
-                    COLORS.selected,
-                    Rect(item_rect.x + 4, item_rect.y + 4, 120, 20),
-                    border_radius=SHAPE.radius_sm,
-                )
             mx, my = pygame.mouse.get_pos()
             eye_rect = self._get_eye_icon_rect(i, (mx, my))
             lock_rect = self._get_lock_icon_rect(i, (mx, my))
@@ -396,13 +389,20 @@ class LayerSelector:
                 self.editor.tooltip.show("Toggle Visibility", (mx + 10, my + 10))
             elif lock_rect and lock_rect.collidepoint(mx, my):
                 self.editor.tooltip.show("Toggle Lock", (mx + 10, my + 10))
+
+            if i == self.renaming_layer_idx:
+                pygame.draw.rect(
+                    screen,
+                    COLORS.selected,
+                    Rect(item_rect.x + 4, item_rect.y + 4, 120, 20),
+                    border_radius=SHAPE.radius_sm,
+                )
                 name_txt = self.font_layer.render(
                     self.rename_text + "|", True, self.text_color
                 )
-                screen.blit(name_txt, (item_rect.x + 5, item_rect.y + 5))
             else:
                 name_txt = self.font_layer.render(layer.name, True, self.text_color)
-                screen.blit(name_txt, (item_rect.x + 5, item_rect.y + 5))
+            screen.blit(name_txt, (item_rect.x + 5, item_rect.y + 5))
 
             eye_x = item_rect.right - 25
             eye_y = item_rect.y + 7

{tilemap_editor-3.2.4 → tilemap_editor-3.2.6}/src/widgets/tile_selector.py

@@ -348,66 +348,56 @@ class TileSelector:
         if path.exists():
             try:
                 surf = pygame.image.load(path).convert_alpha()
-                if tileset_type == "object" or is_image_multipleof(
-                    surf.get_size(), self.editor.tilemap.tile_size
-                ):
-                    tileset_data = TilesetData(
-                        path.name, path, surf, tileset_type=tileset_type
-                    )
-                    tileset_data.properties = properties
-                    # Convert string keys back to int if necessary
-                    tileset_data.tile_properties = {
-                        int(k): v for k, v in tile_properties.items()
-                    }
-                    self._load_collision_data_for_tileset(tileset_data)
-
-                    self.tilesets.append(tileset_data)
-                    self.active_idx = len(self.tilesets) - 1
-                    self.tileset_map[self.active_idx] = tileset_data
-                    if tileset_type == "object":
-                        self.selected_tile = (0, 0, surf.get_width(), surf.get_height())
-                else:
-                    print("Tileset isnt multiple of tile size")
+                tileset_data = TilesetData(
+                    path.name, path, surf, tileset_type=tileset_type
+                )
+                tileset_data.properties = properties
+                tileset_data.tile_properties = {
+                    int(k): v for k, v in tile_properties.items()
+                }
+                self._load_collision_data_for_tileset(tileset_data)
+
+                self.tilesets.append(tileset_data)
+                self.active_idx = len(self.tilesets) - 1
+                self.tileset_map[self.active_idx] = tileset_data
+                if tileset_type == "object":
+                    self.selected_tile = (0, 0, surf.get_width(), surf.get_height())
             except Exception as e:
                 error_handler.capture(e, context="load_tileset_surface")
 
     def _on_tileset_type_selected(self, tileset_type: str):
         """Callback when user selects tileset type from dialog."""
-        print(f"DEBUG: Tileset type selected: {tileset_type}")
         if not hasattr(self, "_pending_tileset_path"):
-            print("DEBUG: No pending tileset path!")
             return
 
-        path = self._pending_tileset_path
         surf = self._pending_tileset_surf
 
         if tileset_type == "tile" and not is_image_multipleof(
             surf.get_size(), self.editor.tilemap.tile_size
         ):
-            self.editor.notifications.error(
-                "Tileset size must be multiple of tile size"
+            w, h = surf.get_size()
+            tw, th = self.editor.tilemap.tile_size
+            self.editor.confirm_dialog.show(
+                title="Tileset Size Warning",
+                message=f"Image size ({w}x{h}) is not an exact multiple of tile size ({tw}x{th}). "
+                f"Some pixels at the edges will be ignored. Proceed?",
+                on_confirm=lambda: self._commit_tileset_load(tileset_type),
+                on_cancel=self._on_tileset_type_cancel,
             )
-            delattr(self, "_pending_tileset_path")
-            delattr(self, "_pending_tileset_surf")
-            if self._pending_tileset_queue:
-                error_handler.capture(
-                    Exception(
-                        f"Queue error continuation: {len(self._pending_tileset_queue)} items"
-                    ),
-                    context="tileset_queue_error",
-                    severity="info",
-                )
-                # Delay slightly to allow dialog to fully close
-                pygame.time.set_timer(pygame.USEREVENT + 1, 100, 1)
-                self._queue_timer_active = True
             return
 
+        self._commit_tileset_load(tileset_type)
+
+    def _commit_tileset_load(self, tileset_type: str):
+        path = self._pending_tileset_path
+        surf = self._pending_tileset_surf
+
         tileset_data = TilesetData(path.name, path, surf, tileset_type=tileset_type)
         self._load_collision_data_for_tileset(tileset_data)
         self.tilesets.append(tileset_data)
         self.active_idx = len(self.tilesets) - 1
         self.tileset_map[self.active_idx] = tileset_data
-        print(f"DEBUG: Added tileset {path.name}, total tilesets: {len(self.tilesets)}")
+
         if tileset_type == "object":
             self.selected_tile = (0, 0, surf.get_width(), surf.get_height())
         else:
@@ -416,14 +406,8 @@ class TileSelector:
         delattr(self, "_pending_tileset_path")
         delattr(self, "_pending_tileset_surf")
         if self._pending_tileset_queue:
-            print(
-                f"DEBUG: Continuing queue, {len(self._pending_tileset_queue)} items remaining"
-            )
-            # Delay slightly to allow dialog to fully close
             pygame.time.set_timer(pygame.USEREVENT + 1, 100, 1)
             self._queue_timer_active = True
-        else:
-            print("DEBUG: Queue processing complete")
 
     def _load_collision_data_for_tileset(self, tileset_data: TilesetData) -> None:
         """Attach existing collision data for tilesets that have sidecar files."""

tilemap_editor-3.2.6/src/widgets/ui/confirm_dialog.py

@@ -0,0 +1,149 @@
+import pygame
+from pygame import Rect, Surface
+from typing import Callable, Optional
+
+
+class ConfirmDialog:
+    def __init__(self, editor_rect: Rect):
+        self.editor_rect = editor_rect
+        self.rect = Rect(0, 0, 420, 180)
+        self.rect.center = editor_rect.center
+
+        self.active = False
+        self.title = ""
+        self.message = ""
+        self.on_confirm: Optional[Callable[[], None]] = None
+        self.on_cancel: Optional[Callable[[], None]] = None
+
+        self.bg_color = (40, 40, 40)
+        self.border_color = (100, 100, 100)
+        self.text_color = (255, 255, 255)
+        self.warn_color = (255, 200, 60)
+        self.button_color = (60, 100, 180)
+        self.button_hover_color = (80, 120, 200)
+
+        self.btn_proceed = Rect(0, 0, 110, 30)
+        self.btn_cancel = Rect(0, 0, 110, 30)
+
+        self.font_title = pygame.font.SysFont("Arial", 18, bold=True)
+        self.font_text = pygame.font.SysFont("Arial", 14)
+        self.font_btn = pygame.font.SysFont("Arial", 14, bold=True)
+
+        self.btn_proceed_hover = False
+        self.btn_cancel_hover = False
+        self._layout()
+
+    def _layout(self):
+        self.rect.center = self.editor_rect.center
+        btn_y = self.rect.bottom - 50
+        cx = self.rect.centerx
+        self.btn_cancel = Rect(cx - 120, btn_y, 110, 30)
+        self.btn_proceed = Rect(cx + 10, btn_y, 110, 30)
+
+    def show(
+        self,
+        title: str,
+        message: str,
+        on_confirm: Callable[[], None],
+        on_cancel: Callable[[], None],
+    ):
+        if self.active:
+            self.hide()
+        self.active = True
+        self.title = title
+        self.message = message
+        self.on_confirm = on_confirm
+        self.on_cancel = on_cancel
+        self.btn_proceed_hover = False
+        self.btn_cancel_hover = False
+        self._layout()
+
+    def hide(self):
+        self.active = False
+
+    def handle_event(self, event: pygame.event.Event) -> bool:
+        if not self.active:
+            return False
+
+        self._layout()
+        mouse_pos = pygame.mouse.get_pos()
+
+        if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+            if self.btn_proceed.collidepoint(mouse_pos):
+                if self.on_confirm:
+                    self.on_confirm()
+                self.hide()
+                return True
+            if self.btn_cancel.collidepoint(mouse_pos):
+                if self.on_cancel:
+                    self.on_cancel()
+                self.hide()
+                return True
+
+        elif event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_ESCAPE:
+                if self.on_cancel:
+                    self.on_cancel()
+                self.hide()
+                return True
+            elif event.key == pygame.K_RETURN:
+                if self.on_confirm:
+                    self.on_confirm()
+                self.hide()
+                return True
+
+        elif event.type == pygame.MOUSEMOTION:
+            self.btn_proceed_hover = self.btn_proceed.collidepoint(mouse_pos)
+            self.btn_cancel_hover = self.btn_cancel.collidepoint(mouse_pos)
+
+        return False
+
+    def draw(self, surface: Surface):
+        if not self.active:
+            return
+
+        self._layout()
+        pygame.draw.rect(surface, self.bg_color, self.rect)
+        pygame.draw.rect(surface, self.border_color, self.rect, 2)
+
+        title_surf = self.font_title.render(self.title, True, self.warn_color)
+        title_rect = title_surf.get_rect(topleft=(self.rect.x + 20, self.rect.y + 15))
+        surface.blit(title_surf, title_rect)
+
+        lines = self._wrap_text(self.message, self.rect.width - 40)
+        y = self.rect.y + 50
+        for line in lines:
+            line_surf = self.font_text.render(line, True, self.text_color)
+            surface.blit(line_surf, (self.rect.x + 20, y))
+            y += 22
+
+        proceed_color = self.button_hover_color if self.btn_proceed_hover else self.button_color
+        cancel_color = self.button_hover_color if self.btn_cancel_hover else (60, 60, 60)
+
+        pygame.draw.rect(surface, cancel_color, self.btn_cancel)
+        pygame.draw.rect(surface, proceed_color, self.btn_proceed)
+
+        cancel_text = self.font_btn.render("Cancel", True, self.text_color)
+        proceed_text = self.font_btn.render("Proceed", True, self.text_color)
+
+        cancel_text_rect = cancel_text.get_rect(center=self.btn_cancel.center)
+        proceed_text_rect = proceed_text.get_rect(center=self.btn_proceed.center)
+
+        surface.blit(cancel_text, cancel_text_rect)
+        surface.blit(proceed_text, proceed_text_rect)
+
+    def _wrap_text(self, text: str, max_width: int):
+        words = text.split()
+        lines = []
+        current = ""
+        for word in words:
+            test = f"{current} {word}".strip()
+            if self.font_text.size(test)[0] <= max_width:
+                current = test
+            else:
+                if current:
+                    lines.append(current)
+                current = word
+        if current:
+            lines.append(current)
+        return lines