Python gobject_compat.is_gtk3函数代码示例

    def _do_paint_rgb(self, cairo_format, has_alpha, img_data, x, y, width, height, rowstride, options):
        """ must be called from UI thread """
        log("cairo._do_paint_rgb(%s, %s, %s bytes,%s,%s,%s,%s,%s,%s)", cairo_format, has_alpha, len(img_data), x, y, width, height, rowstride, options)
        rgb_format = options.strget("rgb_format", "RGB")
        if _memoryview and isinstance(img_data, _memoryview):
            #Pixbuf cannot use the memoryview directly:
            img_data = img_data.tobytes()
        #"cairo.ImageSurface.create_for_data" is not implemented in GTK3! ARGH!
        # http://cairographics.org/documentation/pycairo/3/reference/surfaces.html#cairo.ImageSurface.create_for_data
        # "Not yet available in Python 3"
        #
        #It is available in the cffi cairo bindings, which can be used instead of pycairo
        # but then we can't use it from the draw callbacks:
        # https://mail.gnome.org/archives/python-hackers-list/2011-December/msg00004.html
        # "PyGObject just lacks the glue code that allows it to pass the statically-wrapped
        # cairo.Pattern to introspected methods"

        if not is_gtk3() and rgb_format in ("ARGB", "XRGB"):
            #the pixel format is also what cairo expects
            #maybe we should also check that the stride is acceptable for cairo?
            #cairo_stride = cairo.ImageSurface.format_stride_for_width(cairo_format, width)
            #log("cairo_stride=%s, stride=%s", cairo_stride, rowstride)
            img_surface = cairo.ImageSurface.create_for_data(img_data, cairo_format, width, height, rowstride)
            return self.cairo_paint_surface(img_surface, x, y)

        if not is_gtk3() and rgb_format in ("RGBA", "RGBX"):
            #with GTK2, we can use a pixbuf from RGB(A) pixels
            if rgb_format=="RGBA":
                #we have to unpremultiply for pixbuf!
                img_data = self.unpremultiply(img_data)
            pixbuf = pixbuf_new_from_data(img_data, COLORSPACE_RGB, has_alpha, 8, width, height, rowstride)
            return self.cairo_paint_pixbuf(pixbuf, x, y)

        #PIL fallback
        PIL = get_codec("PIL")
        if has_alpha:
            oformat = "RGBA"
        else:
            oformat = "RGB"
        img = PIL.Image.frombuffer(oformat, (width,height), img_data, "raw", rgb_format, rowstride, 1)
        #This is insane, the code below should work, but it doesn't:
        # img_data = bytearray(img.tostring('raw', oformat, 0, 1))
        # pixbuf = pixbuf_new_from_data(img_data, COLORSPACE_RGB, True, 8, width, height, rowstride)
        # success = self.cairo_paint_pixbuf(pixbuf, x, y)
        #So we still rountrip via PNG:
        png = BytesIOClass()
        img.save(png, format="PNG")
        reader = BytesIOClass(png.getvalue())
        png.close()
        img = cairo.ImageSurface.create_from_png(reader)
        return self.cairo_paint_surface(img, x, y)

def get_preferred_size(widget):
    if is_gtk3():
        #ignore "min", we only care about "natural":
        _, w = widget.get_preferred_width()
        _, h = widget.get_preferred_height()
        return w, h
    return widget.size_request()

def get_pixbuf_from_data(rgb_data, has_alpha, w, h, rowstride):
    if is_gtk3():
        data = array.array('B', strtobytes(rgb_data))
        return GdkPixbuf.Pixbuf.new_from_data(data, GdkPixbuf.Colorspace.RGB,
                                         True, 8, w, h, rowstride,
                                         None, None)
    return gdk.pixbuf_new_from_data(rgb_data, gdk.COLORSPACE_RGB, has_alpha, 8, w, h, rowstride)

def add_close_accel(window, callback):
    if is_gtk3():
        return      #TODO: implement accel for gtk3
    accel_group = gtk.AccelGroup()
    accel_group.connect_group(ord('w'), gdk.CONTROL_MASK, gtk.ACCEL_LOCKED, callback)
    window.add_accel_group(accel_group)
    accel_group = gtk.AccelGroup()
    key, mod = gtk.accelerator_parse('<Alt>F4')
    accel_group.connect_group(key, mod, gtk.ACCEL_LOCKED, callback)
    escape_key, modifier = gtk.accelerator_parse('Escape')
    accel_group.connect_group(escape_key, modifier, gtk.ACCEL_LOCKED |  gtk.ACCEL_VISIBLE, callback)
    window.add_accel_group(accel_group)

 def owner_changed(self, cb, event):
     r = {}
     if not is_gtk3():
         r = {gtk.gdk.OWNER_CHANGE_CLOSE : "close",
              gtk.gdk.OWNER_CHANGE_DESTROY : "destroy",
              gtk.gdk.OWNER_CHANGE_NEW_OWNER : "new owner"}
     owner = self.clipboard.get_owner()
     #print("xid=%s, owner=%s" % (self.value_entry.get_window().xid, event.owner))
     weownit = (owner is not None)
     if weownit:
         owner_info="(us)"
     else:
         owner_info = hex(event.owner)
     self.log("Owner changed, reason: %s, new owner=%s" % (
                     r.get(event.reason, event.reason), owner_info))

def add_close_accel(window, callback):
    if is_gtk3():
        def connect(ag, *args):
            ag.connect(*args)
    else:
        def connect(ag, *args):
            ag.connect_group(*args)
    accel_group = gtk.AccelGroup()
    key, mod = gtk.accelerator_parse('<control>F4')
    connect(accel_group, key, mod, ACCEL_LOCKED, callback)
    window.add_accel_group(accel_group)
    accel_group = gtk.AccelGroup()
    key, mod = gtk.accelerator_parse('<Alt>F4')
    connect(accel_group, key, mod, ACCEL_LOCKED, callback)
    escape_key, modifier = gtk.accelerator_parse('Escape')
    connect(accel_group, escape_key, modifier, ACCEL_LOCKED |  ACCEL_VISIBLE, callback)
    window.add_accel_group(accel_group)

def about(on_close=None):
	global about_dialog
	if about_dialog:
		about_dialog.show()
		about_dialog.present()
		return
	from xpra.platform.paths import get_icon
	xpra_icon = get_icon("xpra.png")
	dialog = gtk.AboutDialog()
	if not is_gtk3():
		def on_website_hook(dialog, web, *args):
			''' called when the website item is selected '''
			webbrowser.open(SITE_URL)
		def on_email_hook(dialog, mail, *args):
			webbrowser.open("mailto://[email protected]")
		gtk.about_dialog_set_url_hook(on_website_hook)
		gtk.about_dialog_set_email_hook(on_email_hook)
		if xpra_icon:
			dialog.set_icon(xpra_icon)
	dialog.set_name("Xpra")
	dialog.set_version(__version__)
	dialog.set_authors(('Antoine Martin <[email protected]>',
						'Nathaniel Smith <[email protected]>',
						'Serviware - Arthur Huillet <[email protected]>'))
	_license = load_license()
	dialog.set_license(_license or "Your installation may be corrupted,"
					+ " the license text for GPL version 2 could not be found,"
					+ "\nplease refer to:\nhttp://www.gnu.org/licenses/gpl-2.0.txt")
	dialog.set_comments("\n".join(get_build_info()))
	dialog.set_website(SITE_URL)
	dialog.set_website_label(SITE_DOMAIN)
	if xpra_icon:
		dialog.set_logo(xpra_icon)
	if hasattr(dialog, "set_program_name"):
		dialog.set_program_name(APPLICATION_NAME)
	def close(*args):
		close_about()
		#the about function may be called as a widget callback
		#so avoid calling the widget as if it was a function!
		if on_close and hasattr(on_close, '__call__'):
			on_close()
	dialog.connect("response", close)
	add_close_accel(dialog, close)
	about_dialog = dialog
	dialog.show()

def make_client(error_cb, opts):
    app = None
    if not opts.client_toolkit:
        from xpra.gtk_common.gobject_compat import import_gobject, is_gtk3
        import_gobject()
        if is_gtk3():
            opts.client_toolkit = "gtk3"
        else:
            opts.client_toolkit = "gtk2"

    ct = opts.client_toolkit.lower()
    toolkits = {}
    try:
        import gtk.gdk                      #@UnusedImport
        import xpra.client.gtk2             #@UnusedImport
        toolkits["gtk2"] = "xpra.client.gtk2.client"
    except Exception, e:
        print("cannot load gtk2: %s" % e)

 def do_setup_xprops(self, *args):
     log("do_setup_xprops(%s)", args)
     if is_gtk3():
         log("x11 root properties and XSETTINGS are not supported yet with GTK3")
         return
     ROOT_PROPS = ["RESOURCE_MANAGER", "_NET_WORKAREA", "_NET_CURRENT_DESKTOP"]
     try:
         from xpra.x11.xsettings import XSettingsWatcher
         from xpra.x11.xroot_props import XRootPropWatcher
         if self._xsettings_watcher is None:
             self._xsettings_watcher = XSettingsWatcher()
             self._xsettings_watcher.connect("xsettings-changed", self._handle_xsettings_changed)
             self._handle_xsettings_changed()
         if self._root_props_watcher is None:
             self._root_props_watcher = XRootPropWatcher(ROOT_PROPS)
             self._root_props_watcher.connect("root-prop-changed", self._handle_root_prop_changed)
             #ensure we get the initial value:
             self._root_props_watcher.do_notify("RESOURCE_MANAGER")
     except ImportError as e:
         log.error("failed to load X11 properties/settings bindings: %s - root window properties will not be propagated", e)

def get_gtk_version_info():
    #update props given:
    global GTK_VERSION_INFO
    def av(k, v):
        GTK_VERSION_INFO.setdefault(k, {})["version"] = v
    if not GTK_VERSION_INFO:
        if hasattr(gtk, "pygtk_version"):
            av("pygtk", gtk.pygtk_version)
        if hasattr(gtk, "gtk_version"):
            #GTK2:
            av("gtk", gtk.gtk_version)
        elif hasattr(gtk, "_version"):
            #GTK3:
            av("gtk", gtk._version)
        if hasattr(gdk, "__version__"):
            #GTK2:
            av("gdk", gdk.__version__)
        elif hasattr(gdk, "_version"):
            #GTK3:
            av("gdk", gdk._version)
        if is_gtk3():
            try:
                import gi
                av("gi", gi.__version__)
            except:
                pass
        if hasattr(gobject, "pygobject_version"):
            av("gobject", gobject.pygobject_version)
        elif hasattr(gobject, "_version"):
            av("gobject", gobject._version)
        if hasattr(cairo, "version"):
            av("cairo", cairo.version)
        if hasattr(pango, "version_string"):
            av("pango", pango.version_string())
        try:
            import glib
            av("glib", glib.glib_version)
            av("pyglib", glib.pyglib_version)
        except:
            pass
    return GTK_VERSION_INFO.copy()

def grok_modifier_map(display, meanings):
    """Return an dict mapping modifier names to corresponding X modifier
    bitmasks."""
    #TODO: needs fixing for GTK3
    from xpra.keyboard.mask import MODIFIER_MAP
    modifier_map = MODIFIER_MAP.copy()
    modifier_map.update({
        "scroll":   0,
        "num":      0,
        "meta":     0,
        "super":    0,
        "hyper":    0,
        "alt":      0,
        })
    if not meanings:
        meanings = DEFAULT_MODIFIER_MEANINGS

    (max_keypermod, keycodes) = X11Keyboard.get_modifier_map()
    assert len(keycodes) == 8 * max_keypermod
    keymap = keymap_get_for_display(display)
    for i in range(8):
        for j in range(max_keypermod):
            keycode = keycodes[i * max_keypermod + j]
            if keycode:
                entries = keymap.get_entries_for_keycode(keycode)
                if entries is None:
                    # This keycode has no entry in the keymap:
                    continue
                if is_gtk3():
                    found, _, keyvals = entries
                    if not found:
                        continue
                else:
                    #(keyval, _, _, _) in entries
                    keyvals = [x[0] for x in entries]
                for keyval in keyvals:
                    keyval_name = gdk.keyval_name(keyval)
                    modifier = meanings.get(keyval_name)
                    if modifier:
                        modifier_map[modifier] |= (1 << i)
    return modifier_map

def get_gtk_version_info():
    #update props given:
    global GTK_VERSION_INFO
    if not GTK_VERSION_INFO:
        if hasattr(gtk, "pygtk_version"):
            GTK_VERSION_INFO["pygtk.version"] = gtk.pygtk_version
        if hasattr(gtk, "gtk_version"):
            #GTK2:
            GTK_VERSION_INFO["gtk.version"] = gtk.gtk_version
        elif hasattr(gtk, "_version"):
            #GTK3:
            GTK_VERSION_INFO["gtk.version"] = gtk._version
        if hasattr(gdk, "__version__"):
            #GTK2:
            GTK_VERSION_INFO["gdk.version"] = gdk.__version__
        elif hasattr(gdk, "_version"):
            #GTK3:
            GTK_VERSION_INFO["gdk.version"] = gdk._version
        if is_gtk3():
            try:
                import gi
                GTK_VERSION_INFO["gi.version"] = gi.__version__
            except:
                pass
        if hasattr(gobject, "pygobject_version"):
            GTK_VERSION_INFO["gobject.version"] = gobject.pygobject_version
        elif hasattr(gobject, "_version"):
            GTK_VERSION_INFO["gobject.version"] = gobject._version
        if hasattr(cairo, "version"):
            GTK_VERSION_INFO["cairo.version"] = cairo.version
        if hasattr(pango, "version_string"):
            GTK_VERSION_INFO["pango.version"] = pango.version_string()
        try:
            import glib
            GTK_VERSION_INFO["glib.version"] = glib.glib_version
            GTK_VERSION_INFO["pyglib.version"] = glib.pyglib_version
        except:
            pass
    return GTK_VERSION_INFO.copy()

    def    __init__(self):
        self.window = gtk.Window()
        self.window.connect("destroy", self.destroy)
        self.window.set_default_size(540, 800)
        self.window.set_border_width(20)
        self.window.set_title("Keyboard State Tool")

        # Title
        vbox = gtk.VBox(False, 0)
        vbox.set_spacing(15)
        label = gtk.Label("Keyboard State")
        label.modify_font(pango.FontDescription("sans 13"))
        vbox.pack_start(label)

        self.modifiers = gtk.Label()
        vbox.add(self.modifiers)

        self.mouse = gtk.Label()
        vbox.add(self.mouse)

        self.keys = gtk.Label()
        fixed = pango.FontDescription('monospace 9')
        self.keys.modify_font(fixed)
        vbox.add(self.keys)

        self.window.add(vbox)
        self.window.show_all()
        gobject.timeout_add(100, self.populate_modifiers)

        self.key_events = maxdeque(maxlen=35)
        self.window.connect("key-press-event", self.key_press)
        self.window.connect("key-release-event", self.key_release)
        if not is_gtk3():
            self.window.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))

        icon = get_icon("keyboard.png")
        if icon:
            self.window.set_icon(icon)

def imagebutton(title, icon, tooltip=None, clicked_callback=None, icon_size=32, default=False, min_size=None, label_color=None):
    button = gtk.Button(title)
    settings = button.get_settings()
    settings.set_property('gtk-button-images', True)
    if icon:
        button.set_image(scaled_image(icon, icon_size))
    if tooltip:
        button.set_tooltip_text(tooltip)
    if min_size:
        button.set_size_request(min_size, min_size)
    if clicked_callback:
        button.connect("clicked", clicked_callback)
    if default:
        if is_gtk3():
            button.set_can_default(True)
        else:
            button.set_flags(gtk.CAN_DEFAULT)
    if label_color:
        alignment = button.get_children()[0]
        b_hbox = alignment.get_children()[0]
        label = b_hbox.get_children()[1]
        label.modify_fg(STATE_NORMAL, label_color)
    return button

gtk = import_gtk()
gdk = import_gdk()
from xpra.gtk_common.gtk_util import get_xwindow

from xpra.log import Logger
log = Logger("x11", "window")

try:
    from xpra.x11.gtk2.gdk_bindings import (
                    get_pywindow,               #@UnresolvedImport
                    get_xvisual,                #@UnresolvedImport
                   )
except ImportError as e:
    #we should only ever be missing the gdk_bindings with GTK3 builds:
    log("cannot import gdk bindings", exc_info=True)
    assert is_gtk3()
    def missing_fn(*args):
        raise NotImplementedError()
    get_pywindow, get_xvisual = missing_fn, missing_fn

from xpra.x11.bindings.window_bindings import (
                constants,                      #@UnresolvedImport
                X11WindowBindings,          #@UnresolvedImport
                PropertyError)              #@UnresolvedImport
X11Window = X11WindowBindings()

from xpra.os_util import StringIOClass
from xpra.gtk_common.error import xsync, XError
from xpra.codecs.argb.argb import premultiply_argb_in_place #@UnresolvedImport