gi/overrides/GObject.py

   1 # -*- Mode: Python; py-indent-offset: 4 -*-
   2 # vim: tabstop=4 shiftwidth=4 expandtab
   3 #
   4 # Copyright (C) 2012 Canonical Ltd.
   5 # Author: Martin Pitt <martin.pitt@ubuntu.com>
   6 # Copyright (C) 2012-2013 Simon Feltman <sfeltman@src.gnome.org>
   7 # Copyright (C) 2012 Bastian Winkler <buz@netbuz.org>
   8 #
   9 # This library is free software; you can redistribute it and/or
  10 # modify it under the terms of the GNU Lesser General Public
  11 # License as published by the Free Software Foundation; either
  12 # version 2.1 of the License, or (at your option) any later version.
  13 #
  14 # This library is distributed in the hope that it will be useful,
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 # Lesser General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU Lesser General Public
  20 # License along with this library; if not, write to the Free Software
  21 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
  22 # USA
  23
  24 import sys
  25 import warnings
  26 from collections import namedtuple
  27
  28 import gi.overrides
  29 import gi.module
  30 from gi.overrides import override
  31 from gi.repository import GLib
  32 from gi import PyGIDeprecationWarning
  33
  34 from gi import _propertyhelper as propertyhelper
  35 from gi import _signalhelper as signalhelper
  36
  37 _gobject = gi._gi._gobject
  38
  39 GObjectModule = gi.module.get_introspection_module('GObject')
  40
  41 __all__ = []
  42
  43
  44 from gi import _option as option
  45 sys.modules['gi._gobject.option'] = option
  46
  47
  48 # API aliases for backwards compatibility
  49 for name in ['markup_escape_text', 'get_application_name',
  50              'set_application_name', 'get_prgname', 'set_prgname',
  51              'main_depth', 'filename_display_basename',
  52              'filename_display_name', 'filename_from_utf8',
  53              'uri_list_extract_uris',
  54              'MainLoop', 'MainContext', 'main_context_default',
  55              'source_remove', 'Source', 'Idle', 'Timeout', 'PollFD',
  56              'idle_add', 'timeout_add', 'timeout_add_seconds',
  57              'io_add_watch', 'child_watch_add', 'get_current_time',
  58              'spawn_async']:
  59     globals()[name] = gi.overrides.deprecated(getattr(GLib, name), 'GLib.' + name)
  60     __all__.append(name)
  61
  62 # constants are also deprecated, but cannot mark them as such
  63 for name in ['PRIORITY_DEFAULT', 'PRIORITY_DEFAULT_IDLE', 'PRIORITY_HIGH',
  64              'PRIORITY_HIGH_IDLE', 'PRIORITY_LOW',
  65              'IO_IN', 'IO_OUT', 'IO_PRI', 'IO_ERR', 'IO_HUP', 'IO_NVAL',
  66              'IO_STATUS_ERROR', 'IO_STATUS_NORMAL', 'IO_STATUS_EOF',
  67              'IO_STATUS_AGAIN', 'IO_FLAG_APPEND', 'IO_FLAG_NONBLOCK',
  68              'IO_FLAG_IS_READABLE', 'IO_FLAG_IS_WRITEABLE',
  69              'IO_FLAG_IS_SEEKABLE', 'IO_FLAG_MASK', 'IO_FLAG_GET_MASK',
  70              'IO_FLAG_SET_MASK',
  71              'SPAWN_LEAVE_DESCRIPTORS_OPEN', 'SPAWN_DO_NOT_REAP_CHILD',
  72              'SPAWN_SEARCH_PATH', 'SPAWN_STDOUT_TO_DEV_NULL',
  73              'SPAWN_STDERR_TO_DEV_NULL', 'SPAWN_CHILD_INHERITS_STDIN',
  74              'SPAWN_FILE_AND_ARGV_ZERO',
  75              'OPTION_FLAG_HIDDEN', 'OPTION_FLAG_IN_MAIN', 'OPTION_FLAG_REVERSE',
  76              'OPTION_FLAG_NO_ARG', 'OPTION_FLAG_FILENAME', 'OPTION_FLAG_OPTIONAL_ARG',
  77              'OPTION_FLAG_NOALIAS', 'OPTION_ERROR_UNKNOWN_OPTION',
  78              'OPTION_ERROR_BAD_VALUE', 'OPTION_ERROR_FAILED', 'OPTION_REMAINING',
  79              'glib_version']:
  80     globals()[name] = getattr(GLib, name)
  81     __all__.append(name)
  82
  83
  84 G_MININT8 = GLib.MININT8
  85 G_MAXINT8 = GLib.MAXINT8
  86 G_MAXUINT8 = GLib.MAXUINT8
  87 G_MININT16 = GLib.MININT16
  88 G_MAXINT16 = GLib.MAXINT16
  89 G_MAXUINT16 = GLib.MAXUINT16
  90 G_MININT32 = GLib.MININT32
  91 G_MAXINT32 = GLib.MAXINT32
  92 G_MAXUINT32 = GLib.MAXUINT32
  93 G_MININT64 = GLib.MININT64
  94 G_MAXINT64 = GLib.MAXINT64
  95 G_MAXUINT64 = GLib.MAXUINT64
  96 __all__ += ['G_MININT8', 'G_MAXINT8', 'G_MAXUINT8', 'G_MININT16',
  97             'G_MAXINT16', 'G_MAXUINT16', 'G_MININT32', 'G_MAXINT32',
  98             'G_MAXUINT32', 'G_MININT64', 'G_MAXINT64', 'G_MAXUINT64']
  99
 100 # these are not currently exported in GLib gir, presumably because they are
 101 # platform dependent; so get them from our static bindings
 102 for name in ['G_MINFLOAT', 'G_MAXFLOAT', 'G_MINDOUBLE', 'G_MAXDOUBLE',
 103              'G_MINSHORT', 'G_MAXSHORT', 'G_MAXUSHORT', 'G_MININT', 'G_MAXINT',
 104              'G_MAXUINT', 'G_MINLONG', 'G_MAXLONG', 'G_MAXULONG', 'G_MAXSIZE',
 105              'G_MINSSIZE', 'G_MAXSSIZE', 'G_MINOFFSET', 'G_MAXOFFSET']:
 106     globals()[name] = getattr(_gobject, name)
 107     __all__.append(name)
 108
 109
 110 TYPE_INVALID = GObjectModule.type_from_name('invalid')
 111 TYPE_NONE = GObjectModule.type_from_name('void')
 112 TYPE_INTERFACE = GObjectModule.type_from_name('GInterface')
 113 TYPE_CHAR = GObjectModule.type_from_name('gchar')
 114 TYPE_UCHAR = GObjectModule.type_from_name('guchar')
 115 TYPE_BOOLEAN = GObjectModule.type_from_name('gboolean')
 116 TYPE_INT = GObjectModule.type_from_name('gint')
 117 TYPE_UINT = GObjectModule.type_from_name('guint')
 118 TYPE_LONG = GObjectModule.type_from_name('glong')
 119 TYPE_ULONG = GObjectModule.type_from_name('gulong')
 120 TYPE_INT64 = GObjectModule.type_from_name('gint64')
 121 TYPE_UINT64 = GObjectModule.type_from_name('guint64')
 122 TYPE_ENUM = GObjectModule.type_from_name('GEnum')
 123 TYPE_FLAGS = GObjectModule.type_from_name('GFlags')
 124 TYPE_FLOAT = GObjectModule.type_from_name('gfloat')
 125 TYPE_DOUBLE = GObjectModule.type_from_name('gdouble')
 126 TYPE_STRING = GObjectModule.type_from_name('gchararray')
 127 TYPE_POINTER = GObjectModule.type_from_name('gpointer')
 128 TYPE_BOXED = GObjectModule.type_from_name('GBoxed')
 129 TYPE_PARAM = GObjectModule.type_from_name('GParam')
 130 TYPE_OBJECT = GObjectModule.type_from_name('GObject')
 131 TYPE_PYOBJECT = GObjectModule.type_from_name('PyObject')
 132 TYPE_GTYPE = GObjectModule.type_from_name('GType')
 133 TYPE_STRV = GObjectModule.type_from_name('GStrv')
 134 TYPE_VARIANT = GObjectModule.type_from_name('GVariant')
 135 TYPE_GSTRING = GObjectModule.type_from_name('GString')
 136 TYPE_VALUE = GObjectModule.Value.__gtype__
 137 TYPE_UNICHAR = TYPE_UINT
 138 __all__ += ['TYPE_INVALID', 'TYPE_NONE', 'TYPE_INTERFACE', 'TYPE_CHAR',
 139             'TYPE_UCHAR', 'TYPE_BOOLEAN', 'TYPE_INT', 'TYPE_UINT', 'TYPE_LONG',
 140             'TYPE_ULONG', 'TYPE_INT64', 'TYPE_UINT64', 'TYPE_ENUM', 'TYPE_FLAGS',
 141             'TYPE_FLOAT', 'TYPE_DOUBLE', 'TYPE_STRING', 'TYPE_POINTER',
 142             'TYPE_BOXED', 'TYPE_PARAM', 'TYPE_OBJECT', 'TYPE_PYOBJECT',
 143             'TYPE_GTYPE', 'TYPE_STRV', 'TYPE_VARIANT', 'TYPE_GSTRING',
 144             'TYPE_UNICHAR', 'TYPE_VALUE']
 145
 146
 147 # Deprecated, use GLib directly
 148 Pid = GLib.Pid
 149 GError = GLib.GError
 150 OptionGroup = GLib.OptionGroup
 151 OptionContext = GLib.OptionContext
 152 __all__ += ['Pid', 'GError', 'OptionGroup', 'OptionContext']
 153
 154
 155 # Deprecated, use: GObject.ParamFlags.* directly
 156 PARAM_CONSTRUCT = GObjectModule.ParamFlags.CONSTRUCT
 157 PARAM_CONSTRUCT_ONLY = GObjectModule.ParamFlags.CONSTRUCT_ONLY
 158 PARAM_LAX_VALIDATION = GObjectModule.ParamFlags.LAX_VALIDATION
 159 PARAM_READABLE = GObjectModule.ParamFlags.READABLE
 160 PARAM_WRITABLE = GObjectModule.ParamFlags.WRITABLE
 161 # PARAM_READWRITE should come from the gi module but cannot due to:
 162 # https://bugzilla.gnome.org/show_bug.cgi?id=687615
 163 PARAM_READWRITE = PARAM_READABLE | PARAM_WRITABLE
 164 __all__ += ['PARAM_CONSTRUCT', 'PARAM_CONSTRUCT_ONLY', 'PARAM_LAX_VALIDATION',
 165             'PARAM_READABLE', 'PARAM_WRITABLE', 'PARAM_READWRITE']
 166
 167
 168 # Deprecated, use: GObject.SignalFlags.* directly
 169 SIGNAL_ACTION = GObjectModule.SignalFlags.ACTION
 170 SIGNAL_DETAILED = GObjectModule.SignalFlags.DETAILED
 171 SIGNAL_NO_HOOKS = GObjectModule.SignalFlags.NO_HOOKS
 172 SIGNAL_NO_RECURSE = GObjectModule.SignalFlags.NO_RECURSE
 173 SIGNAL_RUN_CLEANUP = GObjectModule.SignalFlags.RUN_CLEANUP
 174 SIGNAL_RUN_FIRST = GObjectModule.SignalFlags.RUN_FIRST
 175 SIGNAL_RUN_LAST = GObjectModule.SignalFlags.RUN_LAST
 176 __all__ += ['SIGNAL_ACTION', 'SIGNAL_DETAILED', 'SIGNAL_NO_HOOKS',
 177             'SIGNAL_NO_RECURSE', 'SIGNAL_RUN_CLEANUP', 'SIGNAL_RUN_FIRST',
 178             'SIGNAL_RUN_LAST']
 179
 180
 181 # Static types
 182 GBoxed = _gobject.GBoxed
 183 GEnum = _gobject.GEnum
 184 GFlags = _gobject.GFlags
 185 GInterface = _gobject.GInterface
 186 GObject = _gobject.GObject
 187 GObjectWeakRef = _gobject.GObjectWeakRef
 188 GParamSpec = _gobject.GParamSpec
 189 GPointer = _gobject.GPointer
 190 GType = _gobject.GType
 191 Warning = _gobject.Warning
 192 __all__ += ['GBoxed', 'GEnum', 'GFlags', 'GInterface', 'GObject',
 193             'GObjectWeakRef', 'GParamSpec', 'GPointer', 'GType',
 194             'Warning']
 195
 196
 197 features = _gobject.features
 198 list_properties = _gobject.list_properties
 199 new = _gobject.new
 200 pygobject_version = _gobject.pygobject_version
 201 threads_init = GLib.threads_init
 202 type_register = _gobject.type_register
 203 __all__ += ['features', 'list_properties', 'new',
 204             'pygobject_version', 'threads_init', 'type_register']
 205
 206
 207 class Value(GObjectModule.Value):
 208     def __init__(self, value_type=None, py_value=None):
 209         GObjectModule.Value.__init__(self)
 210         if value_type is not None:
 211             self.init(value_type)
 212             if py_value is not None:
 213                 self.set_value(py_value)
 214
 215     def __del__(self):
 216         if self._free_on_dealloc and self.g_type != TYPE_INVALID:
 217             self.unset()
 218
 219     def set_boxed(self, boxed):
 220         # Workaround the introspection marshalers inability to know
 221         # these methods should be marshaling boxed types. This is because
 222         # the type information is stored on the GValue.
 223         _gobject._gvalue_set(self, boxed)
 224
 225     def get_boxed(self):
 226         return _gobject._gvalue_get(self)
 227
 228     def set_value(self, py_value):
 229         gtype = self.g_type
 230
 231         if gtype == _gobject.TYPE_INVALID:
 232             raise TypeError("GObject.Value needs to be initialized first")
 233         elif gtype == TYPE_BOOLEAN:
 234             self.set_boolean(py_value)
 235         elif gtype == TYPE_CHAR:
 236             self.set_char(py_value)
 237         elif gtype == TYPE_UCHAR:
 238             self.set_uchar(py_value)
 239         elif gtype == TYPE_INT:
 240             self.set_int(py_value)
 241         elif gtype == TYPE_UINT:
 242             self.set_uint(py_value)
 243         elif gtype == TYPE_LONG:
 244             self.set_long(py_value)
 245         elif gtype == TYPE_ULONG:
 246             self.set_ulong(py_value)
 247         elif gtype == TYPE_INT64:
 248             self.set_int64(py_value)
 249         elif gtype == TYPE_UINT64:
 250             self.set_uint64(py_value)
 251         elif gtype == TYPE_FLOAT:
 252             self.set_float(py_value)
 253         elif gtype == TYPE_DOUBLE:
 254             self.set_double(py_value)
 255         elif gtype == TYPE_STRING:
 256             if isinstance(py_value, str):
 257                 py_value = str(py_value)
 258             elif sys.version_info < (3, 0):
 259                 if isinstance(py_value, unicode):
 260                     py_value = py_value.encode('UTF-8')
 261                 else:
 262                     raise ValueError("Expected string or unicode but got %s%s" %
 263                                      (py_value, type(py_value)))
 264             else:
 265                 raise ValueError("Expected string but got %s%s" %
 266                                  (py_value, type(py_value)))
 267             self.set_string(py_value)
 268         elif gtype == TYPE_PARAM:
 269             self.set_param(py_value)
 270         elif gtype.is_a(TYPE_ENUM):
 271             self.set_enum(py_value)
 272         elif gtype.is_a(TYPE_FLAGS):
 273             self.set_flags(py_value)
 274         elif gtype.is_a(TYPE_BOXED):
 275             self.set_boxed(py_value)
 276         elif gtype == TYPE_POINTER:
 277             self.set_pointer(py_value)
 278         elif gtype.is_a(TYPE_OBJECT):
 279             self.set_object(py_value)
 280         elif gtype == TYPE_UNICHAR:
 281             self.set_uint(int(py_value))
 282         # elif gtype == TYPE_OVERRIDE:
 283         #     pass
 284         elif gtype == TYPE_GTYPE:
 285             self.set_gtype(py_value)
 286         elif gtype == TYPE_VARIANT:
 287             self.set_variant(py_value)
 288         elif gtype == TYPE_PYOBJECT:
 289             self.set_boxed(py_value)
 290         else:
 291             raise TypeError("Unknown value type %s" % gtype)
 292
 293     def get_value(self):
 294         gtype = self.g_type
 295
 296         if gtype == TYPE_BOOLEAN:
 297             return self.get_boolean()
 298         elif gtype == TYPE_CHAR:
 299             return self.get_char()
 300         elif gtype == TYPE_UCHAR:
 301             return self.get_uchar()
 302         elif gtype == TYPE_INT:
 303             return self.get_int()
 304         elif gtype == TYPE_UINT:
 305             return self.get_uint()
 306         elif gtype == TYPE_LONG:
 307             return self.get_long()
 308         elif gtype == TYPE_ULONG:
 309             return self.get_ulong()
 310         elif gtype == TYPE_INT64:
 311             return self.get_int64()
 312         elif gtype == TYPE_UINT64:
 313             return self.get_uint64()
 314         elif gtype == TYPE_FLOAT:
 315             return self.get_float()
 316         elif gtype == TYPE_DOUBLE:
 317             return self.get_double()
 318         elif gtype == TYPE_STRING:
 319             return self.get_string()
 320         elif gtype == TYPE_PARAM:
 321             return self.get_param()
 322         elif gtype.is_a(TYPE_ENUM):
 323             return self.get_enum()
 324         elif gtype.is_a(TYPE_FLAGS):
 325             return self.get_flags()
 326         elif gtype.is_a(TYPE_BOXED):
 327             return self.get_boxed()
 328         elif gtype == TYPE_POINTER:
 329             return self.get_pointer()
 330         elif gtype.is_a(TYPE_OBJECT):
 331             return self.get_object()
 332         elif gtype == TYPE_UNICHAR:
 333             return self.get_uint()
 334         elif gtype == TYPE_GTYPE:
 335             return self.get_gtype()
 336         elif gtype == TYPE_VARIANT:
 337             return self.get_variant()
 338         elif gtype == TYPE_PYOBJECT:
 339             pass
 340         else:
 341             return None
 342
 343     def __repr__(self):
 344         return '<Value (%s) %s>' % (self.g_type.name, self.get_value())
 345
 346 Value = override(Value)
 347 __all__.append('Value')
 348
 349
 350 def type_from_name(name):
 351     type_ = GObjectModule.type_from_name(name)
 352     if type_ == TYPE_INVALID:
 353         raise RuntimeError('unknown type name: %s' % name)
 354     return type_
 355
 356 __all__.append('type_from_name')
 357
 358
 359 def type_parent(type_):
 360     parent = GObjectModule.type_parent(type_)
 361     if parent == TYPE_INVALID:
 362         raise RuntimeError('no parent for type')
 363     return parent
 364
 365 __all__.append('type_parent')
 366
 367
 368 def _validate_type_for_signal_method(type_):
 369     if hasattr(type_, '__gtype__'):
 370         type_ = type_.__gtype__
 371     if not type_.is_instantiatable() and not type_.is_interface():
 372         raise TypeError('type must be instantiable or an interface, got %s' % type_)
 373
 374
 375 def signal_list_ids(type_):
 376     _validate_type_for_signal_method(type_)
 377     return GObjectModule.signal_list_ids(type_)
 378
 379 __all__.append('signal_list_ids')
 380
 381
 382 def signal_list_names(type_):
 383     ids = signal_list_ids(type_)
 384     return tuple(GObjectModule.signal_name(i) for i in ids)
 385
 386 __all__.append('signal_list_names')
 387
 388
 389 def signal_lookup(name, type_):
 390     _validate_type_for_signal_method(type_)
 391     return GObjectModule.signal_lookup(name, type_)
 392
 393 __all__.append('signal_lookup')
 394
 395
 396 def signal_query(id_or_name, type_=None):
 397     SignalQuery = namedtuple('SignalQuery',
 398                              ['signal_id',
 399                               'signal_name',
 400                               'itype',
 401                               'signal_flags',
 402                               'return_type',
 403                               # n_params',
 404                               'param_types'])
 405
 406     # signal_query needs to use a static method until the following bugs are fixed:
 407     # https://bugzilla.gnome.org/show_bug.cgi?id=687550
 408     # https://bugzilla.gnome.org/show_bug.cgi?id=687545
 409     # https://bugzilla.gnome.org/show_bug.cgi?id=687541
 410     if type_ is not None:
 411         id_or_name = signal_lookup(id_or_name, type_)
 412
 413     res = _gobject.signal_query(id_or_name)
 414     if res is None:
 415         return None
 416
 417     # Return a named tuple which allows indexing like the static bindings
 418     # along with field like access of the gi struct.
 419     # Note however that the n_params was not returned from the static bindings.
 420     return SignalQuery(*res)
 421
 422 __all__.append('signal_query')
 423
 424
 425 class _HandlerBlockManager(object):
 426     def __init__(self, obj, handler_id):
 427         self.obj = obj
 428         self.handler_id = handler_id
 429
 430     def __enter__(self):
 431         pass
 432
 433     def __exit__(self, exc_type, exc_value, traceback):
 434         GObjectModule.signal_handler_unblock(self.obj, self.handler_id)
 435
 436
 437 def signal_handler_block(obj, handler_id):
 438     """Blocks the signal handler from being invoked until
 439     handler_unblock() is called.
 440
 441     :param GObject.Object obj:
 442         Object instance to block handlers for.
 443     :param int handler_id:
 444         Id of signal to block.
 445     :returns:
 446         A context manager which optionally can be used to
 447         automatically unblock the handler:
 448
 449     .. code-block:: python
 450
 451         with GObject.signal_handler_block(obj, id):
 452             pass
 453     """
 454     GObjectModule.signal_handler_block(obj, handler_id)
 455     return _HandlerBlockManager(obj, handler_id)
 456
 457 __all__.append('signal_handler_block')
 458
 459
 460 def signal_parse_name(detailed_signal, itype, force_detail_quark):
 461     """Parse a detailed signal name into (signal_id, detail).
 462
 463     :param str detailed_signal:
 464         Signal name which can include detail.
 465         For example: "notify:prop_name"
 466     :returns:
 467         Tuple of (signal_id, detail)
 468     :raises ValueError:
 469         If the given signal is unknown.
 470     """
 471     res, signal_id, detail = GObjectModule.signal_parse_name(detailed_signal, itype,
 472                                                              force_detail_quark)
 473     if res:
 474         return signal_id, detail
 475     else:
 476         raise ValueError('%s: unknown signal name: %s' % (itype, detailed_signal))
 477
 478 __all__.append('signal_parse_name')
 479
 480
 481 def remove_emission_hook(obj, detailed_signal, hook_id):
 482     signal_id, detail = signal_parse_name(detailed_signal, obj, True)
 483     GObjectModule.signal_remove_emission_hook(signal_id, hook_id)
 484
 485 __all__.append('remove_emission_hook')
 486
 487
 488 # GObject accumulators with pure Python implementations
 489 # These return a tuple of (continue_emission, accumulation_result)
 490
 491 def signal_accumulator_first_wins(ihint, return_accu, handler_return, user_data=None):
 492     # Stop emission but return the result of the last handler
 493     return (False, handler_return)
 494
 495 __all__.append('signal_accumulator_first_wins')
 496
 497
 498 def signal_accumulator_true_handled(ihint, return_accu, handler_return, user_data=None):
 499     # Stop emission if the last handler returns True
 500     return (not handler_return, handler_return)
 501
 502 __all__.append('signal_accumulator_true_handled')
 503
 504
 505 # Statically bound signal functions which need to clobber GI (for now)
 506
 507 add_emission_hook = _gobject.add_emission_hook
 508 signal_new = _gobject.signal_new
 509
 510 __all__ += ['add_emission_hook', 'signal_new']
 511
 512
 513 class _FreezeNotifyManager(object):
 514     def __init__(self, obj):
 515         self.obj = obj
 516
 517     def __enter__(self):
 518         pass
 519
 520     def __exit__(self, exc_type, exc_value, traceback):
 521         self.obj.thaw_notify()
 522
 523
 524 def _signalmethod(func):
 525     # Function wrapper for signal functions used as instance methods.
 526     # This is needed when the signal functions come directly from GI.
 527     # (they are not already wrapped)
 528     @gi.overrides.wraps(func)
 529     def meth(*args, **kwargs):
 530         return func(*args, **kwargs)
 531     return meth
 532
 533
 534 class Object(GObjectModule.Object):
 535     def _unsupported_method(self, *args, **kargs):
 536         raise RuntimeError('This method is currently unsupported.')
 537
 538     def _unsupported_data_method(self, *args, **kargs):
 539         raise RuntimeError('Data access methods are unsupported. '
 540                            'Use normal Python attributes instead')
 541
 542     # Generic data methods are not needed in python as it can be handled
 543     # with standard attribute access: https://bugzilla.gnome.org/show_bug.cgi?id=641944
 544     get_data = _unsupported_data_method
 545     get_qdata = _unsupported_data_method
 546     set_data = _unsupported_data_method
 547     steal_data = _unsupported_data_method
 548     steal_qdata = _unsupported_data_method
 549     replace_data = _unsupported_data_method
 550     replace_qdata = _unsupported_data_method
 551
 552     # The following methods as unsupported until we verify
 553     # they work as gi methods.
 554     bind_property_full = _unsupported_method
 555     compat_control = _unsupported_method
 556     interface_find_property = _unsupported_method
 557     interface_install_property = _unsupported_method
 558     interface_list_properties = _unsupported_method
 559     notify_by_pspec = _unsupported_method
 560     run_dispose = _unsupported_method
 561     watch_closure = _unsupported_method
 562
 563     # Make all reference management methods private but still accessible.
 564     _ref = GObjectModule.Object.ref
 565     _ref_sink = GObjectModule.Object.ref_sink
 566     _unref = GObjectModule.Object.unref
 567     _force_floating = GObjectModule.Object.force_floating
 568
 569     ref = _unsupported_method
 570     ref_sink = _unsupported_method
 571     unref = _unsupported_method
 572     force_floating = _unsupported_method
 573
 574     # The following methods are static APIs which need to leap frog the
 575     # gi methods until we verify the gi methods can replace them.
 576     get_property = _gobject.GObject.get_property
 577     get_properties = _gobject.GObject.get_properties
 578     set_property = _gobject.GObject.set_property
 579     set_properties = _gobject.GObject.set_properties
 580     bind_property = _gobject.GObject.bind_property
 581     connect = _gobject.GObject.connect
 582     connect_after = _gobject.GObject.connect_after
 583     connect_object = _gobject.GObject.connect_object
 584     connect_object_after = _gobject.GObject.connect_object_after
 585     disconnect_by_func = _gobject.GObject.disconnect_by_func
 586     handler_block_by_func = _gobject.GObject.handler_block_by_func
 587     handler_unblock_by_func = _gobject.GObject.handler_unblock_by_func
 588     emit = _gobject.GObject.emit
 589     chain = _gobject.GObject.chain
 590     weak_ref = _gobject.GObject.weak_ref
 591     __copy__ = _gobject.GObject.__copy__
 592     __deepcopy__ = _gobject.GObject.__deepcopy__
 593
 594     def freeze_notify(self):
 595         """Freezes the object's property-changed notification queue.
 596
 597         :returns:
 598             A context manager which optionally can be used to
 599             automatically thaw notifications.
 600
 601         This will freeze the object so that "notify" signals are blocked until
 602         the thaw_notify() method is called.
 603
 604         .. code-block:: python
 605
 606             with obj.freeze_notify():
 607                 pass
 608         """
 609         super(Object, self).freeze_notify()
 610         return _FreezeNotifyManager(self)
 611
 612     #
 613     # Aliases
 614     #
 615
 616     handler_block = signal_handler_block
 617     handler_unblock = _signalmethod(GObjectModule.signal_handler_unblock)
 618     disconnect = _signalmethod(GObjectModule.signal_handler_disconnect)
 619     handler_disconnect = _signalmethod(GObjectModule.signal_handler_disconnect)
 620     handler_is_connected = _signalmethod(GObjectModule.signal_handler_is_connected)
 621     stop_emission_by_name = _signalmethod(GObjectModule.signal_stop_emission_by_name)
 622
 623     #
 624     # Deprecated Methods
 625     #
 626
 627     def stop_emission(self, detailed_signal):
 628         """Deprecated, please use stop_emission_by_name."""
 629         warnings.warn(self.stop_emission.__doc__, PyGIDeprecationWarning, stacklevel=2)
 630         return self.stop_emission_by_name(detailed_signal)
 631
 632     emit_stop_by_name = stop_emission
 633
 634
 635 Object = override(Object)
 636 GObject = Object
 637 __all__ += ['Object', 'GObject']
 638
 639
 640 class Binding(GObjectModule.Binding):
 641     def __call__(self):
 642         warnings.warn('Using parentheses (binding()) to retrieve the Binding object is no '
 643                       'longer needed because the binding is returned directly from "bind_property.',
 644                       PyGIDeprecationWarning, stacklevel=2)
 645         return self
 646
 647     def unbind(self):
 648         if hasattr(self, '_unbound'):
 649             raise ValueError('binding has already been cleared out')
 650         else:
 651             setattr(self, '_unbound', True)
 652             super(Binding, self).unbind()
 653
 654
 655 Binding = override(Binding)
 656 __all__.append('Binding')
 657
 658
 659 Property = propertyhelper.Property
 660 Signal = signalhelper.Signal
 661 SignalOverride = signalhelper.SignalOverride
 662 # Deprecated naming "property" available for backwards compatibility.
 663 # Keep this at the end of the file to avoid clobbering the builtin.
 664 property = Property
 665 __all__ += ['Property', 'Signal', 'SignalOverride', 'property']