Ticket #1934: window-filters.patch

xpra/server/mixins/server_base_controlcommands.py

@@ -98 +98 @@
             ArgsControlCommand("reset-video-region",    "reset video region heuristics",    min_args=1, max_args=1, validation=[int]),
             ArgsControlCommand("lock-batch-delay",      "set a specific batch delay for a window",       min_args=2, max_args=2, validation=[int, int]),
             ArgsControlCommand("unlock-batch-delay",    "let the heuristics calculate the batch delay again for a window (following a 'lock-batch-delay')",  min_args=1, max_args=1, validation=[int]),
+            ArgsControlCommand("remove-window-filters", "remove all window filters",        min_args=0, max_args=1),
+            ArgsControlCommand("add-window-filter",     "add a window filter",              min_args=4, max_args=5),
             ):
             cmd.do_run = getattr(self, "control_command_%s" % cmd.name.replace("-", "_"))
             self.control_commands[cmd.name] = cmd
@@ -281 +283 @@
         return "%s of '%s' to %s initiated" % (command_type, filename, client_uuids)
 
 
+    def control_command_remove_window_filters(self, client_uuids=""):
+        #modify the existing list object,
+        #which is referenced by all the sources
+        l = len(self.window_filters)
+        self.window_filters[:] = []
+        return "removed %i window-filters" % l
+
+    def control_command_add_window_filter(self, object_name, property_name, operator, value, client_uuids=""):
+        from xpra.server.window import filters
+        window_filter = filters.get_window_filter(object_name, property_name, operator, value)
+        #log("%s%s=%s", filters.get_window_filter, (object_name, property_name, operator, value), window_filter)
+        if client_uuids=="*":
+            #applies to all sources:
+            self.window_filters.append(("*", window_filter))
+        else:
+            sources = tuple(self._control_get_sources(client_uuids))
+            for ss in sources:
+                ss.do_add_window_filter(window_filter)
+        return "added window-filter: %s" % window_filter
+
+
     def control_command_compression(self, compression):
         c = compression.lower()
         from xpra.net import compression

xpra/server/server_base.py

@@ -314 +314 @@
 
         def drop_client(reason="unknown", *args):
             self.disconnect_client(proto, reason, *args)
-        ClientConnectionClass = self.get_server_source_class()
-        ss = ClientConnectionClass(proto, drop_client,
+        from xpra.server.source.client_connection import ClientConnection
+        ss = ClientConnection(proto, drop_client,
                           self.session_name, self,
                           self.idle_add, self.timeout_add, self.source_remove,
                           self.setting_changed,
@@ -335 +335 @@
         self.idle_add(self.parse_hello_ui, ss, c, auth_caps, send_ui, share_count)
 
 
-    def get_server_source_class(self):
-        from xpra.server.source.client_connection import ClientConnection
-        return ClientConnection
-
     def reset_window_filters(self):
         self.window_filters = []
 

xpra/server/source/windows_mixin.py

@@ -303 +303 @@
     def get_all_window_filters(self):
         return [f for uuid, f in self.window_filters if uuid==self.uuid]
 
-    def get_window_filter(self, object_name, property_name, operator, value):
-        if object_name!="window":
-            raise ValueError("invalid object name")
-        from xpra.server.window.filters import WindowPropertyIn, WindowPropertyNotIn
-        if operator=="=":
-            return WindowPropertyIn(property_name, [value])
-        elif operator=="!=":
-            return WindowPropertyNotIn(property_name, [value])
-        raise ValueError("unknown filter operator: %s" % operator)
-
     def add_window_filter(self, object_name, property_name, operator, value):
-        window_filter = self.get_window_filter(object_name, property_name, operator, value)
+        from xpra.server.window.filters import get_window_filter
+        window_filter = get_window_filter(object_name, property_name, operator, value)
         assert window_filter
-        self.window_filters.append((self.uuid, window_filter.show))
+        self.do_add_window_filter(window_filter)
 
+    def do_add_window_filter(self, window_filter):
+        #(reminder: filters are shared between all sources)
+        self.window_filters.append((self.uuid, window_filter))
+
     def can_send_window(self, window):
         if not self.hello_sent:
             return False
-        for uuid,x in self.window_filters:
-            v = x(window)
+        for uuid, window_filter in self.window_filters:
+            v = window_filter.can_show(window)
+            isuuidmatch = uuid==self.uuid or uuid=="*"
             if v is True:
-                return uuid==self.uuid
+                return isuuidmatch
+            elif v is False:
+                return not(isuuidmatch)
         if self.send_windows and self.system_tray:
             #common case shortcut
             return True

xpra/server/window/filters.py

@@ -6 +6 @@
 
 from xpra.log import Logger
 log = Logger("window")
+log.enable_debug()
 
 
 class WindowPropertyFilter(object):
-    def __init__(self, property_name, value):
+    def __init__(self, property_name, value, recurse=False):
         self.property_name = property_name
         self.value = value
+        self.recurse = recurse
 
+    def get_window(self, window):
+        return window.get_property("client-window")
+
     def get_window_value(self, window):
+        assert window
         return window.get_property(self.property_name)
 
-    def show(self, window):
+    def can_show(self, window):
         try:
-            v = self.get_window_value(window)
-            log("%s.show(%s) %s(..)=%s", type(self).__name__, window, self.get_window_value, v)
+            w = self.get_window(window)
+            log("get_window(%s)=%s", window, w)
+            v = self.get_window_value(w)
+            log("%s.can_show(%s) %s(..)=%s", self, w, self.get_window_value, v)
         except Exception:
-            log("%s.show(%s) %s(..) error:", type(self).__name__, window, self.get_window_value, exc_info=True)
+            log("%s.can_show(%s) %s(..) error:", self, w, self.get_window_value, exc_info=True)
             v = None
         e = self.evaluate(v)
+        log("%s.evaluate(%s)=%s", self, v, e)
         return e
 
     def evaluate(self, window_value):
@@ -35 +44 @@
     def evaluate(self, window_value):
         return window_value in self.value
 
+    def __repr__(self):
+        return "WindowPropertyIn(%s=%s, recurse=%s)" % (self.property_name, self.value, self.recurse)
 
+
 class WindowPropertyNotIn(WindowPropertyIn):
 
     def evaluate(self, window_value):
-        return not(WindowPropertyIn.evaluate(window_value))
+        return not(WindowPropertyIn.evaluate(self, window_value))
+
+    def __repr__(self):
+        return "WindowPropertyNotIn(%s=%s, recurse=%s)" % (self.property_name, self.value, self.recurse)
+
+
+def get_window_filter(object_name, property_name, operator, value):
+    oname = object_name.lower()
+    if oname not in ("window", "window-parent"):
+        raise ValueError("invalid object name '%s'" % object_name)
+    recurse = oname=="window-parent"
+    if operator=="=":
+        window_filter = WindowPropertyIn(property_name, [value], recurse)
+    elif operator=="!=":
+        window_filter = WindowPropertyNotIn(property_name, [value], recurse)
+    else:
+        raise ValueError("invalid window filter operator: %s" % operator)
+    log("get_window_filter%s=%s", (object_name, property_name, operator, value), window_filter)
+    return window_filter

xpra/x11/bindings/window_bindings.pyx

@@ -984 +984 @@
                                      xreq_type, &xactual_type,
                                      &actual_format, &nitems, &bytes_after, &prop)
         if status != Success:
-            raise None
+            raise XError("XGetWindowProperty status: %s" % status)
         if xactual_type == XNone:
-            raise None
+            raise BadPropertyType("None type")
         # This should only occur for bad property types:
         assert not (bytes_after and not nitems)
         if bytes_after:
-            raise None
+            raise BadPropertyType("incomplete data: %i bytes after" % bytes_after)
         assert actual_format in (8, 16, 32)
         XFree(prop)
         return self.XGetAtomName(xactual_type)

xpra/x11/x11_server_core.py

@@ -103 +103 @@
         self.current_keyboard_group = None
         with xsync:
             self.x11_init()
+        from xpra.server import server_features
+        if server_features.windows:
+            from xpra.x11.x11_window_filters import init_x11_window_filters
+            init_x11_window_filters()
 
+
     def x11_init(self):
         clean_keyboard_state()
         if self.fake_xinerama:
@@ -275 +280 @@
         self.input_devices = "xtest"
 
 
-    def get_server_source_class(self):
-        from xpra.x11.x11_source import X11ServerSource
-        return X11ServerSource
-
-
     def get_child_env(self):
         #adds fakeXinerama:
         env = super(X11ServerCore, self).get_child_env()