tilemap-editor 3.1.2__tar.gz → 3.1.4__tar.gz

{tilemap_editor-3.1.2/src/tilemap_editor.egg-info → tilemap_editor-3.1.4}/PKG-INFO

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

{tilemap_editor-3.1.2 → tilemap_editor-3.1.4}/pyproject.toml

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

{tilemap_editor-3.1.2 → tilemap_editor-3.1.4}/src/editor.py

@@ -21,6 +21,7 @@ from tilemap import Tilemap
 from widgets.autotiler import AutotileRuleDesigner
 from widgets.regex_automap_designer import RegexAutomapDesigner
 from widgets.mapsetup import MapSetup
+from widgets.map_properties import MapPropertiesDialog
 from widgets.tile_selector import TileSelector
 from widgets.tile_grid import TileGrid
 from widgets.layer_selector import LayerSelector
@@ -117,7 +118,7 @@ def _load_project_config() -> tuple[Path, Path, dict]:
     data_root = base_path / data_path
 
     if not data_root.exists():
-        raise RuntimeError(f"Data directory not found: {data_root}. Run 'tilemap-editor init' to create project structure.")
+        raise RuntimeError(f"Data directory not found: {data_root}. Run 'tilemap-editor init' to create the project structure.")
 
     # Initialize error_handler with proper paths
     log_root = data_root / "logs"
@@ -166,6 +167,7 @@ class Editor:
         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
         self.layer_widget: Optional[LayerSelector] = None
         self.tile_grid_widget: Optional[TileGrid] = None
@@ -231,6 +233,7 @@ class Editor:
         center_y = (self.height - 400) // 2
         self.map_setup_widget = MapSetup(self, Rect(center_x, center_y, 400, 400))
         self.map_setup_widget.visible = False
+        self.map_properties_dialog = MapPropertiesDialog(self, Rect(center_x, center_y, 400, 260))
 
     def open_file_manager(
         self,
@@ -542,6 +545,8 @@ class Editor:
             center_x = (width - 400) // 2
             center_y = (height - 400) // 2
             self.map_setup_widget.resize(Rect(center_x, center_y, 400, 400))
+            if self.map_properties_dialog:
+                self.map_properties_dialog.resize(Rect(center_x, center_y, 400, 260))
 
     def toggle_auto_autotile(self):
         self.autotile_mode = not self.autotile_mode
@@ -555,6 +560,12 @@ class Editor:
             return
         self.map_setup_widget.visible = True
 
+    def open_map_properties(self):
+        if self.map_properties_dialog is None:
+            logger.warning({"msg": "map_properties_dialog is not initialized"})
+            return
+        self.map_properties_dialog.open()
+
     def toggle_autotiler(self):
         if self.autotiler.visible:
             self.autotiler.hide()
@@ -919,6 +930,10 @@ class Editor:
                 if self.map_setup_widget.handle_event(event):
                     continue
 
+            if self.map_properties_dialog and self.map_properties_dialog.visible:
+                if self.map_properties_dialog.handle_event(event):
+                    continue
+
             if self.property_editor and self.property_editor.active:
                 if self.property_editor.handle_event(event):
                     continue
@@ -1089,6 +1104,9 @@ class Editor:
                 self.screen.blit(overlay, (0, 0))
                 self.map_setup_widget.draw(self.screen)
 
+            if self.map_properties_dialog and self.map_properties_dialog.visible:
+                self.map_properties_dialog.draw(self.screen)
+
             if self.save_input.active:
                 self.save_input.draw(self.screen)
             if self.tileset_type_dialog.active:

{tilemap_editor-3.1.2 → tilemap_editor-3.1.4}/src/tilemap.py

@@ -40,6 +40,7 @@ class Tilemap:
         self.map_size = (50, 50)
         self.initial_map_size = (50, 50)
         self.initialized = False
+        self.render_scale = 1.0
 
         self.active_project_path: Optional[Path] = None
         self.history = HistoryManager()
@@ -59,11 +60,12 @@ class Tilemap:
         if active_layer:
             active_layer.tiles = value
 
-    def init_size(self, tile_size: "TCoor", map_size: "TCoor"):
+    def init_size(self, tile_size: "TCoor", map_size: "TCoor", render_scale: float = 1.0):
         self.tile_size = tile_size
         self.map_size = map_size
         self.initial_map_size = map_size  # Store what user initially setup
         self.initialized = True
+        self.render_scale = render_scale
         self.active_project_path = None
 
         # Clear and create default layer
@@ -85,6 +87,7 @@ class Tilemap:
             "active_layer_idx": self.layer_manager.active_layer_idx,
             "tile_size": self.tile_size,
             "map_size": self.map_size,
+            "render_scale": self.render_scale,
         }
         self.history.save_state(state, description)
 
@@ -101,6 +104,7 @@ class Tilemap:
             "active_layer_idx": self.layer_manager.active_layer_idx,
             "tile_size": self.tile_size,
             "map_size": self.map_size,
+            "render_scale": self.render_scale,
         }
         prev_state = self.history.undo(current_state)
         if prev_state:
@@ -119,6 +123,7 @@ class Tilemap:
             "active_layer_idx": self.layer_manager.active_layer_idx,
             "tile_size": self.tile_size,
             "map_size": self.map_size,
+            "render_scale": self.render_scale,
         }
         next_state = self.history.redo(current_state)
         if next_state:
@@ -181,6 +186,7 @@ class Tilemap:
         self.layer_manager.active_layer_idx = state["active_layer_idx"]
         self.tile_size = state["tile_size"]
         self.map_size = state["map_size"]
+        self.render_scale = state.get("render_scale", 1.0)
 
         if hasattr(self.editor, "autotiler"):
             designer = self.editor.autotiler
@@ -269,6 +275,7 @@ class Tilemap:
                     )
                 ),
                 "initial_map_size": serialize_point(self.initial_map_size),
+                "render_scale": self.render_scale,
                 "version": "1.1",
             },
             "resources": {"tilesets": []},
@@ -470,6 +477,7 @@ class Tilemap:
                 self.initial_map_size = deserialize_point(self.initial_map_size)
             else:
                 self.initial_map_size = self.map_size
+            self.render_scale = float(payload["meta"].get("render_scale", 1.0))
         except (KeyError, ValueError) as e:
             raise ValueError(f"Error loading map metadata: {e}") from e
 

{tilemap_editor-3.1.2 → tilemap_editor-3.1.4}/src/tilemap_editor/settings.py

@@ -42,6 +42,10 @@ def init_settings(generate_main: bool = False) -> None:
 
     print(f"Created settings.json at {settings_file}")
 
+    data_dir = base_path / settings["data_path"]
+    data_dir.mkdir(parents=True, exist_ok=True)
+    print(f"Created data directory: {data_dir}")
+
     if generate_main:
         generate_main_file()
 

{tilemap_editor-3.1.2 → tilemap_editor-3.1.4/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.1.2 → tilemap_editor-3.1.4}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -153,6 +153,7 @@ src/widgets/autotiler.py
 src/widgets/filemanager.py
 src/widgets/input.py
 src/widgets/layer_selector.py
+src/widgets/map_properties.py
 src/widgets/mapsetup.py
 src/widgets/regex_automap_designer.py
 src/widgets/tile_grid.py
@@ -174,4 +175,5 @@ src/widgets/ui/toolbar.py
 src/widgets/ui/tooltip.py
 tests/test_collision_layer_mask.py
 tests/test_collision_layer_sidebar.py
-tests/test_project_paths.py
+tests/test_project_paths.py
+tests/test_render_scale.py

tilemap_editor-3.1.4/src/widgets/map_properties.py

@@ -0,0 +1,133 @@
+import pygame
+from typing import TYPE_CHECKING
+from pygame import Rect
+
+from .input import BaseTextInput
+
+if TYPE_CHECKING:
+    from editor import Editor
+
+
+COLOR_BG = (45, 45, 50)
+COLOR_BORDER = (80, 80, 80)
+COLOR_ACCENT = (60, 100, 160)
+COLOR_TEXT = (220, 220, 220)
+COLOR_ERROR = (200, 60, 60)
+
+
+class MapPropertiesDialog:
+    def __init__(self, editor: "Editor", center_rect: Rect):
+        self.editor = editor
+        self.rect = center_rect
+        self.visible = False
+        self.error_message = ""
+
+        self.render_scale_input = BaseTextInput(
+            Rect(self.rect.x + 20, self.rect.y + 60, self.rect.width - 40, 60),
+            "Render Scale",
+            "render_scale",
+            str(editor.tilemap.render_scale),
+            allowed_chars="0123456789.",
+        )
+
+        self.btn_save = Rect(self.rect.centerx - 130, self.rect.bottom - 50, 120, 35)
+        self.btn_cancel = Rect(self.rect.centerx + 10, self.rect.bottom - 50, 120, 35)
+        self.font = pygame.font.SysFont("Arial", 20, bold=True)
+        self.font_info = pygame.font.SysFont("Arial", 14)
+
+    def open(self):
+        self.render_scale_input.text = str(self.editor.tilemap.render_scale)
+        self.render_scale_input.cursor_pos = len(self.render_scale_input.text)
+        self.render_scale_input.is_focused = False
+        self.error_message = ""
+        self.visible = True
+
+    def resize(self, center_rect: Rect):
+        self.rect = center_rect
+        self.render_scale_input.rect_area = Rect(
+            self.rect.x + 20, self.rect.y + 60, self.rect.width - 40, 60
+        )
+        self.render_scale_input.rect_input = Rect(
+            self.render_scale_input.rect_area.x,
+            self.render_scale_input.rect_area.y + 20,
+            self.render_scale_input.rect_area.width,
+            30,
+        )
+        self.btn_save = Rect(self.rect.centerx - 130, self.rect.bottom - 50, 120, 35)
+        self.btn_cancel = Rect(self.rect.centerx + 10, self.rect.bottom - 50, 120, 35)
+
+    def handle_event(self, event: pygame.event.Event) -> bool:
+        if not self.visible:
+            return False
+
+        if event.type == pygame.MOUSEBUTTONDOWN:
+            if event.button == 1:
+                if self.btn_save.collidepoint(event.pos):
+                    self.submit()
+                    return True
+                if self.btn_cancel.collidepoint(event.pos):
+                    self.visible = False
+                    return True
+
+        if event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_ESCAPE:
+                self.visible = False
+                return True
+            if event.key == pygame.K_RETURN:
+                self.submit()
+                return True
+
+        self.render_scale_input.handle_event(event)
+        return True
+
+    def submit(self):
+        try:
+            raw = self.render_scale_input.text.strip()
+            if not raw:
+                raise ValueError("Render Scale is required")
+            value = float(raw)
+            if value <= 0:
+                raise ValueError("Render Scale must be greater than 0")
+            self.editor.tilemap.render_scale = value
+            self.editor.notifications.notify(f"Render Scale set to {value}")
+            self.visible = False
+        except ValueError as e:
+            self.error_message = str(e)
+
+    def draw(self, screen: pygame.Surface):
+        if not self.visible:
+            return
+
+        overlay = pygame.Surface(
+            (self.editor.width, self.editor.height), pygame.SRCALPHA
+        )
+        overlay.fill((0, 0, 0, 180))
+        screen.blit(overlay, (0, 0))
+
+        pygame.draw.rect(screen, COLOR_BG, self.rect, border_radius=8)
+        pygame.draw.rect(screen, COLOR_BORDER, self.rect, 2, border_radius=8)
+
+        title = self.font.render("Map Properties", True, COLOR_TEXT)
+        screen.blit(title, (self.rect.x + 20, self.rect.y + 15))
+
+        # Show read-only info about tile and map size
+        tm = self.editor.tilemap
+        info = f"Tile Size: {tm.tile_size[0]}x{tm.tile_size[1]}  |  Map Size: {tm.map_size[0]}x{tm.map_size[1]}"
+        info_surf = self.font_info.render(info, True, (150, 150, 150))
+        screen.blit(info_surf, (self.rect.x + 20, self.rect.y + 42))
+
+        self.render_scale_input.draw(screen)
+
+        for btn, text, col in [
+            (self.btn_save, "Apply", (40, 150, 80)),
+            (self.btn_cancel, "Cancel", (150, 60, 60)),
+        ]:
+            pygame.draw.rect(screen, col, btn, border_radius=4)
+            txt_surf = self.font.render(text, True, COLOR_TEXT)
+            screen.blit(txt_surf, txt_surf.get_rect(center=btn.center))
+
+        if self.error_message:
+            err = pygame.font.SysFont("Arial", 12).render(
+                self.error_message, True, COLOR_ERROR
+            )
+            screen.blit(err, (self.rect.x + 20, self.btn_save.y - 20))

{tilemap_editor-3.1.2 → tilemap_editor-3.1.4}/src/widgets/tile_grid.py

@@ -44,6 +44,12 @@ class TileGrid:
     def tile_size(self):
         return self.editor.tilemap.tile_size
 
+    @property
+    def effective_tile_size(self):
+        tw, th = self.editor.tilemap.tile_size
+        rs = self.editor.tilemap.render_scale
+        return (tw * rs, th * rs)
+
     def screen_to_world(self, pos: Tuple[int, int]) -> Tuple[int, int]:
         wx = (pos[0] - self.rect.x) / self.zoom_level + self.scroll_x
         wy = (pos[1] - self.rect.y) / self.zoom_level + self.scroll_y
@@ -51,8 +57,8 @@ class TileGrid:
 
     def get_grid_pos(self, pos: Tuple[int, int]) -> Tuple[int, int]:
         wx, wy = self.screen_to_world(pos)
-        tile_w, tile_h = self.tile_size
-        return int(wx // tile_w), int(wy // tile_h)
+        eff_w, eff_h = self.effective_tile_size
+        return int(wx // eff_w), int(wy // eff_h)
 
     def update(self):
         event_blocked = not self.editor.save_input.active
@@ -117,8 +123,9 @@ class TileGrid:
         self.scroll_y = 0
 
     def fit_to_map(self):
-        world_w = self.editor.tilemap.map_size[0] * self.tile_size[0]
-        world_h = self.editor.tilemap.map_size[1] * self.tile_size[1]
+        eff_w, eff_h = self.effective_tile_size
+        world_w = self.editor.tilemap.map_size[0] * eff_w
+        world_h = self.editor.tilemap.map_size[1] * eff_h
         if world_w <= 0 or world_h <= 0:
             return
         zoom_x = self.rect.width / world_w
@@ -129,8 +136,9 @@ class TileGrid:
 
     def clamp_view(self):
         self.zoom_level = max(self.min_zoom, min(self.max_zoom, self.zoom_level))
-        world_w = self.editor.tilemap.map_size[0] * self.tile_size[0]
-        world_h = self.editor.tilemap.map_size[1] * self.tile_size[1]
+        eff_w, eff_h = self.effective_tile_size
+        world_w = self.editor.tilemap.map_size[0] * eff_w
+        world_h = self.editor.tilemap.map_size[1] * eff_h
         view_w = self.rect.width / self.zoom_level
         view_h = self.rect.height / self.zoom_level
 
@@ -631,16 +639,18 @@ class TileGrid:
             if not self.hover_cell:
                 return
 
+            eff_w, eff_h = self.effective_tile_size
+
             if is_erasing:
                 # Eraser preview for tiles: show a red box based on eraser_size
                 screen_x = (
-                    self.hover_cell[0] * tile_w - self.scroll_x
+                    self.hover_cell[0] * eff_w - self.scroll_x
                 ) * self.zoom_level + self.rect.x
                 screen_y = (
-                    self.hover_cell[1] * tile_h - self.scroll_y
+                    self.hover_cell[1] * eff_h - self.scroll_y
                 ) * self.zoom_level + self.rect.y
-                size_w = int(tile_w * self.eraser_size * self.zoom_level)
-                size_h = int(tile_h * self.eraser_size * self.zoom_level)
+                size_w = int(eff_w * self.eraser_size * self.zoom_level)
+                size_h = int(eff_h * self.eraser_size * self.zoom_level)
                 dest_rect = Rect(screen_x, screen_y, size_w, size_h)
                 pygame.draw.rect(screen, (255, 50, 50), dest_rect, 2)
                 return
@@ -654,14 +664,14 @@ class TileGrid:
                     row = self.hover_cell[1] + y_off
 
                     screen_x = (
-                        col * tile_w - self.scroll_x
+                        col * eff_w - self.scroll_x
                     ) * self.zoom_level + self.rect.x
                     screen_y = (
-                        row * tile_h - self.scroll_y
+                        row * eff_h - self.scroll_y
                     ) * self.zoom_level + self.rect.y
 
-                    dest_w = int(tile_w * self.zoom_level)
-                    dest_h = int(tile_h * self.zoom_level)
+                    dest_w = int(eff_w * self.zoom_level)
+                    dest_h = int(eff_h * self.zoom_level)
                     dest_rect = Rect(screen_x, screen_y, dest_w, dest_h)
 
                     pygame.draw.rect(screen, (255, 255, 255), dest_rect, 1)
@@ -683,12 +693,12 @@ class TileGrid:
                         pass
 
     def _draw_grid(self, screen):
-        tile_w, tile_h = self.tile_size
+        eff_w, eff_h = self.effective_tile_size
         map_w, map_h = self.editor.tilemap.map_size
 
         # World coordinates of map boundaries
-        map_world_w = map_w * tile_w
-        map_world_h = map_h * tile_h
+        map_world_w = map_w * eff_w
+        map_world_h = map_h * eff_h
 
         # Screen coordinates of map top-left
         map_screen_x = (0 - self.scroll_x) * self.zoom_level + self.rect.x
@@ -703,15 +713,15 @@ class TileGrid:
         visible_world_w = self.rect.width / self.zoom_level
         visible_world_h = self.rect.height / self.zoom_level
 
-        start_col = max(0, int(self.scroll_x // tile_w))
-        end_col = min(map_w, int((self.scroll_x + visible_world_w) // tile_w) + 1)
+        start_col = max(0, int(self.scroll_x // eff_w))
+        end_col = min(map_w, int((self.scroll_x + visible_world_w) // eff_w) + 1)
 
-        start_row = max(0, int(self.scroll_y // tile_h))
-        end_row = min(map_h, int((self.scroll_y + visible_world_h) // tile_h) + 1)
+        start_row = max(0, int(self.scroll_y // eff_h))
+        end_row = min(map_h, int((self.scroll_y + visible_world_h) // eff_h) + 1)
 
         # Draw vertical lines (at column positions)
         for col in range(start_col, end_col + 1):
-            x = (col * tile_w - self.scroll_x) * self.zoom_level + self.rect.x
+            x = (col * eff_w - self.scroll_x) * self.zoom_level + self.rect.x
             # Line goes from top of map to bottom of map (clipping handled by surface clip)
             pygame.draw.line(
                 screen,
@@ -722,7 +732,7 @@ class TileGrid:
 
         # Draw horizontal lines (at row positions)
         for row in range(start_row, end_row + 1):
-            y = (row * tile_h - self.scroll_y) * self.zoom_level + self.rect.y
+            y = (row * eff_h - self.scroll_y) * self.zoom_level + self.rect.y
             # Line goes from left of map to right of map
             pygame.draw.line(
                 screen,
@@ -782,20 +792,21 @@ class TileGrid:
             return
 
         tile_w, tile_h = self.tile_size
+        rs = tilemap.render_scale
+        eff_w = tile_w * rs
+        eff_h = tile_h * rs
+
         map_w, map_h = tilemap.map_size
 
-        # visible world bounds
+        # visible world bounds (in effective world space)
         visible_world_w = self.rect.width / self.zoom_level
         visible_world_h = self.rect.height / self.zoom_level
 
-        start_col = max(0, int(self.scroll_x // tile_w))
-        end_col = min(map_w, int((self.scroll_x + visible_world_w) // tile_w) + 1)
-
-        start_row = max(0, int(self.scroll_y // tile_h))
-        end_row = min(map_h, int((self.scroll_y + visible_world_h) // tile_h) + 1)
+        start_col = max(0, int(self.scroll_x // eff_w))
+        end_col = min(map_w, int((self.scroll_x + visible_world_w) // eff_w) + 1)
 
-        # Debug boundaries
-        # print(f"DEBUG: Rendering rows {start_row}-{end_row}, cols {start_col}-{end_col} | Scroll: ({self.scroll_x}, {self.scroll_y}) | Zoom: {self.zoom_level}")
+        start_row = max(0, int(self.scroll_y // eff_h))
+        end_row = min(map_h, int((self.scroll_y + visible_world_h) // eff_h) + 1)
 
         assert self.editor.tileset_widget is not None
         tileset_map = self.editor.tileset_widget.tileset_map
@@ -836,29 +847,28 @@ class TileGrid:
                         variant_id = tile["variant"]
                         sheet_w = base_surf.get_width()
 
+                        # Source rect always uses logical tile size
                         sheet_cols = sheet_w // tile_w
-
                         src_x = (variant_id % sheet_cols) * tile_w
                         src_y = (variant_id // sheet_cols) * tile_h
                         src_rect = Rect(src_x, src_y, tile_w, tile_h)
 
+                        # Dest position uses effective (scaled) tile size
                         dest_x = (
-                            (x * tile_w - self.scroll_x) * self.zoom_level
+                            (x * eff_w - self.scroll_x) * self.zoom_level
                             + self.rect.x
                             + draw_offset_x
                         )
                         dest_y = (
-                            (y * tile_h - self.scroll_y) * self.zoom_level
+                            (y * eff_h - self.scroll_y) * self.zoom_level
                             + self.rect.y
                             + draw_offset_y
                         )
 
-                        # Scale if zooming
-                        if self.zoom_level != 1.0:
-                            scaled_w = int(tile_w * self.zoom_level)
-                            scaled_h = int(tile_h * self.zoom_level)
-
-                            # Bounds check
+                        # Scale if zoomed or render_scaled
+                        if self.zoom_level != 1.0 or rs != 1.0:
+                            scaled_w = int(eff_w * self.zoom_level)
+                            scaled_h = int(eff_h * self.zoom_level)
                             if base_surf.get_rect().contains(src_rect):
                                 sub = base_surf.subsurface(src_rect)
                                 scaled_sub = pygame.transform.scale(
@@ -895,19 +905,19 @@ class TileGrid:
                         src_rect = Rect(src_x, src_y, obj_w, obj_h)
 
                     dest_x = (
-                        (obj_x - self.scroll_x) * self.zoom_level
+                        (obj_x * rs - self.scroll_x) * self.zoom_level
                         + self.rect.x
                         + draw_offset_x
                     )
                     dest_y = (
-                        (obj_y - self.scroll_y) * self.zoom_level
+                        (obj_y * rs - self.scroll_y) * self.zoom_level
                         + self.rect.y
                         + draw_offset_y
                     )
 
-                    if self.zoom_level != 1.0:
-                        scaled_w = int(obj_w * self.zoom_level)
-                        scaled_h = int(obj_h * self.zoom_level)
+                    if self.zoom_level != 1.0 or rs != 1.0:
+                        scaled_w = int(obj_w * rs * self.zoom_level)
+                        scaled_h = int(obj_h * rs * self.zoom_level)
                         if base_surf.get_rect().contains(src_rect):
                             sub = base_surf.subsurface(src_rect)
                             scaled_sub = pygame.transform.scale(

{tilemap_editor-3.1.2 → tilemap_editor-3.1.4}/src/widgets/ui/menubar.py

@@ -44,6 +44,7 @@ class MenuBar:
                     MenuAction(
                         "Save As...", self.editor.open_save_as_dialog, "Ctrl+Shift+S"
                     ),
+                    MenuAction("Map Properties", self.editor.open_map_properties),
                     MenuAction("Exit", self.editor.exit_editor),
                 ],
             ),