def _process_desktop_size(self, proto, packet):
width, height = packet[1:3]
ss = self._server_sources.get(proto)
if ss is None:
return
ss.desktop_size = (width, height)
if len(packet) >= 10:
#added in 0.16 for scaled client displays:
xdpi, ydpi = packet[8:10]
if xdpi != self.xdpi or ydpi != self.ydpi:
self.xdpi, self.ydpi = xdpi, ydpi
log("new dpi: %ix%i", self.xdpi, self.ydpi)
self.dpi = iround((self.xdpi + self.ydpi) / 2.0)
self.dpi_changed()
if len(packet) >= 8:
#added in 0.16 for scaled client displays:
ss.desktop_size_unscaled = packet[6:8]
if len(packet) >= 6:
desktops, desktop_names = packet[4:6]
ss.set_desktops(desktops, desktop_names)
self.calculate_desktops()
if len(packet) >= 4:
ss.set_screen_sizes(packet[3])
log("client requesting new size: %sx%s", width, height)
self.set_screen_size(width, height)
if len(packet) >= 4:
log.info("received updated display dimensions")
log.info("client display size is %sx%s with %s screen%s:", width,
height, len(ss.screen_sizes), engs(ss.screen_sizes))
log_screen_sizes(width, height, ss.screen_sizes)
self.calculate_workarea(width, height)
#ensures that DPI and antialias information gets reset:
self.update_all_server_settings()
def do_parse_screen_info(self, ss, desktop_size):
log("do_parse_screen_info%s", (ss, desktop_size))
dw, dh = None, None
if desktop_size:
try:
dw, dh = desktop_size
if not ss.screen_sizes:
log.info(" client root window size is %sx%s", dw, dh)
else:
log.info(
" client root window size is %sx%s with %s display%s:",
dw, dh, len(ss.screen_sizes), engs(ss.screen_sizes))
log_screen_sizes(dw, dh, ss.screen_sizes)
except Exception:
dw, dh = None, None
sw, sh = self.configure_best_screen_size()
log("configure_best_screen_size()=%s", (sw, sh))
#we will tell the client about the size chosen in the hello we send back,
#so record this size as the current server desktop size to avoid change notifications:
ss.desktop_size_server = sw, sh
#prefer desktop size, fallback to screen size:
w = dw or sw
h = dh or sh
#clamp to max supported:
maxw, maxh = self.get_max_screen_size()
w = min(w, maxw)
h = min(h, maxh)
self.set_desktop_geometry_attributes(w, h)
self.set_icc_profile()
return w, h
def get_caps(self):
caps = {
"randr_notify": True,
"show-desktop": True,
}
wm_name = get_wm_name()
if wm_name:
caps["wm_name"] = wm_name
self._last_screen_settings = self.get_screen_settings()
root_w, root_h, sss, ndesktops, desktop_names, u_root_w, u_root_h, _, _ = self._last_screen_settings
if u_root_w and u_root_h:
caps["desktop_size"] = self.cp(u_root_w, u_root_h)
if ndesktops:
caps["desktops"] = ndesktops
caps["desktop.names"] = desktop_names
ss = self.get_screen_sizes()
self._current_screen_sizes = ss
log.info(" desktop size is %sx%s with %s screen%s:", u_root_w,
u_root_h, len(ss), engs(ss))
log_screen_sizes(u_root_w, u_root_h, ss)
if self.xscale != 1 or self.yscale != 1:
caps["screen_sizes.unscaled"] = ss
caps["desktop_size.unscaled"] = u_root_w, u_root_h
root_w, root_h = self.cp(u_root_w, u_root_h)
if fequ(self.xscale, self.yscale):
sinfo = "%i%%" % iround(self.xscale * 100)
else:
sinfo = "%i%% x %i%%" % (iround(
self.xscale * 100), iround(self.yscale * 100))
log.info(" %sscaled by %s, virtual screen size: %ix%i",
["down",
"up"][int(u_root_w > root_w
or u_root_h > root_h)], sinfo, root_w, root_h)
log_screen_sizes(root_w, root_h, sss)
else:
root_w, root_h = u_root_w, u_root_h
sss = ss
caps["screen_sizes"] = sss
caps.update(self.get_screen_caps())
caps.update(
flatten_dict({
"dpi": self.get_dpi_caps(),
"screen-scaling": self.get_scaling_caps(),
}))
return caps
def get_caps(self) -> dict:
caps = {
"randr_notify": True,
"show-desktop": True,
"vrefresh": self.get_vrefresh(),
}
wm_name = get_wm_name()
if wm_name:
caps["wm_name"] = wm_name
self._last_screen_settings = self.get_screen_settings()
root_w, root_h, sss, ndesktops, desktop_names, u_root_w, u_root_h = self._last_screen_settings[:
7]
if u_root_w and u_root_h:
caps["desktop_size"] = self.cp(u_root_w, u_root_h)
if ndesktops:
caps["desktops"] = ndesktops
caps["desktop.names"] = tuple(desktop_names)
ss = self.get_screen_sizes()
self._current_screen_sizes = ss
log.info(" desktop size is %sx%s:", u_root_w, u_root_h)
log_screen_sizes(u_root_w, u_root_h, ss)
if self.xscale != 1 or self.yscale != 1:
caps["screen_sizes.unscaled"] = ss
caps["desktop_size.unscaled"] = u_root_w, u_root_h
root_w, root_h = self.cp(u_root_w, u_root_h)
if fequ(self.xscale, self.yscale):
sinfo = "%i%%" % iround(self.xscale * 100)
else:
sinfo = "%i%% x %i%%" % (iround(
self.xscale * 100), iround(self.yscale * 100))
scaled_up = u_root_w > root_w or u_root_h > root_h
log.info(" %sscaled to %s, virtual screen size: %ix%i",
"up" if scaled_up else "down", sinfo, root_w, root_h)
log_screen_sizes(root_w, root_h, sss)
else:
root_w, root_h = u_root_w, u_root_h
sss = ss
caps["screen_sizes"] = sss
caps.update(self.get_screen_caps())
caps.update(
flatten_dict({
"dpi": self.get_dpi_caps(),
"screen-scaling": self.get_scaling_caps(),
}))
return caps
def update_screen_size(self):
self.screen_size_change_timer = None
screen_settings = self.get_screen_settings()
log("update_screen_size() new settings=%s", screen_settings)
log("update_screen_size() current settings=%s", self._last_screen_settings)
if self._last_screen_settings==screen_settings:
log("screen size unchanged")
return
root_w, root_h, sss = screen_settings[:3]
log.info("sending updated screen size to server: %sx%s", root_w, root_h)
log_screen_sizes(root_w, root_h, sss)
if self.server_desktop_size:
self.send("desktop_size", *screen_settings)
self._last_screen_settings = screen_settings
#update the max packet size (may have gone up):
self.set_max_packet_size()
def _process_desktop_size(self, proto, packet):
log("new desktop size from %s: %s", proto, packet)
width, height = packet[1:3]
ss = self.get_server_source(proto)
if ss is None:
return
ss.desktop_size = (width, height)
if len(packet)>=11:
vrefresh = packet[10]
log("new vrefresh=%s", vrefresh)
#update clientdisplay mixin:
if hasattr(ss, "vrefresh") and getattr(ss, "refresh")!=vrefresh:
ss.vrefresh = vrefresh
#update all batch configs:
if hasattr(ss, "all_window_sources"):
for window_source in ss.all_window_sources():
bc = window_source.batch_config
if bc:
bc.match_vrefresh(vrefresh)
if len(packet)>=10:
#added in 0.16 for scaled client displays:
xdpi, ydpi = packet[8:10]
if xdpi!=self.xdpi or ydpi!=self.ydpi:
self.xdpi, self.ydpi = xdpi, ydpi
log("new dpi: %ix%i", self.xdpi, self.ydpi)
self.dpi = round((self.xdpi + self.ydpi)/2)
self.dpi_changed()
if len(packet)>=8:
#added in 0.16 for scaled client displays:
ss.desktop_size_unscaled = packet[6:8]
if len(packet)>=6:
desktops, desktop_names = packet[4:6]
ss.set_desktops(desktops, desktop_names)
self.calculate_desktops()
if len(packet)>=4:
ss.set_screen_sizes(packet[3])
bigger = ss.screen_resize_bigger
log("client requesting new size: %sx%s (bigger=%s)", width, height, bigger)
self.set_screen_size(width, height, bigger)
if len(packet)>=4:
log.info("received updated display dimensions")
log.info("client display size is %sx%s",
width, height)
log_screen_sizes(width, height, ss.screen_sizes)
self.calculate_workarea(width, height)
#ensures that DPI and antialias information gets reset:
self.update_all_server_settings()
def test_log_screen_sizes(self):
#whatever you throw at it, it should continue:
log_screen_sizes(0, 0, None)
log_screen_sizes(None, object(), ["invalid"])
def print_screen_info(self):
X11ServerBase.print_screen_info(self)
root_w, root_h = get_root_size()
sss = get_screen_sizes()
log_screen_sizes(root_w, root_h, sss)
def print_screen_info(self):
super().print_screen_info()
root_w, root_h = get_root_size()
log.info(" initial resolution: %ix%i", root_w, root_h)
sss = get_screen_sizes()
log_screen_sizes(root_w, root_h, sss)
def parse_server_capabilities(self):
for c in CLIENT_BASES:
if not c.parse_server_capabilities(self):
log.info("failed to parse server capabilities in %s", c)
return False
c = self.server_capabilities
self.server_session_name = strtobytes(c.rawget("session_name", b"")).decode("utf-8")
set_name("Xpra", self.session_name or self.server_session_name or "Xpra")
self.server_platform = c.strget("platform")
self.server_sharing = c.boolget("sharing")
self.server_sharing_toggle = c.boolget("sharing-toggle")
self.server_lock = c.boolget("lock")
self.server_lock_toggle = c.boolget("lock-toggle")
self.server_keyboard = c.boolget("keyboard", True)
self.server_toggle_keyboard_sync = self.server_keyboard and c.boolget("toggle_keyboard_sync", True)
self.server_pointer = c.boolget("pointer", True)
self.server_start_new_commands = c.boolget("start-new-commands")
if self.server_start_new_commands:
self.server_xdg_menu = c.dictget("xdg-menu", None)
if self.start_new_commands or self.start_child_new_commands:
if self.server_start_new_commands:
self.after_handshake(self.send_start_new_commands)
else:
log.warn("Warning: cannot start new commands")
log.warn(" the feature is currently disabled on the server")
self.server_commands_info = c.boolget("server-commands-info")
self.server_commands_signals = c.strlistget("server-commands-signals")
self.server_readonly = c.boolget("readonly")
if self.server_readonly and not self.readonly:
log.info("server is read only")
self.readonly = True
if not self.server_keyboard and self.keyboard_helper:
#swallow packets:
def nosend(*_args):
pass
self.keyboard_helper.send = nosend
i = platform_name(self._remote_platform,
c.strlistget("platform.linux_distribution") or c.strget("platform.release", ""))
r = self._remote_version
if self._remote_revision:
r += "-r%s" % self._remote_revision
mode = c.strget("server.mode", "server")
bits = c.intget("python.bits", 32)
log.info("Xpra %s server version %s %i-bit", mode, std(r), bits)
if i:
log.info(" running on %s", std(i))
if c.boolget("desktop") or c.boolget("shadow"):
v = c.intpair("actual_desktop_size")
if v:
w, h = v
ss = c.listget("screen_sizes")
if ss:
log.info(" remote desktop size is %sx%s with %s screen%s:", w, h, len(ss), engs(ss))
log_screen_sizes(w, h, ss)
else:
log.info(" remote desktop size is %sx%s", w, h)
if c.boolget("proxy"):
proxy_hostname = c.strget("proxy.hostname")
proxy_platform = c.strget("proxy.platform")
proxy_release = c.strget("proxy.platform.release")
proxy_version = c.strget("proxy.version")
proxy_version = c.strget("proxy.build.version", proxy_version)
proxy_distro = c.strget("proxy.linux_distribution")
msg = "via: %s proxy version %s" % (
platform_name(proxy_platform, proxy_distro or proxy_release),
std(proxy_version or "unknown")
)
if proxy_hostname:
msg += " on '%s'" % std(proxy_hostname)
log.info(msg)
return True
def print_screen_info(self):
super(XpraDesktopServer, self).print_screen_info()
root_w, root_h = get_root_size()
sss = get_screen_sizes()
log_screen_sizes(root_w, root_h, sss)
def print_screen_info(self):
X11ServerBase.print_screen_info(self)
root_w, root_h = get_root_size()
sss = get_screen_sizes()
log_screen_sizes(root_w, root_h, sss)
