def do_get_info(self, proto, *args): info = ServerBase.do_get_info(self, proto, *args) updict(info, "server", get_gtk_version_info()) info.update({ "server.type" : "Python/gtk-x11", "features.randr" : self.randr}) return info
def make_hello(self): capabilities = UIXpraClient.make_hello(self) capabilities["named_cursors"] = len(cursor_types)>0 #we need the bindings to support initiate-moveresize (posix only for now): from xpra.client.gtk_base.gtk_client_window_base import HAS_X11_BINDINGS capabilities["window.initiate-moveresize"] = HAS_X11_BINDINGS capabilities.update(get_gtk_version_info()) return capabilities
def do_get_info(self, proto, *args): info = ServerBase.do_get_info(self, proto, *args) ss = self._server_sources.get(proto) info.update(get_gtk_version_info(prefix="server", new_namespace=(ss is not None) and ss.namespace)) info.update({ "server.type" : "Python/gtk-x11", "features.randr" : self.randr}) return info
def do_get_info(self, proto, *args): start = monotonic() info = super().do_get_info(proto, *args) vi = get_gtk_version_info() vi["type"] = "Python/gtk" info.setdefault("server", {}).update(vi) log("GTKServerBase.do_get_info took %ims", (monotonic()-start)*1000) return info
def make_hello(self): capabilities = UIXpraClient.make_hello(self) capabilities["named_cursors"] = len(cursor_types) > 0 #we need the bindings to support initiate-moveresize (posix only for now): from xpra.client.gtk_base.gtk_client_window_base import HAS_X11_BINDINGS capabilities["window.initiate-moveresize"] = HAS_X11_BINDINGS capabilities.update(get_gtk_version_info()) return capabilities
def do_get_info(self, proto, *args): start = time.time() info = ServerBase.do_get_info(self, proto, *args) vi = get_gtk_version_info() vi["type"] = "Python/gtk-x11" info.setdefault("server", {}).update(vi) info.setdefault("features", {})["randr"] = self.randr log("GTKServerBase.do_get_info took %ims", (time.time()-start)*1000) return info
def do_get_info(self, proto, *args): start = monotonic_time() info = ServerBase.do_get_info(self, proto, *args) vi = get_gtk_version_info() vi["type"] = "Python/gtk" info.setdefault("server", {}).update(vi) info.setdefault("features", {})["randr"] = self.randr log("GTKServerBase.do_get_info took %ims", (monotonic_time()-start)*1000) return info
def make_hello(self): capabilities = ServerBase.make_hello(self) display = gtk.gdk.display_get_default() capabilities.update({ "display" : display.get_name(), "cursor.default_size" : display.get_default_cursor_size(), "cursor.max_size" : display.get_maximal_cursor_size()}) capabilities.update(get_gtk_version_info()) return capabilities
def make_hello(self, source): capabilities = ServerBase.make_hello(self, source) if source.wants_display: display = gtk.gdk.display_get_default() capabilities.update({ "display" : display.get_name(), "cursor.default_size" : display.get_default_cursor_size(), "cursor.max_size" : display.get_maximal_cursor_size()}) if source.wants_versions: capabilities.update(flatten_dict(get_gtk_version_info())) return capabilities
def make_hello(self, source): capabilities = ServerBase.make_hello(self, source) if source.wants_display: display = gtk.gdk.display_get_default() capabilities.update({ "display" : display.get_name(), "cursor.default_size" : display.get_default_cursor_size(), "cursor.max_size" : display.get_maximal_cursor_size()}) if source.wants_versions: capabilities.update(get_gtk_version_info()) return capabilities
def make_hello(self): capabilities = UIXpraClient.make_hello(self) capabilities["named_cursors"] = len(cursor_types) > 0 capabilities.update(get_gtk_version_info()) #tell the server which icons GTK can use #so it knows when it should supply one as fallback it = icon_theme_get_default() #this would add our bundled icon directory #to the search path, but I don't think we have #any extra icons that matter in there: #from xpra.platform.paths import get_icon_dir #d = get_icon_dir() #if d not in it.get_search_path(): # it.append_search_path(d) # it.rescan_if_needed() log("default icon theme: %s", it) log("icon search path: %s", it.get_search_path()) log("contexts: %s", it.list_contexts()) icons = [] for context in it.list_contexts(): icons += it.list_icons(context) log("icons: %s", icons) capabilities["theme.default.icons"] = list(set(icons)) if METADATA_SUPPORTED: ms = [x.strip() for x in METADATA_SUPPORTED.split(",")] else: #this is currently unused, and slightly redundant because of metadata.supported below: capabilities["window.states"] = [ "fullscreen", "maximized", "sticky", "above", "below", "shaded", "iconified", "skip-taskbar", "skip-pager" ] ms = list(DEFAULT_METADATA_SUPPORTED) #added in 0.15: ms += ["command", "workspace", "above", "below", "sticky"] if os.name == "posix": #this is only really supported on X11, but posix is easier to check for.. #"strut" and maybe even "fullscreen-monitors" could also be supported on other platforms I guess ms += [ "shaded", "bypass-compositor", "strut", "fullscreen-monitors" ] log("metadata.supported: %s", ms) capabilities["metadata.supported"] = ms #we need the bindings to support initiate-moveresize (posix only for now): from xpra.client.gtk_base.gtk_client_window_base import HAS_X11_BINDINGS capabilities["window.initiate-moveresize"] = HAS_X11_BINDINGS #window icon bits capabilities[ "encoding.icons.greedy"] = True #we don't set a default window icon any more capabilities["encoding.icons.size"] = 64, 64 #size we want capabilities["encoding.icons.max_size"] = 128, 128 #limit from xpra.client.window_backing_base import DELTA_BUCKETS capabilities["encoding.delta_buckets"] = DELTA_BUCKETS return capabilities
def do_get_info(self, proto, *args): info = ServerBase.do_get_info(self, proto, *args) ss = self._server_sources.get(proto) updict( info, "server", get_gtk_version_info( new_namespace=(ss is not None) and ss.namespace)) info.update({ "server.type": "Python/gtk-x11", "features.randr": self.randr }) return info
def get_sys_info(): d = {} for k, v in { "version": get_version_info(), "platform": get_platform_info(), "host": get_host_info(), "paths": get_path_info(), "gtk": get_gtk_version_info(), "user": get_user_info(), "env": os.environ, }.items(): updict(d, k, v) return d
def make_hello(self, source): capabilities = super().make_hello(source) if source.wants_display: display = Gdk.Display.get_default() max_size = tuple(display.get_maximal_cursor_size()) capabilities.update({ "display" : display.get_name(), "cursor.default_size" : display.get_default_cursor_size(), "cursor.max_size" : max_size, }) if source.wants_versions: capabilities.update(flatten_dict(get_gtk_version_info())) return capabilities
def make_hello(self): capabilities = UIXpraClient.make_hello(self) capabilities["named_cursors"] = len(cursor_types)>0 capabilities.update(get_gtk_version_info()) #tell the server which icons GTK can use #so it knows when it should supply one as fallback it = icon_theme_get_default() #this would add our bundled icon directory #to the search path, but I don't think we have #any extra icons that matter in there: #from xpra.platform.paths import get_icon_dir #d = get_icon_dir() #if d not in it.get_search_path(): # it.append_search_path(d) # it.rescan_if_needed() log("default icon theme: %s", it) log("icon search path: %s", it.get_search_path()) log("contexts: %s", it.list_contexts()) icons = [] for context in it.list_contexts(): icons += it.list_icons(context) log("icons: %s", icons) capabilities["theme.default.icons"] = list(set(icons)) if METADATA_SUPPORTED: ms = [x.strip() for x in METADATA_SUPPORTED.split(",")] else: #this is currently unused, and slightly redundant because of metadata.supported below: capabilities["window.states"] = ["fullscreen", "maximized", "sticky", "above", "below", "shaded", "iconified", "skip-taskbar", "skip-pager"] ms = list(DEFAULT_METADATA_SUPPORTED) #added in 0.15: ms += ["command", "workspace", "above", "below", "sticky"] if os.name=="posix": #this is only really supported on X11, but posix is easier to check for.. #"strut" and maybe even "fullscreen-monitors" could also be supported on other platforms I guess ms += ["shaded", "bypass-compositor", "strut", "fullscreen-monitors"] log("metadata.supported: %s", ms) capabilities["metadata.supported"] = ms #we need the bindings to support initiate-moveresize (posix only for now): from xpra.client.gtk_base.gtk_client_window_base import HAS_X11_BINDINGS capabilities["window.initiate-moveresize"] = HAS_X11_BINDINGS #window icon bits capabilities["encoding.icons.greedy"] = True #we don't set a default window icon any more capabilities["encoding.icons.size"] = 64, 64 #size we want capabilities["encoding.icons.max_size"] = 128, 128 #limit from xpra.client.window_backing_base import DELTA_BUCKETS capabilities["encoding.delta_buckets"] = DELTA_BUCKETS return capabilities
def main(): from xpra.util import nonl, pver, flatten_dict, print_nested_dict def print_version_dict(d, vformat=pver): for k in sorted(d.keys()): v = d[k] print("* %-48s : %s" % (str(k).replace(".version", "").ljust(12), nonl(vformat(v)))) from xpra.platform import program_context with program_context("GTK-Version-Info", "GTK Version Info"): from xpra.platform.gui import init as gui_init, ready gui_init() ready() from xpra.gtk_common import gtk_util if "-v" in sys.argv or "--verbose" in sys.argv: gtk_util.SHOW_ALL_VISUALS = True print("GTK Version:") print_version_dict(flatten_dict(gtk_util.get_gtk_version_info())) print("Display:") print_nested_dict(gtk_util.get_display_info(), vformat=str)
def get_sys_info(): from xpra.platform.info import get_user_info from xpra.scripts.config import read_xpra_defaults return { "argv" : sys.argv, "path" : sys.path, "exec_prefix" : sys.exec_prefix, "executable" : sys.executable, "version" : get_version_info(), "platform" : get_platform_info(), "host" : get_host_info(), "paths" : get_path_info(), "gtk" : get_gtk_version_info(), "gui" : get_gui_info(), "display" : get_display_info(), "user" : get_user_info(), "env" : os.environ, "config" : read_xpra_defaults(), }
def get_sys_info(): from xpra.platform.info import get_user_info from xpra.scripts.config import read_xpra_defaults return { "argv": sys.argv, "path": sys.path, "exec_prefix": sys.exec_prefix, "executable": sys.executable, "version": get_version_info(), "platform": get_platform_info(), "host": get_host_info(), "paths": get_path_info(), "gtk": get_gtk_version_info(), "gui": get_gui_info(), "display": get_display_info(), "user": get_user_info(), "env": os.environ, "config": read_xpra_defaults(), }
def get_sys_info(): d = { "argv" : sys.argv, "path" : sys.path, "exec_prefix" : sys.exec_prefix, "executable" : sys.executable, } for k,v in { "version" : get_version_info(), "platform" : get_platform_info(), "host" : get_host_info(), "paths" : get_path_info(), "gtk" : get_gtk_version_info(), "gui" : get_gui_info(), "display" : get_display_info(), "user" : get_user_info(), "env" : os.environ, "config" : read_xpra_defaults(), }.items(): updict(d, k, v) return d
def main(): from xpra.util import nonl, pver def print_dict(d, vformat=pver): for k in sorted(d.keys()): v = d[k] print("* %-48s : %s" % (str(k).replace(".version", "").ljust(12), nonl(vformat(v)))) from xpra.platform import init, clean try: init("GTK-Version-Info", "GTK Version Info") from xpra.platform.gui import init as gui_init, ready gui_init() ready() from xpra.gtk_common.gtk_util import get_gtk_version_info, get_display_info print("GTK Version:") print_dict(get_gtk_version_info()) print("Display:") print_dict(get_display_info(), vformat=str) finally: clean()
def __init__(self, client, session_name, window_icon_pixbuf, conn, get_pixbuf): gtk.Window.__init__(self) self.client = client self.session_name = session_name self.connection = conn self.last_populate_time = 0 self.last_populate_statistics = 0 self.is_closed = False self.get_pixbuf = get_pixbuf if not self.session_name or self.session_name=="Xpra": title = "Session Info" else: title = "%s: Session Info" % self.session_name self.set_title(title) self.set_destroy_with_parent(True) self.set_resizable(True) self.set_decorated(True) if window_icon_pixbuf: self.set_icon(window_icon_pixbuf) self.set_position(WIN_POS_CENTER) #tables on the left in a vbox with buttons at the top: self.tab_box = gtk.VBox(False, 0) self.tab_button_box = gtk.HBox(True, 0) self.tabs = [] #pairs of button, table self.populate_cb = None self.tab_box.pack_start(self.tab_button_box, expand=False, fill=True, padding=0) #Package Table: tb, _ = self.table_tab("package.png", "Software", self.populate_package) #title row: tb.attach(title_box(""), 0, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("Client"), 1, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("Server"), 2, xoptions=EXPAND|FILL, xpadding=0) tb.inc() def make_os_str(*args): s = os_info(*args) return "\n".join(s) distro = "" if hasattr(python_platform, "linux_distribution"): distro = python_platform.linux_distribution() LOCAL_PLATFORM_NAME = make_os_str(sys.platform, python_platform.release(), python_platform.platform(), distro) SERVER_PLATFORM_NAME = make_os_str(self.client._remote_platform, self.client._remote_platform_release, self.client._remote_platform_platform, self.client._remote_platform_linux_distribution) tb.new_row("Operating System", label(LOCAL_PLATFORM_NAME), label(SERVER_PLATFORM_NAME)) scaps = self.client.server_capabilities from xpra.__init__ import __version__ tb.new_row("Xpra", label(__version__), label(self.client._remote_version or "unknown")) cl_rev, cl_ch, cl_date = "unknown", "", "" try: from xpra.build_info import BUILD_DATE as cl_date, BUILD_TIME as cl_time from xpra.src_info import REVISION as cl_rev, LOCAL_MODIFICATIONS as cl_ch #@UnresolvedImport except: pass def make_version_str(version): if version and type(version) in (tuple, list): version = ".".join([str(x) for x in version]) return version or "unknown" def server_info(*prop_names): for x in prop_names: v = scaps.capsget(x) if v is not None: return v if self.client.server_last_info: v = self.client.server_last_info.get(x) if v is not None: return v return None def server_version_info(*prop_names): return make_version_str(server_info(*prop_names)) def make_revision_str(rev, changes): if not changes: return rev return "%s (%s changes)" % (rev, changes) def make_datetime(date, time): if not time: return date return "%s %s" % (date, time) tb.new_row("Revision", label(make_revision_str(cl_rev, cl_ch)), label(make_revision_str(self.client._remote_revision, server_version_info("build.local_modifications", "local_modifications")))) tb.new_row("Build date", label(make_datetime(cl_date, cl_time)), label(make_datetime(server_info("build_date", "build.date"), server_info("build.time")))) gtk_version_info = get_gtk_version_info() def client_vinfo(prop, fallback="unknown"): k = "%s.version" % prop return label(make_version_str(gtk_version_info.get(k, fallback))) def server_vinfo(prop): k = "%s.version" % prop fk = "%s_version" % prop return label(server_version_info(k, fk)) tb.new_row("Glib", client_vinfo("glib"), server_vinfo("glib")) tb.new_row("PyGlib", client_vinfo("pyglib"), server_vinfo("pyglib")) tb.new_row("Gobject", client_vinfo("gobject"), server_vinfo("gobject")) tb.new_row("PyGTK", client_vinfo("pygtk", ""), server_vinfo("pygtk")) tb.new_row("GTK", client_vinfo("gtk"), server_vinfo("gtk")) tb.new_row("GDK", client_vinfo("gdk"), server_vinfo("gdk")) tb.new_row("Cairo", client_vinfo("cairo"), server_vinfo("cairo")) tb.new_row("Pango", client_vinfo("pango"), server_vinfo("pango")) tb.new_row("Python", label(python_platform.python_version()), label(server_version_info("server.python.version", "python_version", "python.version"))) cl_gst_v, cl_pygst_v = "", "" try: from xpra.sound.gstreamer_util import gst_version as cl_gst_v, pygst_version as cl_pygst_v except Exception as e: log("cannot load gstreamer: %s", e) tb.new_row("GStreamer", label(make_version_str(cl_gst_v)), label(server_version_info("sound.gst.version", "gst_version"))) tb.new_row("pygst", label(make_version_str(cl_pygst_v)), label(server_version_info("sound.pygst.version", "pygst_version"))) tb.new_row("OpenGL", label(make_version_str(self.client.opengl_props.get("opengl", "n/a"))), label("n/a")) tb.new_row("OpenGL Vendor", label(make_version_str(self.client.opengl_props.get("vendor", ""))), label("n/a")) tb.new_row("PyOpenGL", label(make_version_str(self.client.opengl_props.get("pyopengl", "n/a"))), label("n/a")) # Features Table: vbox = self.vbox_tab("features.png", "Features", self.populate_features) #add top table: tb = TableBuilder(rows=1, columns=2) table = tb.get_table() al = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.0, yscale=1.0) al.add(table) vbox.pack_start(al, expand=True, fill=False, padding=10) #top table contents: randr_box = gtk.HBox(False, 20) self.server_randr_label = label() self.server_randr_icon = gtk.Image() randr_box.add(self.server_randr_icon) randr_box.add(self.server_randr_label) tb.new_row("RandR Support", randr_box) opengl_box = gtk.HBox(False, 20) self.client_opengl_label = label() self.client_opengl_label.set_line_wrap(True) self.client_opengl_icon = gtk.Image() opengl_box.add(self.client_opengl_icon) opengl_box.add(self.client_opengl_label) tb.new_row("Client OpenGL", opengl_box) self.opengl_buffering = label() tb.new_row("OpenGL Buffering", self.opengl_buffering) self.server_mmap_icon = gtk.Image() tb.new_row("Memory Mapped Transfers", self.server_mmap_icon) self.server_clipboard_icon = gtk.Image() tb.new_row("Clipboard", self.server_clipboard_icon) self.server_notifications_icon = gtk.Image() tb.new_row("Notification Forwarding", self.server_notifications_icon) self.server_bell_icon = gtk.Image() tb.new_row("Bell Forwarding", self.server_bell_icon) self.server_cursors_icon = gtk.Image() tb.new_row("Cursor Forwarding", self.server_cursors_icon) speaker_box = gtk.HBox(False, 20) self.server_speaker_icon = gtk.Image() speaker_box.add(self.server_speaker_icon) self.speaker_codec_label = label() speaker_box.add(self.speaker_codec_label) tb.new_row("Speaker Forwarding", speaker_box) microphone_box = gtk.HBox(False, 20) self.server_microphone_icon = gtk.Image() microphone_box.add(self.server_microphone_icon) self.microphone_codec_label = label() microphone_box.add(self.microphone_codec_label) tb.new_row("Microphone Forwarding", microphone_box) #add bottom table: tb = TableBuilder(rows=1, columns=3) table = tb.get_table() vbox.pack_start(table, expand=True, fill=True, padding=20) #bottom table headings: tb.attach(title_box(""), 0, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("Client"), 1, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("Server"), 2, xoptions=EXPAND|FILL, xpadding=0) tb.inc() #bottom table contents: self.client_encodings_label = label() self.client_encodings_label.set_line_wrap(True) self.client_encodings_label.set_size_request(250, -1) self.server_encodings_label = label() self.server_encodings_label.set_line_wrap(True) self.server_encodings_label.set_size_request(250, -1) tb.new_row("Encodings", self.client_encodings_label, self.server_encodings_label) self.client_speaker_codecs_label = label() self.server_speaker_codecs_label = label() tb.new_row("Speaker Codecs", self.client_speaker_codecs_label, self.server_speaker_codecs_label) self.client_microphone_codecs_label = label() self.server_microphone_codecs_label = label() tb.new_row("Microphone Codecs", self.client_microphone_codecs_label, self.server_microphone_codecs_label) self.client_packet_encoders_label = label() self.server_packet_encoders_label = label() tb.new_row("Packet Encoders", self.client_packet_encoders_label, self.server_packet_encoders_label) self.client_packet_compressors_label = label() self.server_packet_compressors_label = label() tb.new_row("Packet Compressors", self.client_packet_compressors_label, self.server_packet_compressors_label) # Connection Table: tb, _ = self.table_tab("connect.png", "Connection", self.populate_connection) tb.new_row("Server Endpoint", label(self.connection.target)) if self.client.server_display: tb.new_row("Server Display", label(prettify_plug_name(self.client.server_display))) hostname = scaps.strget("hostname") if hostname: tb.new_row("Server Hostname", label(hostname)) if self.client.server_platform: tb.new_row("Server Platform", label(self.client.server_platform)) self.server_load_label = label() tb.new_row("Server Load", self.server_load_label, label_tooltip="Average over 1, 5 and 15 minutes") self.session_started_label = label() tb.new_row("Session Started", self.session_started_label) self.session_connected_label = label() tb.new_row("Session Connected", self.session_connected_label) self.input_packets_label = label() tb.new_row("Packets Received", self.input_packets_label) self.input_bytes_label = label() tb.new_row("Bytes Received", self.input_bytes_label) self.output_packets_label = label() tb.new_row("Packets Sent", self.output_packets_label) self.output_bytes_label = label() tb.new_row("Bytes Sent", self.output_bytes_label) self.compression_label = label() tb.new_row("Encoding + Compression", self.compression_label) self.connection_type_label = label() tb.new_row("Connection Type", self.connection_type_label) self.input_encryption_label = label() tb.new_row("Input Encryption", self.input_encryption_label) self.output_encryption_label = label() tb.new_row("Output Encryption", self.output_encryption_label) self.speaker_label = label() self.speaker_details = label(font="monospace 10") tb.new_row("Speaker", self.speaker_label, self.speaker_details) self.microphone_label = label() tb.new_row("Microphone", self.microphone_label) # Details: tb, stats_box = self.table_tab("browse.png", "Statistics", self.populate_statistics) tb.widget_xalign = 1.0 tb.attach(title_box(""), 0, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("Latest"), 1, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("Minimum"), 2, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("Average"), 3, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("90 percentile"), 4, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("Maximum"), 5, xoptions=EXPAND|FILL, xpadding=0) tb.inc() def maths_labels(): return label(), label(), label(), label(), label() self.server_latency_labels = maths_labels() tb.add_row(label("Server Latency (ms)", "The time it takes for the server to respond to pings"), *self.server_latency_labels) self.client_latency_labels = maths_labels() tb.add_row(label("Client Latency (ms)", "The time it takes for the client to respond to pings, as measured by the server"), *self.client_latency_labels) if self.client.windows_enabled: if self.client.server_info_request: self.batch_labels = maths_labels() tb.add_row(label("Batch Delay (ms)", "How long the server waits for new screen updates to accumulate before processing them"), *self.batch_labels) self.damage_labels = maths_labels() tb.add_row(label("Damage Latency (ms)", "The time it takes to compress a frame and pass it to the OS network layer"), *self.damage_labels) self.quality_labels = maths_labels() tb.add_row(label("Encoding Quality (pct)"), *self.quality_labels) self.speed_labels = maths_labels() tb.add_row(label("Encoding Speed (pct)"), *self.speed_labels) self.decoding_labels = maths_labels() tb.add_row(label("Decoding Latency (ms)", "How long it takes the client to decode a screen update"), *self.decoding_labels) self.regions_per_second_labels = maths_labels() tb.add_row(label("Regions/s", "The number of screen updates per second (includes both partial and full screen updates)"), *self.regions_per_second_labels) self.regions_sizes_labels = maths_labels() tb.add_row(label("Pixels/region", "The number of pixels per screen update"), *self.regions_sizes_labels) self.pixels_per_second_labels = maths_labels() tb.add_row(label("Pixels/s", "The number of pixels processed per second"), *self.pixels_per_second_labels) #Window count stats: wtb = TableBuilder() stats_box.add(wtb.get_table()) #title row: wtb.attach(title_box(""), 0, xoptions=EXPAND|FILL, xpadding=0) wtb.attach(title_box("Regular"), 1, xoptions=EXPAND|FILL, xpadding=0) wtb.attach(title_box("Transient"), 2, xoptions=EXPAND|FILL, xpadding=0) wtb.attach(title_box("Trays"), 3, xoptions=EXPAND|FILL, xpadding=0) if self.client.client_supports_opengl: wtb.attach(title_box("OpenGL"), 4, xoptions=EXPAND|FILL, xpadding=0) wtb.inc() wtb.attach(label("Windows:"), 0, xoptions=EXPAND|FILL, xpadding=0) self.windows_managed_label = label() wtb.attach(self.windows_managed_label, 1) self.transient_managed_label = label() wtb.attach(self.transient_managed_label, 2) self.trays_managed_label = label() wtb.attach(self.trays_managed_label, 3) if self.client.client_supports_opengl: self.opengl_label = label() wtb.attach(self.opengl_label, 4) #add encoder info: etb = TableBuilder() stats_box.add(etb.get_table()) self.encoder_info_box = gtk.HBox(spacing=4) etb.new_row("Window Encoders", self.encoder_info_box) if not is_gtk3(): #needs porting to cairo... self.graph_box = gtk.VBox(False, 10) self.add_tab("statistics.png", "Graphs", self.populate_graphs, self.graph_box) bandwidth_label = "Bandwidth used" if SHOW_PIXEL_STATS: bandwidth_label += ",\nand number of pixels rendered" self.bandwidth_graph = self.add_graph_button(bandwidth_label, self.save_graphs) self.connect("realize", self.populate_graphs) self.latency_graph = self.add_graph_button(None, self.save_graphs) self.pixel_in_data = deque(maxlen=N_SAMPLES+4) self.net_in_bytecount = deque(maxlen=N_SAMPLES+4) self.net_out_bytecount = deque(maxlen=N_SAMPLES+4) self.sound_in_bytecount = deque(maxlen=N_SAMPLES+4) self.sound_out_bytecount = deque(maxlen=N_SAMPLES+4) self.set_border_width(15) self.add(self.tab_box) if not is_gtk3(): self.set_geometry_hints(self.tab_box) def window_deleted(*args): self.is_closed = True self.connect('delete_event', window_deleted) self.show_tab(self.tabs[0][2]) self.set_size_request(-1, 480) self.init_counters() self.populate() self.populate_all() gobject.timeout_add(1000, self.populate) gobject.timeout_add(100, self.populate_tab) add_close_accel(self, self.destroy)
def __init__(self, client, session_name, window_icon_pixbuf, conn, get_pixbuf): gtk.Window.__init__(self) self.client = client self.session_name = session_name self.connection = conn self.last_populate_time = 0 self.last_populate_statistics = 0 self.is_closed = False self.get_pixbuf = get_pixbuf if not self.session_name or self.session_name=="Xpra": title = "Session Info" else: title = "%s: Session Info" % self.session_name self.set_title(title) self.set_destroy_with_parent(True) self.set_resizable(True) self.set_decorated(True) if window_icon_pixbuf: self.set_icon(window_icon_pixbuf) self.set_position(WIN_POS_CENTER) #tables on the left in a vbox with buttons at the top: self.tab_box = gtk.VBox(False, 0) self.tab_button_box = gtk.HBox(True, 0) self.tabs = [] #pairs of button, table self.populate_cb = None self.tab_box.pack_start(self.tab_button_box, expand=False, fill=True, padding=0) #Package Table: tb, _ = self.table_tab("package.png", "Software", self.populate_package) #title row: tb.attach(title_box(""), 0, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("Client"), 1, xoptions=EXPAND|FILL, xpadding=0) tb.attach(title_box("Server"), 2, xoptions=EXPAND|FILL, xpadding=0) tb.inc() def make_os_str(*args): s = os_info(*args) return "\n".join(s) distro = "" if hasattr(python_platform, "linux_distribution"): distro = python_platform.linux_distribution() LOCAL_PLATFORM_NAME = make_os_str(sys.platform, python_platform.release(), python_platform.platform(), distro) SERVER_PLATFORM_NAME = make_os_str(self.client._remote_platform, self.client._remote_platform_release, self.client._remote_platform_platform, self.client._remote_platform_linux_distribution) tb.new_row("Operating System", label(LOCAL_PLATFORM_NAME), label(SERVER_PLATFORM_NAME)) scaps = self.client.server_capabilities from xpra.__init__ import __version__ tb.new_row("Xpra", label(__version__), label(self.client._remote_version or "unknown")) cl_rev, cl_ch, cl_date = "unknown", "", "" try: from xpra.build_info import BUILD_DATE as cl_date, BUILD_TIME as cl_time from xpra.src_info import REVISION as cl_rev, LOCAL_MODIFICATIONS as cl_ch #@UnresolvedImport except: pass def make_version_str(version): if version and type(version) in (tuple, list): version = ".".join([str(x) for x in version]) return version or "unknown" def server_info(*prop_names): for x in prop_names: v = scaps.capsget(x) if v is not None: return v if self.client.server_last_info: v = self.client.server_last_info.get(x) if v is not None: return v return None def server_version_info(*prop_names): return make_version_str(server_info(*prop_names)) def make_revision_str(rev, changes): if not changes: return rev return "%s (%s changes)" % (rev, changes) def make_datetime(date, time): if not time: return date return "%s %s" % (date, time) tb.new_row("Revision", label(make_revision_str(cl_rev, cl_ch)), label(make_revision_str(self.client._remote_revision, server_version_info("build.local_modifications", "local_modifications")))) tb.new_row("Build date", label(make_datetime(cl_date, cl_time)), label(make_datetime(server_info("build_date", "build.date"), server_info("build.time")))) gtk_version_info = get_gtk_version_info() def client_vinfo(prop, fallback="unknown"): k = "%s.version" % prop return label(make_version_str(gtk_version_info.get(k, fallback))) tb.new_row("Glib", client_vinfo("glib"), label(server_version_info("glib.version"))) tb.new_row("Gobject", client_vinfo("gobject"), label(server_version_info("gobject.version", "pygtk_version"))) tb.new_row("PyGTK", client_vinfo("pygtk", ""), label(server_version_info("pygtk.version", "pygtk_version"))) tb.new_row("GTK", client_vinfo("gtk"), label(server_version_info("gtk.version", "gtk_version"))) tb.new_row("GDK", client_vinfo("gdk"), label(server_version_info("gdk.version", "gdk_version"))) tb.new_row("Cairo", client_vinfo("cairo"), label(server_version_info("cairo.version", "cairo_version"))) tb.new_row("Pango", client_vinfo("pango"), label(server_version_info("pango.version", "cairo_version"))) tb.new_row("Python", label(python_platform.python_version()), label(server_version_info("server.python.version", "python_version", "python.version"))) cl_gst_v, cl_pygst_v = "", "" try: from xpra.sound.gstreamer_util import gst_version as cl_gst_v, pygst_version as cl_pygst_v except Exception, e: log("cannot load gstreamer: %s", e)
def make_hello(self): capabilities = UIXpraClient.make_hello(self) capabilities["named_cursors"] = len(cursor_names)>0 capabilities.update(get_gtk_version_info()) return capabilities
def make_hello(self): capabilities = UIXpraClient.make_hello(self) capabilities["named_cursors"] = len(cursor_types)>0 capabilities.update(flatten_dict(get_gtk_version_info())) #tell the server which icons GTK can use #so it knows when it should supply one as fallback it = icon_theme_get_default() #this would add our bundled icon directory #to the search path, but I don't think we have #any extra icons that matter in there: #from xpra.platform.paths import get_icon_dir #d = get_icon_dir() #if d not in it.get_search_path(): # it.append_search_path(d) # it.rescan_if_needed() log("default icon theme: %s", it) log("icon search path: %s", it.get_search_path()) log("contexts: %s", it.list_contexts()) icons = [] for context in it.list_contexts(): icons += it.list_icons(context) log("icons: %s", icons) capabilities["theme.default.icons"] = list(set(icons)) if METADATA_SUPPORTED: ms = [x.strip() for x in METADATA_SUPPORTED.split(",")] else: #this is currently unused, and slightly redundant because of metadata.supported below: capabilities["window.states"] = ["fullscreen", "maximized", "sticky", "above", "below", "shaded", "iconified", "skip-taskbar", "skip-pager"] ms = list(DEFAULT_METADATA_SUPPORTED) #added in 0.15: ms += ["command", "workspace", "above", "below", "sticky", "set-initial-position"] #0.17 if os.name=="posix": #this is only really supported on X11, but posix is easier to check for.. #"strut" and maybe even "fullscreen-monitors" could also be supported on other platforms I guess ms += ["shaded", "bypass-compositor", "strut", "fullscreen-monitors"] if HAS_X11_BINDINGS: ms += ["shape"] if self._set_window_menu: ms += ["menu"] #figure out if we can handle the "global menu" stuff: if os.name=="posix" and not sys.platform.startswith("darwin"): try: from xpra.dbus.helper import DBusHelper assert DBusHelper except: pass log("metadata.supported: %s", ms) capabilities["metadata.supported"] = ms #we need the bindings to support initiate-moveresize (posix only for now): updict(capabilities, "window", { "initiate-moveresize" : HAS_X11_BINDINGS, "configure.pointer" : True, "frame_sizes" : self.get_window_frame_sizes() }) from xpra.client.window_backing_base import DELTA_BUCKETS updict(capabilities, "encoding", { "icons.greedy" : True, #we don't set a default window icon any more "icons.size" : (64, 64), #size we want "icons.max_size" : (128, 128), #limit "delta_buckets" : DELTA_BUCKETS, }) return capabilities
def make_hello(self): capabilities = UIXpraClient.make_hello(self) capabilities["named_cursors"] = len(cursor_names) > 0 capabilities.update(get_gtk_version_info()) return capabilities