def validate_driver_yuv444lossless():
#this should log the kernel module version
v = get_nvidia_module_version()
if not v:
log.warn("Warning: unknown NVidia driver version")
bl = None
else:
bl = is_blacklisted()
if bl is True:
raise Exception("NVidia driver version %s is blacklisted, it does not work with NVENC" % pver(v))
elif bl is None:
global _version_warning
if _version_warning:
l = log
else:
l = log.warn
_version_warning = True
if v:
l("Warning: NVidia driver version %s is untested with NVENC", pver(v))
l(" (this encoder has been tested with versions up to %s.x only)", MAX_TESTED)
if not envbool("XPRA_NVENC_YUV444P", True):
l(" enabling YUV444P and lossless mode")
l(" use XPRA_NVENC_YUV444P=0 to force disable")
return False
return True
def do_get_resources_dir():
rsc = None
RESOURCES = "/Resources/"
#FUGLY warning: importing gtkosx_application causes the dock to appear,
#and in some cases we don't want that.. so use the env var XPRA_SKIP_UI as workaround for such cases:
if not envbool("XPRA_SKIP_UI", False):
try:
import gtkosx_application #@UnresolvedImport
try:
rsc = gtkosx_application.gtkosx_application_get_resource_path()
debug("get_resources_dir() gtkosx_application_get_resource_path=%s", rsc)
except:
#maybe we're not running from an app bundle?
pass
except:
#delayed import to prevent cycles:
from xpra.log import Logger
log = Logger("util")
log.error("ERROR: gtkosx_application module is missing - trying to continue anyway")
else:
debug("XPRA_SKIP_UI is set, not importing gtkosx_application")
if rsc is None:
#try using the path to this file to find the resource path:
rsc = __file__
i = rsc.rfind(RESOURCES)
if i<=0:
#last fallback: try the default app dir
from xpra.platform.paths import default_get_app_dir
rsc = default_get_app_dir()
debug("get_resources_dir() default_get_app_dir()=%s", rsc)
i = rsc.rfind(RESOURCES)
if i>0:
rsc = rsc[:i+len(RESOURCES)]
debug("get_resources_dir()=%s", rsc)
return rsc
def _show_message(message, uType):
global prg_name
# TODO: detect cx_freeze equivallent
GUI_MODE = hasattr(sys, "frozen") and sys.frozen == "windows_exe"
from xpra.util import envbool
SHOW_MESSAGEBOX = envbool("XPRA_MESSAGEBOX", True)
if SHOW_MESSAGEBOX and GUI_MODE:
# try to use an alert box since no console output will be shown:
try:
win32api.MessageBox(0, message, prg_name, uType)
return
except:
pass
print(message)
# This file is part of Xpra.
# Copyright (C) 2010-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.
import os
from xpra.net.compression import Compressed
from xpra.server.source.stub_source_mixin import StubSourceMixin
from xpra.os_util import get_machine_id, get_user_uuid, bytestostr, POSIX
from xpra.util import csv, envbool, flatten_dict, typedict, XPRA_AUDIO_NOTIFICATION_ID
from xpra.log import Logger
log = Logger("sound")
NEW_STREAM_SOUND = envbool("XPRA_NEW_STREAM_SOUND", True)
class AudioMixin(StubSourceMixin):
def __init__(self):
self.sound_properties = {}
self.sound_source_plugin = ""
self.supports_speaker = False
self.speaker_codecs = []
self.supports_microphone = False
self.microphone_codecs = []
def init_from(self, _protocol, server):
self.sound_properties = server.sound_properties
self.sound_source_plugin = server.sound_source_plugin
# This file is part of Xpra.
# Copyright (C) 2013 Serviware (Arthur Huillet, <*****@*****.**>)
# Copyright (C) 2012-2016 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 os
import time, math
from xpra.util import envint, envbool
from xpra.log import Logger
log = Logger("opengl", "paint")
fpslog = Logger("opengl", "fps")
OPENGL_DEBUG = envbool("XPRA_OPENGL_DEBUG", False)
OPENGL_PAINT_BOX = envint("XPRA_OPENGL_PAINT_BOX", 0)
SCROLL_ENCODING = envbool("XPRA_SCROLL_ENCODING", True)
PAINT_FLUSH = envbool("XPRA_PAINT_FLUSH", True)
SAVE_BUFFERS = os.environ.get("XPRA_OPENGL_SAVE_BUFFERS")
if SAVE_BUFFERS not in ("png", "jpeg", None):
log.warn("invalid value for XPRA_OPENGL_SAVE_BUFFERS: must be 'png' or 'jpeg'")
SAVE_BUFFERS = None
from xpra.gtk_common.gtk_util import color_parse, is_realized
_DEFAULT_BOX_COLORS = {
"png" : "yellow",
"h264" : "blue",
"vp8" : "green",
#ensures we only load GTK2:
from xpra.x11.x11_server_base import X11ServerBase
from xpra.util import envbool
from xpra.gtk_common.gtk_util import get_xwindow
from xpra.server.shadow.gtk_shadow_server_base import GTKShadowServerBase
from xpra.server.shadow.gtk_root_window_model import GTKRootWindowModel
from xpra.x11.bindings.ximage import XImageBindings #@UnresolvedImport
from xpra.gtk_common.error import xsync
XImage = XImageBindings()
from xpra.log import Logger
log = Logger("x11", "shadow")
traylog = Logger("tray")
USE_XSHM = envbool("XPRA_XSHM", True)
class GTKX11RootWindowModel(GTKRootWindowModel):
def __init__(self, root_window):
GTKRootWindowModel.__init__(self, root_window)
self.xshm = None
def __repr__(self):
return "GTKX11RootWindowModel(%#x)" % get_xwindow(self.window)
def suspend(self):
#we can cleanup the current xshm area and we'll create a new one later
self.cleanup()
def X11XI2Bindings():
global X11XI2
if X11XI2 is False:
X11XI2 = None
if is_X11():
try:
from xpra.x11.bindings.xi2_bindings import X11XI2Bindings as _X11XI2Bindings #@UnresolvedImport
X11XI2 = _X11XI2Bindings()
except Exception:
log.error("no XI2 bindings", exc_info=True)
return X11XI2
device_bell = None
GTK_MENUS = envbool("XPRA_GTK_MENUS", False)
RANDR_DPI = envbool("XPRA_RANDR_DPI", True)
XSETTINGS_DPI = envbool("XPRA_XSETTINGS_DPI", True)
USE_NATIVE_TRAY = envbool(
"XPRA_USE_NATIVE_TRAY",
is_unity() or (is_Ubuntu() and is_gnome())
or (is_gnome() and not is_Fedora()) or is_kde())
XINPUT_WHEEL_DIV = envint("XPRA_XINPUT_WHEEL_DIV", 15)
DBUS_SCREENSAVER = envbool("XPRA_DBUS_SCREENSAVER", False)
def gl_check():
if not is_X11() and is_Wayland():
return "disabled under wayland with GTK3 (buggy)"
return None
from xpra.log import Logger
log = Logger("x11", "window")
focuslog = Logger("x11", "window", "focus")
screenlog = Logger("x11", "window", "screen")
framelog = Logger("x11", "window", "frame")
CWX = constants["CWX"]
CWY = constants["CWY"]
CWWidth = constants["CWWidth"]
CWHeight = constants["CWHeight"]
NotifyPointerRoot = constants["NotifyPointerRoot"]
NotifyDetailNone = constants["NotifyDetailNone"]
FORCE_REPLACE_WM = envbool("XPRA_FORCE_REPLACE_WM", False)
LOG_MANAGE_FAILURES = envbool("XPRA_LOG_MANAGE_FAILURES", False)
NO_NET_SUPPORTED = os.environ.get("XPRA_NO_NET_SUPPORTED", "").split(",")
DEFAULT_NET_SUPPORTED = [
"_NET_SUPPORTED", # a bit redundant, perhaps...
"_NET_SUPPORTING_WM_CHECK",
"_NET_WM_FULL_PLACEMENT",
"_NET_WM_HANDLED_ICONS",
"_NET_CLIENT_LIST",
"_NET_CLIENT_LIST_STACKING",
"_NET_DESKTOP_VIEWPORT",
"_NET_DESKTOP_GEOMETRY",
"_NET_NUMBER_OF_DESKTOPS",
"_NET_DESKTOP_NAMES",
#!/usr/bin/env python
# This file is part of Xpra.
# Copyright (C) 2014, 2015 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, os
#default implementation uses pycups
from xpra.util import envbool
from xpra.os_util import WIN32
from xpra.log import Logger
log = Logger("printing")
RAW_MODE = envbool("XPRA_PRINTER_RAW", False)
py3 = sys.version >= '3'
if py3:
unicode = str #@ReservedAssignment
def err(*args, **kwargs):
log.error(*args, **kwargs)
def get_printers():
return {}
def get_printer_attributes(name):
return []
def get_default_printer():
# This file is part of Xpra.
# Copyright (C) 2017-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.
import sys
from gi.repository import GLib, Gtk
from xpra.client.gtk_base.sessions_gui import SessionsGUI
from xpra.net.mdns import XPRA_MDNS_TYPE, get_listener_class
from xpra.util import envbool
from xpra.log import Logger
log = Logger("mdns", "util")
HIDE_IPV6 = envbool("XPRA_HIDE_IPV6", False)
class mdns_sessions(SessionsGUI):
def __init__(self, options):
super().__init__(options)
listener_class = get_listener_class()
assert listener_class
self.listener = listener_class(XPRA_MDNS_TYPE,
mdns_found=None,
mdns_add=self.mdns_add,
mdns_remove=self.mdns_remove)
log("%s%s=%s", listener_class,
(XPRA_MDNS_TYPE, None, self.mdns_add, self.mdns_remove),
self.listener)
self.listener.start()
# This file is part of Xpra.
# Copyright (C) 2015 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 os
import logging
from xpra.util import envbool
from xpra.log import Logger
PIL_DEBUG = envbool("XPRA_PIL_DEBUG", False)
if PIL_DEBUG:
log = Logger("encoder", "pillow")
log.info("enabling PIL.DEBUG")
level = logging.DEBUG
else:
level = logging.INFO
#newer versions use this logger,
#we must initialize it before we load the class:
for x in ("Image", "PngImagePlugin", "WebPImagePlugin", "JpegImagePlugin"):
logger = logging.getLogger("PIL.%s" % x)
logger.setLevel(level)
import PIL #@UnresolvedImport
from PIL import Image #@UnresolvedImport
assert PIL is not None and Image is not None, "failed to load Pillow"
try:
PIL_VERSION = PIL.PILLOW_VERSION
except:
PIL_VERSION = Image.VERSION
from urllib.parse import unquote #python3 @Reimport @UnresolvedImport
try:
from BaseHTTPServer import BaseHTTPRequestHandler #python2 @UnusedImport
except ImportError:
from http.server import BaseHTTPRequestHandler #python3 @Reimport @UnresolvedImport
from xpra.util import envbool, std, csv, AdHocStruct
from xpra.os_util import PYTHON2
from xpra.platform.paths import get_desktop_background_paths
from xpra.log import Logger
log = Logger("http")
HTTP_ACCEPT_ENCODING = os.environ.get("XPRA_HTTP_ACCEPT_ENCODING",
"br,gzip").split(",")
DIRECTORY_LISTING = envbool("XPRA_HTTP_DIRECTORY_LISTING", False)
EXTENSION_TO_MIMETYPE = {
".wasm": "application/wasm",
".js": "text/javascript",
".css": "text/css",
}
"""
Xpra's builtin HTTP server.
* locates the desktop background file at "/background.png" dynamically if missing,
* supports the magic ?echo-headers query,
* loads http headers from a directory (and caches the data),
* sets cache headers on responses,
* supports delegation to external script classes,
* supports pre-compressed brotli and gzip, can gzip on-the-fly,
(subclassed in WebSocketRequestHandler to add WebSocket support)
from xpra.version_util import get_version_info_full, get_platform_info
#client mixins:
from xpra.client.mixins.webcam import WebcamForwarder
from xpra.client.mixins.audio import AudioClient
from xpra.client.mixins.rpc import RPCClient
from xpra.client.mixins.clipboard import ClipboardClient
from xpra.client.mixins.notifications import NotificationClient
from xpra.client.mixins.window_manager import WindowClient
from xpra.client.mixins.mmap import MmapClient
from xpra.client.mixins.remote_logging import RemoteLogging
from xpra.client.mixins.display import DisplayClient
from xpra.client.mixins.network_state import NetworkState
from xpra.client.mixins.encodings import Encodings
from xpra.client.mixins.tray import TrayClient
MOUSE_DELAY_AUTO = envbool("XPRA_MOUSE_DELAY_AUTO", True)
TRAY_DELAY = envint("XPRA_TRAY_DELAY", 0)
"""
Utility superclass for client classes which have a UI.
See gtk_client_base and its subclasses.
"""
class UIXpraClient(XpraClientBase, DisplayClient, WindowClient,
WebcamForwarder, AudioClient, ClipboardClient,
NotificationClient, RPCClient, MmapClient, RemoteLogging,
NetworkState, Encodings, TrayClient):
#NOTE: these signals aren't registered here because this class
#does not extend GObject,
#the gtk client subclasses will take care of it.
#these are all "no-arg" signals
from xpra.os_util import memoryview_to_bytes, bytestostr
from xpra.platform.win32 import constants as win32con
from xpra.platform.win32.common import (
GUID, WNDCLASSEX, WNDPROC, GetSystemMetrics, GetCursorPos, PostMessageA,
CreateWindowExA, CreatePopupMenu, AppendMenu, LoadIconA, DefWindowProcA,
RegisterWindowMessageA, RegisterClassExA, ICONINFO, BITMAPV5HEADER,
LoadImageW, CreateIconIndirect, GetDC, ReleaseDC, CreateBitmap,
CreateDIBSection, UpdateWindow, DestroyWindow, PostQuitMessage,
GetModuleHandleA, GetStockObject, DeleteObject)
from xpra.log import Logger
log = Logger("tray", "win32")
log("loading ctypes NotifyIcon functions")
sprintf = ctypes.cdll.msvcrt.sprintf
TRAY_ALPHA = envbool("XPRA_TRAY_ALPHA", True)
def GetProductInfo(dwOSMajorVersion=5,
dwOSMinorVersion=0,
dwSpMajorVersion=0,
dwSpMinorVersion=0):
product_type = DWORD(0)
from xpra.platform.win32.common import GetProductInfo as k32GetProductInfo
v = k32GetProductInfo(dwOSMajorVersion, dwOSMinorVersion, dwSpMajorVersion,
dwSpMinorVersion, byref(product_type))
log("GetProductInfo(%i, %i, %i, %i)=%i product_type=%s", dwOSMajorVersion,
dwOSMinorVersion, dwSpMajorVersion, dwSpMinorVersion, v,
hex(product_type.value))
return bool(v)
log = Logger("opengl")
required_extensions = ["GL_ARB_texture_rectangle", "GL_ARB_vertex_program"]
#for testing:
#GREYLIST["vendor"].append("NVIDIA Corporation")
#WHITELIST["renderer"] = ["GeForce GTX 760/PCIe/SSE2"]
#frequent crashes on OSX with GT 650M: (see ticket #808)
#if OSX:
# GREYLIST.setdefault("vendor", []).append("NVIDIA Corporation")
#alpha requires gtk3 or *nix only for gtk2:
DEFAULT_ALPHA = PYTHON3 or (not WIN32 and not OSX)
GL_ALPHA_SUPPORTED = envbool("XPRA_ALPHA", DEFAULT_ALPHA)
#not working with gtk3 yet?
CAN_DOUBLE_BUFFER = not PYTHON3
#needed on win32?:
DEFAULT_DOUBLE_BUFFERED = WIN32 or CAN_DOUBLE_BUFFER
DOUBLE_BUFFERED = envbool("XPRA_OPENGL_DOUBLE_BUFFERED", DEFAULT_DOUBLE_BUFFERED)
CRASH = envbool("XPRA_OPENGL_FORCE_CRASH", False)
TIMEOUT = envint("XPRA_OPENGL_FORCE_TIMEOUT", 0)
#by default, we raise an ImportError as soon as we find something missing:
def raise_error(msg):
raise ImportError(msg)
def raise_fatal_error(msg):
raise OpenGLFatalError(msg)
from xpra.util import envbool, envint
from xpra.os_util import setsid, shellsub, close_fds, setuidgid, getuid, getgid, strtobytes, osexpand, monotonic_time, POSIX, OSX
from xpra.platform.displayfd import read_displayfd, parse_displayfd
VFB_WAIT = envint("XPRA_VFB_WAIT", 3)
DEFAULT_VFB_RESOLUTION = tuple(
int(x)
for x in os.environ.get("XPRA_DEFAULT_VFB_RESOLUTION",
"8192x4096").replace(",", "x").split("x", 1))
assert len(DEFAULT_VFB_RESOLUTION) == 2
DEFAULT_DESKTOP_VFB_RESOLUTION = tuple(
int(x)
for x in os.environ.get("XPRA_DEFAULT_DESKTOP_VFB_RESOLUTION",
"1280x1024").replace(",", "x").split("x", 1))
assert len(DEFAULT_DESKTOP_VFB_RESOLUTION) == 2
PRIVATE_XAUTH = envbool("XPRA_PRIVATE_XAUTH", True)
XAUTH_PER_DISPLAY = envbool("XPRA_XAUTH_PER_DISPLAY", True)
vfb_logger = None
def _vfb_logger():
global vfb_logger
if not vfb_logger:
from xpra.log import Logger
vfb_logger = Logger("server", "x11")
return vfb_logger
def create_xorg_device_configs(xorg_conf_dir, device_uuid, uid, gid):
log = _vfb_logger()
from xpra.server import server_features
from xpra.server.shadow.root_window_model import RootWindowModel
from xpra.server.gtk_server_base import GTKServerBase
from xpra.server.shadow.shadow_server_base import ShadowServerBase
from xpra.codecs.codec_constants import TransientCodecException, CodecStateException
from xpra.gtk_common.gtk_util import get_screen_sizes, get_icon_pixbuf
from xpra.net.compression import Compressed
from xpra.log import Logger
traylog = Logger("tray")
mouselog = Logger("mouse")
notifylog = Logger("notify")
screenlog = Logger("screen")
log = Logger("shadow")
MULTI_WINDOW = envbool("XPRA_SHADOW_MULTI_WINDOW", True)
def parse_geometry(s):
try:
parts = s.split("@")
if len(parts)==1:
x = y = 0
else:
x, y = [int(v.strip(" ")) for v in parts[1].split("x")]
w, h = [int(v.strip(" ")) for v in parts[0].split("x")]
geometry = [x, y, w, h]
screenlog("capture geometry: %s", geometry)
return geometry
except ValueError:
screenlog("failed to parse geometry %r", s, exc_info=True)
from xpra.exit_codes import (EXIT_OK, EXIT_CONNECTION_LOST, EXIT_TIMEOUT,
EXIT_UNSUPPORTED, EXIT_PASSWORD_REQUIRED,
EXIT_PASSWORD_FILE_ERROR,
EXIT_INCOMPATIBLE_VERSION, EXIT_ENCRYPTION,
EXIT_FAILURE, EXIT_PACKET_FAILURE,
EXIT_NO_AUTHENTICATION, EXIT_INTERNAL_ERROR)
log = Logger("client")
netlog = Logger("network")
authlog = Logger("auth")
mouselog = Logger("mouse")
cryptolog = Logger("crypto")
bandwidthlog = Logger("bandwidth")
EXTRA_TIMEOUT = 10
ALLOW_UNENCRYPTED_PASSWORDS = envbool("XPRA_ALLOW_UNENCRYPTED_PASSWORDS",
False)
ALLOW_LOCALHOST_PASSWORDS = envbool("XPRA_ALLOW_LOCALHOST_PASSWORDS", True)
DETECT_LEAKS = envbool("XPRA_DETECT_LEAKS", False)
LEGACY_SALT_DIGEST = envbool("XPRA_LEGACY_SALT_DIGEST", False)
MOUSE_DELAY = envint("XPRA_MOUSE_DELAY", 0)
def noop():
pass
""" Base class for Xpra clients.
Provides the glue code for:
* sending packets via Protocol
* handling packets received via _process_packet
For an actual implementation, look at:
GST_QUEUE_LEAK_DOWNSTREAM = 2
GST_QUEUE_LEAK_DEFAULT = GST_QUEUE_LEAK_DOWNSTREAM
MS_TO_NS = 1000000
QUEUE_LEAK = envint("XPRA_SOUND_QUEUE_LEAK", GST_QUEUE_LEAK_DEFAULT)
if QUEUE_LEAK not in (GST_QUEUE_NO_LEAK, GST_QUEUE_LEAK_UPSTREAM, GST_QUEUE_LEAK_DOWNSTREAM):
log.error("invalid leak option %s", QUEUE_LEAK)
QUEUE_LEAK = GST_QUEUE_LEAK_DEFAULT
def get_queue_time(default_value=450, prefix=""):
queue_time = int(os.environ.get("XPRA_SOUND_QUEUE_%sTIME" % prefix, default_value))*MS_TO_NS
queue_time = max(0, queue_time)
return queue_time
ALLOW_SOUND_LOOP = envbool("XPRA_ALLOW_SOUND_LOOP", False)
PULSEAUDIO_DEVICE_NAME = os.environ.get("XPRA_PULSEAUDIO_DEVICE_NAME", "")
USE_DEFAULT_DEVICE = envbool("XPRA_USE_DEFAULT_DEVICE", True)
def force_enabled(codec_name):
return os.environ.get("XPRA_SOUND_CODEC_ENABLE_%s" % codec_name.upper(), "0")=="1"
NAME_TO_SRC_PLUGIN = {
"auto" : "autoaudiosrc",
"alsa" : "alsasrc",
"oss" : "osssrc",
"oss4" : "oss4src",
"jack" : "jackaudiosrc",
"osx" : "osxaudiosrc",
"test" : "audiotestsrc",
"pulse" : "pulsesrc",
from xpra.child_reaper import getChildReaper
from xpra.scripts.parsing import parse_bool
from xpra.scripts.config import make_defaults_struct, PROXY_START_OVERRIDABLE_OPTIONS, OPTION_TYPES
from xpra.scripts.main import parse_display_name, connect_to, start_server_subprocess
from xpra.make_thread import start_thread
from xpra.log import Logger
log = Logger("proxy")
authlog = Logger("proxy", "auth")
freeze_support()
PROXY_SOCKET_TIMEOUT = envfloat("XPRA_PROXY_SOCKET_TIMEOUT", "0.1")
PROXY_WS_TIMEOUT = envfloat("XPRA_PROXY_WS_TIMEOUT", "1.0")
assert PROXY_SOCKET_TIMEOUT > 0, "invalid proxy socket timeout"
CAN_STOP_PROXY = envbool("XPRA_CAN_STOP_PROXY", getuid() != 0 or WIN32)
STOP_PROXY_SOCKET_TYPES = os.environ.get("XPRA_STOP_PROXY_SOCKET_TYPES",
"unix-domain,named-pipe").split(",")
STOP_PROXY_AUTH_SOCKET_TYPES = os.environ.get(
"XPRA_STOP_PROXY_AUTH_SOCKET_TYPES", "unix-domain").split(",")
#something (a thread lock?) doesn't allow us to use multiprocessing on MS Windows:
PROXY_INSTANCE_THREADED = envbool("XPRA_PROXY_INSTANCE_THREADED", WIN32)
PROXY_CLEANUP_GRACE_PERIOD = envfloat("XPRA_PROXY_CLEANUP_GRACE_PERIOD", "0.5")
MAX_CONCURRENT_CONNECTIONS = envint("XPRA_PROXY_MAX_CONCURRENT_CONNECTIONS",
200)
if WIN32:
#DEFAULT_ENV_WHITELIST = "ALLUSERSPROFILE,APPDATA,COMMONPROGRAMFILES,COMMONPROGRAMFILES(X86),COMMONPROGRAMW6432,COMPUTERNAME,COMSPEC,FP_NO_HOST_CHECK,LOCALAPPDATA,NUMBER_OF_PROCESSORS,OS,PATH,PATHEXT,PROCESSOR_ARCHITECTURE,PROCESSOR_ARCHITECTURE,PROCESSOR_IDENTIFIER,PROCESSOR_LEVEL,PROCESSOR_REVISION,PROGRAMDATA,PROGRAMFILES,PROGRAMFILES(X86),PROGRAMW6432,PSMODULEPATH,PUBLIC,SYSTEMDRIVE,SYSTEMROOT,TEMP,TMP,USERDOMAIN,WORKGROUP,USERNAME,USERPROFILE,WINDIR,XPRA_REDIRECT_OUTPUT,XPRA_LOG_FILENAME,XPRA_ALL_DEBUG"
DEFAULT_ENV_WHITELIST = "*"
else:
DEFAULT_ENV_WHITELIST = "LANG,HOSTNAME,PWD,TERM,SHELL,SHLVL,PATH,USER,HOME"
screenlog = Logger("win32", "screen")
keylog = Logger("win32", "keyboard")
mouselog = Logger("win32", "mouse")
from xpra.platform.win32.win32_events import get_win32_event_listener
from xpra.platform.win32.window_hooks import Win32Hooks
from xpra.util import AdHocStruct, csv, envint, envbool
import ctypes
from ctypes import CFUNCTYPE, c_int, POINTER, Structure, windll, byref, sizeof
from ctypes.wintypes import HWND, DWORD, WPARAM, LPARAM
import win32con #@UnresolvedImport
import win32api #@UnresolvedImport
import win32gui #@UnresolvedImport
WINDOW_HOOKS = envbool("XPRA_WIN32_WINDOW_HOOKS", True)
GROUP_LEADER = WINDOW_HOOKS and envbool("XPRA_WIN32_GROUP_LEADER", True)
UNDECORATED_STYLE = WINDOW_HOOKS and envbool("XPRA_WIN32_UNDECORATED_STYLE", True)
CLIP_CURSOR = WINDOW_HOOKS and envbool("XPRA_WIN32_CLIP_CURSOR", True)
#GTK3 is fixed, so we don't need this hook:
DEFAULT_MAX_SIZE_HINT = sys.version_info[0]<3
MAX_SIZE_HINT = WINDOW_HOOKS and envbool("XPRA_WIN32_MAX_SIZE_HINT", DEFAULT_MAX_SIZE_HINT)
GEOMETRY = WINDOW_HOOKS and envbool("XPRA_WIN32_GEOMETRY", True)
LANGCHANGE = WINDOW_HOOKS and envbool("XPRA_WIN32_LANGCHANGE", True)
DPI_AWARE = envbool("XPRA_DPI_AWARE", True)
DPI_AWARENESS = envint("XPRA_DPI_AWARENESS", 1)
FORWARD_WINDOWS_KEY = envbool("XPRA_FORWARD_WINDOWS_KEY", True)
WHEEL = envbool("XPRA_WHEEL", True)
WHEEL_DELTA = envint("XPRA_WHEEL_DELTA", 120)
assert WHEEL_DELTA>0
# This file is part of Xpra.
# Copyright (C) 2016-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.
import time
from unit.client.x11_client_test_util import X11ClientTestUtil
from xpra.util import envbool
from xpra.os_util import get_hex_uuid, pollwait, which
from xpra.platform.features import CLIPBOARDS
from xpra.log import Logger
log = Logger("clipboard")
SANITY_CHECKS = envbool("XPRA_CLIPBOARD_SANITY_CHECKS", True)
def has_xclip():
return which("xclip")
class X11ClipboardTestUtil(X11ClientTestUtil):
def get_clipboard_value(self, display, selection="clipboard"):
out = self.get_command_output("xclip -d %s -selection %s -o" %
(display, selection),
shell=True)
return out.decode()
def set_clipboard_value(self, display, value, selection="clipboard"):
cmd = "echo -n '%s' | xclip -d %s -selection %s -i" % (value, display,
MIN_CLIPBOARD_COMPRESSION_SIZE = 512
MAX_CLIPBOARD_PACKET_SIZE = 4*1024*1024
from xpra.platform.features import CLIPBOARDS as PLATFORM_CLIPBOARDS
ALL_CLIPBOARDS = PLATFORM_CLIPBOARDS
CLIPBOARDS = PLATFORM_CLIPBOARDS
CLIPBOARDS_ENV = os.environ.get("XPRA_CLIPBOARDS")
if CLIPBOARDS_ENV is not None:
CLIPBOARDS = CLIPBOARDS_ENV.split(",")
CLIPBOARDS = [x.upper().strip() for x in CLIPBOARDS]
TEST_DROP_CLIPBOARD_REQUESTS = envint("XPRA_TEST_DROP_CLIPBOARD")
STORE_ON_EXIT = envbool("XPRA_CLIPBOARD_STORE_ON_EXIT", True)
_discard_target_strs_ = os.environ.get("XPRA_DISCARD_TARGETS")
if _discard_target_strs_ is not None:
DISCARD_TARGETS = _discard_target_strs_.split(",")
else:
#default:
DISCARD_TARGETS = [
"^SAVE_TARGETS$",
"^COMPOUND_TEXT",
"^NeXT",
"^com\.apple\.",
"^CorePasteboardFlavorType",
"^dyn\."]
log("DISCARD_TARGETS=%s", csv(DISCARD_TARGETS))
DISCARD_TARGETS = [re.compile(x) for x in DISCARD_TARGETS]
from collections import deque
from queue import Queue
from xpra.make_thread import start_thread
from xpra.os_util import monotonic_time
from xpra.util import notypedict, envbool, envint, typedict, AtomicInteger
from xpra.net.compression import compressed_wrapper, Compressed
from xpra.server.source.source_stats import GlobalPerformanceStatistics
from xpra.server.source.stub_source_mixin import StubSourceMixin
from xpra.log import Logger
log = Logger("server")
notifylog = Logger("notify")
bandwidthlog = Logger("bandwidth")
BANDWIDTH_DETECTION = envbool("XPRA_BANDWIDTH_DETECTION", True)
MIN_BANDWIDTH = envint("XPRA_MIN_BANDWIDTH", 5 * 1024 * 1024)
AUTO_BANDWIDTH_PCT = envint("XPRA_AUTO_BANDWIDTH_PCT", 80)
assert 1 < AUTO_BANDWIDTH_PCT <= 100, "invalid value for XPRA_AUTO_BANDWIDTH_PCT: %i" % AUTO_BANDWIDTH_PCT
YIELD = envbool("XPRA_YIELD", False)
counter = AtomicInteger()
"""
This class mediates between the server class (which only knows about actual window objects and display server events)
and the client specific WindowSource instances (which only know about window ids
and manage window pixel compression).
It sends messages to the client via its 'protocol' instance (the network connection),
directly for a number of cases (cursor, sound, notifications, etc)
or on behalf of the window sources for pixel data.
Strategy: if we have 'ordinary_packets' to send, send those.
from xpra.util import envbool
from xpra.gtk_common.gobject_compat import import_gtk, import_gdk, is_gtk3
gtk = import_gtk()
gdk = import_gdk()
from xpra.client.tray_base import TrayBase, log
from xpra.gtk_common.gtk_util import get_icon_from_file, get_pixbuf_from_data, INTERP_HYPER
ORIENTATION = {}
if not is_gtk3():
#where was this moved to??
ORIENTATION[gtk.ORIENTATION_HORIZONTAL] = "HORIZONTAL"
ORIENTATION[gtk.ORIENTATION_VERTICAL] = "VERTICAL"
GUESS_GEOMETRY = sys.platform.startswith("win") or sys.platform.startswith("darwin")
GUESS_GEOMETRY = envbool("XPRA_GUESS_ICON_GEOMETRY", GUESS_GEOMETRY)
log("tray GUESS_GEOMETRY=%s", GUESS_GEOMETRY)
class GTKStatusIconTray(TrayBase):
def __init__(self, *args, **kwargs):
TrayBase.__init__(self, *args, **kwargs)
self.tray_widget = gtk.StatusIcon()
self.tray_widget.set_tooltip_text(self.tooltip or "Xpra")
self.tray_widget.connect('activate', self.activate_menu)
self.tray_widget.connect('popup-menu', self.popup_menu)
if self.size_changed_cb:
self.tray_widget.connect('size-changed', self.size_changed_cb)
filename = self.get_tray_icon_filename(self.default_icon_filename)
if filename:
gi.require_version('Gtk', '3.0')
gi.require_version('Pango', '1.0')
from gi.repository import GLib, Gdk, Gtk #pylint: disable=no-name-in-module
from xpra.util import flatten_dict, envbool
from xpra.os_util import load_binary_file
from xpra.gtk_common.gobject_compat import register_os_signals
from xpra.server import server_features
from xpra.server.server_base import ServerBase
from xpra.gtk_common.gtk_util import (
get_gtk_version_info,
get_root_size,
)
from xpra.log import Logger
UI_THREAD_WATCHER = envbool("XPRA_UI_THREAD_WATCHER")
log = Logger("server", "gtk")
screenlog = Logger("server", "screen")
cursorlog = Logger("server", "cursor")
notifylog = Logger("notify")
class GTKServerBase(ServerBase):
"""
This is the base class for servers.
It provides all the generic functions but is not tied
to a specific backend (X11 or otherwise).
See X11ServerBase, XpraServer and XpraX11ShadowServer
"""
def __init__(self):
import os
import time
from gtk import gdk
import cairo
from xpra.log import Logger
log = Logger("paint")
from xpra.client.gtk2.window_backing import GTK2WindowBacking
from xpra.client.window_backing_base import fire_paint_callbacks
from xpra.os_util import memoryview_to_bytes
from xpra.util import csv, envbool
PIXMAP_RGB_MODES = ["RGB", "RGBX", "RGBA"]
INDIRECT_BGR = envbool("XPRA_PIXMAP_INDIRECT_BGR", False)
if INDIRECT_BGR:
PIXMAP_RGB_MODES += ["BGRX", "BGRA", "BGR"]
INTERP_DICT = {"nearest" : gdk.INTERP_NEAREST,
"tiles" : gdk.INTERP_TILES,
"bilinear" : gdk.INTERP_BILINEAR,
"hyper" : gdk.INTERP_HYPER}
SCALING_INTERP_STR = os.environ.get("XPRA_SCALING_INTERPOLATION", "HYPER").lower()
SCALING_INTERP = INTERP_DICT.get(SCALING_INTERP_STR)
if not SCALING_INTERP:
log.warn("Warning: invalid interpolation '%s'")
log.warn(" supported types: %s", csv(INTERP_DICT.keys()))
"""
# 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.log import Logger
log = Logger("opengl")
from xpra.util import envbool
from xpra.client.gl.gl_check import check_PyOpenGL_support
from xpra.x11.bindings.display_source import get_display_ptr #@UnresolvedImport
from xpra.gtk_common.gtk_util import display_get_default, get_xwindow, make_temp_window
from ctypes import c_int, byref, cast, POINTER
from OpenGL import GLX
from OpenGL.GL import GL_VENDOR, GL_RENDERER, glGetString
DOUBLE_BUFFERED = envbool("XPRA_OPENGL_DOUBLE_BUFFERED", True)
def c_attrs(props):
attrs = []
for k,v in props.items():
attrs += [k, v]
attrs += [0, 0]
return (c_int * len(attrs))(*attrs)
def get_xdisplay():
ptr = get_display_ptr()
assert ptr, "no X11 display registered"
from OpenGL.raw.GLX._types import struct__XDisplay
return cast(ptr, POINTER(struct__XDisplay))
from xpra.os_util import Queue, setbinarymode, SIGNAMES, bytestostr
from xpra.child_reaper import getChildReaper
from xpra.log import Logger
log = Logger("util")
#this wrapper allows us to interact with a subprocess as if it was
#a normal class with gobject signals
#so that we can interact with it using a standard xpra protocol layer
#there is a wrapper for the caller
#and one for the class
#they talk to each other through stdin / stdout,
#using the protocol for encoding the data
DEBUG_WRAPPER = envbool("XPRA_WRAPPER_DEBUG", False)
#to make it possible to inspect files (more human readable):
HEXLIFY_PACKETS = envbool("XPRA_HEXLIFY_PACKETS", False)
#avoids showing a new console window on win32:
WIN32_SHOWWINDOW = envbool("XPRA_WIN32_SHOWWINDOW", False)
#this used to cause problems with py3k / gi bindings?
HANDLE_SIGINT = envbool("XPRA_WRAPPER_SIGINT", True)
FAULT_RATE = envint("XPRA_WRAPPER_FAULT_INJECTION_RATE")
if FAULT_RATE>0:
_counter = 0
def INJECT_FAULT(p):
global _counter
_counter += 1
if (_counter % FAULT_RATE)==0:
log.warn("injecting fault in %s", p)
from xpra.gtk_common.gobject_util import n_arg_signal, gobject
from xpra.sound.gstreamer_util import get_source_plugins, plugin_str, get_encoder_elements, get_encoder_default_options, normv, get_encoders, get_queue_time, \
MP3, CODEC_ORDER, MUXER_DEFAULT_OPTIONS, ENCODER_NEEDS_AUDIOCONVERT, SOURCE_NEEDS_AUDIOCONVERT, MS_TO_NS, GST_QUEUE_LEAK_DOWNSTREAM
from xpra.net.compression import compressed_wrapper
from xpra.scripts.config import InitExit
from xpra.log import Logger
log = Logger("sound")
gstlog = Logger("gstreamer")
APPSINK = os.environ.get("XPRA_SOURCE_APPSINK", "appsink name=sink emit-signals=true max-buffers=10 drop=true sync=false async=false qos=false")
JITTER = envint("XPRA_SOUND_SOURCE_JITTER", 0)
SOURCE_QUEUE_TIME = get_queue_time(50, "SOURCE_")
BUFFER_TIME = envint("XPRA_SOUND_SOURCE_BUFFER_TIME", 0) #ie: 64
LATENCY_TIME = envint("XPRA_SOUND_SOURCE_LATENCY_TIME", 0) #ie: 32
BUNDLE_METADATA = envbool("XPRA_SOUND_BUNDLE_METADATA", True)
SAVE_TO_FILE = os.environ.get("XPRA_SAVE_TO_FILE")
generation = AtomicInteger()
class SoundSource(SoundPipeline):
__gsignals__ = SoundPipeline.__generic_signals__.copy()
__gsignals__.update({
"new-buffer" : n_arg_signal(3),
})
def __init__(self, src_type=None, src_options={}, codecs=get_encoders(), codec_options={}, volume=1.0):
if not src_type:
try:
if uv and uv < [15]:
# Ubuntu 14.x drivers are just too old
GREYLIST.setdefault("vendor", []).append("X.Org")
if False:
# for testing:
BLACKLIST["vendor"].append("NVIDIA Corporation")
WHITELIST["renderer"] = ["GeForce GTX 760/PCIe/SSE2"]
if OSX:
# frequent crashes on osx with GT 650M: (see ticket #808)
GREYLIST.setdefault("vendor", []).append("NVIDIA Corporation")
# alpha requires gtk3 or *nix only for gtk2:
DEFAULT_ALPHA = sys.version > "3" or (not WIN32 and not OSX)
GL_ALPHA_SUPPORTED = envbool("XPRA_ALPHA", DEFAULT_ALPHA)
# not working with gtk3 yet?
CAN_DOUBLE_BUFFER = True
# needed on win32?:
DEFAULT_DOUBLE_BUFFERED = WIN32 and CAN_DOUBLE_BUFFER
DOUBLE_BUFFERED = envbool("XPRA_OPENGL_DOUBLE_BUFFERED", DEFAULT_DOUBLE_BUFFERED)
from xpra.gtk_common.gtk_util import STATIC_GRAY, GRAYSCALE, STATIC_COLOR, PSEUDO_COLOR, TRUE_COLOR, DIRECT_COLOR
VISUAL_NAMES = {
STATIC_GRAY: "STATIC_GRAY",
GRAYSCALE: "GRAYSCALE",
STATIC_COLOR: "STATIC_COLOR",
PSEUDO_COLOR: "PSEUDO_COLOR",
TRUE_COLOR: "TRUE_COLOR",
DIRECT_COLOR: "DIRECT_COLOR",
import time
import sys
import os
import errno
import socket
import types
from xpra.log import Logger
log = Logger("network", "protocol")
from xpra.net import ConnectionClosedException
from xpra.util import envint, envbool
from xpra.os_util import WIN32
TCP_NODELAY = envbool("XPRA_TCP_NODELAY", True)
VSOCK_TIMEOUT = envint("XPRA_VSOCK_TIMEOUT", 5)
SOCKET_TIMEOUT = envint("XPRA_SOCKET_TIMEOUT", 10)
#on some platforms (ie: OpenBSD), reading and writing from sockets
#raises an IOError but we should continue if the error code is EINTR
#this wrapper takes care of it.
#EWOULDBLOCK can also be hit with the proxy server when we handover the socket
CONTINUE = {
errno.EINTR : "EINTR",
errno.EWOULDBLOCK : "EWOULDBLOCK"
}
ABORT = {
errno.ENXIO : "ENXIO",
errno.ECONNRESET : "ECONNRESET",
from xpra.x11.gtk_x11.keys import grok_modifier_map
from xpra.x11.xkbhelper import (
do_set_keymap, set_all_keycodes, set_keycode_translation,
get_modifiers_from_meanings, get_modifiers_from_keycodes,
clear_modifiers, set_modifiers, map_missing_modifiers,
clean_keyboard_state, get_keycode_mappings,
DEBUG_KEYSYMS,
)
from xpra.x11.bindings.keyboard_bindings import X11KeyboardBindings #@UnresolvedImport
from xpra.log import Logger
log = Logger("keyboard")
X11Keyboard = X11KeyboardBindings()
MAP_MISSING_MODIFIERS = envbool("XPRA_MAP_MISSING_MODIFIERS", True)
SHIFT_LOCK = envbool("XPRA_SHIFT_LOCK", False)
ALL_X11_MODIFIERS = {
"shift" : 0,
"lock" : 1,
"control" : 2,
"mod1" : 3,
"mod2" : 4,
"mod3" : 5,
"mod4" : 6,
"mod5" : 7
}
class KeyboardConfig(KeyboardConfigBase):
def __init__(self):
from xpra.util import envbool
from xpra.gtk_common.gobject_compat import import_gtk, import_gdk, is_gtk3
gtk = import_gtk()
gdk = import_gdk()
from xpra.client.tray_base import TrayBase, log
from xpra.gtk_common.gtk_util import get_icon_from_file, get_pixbuf_from_data, INTERP_HYPER
ORIENTATION = {}
if not is_gtk3():
#where was this moved to??
ORIENTATION[gtk.ORIENTATION_HORIZONTAL] = "HORIZONTAL"
ORIENTATION[gtk.ORIENTATION_VERTICAL] = "VERTICAL"
GUESS_GEOMETRY = WIN32 or OSX
GUESS_GEOMETRY = envbool("XPRA_GUESS_ICON_GEOMETRY", GUESS_GEOMETRY)
log("tray GUESS_GEOMETRY=%s", GUESS_GEOMETRY)
class GTKStatusIconTray(TrayBase):
def __init__(self, *args, **kwargs):
TrayBase.__init__(self, *args, **kwargs)
self.tray_widget = gtk.StatusIcon()
self.tray_widget.set_tooltip_text(self.tooltip or "Xpra")
self.tray_widget.connect('activate', self.activate_menu)
self.tray_widget.connect('popup-menu', self.popup_menu)
if self.size_changed_cb:
self.tray_widget.connect('size-changed', self.size_changed_cb)
if self.default_icon_filename:
self.set_icon()
self.tray_widget.set_visible(True)
#!/usr/bin/env python
# This file is part of Xpra.
# Copyright (C) 2011-2016 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.log import Logger
log = Logger("osx", "events")
from xpra.util import envbool
SLEEP_HANDLER = envbool("XPRA_OSX_SLEEP_HANDLER", True)
exit_cb = None
def quit_handler(*args):
global exit_cb
if exit_cb:
exit_cb()
else:
from xpra.gtk_common.quit import gtk_main_quit_really
gtk_main_quit_really()
return True
def set_exit_cb(ecb):
global exit_cb
exit_cb = ecb
macapp = None
def get_OSXApplication():
global macapp
import os
import time
from gtk import gdk
import cairo
from xpra.log import Logger
log = Logger("paint")
from xpra.client.gtk2.window_backing import GTK2WindowBacking
from xpra.client.window_backing_base import fire_paint_callbacks
from xpra.os_util import memoryview_to_bytes, _buffer, _memoryview
from xpra.util import csv, envbool
PIXMAP_RGB_MODES = ["RGB", "RGBX", "RGBA"]
INDIRECT_BGR = envbool("XPRA_PIXMAP_INDIRECT_BGR", False)
if INDIRECT_BGR:
PIXMAP_RGB_MODES += ["BGRX", "BGRA", "BGR"]
INTERP_DICT = {"nearest" : gdk.INTERP_NEAREST,
"tiles" : gdk.INTERP_TILES,
"bilinear" : gdk.INTERP_BILINEAR,
"hyper" : gdk.INTERP_HYPER}
SCALING_INTERP_STR = os.environ.get("XPRA_SCALING_INTERPOLATION", "HYPER").lower()
SCALING_INTERP = INTERP_DICT.get(SCALING_INTERP_STR)
if not SCALING_INTERP:
log.warn("Warning: invalid interpolation '%s'")
log.warn(" supported types: %s", csv(INTERP_DICT.keys()))
"""
log = Logger("sound")
gstlog = Logger("gstreamer")
glib = import_glib()
SINK_SHARED_DEFAULT_ATTRIBUTES = {"sync" : False,
"async" : True,
"qos" : True
}
SINK_DEFAULT_ATTRIBUTES = {
"pulsesink" : {"client-name" : "Xpra"},
}
QUEUE_SILENT = envbool("XPRA_QUEUE_SILENT", False)
QUEUE_TIME = get_queue_time(450)
UNMUTE_DELAY = envint("XPRA_UNMUTE_DELAY", 1000)
GRACE_PERIOD = envint("XPRA_SOUND_GRACE_PERIOD", 2000)
#percentage: from 0 for no margin, to 200% which triples the buffer target
MARGIN = max(0, min(200, envint("XPRA_SOUND_MARGIN", 50)))
#how high we push up the min-level to prevent underruns:
UNDERRUN_MIN_LEVEL = max(0, envint("XPRA_SOUND_UNDERRUN_MIN_LEVEL", 50))
GST_FORMAT_BYTES = 2
GST_FORMAT_TIME = 3
GST_FORMAT_BUFFERS = 4
BUFFER_FORMAT = GST_FORMAT_BUFFERS
import os
import time
import subprocess, shlex
import hashlib
import uuid
from xpra.log import Logger
printlog = Logger("printing")
filelog = Logger("file")
from xpra.child_reaper import getChildReaper
from xpra.util import typedict, csv, nonl, envint, envbool
from xpra.simple_stats import std_unit
DELETE_PRINTER_FILE = envbool("XPRA_DELETE_PRINTER_FILE", True)
FILE_CHUNKS_SIZE = max(0, envint("XPRA_FILE_CHUNKS_SIZE", 65536))
MAX_CONCURRENT_FILES = max(1, envint("XPRA_MAX_CONCURRENT_FILES", 10))
CHUNK_TIMEOUT = 10 * 1000
MIMETYPE_EXTS = {
"application/postscript": "ps",
"application/pdf": "pdf",
"raw": "raw",
}
def safe_open_download_file(basefilename, mimetype):
from xpra.platform.paths import get_download_dir
#make sure we use a filename that does not exist already:
dd = os.path.expanduser(get_download_dir())
from xpra.log import Logger
log = Logger("x11", "server")
keylog = Logger("x11", "server", "keyboard")
mouselog = Logger("x11", "server", "mouse")
grablog = Logger("server", "grab")
cursorlog = Logger("server", "cursor")
screenlog = Logger("server", "screen")
gllog = Logger("screen", "opengl")
from xpra.util import iround, envbool, envint
from xpra.server.gtk_server_base import GTKServerBase
from xpra.x11.xkbhelper import clean_keyboard_state
from xpra.x11.server_keyboard_config import KeyboardConfig
MAX_CONCURRENT_CONNECTIONS = envint("XPRA_MAX_CONCURRENT_CONNECTIONS", 20)
ALWAYS_NOTIFY_MOTION = envbool("XPRA_ALWAYS_NOTIFY_MOTION", False)
def window_name(window):
from xpra.x11.gtk_x11.prop import prop_get
return prop_get(window, "_NET_WM_NAME", "utf8", True) or "unknown"
def window_info(window):
from xpra.x11.gtk_x11.prop import prop_get
net_wm_name = prop_get(window, "_NET_WM_NAME", "utf8", True)
return "%s %s (%s / %s)" % (net_wm_name, window, window.get_geometry(), window.is_visible())
from xpra.x11.gtk2.gdk_bindings import get_children #@UnresolvedImport
def dump_windows():
root = gdk.get_default_root_window()
NorthEastGravity,
WestGravity,
CenterGravity,
EastGravity,
SouthWestGravity,
SouthGravity,
SouthEastGravity,
StaticGravity,
GRAVITY_STR,
)
from xpra.log import Logger
log = Logger("paint")
videolog = Logger("video", "paint")
INTEGRITY_HASH = envbool("XPRA_INTEGRITY_HASH", False)
PAINT_BOX = envint("XPRA_PAINT_BOX", 0) or envint("XPRA_OPENGL_PAINT_BOX", 0)
WEBP_PILLOW = envbool("XPRA_WEBP_PILLOW", False)
SCROLL_ENCODING = envbool("XPRA_SCROLL_ENCODING", True)
REPAINT_ALL = envbool("XPRA_REPAINT_ALL", False)
#ie:
#CSC_OPTIONS = { "YUV420P" : {"RGBX" : [swscale.spec], "BGRX" : ...} }
CSC_OPTIONS = None
def load_csc_options():
global CSC_OPTIONS
if CSC_OPTIONS is None:
CSC_OPTIONS = {}
vh = getVideoHelper()
# later version. See the file COPYING for details.
import os
import time
import sys
from xpra.sound.gstreamer_util import parse_sound_source, get_source_plugins, format_element_options, \
can_decode, can_encode, get_muxers, get_demuxers, get_all_plugin_names
from xpra.net.subprocess_wrapper import subprocess_caller, subprocess_callee, exec_kwargs, exec_env
from xpra.platform.paths import get_sound_command
from xpra.util import AdHocStruct, typedict, parse_simple_dict, envint, envbool
from xpra.scripts.config import InitExit, InitException
from xpra.log import Logger
log = Logger("sound")
DEBUG_SOUND = envbool("XPRA_SOUND_DEBUG", False)
SUBPROCESS_DEBUG = [x.strip() for x in os.environ.get("XPRA_SOUND_SUBPROCESS_DEBUG", "").split(",") if x.strip()]
FAKE_START_FAILURE = envbool("XPRA_SOUND_FAKE_START_FAILURE", False)
FAKE_EXIT = envbool("XPRA_SOUND_FAKE_EXIT", False)
FAKE_CRASH = envbool("XPRA_SOUND_FAKE_CRASH", False)
SOUND_START_TIMEOUT = envint("XPRA_SOUND_START_TIMEOUT", 3000)
BUNDLE_METADATA = envbool("XPRA_SOUND_BUNDLE_METADATA", True)
def get_sound_wrapper_env():
env = {}
if sys.platform.startswith("win"):
#disable bencoder to skip warnings with the py3k Sound subapp
env["XPRA_USE_BENCODER"] = "0"
elif os.name=="posix" and not sys.platform.startswith("darwin"):
try:
BitBlt,
GetDeviceCaps,
GetSystemPaletteEntries,
)
log = Logger("shadow", "win32")
NULLREGION = 1 #The region is empty.
SIMPLEREGION = 2 #The region is a single rectangle.
COMPLEXREGION = 3 #The region is more than a single rectangle.
REGION_CONSTS = {
NULLREGION: "the region is empty",
SIMPLEREGION: "the region is a single rectangle",
COMPLEXREGION: "the region is more than a single rectangle",
}
DISABLE_DWM_COMPOSITION = envbool("XPRA_DISABLE_DWM_COMPOSITION", False)
class PALETTEENTRY(ctypes.Structure):
_fields_ = [
('peRed', ctypes.c_ubyte),
('peGreen', ctypes.c_ubyte),
('peBlue', ctypes.c_ubyte),
('peFlags', ctypes.c_ubyte),
]
DWM_EC_DISABLECOMPOSITION = 0
DWM_EC_ENABLECOMPOSITION = 1
# Copyright (C) 2008 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2012-2016 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 gtk import gdk
from xpra.log import Logger
log = Logger("paint")
from xpra.util import envbool
from xpra.client.gtk_base.gtk_window_backing_base import GTKWindowBacking
from xpra.client.window_backing_base import fire_paint_callbacks
from xpra.codecs.loader import has_codec
USE_PIL = envbool("XPRA_USE_PIL", True)
"""
This is the gtk2 version.
(works much better than gtk3!)
Superclass for PixmapBacking and GLBacking
"""
class GTK2WindowBacking(GTKWindowBacking):
def init(self, *args):
raise Exception("override me!")
def paint_image(self, coding, img_data, x, y, width, height, options, callbacks):
""" can be called from any thread """
import os
import sys
import glob
from time import monotonic
from typing import Generator as generator #@UnresolvedImport, @UnusedImport
from xpra.util import envbool, print_nested_dict, first_time, engs
from xpra.os_util import load_binary_file, OSEnvContext
from xpra.codecs import icon_util
from xpra.platform.paths import get_icon_filename
from xpra.log import Logger, add_debug_category
log = Logger("exec", "menu")
LOAD_GLOB = envbool("XPRA_XDG_LOAD_GLOB", True)
EXPORT_ICONS = envbool("XPRA_XDG_EXPORT_ICONS", True)
DEBUG_COMMANDS = os.environ.get("XPRA_XDG_DEBUG_COMMANDS", "").split(",")
EXPORT_TERMINAL_APPLICATIONS = envbool("XPRA_XDG_EXPORT_TERMINAL_APPLICATIONS",
False)
EXPORT_SELF = envbool("XPRA_XDG_EXPORT_SELF", False)
LOAD_APPLICATIONS = os.environ.get("XPRA_MENU_LOAD_APPLICATIONS",
"%s/share/applications" %
sys.prefix).split(":")
def isvalidtype(v):
if isinstance(v, (list, tuple, generator)):
if not v:
return True
return all(isvalidtype(x) for x in v)
from xpra.scripts.config import parse_number, parse_bool
from xpra.scripts.server import create_unix_domain_socket
from xpra.platform.dotxpra import DotXpra
from xpra.net.bytestreams import SocketConnection, SOCKET_TIMEOUT
from multiprocessing import Process
try:
from xpra.codecs.xor.cyxor import xor_str #@UnresolvedImport
xor = xor_str
except:
pass
PROXY_QUEUE_SIZE = envint("XPRA_PROXY_QUEUE_SIZE", 10)
#for testing only: passthrough as RGB:
PASSTHROUGH = envbool("XPRA_PROXY_PASSTHROUGH", False)
MAX_CONCURRENT_CONNECTIONS = 20
VIDEO_TIMEOUT = 5 #destroy video encoder after N seconds of idle state
def set_blocking(conn):
#Note: importing set_socket_timeout from xpra.net.bytestreams
#fails in mysterious ways, so we duplicate the code here instead
log("set_blocking(%s)", conn)
try:
log("calling %s.setblocking(1)", conn._socket)
conn._socket.setblocking(1)
except:
log("cannot set %s to blocking mode", conn)
# later version. See the file COPYING for details.
import sys
import os
import errno
import socket
from xpra.net.common import ConnectionClosedException
from xpra.util import envint, envbool, csv
from xpra.os_util import POSIX, LINUX
from xpra.platform.features import TCP_OPTIONS, IP_OPTIONS, SOCKET_OPTIONS
from xpra.log import Logger
log = Logger("network", "protocol")
SOCKET_CORK = envbool("XPRA_SOCKET_CORK", LINUX)
if SOCKET_CORK:
try:
assert socket.TCP_CORK > 0 #@UndefinedVariable
except (AttributeError, AssertionError) as cork_e:
log.warn("Warning: unable to use TCP_CORK on %s", sys.platform)
log.warn(" %s", cork_e)
SOCKET_CORK = False
SOCKET_NODELAY = envbool("XPRA_SOCKET_NODELAY", None)
VSOCK_TIMEOUT = envint("XPRA_VSOCK_TIMEOUT", 5)
SOCKET_TIMEOUT = envint("XPRA_SOCKET_TIMEOUT", 20)
#this is more proper but would break the proxy server:
SOCKET_SHUTDOWN = envbool("XPRA_SOCKET_SHUTDOWN", False)
LOG_TIMEOUTS = envint("XPRA_LOG_TIMEOUTS", 1)
ABORT = {
# Copyright (C) 2011-2016 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 win32api #@UnresolvedImport
import win32con #@UnresolvedImport
import win32gui #@UnresolvedImport
from xpra.platform.keyboard_base import KeyboardBase
from xpra.keyboard.layouts import WIN32_LAYOUTS
from xpra.gtk_common.keymap import KEY_TRANSLATIONS
from xpra.util import csv, envint, envbool
from xpra.log import Logger
log = Logger("keyboard")
EMULATE_ALTGR = envbool("XPRA_EMULATE_ALTGR", True)
EMULATE_ALTGR_CONTROL_KEY_DELAY = envint("XPRA_EMULATE_ALTGR_CONTROL_KEY_DELAY", 50)
if EMULATE_ALTGR:
#needed for altgr emulation timeouts:
from xpra.gtk_common.gobject_compat import import_glib
glib = import_glib()
class Keyboard(KeyboardBase):
""" This is for getting keys from the keyboard on the client side.
Deals with GTK bugs and oddities:
* missing 'Num_Lock'
* simulate 'Alt_Gr'
"""
def __init__(self):
log = Logger("paint")
deltalog = Logger("delta")
from threading import Lock
from xpra.net.mmap_pipe import mmap_read
from xpra.net import compression
from xpra.util import typedict, csv, envint, envbool, repr_ellipsized
from xpra.codecs.loader import get_codec
from xpra.codecs.video_helper import getVideoHelper
from xpra.os_util import BytesIOClass, bytestostr, _buffer
from xpra.codecs.xor.cyxor import xor_str #@UnresolvedImport
from xpra.codecs.argb.argb import unpremultiply_argb, unpremultiply_argb_in_place #@UnresolvedImport
DELTA_BUCKETS = envint("XPRA_DELTA_BUCKETS", 5)
INTEGRITY_HASH = envbool("XPRA_INTEGRITY_HASH", False)
PAINT_BOX = envint("XPRA_PAINT_BOX", 0) or envint("XPRA_OPENGL_PAINT_BOX", 0)
WEBP_PILLOW = envbool("XPRA_WEBP_PILLOW", False)
#ie:
#CSC_OPTIONS = { "YUV420P" : {"RGBX" : [swscale.spec], "BGRX" : ...} }
CSC_OPTIONS = None
def load_csc_options():
global CSC_OPTIONS
if CSC_OPTIONS is None:
CSC_OPTIONS = {}
vh = getVideoHelper()
for csc_in in vh.get_csc_inputs():
CSC_OPTIONS[csc_in] = vh.get_csc_specs(csc_in)
# This class is used by the posix server to ensure
# we reap the dead pids so that they don't become zombies,
# also used for implementing --exit-with-children
import os, sys
import signal
from xpra.util import envint, envbool
from xpra.log import Logger
log = Logger("server", "util")
# use process polling with python versions older than 2.7 and 3.0, (because SIGCHLD support is broken)
# or when the user requests it with the env var:
USE_PROCESS_POLLING = os.name != "posix" or envbool("XPRA_USE_PROCESS_POLLING")
POLL_DELAY = envint("XPRA_POLL_DELAY", 2)
singleton = None
def getChildReaper():
global singleton
if singleton is None:
singleton = ChildReaper()
return singleton
def reaper_cleanup():
global singleton
from xpra.util import csv, envint, envbool, repr_ellipsized
from xpra.platform.features import CLIPBOARD_GREEDY
MIN_CLIPBOARD_COMPRESSION_SIZE = 512
MAX_CLIPBOARD_PACKET_SIZE = 4 * 1024 * 1024
from xpra.platform.features import CLIPBOARDS as PLATFORM_CLIPBOARDS
ALL_CLIPBOARDS = PLATFORM_CLIPBOARDS
CLIPBOARDS = PLATFORM_CLIPBOARDS
CLIPBOARDS_ENV = os.environ.get("XPRA_CLIPBOARDS")
if CLIPBOARDS_ENV is not None:
CLIPBOARDS = CLIPBOARDS_ENV.split(",")
CLIPBOARDS = [x.upper().strip() for x in CLIPBOARDS]
TEST_DROP_CLIPBOARD_REQUESTS = envint("XPRA_TEST_DROP_CLIPBOARD")
STORE_ON_EXIT = envbool("XPRA_CLIPBOARD_STORE_ON_EXIT", True)
DELAY_SEND_TOKEN = envint("XPRA_DELAY_SEND_TOKEN", 100)
_discard_target_strs_ = os.environ.get("XPRA_DISCARD_TARGETS")
if _discard_target_strs_ is not None:
DISCARD_TARGETS = _discard_target_strs_.split(",")
else:
#default:
DISCARD_TARGETS = [
"^SAVE_TARGETS$", "^COMPOUND_TEXT", "^NeXT", "^com\.apple\.",
"^CorePasteboardFlavorType", "^dyn\."
]
log("DISCARD_TARGETS=%s", csv(DISCARD_TARGETS))
DISCARD_TARGETS = [re.compile(x) for x in DISCARD_TARGETS]
TEXT_TARGETS = ("UTF8_STRING", "TEXT", "STRING", "text/plain")
#!/usr/bin/env python
# This file is part of Xpra.
# Copyright (C) 2011-2015 Antoine Martin <*****@*****.**>
# Copyright (C) 2008, 2009, 2010 Nathaniel Smith <*****@*****.**>
# 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 time
import unittest
import binascii
from xpra.os_util import strtobytes
from xpra.util import envbool
from xpra.net.crypto import DEFAULT_SALT, DEFAULT_ITERATIONS, DEFAULT_BLOCKSIZE, DEFAULT_IV
SHOW_PERF = envbool("XPRA_SHOW_PERF")
def log(message):
#print(message[:256])
pass
def hexstr(v):
return binascii.hexlify(strtobytes(v))
class TestCrypto(unittest.TestCase):
def setUp(self):
self.backends = []
try:
# Copyright (C) 2010-2021 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
import os.path
from xpra.util import envbool, csv
from xpra.log import Logger
log = Logger("codec", "loader")
#these codecs may well not load because we
#do not require the libraries to be installed
NOWARN = ["nvenc", "enc_x265", "enc_ffmpeg"]
SELFTEST = envbool("XPRA_CODEC_SELFTEST", True)
FULL_SELFTEST = envbool("XPRA_CODEC_FULL_SELFTEST", False)
CODEC_FAIL_IMPORT = os.environ.get("XPRA_CODEC_FAIL_IMPORT", "").split(",")
CODEC_FAIL_SELFTEST = os.environ.get("XPRA_CODEC_FAIL_SELFTEST", "").split(",")
log(
"codec loader settings: SELFTEST=%s, FULL_SELFTEST=%s, CODEC_FAIL_IMPORT=%s, CODEC_FAIL_SELFTEST=%s",
SELFTEST, FULL_SELFTEST, CODEC_FAIL_IMPORT, CODEC_FAIL_SELFTEST)
codec_errors = {}
codecs = {}
def codec_import_check(name, description, top_module, class_module,
classnames):
log = Logger("codec", "loader")
try:
#this makes py2exe do the right thing:
from xpra.codecs import codec_checks
assert codec_checks
except:
pass
if sys.version > '3':
unicode = str #@ReservedAssignment
#these codecs may well not load because we
#do not require the libraries to be installed
NOWARN = ["nvenc7", ]
SELFTEST = envbool("XPRA_CODEC_SELFTEST", True)
FULL_SELFTEST = envbool("XPRA_CODEC_FULL_SELFTEST", False)
CODEC_FAIL_IMPORT = os.environ.get("XPRA_CODEC_FAIL_IMPORT", "").split(",")
CODEC_FAIL_SELFTEST = os.environ.get("XPRA_CODEC_FAIL_SELFTEST", "").split(",")
log("codec loader settings: SELFTEST=%s, FULL_SELFTEST=%s, CODEC_FAIL_IMPORT=%s, CODEC_FAIL_SELFTEST=%s",
SELFTEST, FULL_SELFTEST, CODEC_FAIL_IMPORT, CODEC_FAIL_SELFTEST)
codec_errors = {}
codecs = {}
def codec_import_check(name, description, top_module, class_module, *classnames):
log("%s:", name)
log(" codec_import_check%s", (name, description, top_module, class_module, classnames))
try:
try:
log = Logger("server")
netlog = Logger("network")
httplog = Logger("http")
timeoutlog = Logger("timeout")
screenlog = Logger("screen")
from xpra.server.server_core import ServerCore, get_thread_info
from xpra.server.mixins.server_base_controlcommands import ServerBaseControlCommands
from xpra.os_util import thread, monotonic_time, bytestostr, WIN32, PYTHON3
from xpra.util import typedict, flatten_dict, updict, merge_dicts, envbool, \
SERVER_EXIT, SERVER_ERROR, SERVER_SHUTDOWN, DETACH_REQUEST, NEW_CLIENT, DONE, SESSION_BUSY
from xpra.net.bytestreams import set_socket_timeout
from xpra.server import EXITING_CODE
CLIENT_CAN_SHUTDOWN = envbool("XPRA_CLIENT_CAN_SHUTDOWN", True)
SERVER_BASES = [ServerCore, ServerBaseControlCommands]
from xpra.server import server_features
if server_features.notifications:
from xpra.server.mixins.notification_forwarder import NotificationForwarder
SERVER_BASES.append(NotificationForwarder)
if server_features.webcam:
from xpra.server.mixins.webcam_server import WebcamServer
SERVER_BASES.append(WebcamServer)
if server_features.clipboard:
from xpra.server.mixins.clipboard_server import ClipboardServer
SERVER_BASES.append(ClipboardServer)
if server_features.audio:
from xpra.server.mixins.audio_server import AudioServer
SERVER_BASES.append(AudioServer)
import struct
import binascii
from xpra.log import Logger
log = Logger("posix")
eventlog = Logger("posix", "events")
screenlog = Logger("posix", "screen")
dbuslog = Logger("posix", "dbus")
traylog = Logger("posix", "menu")
menulog = Logger("posix", "menu")
from xpra.util import iround, envbool
from xpra.gtk_common.gobject_compat import get_xid, is_gtk3
device_bell = None
GTK_MENUS = envbool("XPRA_GTK_MENUS", False)
def get_native_system_tray_classes():
try:
from xpra.platform.xposix.appindicator_tray import AppindicatorTray, can_use_appindicator
if can_use_appindicator():
return [AppindicatorTray]
except Exception as e:
traylog("cannot load appindicator tray: %s", e)
return []
def get_wm_name():
wm_name = os.environ.get("XDG_CURRENT_DESKTOP", "")
try:
wm_check = _get_X11_root_property("_NET_SUPPORTING_WM_CHECK", "WINDOW")
from xpra.util import net_utf8, typedict, envbool, envint, WORKSPACE_UNSET, WORKSPACE_NAMES
from xpra.log import Logger
log = Logger("window")
plog = Logger("paint")
focuslog = Logger("focus")
mouselog = Logger("mouse")
workspacelog = Logger("workspace")
keylog = Logger("keyboard")
metalog = Logger("metadata")
geomlog = Logger("geometry")
iconlog = Logger("icon")
alphalog = Logger("alpha")
SIMULATE_MOUSE_DOWN = envbool("XPRA_SIMULATE_MOUSE_DOWN", True)
PROPERTIES_DEBUG = [x.strip() for x in os.environ.get("XPRA_WINDOW_PROPERTIES_DEBUG", "").split(",")]
SET_SIZE_CONSTRAINTS = envbool("XPRA_SET_SIZE_CONSTRAINTS", True)
DEFAULT_GRAVITY = envint("XPRA_DEFAULT_GRAVITY", 0)
OVERRIDE_GRAVITY = envint("XPRA_OVERRIDE_GRAVITY", 0)
FORCE_FLUSH = envbool("XPRA_FORCE_FLUSH", False)
class ClientWindowBase(ClientWidgetBase):
def __init__(self, client, group_leader, watcher_pid, wid,
wx, wy, ww, wh, bw, bh,
metadata, override_redirect, client_properties,
border, max_window_size, default_cursor_data, pixel_depth,
headerbar="no"):
log("%s%s", type(self),
# This file is part of Xpra.
# Copyright (C) 2010 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2010-2016 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 os.path
import sys
import site
from xpra.util import envbool
from xpra.os_util import is_Fedora, is_CentOS, is_RedHat
SOUND_PYTHON3 = envbool("XPRA_SOUND_PYTHON3", is_Fedora() or is_CentOS() or is_RedHat())
def do_get_install_prefix():
#special case for "user" installations, ie:
#$HOME/.local/lib/python2.7/site-packages/xpra/platform/paths.py
try:
base = site.getuserbase()
except:
base = site.USER_BASE
if __file__.startswith(base):
return base
if sys.argv:
p = sys.argv[0].find("/bin/xpra")
if p>0:
return sys.argv[0][:p]
return sys.prefix
def do_get_resources_dir():
from xpra.scripts.config import parse_number, parse_bool
from xpra.version_util import full_version_str
from xpra.server.socket_util import create_unix_domain_socket
from xpra.platform.dotxpra import DotXpra
from xpra.net.bytestreams import SocketConnection, SOCKET_TIMEOUT
from multiprocessing import Process
try:
from xpra.codecs.xor.cyxor import xor_str #@UnresolvedImport
xor = xor_str
except:
pass
PROXY_QUEUE_SIZE = envint("XPRA_PROXY_QUEUE_SIZE", 10)
#for testing only: passthrough as RGB:
PASSTHROUGH = envbool("XPRA_PROXY_PASSTHROUGH", False)
MAX_CONCURRENT_CONNECTIONS = 20
VIDEO_TIMEOUT = 5 #destroy video encoder after N seconds of idle state
LEGACY_SALT_DIGEST = envbool("XPRA_LEGACY_SALT_DIGEST", True)
def set_blocking(conn):
#Note: importing set_socket_timeout from xpra.net.bytestreams
#fails in mysterious ways, so we duplicate the code here instead
log("set_blocking(%s)", conn)
try:
log("calling %s.setblocking(1)", conn._socket)
conn._socket.setblocking(1)
except:
log("cannot set %s to blocking mode", conn)
# This file is part of Xpra.
# Copyright (C) 2011-2016 Antoine Martin <*****@*****.**>
# Copyright (C) 2008, 2009, 2010 Nathaniel Smith <*****@*****.**>
# 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 os
from xpra.util import envint, envbool
from xpra.log import Logger
log = Logger("network", "crypto")
ENABLE_CRYPTO = envbool("XPRA_ENABLE_CRYPTO", True)
ENCRYPT_FIRST_PACKET = envbool("XPRA_ENCRYPT_FIRST_PACKET", False)
DEFAULT_IV = os.environ.get("XPRA_CRYPTO_DEFAULT_IV", "0000000000000000")
DEFAULT_SALT = os.environ.get("XPRA_CRYPTO_DEFAULT_SALT", "0000000000000000")
DEFAULT_ITERATIONS = envint("XPRA_CRYPTO_DEFAULT_ITERATIONS", 1000)
DEFAULT_BLOCKSIZE = envint("XPRA_CRYPTO_BLOCKSIZE", 32) #fixme: can we derive this?
#other option "PKCS#7", "legacy"
PADDING_LEGACY = "legacy"
PADDING_PKCS7 = "PKCS#7"
ALL_PADDING_OPTIONS = (PADDING_LEGACY, PADDING_PKCS7)
INITIAL_PADDING = os.environ.get("XPRA_CRYPTO_INITIAL_PADDING", PADDING_LEGACY)
DEFAULT_PADDING = PADDING_LEGACY
PREFERRED_PADDING = os.environ.get("XPRA_CRYPTO_PREFERRED_PADDING", PADDING_PKCS7)
assert PREFERRED_PADDING in ALL_PADDING_OPTIONS, "invalid preferred padding: %s" % PREFERRED_PADDING
assert INITIAL_PADDING in ALL_PADDING_OPTIONS, "invalid padding: %s" % INITIAL_PADDING
#make sure the preferred one is first in the list:
PADDING_OPTIONS = [PREFERRED_PADDING]
for x in ALL_PADDING_OPTIONS:
# 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.log import Logger
log = Logger("shadow", "osx")
from xpra.util import envbool
from xpra.server.gtk_server_base import GTKServerBase
from xpra.server.shadow.root_window_model import RootWindowModel
from xpra.server.shadow.gtk_shadow_server_base import GTKShadowServerBase
from xpra.platform.darwin.keyboard_config import KeyboardConfig
from xpra.platform.darwin.gui import get_CG_imagewrapper, take_screenshot
import Quartz.CoreGraphics as CG #@UnresolvedImport
USE_TIMER = envbool("XPRA_OSX_SHADOW_USE_TIMER", False)
ALPHA = {
CG.kCGImageAlphaNone: "AlphaNone",
CG.kCGImageAlphaPremultipliedLast: "PremultipliedLast",
CG.kCGImageAlphaPremultipliedFirst: "PremultipliedFirst",
CG.kCGImageAlphaLast: "Last",
CG.kCGImageAlphaFirst: "First",
CG.kCGImageAlphaNoneSkipLast: "SkipLast",
CG.kCGImageAlphaNoneSkipFirst: "SkipFirst",
}
#ensure that picture_encode can deal with pixels as NSCFData:
def patch_picture_encode():
from CoreFoundation import CFDataGetBytes, CFDataGetLength #@UnresolvedImport
