def main():
from xpra.platform import program_context
with program_context("OSX-Shadow-Test", "OSX Shadow Test"):
defaults = make_defaults_struct()
for x in ("daemon", "clipboard", "mmap", "speaker", "microphone",
"cursors", "bell", "notifications",
"system_tray", "sharing",
"delay_tray", "opengl"):
setattr(defaults, x, False)
loop_exit = gtk.main_quit
loop_run = gtk.main
XPRA_DISPLAY = ":10"
sp = "~/.xpra/%s-%s" % (socket.gethostname(), XPRA_DISPLAY[1:])
sockpath = os.path.expanduser(sp)
listener = socket.socket(socket.AF_UNIX)
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.setblocking(1)
listener.bind(sockpath)
sockets = [listener]
ss = ShadowServer()
ss.init(sockets, defaults)
ss.run()
gobject.timeout_add(1000*120, loop_exit)
loop_run()
def main():
from xpra.platform import program_context
from xpra.platform.gui import init as gui_init
with program_context("About"):
gui_init()
about(on_close=gtk.main_quit)
gtk.main()
def main():
from xpra.platform import program_context
from xpra.platform.gui import ready as gui_ready
with program_context("Start-New-Command", "Start New Command"):
#logging init:
if "-v" in sys.argv:
enable_debug_for("util")
from xpra.os_util import SIGNAMES
from xpra.gtk_common.quit import gtk_main_quit_on_fatal_exceptions_enable
gtk_main_quit_on_fatal_exceptions_enable()
app = StartNewCommand()
app.close = app.quit
def app_signal(signum, frame):
print("")
log.info("got signal %s", SIGNAMES.get(signum, signum))
app.quit()
signal.signal(signal.SIGINT, app_signal)
signal.signal(signal.SIGTERM, app_signal)
try:
gui_ready()
app.show()
app.run()
except KeyboardInterrupt:
pass
return 0
def main(force_enable=False):
from xpra.platform import program_context
from xpra.platform.gui import init as gui_init
from xpra.util import print_nested_dict
from xpra.log import enable_color
with program_context("OpenGL-Check"):
gui_init()
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
from xpra.client.gl.gtk_compat import log as clog
clog.enable_debug()
# replace ImportError with a log message:
global gl_check_error
errors = []
def log_error(msg):
log.error("ERROR: %s", msg)
errors.append(msg)
gl_check_error = log_error
props = check_support(force_enable, verbose)
log.info("")
if len(errors) > 0:
log.info("OpenGL errors:")
for e in errors:
log.info(" %s", e)
log.info("")
log.info("OpenGL properties:")
print_nested_dict(props)
return len(errors)
def main():
if "-v" in sys.argv or "--verbose" in sys.argv:
from xpra.log import add_debug_category, enable_debug_for
add_debug_category("printing")
enable_debug_for("printing")
try:
sys.argv.remove("-v")
except:
pass
try:
sys.argv.remove("--verbose")
except:
pass
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("PyCUPS Printing"):
enable_color()
validate_setup()
log.info("")
log.info("printer definitions:")
for k, v in get_printer_definitions().items():
log.info("* %-32s: %s", k, v)
log.info("")
log.info("local printers:")
printers = get_printers()
for k, d in get_all_printers().items():
log.info("* %s%s", k, [" (NOT EXPORTED)", ""][int(k in printers)])
for pk, pv in d.items():
if pk == "printer-state" and pv in PRINTER_STATE:
pv = "%s (%s)" % (pv, PRINTER_STATE.get(pv))
log.info(" %-32s: %s", pk, pv)
def main():
from xpra.platform import program_context
with program_context("Platform-Events", "Platform Events Test"):
if "-v" in sys.argv or "--verbose" in sys.argv:
from xpra.platform.win32.win32_events import log as win32_event_logger
log.enable_debug()
win32_event_logger.enable_debug()
import gobject
gobject.threads_init() #@UndefinedVariable
log.info("Event loop is running")
loop = gobject.MainLoop()
def suspend():
log.info("suspend event")
def resume():
log.info("resume event")
fake_client = AdHocStruct()
fake_client.window_with_grab = None
fake_client.suspend = suspend
fake_client.resume = resume
fake_client.keyboard_helper = None
def signal_quit(*args):
loop.quit()
fake_client.signal_disconnect_and_quit = signal_quit
ClientExtras(fake_client, None)
try:
loop.run()
except KeyboardInterrupt:
log.info("exiting on keyboard interrupt")
def main():
from xpra.util import nonl
def print_options(o):
for k,ot in sorted(OPTION_TYPES.items()):
v = getattr(o, name_to_field(k), "")
if ot==bool and v is None:
v = "Auto"
if type(v)==list:
v = ", ".join(str(x) for x in v)
print("* %-32s : %s" % (k, nonl(v)))
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("Config-Info", "Config Info"):
enable_color()
args = list(sys.argv[1:])
if "-v" in args or "--verbose" in sys.argv:
global debug
def debug(*args):
print(args[0] % args[1:])
args.remove("-v")
print("Default Configuration:")
print_options(make_defaults_struct())
if len(args)>0:
for filename in args:
print("")
print("Configuration file '%s':" % filename)
if not os.path.exists(filename):
print(" Error: file not found")
continue
d = read_config(filename)
config = dict_to_validated_config(d)
print_options(config)
def main():
global pygst_version, gst_version, gst_vinfo
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("GStreamer-Info", "GStreamer Information"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
import_gst()
print("Loaded Python GStreamer version %s for Python %s.%s" % (gst_vinfo, sys.version_info[0], sys.version_info[1]))
apn = get_all_plugin_names()
print("GStreamer plugins found: %s" % csv(apn))
print("")
print("GStreamer version: %s" % ".".join([str(x) for x in gst_version]))
print("PyGStreamer version: %s" % ".".join([str(x) for x in pygst_version]))
print("")
encs = [x for x in CODEC_ORDER if has_encoder(x)]
decs = [x for x in CODEC_ORDER if has_decoder(x)]
print("encoders supported: %s" % csv(encs))
print("decoders supported: %s" % csv(decs))
print("muxers supported: %s" % csv(get_muxers()))
print("demuxers supported: %s" % csv(get_demuxers()))
print("source plugins: %s" % csv([x for x in get_source_plugins() if x in apn]))
print("sink plugins: %s" % csv([x for x in get_sink_plugins() if x in apn]))
print("default sink: %s" % get_default_sink())
def main(args):
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("GTK-Menu Info"):
enable_color()
if "-q" in sys.argv:
sys.argv.remove("-q")
elif "--quiet" in sys.argv:
sys.argv.remove("--quiet")
else:
log.enable_debug()
from xpra.dbus.gtk_menuactions import log as gtkmalog
gtkmalog.enable_debug()
try:
from xpra.x11.gtk2.gdk_display_source import display #@UnresolvedImport
wid = sys.argv[1]
if wid.startswith("0x"):
xid = int(wid[2:], 16)
else:
xid = int(wid)
except Exception as e:
log.error("Error: invalid window id: %s", e)
log.error("usage:")
log.error(" %s WINDOWID", sys.argv[0])
else:
#beware: this import has side-effects:
import dbus.glib
assert dbus.glib
from xpra.dbus.common import loop_init
loop_init()
import gobject
loop = gobject.MainLoop()
v = dump_menuactions(display, xid)
loop.run()
del v
def main():
from xpra.platform.gui import init as gui_init
from xpra.platform import program_context
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
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
def main():
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("Keyboard-Test", "Keyboard Test Tool"):
enable_color()
KeyboardStateInfoWindow()
gtk.main()
def main():
from xpra.platform import program_context
from xpra.util import print_nested_dict
from xpra.log import enable_color
with program_context("GUI-Properties"):
enable_color()
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":
try:
from xpra.x11.bindings import posix_display_source # @UnusedImport
except:
pass # maybe running on OSX? hope for the best..
i = get_info()
print_nested_dict(i)
def main():
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("Features-Info", "Features Info"):
d = {}
for k in _features_list_:
d[k] = globals()[k]
print_nested_dict(d)
def main():
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("Keyboard-Test", "Keyboard Test Tool"):
enable_color()
KeyboardStateInfoWindow()
gtk.main()
return 0
def main():
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("Features-Info", "Features Info"):
d = {}
for k in _features_list_:
d[k] = globals()[k]
print_nested_dict(d)
def main():
from xpra.platform import program_context
from xpra.platform.gui import ready as gui_ready
with program_context("Start-New-Command", "Start New Command"):
#logging init:
if "-v" in sys.argv:
enable_debug_for("util")
from xpra.os_util import SIGNAMES
from xpra.gtk_common.quit import gtk_main_quit_on_fatal_exceptions_enable
gtk_main_quit_on_fatal_exceptions_enable()
client = AdHocStruct()
client.server_last_info_time = monotonic_time()
commands_info = {
0: {'returncode': None, 'name': 'xterm', 'pid': 542, 'dead': False, 'ignore': True, 'command': ('xterm',), 'forget': False},
'start-child' : (),
'start-new' : True,
'start-after-connect-done' : True,
'start' : ('xterm',),
'start-after-connect' : (),
'start-child-on-connect' : (),
'exit-with-children' : False,
'start-child-after-connect': (),
'start-on-connect' : (),
}
client.server_last_info = {"commands" : commands_info}
client.server_start_new_commands = True
client.server_commands_signals = ("SIGINT", "SIGTERM", "SIGUSR1")
def noop(*_args):
pass
client.send_info_request = noop
client.send = noop
window1 = AdHocStruct()
window1._metadata = {"pid" : 542}
client._id_to_window = {
1 : window1
}
def show_start_new_command(*_args):
from xpra.client.gtk_base.start_new_command import getStartNewCommand
getStartNewCommand(None).show()
client.show_start_new_command = show_start_new_command
app = ServerCommandsWindow(client)
app.hide = app.quit
def app_signal(signum, _frame):
print("")
log.info("got signal %s", SIGNAMES.get(signum, signum))
app.quit()
signal.signal(signal.SIGINT, app_signal)
signal.signal(signal.SIGTERM, app_signal)
try:
gui_ready()
app.show()
app.run()
except KeyboardInterrupt:
pass
return 0
def main(args):
from xpra.platform import program_context
from xpra.log import enable_color, LOG_FORMAT, NOPREFIX_FORMAT
from xpra.util import print_nested_dict, pver
with program_context("Loader", "Encoding Info"):
verbose = "-v" in args or "--verbose" in args
args = [x for x in args if x not in ("-v", "--verbose")]
format_string = NOPREFIX_FORMAT
if verbose:
format_string = LOG_FORMAT
log.enable_debug()
enable_color(format_string)
if len(args)>1:
for x in args[1:]:
load_codec(x)
list_codecs = args[1:]
else:
load_codecs()
list_codecs = ALL_CODECS
#not really a codec, but gets used by codecs, so include version info:
add_codec_version("numpy", "numpy")
print("codecs and csc modules found:")
#print("codec_status=%s" % codecs)
for name in sorted(list_codecs):
mod = codecs.get(name, "")
f = mod
if mod and hasattr(mod, "__file__"):
f = mod.__file__
if f.startswith(os.getcwd()):
f = f[len(os.getcwd()):]
if f.startswith(os.path.sep):
f = f[1:]
print("* %s : %s" % (name.ljust(20), f))
if mod and verbose:
try:
if name.find("csc")>=0:
cs = list(mod.get_input_colorspaces())
for c in list(cs):
cs += list(mod.get_output_colorspaces(c))
print(" colorspaces: %s" % csv(list(set(cs))))
elif name.find("enc")>=0 or name.find("dec")>=0:
encodings = mod.get_encodings()
print(" encodings: %s" % csv(encodings))
try:
i = mod.get_info()
for k,v in sorted(i.items()):
print(" %s = %s" % (k,v))
except Exception:
pass
except Exception as e:
print("error getting extra information on %s: %s" % (name, e))
print("")
print("codecs versions:")
def forcever(v):
return pver(v, numsep=".", strsep=".").lstrip("v")
print_nested_dict(codec_versions, vformat=forcever)
return 0
def main():
from xpra.platform import program_context
with program_context("Codec-Constants", "Codec Constants Info"):
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
log.info("LOSSY_PIXEL_FORMATS=%s", LOSSY_PIXEL_FORMATS)
log.info("PIXEL_SUBSAMPLING=%s", PIXEL_SUBSAMPLING)
log.info("RGB_FORMATS=%s", RGB_FORMATS)
def main():
from xpra.util import print_nested_dict
crypto_backend_init()
from xpra.platform import program_context
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
with program_context("Encryption Properties"):
print_nested_dict(get_crypto_caps())
def main():
with program_context("file-chooser", "File Chooser"):
file_filter = Gtk.FileFilter()
file_filter.set_name("Xpra")
file_filter.add_pattern("*.xpra")
window = None
choose_file(window, "test", Gtk.FileChooserAction.OPEN, Gtk.STOCK_OPEN,
None)
return 0
def do_main(opts):
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("Xpra-Session-Browser", "Xpra Session Browser"):
enable_color()
gui = SessionsGUI(opts)
gtk_main()
log.info("do_main() gui.exit_code=%i", gui.exit_code)
return gui.exit_code
def main():
from xpra.platform import program_context
with program_context("Shadow-Test", "Shadow Server Screen Capture Test"):
rwm = RootWindowModel(None)
pngdata = rwm.take_screenshot()
FILENAME = "screenshot.png"
with open(FILENAME, "wb") as f:
f.write(pngdata[4])
print("saved screenshot as %s" % FILENAME)
def main():
from xpra.util import print_nested_dict
crypto_backend_init()
from xpra.platform import program_context
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
with program_context("Encryption Properties"):
print_nested_dict(get_crypto_caps())
def main():
from xpra.platform import program_context
with program_context("Shadow-Test", "Shadow Server Screen Capture Test"):
rwm = Win32RootWindowModel(None)
pngdata = rwm.take_screenshot()
FILENAME = "screenshot.png"
with open(FILENAME , "wb") as f:
f.write(pngdata[4])
print("saved screenshot as %s" % FILENAME)
def main():
if "-v" in sys.argv or "--verbose" in sys.argv:
from xpra.log import add_debug_category
add_debug_category("util")
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("Path-Info", "Path Info"):
print_nested_dict(get_info())
def main():
from xpra.platform import program_context
with program_context("Codec-Constants", "Codec Constants Info"):
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
log.info("LOSSY_PIXEL_FORMATS=%s", LOSSY_PIXEL_FORMATS)
log.info("PIXEL_SUBSAMPLING=%s", PIXEL_SUBSAMPLING)
log.info("RGB_FORMATS=%s", RGB_FORMATS)
def main():
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
add_debug_category("nvfbc")
from xpra.platform import program_context
with program_context("NvFBC-Capture", "NvFBC Capture"):
from xpra.platform.paths import get_download_dir
from xpra.util import print_nested_dict
from xpra.os_util import WIN32, LINUX
if WIN32:
from xpra.codecs.nvfbc import fbc_capture_win as fbc_capture #@UnresolvedImport @UnusedImport
elif LINUX:
from xpra.codecs.nvfbc import fbc_capture_linux as fbc_capture #@UnresolvedImport @Reimport
else:
raise Exception("nvfbc is not support on %s" % sys.platform)
fbc_capture.init_module()
log.info("Info:")
print_nested_dict(fbc_capture.get_info(), print_fn=log.info)
log.info("Status:")
print_nested_dict(fbc_capture.get_status(), print_fn=log.info)
try:
log("creating test capture class")
if USE_NVFBC_CUDA:
c = fbc_capture.NvFBC_CUDACapture() #@UndefinedVariable
else:
c = fbc_capture.NvFBC_SysCapture() #@UndefinedVariable
log("Capture=%s", c)
c.init_context()
assert c.refresh()
except Exception as e:
log("Capture()", exc_info=True)
log.error("Error: failed to create test capture instance:")
log.error(" %s", e)
return 1
image = c.get_image()
assert image
from PIL import Image
w = image.get_width()
h = image.get_height()
pixels = memoryview_to_bytes(image.get_pixels())
stride = image.get_rowstride()
rgb_format = image.get_pixel_format()
try:
img = Image.frombuffer("RGB", (w, h), pixels, "raw", rgb_format,
stride, 1)
filename = os.path.join(
os.path.expanduser(get_download_dir()),
"screenshot-%s-%i.png" % (rgb_format, time.time()))
img.save(filename, "png")
log.info("screenshot saved to %s", filename)
return 0
except Exception as e:
log.warn("Error: failed to save %s:", rgb_format)
log.warn(" %s", e)
return 1
def main():
with program_context("gl-colors-gradient", "OpenGL Colors Gradient"):
import signal
def signal_handler(*_args):
Gtk.main_quit()
signal.signal(signal.SIGINT, signal_handler)
ColorTest()
Gtk.main()
def do_main(opts):
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("Xpra-Session-Browser", "Xpra Session Browser"):
enable_color()
gui = SessionsGUI(opts)
register_os_signals(gui.app_signal)
Gtk.main()
log("do_main() gui.exit_code=%i", gui.exit_code)
return gui.exit_code
def main():
with program_context("text-entry", "Text Entry"):
w = make_window()
add_close_accel(w, Gtk.main_quit)
def show_with_focus():
force_focus()
w.show_all()
w.present()
GLib.idle_add(show_with_focus)
Gtk.main()
def main():
#use gtk as display source:
from xpra.x11.gtk2 import gdk_display_source
assert gdk_display_source
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("GTK-Keyboard", "GTK Keyboard"):
x = GTKKeyboardHelper(None, True, "")
x.query_xkbmap()
print_nested_dict(x.get_keymap_properties())
def main():
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.util import print_nested_dict
with program_context("Pulseaudio-Info"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
i = get_info()
print_nested_dict(i)
def main():
#use gtk as display source:
from xpra.x11.gtk2 import gdk_display_source
assert gdk_display_source
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("GTK-Keyboard", "GTK Keyboard"):
x = GTKKeyboardHelper(None, True, "")
x.query_xkbmap()
print_nested_dict(x.get_keymap_properties())
def main():
with program_context("tray", "Tray"):
from xpra.gtk_common.gobject_compat import register_os_signals
def signal_handler(*_args):
Gtk.main_quit()
register_os_signals(signal_handler)
FakeApplication()
Gtk.main()
def main():
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("Pulseaudio-Info"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
i = get_info()
for k in sorted(i):
log.info("%s : %s", k.ljust(64), i[k])
def main():
with program_context("tray", "Tray"):
import signal
def signal_handler(*_args):
Gtk.main_quit()
signal.signal(signal.SIGINT, signal_handler)
FakeApplication()
Gtk.main()
def main():
with program_context("font-rendering", "Font Rendering"):
from xpra.gtk_common.gobject_compat import register_os_signals
def signal_handler(*_args):
Gtk.main_quit()
register_os_signals(signal_handler)
w = FontWindow()
add_close_accel(w, Gtk.main_quit)
GLib.idle_add(w.show_with_focus)
Gtk.main()
def main():
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.util import print_nested_dict
with program_context("Pulseaudio-Info"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
i = get_info()
print_nested_dict(i)
def do_main(opts):
import os
if os.environ.get("XPRA_HIDE_DOCK") is None:
os.environ["XPRA_HIDE_DOCK"] = "1"
from xpra.platform import program_context
with program_context("qrcode", "QRCode"):
Gtk.Window.set_auto_startup_notification(False)
c = QRCodeClient(opts)
#add_close_accel(w, Gtk.main_quit)
return c.run()
def main(_args):
import os
if os.environ.get("XPRA_HIDE_DOCK") is None:
os.environ["XPRA_HIDE_DOCK"] = "1"
from xpra.platform import program_context
with program_context("splash", "Splash"):
Gtk.Window.set_auto_startup_notification(False)
w = SplashScreen()
add_close_accel(w, Gtk.main_quit)
return w.run()
def main():
from xpra.gtk_common.gobject_compat import register_os_signals
with program_context("clicks", "Clicks"):
w = TestForm()
add_close_accel(w.window, Gtk.main_quit)
GLib.idle_add(w.show_with_focus)
def signal_handler(signal):
Gtk.main_quit()
register_os_signals(signal_handler)
Gtk.main()
def main():
import sys
from xpra.os_util import WIN32, OSX, POSIX, bytestostr
from xpra.util import print_nested_dict, csv
from xpra.platform import program_context
from xpra.log import Logger, enable_color
with program_context("Keyboard-Tool", "Keyboard Tool"):
#use the logger for the platform module we import from
global log
log = None
platform_import(globals(), "keyboard", True, "log")
if log is None:
log = Logger("keyboard")
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv or \
(WIN32 and not ("-q" in sys.argv or "--quiet"))
if verbose:
log.enable_debug()
#naughty, but how else can I hook this up?
if POSIX and not OSX:
try:
from xpra.x11.bindings.posix_display_source import init_posix_display_source #@UnresolvedImport
init_posix_display_source()
except Exception as e:
print("failed to connect to the X11 server:")
print(" %s" % e)
#hope for the best..
keyboard = Keyboard()
mod_meanings, mod_managed, mod_pointermissing = keyboard.get_keymap_modifiers(
)
print("Modifiers:")
print_nested_dict(mod_meanings)
print("")
print("Server Managed : %s" %
(csv(mod_managed) or "None"))
print("Missing from pointer events : %s" %
(csv(mod_pointermissing) or "None"))
print("")
layout, layouts, variant, variants, options = keyboard.get_layout_spec(
)
print("Layout: '%s'" % bytestostr(layout or b""))
print("Layouts: %s" % csv("'%s'" % x for x in (layouts or [])))
print("Variant: '%s'" % bytestostr(variant or b""))
print("Variants: %s" % csv("'%s'" % x for x in (variants or [])))
print("Options: %s" % (options))
print("")
print("Repeat: %s" % csv(keyboard.get_keyboard_repeat()))
if verbose and POSIX:
keysyms = keyboard.get_x11_keymap()
if keysyms:
print("Keysyms:")
for keycode, keysyms in keysyms.items():
print(" %3i : %s" % (keycode, csv(keysyms)))
def main():
with program_context("Network-Test", "Xpra Network Protocol Test Tool"):
mainloop = gobject.MainLoop()
ss = SimpleServer()
ss.init(mainloop.quit)
def start_client(*args):
sc = SimpleClient()
sc.init(mainloop.quit, [("hello", ()), ("disconnect", "because we want to")])
return False
gobject.timeout_add(1000*1, start_client)
mainloop.run()
def main():
with program_context("Clipboard-Test", "Primary Clipboard Test Tool"):
frc = FakeRemoteClipboard()
gobject.timeout_add(1000, frc.fake_token)
# gobject.timeout_add(1200, fake_target, 0)
# gobject.timeout_add(1400, fake_target, 1)
# gobject.timeout_add(1600, fake_target, 2)
# gobject.timeout_add(1800, fake_data, 2)
# gobject.timeout_add(2500, fake_data, 3)
# gobject.timeout_add(3500, fake_data, 5)
gtk.main()
def main():
from xpra.gtk_common.gobject_compat import register_os_signals
with program_context("initiate-moveresize", "Initiate Move-Resize"):
w = make_window()
w.show_all()
add_close_accel(w, Gtk.main_quit)
def signal_handler(signal):
Gtk.main_quit()
register_os_signals(signal_handler)
Gtk.main()
return 0
def main():
with program_context("window-states", "Window States"):
w = make_window()
def show_with_focus():
force_focus()
w.show_all()
w.present()
add_close_accel(w, Gtk.main_quit)
GLib.idle_add(show_with_focus)
Gtk.main()
return 0
def main():
with program_context("Clipboard-Test", "Primary Clipboard Test Tool"):
frc = FakeRemoteClipboard()
gobject.timeout_add(1000, frc.fake_token)
#gobject.timeout_add(1200, fake_target, 0)
#gobject.timeout_add(1400, fake_target, 1)
#gobject.timeout_add(1600, fake_target, 2)
#gobject.timeout_add(1800, fake_data, 2)
#gobject.timeout_add(2500, fake_data, 3)
#gobject.timeout_add(3500, fake_data, 5)
gtk.main()
def main():
name = "test"
if len(sys.argv) >= 2:
name = sys.argv[1]
from xpra.platform import program_context
with program_context(name, name):
notify()
from gi.repository import GLib
GLib.timeout_add(60 * 1000, notify)
loop = GLib.MainLoop()
loop.run()
def main():
from xpra.platform import program_context
with program_context("Password-Input-Dialog", "Password Input Dialog"):
if "-v" in sys.argv:
from xpra.log import enable_debug_for
enable_debug_for("util")
try:
return show_pass_dialog(sys.argv[1:])
except KeyboardInterrupt:
return 1
def main():
name = "test"
if len(sys.argv) >= 2:
name = sys.argv[1]
tooltip = "StatusIcon Example"
if len(sys.argv) >= 3:
tooltip = sys.argv[2]
from xpra.platform import program_context
with program_context(name, name):
StatusIcon(name, tooltip)
Gtk.main()
def main():
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
from xpra.log import add_debug_category
add_debug_category("webcam")
from xpra.platform import program_context
with program_context("Webcam Info", "Webcam Info"):
devices = get_virtual_video_devices()
log.info("Found %i virtual video device%s:", len(devices), engs(devices))
for no, d in devices.items():
log.info("%-2i: %s", no, d)
def main():
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
from xpra.platform import program_context
with program_context("CUDA-Info", "CUDA Info"):
log.info("pycuda_info")
print_nested_dict(get_pycuda_info(), print_fn=log.info)
log.info("cuda_info")
print_nested_dict(get_cuda_info(), print_fn=log.info)
log.info("preferences:")
print_nested_dict(get_prefs())
def main():
import sys
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("Keymap-Tool", "Keymap Information Tool"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
gtk_keymap = get_gtk_keymap()
sizes = [16, 28, 8, 8, 8]
def pkey(*entries):
print(("".join([str(x).ljust(sizes[i]) for i,x in enumerate(entries)])).strip())
pkey("keyval", "name", "keycode", "group", "level")
for x in gtk_keymap:
pkey(*x)
def main():
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
from xpra.platform import program_context
with program_context("Nvidia-Info", "Nvidia Info"):
#this will log the version number:
get_nvidia_module_version()
if is_blacklisted():
log.warn("Warning: this driver version is blacklisted")
log.info("NVENC license keys:")
for v in (0, 3, 4):
keys = get_nvenc_license_keys(v)
log.info("* version %s: %s key(s)", v or "common", len(keys))
for k in keys:
log.info(" %s", k)
def main():
from xpra.codecs.loader import log as loader_log, load_codecs
from xpra.util import print_nested_dict
from xpra.log import enable_color
from xpra.platform import program_context
with program_context("Video Helper"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
loader_log.enable_debug()
log.enable_debug()
load_codecs()
vh = getVideoHelper()
vh.set_modules(ALL_VIDEO_ENCODER_OPTIONS, ALL_CSC_MODULE_OPTIONS, ALL_VIDEO_DECODER_OPTIONS)
vh.init()
log.info("VideoHelper.get_info():")
info = vh.get_info()
print_nested_dict(info)
def main():
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.util import print_nested_dict, pver
with program_context("Loader", "Encoding Info"):
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
load_codecs()
print("codecs and csc modules found:")
#print("codec_status=%s" % codecs)
for name in sorted(ALL_CODECS):
mod = codecs.get(name, "")
f = mod
if mod and hasattr(mod, "__file__"):
f = mod.__file__
if f.startswith(os.getcwd()):
f = f[len(os.getcwd()):]
if f.startswith(os.path.sep):
f = f[1:]
print("* %s : %s" % (name.ljust(20), f))
if mod and verbose:
try:
if name.find("csc")>=0:
cs = list(mod.get_input_colorspaces())
for c in list(cs):
cs += list(mod.get_output_colorspaces(c))
print(" colorspaces: %s" % ", ".join(list(set(cs))))
elif name.find("enc")>=0 or name.find("dec")>=0:
encodings = mod.get_encodings()
print(" encodings: %s" % ", ".join(encodings))
try:
i = mod.get_info()
for k,v in sorted(i.items()):
print(" %s = %s" % (k,v))
except:
pass
except Exception as e:
print("error getting extra information on %s: %s" % (name, e))
print("")
print("codecs versions:")
def forcever(v):
return pver(v, numsep=".", strsep=".").lstrip("v")
print_nested_dict(codec_versions, vformat=forcever)
def main():
from xpra.util import nonl, pver, flatten_dict, print_nested_dict
def print_version_dict(d, vformat=pver):
for k in sorted(d.keys()):
v = d[k]
print("* %-48s : %s" % (str(k).replace(".version", "").ljust(12), nonl(vformat(v))))
from xpra.platform import program_context
with program_context("GTK-Version-Info", "GTK Version Info"):
from xpra.platform.gui import init as gui_init, ready
gui_init()
ready()
from xpra.gtk_common import gtk_util
if "-v" in sys.argv or "--verbose" in sys.argv:
gtk_util.SHOW_ALL_VISUALS = True
print("GTK Version:")
print_version_dict(flatten_dict(gtk_util.get_gtk_version_info()))
print("Display:")
print_nested_dict(gtk_util.get_display_info(), vformat=str)
def main():
global change_count
import time
from xpra.platform import program_context
with program_context("OSX Clipboard Change Test"):
log.enable_debug()
# init UI watcher with gobject (required by pasteboard monitoring code)
from xpra.platform.ui_thread_watcher import get_UI_watcher
gobject.threads_init()
import gtk.gdk
gtk.gdk.threads_init()
get_UI_watcher(glib.timeout_add)
log.info("testing pasteboard")
if not init_pasteboard():
log.warn("failed to initialize a pasteboard!")
return
assert update_clipboard_change_count is not None, "cannot access clipboard change count"
cc = update_clipboard_change_count()
log.info("current change count=%s", cc)
clipboard = gtk.Clipboard(selection="CLIPBOARD")
log.info("changing clipboard %s contents", clipboard)
clipboard.set_text("HELLO WORLD %s" % time.time())
cc = update_clipboard_change_count()
log.info("new change count=%s", cc)
log.info("any update to your clipboard should get logged (^C to exit)")
while True:
v = update_clipboard_change_count()
if v != cc:
log.info("success! the clipboard change has been detected, new change count=%s", v)
else:
log.info(".")
time.sleep(1)
if v == cc:
log.info("no clipboard change detected")
def main():
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
from xpra.log import add_debug_category
add_debug_category("webcam")
run = "-r" in sys.argv or "--run" in sys.argv
if run:
from xpra.gtk_common.gobject_compat import import_glib, import_gobject
glib = import_glib()
gobject = import_gobject()
gobject.threads_init()
from xpra.util import engs, print_nested_dict
from xpra.platform import program_context
with program_context("Webcam Info", "Webcam Info"):
devices = get_virtual_video_devices() or {}
log.info("Found %i virtual video device%s:", len(devices), engs(devices))
print_nested_dict(devices)
all_devices = get_all_video_devices() or {}
log.info("Found %i video device%s in total:", len(all_devices), engs(all_devices))
print_nested_dict(all_devices)
if run:
log.info("add watch for video device changes")
def callback(added=None, device=None):
if added is not None or device:
log.info("video device %s: %s", ["removed", "added"][added], device)
else:
log.info("device change")
log.info("starting main loop")
main_loop = glib.MainLoop()
glib.idle_add(add_video_device_change_callback, callback)
try:
main_loop.run()
except KeyboardInterrupt:
pass
log.info("terminating, removing callback")
remove_video_device_change_callback(callback)
def main():
from xpra.platform import program_context
with program_context("Xpra-Bug-Report", "Xpra Bug Report"):
from xpra.log import enable_color
enable_color()
from xpra.log import Logger, enable_debug_for
log = Logger("util")
#logging init:
if "-v" in sys.argv:
enable_debug_for("util")
from xpra.gtk_common.gobject_compat import import_gobject
gobject = import_gobject()
gobject.threads_init()
from xpra.os_util import SIGNAMES
from xpra.gtk_common.quit import gtk_main_quit_on_fatal_exceptions_enable
gtk_main_quit_on_fatal_exceptions_enable()
from xpra.client.gtk_base.bug_report import BugReport
app = BugReport()
app.close = app.quit
app.init(True)
def app_signal(signum, frame):
print("")
log.info("got signal %s", SIGNAMES.get(signum, signum))
app.quit()
signal.signal(signal.SIGINT, app_signal)
signal.signal(signal.SIGTERM, app_signal)
try:
from xpra.platform.gui import ready as gui_ready
gui_ready()
app.show()
app.run()
except KeyboardInterrupt:
pass
return 0
