tilemap-editor 4.3.9__tar.gz → 4.4.0__tar.gz

{tilemap_editor-4.3.9 → tilemap_editor-4.4.0}/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Changelog
 
 <!-- towncrier release notes start -->
+# tilemap_editor 4.4.0 (2026-08-19)
+
+## Features
+
+- Property editor: added a remove button for individual properties and object-level property support. Right-clicking a map object, tileset image, or tree row now opens the property editor through a context dispatch system, and object properties can be edited on the placed object directly. (context-property-editor)
+
+## Bug Fixes
+
+- Object picking on object layers now hits the visually topmost overlapping object: right-click property open and left-click variant select test objects in reverse draw order. (object-pick-order)
+
 # tilemap_editor 4.3.9 (2026-08-04)
 
 ## Bug Fixes

{tilemap_editor-4.3.9/src/tilemap_editor.egg-info → tilemap_editor-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 4.3.9
+Version: 4.4.0
 Summary: Pygame tilemap editor with collision, animation, sprite & particle tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-4.3.9 → tilemap_editor-4.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "4.3.9"
+version = "4.4.0"
 description = "Pygame tilemap editor with collision, animation, sprite & particle tools"
 readme = "README.md"
 requires-python = ">=3.11"

{tilemap_editor-4.3.9 → tilemap_editor-4.4.0}/src/editor.py

@@ -21,6 +21,7 @@ from constants import BASE_PATH
 from node_manager import NodeManager
 from tilemap import Tilemap
 from utils import error_context, error_handler
+from utils.context_dispatch import PropertyContextDispatcher
 from utils.property_suggestions import PropertySuggestionRegistry
 from utils.standalone import launch_standalone
 from widgets.autotiler import AutotileRuleDesigner
@@ -214,6 +215,7 @@ class Editor:
         self.notifications = NotificationManager(self)
         self.tooltip = TooltipManager()
         self.suggestion_registry = PropertySuggestionRegistry()
+        self.context_dispatch = PropertyContextDispatcher()
         self.error_console_process: subprocess.Popen | None = None
         self.property_editor: PropertyEditor | None = None
         self.particle_config_dialog: ParticleConfigDialog | None = None

{tilemap_editor-4.3.9 → tilemap_editor-4.4.0/src/tilemap_editor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 4.3.9
+Version: 4.4.0
 Summary: Pygame tilemap editor with collision, animation, sprite & particle tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-4.3.9 → tilemap_editor-4.4.0}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -161,6 +161,7 @@ src/tilemap_editor/assets/icons/zoomout.svg
 src/ttypes/__init__.py
 src/ttypes/tilemap.py
 src/utils/__init__.py
+src/utils/context_dispatch.py
 src/utils/editor_preference.py
 src/utils/error_handler.py
 src/utils/font_manager.py
@@ -223,12 +224,14 @@ src/widgets/ui/tree_widget.py
 tests/test_animation_library_grid_offset.py
 tests/test_collision_layer_mask.py
 tests/test_collision_layer_sidebar.py
+tests/test_context_dispatch.py
 tests/test_drag_tracker.py
 tests/test_editor_pan_mode.py
 tests/test_gid_collision.py
 tests/test_layers_autotile.py
 tests/test_map_resize_model.py
 tests/test_natural_sort.py
+tests/test_object_properties_context.py
 tests/test_project_paths.py
 tests/test_render_scale.py
 tests/test_serialization_regression.py

tilemap_editor-4.4.0/src/utils/context_dispatch.py

@@ -0,0 +1,83 @@
+"""Context-based property event dispatch.
+
+Godot-style "context slots": widgets emit a ``PropertyContext`` describing
+what was clicked (right-click on map object, tileset image, tree row, ...);
+the dispatcher routes it to the registered opener (shows the PropertyEditor)
+or saver (applies the saved properties to the context target).
+
+Same input event everywhere, the context decides the polymorphic handler.
+Unregistered kinds no-op cleanly (Qt-style propagation fallback).
+
+Example::
+
+    editor.context_dispatch.open(PropertyContext(ContextKind.TILESET, ts))
+"""
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Any
+
+
+class ContextKind(Enum):
+    """What was clicked / is being edited."""
+
+    TILESET = auto()       # whole-tileset properties
+    TILE_VARIANT = auto()  # per-tile properties (grid tilesets)
+    MAP_OBJECT = auto()    # placed object on an object layer
+    NODE = auto()          # node (area / particle_emitter / group)
+    LAYER = auto()         # layer
+
+
+@dataclass
+class PropertyContext:
+    """Context for an open/save property event.
+
+    ``target`` is the typed object the event refers to (TilesetData, Node,
+    Layer, ...). ``extra`` carries kind-specific data (e.g. variant_ids).
+    """
+
+    kind: ContextKind
+    target: Any = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+
+Opener = Callable[[PropertyContext], None]
+Saver = Callable[[PropertyContext, dict[str, Any]], None]
+
+
+# TODO(dispatcher): temporary shared callback channel. Planned refactor: route
+# property open/save through the Editor reference (self.editor) and direct
+# widget/manager calls instead of registered openers/savers.
+class PropertyContextDispatcher:
+    """Routes property open/save events by context kind.
+
+    One registered handler per kind; dispatch is a no-op for unregistered
+    kinds so new contexts can be introduced without breaking old ones.
+    """
+
+    def __init__(self):
+        self._openers: dict[ContextKind, Opener] = {}
+        self._savers: dict[ContextKind, Saver] = {}
+
+    def register_opener(self, kind: ContextKind, opener: Opener) -> None:
+        self._openers[kind] = opener
+
+    def register_saver(self, kind: ContextKind, saver: Saver) -> None:
+        self._savers[kind] = saver
+
+    def open(self, ctx: PropertyContext) -> bool:
+        """Show the property editor for the context. Returns True if handled."""
+        opener = self._openers.get(ctx.kind)
+        if opener is None:
+            return False
+        opener(ctx)
+        return True
+
+    def save(self, ctx: PropertyContext, props: dict[str, Any]) -> bool:
+        """Apply saved properties to the context target. Returns True if handled."""
+        saver = self._savers.get(ctx.kind)
+        if saver is None:
+            return False
+        saver(ctx, props)
+        return True

{tilemap_editor-4.3.9 → tilemap_editor-4.4.0}/src/widgets/layer_selector.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING
 import pygame
 from pygame import Rect, Surface
 
-from layers import Layer
+from utils.context_dispatch import ContextKind, PropertyContext
 from widgets.ui.button import Button
 from widgets.ui.property_editor import PropertyEditor
 from widgets.ui.theme import COLORS, FONTS, SHAPE
@@ -65,6 +65,10 @@ class LayerSelector:
         self.font_header = FONTS.get_bold_font(FONTS.size_md)
         self.font_layer = FONTS.get_small_font()
 
+        d = self.editor.context_dispatch
+        d.register_opener(ContextKind.LAYER, self._open_layer_properties)
+        d.register_saver(ContextKind.LAYER, self._save_layer_properties)
+
     def resize(self, x: int, y: int, w: int, h: int):
         self.rect = Rect(x, y, w, h)
         self.header_rect = Rect(x, y, w, self.header_h)
@@ -149,14 +153,8 @@ class LayerSelector:
                     if layer_idx is not None:
                         layer = self.editor.tilemap.layer_manager.get_layer(layer_idx)
                         if layer:
-                            self.editor.property_editor = PropertyEditor(
-                                self.editor,
-                                f"Layer Properties: {layer.name}",
-                                layer.properties,
-                                on_save=lambda props: self._save_layer_properties(
-                                    layer, props
-                                ),
-                                on_close=lambda: None,
+                            self.editor.context_dispatch.open(
+                                PropertyContext(ContextKind.LAYER, layer)
                             )
                         return True
 
@@ -406,7 +404,17 @@ class LayerSelector:
         self.rename_text = ""
         self.rename_original_name = ""
 
-    def _save_layer_properties(self, layer: Layer, props: dict):
+    def _open_layer_properties(self, ctx: PropertyContext) -> None:
+        layer = ctx.target
+        self.editor.property_editor = PropertyEditor(
+            self.editor,
+            f"Layer Properties: {layer.name}",
+            layer.properties,
+            context=ctx,
+        )
+
+    def _save_layer_properties(self, ctx: PropertyContext, props: dict):
+        layer = ctx.target
         layer.properties = props
         self.editor.suggestion_registry.refresh(self.editor)
         print(f"Saved properties for layer: {layer.name}")
@@ -547,7 +555,7 @@ class LayerSelector:
             if ysort_rect:
                 ysort_color = COLORS.accent if layer.y_sort else COLORS.text_dim
                 pygame.draw.rect(
-                    screen, ysort_color, ysort_rect, 
+                    screen, ysort_color, ysort_rect,
                     border_radius=SHAPE.radius_sm,
                 )
                 ysort_txt = self.font_layer.render("Y", True, COLORS.text)

{tilemap_editor-4.3.9 → tilemap_editor-4.4.0}/src/widgets/tile_grid.py

@@ -5,6 +5,7 @@ from pygame import K_LEFT, K_RIGHT, K_UP, Rect, Surface
 
 from nodes import NodeRect
 from ttypes.tilemap import TypeObject, TypeTile
+from utils.context_dispatch import ContextKind, PropertyContext
 from widgets.particle_system import MAX_DT, ParticlePreview
 from widgets.ui.drag_tracker import DragTracker
 from widgets.ui.theme import COLORS
@@ -429,7 +430,7 @@ class TileGrid:
                     return True
 
             if event.button == 3:
-                if is_hovering and self.hover_cell:
+                if is_hovering and self.hover_cell and not self._open_object_properties_if_hit(mouse_pos):
                     self.pick_tile_at(self.hover_cell)
                 return True
 
@@ -777,7 +778,7 @@ class TileGrid:
             world_pos = self.screen_to_world(mouse_pos)
             rs = self.editor.tilemap.render_scale
             pick_pos = (int(world_pos[0] / rs), int(world_pos[1] / rs)) if rs else world_pos
-            for _obj_id, obj in active_layer.get_all_objects().items():
+            for _obj_id, obj in reversed(list(active_layer.get_all_objects().items())):
                 area = obj["area"]
                 obj_rect = Rect(area["x"], area["y"], area["w"], area["h"])
                 if obj_rect.collidepoint(pick_pos):
@@ -786,6 +787,43 @@ class TileGrid:
                     ts_widget.select_tile_by_variant(ttype, variant)
                     return
 
+    def _open_object_properties_if_hit(self, mouse_pos: tuple[int, int]) -> bool:
+        """Open the placed object's own properties under the cursor.
+
+        Returns True when an object was hit (event consumed), False otherwise
+        so the caller can fall back to the eyedropper behavior.
+        """
+        active_layer = self.editor.tilemap.layer_manager.get_active_layer()
+        if not active_layer or active_layer.layer_type != "object":
+            return False
+
+        ts_widget = self.editor.tileset_widget
+        if not ts_widget:
+            return False
+
+        world_pos = self.screen_to_world(mouse_pos)
+        rs = self.editor.tilemap.render_scale
+        pick_pos = (int(world_pos[0] / rs), int(world_pos[1] / rs)) if rs else world_pos
+
+        for obj_id, obj in reversed(list(active_layer.get_all_objects().items())):
+            area = obj["area"]
+            obj_rect = Rect(area["x"], area["y"], area["w"], area["h"])
+            if obj_rect.collidepoint(pick_pos):
+                ts = ts_widget.get_tileset_by_index(int(obj["ttype"]))
+                self.editor.context_dispatch.open(
+                    PropertyContext(
+                        ContextKind.MAP_OBJECT,
+                        obj,
+                        {
+                            "obj_id": obj_id,
+                            "layer_name": active_layer.name,
+                            "tileset_name": ts.name if ts else None,
+                        },
+                    )
+                )
+                return True
+        return False
+
     def _point_in_selection(self, grid_pos: tuple[int, int]) -> bool:
         """Check if a grid position is inside the current selection."""
         if not self.selection_rect:

{tilemap_editor-4.3.9 → tilemap_editor-4.4.0}/src/widgets/tile_selector.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any
 import pygame
 from pygame import Rect
 
+from utils.context_dispatch import ContextKind, PropertyContext
 from utils.error_handler import error_handler
 from utils.validation import is_image_multipleof
 from widgets.ui.button import Button
@@ -77,6 +78,17 @@ class TileSelector(WidgetBase):
         self.zoom: float = 1.0
         self.font = FONTS.get_medium_font()
 
+        self._register_context_handlers()
+
+    def _register_context_handlers(self):
+        d = self.editor.context_dispatch
+        d.register_opener(ContextKind.TILESET, self._open_tileset_properties)
+        d.register_saver(ContextKind.TILESET, self._save_tileset_properties)
+        d.register_opener(ContextKind.TILE_VARIANT, self._open_tile_variant_properties)
+        d.register_saver(ContextKind.TILE_VARIANT, self._save_tile_properties_multi)
+        d.register_opener(ContextKind.MAP_OBJECT, self._open_object_properties)
+        d.register_saver(ContextKind.MAP_OBJECT, self._save_object_properties)
+
     def _add_folder(self) -> None:
         self._folder_id_counter += 1
         folder = TreeNode(
@@ -113,14 +125,52 @@ class TileSelector(WidgetBase):
         ts = self._ts_node(item_id)
         if ts is None:
             return
+        self.editor.context_dispatch.open(PropertyContext(ContextKind.TILESET, ts))
+
+    def _open_tileset_properties(self, ctx: PropertyContext) -> None:
+        ts = ctx.target
         self.editor.property_editor = PropertyEditor(
             self.editor,
             f"Tileset Properties: {ts.name}",
             ts.properties,
-            on_save=lambda props: self._save_tileset_properties(ts, props),
-            on_close=lambda: None,
+            context=ctx,
+        )
+
+    def _open_tile_variant_properties(self, ctx: PropertyContext) -> None:
+        ts = ctx.target
+        variant_ids = ctx.extra.get("variant_ids", [])
+        if not variant_ids:
+            return
+        variant_id = variant_ids[0]
+        self.editor.property_editor = PropertyEditor(
+            self.editor,
+            f"Tile Properties: {ts.name} (ID: {variant_id})",
+            ts.tile_properties.get(variant_id, {}),
+            context=ctx,
         )
 
+    def _open_object_properties(self, ctx: PropertyContext) -> None:
+        obj = ctx.target
+        if obj is None:
+            return
+        title = f"Object Properties: {ctx.extra.get('layer_name', '')} #{ctx.extra.get('obj_id', '?')}"
+        ts_name = ctx.extra.get("tileset_name")
+        if ts_name:
+            title = f"{title} ({ts_name})"
+        self.editor.property_editor = PropertyEditor(
+            self.editor,
+            title,
+            obj.get("properties", {}),
+            context=ctx,
+        )
+
+    def _save_object_properties(self, ctx: PropertyContext, props: dict) -> None:
+        obj = ctx.target
+        if obj is None:
+            return
+        obj["properties"] = props
+        self.editor.suggestion_registry.refresh(self.editor)
+
     def _on_tree_structure_changed(self) -> None:
         pass
 
@@ -221,11 +271,14 @@ class TileSelector(WidgetBase):
 
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 3:
             if self.view_rect.collidepoint(mouse_pos) and self.active_idx != -1:
+                ts = self.tilesets[self.active_idx]
+                if ts.tileset_type == "object":
+                    self.editor.context_dispatch.open(
+                        PropertyContext(ContextKind.TILESET, ts)
+                    )
+                    return True
                 if self.selected_tile:
                     sx, sy, sw, sh = self.selected_tile
-                    ts = self.tilesets[self.active_idx]
-                    if ts.tileset_type == "object":
-                        return True
                     img_x = self.view_rect.x + ts.offset[0]
                     img_y = self.view_rect.y + ts.offset[1]
                     sel_rect = Rect(img_x + sx, img_y + sy, sw, sh)
@@ -235,20 +288,18 @@ class TileSelector(WidgetBase):
                         if not variant_ids:
                             return True
 
-                        variant_id = variant_ids[0]
-
-                        self.editor.property_editor = PropertyEditor(
-                            self.editor,
-                            f"Tile Properties: {ts.name} (ID: {variant_id})",
-                            ts.tile_properties.get(variant_id, {}),
-                            on_save=lambda props: self._save_tile_properties_multi(ts, variant_ids, props),
-                            on_close=lambda: None,
+                        self.editor.context_dispatch.open(
+                            PropertyContext(
+                                ContextKind.TILE_VARIANT,
+                                ts,
+                                {"variant_ids": variant_ids},
+                            )
                         )
                         return True
 
                 self.is_panning = True
                 self.pan_start = mouse_pos
-                self.pan_start_offset = tuple(self.tilesets[self.active_idx].offset)
+                self.pan_start_offset = tuple(ts.offset)
                 return True
 
         elif event.type == pygame.MOUSEBUTTONUP and event.button == 3:
@@ -289,9 +340,19 @@ class TileSelector(WidgetBase):
                 ts = self.tilesets[self.active_idx]
                 img_x = self.view_rect.x + ts.offset[0]
                 img_y = self.view_rect.y + ts.offset[1]
-
                 rel_x = (mouse_pos[0] - img_x) / self.zoom
                 rel_y = (mouse_pos[1] - img_y) / self.zoom
+                if ts.tileset_type == "object":
+                    if (
+                        0 <= rel_x < ts.surface.get_width()
+                        and 0 <= rel_y < ts.surface.get_height()
+                    ):
+                        self.hover_pos = (0, 0)
+                    else:
+                        self.hover_pos = None
+                    self.is_selecting = False
+                    self.selection_start_grid = None
+                    return True
 
                 if 0 <= rel_x < ts.surface.get_width() and 0 <= rel_y < ts.surface.get_height():
                     tw, th = self.editor.tilemap.tile_size
@@ -574,7 +635,8 @@ class TileSelector(WidgetBase):
 
         self.editor.launch_collision_editor(ts.tileset_type)
 
-    def _save_tileset_properties(self, ts: TilesetData, props: dict):
+    def _save_tileset_properties(self, ctx: PropertyContext, props: dict):
+        ts = ctx.target
         ts.properties = props
         self.editor.suggestion_registry.refresh(self.editor)
         print(f"Saved properties for tileset: {ts.name}")
@@ -583,7 +645,9 @@ class TileSelector(WidgetBase):
         ts.tile_properties[variant_id] = props
         print(f"Saved properties for tile {variant_id} in tileset: {ts.name}")
 
-    def _save_tile_properties_multi(self, ts: TilesetData, variant_ids: list[int], props: dict):
+    def _save_tile_properties_multi(self, ctx: PropertyContext, props: dict):
+        ts = ctx.target
+        variant_ids = ctx.extra.get("variant_ids", [])
         for vid in variant_ids:
             ts.tile_properties[vid] = props.copy()
         self.editor.suggestion_registry.refresh(self.editor)
@@ -613,6 +677,11 @@ class TileSelector(WidgetBase):
             return None
         return self.tilesets[self.active_idx]
 
+    def get_tileset_by_index(self, index: int) -> TilesetData | None:
+        if index < 0 or index >= len(self.tilesets):
+            return None
+        return self.tilesets[index]
+
     def select_tile_by_variant(self, tileset_index: int, variant_id: int) -> bool:
         if tileset_index < 0 or tileset_index >= len(self.tilesets):
             return False
@@ -802,6 +871,8 @@ class TileSelector(WidgetBase):
     def draw_hover(self, screen, ts: TilesetData, img_x: int, img_y: int):
         if self.hover_pos is None:
             return
+        if ts.tileset_type == "object":
+            return
         tw, th = self.editor.tilemap.tile_size
         col, row = self.hover_pos
         ztw = int(tw * self.zoom)

{tilemap_editor-4.3.9 → tilemap_editor-4.4.0}/src/widgets/ui/button.py

@@ -20,6 +20,7 @@ class Button(WidgetBase):
         font=None,
         text_color=None,
         accent=False,
+        danger=False,
         bg=None,
         border_color=None,
         border_radius=None,
@@ -43,6 +44,7 @@ class Button(WidgetBase):
         self.font = font or FONTS.get_medium_font()
         self._text_color = text_color
         self.accent = accent
+        self.danger = danger
         self.on_click = on_click
         self._active = False
         self._hovered = False
@@ -92,18 +94,30 @@ class Button(WidgetBase):
             border = COLORS.border
             text_color = self._text_color or COLORS.text
         elif self._pressed:
-            bg = COLORS.accent_active if self.accent else COLORS.header
+            bg = (
+                COLORS.accent_active
+                if self.accent
+                else (COLORS.danger_hover if self.danger else COLORS.header)
+            )
             border = COLORS.border
             text_color = self._text_color or COLORS.text
         elif self._hovered:
-            bg = COLORS.accent_hover if self.accent else COLORS.hover
+            bg = (
+                COLORS.accent_hover
+                if self.accent
+                else (COLORS.danger_hover if self.danger else COLORS.hover)
+            )
             border = COLORS.border
             text_color = self._text_color or COLORS.text
         else:
             bg = (
                 self._bg
                 if self._bg is not None
-                else (COLORS.accent if self.accent else COLORS.panel_alt)
+                else (
+                    COLORS.accent
+                    if self.accent
+                    else COLORS.danger if self.danger else COLORS.panel_alt
+                )
             )
             border = self._border if self._border is not None else COLORS.border_soft
             text_color = self._text_color or COLORS.text

{tilemap_editor-4.3.9 → tilemap_editor-4.4.0}/src/widgets/ui/node_editor.py

@@ -5,6 +5,7 @@ from pygame import Rect
 
 if TYPE_CHECKING:
     from editor import Editor
+from utils.context_dispatch import ContextKind, PropertyContext
 from utils.font_manager import FontWeight, font_manager
 from widgets.particle_presets import PRESETS, get_preset_config, get_preset_names
 from widgets.ui.draw_utils import draw_panel
@@ -37,6 +38,10 @@ class NodeEditor:
         self._preset_names: list[str] = get_preset_names()
         self._is_particle = False
 
+        d = self.editor.context_dispatch
+        d.register_opener(ContextKind.NODE, self._open_node_properties)
+        d.register_saver(ContextKind.NODE, self._save_props)
+
     def resize(self, x: int, y: int, w: int):
         self.rect = Rect(x, y, w, self.rect.height)
 
@@ -215,12 +220,8 @@ class NodeEditor:
                         if action == "props":
                             node = mgr.get_active_node()
                             if node:
-                                self.editor.property_editor = PropertyEditor(
-                                    self.editor,
-                                    f"Node Properties: {node.name}",
-                                    dict(node.properties),
-                                    on_save=lambda props: self._save_props(props),
-                                    on_close=lambda: None,
+                                self.editor.context_dispatch.open(
+                                    PropertyContext(ContextKind.NODE, node)
                                 )
                         elif action == "particle":
                             node = mgr.get_active_node()
@@ -352,8 +353,19 @@ class NodeEditor:
         except (ValueError, TypeError):
             return default
 
-    def _save_props(self, props: dict):
-        node = self.editor.node_manager.get_active_node()
+    def _open_node_properties(self, ctx: PropertyContext) -> None:
+        node = ctx.target
+        if node is None:
+            return
+        self.editor.property_editor = PropertyEditor(
+            self.editor,
+            f"Node Properties: {node.name}",
+            dict(node.properties),
+            context=ctx,
+        )
+
+    def _save_props(self, ctx: PropertyContext, props: dict):
+        node = ctx.target
         if node:
             node.properties = props
             self.editor.suggestion_registry.refresh(self.editor)