From 897a3337443e5289a7e1dd6e19a1a0c855f697f9 Mon Sep 17 00:00:00 2001 From: Murray Cumming Date: Thu, 4 Nov 2010 16:11:25 +0100 Subject: [PATCH] GtkWidget: Document the size-request signal deprecation. Hopefully my text is correct. --- gtk/gtkwidget.c | 1036 ++++++++++++++++++++++++----------------------- 1 file changed, 520 insertions(+), 516 deletions(-) diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c index a223693dfb..7b80c6c243 100644 --- a/gtk/gtkwidget.c +++ b/gtk/gtkwidget.c @@ -21,7 +21,7 @@ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS * file for a list of people on the GTK+ Team. See the ChangeLog * files for a list of changes. These files are distributed with - * GTK+ at ftp://ftp.gtk.org/pub/gtk/. + * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ #undef GDK_DISABLE_DEPRECATED /* gdk_input_set_extension_events() */ @@ -73,13 +73,13 @@ * Height-for-width Geometry Management * * GTK+ uses a height-for-width (and width-for-height) geometry management - * system Height-for-width means that a widget can change how much - * vertical space it needs, depending on the amount of horizontal space - * that it is given (and similar for width-for-height). The most common - * example is a label that reflows to fill up the available width, wraps + * system Height-for-width means that a widget can change how much + * vertical space it needs, depending on the amount of horizontal space + * that it is given (and similar for width-for-height). The most common + * example is a label that reflows to fill up the available width, wraps * to fewer lines, and therefore needs less height. * - * Height-for-width geometry management is implemented in GTK+ by way + * Height-for-width geometry management is implemented in GTK+ by way * of five virtual methods: * * @@ -90,10 +90,10 @@ * or %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT mode. * %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH means the widget prefers to * have #GtkWidgetClass.get_preferred_width() called and then - * #GtkWidgetClass.get_preferred_height_for_width() and is the + * #GtkWidgetClass.get_preferred_height_for_width() and is the * default return for unimplemented cases. * However it's important to note (as described below) that any - * widget which trades height-for-width must respond properly to + * widget which trades height-for-width must respond properly to * both #GtkSizeRequestModes since it might be queried in either * orientation by it's parent container. * @@ -117,7 +117,7 @@ * This is called by containers to obtain the minimum and * natural height of a widget. * A widget that does not actually trade any height for width - * or width for height only has to implement these two virtual + * or width for height only has to implement these two virtual * methods (#GtkWidgetClass.get_preferred_width() and * #GtkWidgetClass.get_preferred_height()). * @@ -135,7 +135,7 @@ * * #GtkWidgetClass.get_preferred_width_for_height() * - * This is analogous to #GtkWidgetClass.get_preferred_height_for_width() + * This is analogous to #GtkWidgetClass.get_preferred_height_for_width() * except that it operates in the oposite orientation. It's rare that * a widget actually does %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT requests * but can happen when for example; a widget or container gets additional @@ -152,50 +152,50 @@ * for their minimum sizes it is generally done in two initial passes * in the #GtkSizeRequestMode chosen by the toplevel. * - * For example, when queried in the normal + * For example, when queried in the normal * %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH mode: * First, the default minimum and natural width for each widget - * in the interface will be computed using gtk_width_get_preferred_width(). - * Because the preferred widths for each container depends on the preferred - * widths of thier children, this information propagates up the hierarchy, + * in the interface will be computed using gtk_width_get_preferred_width(). + * Because the preferred widths for each container depends on the preferred + * widths of thier children, this information propagates up the hierarchy, * and finally a minimum and natural width is determined for the entire - * toplevel. Next, the toplevel will use the minimum width to query for the - * minimum height contextual to that width using - * gtk_widget_get_preferred_height_for_width(), which will also be a highly - * recursive operation. The minimum height for the minimum width is normally - * used to set the minimum size constraint on the toplevel + * toplevel. Next, the toplevel will use the minimum width to query for the + * minimum height contextual to that width using + * gtk_widget_get_preferred_height_for_width(), which will also be a highly + * recursive operation. The minimum height for the minimum width is normally + * used to set the minimum size constraint on the toplevel * (unless gtk_window_set_geometry_hints() is explicitly used instead). * - * After the toplevel window has initially requested it's size in both - * dimensions it can go on to allocate itself a reasonable size (or a size - * previously specified with gtk_window_set_default_size()). During the - * recursive allocation process it's important to note that request cycles - * will be recursively executed while container widgets allocate their children. - * Each container widget, once allocated a size will go on to first share the - * space in one orientation among its children and then request each child's - * height for their target allocated width or width for allocated height + * After the toplevel window has initially requested it's size in both + * dimensions it can go on to allocate itself a reasonable size (or a size + * previously specified with gtk_window_set_default_size()). During the + * recursive allocation process it's important to note that request cycles + * will be recursively executed while container widgets allocate their children. + * Each container widget, once allocated a size will go on to first share the + * space in one orientation among its children and then request each child's + * height for their target allocated width or width for allocated height * depending. In this way a #GtkWidget will typically be requested its size - * a number of times before actually being allocated a size, the size a - * widget is finally allocated can of course differ from the size it - * requested. For this reason; #GtkWidget caches a small number of results + * a number of times before actually being allocated a size, the size a + * widget is finally allocated can of course differ from the size it + * requested. For this reason; #GtkWidget caches a small number of results * to avoid re-querying for the same sizes in one allocation cycle. * - * See GtkContainer's + * See GtkContainer's * geometry management section - * to learn more about how height-for-width allocations are performed + * to learn more about how height-for-width allocations are performed * by container widgets. * * If a widget does move content around to smartly use up the * allocated size, then it must support the request in both - * #GtkSizeRequestModes even if the widget in question only + * #GtkSizeRequestModes even if the widget in question only * trades sizes in a single orientation. * * For instance, a #GtkLabel that does height-for-width word wrapping - * will not expect to have #GtkWidgetClass.get_preferred_height() called - * because that call is specific to a width-for-height request. In this - * case the label must return the heights required for it's own minimum - * possible width. By following this rule any widget that handles - * height-for-width or width-for-height requests will always be allocated + * will not expect to have #GtkWidgetClass.get_preferred_height() called + * because that call is specific to a width-for-height request. In this + * case the label must return the heights required for it's own minimum + * possible width. By following this rule any widget that handles + * height-for-width or width-for-height requests will always be allocated * at least enough space to fit its own content. * * Here are some examples of how a %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH widget @@ -210,7 +210,7 @@ * gint min_width; * * GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL); - * GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width, + * GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width, * min_height, nat_height); * } * else @@ -220,13 +220,13 @@ * } * } * ]]> - * + * * And in #GtkWidgetClass.get_preferred_width_for_height() it will simply return * the minimum and natural width: * * * Widget calling its own size request method. * - * GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget), + * GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget), * &min, &natural); * * @@ -873,7 +873,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) klass->get_preferred_width = gtk_widget_real_get_width; klass->get_preferred_height = gtk_widget_real_get_height; klass->get_preferred_width_for_height = gtk_widget_real_get_width_for_height; - klass->get_preferred_height_for_width = gtk_widget_real_get_height_for_width; + klass->get_preferred_height_for_width = gtk_widget_real_get_height_for_width; klass->state_changed = NULL; klass->parent_set = NULL; klass->hierarchy_changed = NULL; @@ -923,7 +923,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) klass->query_tooltip = gtk_widget_real_query_tooltip; klass->show_help = gtk_widget_real_show_help; - + /* Accessibility support */ klass->get_accessible = gtk_widget_real_get_accessible; @@ -942,7 +942,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) g_object_class_install_property (gobject_class, PROP_PARENT, g_param_spec_object ("parent", - P_("Parent widget"), + P_("Parent widget"), P_("The parent widget of this widget. Must be a Container widget"), GTK_TYPE_CONTAINER, GTK_PARAM_READWRITE)); @@ -1069,7 +1069,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) /** * GtkWidget:has-tooltip: * - * Enables or disables the emission of #GtkWidget::query-tooltip on @widget. + * Enables or disables the emission of #GtkWidget::query-tooltip on @widget. * A value of %TRUE indicates that @widget can have a tooltip, in this case * the widget will be queried using #GtkWidget::query-tooltip to determine * whether it will provide a tooltip or not. @@ -1469,6 +1469,10 @@ gtk_widget_class_init (GtkWidgetClass *klass) * GtkWidget::size-request: * @widget: the object which received the signal. * @requisition: + * + * Deprecated: 3.0: Either implement + * height-for-width geometry management or + * use gtk_widget_set_size_request() instead of handling this signal. */ _size_request_signal_id = widget_signals[SIZE_REQUEST] = g_signal_new (I_("size-request"), @@ -1485,7 +1489,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @widget: the object which received the signal. * @allocation: */ - widget_signals[SIZE_ALLOCATE] = + widget_signals[SIZE_ALLOCATE] = g_signal_new (I_("size-allocate"), G_TYPE_FROM_CLASS (gobject_class), G_SIGNAL_RUN_FIRST, @@ -1519,8 +1523,8 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @old_parent: (allow-none): the previous parent, or %NULL if the widget * just got its initial parent. * - * The ::parent-set signal is emitted when a new parent - * has been set on a widget. + * The ::parent-set signal is emitted when a new parent + * has been set on a widget. */ widget_signals[PARENT_SET] = g_signal_new (I_("parent-set"), @@ -1558,10 +1562,10 @@ gtk_widget_class_init (GtkWidgetClass *klass) * GtkWidget::style-set: * @widget: the object on which the signal is emitted * @previous_style: (allow-none): the previous style, or %NULL if the widget - * just got its initial style + * just got its initial style * - * The ::style-set signal is emitted when a new style has been set - * on a widget. Note that style-modifying functions like + * The ::style-set signal is emitted when a new style has been set + * on a widget. Note that style-modifying functions like * gtk_widget_modify_base() also cause this signal to be emitted. */ widget_signals[STYLE_SET] = @@ -1599,12 +1603,12 @@ gtk_widget_class_init (GtkWidgetClass *klass) * if it becomes unshadowed * * The ::grab-notify signal is emitted when a widget becomes - * shadowed by a GTK+ grab (not a pointer or keyboard grab) on - * another widget, or when it becomes unshadowed due to a grab + * shadowed by a GTK+ grab (not a pointer or keyboard grab) on + * another widget, or when it becomes unshadowed due to a grab * being removed. - * - * A widget is shadowed by a gtk_grab_add() when the topmost - * grab widget in the grab stack of its window group is not + * + * A widget is shadowed by a gtk_grab_add() when the topmost + * grab widget in the grab stack of its window group is not * its ancestor. */ widget_signals[GRAB_NOTIFY] = @@ -1622,9 +1626,9 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @widget: the object which received the signal * @pspec: the #GParamSpec of the changed child property * - * The ::child-notify signal is emitted for each + * The ::child-notify signal is emitted for each * child property that has - * changed on an object. The signal's detail holds the property name. + * changed on an object. The signal's detail holds the property name. */ widget_signals[CHILD_NOTIFY] = g_signal_new (I_("child-notify"), @@ -1728,7 +1732,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @widget: the object which received the signal * @direction: the direction of movement * - * Gets emitted if keyboard navigation fails. + * Gets emitted if keyboard navigation fails. * See gtk_widget_keynav_failed() for details. * * Returns: %TRUE if stopping keyboard navigation is fine, %FALSE @@ -1754,13 +1758,13 @@ gtk_widget_class_init (GtkWidgetClass *klass) * * The GTK+ main loop will emit three signals for each GDK event delivered * to a widget: one generic ::event signal, another, more specific, - * signal that matches the type of event delivered (e.g. - * #GtkWidget::key-press-event) and finally a generic + * signal that matches the type of event delivered (e.g. + * #GtkWidget::key-press-event) and finally a generic * #GtkWidget::event-after signal. * - * Returns: %TRUE to stop other handlers from being invoked for the event + * Returns: %TRUE to stop other handlers from being invoked for the event * and to cancel the emission of the second specific ::event signal. - * %FALSE to propagate the event further and to allow the emission of + * %FALSE to propagate the event further and to allow the emission of * the second signal. The ::event-after signal is emitted regardless of * the return value. */ @@ -1779,8 +1783,8 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @widget: the object which received the signal. * @event: the #GdkEvent which triggered this signal * - * After the emission of the #GtkWidget::event signal and (optionally) - * the second more specific signal, ::event-after will be emitted + * After the emission of the #GtkWidget::event signal and (optionally) + * the second more specific signal, ::event-after will be emitted * regardless of the previous two signals handlers return values. * */ @@ -1803,12 +1807,12 @@ gtk_widget_class_init (GtkWidgetClass *klass) * The ::button-press-event signal will be emitted when a button * (typically from a mouse) is pressed. * - * To receive this signal, the #GdkWindow associated to the + * To receive this signal, the #GdkWindow associated to the * widget needs to enable the #GDK_BUTTON_PRESS_MASK mask. * * This signal will be sent to the grab widget if there is one. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[BUTTON_PRESS_EVENT] = @@ -1830,12 +1834,12 @@ gtk_widget_class_init (GtkWidgetClass *klass) * The ::button-release-event signal will be emitted when a button * (typically from a mouse) is released. * - * To receive this signal, the #GdkWindow associated to the + * To receive this signal, the #GdkWindow associated to the * widget needs to enable the #GDK_BUTTON_RELEASE_MASK mask. * * This signal will be sent to the grab widget if there is one. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[BUTTON_RELEASE_EVENT] = @@ -1855,7 +1859,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * this signal. * * The ::scroll-event signal is emitted when a button in the 4 to 7 - * range is pressed. Wheel mice are usually configured to generate + * range is pressed. Wheel mice are usually configured to generate * button press events for buttons 4 and 5 when the wheel is turned. * * To receive this signal, the #GdkWindow associated to the widget needs @@ -1863,7 +1867,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * * This signal will be sent to the grab widget if there is one. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[SCROLL_EVENT] = @@ -1882,15 +1886,15 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @event: (type Gdk.EventMotion): the #GdkEventMotion which triggered * this signal. * - * The ::motion-notify-event signal is emitted when the pointer moves + * The ::motion-notify-event signal is emitted when the pointer moves * over the widget's #GdkWindow. * - * To receive this signal, the #GdkWindow associated to the widget + * To receive this signal, the #GdkWindow associated to the widget * needs to enable the #GDK_POINTER_MOTION_MASK mask. * * This signal will be sent to the grab widget if there is one. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[MOTION_NOTIFY_EVENT] = @@ -1908,7 +1912,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @widget: the object on which the signal is emitted * * The ::composited-changed signal is emitted when the composited - * status of @widgets screen changes. + * status of @widgets screen changes. * See gdk_screen_is_composited(). */ widget_signals[COMPOSITED_CHANGED] = @@ -1931,7 +1935,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * this signal will cause the window to be hidden instead, so that * it can later be shown again without reconstructing it. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[DELETE_EVENT] = @@ -1950,15 +1954,15 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @event: the event which triggered this signal * * The ::destroy-event signal is emitted when a #GdkWindow is destroyed. - * You rarely get this signal, because most widgets disconnect themselves - * from their window before they destroy it, so no widget owns the + * You rarely get this signal, because most widgets disconnect themselves + * from their window before they destroy it, so no widget owns the * window at destroy time. - * + * * To receive this signal, the #GdkWindow associated to the widget needs * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask * automatically for all new windows. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[DESTROY_EVENT] = @@ -1983,7 +1987,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * * This signal will be sent to the grab widget if there is one. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[KEY_PRESS_EVENT] = @@ -2008,7 +2012,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * * This signal will be sent to the grab widget if there is one. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[KEY_RELEASE_EVENT] = @@ -2035,7 +2039,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * * This signal will be sent to the grab widget if there is one. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[ENTER_NOTIFY_EVENT] = @@ -2062,7 +2066,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * * This signal will be sent to the grab widget if there is one. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[LEAVE_NOTIFY_EVENT] = @@ -2088,7 +2092,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask * automatically for all new windows. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[CONFIGURE_EVENT] = @@ -2113,7 +2117,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * To receive this signal, the #GdkWindow associated to the widget needs * to enable the #GDK_FOCUS_CHANGE_MASK mask. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[FOCUS_IN_EVENT] = @@ -2138,7 +2142,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * To receive this signal, the #GdkWindow associated to the widget needs * to enable the #GDK_FOCUS_CHANGE_MASK mask. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[FOCUS_OUT_EVENT] = @@ -2163,7 +2167,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask * automatically for all new windows. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[MAP_EVENT] = @@ -2192,7 +2196,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask * automatically for all new windows. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[UNMAP_EVENT] = @@ -2217,7 +2221,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * To receive this signal, the #GdkWindow associated to the widget needs * to enable the #GDK_PROPERTY_CHANGE_MASK mask. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[PROPERTY_NOTIFY_EVENT] = @@ -2239,7 +2243,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * The ::selection-clear-event signal will be emitted when the * the @widget's window has lost ownership of a selection. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[SELECTION_CLEAR_EVENT] = @@ -2262,7 +2266,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * another client requests ownership of the selection owned by * the @widget's window. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[SELECTION_REQUEST_EVENT] = @@ -2339,7 +2343,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * * This signal will be sent to the grab widget if there is one. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[PROXIMITY_IN_EVENT] = @@ -2363,7 +2367,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * * This signal will be sent to the grab widget if there is one. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[PROXIMITY_OUT_EVENT] = @@ -2382,9 +2386,9 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @drag_context: the drag context * @time: the timestamp of the motion event * - * The ::drag-leave signal is emitted on the drop site when the cursor - * leaves the widget. A typical reason to connect to this signal is to - * undo things done in #GtkWidget::drag-motion, e.g. undo highlighting + * The ::drag-leave signal is emitted on the drop site when the cursor + * leaves the widget. A typical reason to connect to this signal is to + * undo things done in #GtkWidget::drag-motion, e.g. undo highlighting * with gtk_drag_unhighlight() */ widget_signals[DRAG_LEAVE] = @@ -2403,8 +2407,8 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @widget: the object which received the signal * @drag_context: the drag context * - * The ::drag-begin signal is emitted on the drag source when a drag is - * started. A typical reason to connect to this signal is to set up a + * The ::drag-begin signal is emitted on the drag source when a drag is + * started. A typical reason to connect to this signal is to set up a * custom drag icon with gtk_drag_source_set_icon(). * * Note that some widgets set up a drag icon in the default handler of @@ -2426,8 +2430,8 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @widget: the object which received the signal * @drag_context: the drag context * - * The ::drag-end signal is emitted on the drag source when a drag is - * finished. A typical reason to connect to this signal is to undo + * The ::drag-end signal is emitted on the drag source when a drag is + * finished. A typical reason to connect to this signal is to undo * things done in #GtkWidget::drag-begin. */ widget_signals[DRAG_END] = @@ -2445,10 +2449,10 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @widget: the object which received the signal * @drag_context: the drag context * - * The ::drag-data-delete signal is emitted on the drag source when a drag - * with the action %GDK_ACTION_MOVE is successfully completed. The signal - * handler is responsible for deleting the data that has been dropped. What - * "delete" means depends on the context of the drag operation. + * The ::drag-data-delete signal is emitted on the drag source when a drag + * with the action %GDK_ACTION_MOVE is successfully completed. The signal + * handler is responsible for deleting the data that has been dropped. What + * "delete" means depends on the context of the drag operation. */ widget_signals[DRAG_DATA_DELETE] = g_signal_new (I_("drag-data-delete"), @@ -2525,27 +2529,27 @@ gtk_widget_class_init (GtkWidgetClass *klass) * guint time) * { * GdkAtom target; - * + * * PrivateData *private_data = GET_PRIVATE_DATA (widget); - * - * if (!private_data->drag_highlight) + * + * if (!private_data->drag_highlight) * { * private_data->drag_highlight = 1; * gtk_drag_highlight (widget); * } - * + * * target = gtk_drag_dest_find_target (widget, context, NULL); * if (target == GDK_NONE) * gdk_drag_status (context, 0, time); - * else + * else * { * private_data->pending_status = context->suggested_action; * gtk_drag_get_data (widget, context, target, time); * } - * + * * return TRUE; * } - * + * * static void * drag_data_received (GtkWidget *widget, * GdkDragContext *context, @@ -2556,18 +2560,18 @@ gtk_widget_class_init (GtkWidgetClass *klass) * guint time) * { * PrivateData *private_data = GET_PRIVATE_DATA (widget); - * - * if (private_data->suggested_action) + * + * if (private_data->suggested_action) * { * private_data->suggested_action = 0; - * + * * /* We are getting this data due to a request in drag_motion, * * rather than due to a request in drag_drop, so we are just - * * supposed to call gdk_drag_status (), not actually paste in + * * supposed to call gdk_drag_status (), not actually paste in * * the data. * */ * str = gtk_selection_data_get_text (selection_data); - * if (!data_is_acceptable (str)) + * if (!data_is_acceptable (str)) * gdk_drag_status (context, 0, time); * else * gdk_drag_status (context, private_data->suggested_action, time); @@ -2601,15 +2605,15 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @time: the timestamp of the motion event * @returns: whether the cursor position is in a drop zone * - * The ::drag-drop signal is emitted on the drop site when the user drops - * the data onto the widget. The signal handler must determine whether - * the cursor position is in a drop zone or not. If it is not in a drop - * zone, it returns %FALSE and no further processing is necessary. - * Otherwise, the handler returns %TRUE. In this case, the handler must - * ensure that gtk_drag_finish() is called to let the source know that - * the drop is done. The call to gtk_drag_finish() can be done either - * directly or in a #GtkWidget::drag-data-received handler which gets - * triggered by calling gtk_drag_get_data() to receive the data for one + * The ::drag-drop signal is emitted on the drop site when the user drops + * the data onto the widget. The signal handler must determine whether + * the cursor position is in a drop zone or not. If it is not in a drop + * zone, it returns %FALSE and no further processing is necessary. + * Otherwise, the handler returns %TRUE. In this case, the handler must + * ensure that gtk_drag_finish() is called to let the source know that + * the drop is done. The call to gtk_drag_finish() can be done either + * directly or in a #GtkWidget::drag-data-received handler which gets + * triggered by calling gtk_drag_get_data() to receive the data for one * or more of the supported targets. */ widget_signals[DRAG_DROP] = @@ -2630,14 +2634,14 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @widget: the object which received the signal * @drag_context: the drag context * @data: the #GtkSelectionData to be filled with the dragged data - * @info: the info that has been registered with the target in the + * @info: the info that has been registered with the target in the * #GtkTargetList * @time: the timestamp at which the data was requested * - * The ::drag-data-get signal is emitted on the drag source when the drop - * site requests the data which is dragged. It is the responsibility of - * the signal handler to fill @data with the data in the format which - * is indicated by @info. See gtk_selection_data_set() and + * The ::drag-data-get signal is emitted on the drag source when the drop + * site requests the data which is dragged. It is the responsibility of + * the signal handler to fill @data with the data in the format which + * is indicated by @info. See gtk_selection_data_set() and * gtk_selection_data_set_text(). */ widget_signals[DRAG_DATA_GET] = @@ -2660,25 +2664,25 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @x: where the drop happened * @y: where the drop happened * @data: the received data - * @info: the info that has been registered with the target in the + * @info: the info that has been registered with the target in the * #GtkTargetList * @time: the timestamp at which the data was received * - * The ::drag-data-received signal is emitted on the drop site when the - * dragged data has been received. If the data was received in order to - * determine whether the drop will be accepted, the handler is expected - * to call gdk_drag_status() and not finish the drag. - * If the data was received in response to a #GtkWidget::drag-drop signal - * (and this is the last target to be received), the handler for this - * signal is expected to process the received data and then call - * gtk_drag_finish(), setting the @success parameter depending on whether - * the data was processed successfully. - * - * The handler may inspect and modify @drag_context->action before calling - * gtk_drag_finish(), e.g. to implement %GDK_ACTION_ASK as shown in the + * The ::drag-data-received signal is emitted on the drop site when the + * dragged data has been received. If the data was received in order to + * determine whether the drop will be accepted, the handler is expected + * to call gdk_drag_status() and not finish the drag. + * If the data was received in response to a #GtkWidget::drag-drop signal + * (and this is the last target to be received), the handler for this + * signal is expected to process the received data and then call + * gtk_drag_finish(), setting the @success parameter depending on whether + * the data was processed successfully. + * + * The handler may inspect and modify @drag_context->action before calling + * gtk_drag_finish(), e.g. to implement %GDK_ACTION_ASK as shown in the * following example: * |[ - * void + * void * drag_data_received (GtkWidget *widget, * GdkDragContext *drag_context, * gint x, @@ -2689,30 +2693,30 @@ gtk_widget_class_init (GtkWidgetClass *klass) * { * if ((data->length >= 0) && (data->format == 8)) * { - * if (drag_context->action == GDK_ACTION_ASK) + * if (drag_context->action == GDK_ACTION_ASK) * { * GtkWidget *dialog; * gint response; - * + * * dialog = gtk_message_dialog_new (NULL, - * GTK_DIALOG_MODAL | + * GTK_DIALOG_MODAL | * GTK_DIALOG_DESTROY_WITH_PARENT, * GTK_MESSAGE_INFO, * GTK_BUTTONS_YES_NO, * "Move the data ?\n"); * response = gtk_dialog_run (GTK_DIALOG (dialog)); * gtk_widget_destroy (dialog); - * + * * if (response == GTK_RESPONSE_YES) * drag_context->action = GDK_ACTION_MOVE; * else * drag_context->action = GDK_ACTION_COPY; * } - * + * * gtk_drag_finish (drag_context, TRUE, FALSE, time); * return; * } - * + * * gtk_drag_finish (drag_context, FALSE, FALSE, time); * } * ]| @@ -2731,7 +2735,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_UINT, G_TYPE_UINT); - + /** * GtkWidget::visibility-notify-event: * @widget: the object which received the signal @@ -2744,7 +2748,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * To receive this signal the #GdkWindow associated to the widget needs * to enable the #GDK_VISIBILITY_NOTIFY_MASK mask. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[VISIBILITY_NOTIFY_EVENT] = @@ -2767,7 +2771,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) * receives a message (via a ClientMessage event) from another * application. * - * Returns: %TRUE to stop other handlers from being invoked for + * Returns: %TRUE to stop other handlers from being invoked for * the event. %FALSE to propagate the event further. */ widget_signals[CLIENT_EVENT] = @@ -2786,12 +2790,12 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @event: (type Gdk.EventNoExpose): the #GdkEventNoExpose which triggered * this signal. * - * The ::no-expose-event will be emitted when the @widget's window is + * The ::no-expose-event will be emitted when the @widget's window is * drawn as a copy of another #GdkDrawable which was completely unobscured. * If the source window was partially obscured #GdkEventExpose events will * be generated for those areas. * - * Returns: %TRUE to stop other handlers from being invoked for the event. + * Returns: %TRUE to stop other handlers from being invoked for the event. * %FALSE to propagate the event further. */ widget_signals[NO_EXPOSE_EVENT] = @@ -2810,14 +2814,14 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @event: (type Gdk.EventWindowState): the #GdkEventWindowState which * triggered this signal. * - * The ::window-state-event will be emitted when the state of the + * The ::window-state-event will be emitted when the state of the * toplevel window associated to the @widget changes. * - * To receive this signal the #GdkWindow associated to the widget - * needs to enable the #GDK_STRUCTURE_MASK mask. GDK will enable + * To receive this signal the #GdkWindow associated to the widget + * needs to enable the #GDK_STRUCTURE_MASK mask. GDK will enable * this mask automatically for all new windows. * - * Returns: %TRUE to stop other handlers from being invoked for the + * Returns: %TRUE to stop other handlers from being invoked for the * event. %FALSE to propagate the event further. */ widget_signals[WINDOW_STATE_EVENT] = @@ -2859,14 +2863,14 @@ gtk_widget_class_init (GtkWidgetClass *klass) * @widget: the object which received the signal * @event: the #GdkEventGrabBroken event * - * Emitted when a pointer or keyboard grab on a window belonging - * to @widget gets broken. - * - * On X11, this happens when the grab window becomes unviewable - * (i.e. it or one of its ancestors is unmapped), or if the same + * Emitted when a pointer or keyboard grab on a window belonging + * to @widget gets broken. + * + * On X11, this happens when the grab window becomes unviewable + * (i.e. it or one of its ancestors is unmapped), or if the same * application grabs the pointer or keyboard again. * - * Returns: %TRUE to stop other handlers from being invoked for + * Returns: %TRUE to stop other handlers from being invoked for * the event. %FALSE to propagate the event further. * * Since: 2.8 @@ -2884,15 +2888,15 @@ gtk_widget_class_init (GtkWidgetClass *klass) /** * GtkWidget::query-tooltip: * @widget: the object which received the signal - * @x: the x coordinate of the cursor position where the request has + * @x: the x coordinate of the cursor position where the request has * been emitted, relative to @widget->window - * @y: the y coordinate of the cursor position where the request has + * @y: the y coordinate of the cursor position where the request has * been emitted, relative to @widget->window * @keyboard_mode: %TRUE if the tooltip was trigged using the keyboard * @tooltip: a #GtkTooltip * - * Emitted when #GtkWidget:has-tooltip is %TRUE and the #GtkSettings:gtk-tooltip-timeout - * has expired with the cursor hovering "above" @widget; or emitted when @widget got + * Emitted when #GtkWidget:has-tooltip is %TRUE and the #GtkSettings:gtk-tooltip-timeout + * has expired with the cursor hovering "above" @widget; or emitted when @widget got * focus in keyboard mode. * * Using the given coordinates, the signal handler should determine @@ -2925,11 +2929,11 @@ gtk_widget_class_init (GtkWidgetClass *klass) * GtkWidget::popup-menu * @widget: the object which received the signal * - * This signal gets emitted whenever a widget should pop up a context - * menu. This usually happens through the standard key binding mechanism; - * by pressing a certain key while a widget is focused, the user can cause - * the widget to pop up a menu. For example, the #GtkEntry widget creates - * a menu with clipboard commands. See + * This signal gets emitted whenever a widget should pop up a context + * menu. This usually happens through the standard key binding mechanism; + * by pressing a certain key while a widget is focused, the user can cause + * the widget to pop up a menu. For example, the #GtkEntry widget creates + * a menu with clipboard commands. See * for an example of how to use this signal. * * Returns: %TRUE if a menu was activated @@ -3016,7 +3020,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) gtk_binding_entry_add_signal (binding_set, GDK_KEY_F10, GDK_SHIFT_MASK, "popup-menu", 0); gtk_binding_entry_add_signal (binding_set, GDK_KEY_Menu, 0, - "popup-menu", 0); + "popup-menu", 0); gtk_binding_entry_add_signal (binding_set, GDK_KEY_F1, GDK_CONTROL_MASK, "show-help", 1, @@ -3029,7 +3033,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) gtk_binding_entry_add_signal (binding_set, GDK_KEY_F1, GDK_SHIFT_MASK, "show-help", 1, GTK_TYPE_WIDGET_HELP_TYPE, - GTK_WIDGET_HELP_WHATS_THIS); + GTK_WIDGET_HELP_WHATS_THIS); gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_F1, GDK_SHIFT_MASK, "show-help", 1, GTK_TYPE_WIDGET_HELP_TYPE, @@ -3118,7 +3122,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) /** * GtkWidget:wide-separators: * - * The "wide-separators" style property defines whether separators have + * The "wide-separators" style property defines whether separators have * configurable width and should be drawn using a box instead of a line. * * Since: 2.10 @@ -3163,7 +3167,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) /** * GtkWidget:scroll-arrow-hlength: * - * The "scroll-arrow-hlength" style property defines the length of + * The "scroll-arrow-hlength" style property defines the length of * horizontal scroll arrows. * * Since: 2.10 @@ -3178,7 +3182,7 @@ gtk_widget_class_init (GtkWidgetClass *klass) /** * GtkWidget:scroll-arrow-vlength: * - * The "scroll-arrow-vlength" style property defines the length of + * The "scroll-arrow-vlength" style property defines the length of * vertical scroll arrows. * * Since: 2.10 @@ -3287,7 +3291,7 @@ gtk_widget_set_property (GObject *object, tooltip_window = g_object_get_qdata (object, quark_tooltip_window); tooltip_markup = g_value_dup_string (value); - /* Treat an empty string as a NULL string, + /* Treat an empty string as a NULL string, * because an empty string would be useless for a tooltip: */ if (tooltip_markup && (strlen (tooltip_markup) == 0)) @@ -3309,7 +3313,7 @@ gtk_widget_set_property (GObject *object, tooltip_text = g_value_get_string (value); - /* Treat an empty string as a NULL string, + /* Treat an empty string as a NULL string, * because an empty string would be useless for a tooltip: */ if (tooltip_text && (strlen (tooltip_text) == 0)) @@ -3599,10 +3603,10 @@ gtk_widget_dispatch_child_properties_changed (GtkWidget *widget, /** * gtk_widget_freeze_child_notify: * @widget: a #GtkWidget - * - * Stops emission of #GtkWidget::child-notify signals on @widget. The - * signals are queued until gtk_widget_thaw_child_notify() is called - * on @widget. + * + * Stops emission of #GtkWidget::child-notify signals on @widget. The + * signals are queued until gtk_widget_thaw_child_notify() is called + * on @widget. * * This is the analogue of g_object_freeze_notify() for child properties. **/ @@ -3622,11 +3626,11 @@ gtk_widget_freeze_child_notify (GtkWidget *widget) /** * gtk_widget_child_notify: * @widget: a #GtkWidget - * @child_property: the name of a child property installed on the + * @child_property: the name of a child property installed on the * class of @widget's parent - * - * Emits a #GtkWidget::child-notify signal for the - * child property @child_property + * + * Emits a #GtkWidget::child-notify signal for the + * child property @child_property * on @widget. * * This is the analogue of g_object_notify() for child properties. @@ -3668,9 +3672,9 @@ gtk_widget_child_notify (GtkWidget *widget, * @widget: a #GtkWidget * * Reverts the effect of a previous call to gtk_widget_freeze_child_notify(). - * This causes all queued #GtkWidget::child-notify signals on @widget to be + * This causes all queued #GtkWidget::child-notify signals on @widget to be * emitted. - */ + */ void gtk_widget_thaw_child_notify (GtkWidget *widget) { @@ -3696,16 +3700,16 @@ gtk_widget_thaw_child_notify (GtkWidget *widget) * gtk_widget_new: * @type: type ID of the widget to create * @first_property_name: name of first property to set - * @Varargs: value of first property, followed by more properties, + * @Varargs: value of first property, followed by more properties, * %NULL-terminated - * + * * This is a convenience function for creating a widget and setting * its properties in one go. For example you might write: * gtk_widget_new (GTK_TYPE_LABEL, "label", "Hello World", "xalign", * 0.0, NULL) to create a left-aligned label. Equivalent to * g_object_new(), but returns a widget so you don't have to * cast the object yourself. - * + * * Return value: a new #GtkWidget of type @widget_type **/ GtkWidget* @@ -3715,9 +3719,9 @@ gtk_widget_new (GType type, { GtkWidget *widget; va_list var_args; - + g_return_val_if_fail (g_type_is_a (type, GTK_TYPE_WIDGET), NULL); - + va_start (var_args, first_property_name); widget = (GtkWidget *)g_object_new_valist (type, first_property_name, var_args); va_end (var_args); @@ -3725,7 +3729,7 @@ gtk_widget_new (GType type, return widget; } -static inline void +static inline void gtk_widget_queue_draw_child (GtkWidget *widget) { GtkWidgetPrivate *priv = widget->priv; @@ -3743,7 +3747,7 @@ gtk_widget_queue_draw_child (GtkWidget *widget) /** * gtk_widget_unparent: * @widget: a #GtkWidget - * + * * This function is only for use in widget implementations. * Should be called by implementations of the remove method * on #GtkContainer, to dissociate a child from the container. @@ -3755,14 +3759,14 @@ gtk_widget_unparent (GtkWidget *widget) GObjectNotifyQueue *nqueue; GtkWidget *toplevel; GtkWidget *old_parent; - + g_return_if_fail (GTK_IS_WIDGET (widget)); priv = widget->priv; if (priv->parent == NULL) return; - + /* keep this function in sync with gtk_menu_detach() */ @@ -3793,7 +3797,7 @@ gtk_widget_unparent (GtkWidget *widget) */ priv->allocation.width = 1; priv->allocation.height = 1; - + if (gtk_widget_get_realized (widget)) { if (priv->in_reparent) @@ -3807,7 +3811,7 @@ gtk_widget_unparent (GtkWidget *widget) * in the next parent. */ priv->child_visible = TRUE; - + old_parent = priv->parent; priv->parent = NULL; gtk_widget_set_parent_window (widget, NULL); @@ -3896,7 +3900,7 @@ gtk_widget_destroyed (GtkWidget *widget, /** * gtk_widget_show: * @widget: a #GtkWidget - * + * * Flags a widget to be displayed. Any widget that isn't shown will * not appear on the screen. If you want to show all the widgets in a * container, it's easier to call gtk_widget_show_all() on the @@ -3959,14 +3963,14 @@ gtk_widget_show_map_callback (GtkWidget *widget, GdkEvent *event, gint *flag) { *flag = TRUE; g_signal_handlers_disconnect_by_func (widget, - gtk_widget_show_map_callback, + gtk_widget_show_map_callback, flag); } /** * gtk_widget_show_now: * @widget: a #GtkWidget - * + * * Shows a widget. If the widget is an unmapped toplevel widget * (i.e. a #GtkWindow that has not yet been shown), enter the main * loop and wait for the window to actually be mapped. Be careful; @@ -3977,7 +3981,7 @@ void gtk_widget_show_now (GtkWidget *widget) { gint flag = FALSE; - + g_return_if_fail (GTK_IS_WIDGET (widget)); /* make sure we will get event */ @@ -3987,7 +3991,7 @@ gtk_widget_show_now (GtkWidget *widget) gtk_widget_show (widget); g_signal_connect (widget, "map-event", - G_CALLBACK (gtk_widget_show_map_callback), + G_CALLBACK (gtk_widget_show_map_callback), &flag); while (!flag) @@ -4000,7 +4004,7 @@ gtk_widget_show_now (GtkWidget *widget) /** * gtk_widget_hide: * @widget: a #GtkWidget - * + * * Reverses the effects of gtk_widget_show(), causing the widget to be * hidden (invisible to the user). **/ @@ -4008,11 +4012,11 @@ void gtk_widget_hide (GtkWidget *widget) { g_return_if_fail (GTK_IS_WIDGET (widget)); - + if (gtk_widget_get_visible (widget)) { GtkWidget *toplevel = gtk_widget_get_toplevel (widget); - + g_object_ref (widget); if (toplevel != widget && gtk_widget_is_toplevel (toplevel)) _gtk_window_unset_focus_and_default (GTK_WINDOW (toplevel), widget); @@ -4039,7 +4043,7 @@ gtk_widget_real_hide (GtkWidget *widget) if (gtk_widget_get_visible (widget)) { widget->priv->visible = FALSE; - + if (gtk_widget_get_mapped (widget)) gtk_widget_unmap (widget); } @@ -4048,7 +4052,7 @@ gtk_widget_real_hide (GtkWidget *widget) /** * gtk_widget_hide_on_delete: * @widget: a #GtkWidget - * + * * Utility function; intended to be connected to the #GtkWidget::delete-event * signal on a #GtkWindow. The function calls gtk_widget_hide() on its * argument, then returns %TRUE. If connected to ::delete-event, the @@ -4056,23 +4060,23 @@ gtk_widget_real_hide (GtkWidget *widget) * window frame, top right corner usually) will hide but not destroy * the window. By default, GTK+ destroys windows when ::delete-event * is received. - * + * * Return value: %TRUE **/ gboolean gtk_widget_hide_on_delete (GtkWidget *widget) { g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); - + gtk_widget_hide (widget); - + return TRUE; } /** * gtk_widget_show_all: * @widget: a #GtkWidget - * + * * Recursively shows a widget, and any child widgets (if the widget is * a container). **/ @@ -4095,7 +4099,7 @@ gtk_widget_show_all (GtkWidget *widget) /** * gtk_widget_map: * @widget: a #GtkWidget - * + * * This function is only for use in widget implementations. Causes * a widget to be mapped if it isn't already. **/ @@ -4221,13 +4225,13 @@ _gtk_widget_enable_device_events (GtkWidget *widget) /** * gtk_widget_realize: * @widget: a #GtkWidget - * + * * Creates the GDK (windowing system) resources associated with a * widget. For example, @widget->window will be created when a widget * is realized. Normally realization happens implicitly; if you show * a widget and all its parent containers, then the widget will be * realized and mapped automatically. - * + * * Realizing a widget requires all * the widget's parent widgets to be realized; calling * gtk_widget_realize() realizes the widget's parents in addition to @@ -4247,7 +4251,7 @@ gtk_widget_realize (GtkWidget *widget) GtkWidgetPrivate *priv; GdkExtensionMode mode; cairo_region_t *region; - + g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (widget->priv->anchored || GTK_IS_INVISIBLE (widget)); @@ -4266,12 +4270,12 @@ gtk_widget_realize (GtkWidget *widget) g_warning ("Calling gtk_widget_realize() on a widget that isn't " "inside a toplevel window is not going to work very well. " "Widgets must be inside a toplevel container before realizing them."); - + if (priv->parent && !gtk_widget_get_realized (priv->parent)) gtk_widget_realize (priv->parent); gtk_widget_ensure_style (widget); - + g_signal_emit (widget, widget_signals[REALIZE], 0); gtk_widget_real_set_has_tooltip (widget, @@ -4283,7 +4287,7 @@ gtk_widget_realize (GtkWidget *widget) region = g_object_get_qdata (G_OBJECT (widget), quark_shape_info); gdk_window_shape_combine_region (priv->window, region, 0, 0); } - + region = g_object_get_qdata (G_OBJECT (widget), quark_input_shape_info); if (region) gdk_window_input_shape_combine_region (priv->window, region, 0, 0); @@ -4349,20 +4353,20 @@ gtk_widget_unrealize (GtkWidget *widget) * implementations. You might also use it to schedule a redraw of a * #GtkDrawingArea or some portion thereof. **/ -void +void gtk_widget_queue_draw_region (GtkWidget *widget, cairo_region_t *region) { GtkWidgetPrivate *priv; GtkWidget *w; - + g_return_if_fail (GTK_IS_WIDGET (widget)); priv = widget->priv; if (!gtk_widget_get_realized (widget)) return; - + /* Just return if the widget or one of its ancestors isn't mapped */ for (w = widget; w != NULL; w = w->priv->parent) if (!gtk_widget_get_mapped (w)) @@ -4382,7 +4386,7 @@ gtk_widget_queue_draw_region (GtkWidget *widget, * Convenience function that calls gtk_widget_queue_draw_region() on * the region created from the given coordinates. **/ -void +void gtk_widget_queue_draw_area (GtkWidget *widget, gint x, gint y, @@ -4411,11 +4415,11 @@ gtk_widget_queue_draw_area (GtkWidget *widget, * Equivalent to calling gtk_widget_queue_draw_area() for the * entire area of a widget. **/ -void +void gtk_widget_queue_draw (GtkWidget *widget) { GdkRectangle rect; - + g_return_if_fail (GTK_IS_WIDGET (widget)); gtk_widget_get_allocation (widget, &rect); @@ -4445,7 +4449,7 @@ gtk_widget_queue_resize (GtkWidget *widget) if (gtk_widget_get_realized (widget)) gtk_widget_queue_shallow_draw (widget); - + _gtk_size_group_queue_resize (widget, 0); } @@ -4453,7 +4457,7 @@ gtk_widget_queue_resize (GtkWidget *widget) * gtk_widget_queue_resize_no_redraw: * @widget: a #GtkWidget * - * This function works like gtk_widget_queue_resize(), + * This function works like gtk_widget_queue_resize(), * except that the widget is not invalidated. * * Since: 2.4 @@ -4470,7 +4474,7 @@ gtk_widget_queue_resize_no_redraw (GtkWidget *widget) * gtk_widget_size_request: * @widget: a #GtkWidget * @requisition: (out): a #GtkRequisition to be filled in - * + * * This function is typically used when implementing a #GtkContainer * subclass. Obtains the preferred size of a widget. The container * uses this information to arrange its child widgets and decide what @@ -4499,7 +4503,7 @@ gtk_widget_size_request (GtkWidget *widget, * gtk_widget_get_child_requisition: * @widget: a #GtkWidget * @requisition: (out): a #GtkRequisition to be filled in - * + * * This function is only for use in widget implementations. Obtains * @widget->requisition, unless someone has forced a particular * geometry on the widget (e.g. with gtk_widget_set_size_request()), @@ -4553,7 +4557,7 @@ gtk_widget_invalidate_widget_windows (GtkWidget *widget, if (!gtk_widget_get_realized (widget)) return; - + if (gtk_widget_get_has_window (widget) && priv->parent) { int x, y; @@ -4620,7 +4624,7 @@ gtk_widget_size_allocate (GtkWidget *widget, priv = widget->priv; g_return_if_fail (GTK_IS_WIDGET (widget)); - + #ifdef G_ENABLE_DEBUG if (gtk_get_debug_flags () & GTK_DEBUG_GEOMETRY) { @@ -4635,14 +4639,14 @@ gtk_widget_size_allocate (GtkWidget *widget, depth++; parent = gtk_widget_get_parent (parent); } - + name = g_type_name (G_OBJECT_TYPE (G_OBJECT (widget))); - g_print ("gtk_widget_size_allocate: %*s%s %d %d\n", - 2 * depth, " ", name, + g_print ("gtk_widget_size_allocate: %*s%s %d %d\n", + 2 * depth, " ", name, allocation->width, allocation->height); } #endif /* G_ENABLE_DEBUG */ - + alloc_needed = priv->alloc_needed; if (!priv->width_request_needed && !priv->height_request_needed) /* Preserve request/allocate ordering */ @@ -4671,7 +4675,7 @@ gtk_widget_size_allocate (GtkWidget *widget, gtk_widget_get_preferred_width_for_height (widget, real_allocation.height, NULL, &natural_width); } - /* Now that we have the right natural height and width, go ahead and remove any margins from the + /* Now that we have the right natural height and width, go ahead and remove any margins from the * allocated sizes and possibly limit them to the natural sizes */ GTK_WIDGET_GET_CLASS (widget)->adjust_size_allocation (widget, GTK_ORIENTATION_HORIZONTAL, @@ -4708,7 +4712,7 @@ gtk_widget_size_allocate (GtkWidget *widget, real_allocation.width, real_allocation.height); } - + real_allocation.width = MAX (real_allocation.width, 1); real_allocation.height = MAX (real_allocation.height, 1); @@ -4719,7 +4723,7 @@ gtk_widget_size_allocate (GtkWidget *widget, if (!alloc_needed && !size_changed && !position_changed) return; - + g_signal_emit (widget, widget_signals[SIZE_ALLOCATE], 0, &real_allocation); if (gtk_widget_get_mapped (widget)) @@ -4734,7 +4738,7 @@ gtk_widget_size_allocate (GtkWidget *widget, gdk_window_invalidate_region (priv->window, invalidate, FALSE); cairo_region_destroy (invalidate); } - + if (size_changed) { if (priv->redraw_on_alloc) @@ -4763,10 +4767,10 @@ gtk_widget_size_allocate (GtkWidget *widget, * gtk_widget_common_ancestor: * @widget_a: a #GtkWidget * @widget_b: a #GtkWidget - * + * * Find the common ancestor of @widget_a and @widget_b that * is closest to the two widgets. - * + * * Return value: the closest common ancestor of @widget_a and * @widget_b or %NULL if @widget_a and @widget_b do not * share a common ancestor. @@ -4831,7 +4835,7 @@ gtk_widget_common_ancestor (GtkWidget *widget_a, * relative to @dest_widget's allocations. In order to perform this * operation, both widgets must be realized, and must share a common * toplevel. - * + * * Return value: %FALSE if either widget was not realized, or there * was no common ancestor. In this case, nothing is stored in * *@dest_x and *@dest_y. Otherwise %TRUE. @@ -5045,7 +5049,7 @@ gtk_widget_real_can_activate_accel (GtkWidget *widget, * gtk_widget_can_activate_accel: * @widget: a #GtkWidget * @signal_id: the ID of a signal installed on @widget - * + * * Determines whether an accelerator that activates the signal * identified by @signal_id can currently be activated. * This is done by emitting the #GtkWidget::can-activate-accel @@ -5128,7 +5132,7 @@ widget_new_accel_closure (GtkWidget *widget, g_closure_set_marshal (closure, closure_accel_activate); } g_object_set_qdata_full (G_OBJECT (widget), quark_accel_closures, closures, closures_destroy); - + aclosure = (AccelClosure*) closure; g_assert (closure->data == widget); g_assert (closure->marshal == closure_accel_activate); @@ -5220,7 +5224,7 @@ gtk_widget_remove_accelerator (GtkWidget *widget, GtkAccelGroupEntry *ag_entry; GList *slist, *clist; guint n; - + g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); g_return_val_if_fail (GTK_IS_ACCEL_GROUP (accel_group), FALSE); @@ -5294,7 +5298,7 @@ destroy_accel_path (gpointer data) /* closures_destroy takes care of unrefing the closure */ g_object_unref (apath->accel_group); - + g_slice_free (AccelPath, apath); } @@ -5322,9 +5326,9 @@ destroy_accel_path (gpointer data) * Even when you you aren't using #GtkUIManager, if you only want to * set up accelerators on menu items gtk_menu_item_set_accel_path() * provides a somewhat more convenient interface. - * + * * Note that @accel_path string will be stored in a #GQuark. Therefore, if you - * pass a static string, you can save some memory by interning it first with + * pass a static string, you can save some memory by interning it first with * g_intern_static_string(). **/ void @@ -5380,7 +5384,7 @@ _gtk_widget_get_accel_path (GtkWidget *widget, * @group_cycling: %TRUE if there are other widgets with the same mnemonic * * Emits the #GtkWidget::mnemonic-activate signal. - * + * * The default handler for this signal activates the @widget if * @group_cycling is %FALSE, and just grabs the focus if @group_cycling * is %TRUE. @@ -5392,7 +5396,7 @@ gtk_widget_mnemonic_activate (GtkWidget *widget, gboolean group_cycling) { gboolean handled; - + g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); group_cycling = group_cycling != FALSE; @@ -5468,7 +5472,7 @@ gtk_cairo_should_draw_window (cairo_t *cr, g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE); event = _gtk_cairo_get_event (cr); - + return event == NULL || event->window == window; } @@ -5486,7 +5490,7 @@ _gtk_widget_draw_internal (GtkWidget *widget, if (clip_to_size) { - cairo_rectangle (cr, + cairo_rectangle (cr, 0, 0, widget->priv->allocation.width, widget->priv->allocation.height); @@ -5497,7 +5501,7 @@ _gtk_widget_draw_internal (GtkWidget *widget, { gboolean result; - g_signal_emit (widget, widget_signals[DRAW], + g_signal_emit (widget, widget_signals[DRAW], 0, cr, &result); } @@ -5505,7 +5509,7 @@ _gtk_widget_draw_internal (GtkWidget *widget, /** * gtk_widget_draw: - * @widget: the widget to draw. It must be drawable (see + * @widget: the widget to draw. It must be drawable (see * gtk_widget_is_drawable()) and a size must have been allocated. * @cr: a cairo context to draw to * @@ -5590,7 +5594,7 @@ gtk_widget_real_focus_out_event (GtkWidget *widget, * gtk_widget_event: * @widget: a #GtkWidget * @event: a #GdkEvent - * + * * Rarely-used function. This function is used to emit * the event signals on a widget (those signals should never * be emitted without using this function to do so). @@ -5599,8 +5603,8 @@ gtk_widget_real_focus_out_event (GtkWidget *widget, * it were in the event queue. Don't synthesize expose events; instead, * use gdk_window_invalidate_rect() to invalidate a region of the * window. - * - * Return value: return from the event signal emission (%TRUE if + * + * Return value: return from the event signal emission (%TRUE if * the event was handled) **/ gboolean @@ -5617,7 +5621,7 @@ gtk_widget_event (GtkWidget *widget, "followed by gdk_window_process_updates()."); return TRUE; } - + return gtk_widget_event_internal (widget, event); } @@ -5651,8 +5655,8 @@ gtk_widget_get_translation_to_window (GtkWidget *widget, *y += wy; } - if (w == NULL) - { + if (w == NULL) + { *x = 0; *y = 0; return FALSE; @@ -5697,19 +5701,19 @@ gtk_cairo_transform_to_window (cairo_t *cr, * gtk_widget_send_expose: * @widget: a #GtkWidget * @event: a expose #GdkEvent - * + * * Very rarely-used function. This function is used to emit * an expose event on a widget. This function is not normally used * directly. The only time it is used is when propagating an expose * event to a child %NO_WINDOW widget, and that is normally done * using gtk_container_propagate_draw(). * - * If you want to force an area of a window to be redrawn, + * If you want to force an area of a window to be redrawn, * use gdk_window_invalidate_rect() or gdk_window_invalidate_region(). * To cause the redraw to be done immediately, follow that call * with a call to gdk_window_process_updates(). - * - * Return value: return from the event signal emission (%TRUE if + * + * Return value: return from the event signal emission (%TRUE if * the event was handled) **/ gint @@ -5777,8 +5781,8 @@ event_window_is_still_viewable (GdkEvent *event) case GDK_KEY_RELEASE: case GDK_LEAVE_NOTIFY: case GDK_PROXIMITY_OUT: -#endif - +#endif + default: /* Remaining events would make sense on an not-viewable window, * or don't have an associated window. @@ -5923,19 +5927,19 @@ gtk_widget_event_internal (GtkWidget *widget, /** * gtk_widget_activate: * @widget: a #GtkWidget that's activatable - * + * * For widgets that can be "activated" (buttons, menu items, etc.) * this function activates them. Activation is what happens when you - * press Enter on a widget during key navigation. If @widget isn't + * press Enter on a widget during key navigation. If @widget isn't * activatable, the function returns %FALSE. - * + * * Return value: %TRUE if the widget was activatable **/ gboolean gtk_widget_activate (GtkWidget *widget) { g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); - + if (WIDGET_CLASS (widget)->activate_signal) { /* FIXME: we should eventually check the signals signature here */ @@ -5985,7 +5989,7 @@ gtk_widget_reparent_subwindows (GtkWidget *widget, else { children = gdk_window_get_children (parent); - + for (tmp_list = children; tmp_list; tmp_list = tmp_list->next) { GdkWindow *window = tmp_list->data; @@ -5996,7 +6000,7 @@ gtk_widget_reparent_subwindows (GtkWidget *widget, if (child == widget) gdk_window_reparent (window, new_window, 0, 0); } - + g_list_free (children); } } @@ -6009,7 +6013,7 @@ gtk_widget_reparent_fixup_child (GtkWidget *widget, GtkWidgetPrivate *priv = widget->priv; g_assert (client_data != NULL); - + if (!gtk_widget_get_has_window (widget)) { if (priv->window) @@ -6052,12 +6056,12 @@ gtk_widget_reparent (GtkWidget *widget, */ if (gtk_widget_get_realized (widget) && gtk_widget_get_realized (new_parent)) priv->in_reparent = TRUE; - + g_object_ref (widget); gtk_container_remove (GTK_CONTAINER (priv->parent), widget); gtk_container_add (GTK_CONTAINER (new_parent), widget); g_object_unref (widget); - + if (priv->in_reparent) { priv->in_reparent = FALSE; @@ -6076,12 +6080,12 @@ gtk_widget_reparent (GtkWidget *widget, * @widget: a #GtkWidget * @area: a rectangle * @intersection: rectangle to store intersection of @widget and @area - * + * * Computes the intersection of a @widget's area and @area, storing * the intersection in @intersection, and returns %TRUE if there was * an intersection. @intersection may be %NULL if you're only * interested in whether there was an intersection. - * + * * Return value: %TRUE if there was an intersection **/ gboolean @@ -6093,7 +6097,7 @@ gtk_widget_intersect (GtkWidget *widget, GdkRectangle *dest; GdkRectangle tmp; gint return_val; - + g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); g_return_val_if_fail (area != NULL, FALSE); @@ -6103,22 +6107,22 @@ gtk_widget_intersect (GtkWidget *widget, dest = intersection; else dest = &tmp; - + return_val = gdk_rectangle_intersect (&priv->allocation, area, dest); - + if (return_val && intersection && gtk_widget_get_has_window (widget)) { intersection->x -= priv->allocation.x; intersection->y -= priv->allocation.y; } - + return return_val; } /** * gtk_widget_region_intersect: * @widget: a #GtkWidget - * @region: a #cairo_region_t, in the same coordinate system as + * @region: a #cairo_region_t, in the same coordinate system as * @widget->allocation. That is, relative to @widget->window * for %NO_WINDOW widgets; relative to the parent window * of @widget->window for widgets with their own window. @@ -6127,7 +6131,7 @@ gtk_widget_intersect (GtkWidget *widget, * relative to @widget->window for %NO_WINDOW widgets, and * relative to the parent window of @widget->window for * widgets with their own window. - * + * * Computes the intersection of a @widget's area and @region, returning * the intersection. The result may be empty, use cairo_region_is_empty() to * check. @@ -6138,14 +6142,14 @@ gtk_widget_region_intersect (GtkWidget *widget, { GdkRectangle rect; cairo_region_t *dest; - + g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); g_return_val_if_fail (region != NULL, NULL); gtk_widget_get_allocation (widget, &rect); - + dest = cairo_region_create_rectangle (&rect); - + cairo_region_intersect (dest, region); return dest; @@ -6155,9 +6159,9 @@ gtk_widget_region_intersect (GtkWidget *widget, * _gtk_widget_grab_notify: * @widget: a #GtkWidget * @was_grabbed: whether a grab is now in effect - * + * * Emits the #GtkWidget::grab-notify signal on @widget. - * + * * Since: 2.6 **/ void @@ -6170,7 +6174,7 @@ _gtk_widget_grab_notify (GtkWidget *widget, /** * gtk_widget_grab_focus: * @widget: a #GtkWidget - * + * * Causes @widget to have the keyboard focus for the #GtkWindow it's * inside. @widget must be a focusable widget, such as a #GtkEntry; * something like #GtkFrame won't work. @@ -6189,7 +6193,7 @@ gtk_widget_grab_focus (GtkWidget *widget) if (!gtk_widget_is_sensitive (widget)) return; - + g_object_ref (widget); g_signal_emit (widget, widget_signals[GRAB_FOCUS], 0); g_object_notify (G_OBJECT (widget), "has-focus"); @@ -6220,7 +6224,7 @@ gtk_widget_real_grab_focus (GtkWidget *focus_widget) { GtkWidget *toplevel; GtkWidget *widget; - + /* clear the current focus setting, break if the current widget * is the focus widget's parent, since containers above that will * be set by the next loop. @@ -6241,7 +6245,7 @@ gtk_widget_real_grab_focus (GtkWidget *focus_widget) return; } - + if (widget) { while (widget->priv->parent && widget->priv->parent != focus_widget->priv->parent) @@ -6256,7 +6260,7 @@ gtk_widget_real_grab_focus (GtkWidget *focus_widget) /* gtk_widget_grab_focus() operates on a tree without window... * actually, this is very questionable behaviour. */ - + gtk_container_foreach (GTK_CONTAINER (toplevel), reset_focus_recurse, NULL); @@ -6318,7 +6322,7 @@ gtk_widget_real_focus (GtkWidget *widget, { if (!gtk_widget_get_can_focus (widget)) return FALSE; - + if (!gtk_widget_is_focus (widget)) { gtk_widget_grab_focus (widget); @@ -6438,12 +6442,12 @@ gtk_widget_has_focus (GtkWidget *widget) /** * gtk_widget_is_focus: * @widget: a #GtkWidget - * + * * Determines if the widget is the focus widget within its * toplevel. (This does not mean that the %HAS_FOCUS flag is * necessarily set; %HAS_FOCUS will only be set if the * toplevel widget additionally has the global input focus.) - * + * * Return value: %TRUE if the widget is the focus widget. **/ gboolean @@ -6454,7 +6458,7 @@ gtk_widget_is_focus (GtkWidget *widget) g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); toplevel = gtk_widget_get_toplevel (widget); - + if (GTK_IS_WINDOW (toplevel)) return widget == gtk_window_get_focus (GTK_WINDOW (toplevel)); else @@ -6540,8 +6544,8 @@ _gtk_widget_set_has_default (GtkWidget *widget, * Causes @widget to become the default widget. @widget must have the * %GTK_CAN_DEFAULT flag set; typically you have to set this flag * yourself by calling gtk_widget_set_can_default (@widget, - * %TRUE). The default widget is activated when - * the user presses Enter in a window. Default widgets must be + * %TRUE). The default widget is activated when + * the user presses Enter in a window. Default widgets must be * activatable, that is, gtk_widget_activate() should affect them. Note * that #GtkEntry widgets require the "activates-default" property * set to %TRUE before they activate the default widget when Enter @@ -6551,12 +6555,12 @@ void gtk_widget_grab_default (GtkWidget *widget) { GtkWidget *window; - + g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (gtk_widget_get_can_default (widget)); - + window = gtk_widget_get_toplevel (widget); - + if (window && gtk_widget_is_toplevel (window)) gtk_window_set_default (GTK_WINDOW (window), widget); else @@ -6703,8 +6707,8 @@ gtk_widget_device_is_shadowed (GtkWidget *widget, * gtkrc file. You can apply a style to widgets with a particular name * in the gtkrc file. See the documentation for gtkrc files (on the * same page as the docs for #GtkRcStyle). - * - * Note that widget names are separated by periods in paths (see + * + * Note that widget names are separated by periods in paths (see * gtk_widget_path()), so names with embedded periods may cause confusion. **/ void @@ -6713,7 +6717,7 @@ gtk_widget_set_name (GtkWidget *widget, { GtkWidgetPrivate *priv; gchar *new_name; - + g_return_if_fail (GTK_IS_WIDGET (widget)); priv = widget->priv; @@ -6731,10 +6735,10 @@ gtk_widget_set_name (GtkWidget *widget, /** * gtk_widget_get_name: * @widget: a #GtkWidget - * + * * Retrieves the name of a widget. See gtk_widget_set_name() for the * significance of widget names. - * + * * Return value: name of the widget. This string is owned by GTK+ and * should not be modified or freed **/ @@ -6789,7 +6793,7 @@ gtk_widget_set_state (GtkWidget *widget, data.parent_sensitive = TRUE; gtk_widget_propagate_state (widget, &data); - + if (gtk_widget_is_drawable (widget)) gtk_widget_queue_draw (widget); } @@ -7049,13 +7053,13 @@ gtk_widget_set_mapped (GtkWidget *widget, * @app_paintable: %TRUE if the application will paint on the widget * * Sets whether the application intends to draw on the widget in - * an #GtkWidget::draw handler. + * an #GtkWidget::draw handler. * - * This is a hint to the widget and does not affect the behavior of - * the GTK+ core; many widgets ignore this flag entirely. For widgets - * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow, - * the effect is to suppress default themed drawing of the widget's - * background. (Children of the widget will still be drawn.) The application + * This is a hint to the widget and does not affect the behavior of + * the GTK+ core; many widgets ignore this flag entirely. For widgets + * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow, + * the effect is to suppress default themed drawing of the widget's + * background. (Children of the widget will still be drawn.) The application * is then entirely responsible for drawing the widget background. * * Note that the background is still drawn when the widget is mapped. @@ -7118,10 +7122,10 @@ gtk_widget_get_app_paintable (GtkWidget *widget) * In very simple terms, double buffered widgets don't flicker, * so you would only use this function to turn off double buffering * if you had special needs and really knew what you were doing. - * + * * Note: if you turn off double-buffering, you have to handle - * expose events, since even the clearing to the background color or - * pixmap will not happen automatically (as it is done in + * expose events, since even the clearing to the background color or + * pixmap will not happen automatically (as it is done in * gdk_window_begin_paint()). **/ void @@ -7167,7 +7171,7 @@ gtk_widget_get_double_buffered (GtkWidget *widget) * when it is allocated to a new size. Otherwise, only the * new portion of the widget will be redrawn. * - * Sets whether the entire widget is queued for drawing when its size + * Sets whether the entire widget is queued for drawing when its size * allocation changes. By default, this setting is %TRUE and * the entire widget is redrawn on every size change. If your widget * leaves the upper left unchanged when made bigger, turning this @@ -7177,8 +7181,8 @@ gtk_widget_get_double_buffered (GtkWidget *widget) * off all allocation on resizing: the widget will not even redraw if * its position changes; this is to allow containers that don't draw * anything to avoid excess invalidations. If you set this flag on a - * %NO_WINDOW widget that does draw on @widget->window, - * you are responsible for invalidating both the old and new allocation + * %NO_WINDOW widget that does draw on @widget->window, + * you are responsible for invalidating both the old and new allocation * of the widget when the widget is moved and responsible for invalidating * regions newly when the widget increases size. **/ @@ -7288,7 +7292,7 @@ gtk_widget_is_sensitive (GtkWidget *widget) * @widget: a #GtkWidget * @parent: parent container * - * This function is useful only when implementing subclasses of + * This function is useful only when implementing subclasses of * #GtkContainer. * Sets the container as the parent of @widget, and takes care of * some details such as updating the state and style of the child @@ -7301,7 +7305,7 @@ gtk_widget_set_parent (GtkWidget *widget, { GtkWidgetPrivate *priv; GtkStateData data; - + g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (GTK_IS_WIDGET (parent)); g_return_if_fail (widget != parent); @@ -7334,7 +7338,7 @@ gtk_widget_set_parent (GtkWidget *widget, data.use_forall = gtk_widget_is_sensitive (parent) != gtk_widget_is_sensitive (widget); gtk_widget_propagate_state (widget, &data); - + gtk_widget_reset_rc_styles (widget); g_signal_emit (widget, widget_signals[PARENT_SET], 0, NULL); @@ -7469,10 +7473,10 @@ gtk_widget_set_style (GtkWidget *widget, gboolean initial_emission; initial_emission = !widget->priv->rc_style && !widget->priv->user_style; - + widget->priv->rc_style = FALSE; widget->priv->user_style = TRUE; - + gtk_widget_set_style_internal (widget, style, initial_emission); } else @@ -7527,7 +7531,7 @@ gtk_widget_reset_rc_style (GtkWidget *widget) /** * gtk_widget_get_style: * @widget: a #GtkWidget - * + * * Simply an accessor function that returns @widget->style. * * Return value: (transfer none): the widget's #GtkStyle @@ -7544,7 +7548,7 @@ gtk_widget_get_style (GtkWidget *widget) * gtk_widget_modify_style: * @widget: a #GtkWidget * @style: the #GtkRcStyle holding the style modifications - * + * * Modifies style values on the widget. Modifications made using this * technique take precedence over style values set via an RC file, * however, they will be overriden if a style is explicitely set on @@ -7563,13 +7567,13 @@ gtk_widget_get_style (GtkWidget *widget) * to such functions gtk_widget_modify_fg() will have a cumulative * effect with the initial modifications. **/ -void +void gtk_widget_modify_style (GtkWidget *widget, GtkRcStyle *style) { g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (GTK_IS_RC_STYLE (style)); - + g_object_set_qdata_full (G_OBJECT (widget), quark_rc_style, gtk_rc_style_copy (style), @@ -7578,7 +7582,7 @@ gtk_widget_modify_style (GtkWidget *widget, /* note that "style" may be invalid here if it was the old * modifier style and the only reference was our own. */ - + if (widget->priv->rc_style) gtk_widget_reset_rc_style (widget); } @@ -7586,7 +7590,7 @@ gtk_widget_modify_style (GtkWidget *widget, /** * gtk_widget_get_modifier_style: * @widget: a #GtkWidget - * + * * Returns the current modifier style for the widget. (As set by * gtk_widget_modify_style().) If no style has previously set, a new * #GtkRcStyle will be created with all values unset, and set as the @@ -7608,7 +7612,7 @@ GtkRcStyle * gtk_widget_get_modifier_style (GtkWidget *widget) { GtkRcStyle *rc_style; - + g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); rc_style = g_object_get_qdata (G_OBJECT (widget), quark_rc_style); @@ -7631,7 +7635,7 @@ gtk_widget_modify_color_component (GtkWidget *widget, GtkStateType state, const GdkColor *color) { - GtkRcStyle *rc_style = gtk_widget_get_modifier_style (widget); + GtkRcStyle *rc_style = gtk_widget_get_modifier_style (widget); if (color) { @@ -7652,7 +7656,7 @@ gtk_widget_modify_color_component (GtkWidget *widget, default: g_assert_not_reached(); } - + rc_style->color_flags[state] |= component; } else @@ -7720,14 +7724,14 @@ gtk_widget_modify_fg (GtkWidget *widget, * * Sets the background color for a widget in a particular state. * All other style values are left untouched. See also - * gtk_widget_modify_style(). + * gtk_widget_modify_style(). * * Note that "no window" widgets (which have the %GTK_NO_WINDOW flag set) - * draw on their parent container's window and thus may not draw any - * background themselves. This is the case for e.g. #GtkLabel. To modify - * the background of such widgets, you have to set the background color - * on their parent; if you want to set the background of a rectangular - * area around a label, try placing the label in a #GtkEventBox widget + * draw on their parent container's window and thus may not draw any + * background themselves. This is the case for e.g. #GtkLabel. To modify + * the background of such widgets, you have to set the background color + * on their parent; if you want to set the background of a rectangular + * area around a label, try placing the label in a #GtkEventBox widget * and setting the background color on that. **/ void @@ -7781,11 +7785,11 @@ gtk_widget_modify_text (GtkWidget *widget, * and #GtkTextView. See also gtk_widget_modify_style(). * * Note that "no window" widgets (which have the %GTK_NO_WINDOW flag set) - * draw on their parent container's window and thus may not draw any - * background themselves. This is the case for e.g. #GtkLabel. To modify - * the background of such widgets, you have to set the base color on their - * parent; if you want to set the background of a rectangular area around - * a label, try placing the label in a #GtkEventBox widget and setting + * draw on their parent container's window and thus may not draw any + * background themselves. This is the case for e.g. #GtkLabel. To modify + * the background of such widgets, you have to set the base color on their + * parent; if you want to set the background of a rectangular area around + * a label, try placing the label in a #GtkEventBox widget and setting * the base color on that. **/ void @@ -7841,7 +7845,7 @@ modify_color_property (GtkWidget *widget, * * Sets the cursor color to use in a widget, overriding the * #GtkWidget:cursor-color and #GtkWidget:secondary-cursor-color - * style properties. All other style values are left untouched. + * style properties. All other style values are left untouched. * See also gtk_widget_modify_style(). * * Since: 2.12 @@ -7880,7 +7884,7 @@ gtk_widget_modify_font (GtkWidget *widget, g_return_if_fail (GTK_IS_WIDGET (widget)); - rc_style = gtk_widget_get_modifier_style (widget); + rc_style = gtk_widget_get_modifier_style (widget); if (rc_style->font_desc) pango_font_description_free (rc_style->font_desc); @@ -7889,7 +7893,7 @@ gtk_widget_modify_font (GtkWidget *widget, rc_style->font_desc = pango_font_description_copy (font_desc); else rc_style->font_desc = NULL; - + gtk_widget_modify_style (widget, rc_style); } @@ -7980,7 +7984,7 @@ do_screen_change (GtkWidget *widget, if (context) g_object_set_qdata (G_OBJECT (widget), quark_pango_context, NULL); } - + _gtk_tooltip_hide (widget); g_signal_emit (widget, widget_signals[SCREEN_CHANGED], 0, old_screen); } @@ -8000,15 +8004,15 @@ gtk_widget_propagate_hierarchy_changed_recurse (GtkWidget *widget, g_object_ref (widget); priv->anchored = new_anchored; - + g_signal_emit (widget, widget_signals[HIERARCHY_CHANGED], 0, info->previous_toplevel); do_screen_change (widget, info->previous_screen, info->new_screen); - + if (GTK_IS_CONTAINER (widget)) gtk_container_forall (GTK_CONTAINER (widget), gtk_widget_propagate_hierarchy_changed_recurse, client_data); - + g_object_unref (widget); } } @@ -8017,7 +8021,7 @@ gtk_widget_propagate_hierarchy_changed_recurse (GtkWidget *widget, * _gtk_widget_propagate_hierarchy_changed: * @widget: a #GtkWidget * @previous_toplevel: Previous toplevel - * + * * Propagates changes in the anchored state to a widget and all * children, unsetting or setting the %ANCHORED flag, and * emitting #GtkWidget::hierarchy-changed. @@ -8058,21 +8062,21 @@ gtk_widget_propagate_screen_changed_recurse (GtkWidget *widget, HierarchyChangedInfo *info = client_data; g_object_ref (widget); - + do_screen_change (widget, info->previous_screen, info->new_screen); - + if (GTK_IS_CONTAINER (widget)) gtk_container_forall (GTK_CONTAINER (widget), gtk_widget_propagate_screen_changed_recurse, client_data); - + g_object_unref (widget); } /** * gtk_widget_is_composited: * @widget: a #GtkWidget - * + * * Whether @widget can rely on having its alpha channel * drawn correctly. On X11 this function returns whether a * compositing manager is running for @widget's screen. @@ -8080,10 +8084,10 @@ gtk_widget_propagate_screen_changed_recurse (GtkWidget *widget, * Please note that the semantics of this call will change * in the future if used on a widget that has a composited * window in its hierarchy (as set by gdk_window_set_composited()). - * + * * Return value: %TRUE if the widget can rely on its alpha * channel being drawn correctly. - * + * * Since: 2.10 */ gboolean @@ -8092,9 +8096,9 @@ gtk_widget_is_composited (GtkWidget *widget) GdkScreen *screen; g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); - + screen = gtk_widget_get_screen (widget); - + return gdk_screen_is_composited (screen); } @@ -8108,7 +8112,7 @@ propagate_composited_changed (GtkWidget *widget, propagate_composited_changed, NULL); } - + g_signal_emit (widget, widget_signals[COMPOSITED_CHANGED], 0); } @@ -8122,7 +8126,7 @@ _gtk_widget_propagate_composited_changed (GtkWidget *widget) * _gtk_widget_propagate_screen_changed: * @widget: a #GtkWidget * @previous_screen: Previous screen - * + * * Propagates changes in the screen for a widget to all * children, emitting #GtkWidget::screen-changed. **/ @@ -8149,7 +8153,7 @@ reset_rc_styles_recurse (GtkWidget *widget, gpointer data) { if (widget->priv->rc_style) gtk_widget_reset_rc_style (widget); - + if (GTK_IS_CONTAINER (widget)) gtk_container_forall (GTK_CONTAINER (widget), reset_rc_styles_recurse, @@ -8177,7 +8181,7 @@ gtk_widget_reset_rc_styles (GtkWidget *widget) /** * gtk_widget_get_default_style: - * + * * Returns the default style used by all widgets initially. * * Returns: (transfer none): the default style. This #GtkStyle object is owned @@ -8191,7 +8195,7 @@ gtk_widget_get_default_style (void) gtk_default_style = gtk_style_new (); g_object_ref (gtk_default_style); } - + return gtk_default_style; } @@ -8204,7 +8208,7 @@ gtk_widget_peek_pango_context (GtkWidget *widget) /** * gtk_widget_get_pango_context: * @widget: a #GtkWidget - * + * * Gets a #PangoContext with the appropriate font map, font description, * and base direction for this widget. Unlike the context returned * by gtk_widget_create_pango_context(), this context is owned by @@ -8214,7 +8218,7 @@ gtk_widget_peek_pango_context (GtkWidget *widget) * * If you create and keep a #PangoLayout using this context, you must * deal with changes to the context by calling pango_layout_context_changed() - * on the layout in response to the #GtkWidget::style-set and + * on the layout in response to the #GtkWidget::style-set and * #GtkWidget::direction-changed signals for the widget. * * Return value: (transfer none): the #PangoContext for the widget. @@ -8225,7 +8229,7 @@ gtk_widget_get_pango_context (GtkWidget *widget) PangoContext *context; g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); - + context = g_object_get_qdata (G_OBJECT (widget), quark_pango_context); if (!context) { @@ -8255,7 +8259,7 @@ static void gtk_widget_update_pango_context (GtkWidget *widget) { PangoContext *context = gtk_widget_peek_pango_context (widget); - + if (context) { GdkScreen *screen; @@ -8376,7 +8380,7 @@ gtk_widget_render_icon (GtkWidget *widget, GtkWidgetPrivate *priv; GtkIconSet *icon_set; GdkPixbuf *retval; - + g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); g_return_val_if_fail (stock_id != NULL, NULL); g_return_val_if_fail (size > GTK_ICON_SIZE_INVALID || size == -1, NULL); @@ -8384,7 +8388,7 @@ gtk_widget_render_icon (GtkWidget *widget, priv = widget->priv; gtk_widget_ensure_style (widget); - + icon_set = gtk_style_lookup_icon_set (priv->style, stock_id); if (icon_set == NULL) @@ -8405,7 +8409,7 @@ gtk_widget_render_icon (GtkWidget *widget, * gtk_widget_set_parent_window: * @widget: a #GtkWidget. * @parent_window: the new parent window. - * + * * Sets a non default parent window for @widget. **/ void @@ -8415,13 +8419,13 @@ gtk_widget_set_parent_window (GtkWidget *widget, GdkWindow *old_parent_window; g_return_if_fail (GTK_IS_WIDGET (widget)); - + old_parent_window = g_object_get_qdata (G_OBJECT (widget), quark_parent_window); if (parent_window != old_parent_window) { - g_object_set_qdata (G_OBJECT (widget), quark_parent_window, + g_object_set_qdata (G_OBJECT (widget), quark_parent_window, parent_window); if (old_parent_window) g_object_unref (old_parent_window); @@ -8461,14 +8465,14 @@ gtk_widget_get_parent_window (GtkWidget *widget) * @is_visible: if %TRUE, @widget should be mapped along with its parent. * * Sets whether @widget should be mapped along with its when its parent - * is mapped and @widget has been shown with gtk_widget_show(). + * is mapped and @widget has been shown with gtk_widget_show(). * * The child visibility can be set for widget before it is added to * a container with gtk_widget_set_parent(), to avoid mapping * children unnecessary before immediately unmapping them. However * it will be reset to its default state of %TRUE when the widget * is removed from a container. - * + * * Note that changing the child visibility of a widget does not * queue a resize on the widget. Most of the time, the size of * a widget is computed from all visible children, whether or @@ -8520,10 +8524,10 @@ gtk_widget_set_child_visible (GtkWidget *widget, /** * gtk_widget_get_child_visible: * @widget: a #GtkWidget - * + * * Gets the value set with gtk_widget_set_child_visible(). * If you feel a need to use this function, your code probably - * needs reorganization. + * needs reorganization. * * This function is only useful for container implementations and * never should be called by an application. @@ -8534,7 +8538,7 @@ gboolean gtk_widget_get_child_visible (GtkWidget *widget) { g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE); - + return widget->priv->child_visible; } @@ -8542,7 +8546,7 @@ static GdkScreen * gtk_widget_get_screen_unchecked (GtkWidget *widget) { GtkWidget *toplevel; - + toplevel = gtk_widget_get_toplevel (widget); if (gtk_widget_is_toplevel (toplevel)) @@ -8559,7 +8563,7 @@ gtk_widget_get_screen_unchecked (GtkWidget *widget) /** * gtk_widget_get_screen: * @widget: a #GtkWidget - * + * * Get the #GdkScreen from the toplevel window associated with * this widget. This function can only be called after the widget * has been added to a widget hierarchy with a #GtkWindow @@ -8577,7 +8581,7 @@ GdkScreen* gtk_widget_get_screen (GtkWidget *widget) { GdkScreen *screen; - + g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); screen = gtk_widget_get_screen_unchecked (widget); @@ -8600,12 +8604,12 @@ gtk_widget_get_screen (GtkWidget *widget) /** * gtk_widget_has_screen: * @widget: a #GtkWidget - * + * * Checks whether there is a #GdkScreen is associated with * this widget. All toplevel widgets have an associated * screen, and all widgets added into a hierarchy with a toplevel * window at the top. - * + * * Return value: %TRUE if there is a #GdkScreen associcated * with the widget. * @@ -8622,7 +8626,7 @@ gtk_widget_has_screen (GtkWidget *widget) /** * gtk_widget_get_display: * @widget: a #GtkWidget - * + * * Get the #GdkDisplay for the toplevel window associated with * this widget. This function can only be called after the widget * has been added to a widget hierarchy with a #GtkWindow at the top. @@ -8639,14 +8643,14 @@ GdkDisplay* gtk_widget_get_display (GtkWidget *widget) { g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); - + return gdk_screen_get_display (gtk_widget_get_screen (widget)); } /** * gtk_widget_get_root_window: * @widget: a #GtkWidget - * + * * Get the root window where this widget is located. This function can * only be called after the widget has been added to a widget * hierarchy with #GtkWindow at the top. @@ -8678,7 +8682,7 @@ gtk_widget_get_root_window (GtkWidget *widget) * to a particular widget, and gtk_container_set_focus_chain() to * change the focus tab order. So you may want to investigate those * functions instead. - * + * * gtk_widget_child_focus() is called by containers as the user moves * around the window using keyboard shortcuts. @direction indicates * what kind of motion is taking place (up, down, left, right, tab @@ -8713,7 +8717,7 @@ gtk_widget_child_focus (GtkWidget *widget, if (!GTK_IS_CONTAINER (widget) && !gtk_widget_get_can_focus (widget)) return FALSE; - + g_signal_emit (widget, widget_signals[FOCUS], 0, @@ -8741,10 +8745,10 @@ gtk_widget_child_focus (GtkWidget *widget, * navigation outside the widget, e.g. by calling * gtk_widget_child_focus() on the widget's toplevel. * - * The default ::keynav-failed handler returns %TRUE for - * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other - * values of #GtkDirectionType, it looks at the - * #GtkSettings:gtk-keynav-cursor-only setting and returns %FALSE + * The default ::keynav-failed handler returns %TRUE for + * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other + * values of #GtkDirectionType, it looks at the + * #GtkSettings:gtk-keynav-cursor-only setting and returns %FALSE * if the setting is %TRUE. This way the entire user interface * becomes cursor-navigatable on input devices such as mobile phones * which only have cursor keys but no tab key. @@ -8753,10 +8757,10 @@ gtk_widget_child_focus (GtkWidget *widget, * gtk_widget_error_bell() to notify the user of the failed keyboard * navigation. * - * A use case for providing an own implementation of ::keynav-failed + * A use case for providing an own implementation of ::keynav-failed * (either by connecting to it or by overriding it) would be a row of * #GtkEntry widgets where the user should be able to navigate the - * entire row with the cursor keys, as e.g. known from user interfaces + * entire row with the cursor keys, as e.g. known from user interfaces * that require entering license keys. * * Return value: %TRUE if stopping keyboard navigation is fine, %FALSE @@ -8783,7 +8787,7 @@ gtk_widget_keynav_failed (GtkWidget *widget, * gtk_widget_error_bell: * @widget: a #GtkWidget * - * Notifies the user about an input-related error on this widget. + * Notifies the user about an input-related error on this widget. * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls * gdk_window_beep(), otherwise it does nothing. * @@ -8824,11 +8828,11 @@ gtk_widget_set_usize_internal (GtkWidget *widget, { GtkWidgetAuxInfo *aux_info; gboolean changed = FALSE; - + g_object_freeze_notify (G_OBJECT (widget)); aux_info = _gtk_widget_get_aux_info (widget, TRUE); - + if (width > -2 && aux_info->width != width) { if ((flags & GTK_QUEUE_RESIZE_INVALIDATE_ONLY) == 0) @@ -8843,7 +8847,7 @@ gtk_widget_set_usize_internal (GtkWidget *widget, aux_info->height = height; changed = TRUE; } - + if (gtk_widget_get_visible (widget) && changed) { if ((flags & GTK_QUEUE_RESIZE_INVALIDATE_ONLY) == 0) @@ -8872,7 +8876,7 @@ gtk_widget_set_usize_internal (GtkWidget *widget, * will force them to leave the window at least as large as the size * request. When dealing with window sizes, * gtk_window_set_geometry_hints() can be a useful function as well. - * + * * Note the inherent danger of setting any fixed size - themes, * translations into other languages, different fonts, and user action * can all change the appropriate size for a given widget. So, it's @@ -8909,7 +8913,7 @@ gtk_widget_set_size_request (GtkWidget *widget, width = 1; if (height == 0) height = 1; - + gtk_widget_set_usize_internal (widget, width, height, 0); } @@ -9014,7 +9018,7 @@ gtk_widget_set_events (GtkWidget *widget, { g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (!gtk_widget_get_realized (widget)); - + g_object_set_qdata (G_OBJECT (widget), quark_event_mask, GINT_TO_POINTER (events)); g_object_notify (G_OBJECT (widget), "events"); @@ -9203,21 +9207,21 @@ gtk_widget_set_extension_events (GtkWidget *widget, /** * gtk_widget_get_toplevel: * @widget: a #GtkWidget - * + * * This function returns the topmost widget in the container hierarchy * @widget is a part of. If @widget has no parent widgets, it will be * returned as the topmost widget. No reference will be added to the * returned widget; it should not be unreferenced. * * Note the difference in behavior vs. gtk_widget_get_ancestor(); - * gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW) + * gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW) * would return * %NULL if @widget wasn't inside a toplevel window, and if the * window was inside a #GtkWindow-derived widget which was in turn * inside the toplevel #GtkWindow. While the second case may * seem unlikely, it actually happens when a #GtkPlug is embedded * inside a #GtkSocket within the same application. - * + * * To reliably find the toplevel #GtkWindow, use * gtk_widget_get_toplevel() and check if the %TOPLEVEL flags * is set on the result. @@ -9247,15 +9251,15 @@ gtk_widget_get_toplevel (GtkWidget *widget) * gtk_widget_get_ancestor: * @widget: a #GtkWidget * @widget_type: ancestor type - * + * * Gets the first ancestor of @widget with type @widget_type. For example, - * gtk_widget_get_ancestor (widget, GTK_TYPE_BOX) gets - * the first #GtkBox that's an ancestor of @widget. No reference will be - * added to the returned widget; it should not be unreferenced. See note - * about checking for a toplevel #GtkWindow in the docs for + * gtk_widget_get_ancestor (widget, GTK_TYPE_BOX) gets + * the first #GtkBox that's an ancestor of @widget. No reference will be + * added to the returned widget; it should not be unreferenced. See note + * about checking for a toplevel #GtkWindow in the docs for * gtk_widget_get_toplevel(). - * - * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor() + * + * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor() * considers @widget to be an ancestor of itself. * * Return value: (transfer none): the ancestor widget, or %NULL if not found @@ -9271,7 +9275,7 @@ gtk_widget_get_ancestor (GtkWidget *widget, if (!(widget && g_type_is_a (G_OBJECT_TYPE (widget), widget_type))) return NULL; - + return widget; } @@ -9279,7 +9283,7 @@ gtk_widget_get_ancestor (GtkWidget *widget, * gtk_widget_set_visual: * @widget: a #GtkWidget * @visual: visual to be used or %NULL to unset a previous one - * + * * Sets the visual that should be used for by widget and its children for * creating #GdkWindows. The visual must be on the same #GdkScreen as * returned by gdk_widget_get_screen(), so handling the @@ -9299,7 +9303,7 @@ gtk_widget_set_visual (GtkWidget *widget, g_return_if_fail (gtk_widget_get_screen (widget) == gdk_visual_get_screen (visual)); } - g_object_set_qdata_full (G_OBJECT (widget), + g_object_set_qdata_full (G_OBJECT (widget), quark_visual, g_object_ref (visual), g_object_unref); @@ -9308,7 +9312,7 @@ gtk_widget_set_visual (GtkWidget *widget, /** * gtk_widget_get_visual: * @widget: a #GtkWidget - * + * * Gets the visual that will be used to render @widget. * * Return value: (transfer none): the visual for @widget @@ -9347,7 +9351,7 @@ gtk_widget_get_visual (GtkWidget *widget) /** * gtk_widget_get_settings: * @widget: a #GtkWidget - * + * * Gets the settings object holding the settings (global property * settings, RC file information, etc) used for this widget. * @@ -9361,18 +9365,18 @@ GtkSettings* gtk_widget_get_settings (GtkWidget *widget) { g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); - + return gtk_settings_get_for_screen (gtk_widget_get_screen (widget)); } /** * gtk_widget_get_events: * @widget: a #GtkWidget - * + * * Returns the event mask for the widget (a bitfield containing flags * from the #GdkEventMask enumeration). These are the events that the widget * will receive. - * + * * Return value: event mask for @widget **/ gint @@ -9415,10 +9419,10 @@ gtk_widget_get_device_events (GtkWidget *widget, /** * gtk_widget_get_extension_events: * @widget: a #GtkWidget - * + * * Retrieves the extension events the widget will receive; see * gdk_input_set_extension_events(). - * + * * Return value: extension events for @widget **/ GdkExtensionMode @@ -9456,7 +9460,7 @@ gtk_widget_get_pointer (GtkWidget *widget, *x = -1; if (y) *y = -1; - + if (gtk_widget_get_realized (widget)) { gdk_window_get_pointer (priv->window, x, y, NULL); @@ -9475,11 +9479,11 @@ gtk_widget_get_pointer (GtkWidget *widget, * gtk_widget_is_ancestor: * @widget: a #GtkWidget * @ancestor: another #GtkWidget - * + * * Determines whether @widget is somewhere inside @ancestor, possibly with * intermediate containers. - * - * Return value: %TRUE if @ancestor contains @widget as a child, + * + * Return value: %TRUE if @ancestor contains @widget as a child, * grandchild, great grandchild, etc. **/ gboolean @@ -9495,7 +9499,7 @@ gtk_widget_is_ancestor (GtkWidget *widget, return TRUE; widget = widget->priv->parent; } - + return FALSE; } @@ -9505,7 +9509,7 @@ static GQuark quark_composite_name = 0; * gtk_widget_set_composite_name: * @widget: a #GtkWidget. * @name: the name to set - * + * * Sets a widgets composite name. The widget must be * a composite child of its parent; see gtk_widget_push_composite_child(). **/ @@ -9530,10 +9534,10 @@ gtk_widget_set_composite_name (GtkWidget *widget, * gtk_widget_get_composite_name: * @widget: a #GtkWidget * - * Obtains the composite name of a widget. + * Obtains the composite name of a widget. * * Returns: the composite name of @widget, or %NULL if @widget is not - * a composite child. The string should be freed when it is no + * a composite child. The string should be freed when it is no * longer needed. **/ gchar* @@ -9554,23 +9558,23 @@ gtk_widget_get_composite_name (GtkWidget *widget) /** * gtk_widget_push_composite_child: - * + * * Makes all newly-created widgets as composite children until * the corresponding gtk_widget_pop_composite_child() call. - * + * * A composite child is a child that's an implementation detail of the * container it's inside and should not be visible to people using the * container. Composite children aren't treated differently by GTK (but - * see gtk_container_foreach() vs. gtk_container_forall()), but e.g. GUI + * see gtk_container_foreach() vs. gtk_container_forall()), but e.g. GUI * builders might want to treat them in a different way. - * + * * Here is a simple example: * |[ * gtk_widget_push_composite_child (); * scrolled_window->hscrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, hadjustment); * gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar"); * gtk_widget_pop_composite_child (); - * gtk_widget_set_parent (scrolled_window->hscrollbar, + * gtk_widget_set_parent (scrolled_window->hscrollbar, * GTK_WIDGET (scrolled_window)); * g_object_ref (scrolled_window->hscrollbar); * ]| @@ -9585,7 +9589,7 @@ gtk_widget_push_composite_child (void) * gtk_widget_pop_composite_child: * * Cancels the effect of a previous call to gtk_widget_push_composite_child(). - **/ + **/ void gtk_widget_pop_composite_child (void) { @@ -9598,7 +9602,7 @@ gtk_widget_emit_direction_changed (GtkWidget *widget, GtkTextDirection old_dir) { gtk_widget_update_pango_context (widget); - + g_signal_emit (widget, widget_signals[DIRECTION_CHANGED], 0, old_dir); } @@ -9606,7 +9610,7 @@ gtk_widget_emit_direction_changed (GtkWidget *widget, * gtk_widget_set_direction: * @widget: a #GtkWidget * @dir: the new direction - * + * * Sets the reading direction on a particular widget. This direction * controls the primary direction for widgets containing text, * and also the direction in which the children of a container are @@ -9625,7 +9629,7 @@ gtk_widget_set_direction (GtkWidget *widget, GtkTextDirection dir) { GtkTextDirection old_dir; - + g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (dir >= GTK_TEXT_DIR_NONE && dir <= GTK_TEXT_DIR_RTL); @@ -9640,17 +9644,17 @@ gtk_widget_set_direction (GtkWidget *widget, /** * gtk_widget_get_direction: * @widget: a #GtkWidget - * + * * Gets the reading direction for a particular widget. See * gtk_widget_set_direction(). - * + * * Return value: the reading direction for the widget. **/ GtkTextDirection gtk_widget_get_direction (GtkWidget *widget) { g_return_val_if_fail (GTK_IS_WIDGET (widget), GTK_TEXT_DIR_LTR); - + if (widget->priv->direction == GTK_TEXT_DIR_NONE) return gtk_default_direction; else @@ -9663,10 +9667,10 @@ gtk_widget_set_default_direction_recurse (GtkWidget *widget, gpointer data) GtkTextDirection old_dir = GPOINTER_TO_UINT (data); g_object_ref (widget); - + if (widget->priv->direction == GTK_TEXT_DIR_NONE) gtk_widget_emit_direction_changed (widget, old_dir); - + if (GTK_IS_CONTAINER (widget)) gtk_container_forall (GTK_CONTAINER (widget), gtk_widget_set_default_direction_recurse, @@ -9679,7 +9683,7 @@ gtk_widget_set_default_direction_recurse (GtkWidget *widget, gpointer data) * gtk_widget_set_default_direction: * @dir: the new default direction. This cannot be * %GTK_TEXT_DIR_NONE. - * + * * Sets the default reading direction for widgets where the * direction has not been explicitly set by gtk_widget_set_direction(). **/ @@ -9692,12 +9696,12 @@ gtk_widget_set_default_direction (GtkTextDirection dir) { GList *toplevels, *tmp_list; GtkTextDirection old_dir = gtk_default_direction; - + gtk_default_direction = dir; tmp_list = toplevels = gtk_window_list_toplevels (); g_list_foreach (toplevels, (GFunc)g_object_ref, NULL); - + while (tmp_list) { gtk_widget_set_default_direction_recurse (tmp_list->data, @@ -9712,11 +9716,11 @@ gtk_widget_set_default_direction (GtkTextDirection dir) /** * gtk_widget_get_default_direction: - * + * * Obtains the current default reading direction. See * gtk_widget_set_default_direction(). * - * Return value: the current default direction. + * Return value: the current default direction. **/ GtkTextDirection gtk_widget_get_default_direction (void) @@ -9777,14 +9781,14 @@ gtk_widget_finalize (GObject *object) GtkWidgetPrivate *priv = widget->priv; GtkWidgetAuxInfo *aux_info; GtkAccessible *accessible; - + gtk_grab_remove (widget); g_object_unref (priv->style); priv->style = NULL; g_free (priv->name); - + aux_info =_gtk_widget_get_aux_info (widget, FALSE); if (aux_info) gtk_widget_aux_info_destroy (aux_info); @@ -9816,11 +9820,11 @@ gtk_widget_real_map (GtkWidget *widget) GtkWidgetPrivate *priv = widget->priv; g_assert (gtk_widget_get_realized (widget)); - + if (!gtk_widget_get_mapped (widget)) { gtk_widget_set_mapped (widget, TRUE); - + if (gtk_widget_get_has_window (widget)) gdk_window_show (priv->window); } @@ -9862,7 +9866,7 @@ gtk_widget_real_realize (GtkWidget *widget) GtkWidgetPrivate *priv = widget->priv; g_assert (!gtk_widget_get_has_window (widget)); - + gtk_widget_set_realized (widget, TRUE); if (priv->parent) { @@ -9895,7 +9899,7 @@ gtk_widget_real_unrealize (GtkWidget *widget) /* We must do unrealize child widget BEFORE container widget. * gdk_window_destroy() destroys specified xwindow and its sub-xwindows. - * So, unrealizing container widget bofore its children causes the problem + * So, unrealizing container widget bofore its children causes the problem * (for example, gdk_ic_destroy () with destroyed window causes crash. ) */ @@ -9918,7 +9922,7 @@ gtk_widget_real_unrealize (GtkWidget *widget) } gtk_selection_remove_all (widget); - + gtk_widget_set_realized (widget, FALSE); } @@ -9971,10 +9975,10 @@ gtk_widget_real_adjust_size_request (GtkWidget *widget, /** * _gtk_widget_peek_request_cache: - * + * * Returns the address of the widget's request cache (strictly for * internal use in gtksizerequest.c) - * + * * Return value: the address of @widget's size request cache. **/ gpointer @@ -10299,7 +10303,7 @@ _gtk_widget_synthesize_crossing (GtkWidget *from, synth_crossing (from, GDK_LEAVE_NOTIFY, from_window, device, mode, GDK_NOTIFY_INFERIOR); for (list = to_ancestors; list; list = list->next) - synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data, + synth_crossing (NULL, GDK_ENTER_NOTIFY, (GdkWindow *) list->data, device, mode, GDK_NOTIFY_VIRTUAL); synth_crossing (to, GDK_ENTER_NOTIFY, to_window, device, mode, GDK_NOTIFY_ANCESTOR); @@ -10319,10 +10323,10 @@ _gtk_widget_synthesize_crossing (GtkWidget *from, } else { - while (from_ancestors != NULL && to_ancestors != NULL + while (from_ancestors != NULL && to_ancestors != NULL && from_ancestors->data == to_ancestors->data) { - from_ancestors = g_list_delete_link (from_ancestors, + from_ancestors = g_list_delete_link (from_ancestors, from_ancestors); to_ancestors = g_list_delete_link (to_ancestors, to_ancestors); } @@ -10464,9 +10468,9 @@ static const GtkWidgetAuxInfo default_aux_info = { * _gtk_widget_get_aux_info: * @widget: a #GtkWidget * @create: if %TRUE, create the structure if it doesn't exist - * + * * Get the #GtkWidgetAuxInfo structure for the widget. - * + * * Return value: the #GtkAuxInfo structure for the widget, or * %NULL if @create is %FALSE and one doesn't already exist. */ @@ -10475,7 +10479,7 @@ _gtk_widget_get_aux_info (GtkWidget *widget, gboolean create) { GtkWidgetAuxInfo *aux_info; - + aux_info = g_object_get_qdata (G_OBJECT (widget), quark_aux_info); if (!aux_info && create) { @@ -10485,7 +10489,7 @@ _gtk_widget_get_aux_info (GtkWidget *widget, g_object_set_qdata (G_OBJECT (widget), quark_aux_info, aux_info); } - + return aux_info; } @@ -10520,10 +10524,10 @@ gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info) } /** - * gtk_widget_shape_combine_region: + * gtk_widget_shape_combine_region: * @widget: a #GtkWidget * @region: (allow-none): shape to be added, or %NULL to remove an existing shape - * + * * Sets a shape for this widget's GDK window. This allows for * transparent windows etc., see gdk_window_shape_combine_region() * for more information. @@ -10535,7 +10539,7 @@ gtk_widget_shape_combine_region (GtkWidget *widget, cairo_region_t *region) { GtkWidgetPrivate *priv; - + g_return_if_fail (GTK_IS_WIDGET (widget)); /* set_shape doesn't work on widgets without gdk window */ g_return_if_fail (gtk_widget_get_has_window (widget)); @@ -10548,17 +10552,17 @@ gtk_widget_shape_combine_region (GtkWidget *widget, if (priv->window) gdk_window_shape_combine_region (priv->window, NULL, 0, 0); - + g_object_set_qdata (G_OBJECT (widget), quark_shape_info, NULL); } else { priv->has_shape_mask = TRUE; - + g_object_set_qdata_full (G_OBJECT (widget), quark_shape_info, cairo_region_copy (region), (GDestroyNotify) cairo_region_destroy); - + /* set shape if widget has a gdk window already. * otherwise the shape is scheduled to be set by gtk_widget_realize(). */ @@ -10573,7 +10577,7 @@ gtk_widget_shape_combine_region (GtkWidget *widget, * @region: (allow-none): shape to be added, or %NULL to remove an existing shape * * Sets an input shape for this widget's GDK window. This allows for - * windows which react to mouse click in a nonrectangular region, see + * windows which react to mouse click in a nonrectangular region, see * gdk_window_input_shape_combine_region() for more information. * * Since: 3.0 @@ -10583,7 +10587,7 @@ gtk_widget_input_shape_combine_region (GtkWidget *widget, cairo_region_t *region) { GtkWidgetPrivate *priv; - + g_return_if_fail (GTK_IS_WIDGET (widget)); /* set_shape doesn't work on widgets without gdk window */ g_return_if_fail (gtk_widget_get_has_window (widget)); @@ -10594,15 +10598,15 @@ gtk_widget_input_shape_combine_region (GtkWidget *widget, { if (priv->window) gdk_window_input_shape_combine_region (priv->window, NULL, 0, 0); - + g_object_set_qdata (G_OBJECT (widget), quark_input_shape_info, NULL); } else { - g_object_set_qdata_full (G_OBJECT (widget), quark_input_shape_info, + g_object_set_qdata_full (G_OBJECT (widget), quark_input_shape_info, cairo_region_copy (region), (GDestroyNotify) cairo_region_destroy); - + /* set shape if widget has a gdk window already. * otherwise the shape is scheduled to be set by gtk_widget_realize(). */ @@ -10656,8 +10660,8 @@ gtk_widget_reset_shapes (GtkWidget *widget) * @klass: a #GtkWidgetClass * @pspec: the #GParamSpec for the style property * @parser: the parser for the style property - * - * Installs a style property on a widget class. + * + * Installs a style property on a widget class. **/ void gtk_widget_class_install_style_property_parser (GtkWidgetClass *klass, @@ -10668,7 +10672,7 @@ gtk_widget_class_install_style_property_parser (GtkWidgetClass *klass, g_return_if_fail (G_IS_PARAM_SPEC (pspec)); g_return_if_fail (pspec->flags & G_PARAM_READABLE); g_return_if_fail (!(pspec->flags & (G_PARAM_CONSTRUCT_ONLY | G_PARAM_CONSTRUCT))); - + if (g_param_spec_pool_lookup (style_property_spec_pool, pspec->name, G_OBJECT_CLASS_TYPE (klass), FALSE)) { g_warning (G_STRLOC ": class `%s' already contains a style property named `%s'", @@ -10686,7 +10690,7 @@ gtk_widget_class_install_style_property_parser (GtkWidgetClass *klass, * gtk_widget_class_install_style_property: * @klass: a #GtkWidgetClass * @pspec: the #GParamSpec for the property - * + * * Installs a style property on a widget class. The parser for the * style property is determined by the value type of @pspec. **/ @@ -10731,7 +10735,7 @@ gtk_widget_class_find_style_property (GtkWidgetClass *klass, * gtk_widget_class_list_style_properties: * @klass: a #GtkWidgetClass * @n_properties: location to return the number of style properties found - * @returns: an newly allocated array of #GParamSpec*. The array must + * @returns: an newly allocated array of #GParamSpec*. The array must * be freed with g_free(). * * Returns all style properties of a widget class. @@ -10758,7 +10762,7 @@ gtk_widget_class_list_style_properties (GtkWidgetClass *klass, * gtk_widget_style_get_property: * @widget: a #GtkWidget * @property_name: the name of a style property - * @value: location to return the property value + * @value: location to return the property value * * Gets the value of a style property of @widget. */ @@ -10794,7 +10798,7 @@ gtk_widget_style_get_property (GtkWidget *widget, G_OBJECT_TYPE (widget), pspec, (GtkRcPropertyParser) g_param_spec_get_qdata (pspec, quark_property_parser)); - + /* auto-conversion of the caller's value type */ if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec)) @@ -10817,10 +10821,10 @@ gtk_widget_style_get_property (GtkWidget *widget, * @var_args: a va_list of pairs of property names and * locations to return the property values, starting with the location * for @first_property_name. - * - * Non-vararg variant of gtk_widget_style_get(). Used primarily by language + * + * Non-vararg variant of gtk_widget_style_get(). Used primarily by language * bindings. - */ + */ void gtk_widget_style_get_valist (GtkWidget *widget, const gchar *first_property_name, @@ -10878,8 +10882,8 @@ gtk_widget_style_get_valist (GtkWidget *widget, * gtk_widget_style_get: * @widget: a #GtkWidget * @first_property_name: the name of the first property to get - * @Varargs: pairs of property names and locations to - * return the property values, starting with the location for + * @Varargs: pairs of property names and locations to + * return the property values, starting with the location for * @first_property_name, terminated by %NULL. * * Gets the values of a multiple style properties of @widget. @@ -10927,7 +10931,7 @@ gtk_widget_path (GtkWidget *widget, static gchar *rev_path = NULL; static guint tmp_path_len = 0; guint len; - + g_return_if_fail (GTK_IS_WIDGET (widget)); len = 0; @@ -10937,7 +10941,7 @@ gtk_widget_path (GtkWidget *widget, const gchar *s; gchar *d; guint l; - + string = gtk_widget_get_name (widget); l = strlen (string); while (tmp_path_len <= len + l + 1) @@ -10959,7 +10963,7 @@ gtk_widget_path (GtkWidget *widget, rev_path[len++] = 0; } while (widget); - + if (path_length) *path_length = len - 1; if (path_reversed) @@ -10981,7 +10985,7 @@ gtk_widget_path (GtkWidget *widget, * * Same as gtk_widget_path(), but always uses the name of a widget's type, * never uses a custom name set with gtk_widget_set_name(). - * + * **/ void gtk_widget_class_path (GtkWidget *widget, @@ -10992,7 +10996,7 @@ gtk_widget_class_path (GtkWidget *widget, static gchar *rev_path = NULL; static guint tmp_path_len = 0; guint len; - + g_return_if_fail (GTK_IS_WIDGET (widget)); len = 0; @@ -11002,7 +11006,7 @@ gtk_widget_class_path (GtkWidget *widget, const gchar *s; gchar *d; guint l; - + string = g_type_name (G_OBJECT_TYPE (widget)); l = strlen (string); while (tmp_path_len <= len + l + 1) @@ -11024,7 +11028,7 @@ gtk_widget_class_path (GtkWidget *widget, rev_path[len++] = 0; } while (widget); - + if (path_length) *path_length = len - 1; if (path_reversed) @@ -11069,7 +11073,7 @@ gtk_requisition_copy (const GtkRequisition *requisition) /** * gtk_requisition_free: * @requisition: a #GtkRequisition - * + * * Frees a #GtkRequisition. **/ void @@ -11115,12 +11119,12 @@ gtk_widget_get_accessible (GtkWidget *widget) return klass->get_accessible (widget); } -static AtkObject* +static AtkObject* gtk_widget_real_get_accessible (GtkWidget *widget) { AtkObject* accessible; - accessible = g_object_get_qdata (G_OBJECT (widget), + accessible = g_object_get_qdata (G_OBJECT (widget), quark_accessible_object); if (!accessible) { @@ -11128,12 +11132,12 @@ gtk_widget_real_get_accessible (GtkWidget *widget) AtkRegistry *default_registry; default_registry = atk_get_default_registry (); - factory = atk_registry_get_factory (default_registry, + factory = atk_registry_get_factory (default_registry, G_TYPE_FROM_INSTANCE (widget)); accessible = atk_object_factory_create_accessible (factory, G_OBJECT (widget)); - g_object_set_qdata (G_OBJECT (widget), + g_object_set_qdata (G_OBJECT (widget), quark_accessible_object, accessible); } @@ -12405,8 +12409,8 @@ gtk_widget_set_margin_bottom (GtkWidget *widget, * to use. %GDK_SELECTION_CLIPBOARD gives the * default clipboard. Another common value * is %GDK_SELECTION_PRIMARY, which gives - * the primary X selection. - * + * the primary X selection. + * * Returns the clipboard object for the given selection to * be used with @widget. @widget must have a #GdkDisplay * associated with it, so must be attached to a toplevel @@ -12455,7 +12459,7 @@ gtk_widget_list_mnemonic_labels (GtkWidget *widget) { GList *list = NULL; GSList *l; - + g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); for (l = g_object_get_qdata (G_OBJECT (widget), quark_mnemonic_labels); l; l = l->next) @@ -12468,7 +12472,7 @@ gtk_widget_list_mnemonic_labels (GtkWidget *widget) * gtk_widget_add_mnemonic_label: * @widget: a #GtkWidget * @label: a #GtkWidget that acts as a mnemonic label for @widget - * + * * Adds a widget to the list of mnemonic labels for * this widget. (See gtk_widget_list_mnemonic_labels()). Note the * list of mnemonic labels for the widget is cleared when the @@ -12489,7 +12493,7 @@ gtk_widget_add_mnemonic_label (GtkWidget *widget, old_list = g_object_steal_qdata (G_OBJECT (widget), quark_mnemonic_labels); new_list = g_slist_prepend (old_list, label); - + g_object_set_qdata_full (G_OBJECT (widget), quark_mnemonic_labels, new_list, (GDestroyNotify) g_slist_free); } @@ -12499,7 +12503,7 @@ gtk_widget_add_mnemonic_label (GtkWidget *widget, * @widget: a #GtkWidget * @label: a #GtkWidget that was previously set as a mnemnic label for * @widget with gtk_widget_add_mnemonic_label(). - * + * * Removes a widget from the list of mnemonic labels for * this widget. (See gtk_widget_list_mnemonic_labels()). The widget * must have previously been added to the list with @@ -12554,7 +12558,7 @@ gtk_widget_get_no_show_all (GtkWidget *widget) * * This is mostly for use in constructing widget hierarchies with externally * controlled visibility, see #GtkUIManager. - * + * * Since: 2.4 **/ void