| 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) |