def send():
root_window = get_xwindow(root)
window = get_xwindow(self.gdk_window())
X11WindowBindings.sendClientMessage(root_window, window, False,
event_mask, "_NET_WM_DESKTOP",
workspace,
const["CurrentTime"], 0, 0, 0)
def raw_prop_get(target, key, etype, ignore_errors=False, raise_xerrors=False):
def etypestr():
return _etypestr(etype)
if isinstance(etype, (list, tuple)):
scalar_type = etype[0]
else:
scalar_type = etype
atom = PROP_TYPES[scalar_type][1]
try:
buffer_size = PROP_SIZES.get(scalar_type, 64 * 1024)
with XSyncContext():
data = X11WindowBindings().XGetWindowProperty(
target.get_xid(), key, atom, etype, buffer_size)
if data is None:
if not ignore_errors:
log("Missing property %s (%s)", key, etype)
return None
except XError:
log("prop_get%s", (target, key, etype, ignore_errors, raise_xerrors),
exc_info=True)
if raise_xerrors:
raise
log.info("Missing window %s or wrong property type %s (%s)", target,
key, etypestr())
return None
except PropertyError as e:
log("prop_get%s", (target, key, etype, ignore_errors, raise_xerrors),
exc_info=True)
if not ignore_errors:
log.info("Missing property or wrong property type %s (%s)", key,
etypestr())
log.info(" %s", e)
return None
return data
def get_x11_property(atom_name):
from xpra.os_util import OSX, POSIX
if not POSIX or OSX:
return ""
display = os.environ.get("DISPLAY")
if not display:
return ""
try:
from xpra.x11.bindings.posix_display_source import X11DisplayContext #@UnresolvedImport
with X11DisplayContext(display) as dc:
from xpra.x11.bindings.window_bindings import X11WindowBindings
X11Window = X11WindowBindings()
root = X11Window.getDefaultRootWindow()
log("getDefaultRootWindow()=%#x", root)
try:
prop = X11Window.XGetWindowProperty(root, atom_name, "STRING")
except Exception as e:
log("cannot get X11 property '%s': %s", atom_name, e)
return ""
log("XGetWindowProperty(..)=%s", prop)
if prop:
from xpra.x11.prop_conv import prop_decode
v = prop_decode(dc.display, "latin1", prop)
log("get_x11_property(%s)=%s", atom_name, v)
return v
return ""
except Exception:
log.error("Error: cannot get X11 property '%s'",
atom_name,
exc_info=True)
log.error(" for python %s", sys.version_info)
log.error(" xpra command=%s", sys.argv)
return ""
def main():
window = gtk.Window(WINDOW_TOPLEVEL)
window.set_size_request(400, 100)
window.connect("delete_event", gtk.main_quit)
da = gtk.DrawingArea()
window.add(da)
window.show_all()
#self.selectX11FocusChange(self)
def focus_in(_window, event):
print("focus-in-event")
def focus_out(_window, event):
print("focus-out-event")
def has_toplevel_focus(_window, event):
print("has-toplevel-event")
window.connect("focus-in-event", focus_in)
window.connect("focus-out-event", focus_out)
window.connect("notify::has-toplevel-focus", has_toplevel_focus)
#x11 focus events:
gdk_win = window.get_window()
xid = get_xwindow(gdk_win)
init_gdk_display_source()
os.environ["XPRA_X11_DEBUG_EVENTS"] = "FocusIn,FocusOut"
init_x11_filter()
with xlog:
X11WindowBindings().selectFocusChange(xid)
gtk.main()
return 0
def main():
from xpra.platform.gui import init as gui_init
from xpra.platform import program_context
from xpra.gtk_common.error import xsync
with program_context("XSettings"):
gui_init()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
from xpra.log import get_all_loggers
for x in get_all_loggers():
x.enable_debug()
#naughty, but how else can I hook this up?
if os.name != "posix":
print("xsettings require a posix OS")
return 1
with xsync:
from xpra.x11.bindings.posix_display_source import init_posix_display_source #@UnresolvedImport
init_posix_display_source()
from xpra.x11.bindings.window_bindings import X11WindowBindings #@UnresolvedImport
window_bindings = X11WindowBindings()
selection = "_XSETTINGS_S0"
owner = window_bindings.XGetSelectionOwner(selection)
print("owner(%s)=%#x" % (selection, owner))
XSETTINGS = "_XSETTINGS_SETTINGS"
if owner:
data = window_bindings.XGetWindowProperty(
owner, XSETTINGS, XSETTINGS)
serial, settings = get_settings(None, data)
print("serial=%s" % serial)
print("%s settings:" % len(settings))
for s in settings:
print(s)
return 0
def main():
from xpra.platform.gui import init as gui_init
from xpra.platform import init as platform_init,clean
try:
platform_init("XSettings")
gui_init()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
from xpra.log import get_all_loggers
for x in get_all_loggers():
x.enable_debug()
#naughty, but how else can I hook this up?
import os
if os.name!="posix":
print("xsettings require a posix OS")
return 1
from xpra.x11.bindings import posix_display_source #@UnresolvedImport - takes care of hooking up the display
assert posix_display_source
from xpra.x11.bindings.window_bindings import X11WindowBindings #@UnresolvedImport
window_bindings = X11WindowBindings()
selection = "_XSETTINGS_S0"
owner = window_bindings.XGetSelectionOwner(selection)
print("owner(%s)=%#x" % (selection, owner))
XSETTINGS = "_XSETTINGS_SETTINGS"
data = window_bindings.XGetWindowProperty(owner, XSETTINGS, XSETTINGS)
serial, settings = get_settings(None, data)
print("serial=%s" % serial)
print("%s settings:" % len(settings))
for s in settings:
print(s)
return 0
finally:
clean()
def _get_X11_root_property(name, req_type):
try:
X11Window = X11WindowBindings()
root_xid = X11Window.getDefaultRootWindow()
return _get_X11_window_property(root_xid, name, req_type)
except Exception as e:
log.warn("Warning: failed to get X11 root property '%s'", name)
log.warn(" %s", e)
return None
def _get_X11_root_property(name, req_type):
try:
from xpra.x11.bindings.window_bindings import X11WindowBindings #@UnresolvedImport
window_bindings = X11WindowBindings()
root_xid = window_bindings.getDefaultRootWindow()
return _get_X11_window_property(root_xid, name, req_type)
except Exception as e:
log.warn("failed to get X11 root property %s: %s", name, e)
return None
def xsettings_owner(self):
with xlog:
from xpra.x11.bindings.window_bindings import X11WindowBindings #@UnresolvedImport
X11Window = X11WindowBindings()
owner_x = X11Window.XGetSelectionOwner(self._selection)
log("XGetSelectionOwner(%s)=%#x", self._selection, owner_x)
if owner_x == XNone:
return None
return get_pywindow(self._clipboard, owner_x)
def get_wm_info():
with xsync:
from gi.repository import Gdk #pylint: disable=import-outside-toplevel
display = Gdk.Display.get_default()
X11Window = X11WindowBindings()
screen = display.get_default_screen()
root = screen.get_root_window()
info = {
"display": display.get_name(),
"root": root.get_xid(),
"WM_S0": X11Window.XGetSelectionOwner(WM_S0) or 0,
"_NEW_WM_CM_S0": X11Window.XGetSelectionOwner(_NEW_WM_CM_S0) or 0,
}
ewmh_xid = raw_prop_get(root,
"_NET_SUPPORTING_WM_CHECK",
"window",
ignore_errors=False,
raise_xerrors=False)
if ewmh_xid:
ewmh_wm = prop_get(root,
"_NET_SUPPORTING_WM_CHECK",
"window",
ignore_errors=True,
raise_xerrors=False)
if ewmh_wm:
info["_NET_SUPPORTING_WM_CHECK"] = ewmh_wm.get_xid()
info["wmname"] = prop_get(ewmh_wm,
"_NET_WM_NAME",
"utf8",
ignore_errors=True,
raise_xerrors=False) or ""
else:
info["wmname"] = prop_get(root,
"_NET_WM_NAME",
"utf8",
ignore_errors=True,
raise_xerrors=False) or ""
for name, prop_name, prop_type in (
("xpra-server-pid", "XPRA_SERVER_PID", "u32"),
("xpra-vfb-pid", "XPRA_XVFB_PID", "u32"),
("xpra-server-version", "XPRA_SERVER", "latin1"),
("xpra-server-mode", "XPRA_SERVER_MODE", "latin1"),
("dbus-address", "DBUS_SESSION_BUS_ADDRESS", "latin1"),
("dbus-pid", "DBUS_SESSION_BUS_PID", "u32"),
("dbus-window", "DBUS_SESSION_BUS_WINDOW_ID", "u32"),
):
v = prop_get(root,
prop_name,
prop_type,
ignore_errors=True,
raise_xerrors=False)
if v:
info[name] = v
log("get_wm_info()=%s", info)
return info
def prop_get(target, key, etype, ignore_errors=False, raise_xerrors=False):
if isinstance(etype, (list, tuple)):
scalar_type = etype[0]
def etypestr():
return "array of %s" % scalar_type
else:
scalar_type = etype
def etypestr():
return "%s" % etype
atom = PROP_TYPES[scalar_type][1]
try:
buffer_size = PROP_SIZES.get(scalar_type, 64 * 1024)
with XSyncContext():
data = X11WindowBindings().XGetWindowProperty(
target.get_xid(), key, atom, etype, buffer_size)
if data is None:
if not ignore_errors:
log("Missing property %s (%s)", key, etype)
return None
except XError:
log("prop_get%s", (target, key, etype, ignore_errors, raise_xerrors),
exc_info=True)
if raise_xerrors:
raise
log.info("Missing window %s or wrong property type %s (%s)", target,
key, etypestr())
return None
except PropertyError as e:
log("prop_get%s", (target, key, etype, ignore_errors, raise_xerrors),
exc_info=True)
if not ignore_errors:
log.info("Missing property or wrong property type %s (%s)", key,
etypestr())
log.info(" %s", e)
return None
try:
with XSyncContext():
return prop_decode(target, etype, data)
except:
if ignore_errors:
log("prop_get%s",
(target, key, etype, ignore_errors, raise_xerrors),
exc_info=True)
return None
log.warn("Error parsing property '%s' (%s)", key, etypestr())
log.warn(" this may be a misbehaving application, or bug in Xpra")
try:
log.warn(" data length=%i", len(data))
except TypeError:
pass
log.warn(" data: %r", repr_ellipsized(str(data)), exc_info=True)
raise
def make_window():
window = Gtk.Window(type=Gtk.WindowType.TOPLEVEL)
window.set_title("Window Focus")
window.set_size_request(640, 200)
window.connect("delete_event", Gtk.main_quit)
vbox = Gtk.VBox()
N = 8
labels = []
font = Pango.FontDescription("sans 12")
for _ in range(N):
l = Gtk.Label()
l.modify_font(font)
labels.append(l)
for l in labels:
al = Gtk.Alignment(xalign=0, yalign=0.5, xscale=0.0, yscale=0)
al.add(l)
vbox.add(al)
window.add(vbox)
window.show_all()
text = deque(maxlen=N)
def update(s):
text.append("%s: %s" % (datetime.now(), s))
for i, t in enumerate(text):
labels[i].set_text(t)
#self.selectX11FocusChange(self)
def focus_in(_window, event):
update("focus-in-event")
def focus_out(_window, event):
update("focus-out-event")
def has_toplevel_focus(window, _event):
update("has-toplevel-focus: %s" % window.has_toplevel_focus())
window.connect("focus-in-event", focus_in)
window.connect("focus-out-event", focus_out)
window.connect("notify::has-toplevel-focus", has_toplevel_focus)
if POSIX and not OSX:
from xpra.gtk_common.error import xlog
from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source
from xpra.x11.gtk_x11.gdk_bindings import init_x11_filter
from xpra.x11.bindings.window_bindings import X11WindowBindings #pylint: disable=no-name-in-module
from xpra.os_util import is_Wayland
if not is_Wayland():
#x11 focus events:
gdk_win = window.get_window()
xid = gdk_win.get_xid()
init_gdk_display_source()
os.environ["XPRA_X11_DEBUG_EVENTS"] = "FocusIn,FocusOut"
init_x11_filter()
with xlog:
X11WindowBindings().selectFocusChange(xid)
return window
def send_net_showing_desktop(v):
from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source
from xpra.x11.bindings.window_bindings import constants, X11WindowBindings #@UnresolvedImport
init_gdk_display_source()
X11Window = X11WindowBindings()
root = window.get_window().get_screen().get_root_window()
root_xid = root.get_xid()
SubstructureNotifyMask = constants["SubstructureNotifyMask"]
SubstructureRedirectMask = constants["SubstructureRedirectMask"]
event_mask = SubstructureNotifyMask | SubstructureRedirectMask
X11Window.sendClientMessage(root_xid, root_xid, False, event_mask,
"_NET_SHOWING_DESKTOP", v)
def main():
from xpra.x11.gtk2 import gdk_display_source
assert gdk_display_source
from xpra.x11.gtk2.gdk_bindings import init_x11_filter, add_catchall_receiver #@UnresolvedImport
init_x11_filter()
root_window = gtk.gdk.get_default_root_window()
root_window.set_events(root_window.get_events()
| gtk.gdk.SUBSTRUCTURE_MASK)
r = receiver()
add_catchall_receiver("xpra-create-event", r)
X11WindowBindings().substructureRedirect(root_window.xid)
gtk.main()
def close(*args): from xpra.x11.gtk2 import gdk_display_source assert gdk_display_source from xpra.gtk_common.gtk_util import get_xwindow from xpra.x11.bindings.window_bindings import constants, X11WindowBindings #@UnresolvedImport X11Window = X11WindowBindings() root = window.get_window().get_screen().get_root_window() root_xid = get_xwindow(root) xwin = get_xwindow(window.get_window()) SubstructureNotifyMask = constants["SubstructureNotifyMask"] SubstructureRedirectMask = constants["SubstructureRedirectMask"] event_mask = SubstructureNotifyMask | SubstructureRedirectMask now = gtk.gdk.x11_get_server_time(window.get_window()) X11Window.sendClientMessage(root_xid, xwin, False, event_mask, "_NET_CLOSE_WINDOW", now, 1)
def moveresize_X11(self, *_args): new_x, new_y, new_width, new_height = self.get_new_geometry() from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source init_gdk_display_source() from xpra.x11.bindings.window_bindings import constants, X11WindowBindings #@UnresolvedImport X11Window = X11WindowBindings() root = self.get_window().get_screen().get_root_window() root_xid = root.xid xwin = self.get_window().xid SubstructureNotifyMask = constants["SubstructureNotifyMask"] SubstructureRedirectMask = constants["SubstructureRedirectMask"] event_mask = SubstructureNotifyMask | SubstructureRedirectMask X11Window.sendClientMessage(root_xid, xwin, False, event_mask, "_NET_MOVERESIZE_WINDOW", 1+2**8+2**9+2**10+2**11, new_x, new_y, new_width, new_height)
def _get_atom(_disp, d):
unpacked = struct.unpack(b"@L", d)[0]
if unpacked == 0:
log.warn("Warning: invalid zero atom value")
return None
with xsync:
pyatom = X11WindowBindings().XGetAtomName(unpacked)
if not pyatom:
log.error("invalid atom: %s - %s", repr(d), repr(unpacked))
return None
if not isinstance(pyatom, str):
#py3k:
return pyatom.decode()
return pyatom
def initiate(x_root, y_root, direction, button, source_indication):
#print("initiate%s" % str((x_root, y_root, direction, button, source_indication)))
from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source
init_gdk_display_source()
from xpra.x11.bindings.core_bindings import X11CoreBindings #@UnresolvedImport
from xpra.x11.bindings.window_bindings import constants, X11WindowBindings #@UnresolvedImport
event_mask = constants["SubstructureNotifyMask"] | constants["SubstructureRedirectMask"]
root_xid = get_root_window().get_xid()
xwin = window.get_window().get_xid()
X11Core = X11CoreBindings()
X11Core.UngrabPointer()
X11Window = X11WindowBindings()
X11Window.sendClientMessage(root_xid, xwin, False, event_mask, "_NET_WM_MOVERESIZE",
x_root, y_root, direction, button, source_indication)
def _get_X11_window_property(xid, name, req_type):
try:
from xpra.gtk_common.error import xsync
from xpra.x11.bindings.window_bindings import X11WindowBindings, PropertyError #@UnresolvedImport
window_bindings = X11WindowBindings()
try:
with xsync:
prop = window_bindings.XGetWindowProperty(xid, name, req_type)
log("_get_X11_window_property(%#x, %s, %s)=%s, len=%s", xid, name, req_type, type(prop), len(prop or []))
return prop
except PropertyError as e:
log("_get_X11_window_property(%#x, %s, %s): %s", xid, name, req_type, e)
except Exception as e:
log.warn("failed to get X11 window property %s on window %#x: %s", name, xid, e)
return None
def send_maximized_wm_state(mode):
from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source
init_gdk_display_source()
from xpra.x11.bindings.window_bindings import constants, X11WindowBindings #@UnresolvedImport
X11Window = X11WindowBindings()
root = window.get_window().get_screen().get_root_window()
root_xid = root.get_xid()
xwin = window.get_window().get_xid()
SubstructureNotifyMask = constants["SubstructureNotifyMask"]
SubstructureRedirectMask = constants["SubstructureRedirectMask"]
event_mask = SubstructureNotifyMask | SubstructureRedirectMask
X11Window.sendClientMessage(root_xid, xwin, False, event_mask,
"_NET_WM_STATE", mode,
"_NET_WM_STATE_MAXIMIZED_VERT",
"_NET_WM_STATE_MAXIMIZED_HORZ", 0, 0)
def __init__(self, window):
log("XI2_Window(%s)", window)
self.XI2 = X11XI2Bindings()
self.X11Window = X11WindowBindings()
self.window = window
self.xid = window.get_window().xid
self.windows = ()
window.connect("configure-event", self.configured)
self.configured()
#replace event handlers with XI2 version:
self.do_motion_notify_event = window.do_motion_notify_event
window.do_motion_notify_event = self.noop
window.do_button_press_event = self.noop
window.do_button_release_event = self.noop
window.do_scroll_event = self.noop
window.connect("destroy", self.cleanup)
def main():
x, y = 0, 0
if len(sys.argv) == 3:
x, y = int(sys.argv[1]), int(sys.argv[2])
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_size_request(width, height)
window.connect("delete_event", gtk.mainquit)
window.realize()
window.move(x, y)
from xpra.x11.gtk2.gdk_display_source import display
assert display
from xpra.x11.bindings.window_bindings import X11WindowBindings
hints = {"position": (x, y)}
X11WindowBindings().setSizeHints(window.get_window().xid, hints)
window.show_all()
gtk.main()
def _get_X11_root_property(name, req_type):
try:
from xpra.gtk_common.error import xsync
from xpra.x11.bindings.window_bindings import X11WindowBindings, PropertyError #@UnresolvedImport
window_bindings = X11WindowBindings()
root = window_bindings.getDefaultRootWindow()
try:
with xsync:
prop = window_bindings.XGetWindowProperty(root, name, req_type)
log("_get_X11_root_property(%s, %s)=%s, len=%s", name, req_type, type(prop), len(prop or []))
return prop
except PropertyError as e:
log("_get_X11_root_property(%s, %s): %s", name, req_type, e)
except Exception as e:
log.warn("failed to get X11 root property %s: %s", name, e)
return None
def main():
x, y = 0, 0
if len(sys.argv) == 3:
x, y = int(sys.argv[1]), int(sys.argv[2])
window = Gtk.Window(type=Gtk.WindowType.TOPLEVEL)
window.set_size_request(width, height)
window.connect("delete_event", Gtk.main_quit)
window.realize()
window.move(x, y)
from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source
init_gdk_display_source()
from xpra.x11.bindings.window_bindings import X11WindowBindings
hints = {"position": (x, y)}
X11WindowBindings().setSizeHints(window.get_window().get_xid(), hints)
window.show_all()
Gtk.main()
def _get_xsettings():
try:
from xpra.x11.bindings.window_bindings import X11WindowBindings #@UnresolvedImport
window_bindings = X11WindowBindings()
selection = "_XSETTINGS_S0"
owner = window_bindings.XGetSelectionOwner(selection)
if not owner:
return None
XSETTINGS = "_XSETTINGS_SETTINGS"
data = window_bindings.XGetWindowProperty(owner, XSETTINGS, XSETTINGS)
if not data:
return None
from xpra.x11.xsettings_prop import get_settings
return get_settings(window_bindings.get_display_name(), data)
except Exception as e:
log("_get_xsettings error: %s", e)
return None
def moveresize_X11(*args):
new_x, new_y, new_width, new_height = get_new_geometry()
from xpra.x11.gtk_x11 import gdk_display_source
assert gdk_display_source
from xpra.gtk_common.gobject_compat import get_xid
from xpra.x11.bindings.window_bindings import constants, X11WindowBindings #@UnresolvedImport
X11Window = X11WindowBindings()
root = window.get_window().get_screen().get_root_window()
root_xid = get_xid(root)
xwin = get_xid(window.get_window())
SubstructureNotifyMask = constants["SubstructureNotifyMask"]
SubstructureRedirectMask = constants["SubstructureRedirectMask"]
event_mask = SubstructureNotifyMask | SubstructureRedirectMask
X11Window.sendClientMessage(root_xid, xwin, False, event_mask,
"_NET_MOVERESIZE_WINDOW",
1 + 2**8 + 2**9 + 2**10 + 2**11, new_x,
new_y, new_width, new_height)
def _send_client_message(window, message_type, *values):
try:
from xpra.x11.gtk2 import gdk_display_source
assert gdk_display_source
from xpra.x11.bindings.window_bindings import constants, X11WindowBindings #@UnresolvedImport
X11Window = X11WindowBindings()
root_xid = X11Window.getDefaultRootWindow()
if window:
xid = get_xid(window)
else:
xid = root_xid
SubstructureNotifyMask = constants["SubstructureNotifyMask"]
SubstructureRedirectMask = constants["SubstructureRedirectMask"]
event_mask = SubstructureNotifyMask | SubstructureRedirectMask
X11Window.sendClientMessage(root_xid, xid, False, event_mask, message_type, *values)
except Exception as e:
log.warn("failed to send client message '%s' with values=%s: %s", message_type, values, e)
def main():
print("main()")
import gtk
import signal
from xpra.server.socket_util import create_unix_domain_socket
from xpra.x11.vfb_util import start_Xvfb, check_xvfb_process
from xpra.scripts.parsing import parse_cmdline
from xpra.scripts.main import configure_logging
from xpra.platform.dotxpra import DotXpra
script_file = sys.argv[0]
print("main() script_file=%s" % script_file)
cmdline = sys.argv
print("main() cmdline=%s" % cmdline)
parser, opts, args, mode = parse_cmdline(cmdline)
print("main() parser=%s" % parser)
print("main() options=%s" % opts)
print("main() mode=%s" % mode)
display_name = args.pop(0)
print("main() display=%s" % display_name)
assert mode == "start", "only start mode is supported by this test server"
configure_logging(opts, mode)
dotxpra = DotXpra(opts.socket_dir)
sockpath = dotxpra.socket_path(display_name)
socket, cleanup_socket = create_unix_domain_socket(sockpath)
sockets = [socket]
xvfb = start_Xvfb(opts.xvfb, display_name)
assert check_xvfb_process(xvfb), "xvfb error"
from xpra.x11.bindings import posix_display_source #@UnusedImport
from xpra.x11.bindings.window_bindings import X11WindowBindings #@UnresolvedImport
X11Window = X11WindowBindings()
assert X11Window
try:
app = UnrespondingServer()
app.init(opts)
app.init_sockets(sockets)
register_os_signals(app.signal_quit)
signal.signal(signal.SIGINT, app.signal_quit)
return app.run()
finally:
for display in gtk.gdk.display_manager_get().list_displays():
display.close()
xvfb.terminate()
cleanup_socket()
def _get_xsettings():
from xpra.gtk_common.error import xsync
try:
X11Window = X11WindowBindings()
with xsync:
selection = "_XSETTINGS_S0"
owner = X11Window.XGetSelectionOwner(selection)
if not owner:
return None
XSETTINGS = "_XSETTINGS_SETTINGS"
data = X11Window.XGetWindowProperty(owner, XSETTINGS, XSETTINGS)
if not data:
return None
from xpra.x11.xsettings_prop import get_settings
return get_settings(X11Window.get_display_name(), data)
except Exception as e:
log("_get_xsettings()", exc_info=True)
return None
def main():
print("main()")
import gtk
import signal
from xpra.scripts.server import setup_local_socket, start_Xvfb, check_xvfb_process
from xpra.scripts.main import parse_cmdline, configure_logging
from xpra.dotxpra import DotXpra
script_file = sys.argv[0]
print("main() script_file=%s" % script_file)
cmdline = sys.argv
print("main() cmdline=%s" % cmdline)
parser, opts, args, mode = parse_cmdline(cmdline)
print("main() parser=%s" % parser)
print("main() options=%s" % opts)
print("main() mode=%s" % mode)
display_name = args.pop(0)
print("main() display=%s" % display_name)
assert mode=="start", "only start mode is supported by this test server"
configure_logging(opts, mode)
dotxpra = DotXpra(opts.socket_dir)
socket, cleanup_socket = setup_local_socket(dotxpra, display_name, False, opts.mmap_group)
sockets = [socket]
xvfb = start_Xvfb(opts.xvfb, display_name)
assert check_xvfb_process(xvfb), "xvfb error"
from xpra.x11.gtk_x11 import gdk_display_source
assert gdk_display_source
from xpra.x11.bindings.window_bindings import X11WindowBindings #@UnresolvedImport
X11Window = X11WindowBindings()
assert X11Window
try:
app = UnrespondingServer()
app.init(opts)
app.init_sockets(sockets)
signal.signal(signal.SIGTERM, app.signal_quit)
signal.signal(signal.SIGINT, app.signal_quit)
return app.run()
finally:
for display in gtk.gdk.display_manager_get().list_displays():
display.close()
xvfb.terminate()
cleanup_socket()
def send():
root_window = get_xwindow(root)
window = get_xwindow(self.gdk_window())
X11WindowBindings.sendClientMessage(
root_window, window, False, event_mask, "_NET_WM_DESKTOP", workspace, constants["CurrentTime"], 0, 0, 0
)