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 "gtkcontainer.h"
30 #include "gtkmarshalers.h"
33 #include "gtkprivate.h"
34 #include <gdk/gdkkeysyms.h>
38 #define GTK_EXPANDER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_EXPANDER, GtkExpanderPrivate))
40 #define DEFAULT_EXPANDER_SIZE 10
41 #define DEFAULT_EXPANDER_SPACING 2
54 struct _GtkExpanderPrivate
56 GtkWidget *label_widget;
57 GdkWindow *event_window;
60 GtkExpanderStyle expander_style;
61 guint animation_timeout;
65 guint use_underline : 1;
67 guint button_down : 1;
71 static void gtk_expander_class_init (GtkExpanderClass *klass);
72 static void gtk_expander_init (GtkExpander *expander);
74 static void gtk_expander_set_property (GObject *object,
78 static void gtk_expander_get_property (GObject *object,
83 static void gtk_expander_destroy (GtkObject *object);
85 static void gtk_expander_realize (GtkWidget *widget);
86 static void gtk_expander_unrealize (GtkWidget *widget);
87 static void gtk_expander_size_request (GtkWidget *widget,
88 GtkRequisition *requisition);
89 static void gtk_expander_size_allocate (GtkWidget *widget,
90 GtkAllocation *allocation);
91 static void gtk_expander_map (GtkWidget *widget);
92 static void gtk_expander_unmap (GtkWidget *widget);
93 static gboolean gtk_expander_expose (GtkWidget *widget,
94 GdkEventExpose *event);
95 static gboolean gtk_expander_button_press (GtkWidget *widget,
96 GdkEventButton *event);
97 static gboolean gtk_expander_button_release (GtkWidget *widget,
98 GdkEventButton *event);
99 static gboolean gtk_expander_enter_notify (GtkWidget *widget,
100 GdkEventCrossing *event);
101 static gboolean gtk_expander_leave_notify (GtkWidget *widget,
102 GdkEventCrossing *event);
103 static gboolean gtk_expander_focus (GtkWidget *widget,
104 GtkDirectionType direction);
105 static void gtk_expander_grab_notify (GtkWidget *widget,
106 gboolean was_grabbed);
107 static void gtk_expander_state_changed (GtkWidget *widget,
108 GtkStateType previous_state);
109 static gboolean gtk_expander_drag_motion (GtkWidget *widget,
110 GdkDragContext *context,
114 static void gtk_expander_drag_leave (GtkWidget *widget,
115 GdkDragContext *context,
118 static void gtk_expander_add (GtkContainer *container,
120 static void gtk_expander_remove (GtkContainer *container,
122 static void gtk_expander_forall (GtkContainer *container,
123 gboolean include_internals,
124 GtkCallback callback,
125 gpointer callback_data);
127 static void gtk_expander_activate (GtkExpander *expander);
129 static void get_expander_bounds (GtkExpander *expander,
132 static GtkBinClass *parent_class = NULL;
135 gtk_expander_get_type (void)
137 static GType expander_type = 0;
141 static const GTypeInfo expander_info =
143 sizeof (GtkExpanderClass),
144 NULL, /* base_init */
145 NULL, /* base_finalize */
146 (GClassInitFunc) gtk_expander_class_init,
147 NULL, /* class_finalize */
148 NULL, /* class_data */
149 sizeof (GtkExpander),
151 (GInstanceInitFunc) gtk_expander_init,
154 expander_type = g_type_register_static (GTK_TYPE_BIN,
159 return expander_type;
163 gtk_expander_class_init (GtkExpanderClass *klass)
165 GObjectClass *gobject_class;
166 GtkObjectClass *object_class;
167 GtkWidgetClass *widget_class;
168 GtkContainerClass *container_class;
170 parent_class = g_type_class_peek_parent (klass);
172 gobject_class = (GObjectClass *) klass;
173 object_class = (GtkObjectClass *) klass;
174 widget_class = (GtkWidgetClass *) klass;
175 container_class = (GtkContainerClass *) klass;
177 gobject_class->set_property = gtk_expander_set_property;
178 gobject_class->get_property = gtk_expander_get_property;
180 object_class->destroy = gtk_expander_destroy;
182 widget_class->realize = gtk_expander_realize;
183 widget_class->unrealize = gtk_expander_unrealize;
184 widget_class->size_request = gtk_expander_size_request;
185 widget_class->size_allocate = gtk_expander_size_allocate;
186 widget_class->map = gtk_expander_map;
187 widget_class->unmap = gtk_expander_unmap;
188 widget_class->expose_event = gtk_expander_expose;
189 widget_class->button_press_event = gtk_expander_button_press;
190 widget_class->button_release_event = gtk_expander_button_release;
191 widget_class->enter_notify_event = gtk_expander_enter_notify;
192 widget_class->leave_notify_event = gtk_expander_leave_notify;
193 widget_class->focus = gtk_expander_focus;
194 widget_class->grab_notify = gtk_expander_grab_notify;
195 widget_class->state_changed = gtk_expander_state_changed;
196 widget_class->drag_motion = gtk_expander_drag_motion;
197 widget_class->drag_leave = gtk_expander_drag_leave;
199 container_class->add = gtk_expander_add;
200 container_class->remove = gtk_expander_remove;
201 container_class->forall = gtk_expander_forall;
203 klass->activate = gtk_expander_activate;
205 g_type_class_add_private (klass, sizeof (GtkExpanderPrivate));
207 g_object_class_install_property (gobject_class,
209 g_param_spec_boolean ("expanded",
211 P_("Whether the expander has been opened to reveal the child widget"),
213 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
215 g_object_class_install_property (gobject_class,
217 g_param_spec_string ("label",
219 P_("Text of the expander's label"),
221 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
223 g_object_class_install_property (gobject_class,
225 g_param_spec_boolean ("use-underline",
227 P_("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),
229 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
231 g_object_class_install_property (gobject_class,
233 g_param_spec_boolean ("use-markup",
235 P_("The text of the label includes XML markup. See pango_parse_markup()"),
237 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
239 g_object_class_install_property (gobject_class,
241 g_param_spec_int ("spacing",
243 P_("Space to put between the label and the child"),
247 GTK_PARAM_READWRITE));
249 g_object_class_install_property (gobject_class,
251 g_param_spec_object ("label-widget",
253 P_("A widget to display in place of the usual expander label"),
255 GTK_PARAM_READWRITE));
257 gtk_widget_class_install_style_property (widget_class,
258 g_param_spec_int ("expander-size",
260 P_("Size of the expander arrow"),
263 DEFAULT_EXPANDER_SIZE,
264 GTK_PARAM_READABLE));
266 gtk_widget_class_install_style_property (widget_class,
267 g_param_spec_int ("expander-spacing",
268 P_("Indicator Spacing"),
269 P_("Spacing around expander arrow"),
272 DEFAULT_EXPANDER_SPACING,
273 GTK_PARAM_READABLE));
275 widget_class->activate_signal =
276 g_signal_new (I_("activate"),
277 G_TYPE_FROM_CLASS (gobject_class),
278 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
279 G_STRUCT_OFFSET (GtkExpanderClass, activate),
281 _gtk_marshal_VOID__VOID,
286 gtk_expander_init (GtkExpander *expander)
288 GtkExpanderPrivate *priv;
290 expander->priv = priv = GTK_EXPANDER_GET_PRIVATE (expander);
292 GTK_WIDGET_SET_FLAGS (expander, GTK_CAN_FOCUS);
293 GTK_WIDGET_SET_FLAGS (expander, GTK_NO_WINDOW);
295 priv->label_widget = NULL;
296 priv->event_window = NULL;
299 priv->expander_style = GTK_EXPANDER_COLLAPSED;
300 priv->animation_timeout = 0;
302 priv->expanded = FALSE;
303 priv->use_underline = FALSE;
304 priv->use_markup = FALSE;
305 priv->button_down = FALSE;
306 priv->prelight = FALSE;
307 priv->expand_timer = 0;
309 gtk_drag_dest_set (GTK_WIDGET (expander), 0, NULL, 0, 0);
310 gtk_drag_dest_set_track_motion (GTK_WIDGET (expander), TRUE);
314 gtk_expander_set_property (GObject *object,
319 GtkExpander *expander = GTK_EXPANDER (object);
324 gtk_expander_set_expanded (expander, g_value_get_boolean (value));
327 gtk_expander_set_label (expander, g_value_get_string (value));
329 case PROP_USE_UNDERLINE:
330 gtk_expander_set_use_underline (expander, g_value_get_boolean (value));
332 case PROP_USE_MARKUP:
333 gtk_expander_set_use_markup (expander, g_value_get_boolean (value));
336 gtk_expander_set_spacing (expander, g_value_get_int (value));
338 case PROP_LABEL_WIDGET:
339 gtk_expander_set_label_widget (expander, g_value_get_object (value));
342 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
348 gtk_expander_get_property (GObject *object,
353 GtkExpander *expander = GTK_EXPANDER (object);
354 GtkExpanderPrivate *priv = expander->priv;
359 g_value_set_boolean (value, priv->expanded);
362 g_value_set_string (value, gtk_expander_get_label (expander));
364 case PROP_USE_UNDERLINE:
365 g_value_set_boolean (value, priv->use_underline);
367 case PROP_USE_MARKUP:
368 g_value_set_boolean (value, priv->use_markup);
371 g_value_set_int (value, priv->spacing);
373 case PROP_LABEL_WIDGET:
374 g_value_set_object (value,
376 G_OBJECT (priv->label_widget) : NULL);
379 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
385 gtk_expander_destroy (GtkObject *object)
387 GtkExpanderPrivate *priv = GTK_EXPANDER (object)->priv;
389 if (priv->animation_timeout)
391 g_source_remove (priv->animation_timeout);
392 priv->animation_timeout = 0;
395 GTK_OBJECT_CLASS (parent_class)->destroy (object);
399 gtk_expander_realize (GtkWidget *widget)
401 GtkExpanderPrivate *priv;
402 GdkWindowAttr attributes;
403 gint attributes_mask;
405 GdkRectangle expander_rect;
407 priv = GTK_EXPANDER (widget)->priv;
408 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
410 border_width = GTK_CONTAINER (widget)->border_width;
412 get_expander_bounds (GTK_EXPANDER (widget), &expander_rect);
414 attributes.window_type = GDK_WINDOW_CHILD;
415 attributes.x = widget->allocation.x + border_width;
416 attributes.y = expander_rect.y;
417 attributes.width = MAX (widget->allocation.width - 2 * border_width, 1);
418 attributes.height = expander_rect.width;
419 attributes.wclass = GDK_INPUT_ONLY;
420 attributes.event_mask = gtk_widget_get_events (widget) |
421 GDK_BUTTON_PRESS_MASK |
422 GDK_BUTTON_RELEASE_MASK |
423 GDK_ENTER_NOTIFY_MASK |
424 GDK_LEAVE_NOTIFY_MASK;
426 attributes_mask = GDK_WA_X | GDK_WA_Y;
428 widget->window = gtk_widget_get_parent_window (widget);
429 g_object_ref (widget->window);
431 priv->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
432 &attributes, attributes_mask);
433 gdk_window_set_user_data (priv->event_window, widget);
435 widget->style = gtk_style_attach (widget->style, widget->window);
436 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
440 gtk_expander_unrealize (GtkWidget *widget)
442 GtkExpanderPrivate *priv = GTK_EXPANDER (widget)->priv;
444 if (priv->event_window)
446 gdk_window_set_user_data (priv->event_window, NULL);
447 gdk_window_destroy (priv->event_window);
448 priv->event_window = NULL;
451 GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
455 gtk_expander_size_request (GtkWidget *widget,
456 GtkRequisition *requisition)
458 GtkExpander *expander;
460 GtkExpanderPrivate *priv;
463 gint expander_spacing;
464 gboolean interior_focus;
468 bin = GTK_BIN (widget);
469 expander = GTK_EXPANDER (widget);
470 priv = expander->priv;
472 border_width = GTK_CONTAINER (widget)->border_width;
474 gtk_widget_style_get (widget,
475 "interior-focus", &interior_focus,
476 "focus-line-width", &focus_width,
477 "focus-padding", &focus_pad,
478 "expander-size", &expander_size,
479 "expander-spacing", &expander_spacing,
482 requisition->width = expander_size + 2 * expander_spacing +
483 2 * focus_width + 2 * focus_pad;
484 requisition->height = interior_focus ? (2 * focus_width + 2 * focus_pad) : 0;
486 if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
488 GtkRequisition label_requisition;
490 gtk_widget_size_request (priv->label_widget, &label_requisition);
492 requisition->width += label_requisition.width;
493 requisition->height += label_requisition.height;
496 requisition->height = MAX (expander_size + 2 * expander_spacing, requisition->height);
499 requisition->height += 2 * focus_width + 2 * focus_pad;
501 if (bin->child && GTK_WIDGET_CHILD_VISIBLE (bin->child))
503 GtkRequisition child_requisition;
505 gtk_widget_size_request (bin->child, &child_requisition);
507 requisition->width = MAX (requisition->width, child_requisition.width);
508 requisition->height += child_requisition.height + priv->spacing;
511 requisition->width += 2 * border_width;
512 requisition->height += 2 * border_width;
516 get_expander_bounds (GtkExpander *expander,
520 GtkExpanderPrivate *priv;
523 gint expander_spacing;
524 gboolean interior_focus;
529 widget = GTK_WIDGET (expander);
530 priv = expander->priv;
532 border_width = GTK_CONTAINER (expander)->border_width;
534 gtk_widget_style_get (widget,
535 "interior-focus", &interior_focus,
536 "focus-line-width", &focus_width,
537 "focus-padding", &focus_pad,
538 "expander-size", &expander_size,
539 "expander-spacing", &expander_spacing,
542 ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
544 rect->x = widget->allocation.x + border_width;
545 rect->y = widget->allocation.y + border_width;
548 rect->x += expander_spacing;
550 rect->x += widget->allocation.width - 2 * border_width -
551 expander_spacing - expander_size;
553 if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
555 GtkAllocation label_allocation;
557 label_allocation = priv->label_widget->allocation;
559 if (expander_size < label_allocation.height)
560 rect->y += focus_width + focus_pad + (label_allocation.height - expander_size) / 2;
562 rect->y += expander_spacing;
566 rect->y += expander_spacing;
572 rect->x += focus_width + focus_pad;
574 rect->x -= focus_width + focus_pad;
575 rect->y += focus_width + focus_pad;
578 rect->width = rect->height = expander_size;
582 gtk_expander_size_allocate (GtkWidget *widget,
583 GtkAllocation *allocation)
585 GtkExpander *expander;
587 GtkExpanderPrivate *priv;
588 GtkRequisition child_requisition;
589 gboolean child_visible = FALSE;
592 gint expander_spacing;
593 gboolean interior_focus;
598 expander = GTK_EXPANDER (widget);
599 bin = GTK_BIN (widget);
600 priv = expander->priv;
602 border_width = GTK_CONTAINER (widget)->border_width;
604 gtk_widget_style_get (widget,
605 "interior-focus", &interior_focus,
606 "focus-line-width", &focus_width,
607 "focus-padding", &focus_pad,
608 "expander-size", &expander_size,
609 "expander-spacing", &expander_spacing,
612 child_requisition.width = 0;
613 child_requisition.height = 0;
614 if (bin->child && GTK_WIDGET_CHILD_VISIBLE (bin->child))
616 child_visible = TRUE;
617 gtk_widget_get_child_requisition (bin->child, &child_requisition);
620 widget->allocation = *allocation;
622 if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
624 GtkAllocation label_allocation;
625 GtkRequisition label_requisition;
628 gtk_widget_get_child_requisition (priv->label_widget, &label_requisition);
630 ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
633 label_allocation.x = (widget->allocation.x +
634 border_width + focus_width + focus_pad +
635 expander_size + 2 * expander_spacing);
637 label_allocation.x = (widget->allocation.x + widget->allocation.width -
638 (label_requisition.width +
639 border_width + focus_width + focus_pad +
640 expander_size + 2 * expander_spacing));
642 label_allocation.y = widget->allocation.y + border_width + focus_width + focus_pad;
644 label_allocation.width = MIN (label_requisition.width,
645 allocation->width - 2 * border_width -
646 expander_size - 2 * expander_spacing -
647 2 * focus_width - 2 * focus_pad);
648 label_allocation.width = MAX (label_allocation.width, 1);
650 label_allocation.height = MIN (label_requisition.height,
651 allocation->height - 2 * border_width -
652 2 * focus_width - 2 * focus_pad -
653 (child_visible ? priv->spacing : 0));
654 label_allocation.height = MAX (label_allocation.height, 1);
656 gtk_widget_size_allocate (priv->label_widget, &label_allocation);
658 label_height = label_allocation.height;
665 if (GTK_WIDGET_REALIZED (widget))
669 get_expander_bounds (expander, &rect);
671 gdk_window_move_resize (priv->event_window,
672 allocation->x + border_width, rect.y,
673 MAX (allocation->width - 2 * border_width, 1), rect.width);
678 GtkAllocation child_allocation;
681 top_height = MAX (2 * expander_spacing + expander_size,
683 (interior_focus ? 2 * focus_width + 2 * focus_pad : 0));
685 child_allocation.x = widget->allocation.x + border_width;
686 child_allocation.y = widget->allocation.y + border_width + top_height + priv->spacing;
689 child_allocation.y += 2 * focus_width + 2 * focus_pad;
691 child_allocation.width = MAX (allocation->width - 2 * border_width, 1);
693 child_allocation.height = allocation->height - top_height -
694 2 * border_width - priv->spacing -
695 (!interior_focus ? 2 * focus_width + 2 * focus_pad : 0);
696 child_allocation.height = MAX (child_allocation.height, 1);
698 gtk_widget_size_allocate (bin->child, &child_allocation);
703 gtk_expander_map (GtkWidget *widget)
705 GtkExpanderPrivate *priv = GTK_EXPANDER (widget)->priv;
707 if (priv->label_widget)
708 gtk_widget_map (priv->label_widget);
710 GTK_WIDGET_CLASS (parent_class)->map (widget);
712 if (priv->event_window)
713 gdk_window_show (priv->event_window);
717 gtk_expander_unmap (GtkWidget *widget)
719 GtkExpanderPrivate *priv = GTK_EXPANDER (widget)->priv;
721 if (priv->event_window)
722 gdk_window_hide (priv->event_window);
724 GTK_WIDGET_CLASS (parent_class)->unmap (widget);
726 if (priv->label_widget)
727 gtk_widget_unmap (priv->label_widget);
731 gtk_expander_paint_prelight (GtkExpander *expander)
734 GtkContainer *container;
735 GtkExpanderPrivate *priv;
737 gboolean interior_focus;
741 int expander_spacing;
743 priv = expander->priv;
744 widget = GTK_WIDGET (expander);
745 container = GTK_CONTAINER (expander);
747 gtk_widget_style_get (widget,
748 "interior-focus", &interior_focus,
749 "focus-line-width", &focus_width,
750 "focus-padding", &focus_pad,
751 "expander-size", &expander_size,
752 "expander-spacing", &expander_spacing,
755 area.x = widget->allocation.x + container->border_width;
756 area.y = widget->allocation.y + container->border_width;
757 area.width = widget->allocation.width - (2 * container->border_width);
759 if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
760 area.height = priv->label_widget->allocation.height;
764 area.height += interior_focus ? (focus_width + focus_pad) * 2 : 0;
765 area.height = MAX (area.height, expander_size + 2 * expander_spacing);
766 area.height += !interior_focus ? (focus_width + focus_pad) * 2 : 0;
768 gtk_paint_flat_box (widget->style, widget->window,
770 GTK_SHADOW_ETCHED_OUT,
771 &area, widget, "expander",
773 area.width, area.height);
777 gtk_expander_paint (GtkExpander *expander)
783 widget = GTK_WIDGET (expander);
785 get_expander_bounds (expander, &clip);
787 state = widget->state;
788 if (expander->priv->prelight)
790 state = GTK_STATE_PRELIGHT;
792 gtk_expander_paint_prelight (expander);
795 gtk_paint_expander (widget->style,
801 clip.x + clip.width / 2,
802 clip.y + clip.height / 2,
803 expander->priv->expander_style);
807 gtk_expander_paint_focus (GtkExpander *expander,
811 GtkExpanderPrivate *priv;
812 gint x, y, width, height;
813 gboolean interior_focus;
818 gint expander_spacing;
821 widget = GTK_WIDGET (expander);
822 priv = expander->priv;
824 border_width = GTK_CONTAINER (widget)->border_width;
826 gtk_widget_style_get (widget,
827 "interior-focus", &interior_focus,
828 "focus-line-width", &focus_width,
829 "focus-padding", &focus_pad,
830 "expander-size", &expander_size,
831 "expander-spacing", &expander_spacing,
834 ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
838 if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
840 GtkAllocation label_allocation = priv->label_widget->allocation;
842 width = label_allocation.width;
843 height = label_allocation.height;
846 width += 2 * focus_pad + 2 * focus_width;
847 height += 2 * focus_pad + 2 * focus_width;
849 x = widget->allocation.x + border_width;
850 y = widget->allocation.y + border_width;
855 x += expander_spacing * 2 + expander_size;
859 x += widget->allocation.width - 2 * border_width
860 - expander_spacing * 2 - expander_size - width;
865 width += expander_size + 2 * expander_spacing;
866 height = MAX (height, expander_size + 2 * expander_spacing);
869 gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
870 area, widget, "expander",
871 x, y, width, height);
875 gtk_expander_expose (GtkWidget *widget,
876 GdkEventExpose *event)
878 if (GTK_WIDGET_DRAWABLE (widget))
880 GtkExpander *expander = GTK_EXPANDER (widget);
882 gtk_expander_paint (expander);
884 if (GTK_WIDGET_HAS_FOCUS (expander))
885 gtk_expander_paint_focus (expander, &event->area);
887 GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
894 gtk_expander_button_press (GtkWidget *widget,
895 GdkEventButton *event)
897 GtkExpander *expander = GTK_EXPANDER (widget);
899 if (event->button == 1 && event->window == expander->priv->event_window)
901 expander->priv->button_down = TRUE;
909 gtk_expander_button_release (GtkWidget *widget,
910 GdkEventButton *event)
912 GtkExpander *expander = GTK_EXPANDER (widget);
914 if (event->button == 1 && expander->priv->button_down)
916 gtk_widget_activate (widget);
917 expander->priv->button_down = FALSE;
925 gtk_expander_grab_notify (GtkWidget *widget,
926 gboolean was_grabbed)
929 GTK_EXPANDER (widget)->priv->button_down = FALSE;
933 gtk_expander_state_changed (GtkWidget *widget,
934 GtkStateType previous_state)
936 if (!GTK_WIDGET_IS_SENSITIVE (widget))
937 GTK_EXPANDER (widget)->priv->button_down = FALSE;
941 gtk_expander_redraw_expander (GtkExpander *expander)
945 widget = GTK_WIDGET (expander);
947 if (GTK_WIDGET_REALIZED (widget))
948 gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
952 gtk_expander_enter_notify (GtkWidget *widget,
953 GdkEventCrossing *event)
955 GtkExpander *expander = GTK_EXPANDER (widget);
956 GtkWidget *event_widget;
958 event_widget = gtk_get_event_widget ((GdkEvent *) event);
960 if (event_widget == widget &&
961 event->detail != GDK_NOTIFY_INFERIOR)
963 expander->priv->prelight = TRUE;
965 if (expander->priv->label_widget)
966 gtk_widget_set_state (expander->priv->label_widget, GTK_STATE_PRELIGHT);
968 gtk_expander_redraw_expander (expander);
975 gtk_expander_leave_notify (GtkWidget *widget,
976 GdkEventCrossing *event)
978 GtkExpander *expander = GTK_EXPANDER (widget);
979 GtkWidget *event_widget;
981 event_widget = gtk_get_event_widget ((GdkEvent *) event);
983 if (event_widget == widget &&
984 event->detail != GDK_NOTIFY_INFERIOR)
986 expander->priv->prelight = FALSE;
988 if (expander->priv->label_widget)
989 gtk_widget_set_state (expander->priv->label_widget, GTK_STATE_NORMAL);
991 gtk_expander_redraw_expander (expander);
998 expand_timeout (gpointer data)
1000 GtkExpander *expander = GTK_EXPANDER (data);
1001 GtkExpanderPrivate *priv = expander->priv;
1003 priv->expand_timer = 0;
1004 gtk_expander_set_expanded (expander, TRUE);
1010 gtk_expander_drag_motion (GtkWidget *widget,
1011 GdkDragContext *context,
1016 GtkExpander *expander = GTK_EXPANDER (widget);
1017 GtkExpanderPrivate *priv = expander->priv;
1019 if (!priv->expanded && !priv->expand_timer)
1021 GtkSettings *settings;
1024 settings = gtk_widget_get_settings (widget);
1025 g_object_get (settings, "gtk-timeout-expand", &timeout, NULL);
1027 priv->expand_timer = g_timeout_add (timeout, (GSourceFunc) expand_timeout, expander);
1034 gtk_expander_drag_leave (GtkWidget *widget,
1035 GdkDragContext *context,
1038 GtkExpander *expander = GTK_EXPANDER (widget);
1039 GtkExpanderPrivate *priv = expander->priv;
1041 if (priv->expand_timer)
1043 g_source_remove (priv->expand_timer);
1044 priv->expand_timer = 0;
1057 focus_current_site (GtkExpander *expander,
1058 GtkDirectionType direction)
1060 GtkWidget *current_focus;
1062 current_focus = GTK_CONTAINER (expander)->focus_child;
1067 return gtk_widget_child_focus (current_focus, direction);
1071 focus_in_site (GtkExpander *expander,
1073 GtkDirectionType direction)
1078 gtk_widget_grab_focus (GTK_WIDGET (expander));
1081 if (expander->priv->label_widget)
1082 return gtk_widget_child_focus (expander->priv->label_widget, direction);
1087 GtkWidget *child = gtk_bin_get_child (GTK_BIN (expander));
1089 if (child && GTK_WIDGET_CHILD_VISIBLE (child))
1090 return gtk_widget_child_focus (child, direction);
1098 g_assert_not_reached ();
1103 get_next_site (GtkExpander *expander,
1105 GtkDirectionType direction)
1109 ltr = gtk_widget_get_direction (GTK_WIDGET (expander)) != GTK_TEXT_DIR_RTL;
1116 case GTK_DIR_TAB_BACKWARD:
1120 case GTK_DIR_TAB_FORWARD:
1123 return FOCUS_WIDGET;
1128 case GTK_DIR_TAB_BACKWARD:
1132 return ltr ? FOCUS_NONE : FOCUS_LABEL;
1133 case GTK_DIR_TAB_FORWARD:
1137 return ltr ? FOCUS_LABEL : FOCUS_NONE;
1143 case GTK_DIR_TAB_BACKWARD:
1145 return FOCUS_WIDGET;
1147 return ltr ? FOCUS_WIDGET : FOCUS_CHILD;
1148 case GTK_DIR_TAB_FORWARD:
1152 return ltr ? FOCUS_CHILD : FOCUS_WIDGET;
1158 case GTK_DIR_TAB_BACKWARD:
1162 case GTK_DIR_TAB_FORWARD:
1169 g_assert_not_reached ();
1174 gtk_expander_focus (GtkWidget *widget,
1175 GtkDirectionType direction)
1177 GtkExpander *expander = GTK_EXPANDER (widget);
1179 if (!focus_current_site (expander, direction))
1181 GtkWidget *old_focus_child;
1182 gboolean widget_is_focus;
1183 FocusSite site = FOCUS_NONE;
1185 widget_is_focus = gtk_widget_is_focus (widget);
1186 old_focus_child = GTK_CONTAINER (widget)->focus_child;
1188 if (old_focus_child && old_focus_child == expander->priv->label_widget)
1190 else if (old_focus_child)
1192 else if (widget_is_focus)
1193 site = FOCUS_WIDGET;
1195 while ((site = get_next_site (expander, site, direction)) != FOCUS_NONE)
1197 if (focus_in_site (expander, site, direction))
1208 gtk_expander_add (GtkContainer *container,
1211 GTK_CONTAINER_CLASS (parent_class)->add (container, widget);
1213 gtk_widget_set_child_visible (widget, GTK_EXPANDER (container)->priv->expanded);
1214 gtk_widget_queue_resize (GTK_WIDGET (container));
1218 gtk_expander_remove (GtkContainer *container,
1221 GtkExpander *expander = GTK_EXPANDER (container);
1223 if (GTK_EXPANDER (expander)->priv->label_widget == widget)
1224 gtk_expander_set_label_widget (expander, NULL);
1226 GTK_CONTAINER_CLASS (parent_class)->remove (container, widget);
1230 gtk_expander_forall (GtkContainer *container,
1231 gboolean include_internals,
1232 GtkCallback callback,
1233 gpointer callback_data)
1235 GtkBin *bin = GTK_BIN (container);
1236 GtkExpanderPrivate *priv = GTK_EXPANDER (container)->priv;
1239 (* callback) (bin->child, callback_data);
1241 if (priv->label_widget)
1242 (* callback) (priv->label_widget, callback_data);
1246 gtk_expander_activate (GtkExpander *expander)
1248 gtk_expander_set_expanded (expander, !expander->priv->expanded);
1253 * @label: the text of the label
1255 * Creates a new expander using @label as the text of the label.
1257 * Return value: a new #GtkExpander widget.
1262 gtk_expander_new (const gchar *label)
1264 return g_object_new (GTK_TYPE_EXPANDER, "label", label, NULL);
1268 * gtk_expander_new_with_mnemonic:
1269 * @label: the text of the label with an underscore in front of the
1270 * mnemonic character
1272 * Creates a new expander using @label as the text of the label.
1273 * If characters in @label are preceded by an underscore, they are underlined.
1274 * If you need a literal underscore character in a label, use '__' (two
1275 * underscores). The first underlined character represents a keyboard
1276 * accelerator called a mnemonic.
1277 * Pressing Alt and that key activates the button.
1279 * Return value: a new #GtkExpander widget.
1284 gtk_expander_new_with_mnemonic (const gchar *label)
1286 return g_object_new (GTK_TYPE_EXPANDER,
1288 "use-underline", TRUE,
1293 gtk_expander_animation_timeout (GtkExpander *expander)
1295 GtkExpanderPrivate *priv = expander->priv;
1297 gboolean finish = FALSE;
1299 GDK_THREADS_ENTER();
1301 if (GTK_WIDGET_REALIZED (expander))
1303 get_expander_bounds (expander, &area);
1304 gdk_window_invalidate_rect (GTK_WIDGET (expander)->window, &area, TRUE);
1309 if (priv->expander_style == GTK_EXPANDER_COLLAPSED)
1311 priv->expander_style = GTK_EXPANDER_SEMI_EXPANDED;
1315 priv->expander_style = GTK_EXPANDER_EXPANDED;
1321 if (priv->expander_style == GTK_EXPANDER_EXPANDED)
1323 priv->expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
1327 priv->expander_style = GTK_EXPANDER_COLLAPSED;
1334 priv->animation_timeout = 0;
1335 if (GTK_BIN (expander)->child)
1336 gtk_widget_set_child_visible (GTK_BIN (expander)->child, priv->expanded);
1337 gtk_widget_queue_resize (GTK_WIDGET (expander));
1340 GDK_THREADS_LEAVE();
1346 gtk_expander_start_animation (GtkExpander *expander)
1348 GtkExpanderPrivate *priv = expander->priv;
1350 if (priv->animation_timeout)
1351 g_source_remove (priv->animation_timeout);
1353 priv->animation_timeout =
1355 (GSourceFunc) gtk_expander_animation_timeout,
1360 * gtk_expander_set_expanded:
1361 * @expander: a #GtkExpander
1362 * @expanded: whether the child widget is revealed
1364 * Sets the state of the expander. Set to %TRUE, if you want
1365 * the child widget to be revealed, and %FALSE if you want the
1366 * child widget to be hidden.
1371 gtk_expander_set_expanded (GtkExpander *expander,
1374 GtkExpanderPrivate *priv;
1376 g_return_if_fail (GTK_IS_EXPANDER (expander));
1378 priv = expander->priv;
1380 expanded = expanded != FALSE;
1382 if (priv->expanded != expanded)
1384 GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (expander));
1385 gboolean enable_animations;
1387 priv->expanded = expanded;
1389 g_object_get (settings, "gtk-enable-animations", &enable_animations, NULL);
1391 if (enable_animations && GTK_WIDGET_REALIZED (expander))
1393 gtk_expander_start_animation (expander);
1397 priv->expander_style = expanded ? GTK_EXPANDER_EXPANDED :
1398 GTK_EXPANDER_COLLAPSED;
1400 if (GTK_BIN (expander)->child)
1402 gtk_widget_set_child_visible (GTK_BIN (expander)->child, priv->expanded);
1403 gtk_widget_queue_resize (GTK_WIDGET (expander));
1407 g_object_notify (G_OBJECT (expander), "expanded");
1412 * gtk_expander_get_expanded:
1413 * @expander:a #GtkExpander
1415 * Queries a #GtkExpander and returns its current state. Returns %TRUE
1416 * if the child widget is revealed.
1418 * See gtk_expander_set_expanded().
1420 * Return value: the current state of the expander.
1425 gtk_expander_get_expanded (GtkExpander *expander)
1427 g_return_val_if_fail (GTK_IS_EXPANDER (expander), FALSE);
1429 return expander->priv->expanded;
1433 * gtk_expander_set_spacing:
1434 * @expander: a #GtkExpander
1435 * @spacing: distance between the expander and child in pixels.
1437 * Sets the spacing field of @expander, which is the number of pixels to
1438 * place between expander and the child.
1443 gtk_expander_set_spacing (GtkExpander *expander,
1446 g_return_if_fail (GTK_IS_EXPANDER (expander));
1447 g_return_if_fail (spacing >= 0);
1449 if (expander->priv->spacing != spacing)
1451 expander->priv->spacing = spacing;
1453 gtk_widget_queue_resize (GTK_WIDGET (expander));
1455 g_object_notify (G_OBJECT (expander), "spacing");
1460 * gtk_expander_get_spacing:
1461 * @expander: a #GtkExpander
1463 * Gets the value set by gtk_expander_set_spacing().
1465 * Return value: spacing between the expander and child.
1470 gtk_expander_get_spacing (GtkExpander *expander)
1472 g_return_val_if_fail (GTK_IS_EXPANDER (expander), 0);
1474 return expander->priv->spacing;
1478 * gtk_expander_set_label:
1479 * @expander: a #GtkExpander
1482 * Sets the text of the label of the expander to @label.
1484 * This will also clear any previously set labels.
1489 gtk_expander_set_label (GtkExpander *expander,
1492 g_return_if_fail (GTK_IS_EXPANDER (expander));
1496 gtk_expander_set_label_widget (expander, NULL);
1502 child = gtk_label_new (label);
1503 gtk_label_set_use_underline (GTK_LABEL (child), expander->priv->use_underline);
1504 gtk_label_set_use_markup (GTK_LABEL (child), expander->priv->use_markup);
1505 gtk_widget_show (child);
1507 gtk_expander_set_label_widget (expander, child);
1510 g_object_notify (G_OBJECT (expander), "label");
1514 * gtk_expander_get_label:
1515 * @expander: a #GtkExpander
1517 * Fetches the text from the label of the expander, as set by
1518 * gtk_expander_set_label(). If the label text has not
1519 * been set the return value will be %NULL. This will be the
1520 * case if you create an empty button with gtk_button_new() to
1521 * use as a container.
1523 * Return value: The text of the label widget. This string is owned
1524 * by the widget and must not be modified or freed.
1528 G_CONST_RETURN char *
1529 gtk_expander_get_label (GtkExpander *expander)
1531 GtkExpanderPrivate *priv;
1533 g_return_val_if_fail (GTK_IS_EXPANDER (expander), NULL);
1535 priv = expander->priv;
1537 if (priv->label_widget && GTK_IS_LABEL (priv->label_widget))
1538 return gtk_label_get_text (GTK_LABEL (priv->label_widget));
1544 * gtk_expander_set_use_underline:
1545 * @expander: a #GtkExpander
1546 * @use_underline: %TRUE if underlines in the text indicate mnemonics
1548 * If true, an underline in the text of the expander label indicates
1549 * the next character should be used for the mnemonic accelerator key.
1554 gtk_expander_set_use_underline (GtkExpander *expander,
1555 gboolean use_underline)
1557 GtkExpanderPrivate *priv;
1559 g_return_if_fail (GTK_IS_EXPANDER (expander));
1561 priv = expander->priv;
1563 use_underline = use_underline != FALSE;
1565 if (priv->use_underline != use_underline)
1567 priv->use_underline = use_underline;
1569 if (priv->label_widget && GTK_IS_LABEL (priv->label_widget))
1570 gtk_label_set_use_underline (GTK_LABEL (priv->label_widget), use_underline);
1572 g_object_notify (G_OBJECT (expander), "use-underline");
1577 * gtk_expander_get_use_underline:
1578 * @expander: a #GtkExpander
1580 * Returns whether an embedded underline in the expander label indicates a
1581 * mnemonic. See gtk_expander_set_use_underline().
1583 * Return value: %TRUE if an embedded underline in the expander label
1584 * indicates the mnemonic accelerator keys.
1589 gtk_expander_get_use_underline (GtkExpander *expander)
1591 g_return_val_if_fail (GTK_IS_EXPANDER (expander), FALSE);
1593 return expander->priv->use_underline;
1597 * gtk_expander_set_use_markup:
1598 * @expander: a #GtkExpander
1599 * @use_markup: %TRUE if the label's text should be parsed for markup
1601 * Sets whether the text of the label contains markup in <link
1602 * linkend="PangoMarkupFormat">Pango's text markup
1603 * language</link>. See gtk_label_set_markup().
1608 gtk_expander_set_use_markup (GtkExpander *expander,
1609 gboolean use_markup)
1611 GtkExpanderPrivate *priv;
1613 g_return_if_fail (GTK_IS_EXPANDER (expander));
1615 priv = expander->priv;
1617 use_markup = use_markup != FALSE;
1619 if (priv->use_markup != use_markup)
1621 priv->use_markup = use_markup;
1623 if (priv->label_widget && GTK_IS_LABEL (priv->label_widget))
1624 gtk_label_set_use_markup (GTK_LABEL (priv->label_widget), use_markup);
1626 g_object_notify (G_OBJECT (expander), "use-markup");
1631 * gtk_expander_get_use_markup:
1632 * @expander: a #GtkExpander
1634 * Returns whether the label's text is interpreted as marked up with
1635 * the <link linkend="PangoMarkupFormat">Pango text markup
1636 * language</link>. See gtk_expander_set_use_markup ().
1638 * Return value: %TRUE if the label's text will be parsed for markup
1643 gtk_expander_get_use_markup (GtkExpander *expander)
1645 g_return_val_if_fail (GTK_IS_EXPANDER (expander), FALSE);
1647 return expander->priv->use_markup;
1651 * gtk_expander_set_label_widget:
1652 * @expander: a #GtkExpander
1653 * @label_widget: the new label widget
1655 * Set the label widget for the expander. This is the widget
1656 * that will appear embedded alongside the expander arrow.
1661 gtk_expander_set_label_widget (GtkExpander *expander,
1662 GtkWidget *label_widget)
1664 GtkExpanderPrivate *priv;
1666 g_return_if_fail (GTK_IS_EXPANDER (expander));
1667 g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget));
1668 g_return_if_fail (label_widget == NULL || label_widget->parent == NULL);
1670 priv = expander->priv;
1672 if (priv->label_widget == label_widget)
1675 if (priv->label_widget)
1677 gtk_widget_set_state (priv->label_widget, GTK_STATE_NORMAL);
1678 gtk_widget_unparent (priv->label_widget);
1681 priv->label_widget = label_widget;
1685 priv->label_widget = label_widget;
1687 gtk_widget_set_parent (label_widget, GTK_WIDGET (expander));
1690 gtk_widget_set_state (label_widget, GTK_STATE_PRELIGHT);
1693 if (GTK_WIDGET_VISIBLE (expander))
1694 gtk_widget_queue_resize (GTK_WIDGET (expander));
1696 g_object_freeze_notify (G_OBJECT (expander));
1697 g_object_notify (G_OBJECT (expander), "label-widget");
1698 g_object_notify (G_OBJECT (expander), "label");
1699 g_object_thaw_notify (G_OBJECT (expander));
1703 * gtk_expander_get_label_widget:
1704 * @expander: a #GtkExpander
1706 * Retrieves the label widget for the frame. See
1707 * gtk_expander_set_label_widget().
1709 * Return value: the label widget, or %NULL if there is none.
1714 gtk_expander_get_label_widget (GtkExpander *expander)
1716 g_return_val_if_fail (GTK_IS_EXPANDER (expander), NULL);
1718 return expander->priv->label_widget;
1721 #define __GTK_EXPANDER_C__
1722 #include "gtkaliasdef.c"