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