629 lines
20 KiB
Python
629 lines
20 KiB
Python
# -*- 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
|
|
from collections import UserList
|
|
|
|
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():
|
|
warnings.warn("pygtkcompat is deprecated, see https://pygobject.gnome.org for migration instructions", gi.PyGIDeprecationWarning)
|
|
|
|
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[:]
|
|
|
|
|
|
def enable_gtk(version='3.0'):
|
|
if _check_enabled("gtk", version):
|
|
return
|
|
|
|
if version == "4.0":
|
|
raise ValueError("version 4.0 not supported")
|
|
|
|
# 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)
|
|
_patch(Gdk, "pixbuf_new_from_file_at_scale", GdkPixbuf.Pixbuf.new_from_file_at_scale)
|
|
_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_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)
|
|
_patch(Gtk, "clipboard_get", Gtk.Clipboard.get)
|
|
|
|
# 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)
|