#3473 pre-map windows capability

the opengl backend needed a way to wait until the drawing area is realized so that it can generate an opengl context

xpra/client/gl/gtk3/gl_drawing_area.py

@@ -18,6 +18,10 @@
 
 class GLDrawingArea(GLWindowBackingBase):
 
+    def __init__(self, wid : int, window_alpha : bool, pixel_depth : int=0):
+        self.on_realize_cb = []
+        super().__init__(wid, window_alpha, pixel_depth)
+
     def __repr__(self):
         return "GLDrawingArea(%s, %s, %s)" % (self.wid, self.size, self.pixel_format)
 
@@ -33,6 +37,7 @@ def is_double_buffered(self):
 
     def init_backing(self):
         da = Gtk.DrawingArea()
+        da.connect_after("realize", self.on_realize)
         #da.connect('configure_event', self.on_configure_event)
         #da.connect('draw', self.on_draw)
         #double-buffering is enabled by default anyway, so this is redundant:
@@ -42,6 +47,32 @@ def init_backing(self):
         da.show()
         self._backing = da
 
+    def on_realize(self, *args):
+        onrcb = self.on_realize_cb
+        log("GLDrawingArea.on_realize%s callbacks=%s", args, onrcb)
+        self.on_realize_cb = []
+        gl_context = self.gl_context()
+        with gl_context:
+            for x, args in onrcb:
+                try:
+                    x(gl_context, *args)
+                except Exception:
+                    log.error("Error calling realize callback %s", x, exc_info=True)
+
+    def with_gl_context(self, cb, *args):
+        da = self._backing
+        if da and da.get_mapped():
+            gl_context = self.gl_context()
+            if gl_context:
+                with gl_context:
+                    cb(gl_context, *args)
+            else:
+                cb(None, *args)
+        else:
+            log("GLDrawingArea.with_gl_context delayed: %s%s", cb, args)
+            self.on_realize_cb.append((cb, args))
+
+
     def get_bit_depth(self, pixel_depth=0):
         return pixel_depth or self.context.get_bit_depth() or 24
 

xpra/client/mixins/window_manager.py

@@ -79,6 +79,7 @@
 MOUSE_SCROLL_SQRT_SCALE = envbool("XPRA_MOUSE_SCROLL_SQRT_SCALE", OSX)
 MOUSE_SCROLL_MULTIPLIER = envint("XPRA_MOUSE_SCROLL_MULTIPLIER", 100)
 
+PRE_MAP = envbool("XPRA_PRE_MAP_WINDOWS", True)
 
 DRAW_TYPES = {bytes : "bytes", str : "bytes", tuple : "arrays", list : "arrays"}
 
@@ -339,6 +340,7 @@ def get_window_caps(self) -> dict:
             "min-size"                  : self.min_window_size,
             "max-size"                  : self.max_window_size,
             "restack"                   : True,
+            "pre-map"                   : PRE_MAP,
             }
 
 

xpra/server/source/windows_mixin.py

@@ -80,6 +80,7 @@ def init_state(self):
         self.window_min_size = 0, 0
         self.window_max_size = 0, 0
         self.window_restack = False
+        self.window_pre_map = False
         self.system_tray = False
         self.metadata_supported = ()
 
@@ -146,6 +147,7 @@ def parse_client_caps(self, c):
         self.window_min_size = c.inttupleget("window.min-size", (0, 0))
         self.window_max_size = c.inttupleget("window.max-size", (0, 0))
         self.window_restack = c.boolget("window.restack", False)
+        self.window_pre_map = c.boolget("window.pre-map", False)
         log("cursors=%s (encodings=%s), bell=%s",
             self.send_cursors, self.cursor_encodings, self.send_bell)
         #window filters:
@@ -169,6 +171,8 @@ def get_info(self) -> dict:
             "bell"          : self.send_bell,
             "system-tray"   : self.system_tray,
             "suspended"     : self.suspended,
+            "restack"       : self.window_restack,
+            "pre-map"       : self.window_pre_map,
             }
         wsize = info.setdefault("window-size", {})
         wsize.update({

xpra/x11/server.py

@@ -55,6 +55,7 @@
 SHARING_SYNC_SIZE = envbool("XPRA_SHARING_SYNC_SIZE", True)
 CLAMP_WINDOW_TO_ROOT = envbool("XPRA_CLAMP_WINDOW_TO_ROOT", False)
 ALWAYS_RAISE_WINDOW = envbool("XPRA_ALWAYS_RAISE_WINDOW", False)
+PRE_MAP = envbool("XPRA_PRE_MAP_WINDOWS", True)
 
 WINDOW_SIGNALS = os.environ.get("XPRA_WINDOW_SIGNALS", "SIGINT,SIGTERM,SIGQUIT,SIGCONT,SIGUSR1,SIGUSR2").split(",")
 
@@ -636,6 +637,18 @@ def _add_new_window(self, window):
         self._desktop_manager.add_window(window, x, y, w, h)
         window.managed_connect("notify::geometry", self._window_resized_signaled)
         self._send_new_window_packet(window)
+        if PRE_MAP:
+            #pre-map the window if any client supports this,
+            #so we can send the pixel data immediately after:
+            sources = tuple(filter(lambda source : getattr(source, "window_pre_map", False), self._server_sources.values()))
+            if sources:
+                wid = self._window_to_id.get(window)
+                log("pre-mapping window %i for %s", wid, sources)
+                self._desktop_manager.configure_window(window, x, y, w, h)
+                self._desktop_manager.show_window(window)
+                for s in sources:
+                    s.map_window(wid, window, (x, y, w, h))
+                self.schedule_configure_damage(wid, 0)
 
 
     def _window_resized_signaled(self, window, *args):
@@ -1108,7 +1121,7 @@ def _process_configure_window(self, proto, packet):
         if damage:
             self.schedule_configure_damage(wid)
 
-    def schedule_configure_damage(self, wid):
+    def schedule_configure_damage(self, wid, delay=CONFIGURE_DAMAGE_RATE):
         #rate-limit the damage events
         timer = self.configure_damage_timers.get(wid)
         if timer:
@@ -1118,7 +1131,7 @@ def damage():
             window = self._lookup_window(wid)
             if window and window.is_managed():
                 self.refresh_window(window)
-        self.configure_damage_timers[wid] = self.timeout_add(CONFIGURE_DAMAGE_RATE, damage)
+        self.configure_damage_timers[wid] = self.timeout_add(delay, damage)
 
     def cancel_configure_damage(self, wid):
         timer = self.configure_damage_timers.pop(wid, None)