def parse_server_capabilities(self, capabilities):
self._protocol.raw_packets = bool(
capabilities.get("raw_packets", False))
self._protocol.chunked_compression = bool(
capabilities.get("chunked_compression", False))
self._remote_version = capabilities.get("version") or capabilities.get(
"__prerelease_version")
if not is_compatible_with(self._remote_version):
self.quit(1)
def parse_server_capabilities(self, capabilities):
self._remote_version = capabilities.get("version") or capabilities.get("__prerelease_version")
if not is_compatible_with(self._remote_version):
self.quit(4)
return False
if capabilities.get("rencode") and has_rencode:
self._protocol.enable_rencode()
self._protocol.chunked_compression = bool(capabilities.get("chunked_compression", False))
return True
def parse_server_capabilities(self, capabilities):
self._remote_version = capabilities.get("version")
if not is_compatible_with(self._remote_version):
self.quit(4)
return False
if capabilities.get("rencode") and has_rencode:
self._protocol.enable_rencode()
self._protocol.chunked_compression = capabilities.get("chunked_compression", False)
return True
def parse_server_capabilities(self, capabilities):
self._remote_version = capabilities.get("version")
self._remote_revision = capabilities.get("revision")
if not is_compatible_with(self._remote_version):
self.warn_and_quit(EXIT_INCOMPATIBLE_VERSION, "incompatible remote version: %s" % self._remote_version)
return False
if capabilities.get("rencode") and has_rencode:
self._protocol.enable_rencode()
self._protocol.chunked_compression = capabilities.get("chunked_compression", False)
return True
def parse_server_capabilities(self, capabilities):
self._remote_version = capabilities.get("version")
self._remote_revision = capabilities.get("revision")
if not is_compatible_with(self._remote_version):
self.warn_and_quit(
EXIT_INCOMPATIBLE_VERSION,
"incompatible remote version: %s" % self._remote_version)
return False
if capabilities.get("rencode") and has_rencode:
self._protocol.enable_rencode()
self._protocol.chunked_compression = capabilities.get(
"chunked_compression", False)
return True
def parse_server_capabilities(self, capabilities):
self._remote_version = capabilities.get("version")
self._remote_revision = capabilities.get("revision")
if not is_compatible_with(self._remote_version):
self.warn_and_quit(EXIT_INCOMPATIBLE_VERSION, "incompatible remote version: %s" % self._remote_version)
return False
if capabilities.get("rencode") and use_rencode:
self._protocol.enable_rencode()
if self.encryption:
#server uses a new cipher after second hello:
self.set_server_encryption(capabilities)
self._protocol.chunked_compression = capabilities.get("chunked_compression", False)
return True
def parse_server_capabilities(self, capabilities):
self._remote_version = capabilities.get("version")
self._remote_revision = capabilities.get("revision")
self._remote_revision = capabilities.get("build.revision", self._remote_revision)
if not is_compatible_with(self._remote_version):
self.warn_and_quit(EXIT_INCOMPATIBLE_VERSION, "incompatible remote version: %s" % self._remote_version)
return False
if capabilities.get("rencode") and use_rencode:
self._protocol.enable_rencode()
if self.encryption:
#server uses a new cipher after second hello:
self.set_server_encryption(capabilities)
self._protocol.chunked_compression = capabilities.get("chunked_compression", False)
self._protocol.aliases = capabilities.get("aliases", {})
if self.pings:
gobject.timeout_add(1000, self.send_ping)
else:
gobject.timeout_add(10*1000, self.send_ping)
return True
def send_refresh_all(self):
log.debug("Automatic refresh for all windows ")
self.send_refresh(-1)
def _process_hello(self, packet):
capabilities = packet[1]
self.server_capabilities = capabilities
if not self.session_name:
self.session_name = capabilities.get("session_name", "Xpra")
try:
import glib
glib.set_application_name(self.session_name)
except ImportError, e:
log.warn("glib is missing, cannot set the application name, please install glib's python bindings: %s", e)
self._remote_version = capabilities.get("version") or capabilities.get("__prerelease_version")
if not is_compatible_with(self._remote_version):
self.quit()
return
#figure out the maximum actual desktop size and use to
#calculate the maximum size of a packet (a full screen update packet)
root_w, root_h = get_root_size()
self.server_actual_desktop_size = capabilities.get("actual_desktop_size")
maxw, maxh = root_w, root_h
try:
server_w, server_h = self.server_actual_desktop_size
maxw = max(root_w, server_w)
maxh = max(root_h, server_h)
except:
pass
assert maxw>0 and maxh>0 and maxw<32768 and maxh<32768, "problems calculating maximum desktop size: %sx%s" % (maxw, maxh)
#full screen at 32bits times 4 for safety
def parse_server_capabilities(self, capabilities):
self._protocol.raw_packets = bool(capabilities.get("raw_packets", False))
self._protocol.chunked_compression = bool(capabilities.get("chunked_compression", False))
self._remote_version = capabilities.get("version") or capabilities.get("__prerelease_version")
if not is_compatible_with(self._remote_version):
self.quit(4)
def _process_hello(self, packet):
capabilities = packet[1]
self.server_capabilities = capabilities
if not self.session_name:
self.session_name = capabilities.get("session_name", "Xpra")
import glib
glib.set_application_name(self.session_name)
self.keyboard_as_properties = capabilities.get("keyboard_as_properties", False)
self._raw_keycodes_feature = capabilities.get("raw_keycodes_feature", False)
self._raw_keycodes_full = capabilities.get("raw_keycodes_full", False)
self._focus_modifiers_feature = capabilities.get("raw_keycodes_feature", False)
self._remote_version = capabilities.get("__prerelease_version") or capabilities.get("version")
if not is_compatible_with(self._remote_version):
self.quit()
return
if capabilities.get("dynamic_compression", False):
self.send_deflate_level()
elif "deflate" in capabilities:
#"deflate" is the old-style (pre 0.0.7.33): enable straight away:
self._protocol.enable_deflate(capabilities["deflate"])
self.server_actual_desktop_size = capabilities.get("actual_desktop_size")
self.server_desktop_size = capabilities.get("desktop_size")
if self.server_desktop_size:
avail_w, avail_h = self.server_desktop_size
root_w, root_h = gtk.gdk.get_default_root_window().get_size()
if (avail_w, avail_h) < (root_w, root_h):
log.warn("Server's virtual screen is too small -- "
"(server: %sx%s vs. client: %sx%s)\n"
"You may see strange behavior.\n"
"Please see "
"http://xpra.org/trac/ticket/10"
% (avail_w, avail_h, root_w, root_h))
self._protocol._send_size = capabilities.get("packet_size", False)
self.server_randr = capabilities.get("resize_screen", False)
log.debug("server has randr: %s", self.server_randr)
if self.server_randr:
display = gtk.gdk.display_get_default()
i=0
while i<display.get_n_screens():
screen = display.get_screen(i)
screen.connect("size-changed", self._screen_size_changed)
i += 1
e = capabilities.get("encoding")
if e and e!=self.encoding:
log.debug("server is using %s encoding" % e)
self.encoding = e
self.bell_enabled = capabilities.get("bell", False)
self.notifications_enabled = capabilities.get("notifications", False)
clipboard_server_support = capabilities.get("clipboard", True)
self.clipboard_enabled = clipboard_server_support and self._client_extras.supports_clipboard()
self.send_damage_sequence = capabilities.get("damage_sequence", False)
self.can_ping = capabilities.get("ping", False)
self.send_nuisance_modifiers = capabilities.get("modifiers_nuisance", False)
self.mmap_enabled = self.supports_mmap and self.mmap_file and capabilities.get("mmap_enabled")
if self.mmap_enabled:
log.info("mmap enabled using %s", self.mmap_file)
self.server_start_time = capabilities.get("start_time", -1)
self.server_platform = capabilities.get("platform")
#the server will have a handle on the mmap file by now, safe to delete:
self.clean_mmap()
#ui may want to know this is now set:
self.emit("clipboard-toggled")
self.key_repeat_delay, self.key_repeat_interval = capabilities.get("key_repeat", (-1,-1))
self.key_repeat_modifiers = capabilities.get("key_repeat_modifiers", False)
self.emit("handshake-complete")
if clipboard_server_support:
#from now on, we will send a message to the server whenever the clipboard flag changes:
self.connect("clipboard-toggled", self.send_clipboard_enabled_status)
def _process_hello(self, packet):
capabilities = packet[1]
self.server_capabilities = capabilities
if not self.session_name:
self.session_name = capabilities.get("session_name", "Xpra")
try:
import glib
glib.set_application_name(self.session_name)
except ImportError, e:
log.warn(
"glib is missing, cannot set the application name, please install glib's python bindings: %s",
e)
self._remote_version = capabilities.get("version") or capabilities.get(
"__prerelease_version")
if not is_compatible_with(self._remote_version):
self.quit()
return
#figure out the maximum actual desktop size and use to
#calculate the maximum size of a packet (a full screen update packet)
root_w, root_h = gtk.gdk.get_default_root_window().get_size()
self.server_actual_desktop_size = capabilities.get(
"actual_desktop_size")
maxw, maxh = root_w, root_h
try:
server_w, server_h = self.server_actual_desktop_size
maxw = max(root_w, server_w)
maxh = max(root_h, server_h)
except:
pass
assert maxw > 0 and maxh > 0 and maxw < 32768 and maxh < 32768, "problems calculating maximum desktop size: %sx%s" % (
