Edit File: pygtkcompat.py
# -*- Mode: Python; py-indent-offset: 4 -*- # vim: tabstop=4 shiftwidth=4 expandtab # # Copyright (C) 2011-2012 Johan Dahlin <johan@gnome.org> # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 # USA """ PyGTK compatibility layer. This modules goes a little bit longer to maintain PyGTK compatibility than the normal overrides system. It is recommended to not depend on this layer, but only use it as an intermediate step when porting your application to PyGI. Compatibility might never be 100%, but the aim is to make it possible to run a well behaved PyGTK application mostly unmodified on top of PyGI. """ import sys import warnings try: # Python 3 from collections import UserList UserList # pyflakes with warnings.catch_warnings(): warnings.simplefilter('ignore') from imp import reload except ImportError: # Python 2 ships that in a different module from UserList import UserList UserList # pyflakes import gi from gi.repository import GObject _patches = [] _module_patches = [] _unset = object() _enabled_registry = {} def _patch(obj, name, new_value): old_value = getattr(obj, name, _unset) setattr(obj, name, new_value) _patches.append((obj, name, old_value)) def _patch_module(name, new_value): old_value = sys.modules.get(name, _unset) sys.modules[name] = new_value _module_patches.append((name, old_value)) def _install_enums(module, dest=None, strip=''): if dest is None: dest = module modname = dest.__name__.rsplit('.', 1)[1].upper() for attr in dir(module): try: obj = getattr(module, attr, None) except: continue try: if issubclass(obj, GObject.GEnum): for value, enum in obj.__enum_values__.items(): name = enum.value_name name = name.replace(modname + '_', '') if strip and name.startswith(strip): name = name[len(strip):] _patch(dest, name, enum) except TypeError: continue try: if issubclass(obj, GObject.GFlags): for value, flag in obj.__flags_values__.items(): try: name = flag.value_names[-1].replace(modname + '_', '') except IndexError: # FIXME: this happens for some large flags which do not # fit into a long on 32 bit systems continue _patch(dest, name, flag) except TypeError: continue def _check_enabled(name, version=None): """Returns True in case it is already enabled""" if name in _enabled_registry: enabled_version = _enabled_registry[name] if enabled_version != version: raise ValueError( "%r already enabled with different version (%r)" % ( name, enabled_version)) return True else: _enabled_registry[name] = version return False def enable(): if _check_enabled(""): return # gobject from gi.repository import GLib _patch_module('glib', GLib) # gobject from gi.repository import GObject _patch_module('gobject', GObject) from gi import _propertyhelper _patch_module('gobject.propertyhelper', _propertyhelper) # gio from gi.repository import Gio _patch_module('gio', Gio) def _disable_all(): """Reverse all effects of the enable_xxx() calls except for require_version() calls and imports. """ _enabled_registry.clear() for obj, name, old_value in reversed(_patches): if old_value is _unset: delattr(obj, name) else: # try if deleting is enough (for override proxies) delattr(obj, name) if getattr(obj, name, _unset) is not old_value: setattr(obj, name, old_value) del _patches[:] for name, old_value in reversed(_module_patches): if old_value is _unset: del sys.modules[name] else: sys.modules[name] = old_value del _module_patches[:] reload(sys) if sys.version_info < (3, 0): sys.setdefaultencoding('ascii') def enable_gtk(version='3.0'): if _check_enabled("gtk", version): return if version == "4.0": raise ValueError("version 4.0 not supported") # set the default encoding like PyGTK reload(sys) if sys.version_info < (3, 0): sys.setdefaultencoding('utf-8') # atk gi.require_version('Atk', '1.0') from gi.repository import Atk _patch_module('atk', Atk) _install_enums(Atk) # pango gi.require_version('Pango', '1.0') from gi.repository import Pango _patch_module('pango', Pango) _install_enums(Pango) # pangocairo gi.require_version('PangoCairo', '1.0') from gi.repository import PangoCairo _patch_module('pangocairo', PangoCairo) # gdk gi.require_version('Gdk', version) gi.require_version('GdkPixbuf', '2.0') from gi.repository import Gdk from gi.repository import GdkPixbuf _patch_module('gtk.gdk', Gdk) _install_enums(Gdk) _install_enums(GdkPixbuf, dest=Gdk) _patch(Gdk, "_2BUTTON_PRESS", 5) _patch(Gdk, "BUTTON_PRESS", 4) _patch(Gdk, "screen_get_default", Gdk.Screen.get_default) _patch(Gdk, "Pixbuf", GdkPixbuf.Pixbuf) _patch(Gdk, "PixbufLoader", GdkPixbuf.PixbufLoader.new_with_type) _patch(Gdk, "pixbuf_new_from_data", GdkPixbuf.Pixbuf.new_from_data) _patch(Gdk, "pixbuf_new_from_file", GdkPixbuf.Pixbuf.new_from_file) try: _patch(Gdk, "pixbuf_new_from_file_at_scale", GdkPixbuf.Pixbuf.new_from_file_at_scale) except AttributeError: pass _patch(Gdk, "pixbuf_new_from_file_at_size", GdkPixbuf.Pixbuf.new_from_file_at_size) _patch(Gdk, "pixbuf_new_from_inline", GdkPixbuf.Pixbuf.new_from_inline) _patch(Gdk, "pixbuf_new_from_stream", GdkPixbuf.Pixbuf.new_from_stream) _patch(Gdk, "pixbuf_new_from_stream_at_scale", GdkPixbuf.Pixbuf.new_from_stream_at_scale) _patch(Gdk, "pixbuf_new_from_xpm_data", GdkPixbuf.Pixbuf.new_from_xpm_data) _patch(Gdk, "pixbuf_get_file_info", GdkPixbuf.Pixbuf.get_file_info) orig_get_formats = GdkPixbuf.Pixbuf.get_formats def get_formats(): formats = orig_get_formats() result = [] def make_dict(format_): result = {} result['description'] = format_.get_description() result['name'] = format_.get_name() result['mime_types'] = format_.get_mime_types() result['extensions'] = format_.get_extensions() return result for format_ in formats: result.append(make_dict(format_)) return result _patch(Gdk, "pixbuf_get_formats", get_formats) orig_get_frame_extents = Gdk.Window.get_frame_extents def get_frame_extents(window): try: try: rect = Gdk.Rectangle(0, 0, 0, 0) except TypeError: rect = Gdk.Rectangle() orig_get_frame_extents(window, rect) except TypeError: rect = orig_get_frame_extents(window) return rect _patch(Gdk.Window, "get_frame_extents", get_frame_extents) orig_get_origin = Gdk.Window.get_origin def get_origin(self): return orig_get_origin(self)[1:] _patch(Gdk.Window, "get_origin", get_origin) _patch(Gdk, "screen_width", Gdk.Screen.width) _patch(Gdk, "screen_height", Gdk.Screen.height) orig_gdk_window_get_geometry = Gdk.Window.get_geometry def gdk_window_get_geometry(window): return orig_gdk_window_get_geometry(window) + (window.get_visual().get_best_depth(),) _patch(Gdk.Window, "get_geometry", gdk_window_get_geometry) # gtk gi.require_version('Gtk', version) from gi.repository import Gtk _patch_module('gtk', Gtk) _patch(Gtk, "gdk", Gdk) _patch(Gtk, "pygtk_version", (2, 99, 0)) _patch(Gtk, "gtk_version", (Gtk.MAJOR_VERSION, Gtk.MINOR_VERSION, Gtk.MICRO_VERSION)) _install_enums(Gtk) # Action def set_tool_item_type(menuaction, gtype): warnings.warn('set_tool_item_type() is not supported', gi.PyGIDeprecationWarning, stacklevel=2) _patch(Gtk.Action, "set_tool_item_type", classmethod(set_tool_item_type)) # Alignment orig_Alignment = Gtk.Alignment class Alignment(orig_Alignment): def __init__(self, xalign=0.0, yalign=0.0, xscale=0.0, yscale=0.0): orig_Alignment.__init__(self) self.props.xalign = xalign self.props.yalign = yalign self.props.xscale = xscale self.props.yscale = yscale _patch(Gtk, "Alignment", Alignment) # Box orig_pack_end = Gtk.Box.pack_end def pack_end(self, child, expand=True, fill=True, padding=0): orig_pack_end(self, child, expand, fill, padding) _patch(Gtk.Box, "pack_end", pack_end) orig_pack_start = Gtk.Box.pack_start def pack_start(self, child, expand=True, fill=True, padding=0): orig_pack_start(self, child, expand, fill, padding) _patch(Gtk.Box, "pack_start", pack_start) # TreeViewColumn orig_tree_view_column_pack_end = Gtk.TreeViewColumn.pack_end def tree_view_column_pack_end(self, cell, expand=True): orig_tree_view_column_pack_end(self, cell, expand) _patch(Gtk.TreeViewColumn, "pack_end", tree_view_column_pack_end) orig_tree_view_column_pack_start = Gtk.TreeViewColumn.pack_start def tree_view_column_pack_start(self, cell, expand=True): orig_tree_view_column_pack_start(self, cell, expand) _patch(Gtk.TreeViewColumn, "pack_start", tree_view_column_pack_start) # CellLayout orig_cell_pack_end = Gtk.CellLayout.pack_end def cell_pack_end(self, cell, expand=True): orig_cell_pack_end(self, cell, expand) _patch(Gtk.CellLayout, "pack_end", cell_pack_end) orig_cell_pack_start = Gtk.CellLayout.pack_start def cell_pack_start(self, cell, expand=True): orig_cell_pack_start(self, cell, expand) _patch(Gtk.CellLayout, "pack_start", cell_pack_start) orig_set_cell_data_func = Gtk.CellLayout.set_cell_data_func def set_cell_data_func(self, cell, func, user_data=_unset): def callback(*args): if args[-1] == _unset: args = args[:-1] return func(*args) orig_set_cell_data_func(self, cell, callback, user_data) _patch(Gtk.CellLayout, "set_cell_data_func", set_cell_data_func) # CellRenderer class GenericCellRenderer(Gtk.CellRenderer): pass _patch(Gtk, "GenericCellRenderer", GenericCellRenderer) # ComboBox orig_combo_row_separator_func = Gtk.ComboBox.set_row_separator_func def combo_row_separator_func(self, func, user_data=_unset): def callback(*args): if args[-1] == _unset: args = args[:-1] return func(*args) orig_combo_row_separator_func(self, callback, user_data) _patch(Gtk.ComboBox, "set_row_separator_func", combo_row_separator_func) # ComboBoxEntry class ComboBoxEntry(Gtk.ComboBox): def __init__(self, **kwds): Gtk.ComboBox.__init__(self, has_entry=True, **kwds) def set_text_column(self, text_column): self.set_entry_text_column(text_column) def get_text_column(self): return self.get_entry_text_column() _patch(Gtk, "ComboBoxEntry", ComboBoxEntry) def combo_box_entry_new(): return Gtk.ComboBoxEntry() _patch(Gtk, "combo_box_entry_new", combo_box_entry_new) def combo_box_entry_new_with_model(model): return Gtk.ComboBoxEntry(model=model) _patch(Gtk, "combo_box_entry_new_with_model", combo_box_entry_new_with_model) # Container def install_child_property(container, flag, pspec): warnings.warn('install_child_property() is not supported', gi.PyGIDeprecationWarning, stacklevel=2) _patch(Gtk.Container, "install_child_property", classmethod(install_child_property)) def new_text(): combo = Gtk.ComboBox() model = Gtk.ListStore(str) combo.set_model(model) combo.set_entry_text_column(0) return combo _patch(Gtk, "combo_box_new_text", new_text) def append_text(self, text): model = self.get_model() model.append([text]) _patch(Gtk.ComboBox, "append_text", append_text) _patch(Gtk, "expander_new_with_mnemonic", Gtk.Expander.new_with_mnemonic) _patch(Gtk, "icon_theme_get_default", Gtk.IconTheme.get_default) _patch(Gtk, "image_new_from_pixbuf", Gtk.Image.new_from_pixbuf) _patch(Gtk, "image_new_from_stock", Gtk.Image.new_from_stock) _patch(Gtk, "image_new_from_animation", Gtk.Image.new_from_animation) _patch(Gtk, "image_new_from_icon_set", Gtk.Image.new_from_icon_set) _patch(Gtk, "image_new_from_file", Gtk.Image.new_from_file) _patch(Gtk, "settings_get_default", Gtk.Settings.get_default) _patch(Gtk, "window_set_default_icon", Gtk.Window.set_default_icon) try: _patch(Gtk, "clipboard_get", Gtk.Clipboard.get) except AttributeError: pass # AccelGroup _patch(Gtk.AccelGroup, "connect_group", Gtk.AccelGroup.connect) # StatusIcon _patch(Gtk, "status_icon_position_menu", Gtk.StatusIcon.position_menu) _patch(Gtk.StatusIcon, "set_tooltip", Gtk.StatusIcon.set_tooltip_text) # Scale orig_HScale = Gtk.HScale orig_VScale = Gtk.VScale class HScale(orig_HScale): def __init__(self, adjustment=None): orig_HScale.__init__(self, adjustment=adjustment) _patch(Gtk, "HScale", HScale) class VScale(orig_VScale): def __init__(self, adjustment=None): orig_VScale.__init__(self, adjustment=adjustment) _patch(Gtk, "VScale", VScale) _patch(Gtk, "stock_add", lambda items: None) # Widget _patch(Gtk.Widget, "window", property(fget=Gtk.Widget.get_window)) _patch(Gtk, "widget_get_default_direction", Gtk.Widget.get_default_direction) orig_size_request = Gtk.Widget.size_request def size_request(widget): class SizeRequest(UserList): def __init__(self, req): self.height = req.height self.width = req.width UserList.__init__(self, [self.width, self.height]) return SizeRequest(orig_size_request(widget)) _patch(Gtk.Widget, "size_request", size_request) _patch(Gtk.Widget, "hide_all", Gtk.Widget.hide) class BaseGetter(object): def __init__(self, context): self.context = context def __getitem__(self, state): color = self.context.get_background_color(state) return Gdk.Color(red=int(color.red * 65535), green=int(color.green * 65535), blue=int(color.blue * 65535)) class Styles(object): def __init__(self, widget): context = widget.get_style_context() self.base = BaseGetter(context) self.black = Gdk.Color(red=0, green=0, blue=0) class StyleDescriptor(object): def __get__(self, instance, class_): return Styles(instance) _patch(Gtk.Widget, "style", StyleDescriptor()) # TextView orig_text_view_scroll_to_mark = Gtk.TextView.scroll_to_mark def text_view_scroll_to_mark(self, mark, within_margin, use_align=False, xalign=0.5, yalign=0.5): return orig_text_view_scroll_to_mark(self, mark, within_margin, use_align, xalign, yalign) _patch(Gtk.TextView, "scroll_to_mark", text_view_scroll_to_mark) # Window orig_set_geometry_hints = Gtk.Window.set_geometry_hints def set_geometry_hints(self, geometry_widget=None, min_width=-1, min_height=-1, max_width=-1, max_height=-1, base_width=-1, base_height=-1, width_inc=-1, height_inc=-1, min_aspect=-1.0, max_aspect=-1.0): geometry = Gdk.Geometry() geom_mask = Gdk.WindowHints(0) if min_width >= 0 or min_height >= 0: geometry.min_width = max(min_width, 0) geometry.min_height = max(min_height, 0) geom_mask |= Gdk.WindowHints.MIN_SIZE if max_width >= 0 or max_height >= 0: geometry.max_width = max(max_width, 0) geometry.max_height = max(max_height, 0) geom_mask |= Gdk.WindowHints.MAX_SIZE if base_width >= 0 or base_height >= 0: geometry.base_width = max(base_width, 0) geometry.base_height = max(base_height, 0) geom_mask |= Gdk.WindowHints.BASE_SIZE if width_inc >= 0 or height_inc >= 0: geometry.width_inc = max(width_inc, 0) geometry.height_inc = max(height_inc, 0) geom_mask |= Gdk.WindowHints.RESIZE_INC if min_aspect >= 0.0 or max_aspect >= 0.0: if min_aspect <= 0.0 or max_aspect <= 0.0: raise TypeError("aspect ratios must be positive") geometry.min_aspect = min_aspect geometry.max_aspect = max_aspect geom_mask |= Gdk.WindowHints.ASPECT return orig_set_geometry_hints(self, geometry_widget, geometry, geom_mask) _patch(Gtk.Window, "set_geometry_hints", set_geometry_hints) _patch(Gtk, "window_list_toplevels", Gtk.Window.list_toplevels) _patch(Gtk, "window_set_default_icon_name", Gtk.Window.set_default_icon_name) # gtk.unixprint class UnixPrint(object): pass unixprint = UnixPrint() _patch_module('gtkunixprint', unixprint) # gtk.keysyms with warnings.catch_warnings(): warnings.simplefilter('ignore', category=RuntimeWarning) from gi.overrides import keysyms _patch_module('gtk.keysyms', keysyms) _patch(Gtk, "keysyms", keysyms) from . import generictreemodel _patch(Gtk, "GenericTreeModel", generictreemodel.GenericTreeModel) def enable_vte(): if _check_enabled("vte"): return gi.require_version('Vte', '0.0') from gi.repository import Vte _patch_module('vte', Vte) def enable_poppler(): if _check_enabled("poppler"): return gi.require_version('Poppler', '0.18') from gi.repository import Poppler _patch_module('poppler', Poppler) _patch(Poppler, "pypoppler_version", (1, 0, 0)) def enable_webkit(version='1.0'): if _check_enabled("webkit", version): return gi.require_version('WebKit', version) from gi.repository import WebKit _patch_module('webkit', WebKit) _patch(WebKit.WebView, "get_web_inspector", WebKit.WebView.get_inspector) def enable_gudev(): if _check_enabled("gudev"): return gi.require_version('GUdev', '1.0') from gi.repository import GUdev _patch_module('gudev', GUdev) def enable_gst(): if _check_enabled("gst"): return gi.require_version('Gst', '0.10') from gi.repository import Gst _patch_module('gst', Gst) _install_enums(Gst) _patch(Gst, "registry_get_default", Gst.Registry.get_default) _patch(Gst, "element_register", Gst.Element.register) _patch(Gst, "element_factory_make", Gst.ElementFactory.make) _patch(Gst, "caps_new_any", Gst.Caps.new_any) _patch(Gst, "get_pygst_version", lambda: (0, 10, 19)) _patch(Gst, "get_gst_version", lambda: (0, 10, 40)) from gi.repository import GstInterfaces _patch_module('gst.interfaces', GstInterfaces) _install_enums(GstInterfaces) from gi.repository import GstAudio _patch_module('gst.audio', GstAudio) _install_enums(GstAudio) from gi.repository import GstVideo _patch_module('gst.video', GstVideo) _install_enums(GstVideo) from gi.repository import GstBase _patch_module('gst.base', GstBase) _install_enums(GstBase) _patch(Gst, "BaseTransform", GstBase.BaseTransform) _patch(Gst, "BaseSink", GstBase.BaseSink) from gi.repository import GstController _patch_module('gst.controller', GstController) _install_enums(GstController, dest=Gst) from gi.repository import GstPbutils _patch_module('gst.pbutils', GstPbutils) _install_enums(GstPbutils) def enable_goocanvas(): if _check_enabled("goocanvas"): return gi.require_version('GooCanvas', '2.0') from gi.repository import GooCanvas _patch_module('goocanvas', GooCanvas) _install_enums(GooCanvas, strip='GOO_CANVAS_') _patch(GooCanvas, "ItemSimple", GooCanvas.CanvasItemSimple) _patch(GooCanvas, "Item", GooCanvas.CanvasItem) _patch(GooCanvas, "Image", GooCanvas.CanvasImage) _patch(GooCanvas, "Group", GooCanvas.CanvasGroup) _patch(GooCanvas, "Rect", GooCanvas.CanvasRect)
Back to File Manager