gobject.GObject.get_property

    def get_property(property_name)

The get_property() method returns the value of the property specified by property_name or None if there is no value associated with the property.

The TypeError exception is raised if the property name is not registered with the object class.

gobject.GObject.set_property

    def set_property(property_name, value)

The set_property() method sets the property specified by property_name to the specified value.

The TypeError exception is raised if the property name is not registered with the object class or if the value specified could not be converted to the property type.

gobject.GObject.freeze_notify

    def freeze_notify()

The freeze_notify() method freezes the object's property-changed notification queue so that "notify" signals are blocked until the thaw_notify() method is called.

gobject.GObject.notify

    def notify(property_name)

The notify() method causes the "notify" signal for the property specified by property_name to be emitted.

gobject.GObject.thaw_notify

    def thaw_notify()

The thaw_notify() method thaws the object's property-changed notification queue so that "notify" signals are emitted.

gobject.GObject.get_data

    def get_data(key)

The get_data() method returns the Python object associated with the specified key or None if there is no data associated with the key or if there is no key associated with the object.

gobject.GObject.set_data

    def set_data(key, data)

The set_data() method associates the specified Python object (data) with key.

gobject.GObject.connect

    def connect(detailed_signal, handler, ...)

The connect() method adds a function or method (handler)to the end of the list of signal handlers for the named detailed_signal but before the default class signal handler. An optional set of parameters may be specified after the handler parameter. These will all be passed to the signal handler when invoked.

For example if a function handler was connected to a signal using:

  handler_id = object.connect("signal_name", handler, arg1, arg2, arg3)

The handler should be defined as:

  def handler(object, arg1, arg2, arg3):

A method handler connected to a signal using:

  handler_id = object.connect("signal_name", self.handler, arg1, arg2)

requires an additional argument when defined:

  def handler(self, object, arg1, arg2)

A TypeError exception is raised if detailed_signal identifies a signal name that is not associated with the object.

gobject.GObject.connect_after

    def connect_after(detailed_signal, handler, ...)

The connect_after() method is similar to the connect() method except that the handler is added to the signal handler list after the default class signal handler. Otherwise the details of handler definition and invocation are the same.

gobject.GObject.connect_object

    def connect_object(detailed_signal, handler, gobject)

The connect_object() method is the same as the connect() method except that the handler is invoked with the specified gobject in place of the object invoking the connect_object() method. For example, a call with a function handler:

  handler_id = object("signal_name", handler, gobject)

will cause the handler to be invoked as:

  handler(gobject)

Likewise a method handler will be invoked as:

  self.handler(gobject)

This can be helpful in invoking PyGTK widget methods that require no arguments except the widget itself (e.g. widget.destroy()) by using the class method as the handler. For example, a Button "clicked" signal can be set up to invoke the Window destroy() method as:

  handler_id = button.connect_object("clicked", Window.destroy, window)

When the button is clicked the handler is invoked as:

  Window.destroy(window)

which is the same as:

  window.destroy()

Additional arguments may be passed to the handler as with the connect() method handler invocations.

gobject.GObject.connect_object_after

    def connect_object_after(detailed_signal, handler)

The connect_object_after() method is similar to the connect_object() method except that the handler is added to the signal handler list after the default class signal handler. Otherwise the details of handler definition and invocation are the same.

gobject.GObject.disconnect

    def disconnect(handler_id)

The disconnect() method removes the signal handler with the specified handler_id from the list of signal handlers for the object.

gobject.GObject.handler_disconnect

    def handler_disconnect(handler_id)

The handler_disconnect() method removes the signal handler with the specified handler_id from the list of signal handlers for the object.

gobject.GObject.handler_is_connected

    def handler_is_connected(handler_id)

The handler_is_connected() method returns TRUE if the signal handler with the specified handler_id is connected to the object.

gobject.GObject.handler_block

    def handler_block(handler_id)

The handler_block() method blocks the signal handler with the specified handler_id from being invoked until it is unblocked.

gobject.GObject.handler_unblock

    def handler_unblock(handler_id)

The handler_unblock() method unblocks the signal handler with the specified handler_id thereby allowing it to be invoked when the associated signal is emitted.

gobject.GObject.emit

    def emit(detailed_signal, ...)

The emit() method causes the object to emit the signal specified by detailed_signal. The additional parameters must match the number and type of the required signal handler parameters. In most cases no additional parameters are needed. for example:

  button.emit("clicked")

is all that is required to emit the "clicked" signal for a button. The most common case requiring additional parameters occurs when emitting an event signal; for example:

  button.emit("button_press_event", event)

gobject.GObject.stop_emission

    def stop_emission(detailed_signal)

The stop_emission() method stops the current emission of the signal specified by detailed_signal. Any signal handlers in the list still to be run will not be invoked.

gobject.GObject.emit_stop_by_name

    def emit_stop_by_name(detailed_signal)

The emit_stop_by_name() method stops the current emission of the signal specified by detailed_signal. Any signal handlers in the list still to be run will not be invoked.

gobject.GObject.chain

    def chain(...)

The chain() method does something.

The GObject "notify" Signal

    def callback(gobject, property_spec, user_param1, ...)

The "notify" signal is emitted on a gobject when one of its properties has been changed. Note that getting this signal doesn't guarantee that the value of the property has actually changed, it may also be emitted when the setter for the property is called to reinstate the previous value. For example to be notified of the change of the title of a gtk.Window you could connect to the "notify" signal similar to:

  window.connect("notify::title", callback)