gtk.Object — the base class of the PyGTK type hierarchy.
class gtk.Object( |
Functionsdef gtk.bindings_activate(
object
,keyval
,modifiers
)def gtk.bindings_activate_event(
object
,event
)def gtk.binding_entry_add_signal(
object
,keyval
,modifiers
,signal_name
,...
)def gtk.binding_entry_remove(
class_type
,keyval
,modifiers
)
"destroy" | def callback( |
gtk.Object
is the
base class for all widgets, and for a few non-widget objects such as gtk.Adjustment
.
gtk.Object
predates GObject
gtk.Object
rather
than GObject
The "destroy" signal, emitted by the destroy
()
method asks all code owning a GTK reference to the object to release its GTK
reference. So, for example, if you call
window.destroy
() where
window
is a gtk.Window
, GTK will
release the GTK reference count that it owns; if you call
button.destroy
() where button is a gtk.Button
,
button
will be removed from its parent container and
the parent container will release its GTK reference to
button
. Because these GTK references are released,
calling destroy
()
should result in freeing all memory associated with an object (finalizing
it) if the GTK reference count reaches zero. However, in PyGTK the GTK
objects are wrapped in a Python object that has its own reference counting
mechanism. The destroy
()
method does not affect the Python reference counts. The GTK object
associated with a Python object will not be released until the Python object
reference count reaches zero. Therefore, calling the destroy
()
method will not result in the finalization of the GTK object until the
Python object is finalized. In the case mentioned above if a gtk.Button
is
destroyed using the destroy
()
method, it will be removed from its container and unmapped and unrealized
but it will not be finalized because the Python wrapper object will still
exist and hold a reference.
def flags()
Returns : | the flags set for the object |
The flags
() method returns the value of
the flags for the object. The flags returned will include both the gtk.Object
flags and
the gtk.Widget
flags.
The gtk.Object
flags
are:
| the object is currently being destroyed. |
| the object is orphaned. |
| reserved for future use |
| reserved for future use |
The gtk.Widget
flags
are:
| widgets without a real parent (e.g. gtk.Window and gtk.Menu ) have this
flag set throughout their lifetime. Toplevel widgets always contain their
own gtk.gdk.Window . |
| a widget that does not provide its own gtk.gdk.Window .
Visible action (e.g. drawing) is performed on the parent's gtk.gdk.Window . |
| the widget has an associated gtk.gdk.Window . |
| the widget can be displayed on the screen. |
| the widget will be mapped as soon as its parent is mapped. |
| The sensitivity of a widget determines whether it will receive certain events (e.g. button or key presses). One requirement for the widget's sensitivity is to have this flag set. |
| This is the second requirement for the widget's
sensitivity. Once a widget has gtk.SENSITIVE and
gtk.PARENT_SENSITIVE set , its state is effectively
sensitive. |
| the widget is able to handle focus grabs. |
| the widget has the focus - assumes that
gtk.CAN_FOCUS is set |
| the widget is allowed to receive the default action. |
| the widget currently will receive the default action. |
| the widget is in the grab_widgets stack, and will be the preferred one for receiving events. |
| the widgets style has been looked up through the RC mechanism. It does not imply that the widget actually had a style defined through the RC mechanism. |
| the widget is a composite child of its parent. |
| unused |
| set on widgets whose window the application directly draws on, in order to keep GTK from overwriting the drawn stuff. |
| the widget when focused will receive the default action
and have gtk.HAS_DEFAULT set even if there is a different
widget set as default. |
| exposes done on the widget should be double-buffered. |
def set_flags(flags
)
| the gtk.Object and gtk.Widget flags to
be set on this object |
The set_flags
() method sets the object
flags according to the value of flags
. See flags
()
for a description of the gtk.Object
and gtk.Widget
flags
that can be set.
def unset_flags(flags
)
| the gtk.Object and gtk.Widget flags to
be unset on this object |
The unset_flags
() method unsets the
object flags according to the value of flags
. See
flags
()
for a description of the gtk.Object
and gtk.Widget
flags
that can be unset.
def destroy()
The destroy
() method emits the
"destroy" signal notifying all reference holders that they should release
the gtk.Object
.
def gtk.bindings_activate(object
, keyval
, modifiers
)
| the gtk.Object to
activate the bindings on |
| a key value |
| a modifier mask |
| |
Returns : | True if the binding could be
activated |
The gtk.bindings_activate
() function
activates the bindings associated with the gtk.Object
specified
by object with the key value specified by keyval
and
the modifier mask specified by modifiers
.
def gtk.bindings_activate_event(object
, event
)
| the gtk.Object to
activate the bindings on |
| a gtk.gdk.Event |
Returns : | True if a matching key
binding was found |
The gtk.bindings_activate_event
() function
looks up key bindings for the gtk.Object
specified
by object
to find one matching the key gtk.gdk.Event
specified by event
, and if one was found, activate
it.
def gtk.binding_entry_add_signal(object
, keyval
, modifiers
, signal_name
, ...
)
| the gtk.Object
class the binding entry will be associated with |
| the key value |
| the modifier mask |
| the signal name |
| zero or more pairs of value type-value pairs |
The gtk.binding_entry_add_signal
() function
adds a binding (specified by keyval
and
modifiers
) to the binding set of the object class
derived from object
. The signal specified by
signal_name
will be emitted with the optional
arguments specified by the argument pairs denoted by ... that are value type
and value. This function is used when creating a new widget class to set up
key bindings.
def gtk.binding_entry_remove(class_type
, keyval
, modifiers
)
| the gtk.Object
class the binding entry will be removed from |
| the key value |
| the modifier mask |
This function is available in PyGTK 2.2 and above.
The gtk.binding_entry_remove
() function
removes the binding (specified by keyval
and
modifiers
) from the binding set of the object class
specified by class_type
.
def callback(object
, user_param1
, ...
)
| the object that received the signal |
| the first user parameter (if any) specified
with the connect () |
| additional user parameters (if any) |
The "destroy" signal is emitted when the references for the object should be destroyed.