def dump_windows(): root = gtk.gdk.get_default_root_window() log("root window: %s" % root) children = get_children(root) log("%s windows" % len(children)) for window in get_children(root): log("found window: %s", window_info(window))
def dump_windows(): from xpra.log import Logger log = Logger("x11", "window") from gtk import gdk root = gdk.get_default_root_window() log("root window: %s" % root) try: from xpra.x11.gtk_x11.gdk_bindings import get_children #@UnresolvedImport except ImportError: pass else: children = get_children(root) log("%s windows" % len(children)) for window in get_children(root): log("found window: %s", window_info(window))
def update_children(self): ww, wh = self.client_window.get_geometry()[2:4] children = [] for w in get_children(self.client_window): xid = w.get_xid() if X11Window.is_inputonly(xid): continue geom = X11Window.getGeometry(xid) if not geom: continue if geom[2]==geom[3]==1: #skip 1x1 windows, as those are usually just event windows continue if geom[0]==geom[1]==0 and geom[2]==ww and geom[3]==wh: #exact same geometry as the window itself continue #record xid and geometry: children.append([xid]+list(geom)) self._internal_set_property("children", children)
def load_existing_windows(self, system_tray): # Tray handler: self._tray = None if system_tray: try: self._tray = SystemTray() except Exception as e: log.error("cannot setup tray forwarding: %s", e, exc_info=True) ### Create our window managing data structures: self._desktop_manager = DesktopManager() self._wm.get_property("toplevel").add(self._desktop_manager) self._desktop_manager.show_all() ### Load in existing windows: for window in self._wm.get_property("windows"): self._add_new_window(window) root = gtk.gdk.get_default_root_window() for window in get_children(root): if X11Window.is_override_redirect(window.xid) and X11Window.is_mapped(window.xid): self._add_new_or_window(window)
def load_existing_windows(self, system_tray): # Tray handler: self._tray = None if system_tray: try: self._tray = SystemTray() except Exception as e: log.error("cannot setup tray forwarding: %s", e, exc_info=True) ### Create our window managing data structures: self._desktop_manager = DesktopManager() self._wm.get_property("toplevel").add(self._desktop_manager) self._desktop_manager.show_all() ### Load in existing windows: for window in self._wm.get_property("windows"): self._add_new_window(window) root = gtk.gdk.get_default_root_window() for window in get_children(root): if X11Window.is_override_redirect( window.xid) and X11Window.is_mapped(window.xid): self._add_new_or_window(window)
def __init__(self, replace_other_wm, display=None): gobject.GObject.__init__(self) if display is None: display = gtk.gdk.display_manager_get().get_default_display() self._display = display self._alt_display = gtk.gdk.Display(self._display.get_name()) self._root = self._display.get_default_screen().get_root_window() self._ewmh_window = None self._windows = {} # EWMH says we have to know the order of our windows oldest to # youngest... self._windows_in_order = [] # Become the Official Window Manager of this year's display: self._wm_selection = xpra.x11.gtk_x11.selection.ManagerSelection(self._display, "WM_S0") self._cm_wm_selection = xpra.x11.gtk_x11.selection.ManagerSelection(self._display, "_NET_WM_CM_S0") self._wm_selection.connect("selection-lost", self._lost_wm_selection) self._cm_wm_selection.connect("selection-lost", self._lost_wm_selection) # May throw AlreadyOwned: if replace_other_wm: mode = self._wm_selection.FORCE else: mode = self._wm_selection.IF_UNOWNED self._wm_selection.acquire(mode) self._cm_wm_selection.acquire(mode) # Set up the necessary EWMH properties on the root window. self._setup_ewmh_window() # Start with just one desktop: self.do_desktop_list_changed([u"Main"]) self.set_current_desktop(0) # Start with the full display as workarea: root_w, root_h = gtk.gdk.get_default_root_window().get_size() self.root_set("_NET_SUPPORTED", ["atom"], self._NET_SUPPORTED) self.set_workarea(0, 0, root_w, root_h) self.set_desktop_geometry(root_w, root_h) self.root_set("_NET_DESKTOP_VIEWPORT", ["u32"], [0, 0]) # Load up our full-screen widget self._world_window = WorldWindow() self._world_window.set_screen(self._display.get_default_screen()) self.notify("toplevel") self._world_window.show_all() # Okay, ready to select for SubstructureRedirect and then load in all # the existing clients. add_event_receiver(self._root, self) X11Window.substructureRedirect(self._root.xid) for w in get_children(self._root): # Checking for FOREIGN here filters out anything that we've # created ourselves (like, say, the world window), and checking # for mapped filters out any withdrawn windows. if (w.get_window_type() == gtk.gdk.WINDOW_FOREIGN and not X11Window.is_override_redirect(w.xid) and X11Window.is_mapped(w.xid)): log("Wm managing pre-existing child") self._manage_client(w) # Also watch for focus change events on the root window X11Window.selectFocusChange(self._root.xid) X11Keyboard.selectBellNotification(True)
def __init__(self, replace_other_wm, wm_name, display=None): gobject.GObject.__init__(self) if display is None: display = display_get_default() self._display = display self._root = self._display.get_default_screen().get_root_window() self._wm_name = wm_name self._ewmh_window = None self._windows = {} # EWMH says we have to know the order of our windows oldest to # youngest... self._windows_in_order = [] # Become the Official Window Manager of this year's display: self._wm_selection = ManagerSelection(self._display, "WM_S0") self._cm_wm_selection = ManagerSelection(self._display, "_NET_WM_CM_S0") self._wm_selection.connect("selection-lost", self._lost_wm_selection) self._cm_wm_selection.connect("selection-lost", self._lost_wm_selection) # May throw AlreadyOwned: if replace_other_wm: mode = self._wm_selection.FORCE else: mode = self._wm_selection.IF_UNOWNED self._wm_selection.acquire(mode) self._cm_wm_selection.acquire(mode) # Set up the necessary EWMH properties on the root window. self._setup_ewmh_window() # Start with just one desktop: self.set_desktop_list((u"Main", )) self.set_current_desktop(0) # Start with the full display as workarea: root_w, root_h = get_default_root_window().get_geometry()[2:4] self.root_set("_NET_SUPPORTED", ["atom"], NET_SUPPORTED) self.set_workarea(0, 0, root_w, root_h) self.set_desktop_geometry(root_w, root_h) self.root_set("_NET_DESKTOP_VIEWPORT", ["u32"], [0, 0]) self.size_constraints = DEFAULT_SIZE_CONSTRAINTS # Load up our full-screen widget self._world_window = None if not is_gtk3(): self._world_window = WorldWindow( self._display.get_default_screen()) self.notify("toplevel") self._world_window.show_all() # Okay, ready to select for SubstructureRedirect and then load in all # the existing clients. add_event_receiver(self._root, self) add_fallback_receiver("xpra-client-message-event", self) #when reparenting, the events may get sent #to a window that is already destroyed #and we don't want to miss those events, so: add_fallback_receiver("child-map-request-event", self) rxid = get_xwindow(self._root) X11Window.substructureRedirect(rxid) for w in get_children(self._root): # Checking for FOREIGN here filters out anything that we've # created ourselves (like, say, the world window), and checking # for mapped filters out any withdrawn windows. xid = get_xwindow(w) if (w.get_window_type() == GDKWINDOW_FOREIGN and not X11Window.is_override_redirect(xid) and X11Window.is_mapped(xid)): log("Wm managing pre-existing child window %#x", xid) self._manage_client(w) # Also watch for focus change events on the root window X11Window.selectFocusChange(rxid) X11Keyboard.selectBellNotification(True)
class XpraServer(gobject.GObject, X11ServerBase): __gsignals__ = { "xpra-child-map-event": one_arg_signal, "xpra-cursor-event": one_arg_signal, } def __init__(self): gobject.GObject.__init__(self) X11ServerBase.__init__(self) def init(self, clobber, opts): X11ServerBase.init(self, clobber, opts) def x11_init(self): X11ServerBase.x11_init(self) init_x11_filter() self._has_focus = 0 # Do this before creating the Wm object, to avoid clobbering its # selecting SubstructureRedirect. root = gtk.gdk.get_default_root_window() root.set_events(root.get_events() | gtk.gdk.SUBSTRUCTURE_MASK) root.property_change(gtk.gdk.atom_intern("XPRA_SERVER", False), gtk.gdk.atom_intern("STRING", False), 8, gtk.gdk.PROP_MODE_REPLACE, xpra.__version__) add_event_receiver(root, self) ### Create the WM object self._wm = Wm(self.clobber) self._wm.connect("new-window", self._new_window_signaled) self._wm.connect("bell", self._bell_signaled) self._wm.connect("quit", lambda _: self.quit(True)) self.default_cursor_data = None self.last_cursor_serial = None self.send_cursor_pending = False self.cursor_data = None self.cursor_sizes = None def get_default_cursor(): self.default_cursor_data = X11Keyboard.get_cursor_image() log("get_default_cursor=%s", self.default_cursor_data) trap.swallow_synced(get_default_cursor) self._wm.enableCursors(True) def make_hello(self): capabilities = X11ServerBase.make_hello(self) capabilities["window.raise"] = True capabilities["pointer.grabs"] = True return capabilities def do_get_info(self, proto, server_sources, window_ids): info = X11ServerBase.do_get_info(self, proto, server_sources, window_ids) log("do_get_info: adding cursor=%s", self.cursor_data) #copy to prevent race: cd = self.cursor_data if cd is None: info["cursor"] = "None" else: info["cursor.is_default"] = bool(self.default_cursor_data and len(self.default_cursor_data)>=8 and len(cd)>=8 and cd[7]==cd[7]) #all but pixels: i = 0 for x in ("x", "y", "width", "height", "xhot", "yhot", "serial", None, "name"): if x: v = cd[i] or "" info["cursor." + x] = v i += 1 return info def get_ui_info(self, proto, wids, *args): info = X11ServerBase.get_ui_info(self, proto, wids, *args) #now cursor size info: display = gtk.gdk.display_get_default() for prop, size in {"default" : display.get_default_cursor_size(), "max" : display.get_maximal_cursor_size()}.items(): if size is None: continue info["cursor.%s_size" % prop] = size return info def get_window_info(self, window): info = X11ServerBase.get_window_info(self, window) info["focused"] = self._window_to_id.get(window, -1)==self._has_focus return info def set_workarea(self, workarea): self._wm.set_workarea(workarea.x, workarea.y, workarea.width, workarea.height) def get_transient_for(self, window): return self._desktop_manager.get_transient_for(window, self._window_to_id) def is_shown(self, window): return self._desktop_manager.is_shown(window) def cleanup(self, *args): if self._tray: self._tray.cleanup() self._tray = None X11ServerBase.cleanup(self) def load_existing_windows(self, system_tray): # Tray handler: self._tray = None if system_tray: try: self._tray = SystemTray() except Exception, e: log.error("cannot setup tray forwarding: %s", e, exc_info=True) ### Create our window managing data structures: self._desktop_manager = DesktopManager() self._wm.get_property("toplevel").add(self._desktop_manager) self._desktop_manager.show_all() ### Load in existing windows: for window in self._wm.get_property("windows"): self._add_new_window(window) root = gtk.gdk.get_default_root_window() for window in get_children(root): if X11Window.is_override_redirect(get_xwindow(window)) and X11Window.is_mapped(get_xwindow(window)): self._add_new_or_window(window)
def __init__(self, replace_other_wm, display=None): gobject.GObject.__init__(self) if display is None: display = gtk.gdk.display_manager_get().get_default_display() self._display = display self._alt_display = gtk.gdk.Display(self._display.get_name()) self._root = self._display.get_default_screen().get_root_window() self._ewmh_window = None self._windows = {} # EWMH says we have to know the order of our windows oldest to # youngest... self._windows_in_order = [] # Become the Official Window Manager of this year's display: self._wm_selection = xpra.x11.gtk_x11.selection.ManagerSelection( self._display, "WM_S0") self._cm_wm_selection = xpra.x11.gtk_x11.selection.ManagerSelection( self._display, "_NET_WM_CM_S0") self._wm_selection.connect("selection-lost", self._lost_wm_selection) self._cm_wm_selection.connect("selection-lost", self._lost_wm_selection) # May throw AlreadyOwned: if replace_other_wm: mode = self._wm_selection.FORCE else: mode = self._wm_selection.IF_UNOWNED self._wm_selection.acquire(mode) self._cm_wm_selection.acquire(mode) # Set up the necessary EWMH properties on the root window. self._setup_ewmh_window() # Start with just one desktop: self.do_desktop_list_changed([u"Main"]) self.set_current_desktop(0) # Start with the full display as workarea: root_w, root_h = gtk.gdk.get_default_root_window().get_size() self.root_set("_NET_SUPPORTED", ["atom"], self._NET_SUPPORTED) self.set_workarea(0, 0, root_w, root_h) self.root_set("_NET_DESKTOP_VIEWPORT", ["u32"], [0, 0]) # Load up our full-screen widget self._world_window = WorldWindow() self._world_window.set_screen(self._display.get_default_screen()) self.notify("toplevel") self._world_window.show_all() # Okay, ready to select for SubstructureRedirect and then load in all # the existing clients. add_event_receiver(self._root, self) X11Window.substructureRedirect(get_xwindow(self._root)) for w in get_children(self._root): # Checking for FOREIGN here filters out anything that we've # created ourselves (like, say, the world window), and checking # for mapped filters out any withdrawn windows. if (w.get_window_type() == gtk.gdk.WINDOW_FOREIGN and not X11Window.is_override_redirect(get_xwindow(w)) and X11Window.is_mapped(get_xwindow(w))): log("Wm managing pre-existing child") self._manage_client(w) # Also watch for focus change events on the root window X11Window.selectFocusChange(get_xwindow(self._root)) X11Keyboard.selectBellNotification(True)