tilemap-editor 4.3.5__tar.gz → 4.3.6__tar.gz

{tilemap_editor-4.3.5/src/tilemap_editor.egg-info → tilemap_editor-4.3.6}/PKG-INFO

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

{tilemap_editor-4.3.5 → tilemap_editor-4.3.6}/pyproject.toml

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

{tilemap_editor-4.3.5 → tilemap_editor-4.3.6}/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.property_suggestions import PropertySuggestionRegistry
 from utils.standalone import launch_standalone
 from widgets.autotiler import AutotileRuleDesigner
 from widgets.layer_selector import LayerSelector
@@ -212,6 +213,7 @@ class Editor:
         self.regex_automap_designer = RegexAutomapDesigner(self, 150, 100)
         self.notifications = NotificationManager(self)
         self.tooltip = TooltipManager()
+        self.suggestion_registry = PropertySuggestionRegistry()
         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.5 → tilemap_editor-4.3.6}/src/tilemap.py

@@ -623,6 +623,8 @@ class Tilemap:
             if hasattr(self.editor, "node_selector"):
                 self.editor.node_selector._rebuild_filter()
 
+        if hasattr(self.editor, "suggestion_registry"):
+            self.editor.suggestion_registry.refresh(self.editor)
         self.initialized = True
 
         if self.editor.tile_grid_widget:

{tilemap_editor-4.3.5 → tilemap_editor-4.3.6/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-4.3.5 → tilemap_editor-4.3.6}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -159,6 +159,7 @@ src/utils/icon_manager.py
 src/utils/icons_cache.py
 src/utils/log_capture.py
 src/utils/project_paths.py
+src/utils/property_suggestions.py
 src/utils/serialization.py
 src/utils/standalone.py
 src/utils/validation.py

tilemap_editor-4.3.6/src/utils/property_suggestions.py

@@ -0,0 +1,70 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from editor import Editor
+
+
+class PropertySuggestionRegistry:
+    def __init__(self):
+        self._data: dict[str, list[str]] = {}
+
+    def refresh(self, editor: "Editor"):
+        values: dict[str, set[str]] = {}
+
+        if editor.tileset_widget:
+            for ts in editor.tileset_widget.tilesets:
+                for k, v in ts.properties.items():
+                    values.setdefault(k, set()).add(str(v))
+                for tile_props in ts.tile_properties.values():
+                    for k, v in tile_props.items():
+                        values.setdefault(k, set()).add(str(v))
+
+        if editor.tilemap:
+            for layer in editor.tilemap.layer_manager.layers:
+                for k, v in layer.properties.items():
+                    values.setdefault(k, set()).add(str(v))
+                for tile in layer.tiles.values():
+                    if "properties" in tile:
+                        for k, v in tile["properties"].items():
+                            values.setdefault(k, set()).add(str(v))
+                if layer.layer_type == "object":
+                    for obj in layer.objects.values():
+                        if "properties" in obj:
+                            for k, v in obj["properties"].items():
+                                values.setdefault(k, set()).add(str(v))
+
+        if editor.node_manager:
+            for node in editor.node_manager.nodes.values():
+                for k, v in node.properties.items():
+                    values.setdefault(k, set()).add(str(v))
+
+        self._data = {k: sorted(v) for k, v in values.items()}
+
+    @property
+    def known_keys(self) -> list[str]:
+        return sorted(self._data.keys())
+
+    def ghost_text(self, key: str, input_text: str) -> str:
+        if key not in self._data:
+            return ""
+        prefix = input_text.lower()
+        matches = [
+            v
+            for v in self._data[key]
+            if v.lower().startswith(prefix) and v != input_text
+        ]
+        if matches:
+            return matches[0][len(input_text):]
+        return ""
+
+    def key_ghost(self, input_text: str) -> str:
+        if not input_text:
+            return ""
+        prefix = input_text.lower()
+        matches = [
+            k for k in self._data
+            if k.lower().startswith(prefix) and k != input_text
+        ]
+        if matches:
+            return sorted(matches)[0][len(input_text):]
+        return ""

{tilemap_editor-4.3.5 → tilemap_editor-4.3.6}/src/widgets/layer_selector.py

@@ -408,6 +408,7 @@ class LayerSelector:
 
     def _save_layer_properties(self, layer: Layer, props: dict):
         layer.properties = props
+        self.editor.suggestion_registry.refresh(self.editor)
         print(f"Saved properties for layer: {layer.name}")
 
     def draw(self, screen: Surface) -> None:

{tilemap_editor-4.3.5 → tilemap_editor-4.3.6}/src/widgets/tile_selector.py

@@ -416,6 +416,7 @@ class TileSelector(WidgetBase):
                 self._tree.selected_ids = {tileset_data.uid}
                 if tileset_type == "object":
                     self.selected_tile = (0, 0, surf.get_width(), surf.get_height())
+                self.editor.suggestion_registry.refresh(self.editor)
             except Exception as e:
                 error_handler.capture(e, context="load_tileset_surface")
 
@@ -479,6 +480,7 @@ class TileSelector(WidgetBase):
         self._sync_tree()
         self._tree.selected_ids = {tileset_data.uid}
 
+        self.editor.suggestion_registry.refresh(self.editor)
         delattr(self, "_pending_tileset_path")
         delattr(self, "_pending_tileset_surf")
         if self._pending_tileset_queue:
@@ -561,6 +563,7 @@ class TileSelector(WidgetBase):
             if not self.tilesets:
                 self.active_idx = -1
                 self._sync_tree()
+            self.editor.suggestion_registry.refresh(self.editor)
 
     def open_collision_editor(self):
         if self.active_idx == -1 or self.active_idx >= len(self.tilesets):
@@ -573,6 +576,7 @@ class TileSelector(WidgetBase):
 
     def _save_tileset_properties(self, ts: TilesetData, props: dict):
         ts.properties = props
+        self.editor.suggestion_registry.refresh(self.editor)
         print(f"Saved properties for tileset: {ts.name}")
 
     def _save_tile_properties(self, ts: TilesetData, variant_id: int, props: dict):
@@ -582,6 +586,7 @@ class TileSelector(WidgetBase):
     def _save_tile_properties_multi(self, ts: TilesetData, variant_ids: list[int], props: dict):
         for vid in variant_ids:
             ts.tile_properties[vid] = props.copy()
+        self.editor.suggestion_registry.refresh(self.editor)
         if len(variant_ids) == 1:
             print(f"Saved properties for tile {variant_ids[0]} in tileset: {ts.name}")
         else:

{tilemap_editor-4.3.5 → tilemap_editor-4.3.6}/src/widgets/ui/node_editor.py

@@ -356,12 +356,14 @@ class NodeEditor:
         node = self.editor.node_manager.get_active_node()
         if node:
             node.properties = props
+            self.editor.suggestion_registry.refresh(self.editor)
 
     def _save_particle_config(self, cfg: dict):
         node = self.editor.node_manager.get_active_node()
         if node:
             node.properties.clear()
             node.properties.update(cfg)
+            self.editor.suggestion_registry.refresh(self.editor)
             self.editor.tile_grid_widget.reset_particle_preview(node.node_id, cfg)
 
     def draw(self, screen: pygame.Surface):

{tilemap_editor-4.3.5 → tilemap_editor-4.3.6}/src/widgets/ui/property_editor.py

@@ -52,6 +52,8 @@ class PropertyEditor:
         self.is_entering_new_key = False
 
         self._hovered_truncated: str | None = None
+        self._ghost_text: str = ""
+        self.editor.suggestion_registry.refresh(self.editor)
 
         btn_h = 30
         btn_w = 100
@@ -78,6 +80,7 @@ class PropertyEditor:
     def _on_save_click(self):
         self.on_save(self.properties)
         self.active = False
+        self._ghost_text = ""
         self.on_close()
 
     def _on_cancel_click(self):
@@ -89,6 +92,7 @@ class PropertyEditor:
         self.new_key_input = ""
         self.selected_key = None
         self.editing_value = False
+        self._ghost_text = self.editor.suggestion_registry.key_ghost("")
 
     def _update_hovered_tooltip(self, mouse_pos):
         self._hovered_truncated = None
@@ -132,10 +136,14 @@ class PropertyEditor:
                         self.selected_key = keys[idx]
                         self.editing_value = True
                         self.input_text = str(self.properties[self.selected_key])
+                        self._ghost_text = self.editor.suggestion_registry.ghost_text(
+                            self.selected_key, self.input_text
+                        )
                         self.is_entering_new_key = False
                         return True
                     self.selected_key = None
                     self.editing_value = False
+                    self._ghost_text = ""
                     self.is_entering_new_key = False
 
             elif event.button == 4:
@@ -184,12 +192,36 @@ class PropertyEditor:
                         self.selected_key = self.new_key_input
                         self.editing_value = True
                         self.input_text = ""
+                        self._ghost_text = self.editor.suggestion_registry.ghost_text(
+                            self.selected_key, self.input_text
+                        )
                         self.is_entering_new_key = False
                     return True
+                if event.key == pygame.K_TAB:
+                    if self._ghost_text:
+                        self.new_key_input = self.new_key_input + self._ghost_text
+                        self._ghost_text = self.editor.suggestion_registry.key_ghost(
+                            self.new_key_input
+                        )
+                    return True
                 if event.key == pygame.K_BACKSPACE:
                     self.new_key_input = self.new_key_input[:-1]
+                    self._ghost_text = self.editor.suggestion_registry.key_ghost(
+                        self.new_key_input
+                    )
                 else:
                     self.new_key_input += event.unicode
+                    if self._ghost_text and event.unicode:
+                        if self._ghost_text[0].lower() == event.unicode.lower():
+                            self._ghost_text = self._ghost_text[1:]
+                        else:
+                            self._ghost_text = self.editor.suggestion_registry.key_ghost(
+                                self.new_key_input
+                            )
+                    else:
+                        self._ghost_text = self.editor.suggestion_registry.key_ghost(
+                            self.new_key_input
+                        )
                 return True
 
             if self.editing_value and self.selected_key:
@@ -206,15 +238,35 @@ class PropertyEditor:
                             pass
                     self.properties[self.selected_key] = val
                     self.editing_value = False
+                    self._ghost_text = ""
+                elif event.key == pygame.K_TAB:
+                    if self._ghost_text:
+                        self.input_text = self.input_text + self._ghost_text
+                        self._ghost_text = ""
                 elif event.key == pygame.K_BACKSPACE:
                     self.input_text = self.input_text[:-1]
+                    self._ghost_text = self.editor.suggestion_registry.ghost_text(
+                        self.selected_key, self.input_text
+                    )
                 elif event.key == pygame.K_DELETE:
                     if self.selected_key in self.properties:
                         del self.properties[self.selected_key]
                         self.selected_key = None
                         self.editing_value = False
+                        self._ghost_text = ""
                 else:
                     self.input_text += event.unicode
+                    if self._ghost_text and event.unicode:
+                        if self._ghost_text[0].lower() == event.unicode.lower():
+                            self._ghost_text = self._ghost_text[1:]
+                        else:
+                            self._ghost_text = self.editor.suggestion_registry.ghost_text(
+                                self.selected_key, self.input_text
+                            )
+                    else:
+                        self._ghost_text = self.editor.suggestion_registry.ghost_text(
+                            self.selected_key, self.input_text
+                        )
                 return True
 
         return True
@@ -262,23 +314,47 @@ class PropertyEditor:
             key_surf = self.font_label.render(f"{key}:", True, COLORS.text)
             screen.blit(key_surf, (row_rect.x + 10, row_rect.y + 10))
 
+            value_x = row_rect.x + 120
+            max_width = row_rect.right - value_x - 10
+
             if is_selected and self.editing_value:
-                val_text = self.input_text + "|"
-                val_col = COLORS.text
+                if self._ghost_text:
+                    display_input, was_truncated = truncate_text(self.input_text, self.font_label, max_width)
+                    user_surf = self.font_label.render(display_input, True, COLORS.text)
+                    screen.blit(user_surf, (value_x, row_rect.y + 10))
+                    cursor_x = value_x + user_surf.get_width()
+                    if not was_truncated:
+                        ghost_surf = self.font_label.render(self._ghost_text, True, COLORS.text_dim)
+                        ghost_w = ghost_surf.get_width()
+                        if cursor_x + ghost_w <= row_rect.right - 10:
+                            screen.blit(ghost_surf, (cursor_x, row_rect.y + 10))
+                    if pygame.time.get_ticks() // 500 % 2 == 0:
+                        pygame.draw.line(
+                            screen, COLORS.text,
+                            (cursor_x, row_rect.y + 8),
+                            (cursor_x, row_rect.y + 28), 2,
+                        )
+                else:
+                    val_text = self.input_text + ("|" if pygame.time.get_ticks() // 500 % 2 == 0 else " ")
+                    display_val, _ = truncate_text(val_text, self.font_label, max_width)
+                    val_surf = self.font_label.render(display_val, True, COLORS.text)
+                    screen.blit(val_surf, (value_x, row_rect.y + 10))
             else:
-                val_text = str(self.properties[key])
-                if isinstance(self.properties[key], bool):
-                    val_col = COLORS.warning
-                elif isinstance(self.properties[key], (int, float)):
-                    val_col = COLORS.success
+                raw_val = str(self.properties[key])
+                if raw_val == "":
+                    val_text = "(empty)"
+                    val_col = COLORS.text_dim
                 else:
-                    val_col = COLORS.text
-
-            value_x = row_rect.x + 120
-            max_width = row_rect.right - value_x - 10
-            display_val, _ = truncate_text(val_text, self.font_label, max_width)
-            val_surf = self.font_label.render(display_val, True, val_col)
-            screen.blit(val_surf, (value_x, row_rect.y + 10))
+                    val_text = raw_val
+                    if isinstance(self.properties[key], bool):
+                        val_col = COLORS.warning
+                    elif isinstance(self.properties[key], (int, float)):
+                        val_col = COLORS.success
+                    else:
+                        val_col = COLORS.text
+                display_val, _ = truncate_text(val_text, self.font_label, max_width)
+                val_surf = self.font_label.render(display_val, True, val_col)
+                screen.blit(val_surf, (value_x, row_rect.y + 10))
 
         if self.is_entering_new_key:
             y = self.rect.y + 40 + len(keys) * self.item_height - self.scroll_y
@@ -286,10 +362,34 @@ class PropertyEditor:
                 self.rect.x + 5, y + 2, self.width - 10, self.item_height - 4
             )
             pygame.draw.rect(screen, COLORS.selected, row_rect, border_radius=4)
-            key_surf = self.font_label.render(
-                "New Key: " + self.new_key_input + "|", True, COLORS.text
-            )
-            screen.blit(key_surf, (row_rect.x + 10, row_rect.y + 10))
+            label_w = self.font_label.size("New Key: ")[0]
+            lbl_surf = self.font_label.render("New Key: ", True, COLORS.text)
+            screen.blit(lbl_surf, (row_rect.x + 10, row_rect.y + 10))
+            input_x = row_rect.x + 10 + label_w
+            key_input = self.new_key_input
+            max_kw = row_rect.right - input_x - 10
+            display_key, _ = truncate_text(key_input, self.font_label, max_kw)
+            input_surf = self.font_label.render(display_key, True, COLORS.text)
+            screen.blit(input_surf, (input_x, row_rect.y + 10))
+            cursor_x = input_x + input_surf.get_width()
+            if self._ghost_text:
+                ghost_surf = self.font_label.render(self._ghost_text, True, COLORS.text_dim)
+                max_gw = row_rect.right - cursor_x - 10
+                if ghost_surf.get_width() <= max_gw:
+                    screen.blit(ghost_surf, (cursor_x, row_rect.y + 10))
+                if pygame.time.get_ticks() // 500 % 2 == 0:
+                    pygame.draw.line(
+                        screen, COLORS.text,
+                        (cursor_x, row_rect.y + 8),
+                        (cursor_x, row_rect.y + 28), 2,
+                    )
+            else:
+                if pygame.time.get_ticks() // 500 % 2 == 0:
+                    cursor_char = "|"
+                else:
+                    cursor_char = " "
+                cur_surf = self.font_label.render(cursor_char, True, COLORS.text)
+                screen.blit(cur_surf, (cursor_x, row_rect.y + 10))
 
         screen.set_clip(clip)