From 6a4fa002a2d53de62cb38fdb9f7ed67849a632f2 Mon Sep 17 00:00:00 2001 From: Dieter Verfaillie Date: Wed, 9 Mar 2011 23:10:40 +0100 Subject: reference: pygtk-gtkwidget.xml: add missing methods and properties --- docs/reference/pygtk-gtkwidget.xml | 879 ++++++++++++++++++++++++++++++++++++- 1 file changed, 869 insertions(+), 10 deletions(-) diff --git a/docs/reference/pygtk-gtkwidget.xml b/docs/reference/pygtk-gtkwidget.xml index 55109034..3150c114 100644 --- a/docs/reference/pygtk-gtkwidget.xml +++ b/docs/reference/pygtk-gtkwidget.xml @@ -15,7 +15,11 @@ widgets gtk.Widget gtk.Object - + + set_allocation + allocation + + get_allocation @@ -713,6 +717,122 @@ widgets get_window + + send_focus_change + event + + + set_realized + realized + + + get_realized + + + + set_mapped + mapped + + + get_mapped + + + + get_requisition + + + + style_attach + + + + has_rc_style + + + + get_app_paintable + + + + set_can_default + can_default + + + get_can_default + + + + set_can_focus + can_focus + + + get_can_focus + + + + get_double_buffered + + + + set_has_window + has_window + + + get_has_window + + + + set_receives_default + receives_default + + + get_receives_default + + + + get_sensitive + + + + get_state + + + + set_visible + visible + + + get_visible + + + + set_window + window + + + has_default + + + + has_focus + + + + has_grab + + + + is_sensitive + + + + is_toplevel + + + + is_drawable + + @@ -824,6 +944,12 @@ input focus composite widget + + "double-buffered" + Read-Write + If True, the widget is double buffered + + "events" Read-Write @@ -966,6 +1092,14 @@ visible request should be used. + + "window" + Read + The widget's window if realized, + None otherwise. + This property is available in GTK+ 2.14 and above. + + @@ -1103,14 +1237,6 @@ right-to-left and left-to-right text. 2.10 and above. - - "window" - Read - The "window" property is the widget's window if it is - realized, None otherwise. - This property is available in GTK+ 2.14 and above. - - @@ -2010,6 +2136,30 @@ without the need to write a theme engine in C. Methods + + gtk.Widget.set_allocation + + + set_allocation + allocation + + + + allocation : + a gtk.gdk.Rectangle. + + + + + This method is available in PyGTK 2.20 and above. + + + The set_allocation() method sets the widget's allocation. + This should not be used directly, but from within a widget's + "size_allocate" implementation. + + + gtk.Widget.get_allocation @@ -4125,7 +4275,9 @@ widget to become the default widget. The widget must have the gtk.CAN_DEFAULT flag set by calling the gtk.Object.set_flags() method. The default widget is activated when the user presses -Enter in a window. +Enter in a window. Default widgets must be activatable, that is, +gtk.Widget.activate() +should affect them. @@ -6836,6 +6988,713 @@ method. + + gtk.Widget.send_focus_change + + + send_focus_change + event + + + + event : + a FOCUS_CHANGE gtk.gdk.Event. + + + Returns : + the return value from the event signal emission: True if the event was handled, and False otherwise. + + + + + This method is available in PyGTK 2.22 and above. + + + The send_focus_change() method ends the focus change + event to the widget. + + This method is not meant to be used by applications. The only time it should be used is when it is necessary for a + gtk.Widget to assign focus to a widget that is semantically + owned by the first widget even though it's not a direct child - for instance, a search entry in a floating window similar + to the quick search in gtk.TreeView. + + + + + gtk.Widget.set_realized + + + set_realized + realized + + + + realized : + True to mark the widget as realized, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The set_realized() method marks the widget as being realized. + + This method should only ever be called in a derived widget's "realize" or "unrealize" implementation. + + + + + gtk.Widget.get_realized + + + get_realized + + + + + Returns : + True if widget is realized, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_realized() method determines whether widget is realized. + + + + + gtk.Widget.set_mapped + + + set_mapped + mapped + + + + mapped : + True to mark the widget as mapped, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The set_mapped() method marks the widget as being mapped. + + + + + gtk.Widget.get_mapped + + + get_mapped + + + + + Returns : + True if the widget is mapped, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_mapped() method determines whether + the widget is mapped. + + + + + gtk.Widget.get_requisition + + + get_requisition + requisition + + + + Returns : + a gtk.Requisition. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_requisition() method retrieves the widget's requisition. + + This method should only be used by widget implementations in order to figure whether the widget's + requisition has actually changed after some internal state change (so that they can call + queue_resize() + instead of + gtk.Widget.queue_draw()). + + + + + gtk.Widget.style_attach + + + style_attach + + + + + This method is available in PyGTK 2.20 and above. + + + The style_attach() method attaches the widget's + gtk.Style to the widget's + gtk.gdk.Window. It is a + replacement for the gtk.Style.attach() + method and should only ever be called in a derived widget's "realize" implementation which + does not chain up to its parent class' "realize" implementation, because one of the parent + classes (finally gtk.Widget) + would attach the style itself. + + + + + gtk.Widget.has_rc_style + + + has_rc_style + + + + + Returns : + Trueif the widget has been looked up through the rc mechanism, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The has_rc_style() method determines + if the widget style has been looked up through the rc mechanism. + + + + + gtk.Widget.get_app_paintable + + + get_app_paintable + + + + + Returns : + True if the widget is app paintable, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_app_paintable() method determines + whether the application intends to draw on the widget in an "expose-event" + handler. + + + + + gtk.Widget.set_can_default + + + set_can_default + can_default + + + + can_default : + True if the widget can be a default widget, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The set_can_default() method specifies whether + the widget can be a default widget. See gtk.Widget.grab_default() + for details about the meaning of "default". + + + + + gtk.Widget.get_can_default + + + get_can_default + + + + + Returns : + True if widget can be a default widget, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_can_default() method determines whether + widget can be a default widget. + + + + + gtk.Widget.set_can_focus + + + set_can_focus + can_focus + + + + can_focus : + True if the widget can own the input focus, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The set_can_focus() method specifies whether + the widget can own the input focus. See + grab_focus() + for actually setting the input focus on a widget. + + + + + gtk.Widget.get_can_focus + + + get_can_focus + + + + + Returns : + True if the widget can own the input focus, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_can_focus() method determines whether + widget can own the input focus. + + + + + gtk.Widget.get_double_buffered + + + get_double_buffered + + + + + Returns : + True if the widget is double buffered, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_double_buffered() method determines whether + the widget is double buffered. + + + + + gtk.Widget.set_has_window + + + set_has_window + has_window + + + + has_window : + True if the widget has a window, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The set_has_window() method specifies whether + the widget has a gtk.gdk.Window + of its own. Note that all realized widgets have a non-None "window" + (get_window() + never returns a None window when a widget is realized), but for many of them it's + actually the gtk.gdk.Window of one + of its parent widgets. Widgets that do not create a window for themselves in their "realize" implementation + must announce this by calling this function with has_window = False. + + + + + gtk.Widget.get_has_window + + + get_has_window + + + + + Returns : + True if widget has a window, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_has_window() method determines whether + widget has a gtk.gdk.Window of its own. + + + + + gtk.Widget.set_receives_default + + + set_receives_default + receives_default + + + + receives_default : + True if the widget can be a default widget, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The set_receives_default() method specifies whether + the widget will be treated as the default widget within its toplevel when it has the + focus, even if another widget is the default. + + + + + gtk.Widget.get_receives_default + + + get_receives_default + + + + + Returns : + True if widget acts as default widget when focussed, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_receives_default() method determines whether + the widget is alyways treated as default widget withing its toplevel when it has the + focus, even if another widget is the default. + + The effective sensitivity of a widget is however determined by both its own and + its parent widget's sensitivity. See + is_sensitive(). + + + + + gtk.Widget.get_sensitive + + + get_sensitive + + + + + Returns : + True if the widget is sensitive, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_sensitive() method returns the widget's sensitivity + (in the sense of returning the value that has been set using + set_sensitive()). + + + + + gtk.Widget.get_state + + + get_state + + + + + Returns : + the state of the widget. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_state() method returns the widget's state. + + + + + gtk.Widget.set_visible + + + set_visible + visible + + + + visible : + True if the widget should be shown, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The set_visible() method sets the visibility + state of the widget. Note that setting this to True doesn't + mean the widget is actually viewable, see + get_visible(). + + + + + gtk.Widget.get_visible + + + get_visible + + + + + Returns : + True if the widget is visible, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The get_visible() method determines whether + the widget is visible. Note that this doesn't take into account whether the + widget's parent is also visible or the widget is obscured in any way. + + + + + gtk.Widget.set_window + + + set_window + window + + + + window : + a gtk.gdk.Window. + + + + + This method is available in PyGTK 2.20 and above. + + + The set_window() method sets the widget's + window. This method should only be used in a widget's "realize" implementation. + The window passed is usually either a new window or the window of its parent widget as returned by + get_parent_window(). + + Widgets must indicate whether they will create their own + gtk.gdk.Window + by calling set_has_window(). + This is usually done in the widget's init() method. + + + + + gtk.Widget.has_default + + + has_default + + + + + Returns : + True if widget is the current default widget within its toplevel, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The has_default() method determines whether + widget is the current default widget within its toplevel. + + + + + gtk.Widget.has_focus + + + has_focus + + + + + Returns : + True if the widget has the global input focus, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The has_focus() method determines + if the widget has the global input focus. + + + + + gtk.Widget.has_grab + + + has_grab + + + + + Returns : + True if the widget is in the grab_widgets stack, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The has_grab() method determines whether + the widget is currently grabbing events, so it is the only widget + receiving input events (keyboard and mouse). + + + + + gtk.Widget.is_sensitive + + + is_sensitive + + + + + Returns : + True if the widget is effectively sensitive, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The is_sensitive() method returns the + widget's effective sensitivity, which means it is sensitive itself and + also its parent widget is sensntive. + + + + + gtk.Widget.is_toplevel + + + is_toplevel + + + + + Returns : + True if the widget is a toplevel, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The is_toplevel() method determines whether + widget is a toplevel widget. Toplevel widgets have no parent widget. + + + + + gtk.Widget.is_drawable + + + is_drawable + + + + + Returns : + True if the widget is drawable, False otherwise. + + + + + This method is available in PyGTK 2.20 and above. + + + The is_drawable() method determines whether + the widget can be drawn to. A widget can be drawn to if it is mapped and visible. + + -- cgit v1.2.1