Exemple #1
0
 def f(*args):
     try:
         platform_import(where, *args)
     except ImportError:
         pass
     else:
         raise Exception("should have failed to import invalid name")
Exemple #2
0
 def test_fail_import(self):
     where = {}
     platform_import(where, "invalid name", False, "foo")
     try:
         platform_import(where, "invalid name", True, "bar")
     except ImportError:
         pass
     else:
         raise Exception("should have failed to import invalid name")
Exemple #3
0
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)))
Exemple #4
0
 def test_fail_import(self):
     where = {}
     platform_import(where, "invalid name", False, "foo")
     def f(*args):
         try:
             platform_import(where, *args)
         except ImportError:
             pass
         else:
             raise Exception("should have failed to import invalid name")
     f("invalid name", True, "bar")
     #test with some valid platform modules:
     # - required import is missing:
     f("paths", True, "this-function-does-not-exist")
     where = {}
     # - optional import is missing:
     platform_import(where, "paths", False, "do_get_app_dir", "optional-function")
     assert len(where)==1, "where=%s" % (where,)
Exemple #5
0
def main():
    import sys
    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()
        if "-v" in sys.argv or "--verbose" in sys.argv or \
            (sys.platform.startswith("win") and not ("-q" in sys.argv or "--quiet")):
            log.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..

        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 = keyboard.get_layout_spec()
        print("Layout:     '%s'" % (layout))
        print("Layouts:    %s" % (layouts, ))
        print("Variant:    '%s'" % (variant or ""))
        print("Variants:   %s" % (variants, ))
        print("")
        print("Repeat:     %s" % csv(keyboard.get_keyboard_repeat()))
Exemple #6
0
# This file is part of Xpra.
# Copyright (C) 2010 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2011-2017 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.

#default:
Keyboard = None

from xpra.platform import platform_import

platform_import(globals(), "keyboard", True, "Keyboard")


def main():
    import sys
    from xpra.os_util import WIN32, OSX, 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()
        if "-v" in sys.argv or "--verbose" in sys.argv or \
            (WIN32 and not ("-q" in sys.argv or "--quiet")):
            log.enable_debug()
Exemple #7
0
#default implementation uses pycups:
from xpra.platform import platform_import
if not WIN32:
    #pycups is not available on win32
    try:
        from xpra.platform.pycups_printing import get_printers, print_files, printing_finished, init_printing, cleanup_printing, get_info
        assert get_printers and print_files and printing_finished and init_printing, cleanup_printing
    except Exception as e:
        err("Error: printing disabled:")
        err(" %s", e)

platform_import(globals(), "printing", False,
                "init_printing",
                "cleanup_printing",
                "get_printers",
                "get_default_printer",
                "print_files",
                "printing_finished",
                "get_info",
                "DEFAULT_MIMETYPES")


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
Exemple #8
0
# This file is part of Xpra.
# Copyright (C) 2017-2018 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.


def get_interface_info(*_args):
    return {}


from xpra.platform import platform_import
platform_import(
    globals(),
    "netdev_query",
    False,
    "get_interface_info",
)


def main():
    import sys
    import socket

    from xpra.os_util import POSIX
    from xpra.util import print_nested_dict
    from xpra.net.net_util import import_netifaces, get_interfaces, if_nametoindex
    from xpra.platform import program_context
    from xpra.log import Logger, enable_color, add_debug_category, enable_debug_for
    log = Logger("network")
    with program_context("Network-Device-Info", "Network Device Info"):
        enable_color()
Exemple #9
0
def _get_pwd():
    try:
        import pwd
        USER_ID = os.getuid()
        return pwd.getpwuid(USER_ID)
    except:
        return None


def get_username():
    p = _get_pwd()
    if p is None:
        return ""
    return p.pw_name


def get_name():
    p = _get_pwd()
    if p is None:
        return ""
    return p.pw_gecos.replace(",", "")


def get_user_info():
    return {"username": get_username(), "name": get_name()}


from xpra.platform import platform_import
platform_import(globals(), "info", False, "get_sys_info", "get_version_info",
                "get_username", "get_name")
Exemple #10
0
                license_file = open(filename, mode='r', encoding='ascii')
            LICENSE_TEXT = license_file.read()
        finally:
            license_file.close()
    if not LICENSE_TEXT:
        LICENSE_TEXT = "GPL version 2"
    return LICENSE_TEXT


def get_sound_executable():
    return os.environ.get("XPRA_SOUND_EXECUTABLE", "xpra")


from xpra.platform import platform_import
platform_import(globals(), "paths", True,
                "get_resources_dir",
                "get_app_dir",
                "get_icon_dir")
platform_import(globals(), "paths", False,
                "get_sound_executable",
                "get_install_prefix",
                "get_default_conf_dir",
                "get_system_conf_dir",
                "get_user_conf_dir",
                "get_default_socket_dir")

def get_info():
    return {
            "install.prefix"    : get_install_prefix(),
            "default_conf.dir"  : get_default_conf_dir(),
            "system_conf.dir"   : get_system_conf_dir(),
            "user_conf.dir"     : get_user_conf_dir(),
Exemple #11
0
                    s = os.stat(sockpath)
                except OSError as e:
                    debug("socket_details: '%s' path cannot be accessed: %s", sockpath, e)
                    #socket cannot be accessed
                    continue
                if stat.S_ISSOCK(s.st_mode):
                    if check_uid>0:
                        if s.st_uid!=check_uid:
                            #socket uid does not match
                            debug("socket_details: '%s' uid does not match (%s vs %s)", sockpath, s.st_uid, check_uid)
                            continue
                    local_display = ":"+sockpath[len(base):]
                    if matching_display and local_display!=matching_display:
                        debug("socket_details: '%s' display does not match (%s vs %s)", sockpath, local_display, matching_display)
                        continue
                    state = self.get_server_state(sockpath)
                    if matching_state and state!=matching_state:
                        debug("socket_details: '%s' state does not match (%s vs %s)", sockpath, state, matching_state)
                        continue
                    results.append((state, local_display, sockpath))
            if results:
                sd[d] = results
        return sd


#win32 re-defines DotXpra for namedpipes:
from xpra.platform import platform_import
platform_import(globals(), "dotxpra", False,
                "DotXpra",
                "norm_makepath")
Exemple #12
0
# Copyright (C) 2011-2013 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.

#defaults which may be overriden by platform_import:
LOCAL_SERVERS_SUPPORTED = False
SHADOW_SUPPORTED = False
MMAP_SUPPORTED = False
SYSTEM_TRAY_SUPPORTED = False
DEFAULT_SSH_CMD = False
GOT_PASSWORD_PROMPT_SUGGESTION = ""
CLIPBOARDS = []
CLIPBOARD_WANT_TARGETS = False
CLIPBOARD_GREEDY = False
CLIPBOARD_NATIVE_CLASS = None
CAN_DAEMONIZE = False

from xpra.platform import platform_import
platform_import(globals(), "features", False,
                "LOCAL_SERVERS_SUPPORTED",
                "SHADOW_SUPPORTED",
                "CAN_DAEMONIZE",
                "MMAP_SUPPORTED",
                "SYSTEM_TRAY_SUPPORTED",
                "DEFAULT_SSH_CMD",
                "GOT_PASSWORD_PROMPT_SUGGESTION",
                "CLIPBOARDS",
                "CLIPBOARD_WANT_TARGETS",
                "CLIPBOARD_GREEDY",
                "CLIPBOARD_NATIVE_CLASS")
Exemple #13
0
    #the classes we can use for application system tray forwarding:
    #let the toolkit classes use their own
    return []
def system_bell(*args):
    #let the toolkit classes use their own
    return False
def get_native_notifier_classes():
    return []
def get_fixed_cursor_size():
    return -1, -1

def gl_check():
    return None     #no problem

take_screenshot = None
ClientExtras = None

from xpra.platform import platform_import
platform_import(globals(), "gui", False,
                "do_ready",
                "do_init",
                "gl_check",
                "ClientExtras",
                "take_screenshot",
                "get_native_tray_menu_helper_classes",
                "get_native_tray_classes",
                "get_native_system_tray_classes",
                "get_native_notifier_classes",
                "get_fixed_cursor_size",
                "system_bell")
Exemple #14
0
# This file is part of Xpra.
# Copyright (C) 2010 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2011-2013 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.

#default:
def add_client_options(*args):
    pass

from xpra.platform import platform_import
platform_import(globals(), "options", True,
                "add_client_options")
Exemple #15
0
_video_device_change_callbacks = []
def _fire_video_device_change(create=None, pathname=None):
    global _video_device_change_callbacks
    for x in _video_device_change_callbacks:
        try:
            x(create, pathname)
        except Exception as e:
            log("error on %s", x, exc_info=True)
            log.error("Error: video device change callback error")
            log.error(" %s", e)


from xpra.platform import platform_import
platform_import(globals(), "webcam", False,
                "get_virtual_video_devices",
                "get_all_video_devices",
                "add_video_device_change_callback",
                "remove_video_device_change_callback")


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()
Exemple #16
0

def get_sound_command():
    envvalue = os.environ.get("XPRA_SOUND_COMMAND")
    if envvalue:
        import shlex
        return shlex.split(envvalue)
    return do_get_sound_command()


def do_get_sound_command():
    return get_xpra_command()


from xpra.platform import platform_import
platform_import(globals(), "paths", True, "do_get_resources_dir",
                "do_get_app_dir", "do_get_icon_dir")
platform_import(globals(), "paths", False, "get_default_icon_extension",
                "get_default_tray_icon_name", "get_tray_icon_filename",
                "do_get_sshpass_command", "do_get_xpra_command",
                "do_get_sound_command", "do_get_install_prefix",
                "do_get_default_conf_dirs", "do_get_system_conf_dirs",
                "do_get_user_conf_dirs", "do_get_socket_dirs",
                "do_get_default_log_dir", "do_get_download_dir",
                "do_get_script_bin_dirs")


def get_info():
    return {
        "install": {
            "prefix": get_install_prefix()
        },
Exemple #17
0
# This file is part of Xpra.
# Copyright (C) 2019 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.

from xpra.platform import platform_import

from xpra.server.proxy.proxy_server import ProxyServer
assert ProxyServer

platform_import(globals(), "proxy_server", False, "ProxyServer")
Exemple #18
0
    return get_icon_from_file(filename)


LICENSE_TEXT = None


def get_license_text(self):
    global LICENSE_TEXT
    if LICENSE_TEXT:
        return LICENSE_TEXT
    filename = os.path.join(get_resources_dir(), "COPYING")
    if os.path.exists(filename):
        try:
            if sys.version < "3":
                license_file = open(filename, mode="rb")
            else:
                license_file = open(filename, mode="r", encoding="ascii")
            LICENSE_TEXT = license_file.read()
        finally:
            license_file.close()
    if not LICENSE_TEXT:
        LICENSE_TEXT = "GPL version 2"
    return LICENSE_TEXT


from xpra.platform import platform_import

platform_import(globals(), "paths", True, "get_resources_dir", "get_app_dir", "get_icon_dir")
platform_import(globals(), "paths", False, "get_default_conf_dir", "get_default_socket_dir")
Exemple #19
0
# This file is part of Xpra.
# Copyright (C) 2010 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2011-2013 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.

ShadowServer = None
from xpra.platform import platform_import
platform_import(globals(), "shadow_server", True, "ShadowServer")
Exemple #20
0
                   "CLIPBOARDS",
                   "CLIPBOARD_WANT_TARGETS",
                   "CLIPBOARD_GREEDY",
                   "CLIPBOARD_NATIVE_CLASS",
                   "EXECUTABLE_EXTENSION",
                   "UI_THREAD_POLLING",
                   "CLIENT_MODULES",
                   "INPUT_DEVICES",
                   "SYSTEM_PROXY_SOCKET",
                   "OPEN_COMMAND",
                   "SOCKET_OPTIONS",
                   "IP_OPTIONS",
                   "TCP_OPTONS",
                   ]
from xpra.platform import platform_import
platform_import(globals(), "features", False,
                *_features_list_)


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)


if __name__ == "__main__":
    main()
Exemple #21
0
def cleanup_printing():
    pass


#default implementation uses pycups:
from xpra.platform import platform_import
try:
    from xpra.platform.pycups_printing import get_printers, print_files, printing_finished, init_printing, cleanup_printing
    assert get_printers and print_files and printing_finished and init_printing, cleanup_printing
except Exception as e:
    #ignore the error on win32:
    if not sys.platform.startswith("win"):
        err("cannot use pycups for printing: %s", e)

platform_import(globals(), "printing", False, "init_printing",
                "cleanup_printing", "get_printers", "print_files",
                "printing_finished")


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:
Exemple #22
0
    }
    from xpra.util import updict
    updict(info, "antialias", get_antialias_info())
    updict(info, "window_frame", get_window_frame_sizes())
    return info


get_info = get_info_base

from xpra.platform import platform_import
platform_import(
    globals(), "gui", False, "do_ready", "do_init", "gl_check", "show_desktop",
    "set_fullscreen_monitors", "set_shaded", "ClientExtras", "take_screenshot",
    "get_menu_support_function", "get_native_tray_menu_helper_classes",
    "get_native_tray_classes", "get_native_system_tray_classes",
    "get_native_notifier_classes", "get_vrefresh", "get_workarea",
    "get_workareas", "get_number_of_desktops", "get_desktop_names",
    "get_antialias_info", "get_icon_size", "get_xdpi", "get_ydpi",
    "get_double_click_time", "get_double_click_distance",
    "get_fixed_cursor_size", "get_cursor_size", "get_window_frame_sizes",
    "add_window_hooks", "remove_window_hooks", "system_bell", "get_info")


def main():
    from xpra.platform import init as platform_init, clean
    from xpra.util import nonl
    from xpra.log import enable_color
    try:
        platform_init("GUI-Properties")
        enable_color()
        init()
Exemple #23
0
    return get_icon_from_file(filename)


LICENSE_TEXT = None
def get_license_text(self):
    global LICENSE_TEXT
    if LICENSE_TEXT:
        return  LICENSE_TEXT
    filename = os.path.join(get_resources_dir(), 'COPYING')
    if os.path.exists(filename):
        try:
            if sys.version < '3':
                license_file = open(filename, mode='rb')
            else:
                license_file = open(filename, mode='r', encoding='ascii')
            LICENSE_TEXT = license_file.read()
        finally:
            license_file.close()
    if not LICENSE_TEXT:
        LICENSE_TEXT = "GPL version 2"
    return LICENSE_TEXT


from xpra.platform import platform_import
platform_import(globals(), "paths", True,
                "get_app_dir",
                "get_icon_dir")
platform_import(globals(), "paths", False,
                "get_default_conf_dir",
                "get_default_socket_dir")
Exemple #24
0
        printing_finished,
        init_printing,
        cleanup_printing,
    )

    assert get_printers and print_files and printing_finished and init_printing, cleanup_printing
except Exception as e:
    # ignore the error on win32:
    if not sys.platform.startswith("win"):
        err("cannot use pycups for printing: %s", e)

platform_import(
    globals(),
    "printing",
    False,
    "init_printing",
    "cleanup_printing",
    "get_printers",
    "print_files",
    "printing_finished",
)


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:
Exemple #25
0
                "CAN_DAEMONIZE",
                "MMAP_SUPPORTED",
                "SYSTEM_TRAY_SUPPORTED",
                "REINIT_WINDOWS",
                "DEFAULT_ENV",
                "DEFAULT_SSH_COMMAND",
                "DEFAULT_PULSEAUDIO_COMMAND",
                "DEFAULT_PULSEAUDIO_CONFIGURE_COMMANDS",
                "CLIPBOARDS",
                "CLIPBOARD_WANT_TARGETS",
                "CLIPBOARD_GREEDY",
                "CLIPBOARD_NATIVE_CLASS",
                "UI_THREAD_POLLING",
                "CLIENT_MODULES"]
from xpra.platform import platform_import
platform_import(globals(), "features", False,
                *_features_list_)


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)


if __name__ == "__main__":
    main()
Exemple #26
0
# later version. See the file COPYING for details.

#defaults which may be overriden by platform_import:
LOCAL_SERVERS_SUPPORTED = False
SHADOW_SUPPORTED = False
MMAP_SUPPORTED = False
SYSTEM_TRAY_SUPPORTED = False
DEFAULT_SSH_CMD = False
GOT_PASSWORD_PROMPT_SUGGESTION = ""
CLIPBOARDS = []
CLIPBOARD_WANT_TARGETS = False
CLIPBOARD_GREEDY = False
CLIPBOARD_NATIVE_CLASS = None
CAN_DAEMONIZE = False
UI_THREAD_POLLING = 0

from xpra.platform import platform_import
platform_import(globals(), "features", False,
                "LOCAL_SERVERS_SUPPORTED",
                "SHADOW_SUPPORTED",
                "CAN_DAEMONIZE",
                "MMAP_SUPPORTED",
                "SYSTEM_TRAY_SUPPORTED",
                "DEFAULT_SSH_CMD",
                "GOT_PASSWORD_PROMPT_SUGGESTION",
                "CLIPBOARDS",
                "CLIPBOARD_WANT_TARGETS",
                "CLIPBOARD_GREEDY",
                "CLIPBOARD_NATIVE_CLASS",
                "UI_THREAD_POLLING")
Exemple #27
0
# This file is part of Xpra.
# Copyright (C) 2011-2020 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.

from xpra.platform import platform_import


def ShadowServer():  # pragma: no cover
    raise NotImplementedError()


platform_import(globals(), "shadow_server", True, "ShadowServer")
Exemple #28
0
# Copyright (C) 2017 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.

import sys

from xpra.platform import platform_import

GLContext = None


def check_support():
    return GLContext().check_support()


platform_import(globals(), "gl_context", False, "GLContext", "check_support")


def main():
    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, Logger
    with program_context("OpenGL Native Context Check"):
        gui_init()
        enable_color()
        log = Logger("opengl")
        verbose = "-v" in sys.argv or "--verbose" in sys.argv
        if verbose:
            log.enable_debug()
        if not GLContext:
Exemple #29
0
def get_native_tray_menu_helper_classes():
    #classes that generate menus for xpra's system tray
    #let the toolkit classes use their own
    return []
def get_native_tray_classes(*args):
    #the classes we can use for our system tray:
    #let the toolkit classes use their own
    return []
def get_native_system_tray_classes(*args):
    #the classes we can use for application system tray forwarding:
    #let the toolkit classes use their own
    return []
def system_bell(*args):
    #let the toolkit classes use their own
    return False
def get_native_notifier_classes():
    return []

ClientExtras = None

from xpra.platform import platform_import
platform_import(globals(), "gui", False,
                "do_ready",
                "do_init",
                "ClientExtras",
                "get_native_tray_menu_helper_classes",
                "get_native_tray_classes",
                "get_native_system_tray_classes",
                "get_native_notifier_classes",
                "system_bell")
Exemple #30
0
    return []


def system_bell(*args):
    #let the toolkit classes use their own
    return False


def get_native_notifier_classes():
    return []


def get_fixed_cursor_size():
    return -1, -1


def gl_check():
    return None  #no problem


take_screenshot = None
ClientExtras = None

from xpra.platform import platform_import
platform_import(globals(), "gui", False, "do_ready", "do_init", "gl_check",
                "ClientExtras", "take_screenshot",
                "get_native_tray_menu_helper_classes",
                "get_native_tray_classes", "get_native_system_tray_classes",
                "get_native_notifier_classes", "get_fixed_cursor_size",
                "system_bell")
Exemple #31
0
                license_file = open(filename, mode="r", encoding="ascii")
            LICENSE_TEXT = license_file.read()
        finally:
            license_file.close()
    if not LICENSE_TEXT:
        LICENSE_TEXT = "GPL version 2"
    return LICENSE_TEXT


def get_sound_executable():
    return os.environ.get("XPRA_SOUND_EXECUTABLE", "xpra")


from xpra.platform import platform_import

platform_import(globals(), "paths", True, "get_resources_dir", "get_app_dir", "get_icon_dir")
platform_import(
    globals(),
    "paths",
    False,
    "get_sound_executable",
    "get_install_prefix",
    "get_default_conf_dir",
    "get_system_conf_dir",
    "get_user_conf_dir",
    "get_default_socket_dir",
)


def get_info():
    return {
Exemple #32
0
def get_sys_info():
    return {}

def _get_pwd():
    try:
        import pwd
        import os
        USER_ID = os.getuid()
        return pwd.getpwuid(USER_ID)
    except:
        return None

def get_username():
    p = _get_pwd()
    if p is None:
        return ""
    return p.pw_name

def get_name():
    p = _get_pwd()
    if p is None:
        return ""
    return p.pw_gecos.replace(",", "")


from xpra.platform import platform_import
platform_import(globals(), "info", False,
                "get_sys_info",
                "get_username",
                "get_name")
Exemple #33
0

platform_import(globals(), "gui", False,
                "do_ready",
                "do_init",
                "force_focus",
                "gl_check",
                "use_stdin",
                "get_wm_name",
                "show_desktop", "set_fullscreen_monitors", "set_shaded",
                "ClientExtras",
                "take_screenshot",
                "get_clipboard_native_class",
                "get_native_tray_menu_helper_class",
                "get_native_tray_classes",
                "get_native_system_tray_classes",
                "get_native_notifier_classes",
                "get_session_type",
                "get_vrefresh", "get_workarea", "get_workareas",
                "get_number_of_desktops", "get_desktop_names",
                "get_antialias_info", "get_icc_info", "get_display_icc_info", "get_xdpi", "get_ydpi",
                "get_icon_size",
                "get_window_min_size", "get_window_max_size",
                "get_mouse_config",
                "get_double_click_time", "get_double_click_distance",
                "get_fixed_cursor_size", "get_cursor_size", "get_window_frame_sizes",
                "add_window_hooks", "remove_window_hooks",
                "system_bell",
                "can_access_display",
                "get_info")

Exemple #34
0
platform_import(
    globals(),
    "gui",
    False,
    "do_ready",
    "do_init",
    "gl_check",
    "get_wm_name",
    "show_desktop",
    "set_fullscreen_monitors",
    "set_shaded",
    "ClientExtras",
    "take_screenshot",
    "get_menu_support_function",
    "get_native_tray_menu_helper_classes",
    "get_native_tray_classes",
    "get_native_system_tray_classes",
    "get_native_notifier_classes",
    "get_vrefresh",
    "get_workarea",
    "get_workareas",
    "get_number_of_desktops",
    "get_desktop_names",
    "get_antialias_info",
    "get_icc_info",
    "get_xdpi",
    "get_ydpi",
    "get_icon_size",
    "get_mouse_config",
    "get_double_click_time",
    "get_double_click_distance",
    "get_fixed_cursor_size",
    "get_cursor_size",
    "get_window_frame_sizes",
    "add_window_hooks",
    "remove_window_hooks",
    "system_bell",
    "get_info",
)
Exemple #35
0
            get_printers,
            print_files,
            printing_finished,
            init_printing,
            cleanup_printing,
            get_info,
        )
        assert get_printers and print_files and printing_finished and init_printing, cleanup_printing
    except Exception as e:
        log("cannot load pycups", exc_info=True)
        err("Error: printing disabled:")
        err(" %s", e)
        del e

platform_import(globals(), "printing", False, "init_printing",
                "cleanup_printing", "get_printers", "get_default_printer",
                "print_files", "printing_finished", "get_info",
                "DEFAULT_MIMETYPES")


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 ValueError:
            pass
        try:
            sys.argv.remove("--verbose")
        except ValueError:
Exemple #36
0

def get_sound_command():
    envvalue = os.environ.get("XPRA_SOUND_COMMAND")
    if envvalue:
        import shlex
        return shlex.split(envvalue)
    return do_get_sound_command()


def do_get_sound_command():
    return ["xpra"]


from xpra.platform import platform_import
platform_import(globals(), "paths", True, "do_get_resources_dir",
                "do_get_app_dir", "do_get_icon_dir")
platform_import(globals(), "paths", False, "do_get_sound_command",
                "do_get_install_prefix", "do_get_default_conf_dirs",
                "do_get_system_conf_dirs", "do_get_user_conf_dirs",
                "do_get_socket_dirs", "do_get_default_log_dir",
                "do_get_download_dir", "do_get_script_bin_dir")


def get_info():
    return {
        "install.prefix": get_install_prefix(),
        "default_conf.dirs": get_default_conf_dirs(),
        "system_conf.dirs": get_system_conf_dirs(),
        "user_conf.dirs": get_user_conf_dirs(),
        "socket.dirs": get_socket_dirs(),
        "log.dir": get_default_log_dir(),
Exemple #37
0
    return get_xpra_command()


def get_sound_command():
    envvalue = os.environ.get("XPRA_SOUND_COMMAND")
    if envvalue:
        import shlex
        return shlex.split(envvalue)
    return do_get_sound_command()


def do_get_sound_command():
    return get_xpra_command()


platform_import(globals(), "paths", True, "do_get_resources_dir",
                "do_get_app_dir", "do_get_icon_dir")
platform_import(
    globals(),
    "paths",
    False,
    "do_get_sshpass_command",
    "do_get_xpra_command",
    "do_get_sound_command",
    "do_get_nodock_command",
    "do_get_install_prefix",
    "do_get_default_conf_dirs",
    "do_get_system_conf_dirs",
    "do_get_ssh_conf_dirs",
    "do_get_ssh_known_hosts_files",
    "do_get_user_conf_dirs",
    "do_get_socket_dirs",
Exemple #38
0
# This file is part of Xpra.
# Copyright (C) 2010 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2011-2013 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.


#default:
def add_client_options(*args):
    pass


from xpra.platform import platform_import

platform_import(globals(), "options", True, "add_client_options")
Exemple #39
0
                    add_session_dir(session_dir, p)
            #ie: "~/.xpra/HOSTNAME-"
            base = os.path.join(d, PREFIX)
            if matching_display:
                dstr = strip_display_prefix(matching_display)
            else:
                dstr = "*"
            potential_sockets = glob.glob(base + dstr)
            for sockpath in sorted(potential_sockets):
                state = self.is_socket_match(sockpath, check_uid,
                                             matching_state)
                if state:
                    local_display = DISPLAY_PREFIX + sockpath[len(base):]
                    add_result(d, (state, local_display, sockpath))
        return sd

    def is_socket_match(self, sockpath, check_uid=None, matching_state=None):
        if not is_socket(sockpath, check_uid):
            return None
        state = self.get_server_state(sockpath)
        if matching_state and state != matching_state:
            debug("is_socket_match%s state '%s' does not match",
                  (sockpath, check_uid, matching_state), state)
            return None
        return state


#win32 re-defines DotXpra for namedpipes:
platform_import(globals(), "dotxpra", False, "DotXpra", "DISPLAY_PREFIX",
                "norm_makepath")
Exemple #40
0
    if os.path.exists(filename):
        try:
            if sys.version < '3':
                license_file = open(filename, mode='rb')
            else:
                license_file = open(filename, mode='r', encoding='ascii')
            LICENSE_TEXT = license_file.read()
        finally:
            license_file.close()
    if not LICENSE_TEXT:
        LICENSE_TEXT = "GPL version 2"
    return LICENSE_TEXT


from xpra.platform import platform_import
platform_import(globals(), "paths", True, "get_resources_dir", "get_app_dir",
                "get_icon_dir")
platform_import(globals(), "paths", False, "get_default_conf_dir",
                "get_system_conf_dir", "get_user_conf_dir",
                "get_default_socket_dir")


def get_info():
    return {
        "default_conf.dir": get_default_conf_dir(),
        "system_conf_dir": get_system_conf_dir(),
        "user_conf_dir": get_user_conf_dir(),
        "socket": get_default_socket_dir(),
        "app": get_app_dir(),
        "app.default": default_get_app_dir(),
        "resources": get_resources_dir(),
        "icons": get_icon_dir(),
Exemple #41
0
    return {}


def load_desktop_sessions():
    return {}


def clear_cache():
    pass


from xpra.platform import platform_import
platform_import(
    globals(),
    "menu_helper",
    False,
    "load_menu",
    "load_desktop_sessions",
    "clear_cache",
)


def main():
    import os
    from xpra.util import print_nested_dict
    from xpra.log import Logger, add_debug_category
    log = Logger("exec", "menu")
    from xpra.platform import program_context  #pylint: disable=import-outside-toplevel
    with program_context("XDG-Menu-Helper", "XDG Menu Helper"):
        for x in list(sys.argv):
            if x in ("-v", "--verbose"):
                sys.argv.remove(x)
Exemple #42
0

def get_native_tray_classes(*args):
    #the classes we can use for our system tray:
    #let the toolkit classes use their own
    return []


def get_native_system_tray_classes(*args):
    #the classes we can use for application system tray forwarding:
    #let the toolkit classes use their own
    return []


def system_bell(*args):
    #let the toolkit classes use their own
    return False


def get_native_notifier_classes():
    return []


ClientExtras = None

from xpra.platform import platform_import
platform_import(globals(), "gui", False, "do_ready", "do_init", "ClientExtras",
                "get_native_tray_menu_helper_classes",
                "get_native_tray_classes", "get_native_system_tray_classes",
                "get_native_notifier_classes", "system_bell")
Exemple #43
0

def _fire_video_device_change(create=None, pathname=None):
    global _video_device_change_callbacks
    for x in _video_device_change_callbacks:
        try:
            x(create, pathname)
        except Exception as e:
            log("error on %s", x, exc_info=True)
            log.error("Error: video device change callback error")
            log.error(" %s", e)


from xpra.platform import platform_import
platform_import(globals(), "webcam", False, "get_virtual_video_devices",
                "get_all_video_devices", "add_video_device_change_callback",
                "remove_video_device_change_callback")


def main(argv):
    if "-v" in argv or "--verbose" in argv:
        from xpra.log import add_debug_category, enable_debug_for
        enable_debug_for("webcam")
        add_debug_category("webcam")
    run = "-r" in argv or "--run" in argv
    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))
Exemple #44
0
# This file is part of Xpra.
# Copyright (C) 2010 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2011-2013 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.

#default:
Keyboard = None

from xpra.platform import platform_import
platform_import(globals(), "keyboard", True,
                "Keyboard")