remove 'xdg-' prefix for menu

Author: totaam

xpra/client/gtk3/client_base.py

@@ -425,13 +425,13 @@ def show_start_new_command(self, *args) -> None:
         dialog = self.sub_dialogs.get("start-new-command")
         log(f"show_start_new_command{args} current {dialog=}, flag={self.server_start_new_commands}")
         if not dialog:
-            log("server_xdg_menu=%s", Ellipsizer(self.server_xdg_menu))
+            log("server_menu=%s", Ellipsizer(self.server_menu))
             from xpra.gtk.dialogs.start_new_command import getStartNewCommand
 
             def run_command_cb(command, sharing=True):
                 self.send_start_command(command, command, False, sharing)
 
-            dialog = getStartNewCommand(run_command_cb, self.server_sharing, self.server_xdg_menu)
+            dialog = getStartNewCommand(run_command_cb, self.server_sharing, self.server_menu)
             self.sub_dialogs["start-new-command"] = dialog
         dialog.show()
 

xpra/client/gtk3/tray_menu.py

@@ -9,7 +9,7 @@
 from collections.abc import Sequence, Callable, Iterable
 
 from xpra.util.objects import typedict, reverse_dict
-from xpra.util.str_fn import Ellipsizer, repr_ellipsized, csv
+from xpra.util.str_fn import Ellipsizer, csv
 from xpra.util.env import envbool, ignorewarnings
 from xpra.os_util import gi_import, OSX, WIN32
 from xpra.common import RESOLUTION_ALIASES, ConnectionMessage, uniq
@@ -1691,7 +1691,7 @@ def make_startmenuitem(self) -> Gtk.ImageMenuItem:
         start_menu_item = self.handshake_menuitem("Start", "start.png")
         start_menu_item.show()
 
-        def update_menu_data() -> None:
+        def update_menu_data(*_args) -> None:
             if not self.client.start_new_commands:
                 set_sensitive(start_menu_item, False)
                 start_menu_item.set_tooltip_text("Starting new commands is disabled")
@@ -1700,7 +1700,7 @@ def update_menu_data() -> None:
                 set_sensitive(start_menu_item, False)
                 start_menu_item.set_tooltip_text("This server does not support starting new commands")
                 return
-            if not self.client.server_xdg_menu:
+            if not self.client.server_menu:
                 set_sensitive(start_menu_item, False)
                 start_menu_item.set_tooltip_text("This server does not provide start menu data")
                 return
@@ -1709,23 +1709,18 @@ def update_menu_data() -> None:
             start_menu_item.set_submenu(menu)
             start_menu_item.set_tooltip_text(None)
 
-        def start_menu_init() -> None:
-            update_menu_data()
-
-            def on_xdg_menu_changed(setting, value) -> None:
-                log("on_xdg_menu_changed(%s, %s)", setting, repr_ellipsized(str(value)))
-                update_menu_data()
-
-            self.client.on_server_setting_changed("xdg-menu", on_xdg_menu_changed)
-
-        self.after_handshake(start_menu_init)
+        # legacy pre v6.4 name:
+        self.client.on_server_setting_changed("xdg-menu", update_menu_data)
+        # v6.4 and later:
+        self.client.on_server_setting_changed("menu", update_menu_data)
+        # older servers may have supplied as part of the hello handshake:
+        self.after_handshake(update_menu_data)
         return start_menu_item
 
     def build_start_menu(self) -> Gtk.Menu:
         menu = Gtk.Menu()
-        execlog("build_start_menu() %i menu items", len(self.client.server_xdg_menu))
-        execlog("self.client.server_xdg_menu=%s", Ellipsizer(self.client.server_xdg_menu))
-        for category, category_props in sorted(self.client.server_xdg_menu.items()):
+        execlog("build_start_menu() %i menu items: %s", len(self.client.server_menu), Ellipsizer(self.client.server_menu))
+        for category, category_props in sorted(self.client.server_menu.items()):
             execlog(" * category: %s", category)
             # log("category_props(%s)=%s", category, category_props)
             if not isinstance(category_props, dict):

xpra/client/gui/ui_client_base.py

@@ -349,7 +349,7 @@ def _process_setting_change(self, packet: PacketType) -> None:
                 "sharing", "sharing-toggle", "lock", "lock-toggle",
                 "start-new-commands", "client-shutdown", "webcam",
                 "bandwidth-limit", "clipboard-limits",
-                "xdg-menu", "monitors",
+                "xdg-menu", "menu", "monitors",
                 "ibus-layouts",
         ):
             setattr(self, "server_%s" % setting.replace("-", "_"), value)

xpra/client/subsystem/command.py

@@ -8,6 +8,7 @@
 from collections.abc import Sequence
 
 from xpra.client.base.stub_client_mixin import StubClientMixin
+from xpra.common import noop
 from xpra.scripts.config import str_to_bool
 from xpra.util.objects import typedict
 from xpra.log import Logger
@@ -23,7 +24,7 @@ class CommandClient(StubClientMixin):
 
     def __init__(self):
         self.server_start_new_commands: bool = False
-        self.server_xdg_menu = None
+        self.server_menu = {}
         self.start_new_commands: bool = False
         self.server_commands_info = False
         self.server_commands_signals: Sequence[str] = ()
@@ -44,6 +45,9 @@ def get_info(self) -> dict[str, dict[str, Any]]:
 
     def get_caps(self) -> dict[str, Any]:
         return {
+            # v6.4:
+            "menu": self.start_new_commands,
+            # pre-v6.4:
             "xdg-menu": self.start_new_commands,
             # legacy flag:
             "xdg-menu-update": True,
@@ -52,7 +56,14 @@ def get_caps(self) -> dict[str, Any]:
     def parse_server_capabilities(self, c: typedict) -> bool:
         self.server_start_new_commands = c.boolget("start-new-commands")
         if self.server_start_new_commands:
-            self.server_xdg_menu = c.dictget("xdg-menu", None)
+            self.server_menu = c.dictget("xdg-menu", {})
+            # weak dependency injection on ui client:
+            onchange = getattr(self, "on_server_setting_changed", noop)
+
+            def update_menu_value(_setting, menu) -> None:
+                self.server_menu = menu
+            onchange("xdg-menu", update_menu_value)
+            onchange("menu", update_menu_value)
         if self.request_start or self.request_start_child:
             if self.server_start_new_commands:
                 self.after_handshake(self.send_start_new_commands)

xpra/gtk/dialogs/start_new_command.py

@@ -35,10 +35,10 @@ def load_config() -> dict:
 _instance = None
 
 
-def getStartNewCommand(run_callback, can_share=False, xdg_menu=None):
+def getStartNewCommand(run_callback, can_share=False, menu=None):
     global _instance
     if _instance is None:
-        _instance = StartNewCommand(run_callback, can_share, xdg_menu)
+        _instance = StartNewCommand(run_callback, can_share, menu)
     return _instance
 
 
@@ -54,9 +54,9 @@ def btn(label, tooltip, callback, icon_name="") -> Gtk.Button:
 
 class StartNewCommand:
 
-    def __init__(self, run_callback=None, can_share=False, xdg_menu=None):
+    def __init__(self, run_callback=None, can_share=False, menu=None):
         self.run_callback = run_callback
-        self.xdg_menu = typedict(xdg_menu or {})
+        self.menu = typedict(menu or {})
         self.window = Gtk.Window()
         self.window.set_border_width(20)
         self.window.connect("delete-event", self.close)
@@ -77,15 +77,15 @@ def __init__(self, run_callback=None, can_share=False, xdg_menu=None):
         self.entry.set_max_length(255)
         self.entry.set_width_chars(32)
         self.entry.connect('activate', self.run_command)
-        if self.xdg_menu:
+        if self.menu:
             # or use menus if we have xdg data:
             hbox = Gtk.HBox(homogeneous=False, spacing=20)
             vbox.add(hbox)
             hbox.add(label("Category:"))
             self.category_combo = Gtk.ComboBoxText()
             hbox.add(self.category_combo)
             index = 0
-            for i, name in enumerate(sorted(self.xdg_menu.keys())):
+            for i, name in enumerate(sorted(self.menu.keys())):
                 self.category_combo.append_text(name)
                 if name == self.prefs.get("category", ""):
                     index = i
@@ -133,7 +133,7 @@ def accel_close(*_args) -> None:
     def category_changed(self, *args) -> None:
         category = self.category_combo.get_active_text()
         update_config("category", category)
-        entries = typedict(typedict(self.xdg_menu.dictget(category, {})).dictget("Entries", {}))
+        entries = typedict(typedict(self.menu.dictget(category, {})).dictget("Entries", {}))
         log("category_changed(%s) category=%s, entries=%s", args, category, entries)
         self.command_combo.get_model().clear()
         index = -1
@@ -148,7 +148,7 @@ def command_changed(self, *args) -> None:
         if not self.entry:
             return
         category = self.category_combo.get_active_text()
-        entries = typedict(typedict(self.xdg_menu.dictget(category, {})).dictget("Entries", {}))
+        entries = typedict(typedict(self.menu.dictget(category, {})).dictget("Entries", {}))
         command_name = self.command_combo.get_active_text()
         if command_name:
             update_config("command", command_name)

xpra/gtk/examples/tray.py

@@ -47,7 +47,7 @@ def __init__(self):
         self.server_encodings_with_quality = []
         self.server_encodings_with_speed = []
         self.server_start_new_commands = True
-        self.server_xdg_menu = False
+        self.server_menu = False
         self.server_commands_info = None
         self.server_multi_monitors = False
         self.server_bandwidth_limit = 0

xpra/net/glib_handler.py

@@ -47,6 +47,8 @@ def add_packet_handlers(self, defs: dict[str, ServerPacketHandlerType], main_thr
             self.add_packet_handler(packet_type, handler, main_thread)
 
     def add_packet_handler(self, packet_type: str, handler: ServerPacketHandlerType, main_thread=False) -> None:
+        # replace any previously defined handlers:
+        self.remove_packet_handlers(packet_type)
         log("add_packet_handler%s", (packet_type, handler, main_thread))
         if main_thread:
             handlers = self._authenticated_ui_packet_handlers

xpra/server/source/client_connection.py

@@ -95,6 +95,7 @@ def init_state(self) -> None:
         self.lock = False
         self.client_control_commands: Sequence[str] = ()
         self.xdg_menu = True
+        self.menu = False
         self.ssh_auth_sock = ""
         # what we send back in hello packet:
         self.ui_client = True
@@ -143,7 +144,9 @@ def parse_client_caps(self, c: typedict) -> None:
         self.share = c.boolget("share")
         self.lock = c.boolget("lock")
         self.client_control_commands = c.strtupleget("control_commands")
+        # `xdg-menu` is the pre v6.4 legacy name:
         self.xdg_menu = c.boolget("xdg-menu", False)
+        self.menu = c.boolget("menu", False)
         self.ssh_auth_sock = c.strget("ssh-auth-sock")
 
     def startup_complete(self) -> None:
@@ -280,7 +283,9 @@ def get_features_info(self) -> dict[str, Any]:
         info = {
             "lock": bool(self.lock),
             "share": bool(self.share),
+            # legacy pre v6.4 name:
             "xdg-menu": bool(self.xdg_menu),
+            "menu": bool(self.menu),
         }
         return info
 

xpra/server/subsystem/command.py

@@ -34,6 +34,25 @@
 TERMINATE_DELAY = envint("XPRA_TERMINATE_DELAY", 1000) / 1000.0
 
 
+def do_send_menu_data(ss, menu) -> None:
+    if ss.is_closed():
+        return
+    if not getattr(ss, "send_setting_change", False):
+        return
+    log("do_send_menu_data(%s, %s) %s", ss, Ellipsizer(menu))
+    if getattr(ss, "menu", False):
+        # v6.4 and later:
+        attr = "menu"
+    elif getattr(ss, "xdg_menu", False):
+        # legacy name:
+        attr = "xdg-menu"
+    else:
+        # not supported by this connection
+        return
+    ss.send_setting_change(attr, menu)
+    log(f"{len(menu)} menu data entries sent to {ss}")
+
+
 class ChildCommandServer(StubServerMixin):
     """
     Mixin for servers that start subcommands,
@@ -138,7 +157,7 @@ def get_server_features(self, _source) -> dict[str, Any]:
             "server-commands-info": not WIN32 and not OSX,
         }
 
-    def _get_xdg_menu_data(self) -> dict[str, Any] | None:
+    def _get_menu_data(self) -> dict[str, Any] | None:
         if not self.start_new_commands:
             return None
         assert self.menu_provider
@@ -159,34 +178,24 @@ def add_new_client(self, ss, c: typedict, send_ui: bool, share_count: int) -> No
         self.exec_on_connect_commands()
 
     def send_initial_data(self, ss, caps: typedict, send_ui: bool, share_count: int) -> None:
-        xdg_menu = getattr(ss, "xdg_menu", False)
-        log(f"send_initial_data(..) {xdg_menu=}")
-        if not xdg_menu:
+        menu = getattr(ss, "xdg_menu", False) or getattr(ss, "menu", False)
+        log(f"send_initial_data(..) {menu=}")
+        if not menu:
             return
         # this method may block if the menus are still being loaded,
         # so do it in a throw-away thread:
-        start_thread(self.send_xdg_menu_data, "send-xdg-menu-data", True, (ss,))
+        start_thread(self.send_menu_data, "send-xdg-menu-data", True, (ss,))
 
-    def send_xdg_menu_data(self, ss) -> None:
+    def send_menu_data(self, ss) -> None:
         if ss.is_closed():
             return
-        xdg_menu = self._get_xdg_menu_data() or {}
-        self.do_send_xdg_menu_data(ss, xdg_menu)
-
-    def do_send_xdg_menu_data(self, ss, xdg_menu):
-        if ss.is_closed():
-            return
-        if not getattr(ss, "send_setting_change", False):
-            return
-        if not getattr(ss, "xdg_menu", False):
-            return
-        ss.send_setting_change("xdg-menu", xdg_menu)
-        log(f"{len(xdg_menu)} menu data entries sent to {ss}")
+        menu = self._get_menu_data() or {}
+        do_send_menu_data(ss, menu)
 
-    def send_updated_menu(self, xdg_menu) -> None:
-        log("send_updated_menu(%s)", Ellipsizer(xdg_menu))
+    def send_updated_menu(self, menu) -> None:
+        log("send_updated_menu(%s)", Ellipsizer(menu))
         for source in tuple(self._server_sources.values()):
-            self.do_send_xdg_menu_data(source, xdg_menu)
+            do_send_menu_data(source, menu)
 
     def get_info(self, _proto) -> dict[str, Any]:
         info: dict[Any, Any] = {

xpra/server/subsystem/http.py

@@ -131,8 +131,8 @@ def get_info(self, _proto=None) -> dict[str, Any]:
         }
 
     def http_menu_request(self, _uri: str) -> HttpResponse:
-        xdg_menu = self.menu_provider.get_menu_data(remove_icons=True)
-        return send_json_response(xdg_menu or "not available")
+        menu = self.menu_provider.get_menu_data(remove_icons=True)
+        return send_json_response(menu or "not available")
 
     def http_desktop_menu_request(self, _uri: str) -> HttpResponse:
         xsessions = self.menu_provider.get_desktop_sessions(remove_icons=True)