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