1 /* GTK - The GIMP Toolkit
3 * Copyright (C) 2003 Sun Microsystems, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
21 * Mark McLoughlin <mark@skynet.ie>
26 #include "gtkexpander.h"
29 #include "gtkbuildable.h"
30 #include "gtkcontainer.h"
31 #include "gtkmarshalers.h"
34 #include "gtkprivate.h"
35 #include <gdk/gdkkeysyms.h>
39 #define GTK_EXPANDER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_EXPANDER, GtkExpanderPrivate))
41 #define DEFAULT_EXPANDER_SIZE 10
42 #define DEFAULT_EXPANDER_SPACING 2
55 struct _GtkExpanderPrivate
57 GtkWidget *label_widget;
58 GdkWindow *event_window;
61 GtkExpanderStyle expander_style;
62 guint animation_timeout;
66 guint use_underline : 1;
68 guint button_down : 1;
72 static void gtk_expander_set_property (GObject *object,
76 static void gtk_expander_get_property (GObject *object,
81 static void gtk_expander_destroy (GtkObject *object);
83 static void gtk_expander_realize (GtkWidget *widget);
84 static void gtk_expander_unrealize (GtkWidget *widget);
85 static void gtk_expander_size_request (GtkWidget *widget,
86 GtkRequisition *requisition);
87 static void gtk_expander_size_allocate (GtkWidget *widget,
88 GtkAllocation *allocation);
89 static void gtk_expander_map (GtkWidget *widget);
90 static void gtk_expander_unmap (GtkWidget *widget);
91 static gboolean gtk_expander_expose (GtkWidget *widget,
92 GdkEventExpose *event);
93 static gboolean gtk_expander_button_press (GtkWidget *widget,
94 GdkEventButton *event);
95 static gboolean gtk_expander_button_release (GtkWidget *widget,
96 GdkEventButton *event);
97 static gboolean gtk_expander_enter_notify (GtkWidget *widget,
98 GdkEventCrossing *event);
99 static gboolean gtk_expander_leave_notify (GtkWidget *widget,
100 GdkEventCrossing *event);
101 static gboolean gtk_expander_focus (GtkWidget *widget,
102 GtkDirectionType direction);
103 static void gtk_expander_grab_notify (GtkWidget *widget,
104 gboolean was_grabbed);
105 static void gtk_expander_state_changed (GtkWidget *widget,
106 GtkStateType previous_state);
107 static gboolean gtk_expander_drag_motion (GtkWidget *widget,
108 GdkDragContext *context,
112 static void gtk_expander_drag_leave (GtkWidget *widget,
113 GdkDragContext *context,
116 static void gtk_expander_add (GtkContainer *container,
118 static void gtk_expander_remove (GtkContainer *container,
120 static void gtk_expander_forall (GtkContainer *container,
121 gboolean include_internals,
122 GtkCallback callback,
123 gpointer callback_data);
125 static void gtk_expander_activate (GtkExpander *expander);
127 static void get_expander_bounds (GtkExpander *expander,
131 static void gtk_expander_buildable_init (GtkBuildableIface *iface);
132 static void gtk_expander_buildable_add_child (GtkBuildable *buildable,
137 G_DEFINE_TYPE_WITH_CODE (GtkExpander, gtk_expander, GTK_TYPE_BIN,
138 G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
139 gtk_expander_buildable_init))
142 gtk_expander_class_init (GtkExpanderClass *klass)
144 GObjectClass *gobject_class;
145 GtkObjectClass *object_class;
146 GtkWidgetClass *widget_class;
147 GtkContainerClass *container_class;
149 gobject_class = (GObjectClass *) klass;
150 object_class = (GtkObjectClass *) klass;
151 widget_class = (GtkWidgetClass *) klass;
152 container_class = (GtkContainerClass *) klass;
154 gobject_class->set_property = gtk_expander_set_property;
155 gobject_class->get_property = gtk_expander_get_property;
157 object_class->destroy = gtk_expander_destroy;
159 widget_class->realize = gtk_expander_realize;
160 widget_class->unrealize = gtk_expander_unrealize;
161 widget_class->size_request = gtk_expander_size_request;
162 widget_class->size_allocate = gtk_expander_size_allocate;
163 widget_class->map = gtk_expander_map;
164 widget_class->unmap = gtk_expander_unmap;
165 widget_class->expose_event = gtk_expander_expose;
166 widget_class->button_press_event = gtk_expander_button_press;
167 widget_class->button_release_event = gtk_expander_button_release;
168 widget_class->enter_notify_event = gtk_expander_enter_notify;
169 widget_class->leave_notify_event = gtk_expander_leave_notify;
170 widget_class->focus = gtk_expander_focus;
171 widget_class->grab_notify = gtk_expander_grab_notify;
172 widget_class->state_changed = gtk_expander_state_changed;
173 widget_class->drag_motion = gtk_expander_drag_motion;
174 widget_class->drag_leave = gtk_expander_drag_leave;
176 container_class->add = gtk_expander_add;
177 container_class->remove = gtk_expander_remove;
178 container_class->forall = gtk_expander_forall;
180 klass->activate = gtk_expander_activate;
182 g_type_class_add_private (klass, sizeof (GtkExpanderPrivate));
184 g_object_class_install_property (gobject_class,
186 g_param_spec_boolean ("expanded",
188 P_("Whether the expander has been opened to reveal the child widget"),
190 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
192 g_object_class_install_property (gobject_class,
194 g_param_spec_string ("label",
196 P_("Text of the expander's label"),
198 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
200 g_object_class_install_property (gobject_class,
202 g_param_spec_boolean ("use-underline",
204 P_("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),
206 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
208 g_object_class_install_property (gobject_class,
210 g_param_spec_boolean ("use-markup",
212 P_("The text of the label includes XML markup. See pango_parse_markup()"),
214 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
216 g_object_class_install_property (gobject_class,
218 g_param_spec_int ("spacing",
220 P_("Space to put between the label and the child"),
224 GTK_PARAM_READWRITE));
226 g_object_class_install_property (gobject_class,
228 g_param_spec_object ("label-widget",
230 P_("A widget to display in place of the usual expander label"),
232 GTK_PARAM_READWRITE));
234 gtk_widget_class_install_style_property (widget_class,
235 g_param_spec_int ("expander-size",
237 P_("Size of the expander arrow"),
240 DEFAULT_EXPANDER_SIZE,
241 GTK_PARAM_READABLE));
243 gtk_widget_class_install_style_property (widget_class,
244 g_param_spec_int ("expander-spacing",
245 P_("Indicator Spacing"),
246 P_("Spacing around expander arrow"),
249 DEFAULT_EXPANDER_SPACING,
250 GTK_PARAM_READABLE));
252 widget_class->activate_signal =
253 g_signal_new (I_("activate"),
254 G_TYPE_FROM_CLASS (gobject_class),
255 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
256 G_STRUCT_OFFSET (GtkExpanderClass, activate),
258 _gtk_marshal_VOID__VOID,
263 gtk_expander_init (GtkExpander *expander)
265 GtkExpanderPrivate *priv;
267 expander->priv = priv = GTK_EXPANDER_GET_PRIVATE (expander);
269 gtk_widget_set_can_focus (GTK_WIDGET (expander), TRUE);
270 gtk_widget_set_has_window (GTK_WIDGET (expander), FALSE);
272 priv->label_widget = NULL;
273 priv->event_window = NULL;
276 priv->expander_style = GTK_EXPANDER_COLLAPSED;
277 priv->animation_timeout = 0;
279 priv->expanded = FALSE;
280 priv->use_underline = FALSE;
281 priv->use_markup = FALSE;
282 priv->button_down = FALSE;
283 priv->prelight = FALSE;
284 priv->expand_timer = 0;
286 gtk_drag_dest_set (GTK_WIDGET (expander), 0, NULL, 0, 0);
287 gtk_drag_dest_set_track_motion (GTK_WIDGET (expander), TRUE);
291 gtk_expander_buildable_add_child (GtkBuildable *buildable,
297 gtk_container_add (GTK_CONTAINER (buildable), GTK_WIDGET (child));
298 else if (strcmp (type, "label") == 0)
299 gtk_expander_set_label_widget (GTK_EXPANDER (buildable), GTK_WIDGET (child));
301 GTK_BUILDER_WARN_INVALID_CHILD_TYPE (GTK_EXPANDER (buildable), type);
305 gtk_expander_buildable_init (GtkBuildableIface *iface)
307 iface->add_child = gtk_expander_buildable_add_child;
311 gtk_expander_set_property (GObject *object,
316 GtkExpander *expander = GTK_EXPANDER (object);
321 gtk_expander_set_expanded (expander, g_value_get_boolean (value));
324 gtk_expander_set_label (expander, g_value_get_string (value));
326 case PROP_USE_UNDERLINE:
327 gtk_expander_set_use_underline (expander, g_value_get_boolean (value));
329 case PROP_USE_MARKUP:
330 gtk_expander_set_use_markup (expander, g_value_get_boolean (value));
333 gtk_expander_set_spacing (expander, g_value_get_int (value));
335 case PROP_LABEL_WIDGET:
336 gtk_expander_set_label_widget (expander, g_value_get_object (value));
339 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
345 gtk_expander_get_property (GObject *object,
350 GtkExpander *expander = GTK_EXPANDER (object);
351 GtkExpanderPrivate *priv = expander->priv;
356 g_value_set_boolean (value, priv->expanded);
359 g_value_set_string (value, gtk_expander_get_label (expander));
361 case PROP_USE_UNDERLINE:
362 g_value_set_boolean (value, priv->use_underline);
364 case PROP_USE_MARKUP:
365 g_value_set_boolean (value, priv->use_markup);
368 g_value_set_int (value, priv->spacing);
370 case PROP_LABEL_WIDGET:
371 g_value_set_object (value,
373 G_OBJECT (priv->label_widget) : NULL);
376 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
382 gtk_expander_destroy (GtkObject *object)
384 GtkExpanderPrivate *priv = GTK_EXPANDER (object)->priv;
386 if (priv->animation_timeout)
388 g_source_remove (priv->animation_timeout);
389 priv->animation_timeout = 0;
392 GTK_OBJECT_CLASS (gtk_expander_parent_class)->destroy (object);
396 gtk_expander_realize (GtkWidget *widget)
398 GtkExpanderPrivate *priv;
399 GdkWindowAttr attributes;
400 gint attributes_mask;
402 GdkRectangle expander_rect;
405 priv = GTK_EXPANDER (widget)->priv;
406 gtk_widget_set_realized (widget, TRUE);
408 border_width = GTK_CONTAINER (widget)->border_width;
410 get_expander_bounds (GTK_EXPANDER (widget), &expander_rect);
412 if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
414 GtkRequisition label_requisition;
416 gtk_widget_get_child_requisition (priv->label_widget, &label_requisition);
417 label_height = label_requisition.height;
422 attributes.window_type = GDK_WINDOW_CHILD;
423 attributes.x = widget->allocation.x + border_width;
424 attributes.y = widget->allocation.y + border_width;
425 attributes.width = MAX (widget->allocation.width - 2 * border_width, 1);
426 attributes.height = MAX (expander_rect.height, label_height - 2 * border_width);
427 attributes.wclass = GDK_INPUT_ONLY;
428 attributes.event_mask = gtk_widget_get_events (widget) |
429 GDK_BUTTON_PRESS_MASK |
430 GDK_BUTTON_RELEASE_MASK |
431 GDK_ENTER_NOTIFY_MASK |
432 GDK_LEAVE_NOTIFY_MASK;
434 attributes_mask = GDK_WA_X | GDK_WA_Y;
436 widget->window = gtk_widget_get_parent_window (widget);
437 g_object_ref (widget->window);
439 priv->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
440 &attributes, attributes_mask);
441 gdk_window_set_user_data (priv->event_window, widget);
443 widget->style = gtk_style_attach (widget->style, widget->window);
447 gtk_expander_unrealize (GtkWidget *widget)
449 GtkExpanderPrivate *priv = GTK_EXPANDER (widget)->priv;
451 if (priv->event_window)
453 gdk_window_set_user_data (priv->event_window, NULL);
454 gdk_window_destroy (priv->event_window);
455 priv->event_window = NULL;
458 GTK_WIDGET_CLASS (gtk_expander_parent_class)->unrealize (widget);
462 gtk_expander_size_request (GtkWidget *widget,
463 GtkRequisition *requisition)
465 GtkExpander *expander;
467 GtkExpanderPrivate *priv;
470 gint expander_spacing;
471 gboolean interior_focus;
475 bin = GTK_BIN (widget);
476 expander = GTK_EXPANDER (widget);
477 priv = expander->priv;
479 border_width = GTK_CONTAINER (widget)->border_width;
481 gtk_widget_style_get (widget,
482 "interior-focus", &interior_focus,
483 "focus-line-width", &focus_width,
484 "focus-padding", &focus_pad,
485 "expander-size", &expander_size,
486 "expander-spacing", &expander_spacing,
489 requisition->width = expander_size + 2 * expander_spacing +
490 2 * focus_width + 2 * focus_pad;
491 requisition->height = interior_focus ? (2 * focus_width + 2 * focus_pad) : 0;
493 if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
495 GtkRequisition label_requisition;
497 gtk_widget_size_request (priv->label_widget, &label_requisition);
499 requisition->width += label_requisition.width;
500 requisition->height += label_requisition.height;
503 requisition->height = MAX (expander_size + 2 * expander_spacing, requisition->height);
506 requisition->height += 2 * focus_width + 2 * focus_pad;
508 if (bin->child && GTK_WIDGET_CHILD_VISIBLE (bin->child))
510 GtkRequisition child_requisition;
512 gtk_widget_size_request (bin->child, &child_requisition);
514 requisition->width = MAX (requisition->width, child_requisition.width);
515 requisition->height += child_requisition.height + priv->spacing;
518 requisition->width += 2 * border_width;
519 requisition->height += 2 * border_width;
523 get_expander_bounds (GtkExpander *expander,
527 GtkExpanderPrivate *priv;
530 gint expander_spacing;
531 gboolean interior_focus;
536 widget = GTK_WIDGET (expander);
537 priv = expander->priv;
539 border_width = GTK_CONTAINER (expander)->border_width;
541 gtk_widget_style_get (widget,
542 "interior-focus", &interior_focus,
543 "focus-line-width", &focus_width,
544 "focus-padding", &focus_pad,
545 "expander-size", &expander_size,
546 "expander-spacing", &expander_spacing,
549 ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
551 rect->x = widget->allocation.x + border_width;
552 rect->y = widget->allocation.y + border_width;
555 rect->x += expander_spacing;
557 rect->x += widget->allocation.width - 2 * border_width -
558 expander_spacing - expander_size;
560 if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
562 GtkAllocation label_allocation;
564 label_allocation = priv->label_widget->allocation;
566 if (expander_size < label_allocation.height)
567 rect->y += focus_width + focus_pad + (label_allocation.height - expander_size) / 2;
569 rect->y += expander_spacing;
573 rect->y += expander_spacing;
579 rect->x += focus_width + focus_pad;
581 rect->x -= focus_width + focus_pad;
582 rect->y += focus_width + focus_pad;
585 rect->width = rect->height = expander_size;
589 gtk_expander_size_allocate (GtkWidget *widget,
590 GtkAllocation *allocation)
592 GtkExpander *expander;
594 GtkExpanderPrivate *priv;
595 GtkRequisition child_requisition;
596 gboolean child_visible = FALSE;
599 gint expander_spacing;
600 gboolean interior_focus;
605 expander = GTK_EXPANDER (widget);
606 bin = GTK_BIN (widget);
607 priv = expander->priv;
609 border_width = GTK_CONTAINER (widget)->border_width;
611 gtk_widget_style_get (widget,
612 "interior-focus", &interior_focus,
613 "focus-line-width", &focus_width,
614 "focus-padding", &focus_pad,
615 "expander-size", &expander_size,
616 "expander-spacing", &expander_spacing,
619 child_requisition.width = 0;
620 child_requisition.height = 0;
621 if (bin->child && GTK_WIDGET_CHILD_VISIBLE (bin->child))
623 child_visible = TRUE;
624 gtk_widget_get_child_requisition (bin->child, &child_requisition);
627 widget->allocation = *allocation;
629 if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
631 GtkAllocation label_allocation;
632 GtkRequisition label_requisition;
635 gtk_widget_get_child_requisition (priv->label_widget, &label_requisition);
637 ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
640 label_allocation.x = (widget->allocation.x +
641 border_width + focus_width + focus_pad +
642 expander_size + 2 * expander_spacing);
644 label_allocation.x = (widget->allocation.x + widget->allocation.width -
645 (label_requisition.width +
646 border_width + focus_width + focus_pad +
647 expander_size + 2 * expander_spacing));
649 label_allocation.y = widget->allocation.y + border_width + focus_width + focus_pad;
651 label_allocation.width = MIN (label_requisition.width,
652 allocation->width - 2 * border_width -
653 expander_size - 2 * expander_spacing -
654 2 * focus_width - 2 * focus_pad);
655 label_allocation.width = MAX (label_allocation.width, 1);
657 label_allocation.height = MIN (label_requisition.height,
658 allocation->height - 2 * border_width -
659 2 * focus_width - 2 * focus_pad -
660 (child_visible ? priv->spacing : 0));
661 label_allocation.height = MAX (label_allocation.height, 1);
663 gtk_widget_size_allocate (priv->label_widget, &label_allocation);
665 label_height = label_allocation.height;
672 if (gtk_widget_get_realized (widget))
676 get_expander_bounds (expander, &rect);
678 gdk_window_move_resize (priv->event_window,
679 allocation->x + border_width,
680 allocation->y + border_width,
681 MAX (allocation->width - 2 * border_width, 1),
682 MAX (rect.height, label_height - 2 * border_width));
687 GtkAllocation child_allocation;
690 top_height = MAX (2 * expander_spacing + expander_size,
692 (interior_focus ? 2 * focus_width + 2 * focus_pad : 0));
694 child_allocation.x = widget->allocation.x + border_width;
695 child_allocation.y = widget->allocation.y + border_width + top_height + priv->spacing;
698 child_allocation.y += 2 * focus_width + 2 * focus_pad;
700 child_allocation.width = MAX (allocation->width - 2 * border_width, 1);
702 child_allocation.height = allocation->height - top_height -
703 2 * border_width - priv->spacing -
704 (!interior_focus ? 2 * focus_width + 2 * focus_pad : 0);
705 child_allocation.height = MAX (child_allocation.height, 1);
707 gtk_widget_size_allocate (bin->child, &child_allocation);
712 gtk_expander_map (GtkWidget *widget)
714 GtkExpanderPrivate *priv = GTK_EXPANDER (widget)->priv;
716 if (priv->label_widget)
717 gtk_widget_map (priv->label_widget);
719 GTK_WIDGET_CLASS (gtk_expander_parent_class)->map (widget);
721 if (priv->event_window)
722 gdk_window_show (priv->event_window);
726 gtk_expander_unmap (GtkWidget *widget)
728 GtkExpanderPrivate *priv = GTK_EXPANDER (widget)->priv;
730 if (priv->event_window)
731 gdk_window_hide (priv->event_window);
733 GTK_WIDGET_CLASS (gtk_expander_parent_class)->unmap (widget);
735 if (priv->label_widget)
736 gtk_widget_unmap (priv->label_widget);
740 gtk_expander_paint_prelight (GtkExpander *expander)
743 GtkContainer *container;
744 GtkExpanderPrivate *priv;
746 gboolean interior_focus;
750 int expander_spacing;
752 priv = expander->priv;
753 widget = GTK_WIDGET (expander);
754 container = GTK_CONTAINER (expander);
756 gtk_widget_style_get (widget,
757 "interior-focus", &interior_focus,
758 "focus-line-width", &focus_width,
759 "focus-padding", &focus_pad,
760 "expander-size", &expander_size,
761 "expander-spacing", &expander_spacing,
764 area.x = widget->allocation.x + container->border_width;
765 area.y = widget->allocation.y + container->border_width;
766 area.width = widget->allocation.width - (2 * container->border_width);
768 if (priv->label_widget && gtk_widget_get_visible (priv->label_widget))
769 area.height = priv->label_widget->allocation.height;
773 area.height += interior_focus ? (focus_width + focus_pad) * 2 : 0;
774 area.height = MAX (area.height, expander_size + 2 * expander_spacing);
775 area.height += !interior_focus ? (focus_width + focus_pad) * 2 : 0;
777 gtk_paint_flat_box (widget->style, widget->window,
779 GTK_SHADOW_ETCHED_OUT,
780 &area, widget, "expander",
782 area.width, area.height);
786 gtk_expander_paint (GtkExpander *expander)
792 widget = GTK_WIDGET (expander);
794 get_expander_bounds (expander, &clip);
796 state = widget->state;
797 if (expander->priv->prelight)
799 state = GTK_STATE_PRELIGHT;
801 gtk_expander_paint_prelight (expander);
804 gtk_paint_expander (widget->style,
810 clip.x + clip.width / 2,
811 clip.y + clip.height / 2,
812 expander->priv->expander_style);
816 gtk_expander_paint_focus (GtkExpander *expander,
820 GtkExpanderPrivate *priv;
822 gint x, y, width, height;
823 gboolean interior_focus;
828 gint expander_spacing;
831 widget = GTK_WIDGET (expander);
832 priv = expander->priv;
834 border_width = GTK_CONTAINER (widget)->border_width;
836 gtk_widget_style_get (widget,
837 "interior-focus", &interior_focus,
838 "focus-line-width", &focus_width,
839 "focus-padding", &focus_pad,
840 "expander-size", &expander_size,
841 "expander-spacing", &expander_spacing,
844 ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
848 if (priv->label_widget)
850 if (gtk_widget_get_visible (priv->label_widget))
852 GtkAllocation label_allocation = priv->label_widget->allocation;
854 width = label_allocation.width;
855 height = label_allocation.height;
858 width += 2 * focus_pad + 2 * focus_width;
859 height += 2 * focus_pad + 2 * focus_width;
861 x = widget->allocation.x + border_width;
862 y = widget->allocation.y + border_width;
867 x += expander_spacing * 2 + expander_size;
871 x += widget->allocation.width - 2 * border_width
872 - expander_spacing * 2 - expander_size - width;
877 width += expander_size + 2 * expander_spacing;
878 height = MAX (height, expander_size + 2 * expander_spacing);
883 get_expander_bounds (expander, &rect);
885 x = rect.x - focus_pad;
886 y = rect.y - focus_pad;
887 width = rect.width + 2 * focus_pad;
888 height = rect.height + 2 * focus_pad;
891 gtk_paint_focus (widget->style, widget->window, gtk_widget_get_state (widget),
892 area, widget, "expander",
893 x, y, width, height);
897 gtk_expander_expose (GtkWidget *widget,
898 GdkEventExpose *event)
900 if (gtk_widget_is_drawable (widget))
902 GtkExpander *expander = GTK_EXPANDER (widget);
904 gtk_expander_paint (expander);
906 if (gtk_widget_has_focus (widget))
907 gtk_expander_paint_focus (expander, &event->area);
909 GTK_WIDGET_CLASS (gtk_expander_parent_class)->expose_event (widget, event);
916 gtk_expander_button_press (GtkWidget *widget,
917 GdkEventButton *event)
919 GtkExpander *expander = GTK_EXPANDER (widget);
921 if (event->button == 1 && event->window == expander->priv->event_window)
923 expander->priv->button_down = TRUE;
931 gtk_expander_button_release (GtkWidget *widget,
932 GdkEventButton *event)
934 GtkExpander *expander = GTK_EXPANDER (widget);
936 if (event->button == 1 && expander->priv->button_down)
938 gtk_widget_activate (widget);
939 expander->priv->button_down = FALSE;
947 gtk_expander_grab_notify (GtkWidget *widget,
948 gboolean was_grabbed)
951 GTK_EXPANDER (widget)->priv->button_down = FALSE;
955 gtk_expander_state_changed (GtkWidget *widget,
956 GtkStateType previous_state)
958 if (!gtk_widget_is_sensitive (widget))
959 GTK_EXPANDER (widget)->priv->button_down = FALSE;
963 gtk_expander_redraw_expander (GtkExpander *expander)
967 widget = GTK_WIDGET (expander);
969 if (gtk_widget_get_realized (widget))
970 gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
974 gtk_expander_enter_notify (GtkWidget *widget,
975 GdkEventCrossing *event)
977 GtkExpander *expander = GTK_EXPANDER (widget);
978 GtkWidget *event_widget;
980 event_widget = gtk_get_event_widget ((GdkEvent *) event);
982 if (event_widget == widget &&
983 event->detail != GDK_NOTIFY_INFERIOR)
985 expander->priv->prelight = TRUE;
987 if (expander->priv->label_widget)
988 gtk_widget_set_state (expander->priv->label_widget, GTK_STATE_PRELIGHT);
990 gtk_expander_redraw_expander (expander);
997 gtk_expander_leave_notify (GtkWidget *widget,
998 GdkEventCrossing *event)
1000 GtkExpander *expander = GTK_EXPANDER (widget);
1001 GtkWidget *event_widget;
1003 event_widget = gtk_get_event_widget ((GdkEvent *) event);
1005 if (event_widget == widget &&
1006 event->detail != GDK_NOTIFY_INFERIOR)
1008 expander->priv->prelight = FALSE;
1010 if (expander->priv->label_widget)
1011 gtk_widget_set_state (expander->priv->label_widget, GTK_STATE_NORMAL);
1013 gtk_expander_redraw_expander (expander);
1020 expand_timeout (gpointer data)
1022 GtkExpander *expander = GTK_EXPANDER (data);
1023 GtkExpanderPrivate *priv = expander->priv;
1025 priv->expand_timer = 0;
1026 gtk_expander_set_expanded (expander, TRUE);
1032 gtk_expander_drag_motion (GtkWidget *widget,
1033 GdkDragContext *context,
1038 GtkExpander *expander = GTK_EXPANDER (widget);
1039 GtkExpanderPrivate *priv = expander->priv;
1041 if (!priv->expanded && !priv->expand_timer)
1043 GtkSettings *settings;
1046 settings = gtk_widget_get_settings (widget);
1047 g_object_get (settings, "gtk-timeout-expand", &timeout, NULL);
1049 priv->expand_timer = gdk_threads_add_timeout (timeout, (GSourceFunc) expand_timeout, expander);
1056 gtk_expander_drag_leave (GtkWidget *widget,
1057 GdkDragContext *context,
1060 GtkExpander *expander = GTK_EXPANDER (widget);
1061 GtkExpanderPrivate *priv = expander->priv;
1063 if (priv->expand_timer)
1065 g_source_remove (priv->expand_timer);
1066 priv->expand_timer = 0;
1079 focus_current_site (GtkExpander *expander,
1080 GtkDirectionType direction)
1082 GtkWidget *current_focus;
1084 current_focus = GTK_CONTAINER (expander)->focus_child;
1089 return gtk_widget_child_focus (current_focus, direction);
1093 focus_in_site (GtkExpander *expander,
1095 GtkDirectionType direction)
1100 gtk_widget_grab_focus (GTK_WIDGET (expander));
1103 if (expander->priv->label_widget)
1104 return gtk_widget_child_focus (expander->priv->label_widget, direction);
1109 GtkWidget *child = gtk_bin_get_child (GTK_BIN (expander));
1111 if (child && GTK_WIDGET_CHILD_VISIBLE (child))
1112 return gtk_widget_child_focus (child, direction);
1120 g_assert_not_reached ();
1125 get_next_site (GtkExpander *expander,
1127 GtkDirectionType direction)
1131 ltr = gtk_widget_get_direction (GTK_WIDGET (expander)) != GTK_TEXT_DIR_RTL;
1138 case GTK_DIR_TAB_BACKWARD:
1142 case GTK_DIR_TAB_FORWARD:
1145 return FOCUS_WIDGET;
1150 case GTK_DIR_TAB_BACKWARD:
1154 return ltr ? FOCUS_NONE : FOCUS_LABEL;
1155 case GTK_DIR_TAB_FORWARD:
1159 return ltr ? FOCUS_LABEL : FOCUS_NONE;
1165 case GTK_DIR_TAB_BACKWARD:
1167 return FOCUS_WIDGET;
1169 return ltr ? FOCUS_WIDGET : FOCUS_CHILD;
1170 case GTK_DIR_TAB_FORWARD:
1174 return ltr ? FOCUS_CHILD : FOCUS_WIDGET;
1180 case GTK_DIR_TAB_BACKWARD:
1184 case GTK_DIR_TAB_FORWARD:
1191 g_assert_not_reached ();
1196 gtk_expander_focus (GtkWidget *widget,
1197 GtkDirectionType direction)
1199 GtkExpander *expander = GTK_EXPANDER (widget);
1201 if (!focus_current_site (expander, direction))
1203 GtkWidget *old_focus_child;
1204 gboolean widget_is_focus;
1205 FocusSite site = FOCUS_NONE;
1207 widget_is_focus = gtk_widget_is_focus (widget);
1208 old_focus_child = GTK_CONTAINER (widget)->focus_child;
1210 if (old_focus_child && old_focus_child == expander->priv->label_widget)
1212 else if (old_focus_child)
1214 else if (widget_is_focus)
1215 site = FOCUS_WIDGET;
1217 while ((site = get_next_site (expander, site, direction)) != FOCUS_NONE)
1219 if (focus_in_site (expander, site, direction))
1230 gtk_expander_add (GtkContainer *container,
1233 GTK_CONTAINER_CLASS (gtk_expander_parent_class)->add (container, widget);
1235 gtk_widget_set_child_visible (widget, GTK_EXPANDER (container)->priv->expanded);
1236 gtk_widget_queue_resize (GTK_WIDGET (container));
1240 gtk_expander_remove (GtkContainer *container,
1243 GtkExpander *expander = GTK_EXPANDER (container);
1245 if (GTK_EXPANDER (expander)->priv->label_widget == widget)
1246 gtk_expander_set_label_widget (expander, NULL);
1248 GTK_CONTAINER_CLASS (gtk_expander_parent_class)->remove (container, widget);
1252 gtk_expander_forall (GtkContainer *container,
1253 gboolean include_internals,
1254 GtkCallback callback,
1255 gpointer callback_data)
1257 GtkBin *bin = GTK_BIN (container);
1258 GtkExpanderPrivate *priv = GTK_EXPANDER (container)->priv;
1261 (* callback) (bin->child, callback_data);
1263 if (priv->label_widget)
1264 (* callback) (priv->label_widget, callback_data);
1268 gtk_expander_activate (GtkExpander *expander)
1270 gtk_expander_set_expanded (expander, !expander->priv->expanded);
1275 * @label: the text of the label
1277 * Creates a new expander using @label as the text of the label.
1279 * Return value: a new #GtkExpander widget.
1284 gtk_expander_new (const gchar *label)
1286 return g_object_new (GTK_TYPE_EXPANDER, "label", label, NULL);
1290 * gtk_expander_new_with_mnemonic:
1291 * @label: (allow-none): the text of the label with an underscore in front of the
1292 * mnemonic character
1294 * Creates a new expander using @label as the text of the label.
1295 * If characters in @label are preceded by an underscore, they are underlined.
1296 * If you need a literal underscore character in a label, use '__' (two
1297 * underscores). The first underlined character represents a keyboard
1298 * accelerator called a mnemonic.
1299 * Pressing Alt and that key activates the button.
1301 * Return value: a new #GtkExpander widget.
1306 gtk_expander_new_with_mnemonic (const gchar *label)
1308 return g_object_new (GTK_TYPE_EXPANDER,
1310 "use-underline", TRUE,
1315 gtk_expander_animation_timeout (GtkExpander *expander)
1317 GtkExpanderPrivate *priv = expander->priv;
1319 gboolean finish = FALSE;
1321 if (gtk_widget_get_realized (GTK_WIDGET (expander)))
1323 get_expander_bounds (expander, &area);
1324 gdk_window_invalidate_rect (GTK_WIDGET (expander)->window, &area, TRUE);
1329 if (priv->expander_style == GTK_EXPANDER_COLLAPSED)
1331 priv->expander_style = GTK_EXPANDER_SEMI_EXPANDED;
1335 priv->expander_style = GTK_EXPANDER_EXPANDED;
1341 if (priv->expander_style == GTK_EXPANDER_EXPANDED)
1343 priv->expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
1347 priv->expander_style = GTK_EXPANDER_COLLAPSED;
1354 priv->animation_timeout = 0;
1355 if (GTK_BIN (expander)->child)
1356 gtk_widget_set_child_visible (GTK_BIN (expander)->child, priv->expanded);
1357 gtk_widget_queue_resize (GTK_WIDGET (expander));
1364 gtk_expander_start_animation (GtkExpander *expander)
1366 GtkExpanderPrivate *priv = expander->priv;
1368 if (priv->animation_timeout)
1369 g_source_remove (priv->animation_timeout);
1371 priv->animation_timeout =
1372 gdk_threads_add_timeout (50,
1373 (GSourceFunc) gtk_expander_animation_timeout,
1378 * gtk_expander_set_expanded:
1379 * @expander: a #GtkExpander
1380 * @expanded: whether the child widget is revealed
1382 * Sets the state of the expander. Set to %TRUE, if you want
1383 * the child widget to be revealed, and %FALSE if you want the
1384 * child widget to be hidden.
1389 gtk_expander_set_expanded (GtkExpander *expander,
1392 GtkExpanderPrivate *priv;
1394 g_return_if_fail (GTK_IS_EXPANDER (expander));
1396 priv = expander->priv;
1398 expanded = expanded != FALSE;
1400 if (priv->expanded != expanded)
1402 GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (expander));
1403 gboolean enable_animations;
1405 priv->expanded = expanded;
1407 g_object_get (settings, "gtk-enable-animations", &enable_animations, NULL);
1409 if (enable_animations && gtk_widget_get_realized (GTK_WIDGET (expander)))
1411 gtk_expander_start_animation (expander);
1415 priv->expander_style = expanded ? GTK_EXPANDER_EXPANDED :
1416 GTK_EXPANDER_COLLAPSED;
1418 if (GTK_BIN (expander)->child)
1420 gtk_widget_set_child_visible (GTK_BIN (expander)->child, priv->expanded);
1421 gtk_widget_queue_resize (GTK_WIDGET (expander));
1425 g_object_notify (G_OBJECT (expander), "expanded");
1430 * gtk_expander_get_expanded:
1431 * @expander:a #GtkExpander
1433 * Queries a #GtkExpander and returns its current state. Returns %TRUE
1434 * if the child widget is revealed.
1436 * See gtk_expander_set_expanded().
1438 * Return value: the current state of the expander.
1443 gtk_expander_get_expanded (GtkExpander *expander)
1445 g_return_val_if_fail (GTK_IS_EXPANDER (expander), FALSE);
1447 return expander->priv->expanded;
1451 * gtk_expander_set_spacing:
1452 * @expander: a #GtkExpander
1453 * @spacing: distance between the expander and child in pixels.
1455 * Sets the spacing field of @expander, which is the number of pixels to
1456 * place between expander and the child.
1461 gtk_expander_set_spacing (GtkExpander *expander,
1464 g_return_if_fail (GTK_IS_EXPANDER (expander));
1465 g_return_if_fail (spacing >= 0);
1467 if (expander->priv->spacing != spacing)
1469 expander->priv->spacing = spacing;
1471 gtk_widget_queue_resize (GTK_WIDGET (expander));
1473 g_object_notify (G_OBJECT (expander), "spacing");
1478 * gtk_expander_get_spacing:
1479 * @expander: a #GtkExpander
1481 * Gets the value set by gtk_expander_set_spacing().
1483 * Return value: spacing between the expander and child.
1488 gtk_expander_get_spacing (GtkExpander *expander)
1490 g_return_val_if_fail (GTK_IS_EXPANDER (expander), 0);
1492 return expander->priv->spacing;
1496 * gtk_expander_set_label:
1497 * @expander: a #GtkExpander
1498 * @label: (allow-none): a string
1500 * Sets the text of the label of the expander to @label.
1502 * This will also clear any previously set labels.
1507 gtk_expander_set_label (GtkExpander *expander,
1510 g_return_if_fail (GTK_IS_EXPANDER (expander));
1514 gtk_expander_set_label_widget (expander, NULL);
1520 child = gtk_label_new (label);
1521 gtk_label_set_use_underline (GTK_LABEL (child), expander->priv->use_underline);
1522 gtk_label_set_use_markup (GTK_LABEL (child), expander->priv->use_markup);
1523 gtk_widget_show (child);
1525 gtk_expander_set_label_widget (expander, child);
1528 g_object_notify (G_OBJECT (expander), "label");
1532 * gtk_expander_get_label:
1533 * @expander: a #GtkExpander
1535 * Fetches the text from a label widget including any embedded
1536 * underlines indicating mnemonics and Pango markup, as set by
1537 * gtk_expander_set_label(). If the label text has not been set the
1538 * return value will be %NULL. This will be the case if you create an
1539 * empty button with gtk_button_new() to use as a container.
1541 * Note that this function behaved differently in versions prior to
1542 * 2.14 and used to return the label text stripped of embedded
1543 * underlines indicating mnemonics and Pango markup. This problem can
1544 * be avoided by fetching the label text directly from the label
1547 * Return value: The text of the label widget. This string is owned
1548 * by the widget and must not be modified or freed.
1552 G_CONST_RETURN char *
1553 gtk_expander_get_label (GtkExpander *expander)
1555 GtkExpanderPrivate *priv;
1557 g_return_val_if_fail (GTK_IS_EXPANDER (expander), NULL);
1559 priv = expander->priv;
1561 if (GTK_IS_LABEL (priv->label_widget))
1562 return gtk_label_get_label (GTK_LABEL (priv->label_widget));
1568 * gtk_expander_set_use_underline:
1569 * @expander: a #GtkExpander
1570 * @use_underline: %TRUE if underlines in the text indicate mnemonics
1572 * If true, an underline in the text of the expander label indicates
1573 * the next character should be used for the mnemonic accelerator key.
1578 gtk_expander_set_use_underline (GtkExpander *expander,
1579 gboolean use_underline)
1581 GtkExpanderPrivate *priv;
1583 g_return_if_fail (GTK_IS_EXPANDER (expander));
1585 priv = expander->priv;
1587 use_underline = use_underline != FALSE;
1589 if (priv->use_underline != use_underline)
1591 priv->use_underline = use_underline;
1593 if (GTK_IS_LABEL (priv->label_widget))
1594 gtk_label_set_use_underline (GTK_LABEL (priv->label_widget), use_underline);
1596 g_object_notify (G_OBJECT (expander), "use-underline");
1601 * gtk_expander_get_use_underline:
1602 * @expander: a #GtkExpander
1604 * Returns whether an embedded underline in the expander label indicates a
1605 * mnemonic. See gtk_expander_set_use_underline().
1607 * Return value: %TRUE if an embedded underline in the expander label
1608 * indicates the mnemonic accelerator keys.
1613 gtk_expander_get_use_underline (GtkExpander *expander)
1615 g_return_val_if_fail (GTK_IS_EXPANDER (expander), FALSE);
1617 return expander->priv->use_underline;
1621 * gtk_expander_set_use_markup:
1622 * @expander: a #GtkExpander
1623 * @use_markup: %TRUE if the label's text should be parsed for markup
1625 * Sets whether the text of the label contains markup in <link
1626 * linkend="PangoMarkupFormat">Pango's text markup
1627 * language</link>. See gtk_label_set_markup().
1632 gtk_expander_set_use_markup (GtkExpander *expander,
1633 gboolean use_markup)
1635 GtkExpanderPrivate *priv;
1637 g_return_if_fail (GTK_IS_EXPANDER (expander));
1639 priv = expander->priv;
1641 use_markup = use_markup != FALSE;
1643 if (priv->use_markup != use_markup)
1645 priv->use_markup = use_markup;
1647 if (GTK_IS_LABEL (priv->label_widget))
1648 gtk_label_set_use_markup (GTK_LABEL (priv->label_widget), use_markup);
1650 g_object_notify (G_OBJECT (expander), "use-markup");
1655 * gtk_expander_get_use_markup:
1656 * @expander: a #GtkExpander
1658 * Returns whether the label's text is interpreted as marked up with
1659 * the <link linkend="PangoMarkupFormat">Pango text markup
1660 * language</link>. See gtk_expander_set_use_markup ().
1662 * Return value: %TRUE if the label's text will be parsed for markup
1667 gtk_expander_get_use_markup (GtkExpander *expander)
1669 g_return_val_if_fail (GTK_IS_EXPANDER (expander), FALSE);
1671 return expander->priv->use_markup;
1675 * gtk_expander_set_label_widget:
1676 * @expander: a #GtkExpander
1677 * @label_widget: (allow-none): the new label widget
1679 * Set the label widget for the expander. This is the widget
1680 * that will appear embedded alongside the expander arrow.
1685 gtk_expander_set_label_widget (GtkExpander *expander,
1686 GtkWidget *label_widget)
1688 GtkExpanderPrivate *priv;
1691 g_return_if_fail (GTK_IS_EXPANDER (expander));
1692 g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget));
1693 g_return_if_fail (label_widget == NULL || label_widget->parent == NULL);
1695 priv = expander->priv;
1697 if (priv->label_widget == label_widget)
1700 if (priv->label_widget)
1702 gtk_widget_set_state (priv->label_widget, GTK_STATE_NORMAL);
1703 gtk_widget_unparent (priv->label_widget);
1706 priv->label_widget = label_widget;
1707 widget = GTK_WIDGET (expander);
1711 priv->label_widget = label_widget;
1713 gtk_widget_set_parent (label_widget, widget);
1716 gtk_widget_set_state (label_widget, GTK_STATE_PRELIGHT);
1719 if (gtk_widget_get_visible (widget))
1720 gtk_widget_queue_resize (widget);
1722 g_object_freeze_notify (G_OBJECT (expander));
1723 g_object_notify (G_OBJECT (expander), "label-widget");
1724 g_object_notify (G_OBJECT (expander), "label");
1725 g_object_thaw_notify (G_OBJECT (expander));
1729 * gtk_expander_get_label_widget:
1730 * @expander: a #GtkExpander
1732 * Retrieves the label widget for the frame. See
1733 * gtk_expander_set_label_widget().
1735 * Return value: the label widget, or %NULL if there is none.
1740 gtk_expander_get_label_widget (GtkExpander *expander)
1742 g_return_val_if_fail (GTK_IS_EXPANDER (expander), NULL);
1744 return expander->priv->label_widget;
1747 #define __GTK_EXPANDER_C__
1748 #include "gtkaliasdef.c"