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 handler_unblock() is called.
 439
 440     Returns a context manager which optionally can be used to
 441     automatically unblock the handler:
 442
 443       with GObject.signal_handler_block(obj, id):
 444          pass
 445     """
 446     GObjectModule.signal_handler_block(obj, handler_id)
 447     return _HandlerBlockManager(obj, handler_id)
 448
 449 __all__.append('signal_handler_block')
 450
 451
 452 def signal_parse_name(detailed_signal, itype, force_detail_quark):
 453     """Parse a detailed signal name into (signal_id, detail).
 454
 455     :Raises ValueError:
 456         If the given signal is unknown.
 457
 458     :Returns:
 459         Tuple of (signal_id, detail)
 460     """
 461     res, signal_id, detail = GObjectModule.signal_parse_name(detailed_signal, itype,
 462                                                              force_detail_quark)
 463     if res:
 464         return signal_id, detail
 465     else:
 466         raise ValueError('%s: unknown signal name: %s' % (itype, detailed_signal))
 467
 468 __all__.append('signal_parse_name')
 469
 470
 471 def remove_emission_hook(obj, detailed_signal, hook_id):
 472     signal_id, detail = signal_parse_name(detailed_signal, obj, True)
 473     GObjectModule.signal_remove_emission_hook(signal_id, hook_id)
 474
 475 __all__.append('remove_emission_hook')
 476
 477
 478 # GObject accumulators with pure Python implementations
 479 # These return a tuple of (continue_emission, accumulation_result)
 480
 481 def signal_accumulator_first_wins(ihint, return_accu, handler_return, user_data=None):
 482     # Stop emission but return the result of the last handler
 483     return (False, handler_return)
 484
 485 __all__.append('signal_accumulator_first_wins')
 486
 487
 488 def signal_accumulator_true_handled(ihint, return_accu, handler_return, user_data=None):
 489     # Stop emission if the last handler returns True
 490     return (not handler_return, handler_return)
 491
 492 __all__.append('signal_accumulator_true_handled')
 493
 494
 495 # Statically bound signal functions which need to clobber GI (for now)
 496
 497 add_emission_hook = _gobject.add_emission_hook
 498 signal_new = _gobject.signal_new
 499
 500 __all__ += ['add_emission_hook', 'signal_new']
 501
 502
 503 class _FreezeNotifyManager(object):
 504     def __init__(self, obj):
 505         self.obj = obj
 506
 507     def __enter__(self):
 508         pass
 509
 510     def __exit__(self, exc_type, exc_value, traceback):
 511         self.obj.thaw_notify()
 512
 513
 514 def _signalmethod(func):
 515     # Function wrapper for signal functions used as instance methods.
 516     # This is needed when the signal functions come directly from GI.
 517     # (they are not already wrapped)
 518     @gi.overrides.wraps(func)
 519     def meth(*args, **kwargs):
 520         return func(*args, **kwargs)
 521     return meth
 522
 523
 524 class Object(GObjectModule.Object):
 525     def _unsupported_method(self, *args, **kargs):
 526         raise RuntimeError('This method is currently unsupported.')
 527
 528     def _unsupported_data_method(self, *args, **kargs):
 529         raise RuntimeError('Data access methods are unsupported. '
 530                            'Use normal Python attributes instead')
 531
 532     # Generic data methods are not needed in python as it can be handled
 533     # with standard attribute access: https://bugzilla.gnome.org/show_bug.cgi?id=641944
 534     get_data = _unsupported_data_method
 535     get_qdata = _unsupported_data_method
 536     set_data = _unsupported_data_method
 537     steal_data = _unsupported_data_method
 538     steal_qdata = _unsupported_data_method
 539     replace_data = _unsupported_data_method
 540     replace_qdata = _unsupported_data_method
 541
 542     # The following methods as unsupported until we verify
 543     # they work as gi methods.
 544     bind_property_full = _unsupported_method
 545     compat_control = _unsupported_method
 546     interface_find_property = _unsupported_method
 547     interface_install_property = _unsupported_method
 548     interface_list_properties = _unsupported_method
 549     notify_by_pspec = _unsupported_method
 550     run_dispose = _unsupported_method
 551     watch_closure = _unsupported_method
 552
 553     # Make all reference management methods private but still accessible.
 554     _ref = GObjectModule.Object.ref
 555     _ref_sink = GObjectModule.Object.ref_sink
 556     _unref = GObjectModule.Object.unref
 557     _force_floating = GObjectModule.Object.force_floating
 558
 559     ref = _unsupported_method
 560     ref_sink = _unsupported_method
 561     unref = _unsupported_method
 562     force_floating = _unsupported_method
 563
 564     # The following methods are static APIs which need to leap frog the
 565     # gi methods until we verify the gi methods can replace them.
 566     get_property = _gobject.GObject.get_property
 567     get_properties = _gobject.GObject.get_properties
 568     set_property = _gobject.GObject.set_property
 569     set_properties = _gobject.GObject.set_properties
 570     bind_property = _gobject.GObject.bind_property
 571     connect = _gobject.GObject.connect
 572     connect_after = _gobject.GObject.connect_after
 573     connect_object = _gobject.GObject.connect_object
 574     connect_object_after = _gobject.GObject.connect_object_after
 575     disconnect_by_func = _gobject.GObject.disconnect_by_func
 576     handler_block_by_func = _gobject.GObject.handler_block_by_func
 577     handler_unblock_by_func = _gobject.GObject.handler_unblock_by_func
 578     emit = _gobject.GObject.emit
 579     chain = _gobject.GObject.chain
 580     weak_ref = _gobject.GObject.weak_ref
 581     __copy__ = _gobject.GObject.__copy__
 582     __deepcopy__ = _gobject.GObject.__deepcopy__
 583
 584     def freeze_notify(self):
 585         """Freezes the object's property-changed notification queue.
 586
 587         This will freeze the object so that "notify" signals are blocked until
 588         the thaw_notify() method is called.
 589
 590         Returns a context manager which optionally can be used to
 591         automatically thaw notifications:
 592
 593           with obj.freeze_notify():
 594               pass
 595         """
 596         super(Object, self).freeze_notify()
 597         return _FreezeNotifyManager(self)
 598
 599     #
 600     # Aliases
 601     #
 602
 603     handler_block = signal_handler_block
 604     handler_unblock = _signalmethod(GObjectModule.signal_handler_unblock)
 605     disconnect = _signalmethod(GObjectModule.signal_handler_disconnect)
 606     handler_disconnect = _signalmethod(GObjectModule.signal_handler_disconnect)
 607     handler_is_connected = _signalmethod(GObjectModule.signal_handler_is_connected)
 608     stop_emission_by_name = _signalmethod(GObjectModule.signal_stop_emission_by_name)
 609
 610     #
 611     # Deprecated Methods
 612     #
 613
 614     def stop_emission(self, detailed_signal):
 615         """Deprecated, please use stop_emission_by_name."""
 616         warnings.warn(self.stop_emission.__doc__, PyGIDeprecationWarning, stacklevel=2)
 617         return self.stop_emission_by_name(detailed_signal)
 618
 619     emit_stop_by_name = stop_emission
 620
 621
 622 Object = override(Object)
 623 GObject = Object
 624 __all__ += ['Object', 'GObject']
 625
 626
 627 class Binding(GObjectModule.Binding):
 628     def __call__(self):
 629         warnings.warn('Using parentheses (binding()) to retrieve the Binding object is no '
 630                       'longer needed because the binding is returned directly from "bind_property.',
 631                       PyGIDeprecationWarning, stacklevel=2)
 632         return self
 633
 634     def unbind(self):
 635         if hasattr(self, '_unbound'):
 636             raise ValueError('binding has already been cleared out')
 637         else:
 638             setattr(self, '_unbound', True)
 639             super(Binding, self).unbind()
 640
 641
 642 Binding = override(Binding)
 643 __all__.append('Binding')
 644
 645
 646 Property = propertyhelper.Property
 647 Signal = signalhelper.Signal
 648 SignalOverride = signalhelper.SignalOverride
 649 # Deprecated naming "property" available for backwards compatibility.
 650 # Keep this at the end of the file to avoid clobbering the builtin.
 651 property = Property
 652 __all__ += ['Property', 'Signal', 'SignalOverride', 'property']