Debian Codegraph @

src/app_model/registries/_menus_reg.py

raw
1 from __future__ import annotations
2
3 from typing import TYPE_CHECKING, Any, Callable, Final, cast
4
5 from psygnal import Signal
6
7 from app_model.types import MenuItem
8
9 if TYPE_CHECKING:
10 from collections.abc import Iterable, Iterator
11
12 from app_model.types import Action, DisposeCallable, MenuOrSubmenu
13
14 MenuId = str
15
16
17 class MenusRegistry:
18 """Registry for menu and submenu items."""
19
20 COMMAND_PALETTE_ID: Final = "_command_pallet_"
21 menus_changed = Signal(set)
22
23 def __init__(self) -> None:
24 self._menu_items: dict[MenuId, dict[MenuOrSubmenu, None]] = {}
25
26 def append_action_menus(self, action: Action) -> DisposeCallable | None:
27 """Append all MenuRule items declared in `action.menus`.
28
29 Parameters
30 ----------
31 action : Action
32 The action containing menus to append.
33
34 Returns
35 -------
36 DisposeCallable | None
37 A function that can be called to unregister the menu items. If no
38 menu items were registered, returns `None`.
39 """
40 disposers: list[Callable[[], None]] = []
41 disp1 = self.append_menu_items(
42 (
43 rule.id,
44 MenuItem(
45 command=action, when=rule.when, group=rule.group, order=rule.order
46 ),
47 )
48 for rule in action.menus or ()
49 )
50 disposers.append(disp1)
51
52 if action.palette:
53 menu_item = MenuItem(command=action, when=action.enablement)
54 disp = self.append_menu_items([(self.COMMAND_PALETTE_ID, menu_item)])
55 disposers.append(disp)
56
57 if not disposers: # pragma: no cover
58 return None
59
60 def _dispose() -> None:
61 for disposer in disposers:
62 disposer()
63
64 return _dispose
65
66 def append_menu_items(
67 self, items: Iterable[tuple[MenuId, MenuOrSubmenu | dict]]
68 ) -> DisposeCallable:
69 """Append menu items to the registry.
70
71 Parameters
72 ----------
73 items : Iterable[Tuple[str, MenuOrSubmenu]]
74 Items to append.
75
76 Returns
77 -------
78 DisposeCallable
79 A function that can be called to unregister the menu items.
80 """
81 changed_ids: set[str] = set()
82 disposers: list[Callable[[], None]] = []
83 for menu_id, item in items:
84 item = cast("MenuOrSubmenu", MenuItem._validate(item))
85 menu_dict = self._menu_items.setdefault(menu_id, {})
86 menu_dict[item] = None
87 changed_ids.add(menu_id)
88
89 def _remove(dct: dict = menu_dict, _item: Any = item) -> None:
90 dct.pop(_item, None)
91
92 disposers.append(_remove)
93
94 def _dispose() -> None:
95 for disposer in disposers:
96 disposer()
97 for id_ in changed_ids:
98 if not self._menu_items.get(id_):
99 del self._menu_items[id_]
100 self.menus_changed.emit(changed_ids)
101
102 if changed_ids:
103 self.menus_changed.emit(changed_ids)
104
105 return _dispose
106
107 def __iter__(
108 self,
109 ) -> Iterator[tuple[MenuId, Iterable[MenuOrSubmenu]]]:
110 yield from self._menu_items.items()
111
112 def __contains__(self, id: object) -> bool:
113 return id in self._menu_items
114
115 def get_menu(self, menu_id: MenuId) -> list[MenuOrSubmenu]:
116 """Return menu items for `menu_id`."""
117 # using method rather than __getitem__ so that subclasses can use arguments
118 return list(self._menu_items[menu_id])
119
120 def __repr__(self) -> str:
121 name = self.__class__.__name__
122 return f"<{name} at {hex(id(self))} ({len(self._menu_items)} menus)>"
123
124 def __str__(self) -> str:
125 return "\n".join(self._render())
126
127 def _render(self) -> list[str]:
128 """Return registered menu items as lines of strings."""
129 # this is mostly here as a debugging tool. Can be removed or improved later.
130 lines: list[str] = []
131
132 branch = " ├──"
133 for menu in self._menu_items:
134 lines.append(menu)
135 for group in self.iter_menu_groups(menu):
136 first = next(iter(group))
137 lines.append(f" ├───────────{first.group}───────────────")
138 for child in group:
139 if isinstance(child, MenuItem):
140 lines.append(
141 f"{branch} {child.command.title} ({child.command.id})"
142 )
143 else:
144 lines.extend(
145 [
146 f"{branch} {child.submenu}",
147 " ├── └── ...",
148 ]
149 )
150 lines.append("")
151 return lines
152
153 def iter_menu_groups(self, menu_id: MenuId) -> Iterator[list[MenuOrSubmenu]]:
154 """Iterate over menu groups for `menu_id`.
155
156 Groups are broken into sections (lists of menu or submenu items) based on
157 their `group` attribute. And each group is sorted by `order` attribute.
158
159 Parameters
160 ----------
161 menu_id : str
162 The menu ID to return groups for.
163
164 Yields
165 ------
166 Iterator[List[MenuOrSubmenu]]
167 Iterator of menu/submenu groups.
168 """
169 if menu_id in self:
170 yield from _sort_groups(self.get_menu(menu_id))
171
172
173 def _sort_groups(
174 items: list[MenuOrSubmenu],
175 group_key: Callable = lambda x: "0000" if x == "navigation" else x or "",
176 order_key: Callable = lambda x: getattr(x, "order", "") or 0,
177 ) -> Iterator[list[MenuOrSubmenu]]:
178 """Sort a list of menu items based on their .group and .order attributes."""
179 groups: dict[str | None, list[MenuOrSubmenu]] = {}
180 for item in items:
181 groups.setdefault(item.group, []).append(item)
182
183 for group_id in sorted(groups, key=group_key):
184 yield sorted(groups[group_id], key=order_key)