class ChildReaper(object):
def __init__(self, quit_cb, children_pids={}):
self._quit = quit_cb
self._children_pids = children_pids
self._dead_pids = set()
from wimpiggy.log import Logger
self._logger = Logger()
def check(self):
if self._children_pids:
pids = set(self._children_pids.keys())
if pids.issubset(self._dead_pids):
self._quit()
def sigchld(self, signum, frame):
self.reap()
def add_dead_pid(self, pid):
if pid not in self._dead_pids:
cmd = self._children_pids.get(pid)
if cmd:
self._logger.info("child '%s' with pid %s has terminated", cmd, pid)
self._dead_pids.add(pid)
self.check()
def reap(self):
while True:
try:
pid, _ = os.waitpid(-1, os.WNOHANG)
except OSError:
break
if pid == 0:
break
self.add_dead_pid(pid)
def handshake_complete(*args):
from wimpiggy.log import Logger
log = Logger()
if mode=="detach":
log.info("handshake-complete: detaching")
app.quit(0)
elif mode=="attach":
log.info("Attached to %s (press Control-C to detach)\n" % conn.target)
def handshake_complete(*args):
from wimpiggy.log import Logger
log = Logger()
if mode == "detach":
log.info("handshake-complete: detaching")
app.quit(0)
elif mode == "attach":
log.info("Attached to %s (press Control-C to detach)\n" % target)
debug("do_set_keymap using xkbmap_print")
#try to guess the layout by parsing "setxkbmap -print"
try:
sym_re = re.compile("\s*xkb_symbols\s*{\s*include\s*\"([\w\+]*)")
for line in xkbmap_print.splitlines():
m = sym_re.match(line)
if m:
layout = m.group(1)
log.info("guessing keyboard layout='%s'" % layout)
exec_keymap_command(["setxkbmap", layout])
break
except Exception, e:
log.info("error setting keymap: %s" % e)
else:
layout = xkbmap_layout or "us"
log.info("setting keyboard layout to '%s'", layout)
set_layout = ["setxkbmap", "-layout", layout]
if xkbmap_variant:
set_layout += ["-variant", xkbmap_variant]
if not exec_keymap_command(set_layout) and xkbmap_variant:
log.info("error setting keymap with variant %s, retrying with just layout %s", xkbmap_variant, layout)
set_layout = ["setxkbmap", "-layout", layout]
exec_keymap_command(set_layout)
display = os.environ.get("DISPLAY")
if xkbmap_print:
#there may be a junk header, if so remove it:
pos = xkbmap_print.find("xkb_keymap {")
if pos>0:
xkbmap_print = xkbmap_print[pos:]
log.info("setting full keymap definition from client via xkbcomp")
m = sym_re.match(line)
if m:
layout = m.group(1)
log.info("guessing keyboard layout='%s'" % layout)
exec_keymap_command(["setxkbmap", layout])
break
except Exception, e:
log.info("error setting keymap: %s" % e)
else:
#just set the layout (use 'us' if we don't even have that information!)
layout = xkbmap_layout or "us"
set_layout = ["setxkbmap", "-layout", layout]
if xkbmap_variant:
set_layout += ["-variant", xkbmap_variant]
if not exec_keymap_command(set_layout) and xkbmap_variant:
log.info("error setting keymap with variant %s, retrying with just layout %s", xkbmap_variant, layout)
set_layout = ["setxkbmap", "-layout", layout]
exec_keymap_command(set_layout)
display = os.environ.get("DISPLAY")
if xkbmap_print:
exec_keymap_command(["xkbcomp", "-", display], xkbmap_print)
def parse_xmodmap(xmodmap_data):
if type(xmodmap_data)==str and xmodmap_data.find("\n"):
xmodmap_data = xmodmap_data.splitlines()
import pygtk
pygtk.require("2.0")
import gtk
root = gtk.gdk.get_default_root_window()
if m:
layout = m.group(1)
log.info("guessing keyboard layout='%s'" % layout)
exec_keymap_command(["setxkbmap", layout])
break
except Exception, e:
log.info("error setting keymap: %s" % e)
else:
#just set the layout (use 'us' if we don't even have that information!)
layout = xkbmap_layout or "us"
set_layout = ["setxkbmap", "-layout", layout]
if xkbmap_variant:
set_layout += ["-variant", xkbmap_variant]
if not exec_keymap_command(set_layout) and xkbmap_variant:
log.info(
"error setting keymap with variant %s, retrying with just layout %s",
xkbmap_variant, layout)
set_layout = ["setxkbmap", "-layout", layout]
exec_keymap_command(set_layout)
display = os.environ.get("DISPLAY")
if xkbmap_print:
#there may be a junk header, if so remove it:
pos = xkbmap_print.find("xkb_keymap {")
if pos > 0:
xkbmap_print = xkbmap_print[pos:]
exec_keymap_command(["xkbcomp", "-", display], xkbmap_print)
def parse_xmodmap(xmodmap_data):
if type(xmodmap_data) == str and xmodmap_data.find("\n"):
display = 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.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.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)
if self.compression_level!=0:
log.info("disabling compression")
self.compression_level = 0
self.send_deflate_level()
self.server_start_time = capabilities.get("start_time", -1)
self.server_platform = capabilities.get("platform")
self.toggle_cursors_bell_notify = capabilities.get("toggle_cursors_bell_notify")
#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.emit("handshake-complete")
if clipboard_server_support:
from xpra.keys import DEFAULT_MODIFIER_MEANINGS, DEFAULT_MODIFIER_NUISANCE, DEFAULT_MODIFIER_IGNORE_KEYNAMES
from xpra.platform.gui import ClientExtras
from xpra.scripts.main import ENCODINGS
from xpra.version_util import add_gtk_version_info
from xpra.maths import std_unit
from xpra.client_window import ClientWindow
ClientWindowClass = ClientWindow
#the GL backend only works with gtk2
USE_OPENGL = False
if USE_OPENGL and not is_gtk3():
try:
from xpra.gl_client_window import GLClientWindow
ClientWindowClass = GLClientWindow
except ImportError, e:
log.info("Disabled OpenGL output: %s" % e)
def nn(x):
if x is None:
return ""
return x
class XpraClient(XpraClientBase):
__gsignals__ = {
"clipboard-toggled": n_arg_signal(0),
"keyboard-sync-toggled": n_arg_signal(0),
}
def __init__(self, conn, opts):
debug("do_set_keymap using xkbmap_print")
#try to guess the layout by parsing "setxkbmap -print"
try:
sym_re = re.compile("\s*xkb_symbols\s*{\s*include\s*\"([\w\+]*)")
for line in xkbmap_print.splitlines():
m = sym_re.match(line)
if m:
layout = m.group(1)
log.info("guessing keyboard layout='%s'" % layout)
exec_keymap_command(["setxkbmap", layout])
break
except Exception, e:
log.info("error setting keymap: %s" % e)
else:
layout = xkbmap_layout or "us"
log.info("setting keyboard layout to '%s'", layout)
set_layout = ["setxkbmap", "-layout", layout]
if xkbmap_variant:
set_layout += ["-variant", xkbmap_variant]
if not exec_keymap_command(set_layout) and xkbmap_variant:
log.info(
"error setting keymap with variant %s, retrying with just layout %s",
xkbmap_variant, layout)
set_layout = ["setxkbmap", "-layout", layout]
exec_keymap_command(set_layout)
display = os.environ.get("DISPLAY")
if xkbmap_print:
#there may be a junk header, if so remove it:
pos = xkbmap_print.find("xkb_keymap {")
if pos > 0:
#sanity checks: OpenGL version
try:
from gtk import gdk
glconfig = gtk.gdkgl.Config(mode=gtk.gdkgl.MODE_RGB|gtk.gdkgl.MODE_SINGLE)
glext = gtk.gdkgl.ext(gdk.Pixmap(gdk.get_default_root_window(), 1, 1))
gldrawable = glext.set_gl_capability(glconfig)
glcontext = gtk.gdkgl.Context(gldrawable, direct=True)
if not gldrawable.gl_begin(glcontext):
raise ImportError("gl_begin failed on %s" % gldrawable)
try:
gl_major = int(glGetString(GL_VERSION)[0])
gl_minor = int(glGetString(GL_VERSION)[2])
if gl_major<=1 and gl_minor<1:
raise ImportError("** OpenGL output requires OpenGL version 1.1 or greater, not %s.%s" % (gl_major, gl_minor))
log.info("found valid OpenGL: %s.%s", gl_major, gl_minor)
#this allows us to do CSC via OpenGL:
#see http://www.opengl.org/registry/specs/ARB/fragment_program.txt
use_openGL_CSC = glInitFragmentProgramARB()
finally:
gldrawable.gl_end()
del glcontext, gldrawable, glext, glconfig
except Exception, e:
raise ImportError("** OpenGL initialization error: %s" % e)
class GLClientWindow(ClientWindow):
MODE_UNINITIALIZED = 0
MODE_RGB = 1
MODE_YUV = 2
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.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.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)
if self.compression_level != 0:
log.info("disabling compression")
self.compression_level = 0
self.send_deflate_level()
self.server_start_time = capabilities.get("start_time", -1)
self.server_platform = capabilities.get("platform")
self.toggle_cursors_bell_notify = capabilities.get(
"toggle_cursors_bell_notify")
#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))
elif xkbmap_print:
log.debug("do_set_keymap using xkbmap_print")
#try to guess the layout by parsing "setxkbmap -print"
try:
sym_re = re.compile("\s*xkb_symbols\s*{\s*include\s*\"([\w\+]*)")
for line in xkbmap_print.splitlines():
m = sym_re.match(line)
if m:
layout = m.group(1)
log.info("guessing keyboard layout='%s'" % layout)
exec_keymap_command(["setxkbmap", layout])
break
except Exception, e:
log.info("error setting keymap: %s" % e)
else:
log.info("do_set_keymap using 'us' default layout")
#just set the layout (use 'us' if we don't even have that information!)
layout = xkbmap_layout or "us"
set_layout = ["setxkbmap", "-layout", layout]
if xkbmap_variant:
set_layout += ["-variant", xkbmap_variant]
if not exec_keymap_command(set_layout) and xkbmap_variant:
log.info("error setting keymap with variant %s, retrying with just layout %s", xkbmap_variant, layout)
set_layout = ["setxkbmap", "-layout", layout]
exec_keymap_command(set_layout)
display = os.environ.get("DISPLAY")
if xkbmap_print:
#there may be a junk header, if so remove it:
pos = xkbmap_print.find("xkb_keymap {")
if pos>0:
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 send_deflate_level(self):
from xpra.client_base import XpraClientBase
from xpra.keys import mask_to_names, DEFAULT_MODIFIER_MEANINGS, DEFAULT_MODIFIER_NUISANCE, DEFAULT_MODIFIER_IGNORE_KEYNAMES
from xpra.platform.gui import ClientExtras
from xpra.scripts.main import ENCODINGS
from xpra.version_util import add_gtk_version_info
from xpra.client_window import ClientWindow
ClientWindowClass = ClientWindow
#the GL backend only works with gtk2
USE_OPENGL = False
if USE_OPENGL and not is_gtk3():
try:
from xpra.gl_client_window import GLClientWindow
ClientWindowClass = GLClientWindow
except ImportError, e:
log.info("Disabled OpenGL output: %s" % e)
def nn(x):
if x is None:
return ""
return x
class XpraClient(XpraClientBase):
__gsignals__ = {
"clipboard-toggled": n_arg_signal(0),
"keyboard-sync-toggled": n_arg_signal(0),
}
def __init__(self, conn, opts):
from gtk import gdk
glconfig = gtk.gdkgl.Config(mode=gtk.gdkgl.MODE_RGB
| gtk.gdkgl.MODE_SINGLE)
glext = gtk.gdkgl.ext(gdk.Pixmap(gdk.get_default_root_window(), 1, 1))
gldrawable = glext.set_gl_capability(glconfig)
glcontext = gtk.gdkgl.Context(gldrawable, direct=True)
if not gldrawable.gl_begin(glcontext):
raise ImportError("gl_begin failed on %s" % gldrawable)
try:
gl_major = int(glGetString(GL_VERSION)[0])
gl_minor = int(glGetString(GL_VERSION)[2])
if gl_major <= 1 and gl_minor < 1:
raise ImportError(
"** OpenGL output requires OpenGL version 1.1 or greater, not %s.%s"
% (gl_major, gl_minor))
log.info("found valid OpenGL: %s.%s", gl_major, gl_minor)
#this allows us to do CSC via OpenGL:
#see http://www.opengl.org/registry/specs/ARB/fragment_program.txt
use_openGL_CSC = glInitFragmentProgramARB()
finally:
gldrawable.gl_end()
del glcontext, gldrawable, glext, glconfig
except Exception, e:
raise ImportError("** OpenGL initialization error: %s" % e)
class GLClientWindow(ClientWindow):
MODE_UNINITIALIZED = 0
MODE_RGB = 1
MODE_YUV = 2
from xpra.keys import mask_to_names, DEFAULT_MODIFIER_MEANINGS, DEFAULT_MODIFIER_NUISANCE, DEFAULT_MODIFIER_IGNORE_KEYNAMES
from xpra.platform.gui import ClientExtras
from xpra.scripts.main import ENCODINGS
from xpra.version_util import add_gtk_version_info
from xpra.client_window import ClientWindow
ClientWindowClass = ClientWindow
#the GL backend only works with gtk2
USE_OPENGL = False
if USE_OPENGL and not is_gtk3():
try:
from xpra.gl_client_window import GLClientWindow
ClientWindowClass = GLClientWindow
except ImportError, e:
log.info("Disabled OpenGL output: %s" % e)
def nn(x):
if x is None:
return ""
return x
class XpraClient(XpraClientBase):
__gsignals__ = {
"clipboard-toggled": n_arg_signal(0),
"keyboard-sync-toggled": n_arg_signal(0),
}
def __init__(self, conn, opts):
from xpra.keys import DEFAULT_MODIFIER_MEANINGS, DEFAULT_MODIFIER_NUISANCE, DEFAULT_MODIFIER_IGNORE_KEYNAMES
from xpra.platform.gui import ClientExtras
from xpra.scripts.main import ENCODINGS
from xpra.version_util import add_gtk_version_info
from xpra.maths import std_unit
from xpra.client_window import ClientWindow
ClientWindowClass = ClientWindow
#the GL backend only works with gtk2
USE_OPENGL = False
if USE_OPENGL and not is_gtk3():
try:
from xpra.gl_client_window import GLClientWindow
ClientWindowClass = GLClientWindow
except ImportError, e:
log.info("Disabled OpenGL output: %s" % e)
def nn(x):
if x is None:
return ""
return x
class XpraClient(XpraClientBase):
__gsignals__ = {
"clipboard-toggled": n_arg_signal(0),
"keyboard-sync-toggled": n_arg_signal(0),
}
def __init__(self, conn, opts):
