Mercurial > pidgin3 / file comparison

comparison: src/gtkexpander.c

src/gtkexpander.c

changeset 11735
a1d2afa9b4e9
child 11752
8319fac0c0e5
equal deleted inserted replaced
11734:6faaedf20f96 11735:a1d2afa9b4e9
1 /* GTK - The GIMP Toolkit
2 *
3 * Copyright (C) 2003 Sun Microsystems, Inc.
4 *
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.
9 *
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.
14 *
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.
19 *
20 * Authors:
21 * Mark McLoughlin <mark@skynet.ie>
22 */
23
24 /*
25 #include <config.h>
26 */
27
28 #include <gtk/gtkversion.h>
29 #if !GTK_CHECK_VERSION(2,4,0)
30 #include "gtkexpander.h"
31
32 #include <gtk/gtklabel.h>
33 #include <gtk/gtkcontainer.h>
34 #include <gtk/gtkmarshalers.h>
35 #include <gtk/gtkmain.h>
36 #include <gtk/gtkintl.h>
37 #include <gtk/gtkprivate.h>
38 #include <gdk/gdkkeysyms.h>
39 #include <gtk/gtkalias.h>
40
41 #define GTK_EXPANDER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_EXPANDER, GtkExpanderPrivate))
42
43 #define DEFAULT_EXPANDER_SIZE 10
44 #define DEFAULT_EXPANDER_SPACING 2
45
46 enum
47 {
48 PROP_0,
49 PROP_EXPANDED,
50 PROP_LABEL,
51 PROP_USE_UNDERLINE,
52 PROP_USE_MARKUP,
53 PROP_SPACING,
54 PROP_LABEL_WIDGET
55 };
56
57 struct _GtkExpanderPrivate
58 {
59 GtkWidget *label_widget;
60 GdkWindow *event_window;
61 gint spacing;
62
63 GtkExpanderStyle expander_style;
64 guint animation_timeout;
65
66 guint expanded : 1;
67 guint use_underline : 1;
68 guint use_markup : 1;
69 guint button_down : 1;
70 guint prelight : 1;
71 };
72
73 static void gtk_expander_class_init (GtkExpanderClass *klass);
74 static void gtk_expander_init (GtkExpander *expander);
75
76 static void gtk_expander_set_property (GObject *object,
77 guint prop_id,
78 const GValue *value,
79 GParamSpec *pspec);
80 static void gtk_expander_get_property (GObject *object,
81 guint prop_id,
82 GValue *value,
83 GParamSpec *pspec);
84
85 static void gtk_expander_destroy (GtkObject *object);
86
87 static void gtk_expander_realize (GtkWidget *widget);
88 static void gtk_expander_unrealize (GtkWidget *widget);
89 static void gtk_expander_size_request (GtkWidget *widget,
90 GtkRequisition *requisition);
91 static void gtk_expander_size_allocate (GtkWidget *widget,
92 GtkAllocation *allocation);
93 static void gtk_expander_map (GtkWidget *widget);
94 static void gtk_expander_unmap (GtkWidget *widget);
95 static gboolean gtk_expander_expose (GtkWidget *widget,
96 GdkEventExpose *event);
97 static gboolean gtk_expander_button_press (GtkWidget *widget,
98 GdkEventButton *event);
99 static gboolean gtk_expander_button_release (GtkWidget *widget,
100 GdkEventButton *event);
101 static gboolean gtk_expander_enter_notify (GtkWidget *widget,
102 GdkEventCrossing *event);
103 static gboolean gtk_expander_leave_notify (GtkWidget *widget,
104 GdkEventCrossing *event);
105 static gboolean gtk_expander_focus (GtkWidget *widget,
106 GtkDirectionType direction);
107 static void gtk_expander_grab_notify (GtkWidget *widget,
108 gboolean was_grabbed);
109 static void gtk_expander_state_changed (GtkWidget *widget,
110 GtkStateType previous_state);
111
112 static void gtk_expander_add (GtkContainer *container,
113 GtkWidget *widget);
114 static void gtk_expander_remove (GtkContainer *container,
115 GtkWidget *widget);
116 static void gtk_expander_forall (GtkContainer *container,
117 gboolean include_internals,
118 GtkCallback callback,
119 gpointer callback_data);
120
121 static void gtk_expander_activate (GtkExpander *expander);
122
123 static void get_expander_bounds (GtkExpander *expander,
124 GdkRectangle *rect);
125
126 static GtkBinClass *parent_class = NULL;
127
128 GType
129 gtk_expander_get_type (void)
130 {
131 static GType expander_type = 0;
132
133 if (!expander_type)
134 {
135 static const GTypeInfo expander_info =
136 {
137 sizeof (GtkExpanderClass),
138 NULL, /* base_init */
139 NULL, /* base_finalize */
140 (GClassInitFunc) gtk_expander_class_init,
141 NULL, /* class_finalize */
142 NULL, /* class_data */
143 sizeof (GtkExpander),
144 0, /* n_preallocs */
145 (GInstanceInitFunc) gtk_expander_init,
146 };
147
148 expander_type = g_type_register_static (GTK_TYPE_BIN,
149 "GtkExpander",
150 &expander_info, 0);
151 }
152
153 return expander_type;
154 }
155
156 static void
157 gtk_expander_class_init (GtkExpanderClass *klass)
158 {
159 GObjectClass *gobject_class;
160 GtkObjectClass *object_class;
161 GtkWidgetClass *widget_class;
162 GtkContainerClass *container_class;
163
164 parent_class = g_type_class_peek_parent (klass);
165
166 gobject_class = (GObjectClass *) klass;
167 object_class = (GtkObjectClass *) klass;
168 widget_class = (GtkWidgetClass *) klass;
169 container_class = (GtkContainerClass *) klass;
170
171 gobject_class->set_property = gtk_expander_set_property;
172 gobject_class->get_property = gtk_expander_get_property;
173
174 object_class->destroy = gtk_expander_destroy;
175
176 widget_class->realize = gtk_expander_realize;
177 widget_class->unrealize = gtk_expander_unrealize;
178 widget_class->size_request = gtk_expander_size_request;
179 widget_class->size_allocate = gtk_expander_size_allocate;
180 widget_class->map = gtk_expander_map;
181 widget_class->unmap = gtk_expander_unmap;
182 widget_class->expose_event = gtk_expander_expose;
183 widget_class->button_press_event = gtk_expander_button_press;
184 widget_class->button_release_event = gtk_expander_button_release;
185 widget_class->enter_notify_event = gtk_expander_enter_notify;
186 widget_class->leave_notify_event = gtk_expander_leave_notify;
187 widget_class->focus = gtk_expander_focus;
188 widget_class->grab_notify = gtk_expander_grab_notify;
189 widget_class->state_changed = gtk_expander_state_changed;
190
191 container_class->add = gtk_expander_add;
192 container_class->remove = gtk_expander_remove;
193 container_class->forall = gtk_expander_forall;
194
195 klass->activate = gtk_expander_activate;
196
197 g_type_class_add_private (klass, sizeof (GtkExpanderPrivate));
198
199 g_object_class_install_property (gobject_class,
200 PROP_EXPANDED,
201 g_param_spec_boolean ("expanded",
202 P_("Expanded"),
203 P_("Whether the expander has been opened to reveal the child widget"),
204 FALSE,
205 G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
206
207 g_object_class_install_property (gobject_class,
208 PROP_LABEL,
209 g_param_spec_string ("label",
210 P_("Label"),
211 P_("Text of the expander's label"),
212 NULL,
213 G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
214
215 g_object_class_install_property (gobject_class,
216 PROP_USE_UNDERLINE,
217 g_param_spec_boolean ("use_underline",
218 P_("Use underline"),
219 P_("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),
220 FALSE,
221 G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
222
223 g_object_class_install_property (gobject_class,
224 PROP_USE_MARKUP,
225 g_param_spec_boolean ("use_markup",
226 P_("Use markup"),
227 P_("The text of the label includes XML markup. See pango_parse_markup()"),
228 FALSE,
229 G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
230
231 g_object_class_install_property (gobject_class,
232 PROP_SPACING,
233 g_param_spec_int ("spacing",
234 P_("Spacing"),
235 P_("Space to put between the label and the child"),
236 0,
237 G_MAXINT,
238 0,
239 G_PARAM_READWRITE));
240
241 g_object_class_install_property (gobject_class,
242 PROP_LABEL_WIDGET,
243 g_param_spec_object ("label_widget",
244 P_("Label widget"),
245 P_("A widget to display in place of the usual expander label"),
246 GTK_TYPE_WIDGET,
247 G_PARAM_READWRITE));
248
249 gtk_widget_class_install_style_property (widget_class,
250 g_param_spec_int ("expander-size",
251 P_("Expander Size"),
252 P_("Size of the expander arrow"),
253 0,
254 G_MAXINT,
255 DEFAULT_EXPANDER_SIZE,
256 G_PARAM_READABLE));
257
258 gtk_widget_class_install_style_property (widget_class,
259 g_param_spec_int ("expander-spacing",
260 P_("Indicator Spacing"),
261 P_("Spacing around expander arrow"),
262 0,
263 G_MAXINT,
264 DEFAULT_EXPANDER_SPACING,
265 G_PARAM_READABLE));
266
267 widget_class->activate_signal =
268 g_signal_new ("activate",
269 G_TYPE_FROM_CLASS (gobject_class),
270 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
271 G_STRUCT_OFFSET (GtkExpanderClass, activate),
272 NULL, NULL,
273 _gtk_marshal_VOID__VOID,
274 G_TYPE_NONE, 0);
275 }
276
277 static void
278 gtk_expander_init (GtkExpander *expander)
279 {
280 GtkExpanderPrivate *priv;
281
282 expander->priv = priv = GTK_EXPANDER_GET_PRIVATE (expander);
283
284 GTK_WIDGET_SET_FLAGS (expander, GTK_CAN_FOCUS);
285 GTK_WIDGET_SET_FLAGS (expander, GTK_NO_WINDOW);
286
287 priv->label_widget = NULL;
288 priv->event_window = NULL;
289 priv->spacing = 0;
290
291 priv->expander_style = GTK_EXPANDER_COLLAPSED;
292 priv->animation_timeout = 0;
293
294 priv->expanded = FALSE;
295 priv->use_underline = FALSE;
296 priv->use_markup = FALSE;
297 priv->button_down = FALSE;
298 priv->prelight = FALSE;
299 }
300
301 static void
302 gtk_expander_set_property (GObject *object,
303 guint prop_id,
304 const GValue *value,
305 GParamSpec *pspec)
306 {
307 GtkExpander *expander = GTK_EXPANDER (object);
308
309 switch (prop_id)
310 {
311 case PROP_EXPANDED:
312 gtk_expander_set_expanded (expander, g_value_get_boolean (value));
313 break;
314 case PROP_LABEL:
315 gtk_expander_set_label (expander, g_value_get_string (value));
316 break;
317 case PROP_USE_UNDERLINE:
318 gtk_expander_set_use_underline (expander, g_value_get_boolean (value));
319 break;
320 case PROP_USE_MARKUP:
321 gtk_expander_set_use_markup (expander, g_value_get_boolean (value));
322 break;
323 case PROP_SPACING:
324 gtk_expander_set_spacing (expander, g_value_get_int (value));
325 break;
326 case PROP_LABEL_WIDGET:
327 gtk_expander_set_label_widget (expander, g_value_get_object (value));
328 break;
329 default:
330 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
331 break;
332 }
333 }
334
335 static void
336 gtk_expander_get_property (GObject *object,
337 guint prop_id,
338 GValue *value,
339 GParamSpec *pspec)
340 {
341 GtkExpander *expander = GTK_EXPANDER (object);
342 GtkExpanderPrivate *priv = expander->priv;
343
344 switch (prop_id)
345 {
346 case PROP_EXPANDED:
347 g_value_set_boolean (value, priv->expanded);
348 break;
349 case PROP_LABEL:
350 g_value_set_string (value, gtk_expander_get_label (expander));
351 break;
352 case PROP_USE_UNDERLINE:
353 g_value_set_boolean (value, priv->use_underline);
354 break;
355 case PROP_USE_MARKUP:
356 g_value_set_boolean (value, priv->use_markup);
357 break;
358 case PROP_SPACING:
359 g_value_set_int (value, priv->spacing);
360 break;
361 case PROP_LABEL_WIDGET:
362 g_value_set_object (value,
363 priv->label_widget ?
364 G_OBJECT (priv->label_widget) : NULL);
365 break;
366 default:
367 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
368 break;
369 }
370 }
371
372 static void
373 gtk_expander_destroy (GtkObject *object)
374 {
375 GtkExpanderPrivate *priv = GTK_EXPANDER (object)->priv;
376
377 if (priv->animation_timeout)
378 {
379 g_source_remove (priv->animation_timeout);
380 priv->animation_timeout = 0;
381 }
382
383 GTK_OBJECT_CLASS (parent_class)->destroy (object);
384 }
385
386 static void
387 gtk_expander_realize (GtkWidget *widget)
388 {
389 GtkExpanderPrivate *priv;
390 GdkWindowAttr attributes;
391 gint attributes_mask;
392 gint border_width;
393 GdkRectangle expander_rect;
394
395 priv = GTK_EXPANDER (widget)->priv;
396 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
397
398 border_width = GTK_CONTAINER (widget)->border_width;
399
400 get_expander_bounds (GTK_EXPANDER (widget), &expander_rect);
401
402 attributes.window_type = GDK_WINDOW_CHILD;
403 attributes.x = widget->allocation.x + border_width;
404 attributes.y = expander_rect.y;
405 attributes.width = MAX (widget->allocation.width - 2 * border_width, 1);
406 attributes.height = expander_rect.width;
407 attributes.wclass = GDK_INPUT_ONLY;
408 attributes.event_mask = gtk_widget_get_events (widget) |
409 GDK_BUTTON_PRESS_MASK |
410 GDK_BUTTON_RELEASE_MASK |
411 GDK_ENTER_NOTIFY_MASK |
412 GDK_LEAVE_NOTIFY_MASK;
413
414 attributes_mask = GDK_WA_X | GDK_WA_Y;
415
416 widget->window = gtk_widget_get_parent_window (widget);
417 g_object_ref (widget->window);
418
419 priv->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
420 &attributes, attributes_mask);
421 gdk_window_set_user_data (priv->event_window, widget);
422
423 widget->style = gtk_style_attach (widget->style, widget->window);
424 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
425 }
426
427 static void
428 gtk_expander_unrealize (GtkWidget *widget)
429 {
430 GtkExpanderPrivate *priv = GTK_EXPANDER (widget)->priv;
431
432 if (priv->event_window)
433 {
434 gdk_window_set_user_data (priv->event_window, NULL);
435 gdk_window_destroy (priv->event_window);
436 priv->event_window = NULL;
437 }
438
439 GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
440 }
441
442 static void
443 gtk_expander_size_request (GtkWidget *widget,
444 GtkRequisition *requisition)
445 {
446 GtkExpander *expander;
447 GtkBin *bin;
448 GtkExpanderPrivate *priv;
449 gint border_width;
450 gint expander_size;
451 gint expander_spacing;
452 gboolean interior_focus;
453 gint focus_width;
454 gint focus_pad;
455
456 bin = GTK_BIN (widget);
457 expander = GTK_EXPANDER (widget);
458 priv = expander->priv;
459
460 border_width = GTK_CONTAINER (widget)->border_width;
461
462 gtk_widget_style_get (widget,
463 "interior-focus", &interior_focus,
464 "focus-line-width", &focus_width,
465 "focus-padding", &focus_pad,
466 "expander-size", &expander_size,
467 "expander-spacing", &expander_spacing,
468 NULL);
469
470 requisition->width = expander_size + 2 * expander_spacing +
471 2 * focus_width + 2 * focus_pad;
472 requisition->height = interior_focus ? (2 * focus_width + 2 * focus_pad) : 0;
473
474 if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
475 {
476 GtkRequisition label_requisition;
477
478 gtk_widget_size_request (priv->label_widget, &label_requisition);
479
480 requisition->width += label_requisition.width;
481 requisition->height += label_requisition.height;
482 }
483
484 requisition->height = MAX (expander_size + 2 * expander_spacing, requisition->height);
485
486 if (!interior_focus)
487 requisition->height += 2 * focus_width + 2 * focus_pad;
488
489 if (bin->child && GTK_WIDGET_CHILD_VISIBLE (bin->child))
490 {
491 GtkRequisition child_requisition;
492
493 gtk_widget_size_request (bin->child, &child_requisition);
494
495 requisition->width = MAX (requisition->width, child_requisition.width);
496 requisition->height += child_requisition.height + priv->spacing;
497 }
498
499 requisition->width += 2 * border_width;
500 requisition->height += 2 * border_width;
501 }
502
503 static void
504 get_expander_bounds (GtkExpander *expander,
505 GdkRectangle *rect)
506 {
507 GtkWidget *widget;
508 GtkBin *bin;
509 GtkExpanderPrivate *priv;
510 gint border_width;
511 gint expander_size;
512 gint expander_spacing;
513 gboolean interior_focus;
514 gint focus_width;
515 gint focus_pad;
516 gboolean ltr;
517
518 widget = GTK_WIDGET (expander);
519 bin = GTK_BIN (expander);
520 priv = expander->priv;
521
522 border_width = GTK_CONTAINER (expander)->border_width;
523
524 gtk_widget_style_get (widget,
525 "interior-focus", &interior_focus,
526 "focus-line-width", &focus_width,
527 "focus-padding", &focus_pad,
528 "expander-size", &expander_size,
529 "expander-spacing", &expander_spacing,
530 NULL);
531
532 ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
533
534 rect->x = widget->allocation.x + border_width;
535 rect->y = widget->allocation.y + border_width;
536
537 if (ltr)
538 rect->x += expander_spacing;
539 else
540 rect->x += widget->allocation.width - 2 * border_width -
541 expander_spacing - expander_size;
542
543 if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
544 {
545 GtkAllocation label_allocation;
546
547 label_allocation = priv->label_widget->allocation;
548
549 if (expander_size < label_allocation.height)
550 rect->y += focus_width + focus_pad + (label_allocation.height - expander_size) / 2;
551 else
552 rect->y += expander_spacing;
553 }
554 else
555 {
556 rect->y += expander_spacing;
557 }
558
559 if (!interior_focus)
560 {
561 if (ltr)
562 rect->x += focus_width + focus_pad;
563 else
564 rect->x -= focus_width + focus_pad;
565 rect->y += focus_width + focus_pad;
566 }
567
568 rect->width = rect->height = expander_size;
569 }
570
571 static void
572 gtk_expander_size_allocate (GtkWidget *widget,
573 GtkAllocation *allocation)
574 {
575 GtkExpander *expander;
576 GtkBin *bin;
577 GtkExpanderPrivate *priv;
578 GtkRequisition child_requisition;
579 gboolean child_visible = FALSE;
580 gint border_width;
581 gint expander_size;
582 gint expander_spacing;
583 gboolean interior_focus;
584 gint focus_width;
585 gint focus_pad;
586 gint label_height;
587
588 expander = GTK_EXPANDER (widget);
589 bin = GTK_BIN (widget);
590 priv = expander->priv;
591
592 border_width = GTK_CONTAINER (widget)->border_width;
593
594 gtk_widget_style_get (widget,
595 "interior-focus", &interior_focus,
596 "focus-line-width", &focus_width,
597 "focus-padding", &focus_pad,
598 "expander-size", &expander_size,
599 "expander-spacing", &expander_spacing,
600 NULL);
601
602 child_requisition.width = 0;
603 child_requisition.height = 0;
604 if (bin->child && GTK_WIDGET_CHILD_VISIBLE (bin->child))
605 {
606 child_visible = TRUE;
607 gtk_widget_get_child_requisition (bin->child, &child_requisition);
608 }
609
610 widget->allocation = *allocation;
611
612 if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
613 {
614 GtkAllocation label_allocation;
615 GtkRequisition label_requisition;
616 gboolean ltr;
617
618 gtk_widget_get_child_requisition (priv->label_widget, &label_requisition);
619
620 ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
621
622 if (ltr)
623 label_allocation.x = (widget->allocation.x +
624 border_width + focus_width + focus_pad +
625 expander_size + 2 * expander_spacing);
626 else
627 label_allocation.x = (widget->allocation.x + widget->allocation.width -
628 (label_requisition.width +
629 border_width + focus_width + focus_pad +
630 expander_size + 2 * expander_spacing));
631
632 label_allocation.y = widget->allocation.y + border_width + focus_width + focus_pad;
633
634 label_allocation.width = MIN (label_requisition.width,
635 allocation->width - 2 * border_width -
636 expander_size - 2 * expander_spacing -
637 2 * focus_width - 2 * focus_pad);
638 label_allocation.width = MAX (label_allocation.width, 1);
639
640 label_allocation.height = MIN (label_requisition.height,
641 allocation->height - 2 * border_width -
642 2 * focus_width - 2 * focus_pad -
643 (child_visible ? priv->spacing : 0));
644 label_allocation.height = MAX (label_allocation.height, 1);
645
646 gtk_widget_size_allocate (priv->label_widget, &label_allocation);
647
648 label_height = label_allocation.height;
649 }
650 else
651 {
652 label_height = 0;
653 }
654
655 if (GTK_WIDGET_REALIZED (widget))
656 {
657 GdkRectangle rect;
658
659 get_expander_bounds (expander, &rect);
660
661 gdk_window_move_resize (priv->event_window,
662 allocation->x + border_width, rect.y,
663 MAX (allocation->width - 2 * border_width, 1), rect.width);
664 }
665
666 if (child_visible)
667 {
668 GtkAllocation child_allocation;
669 gint top_height;
670
671 top_height = MAX (2 * expander_spacing + expander_size,
672 label_height +
673 (interior_focus ? 2 * focus_width + 2 * focus_pad : 0));
674
675 child_allocation.x = widget->allocation.x + border_width;
676 child_allocation.y = widget->allocation.y + border_width + top_height + priv->spacing;
677
678 if (!interior_focus)
679 child_allocation.y += 2 * focus_width + 2 * focus_pad;
680
681 child_allocation.width = MAX (allocation->width - 2 * border_width, 1);
682
683 child_allocation.height = allocation->height - top_height -
684 2 * border_width - priv->spacing -
685 (!interior_focus ? 2 * focus_width + 2 * focus_pad : 0);
686 child_allocation.height = MAX (child_allocation.height, 1);
687
688 gtk_widget_size_allocate (bin->child, &child_allocation);
689 }
690 }
691
692 static void
693 gtk_expander_map (GtkWidget *widget)
694 {
695 GtkExpanderPrivate *priv = GTK_EXPANDER (widget)->priv;
696
697 if (priv->label_widget)
698 gtk_widget_map (priv->label_widget);
699
700 GTK_WIDGET_CLASS (parent_class)->map (widget);
701
702 if (priv->event_window)
703 gdk_window_show (priv->event_window);
704 }
705
706 static void
707 gtk_expander_unmap (GtkWidget *widget)
708 {
709 GtkExpanderPrivate *priv = GTK_EXPANDER (widget)->priv;
710
711 if (priv->event_window)
712 gdk_window_hide (priv->event_window);
713
714 GTK_WIDGET_CLASS (parent_class)->unmap (widget);
715
716 if (priv->label_widget)
717 gtk_widget_unmap (priv->label_widget);
718 }
719
720 static void
721 gtk_expander_paint_prelight (GtkExpander *expander)
722 {
723 GtkWidget *widget;
724 GtkContainer *container;
725 GtkExpanderPrivate *priv;
726 GdkRectangle area;
727 gboolean interior_focus;
728 int focus_width;
729 int focus_pad;
730 int expander_size;
731 int expander_spacing;
732
733 priv = expander->priv;
734 widget = GTK_WIDGET (expander);
735 container = GTK_CONTAINER (expander);
736
737 gtk_widget_style_get (widget,
738 "interior-focus", &interior_focus,
739 "focus-line-width", &focus_width,
740 "focus-padding", &focus_pad,
741 "expander-size", &expander_size,
742 "expander-spacing", &expander_spacing,
743 NULL);
744
745 area.x = widget->allocation.x + container->border_width;
746 area.y = widget->allocation.y + container->border_width;
747 area.width = widget->allocation.width - (2 * container->border_width);
748
749 if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
750 area.height = priv->label_widget->allocation.height;
751 else
752 area.height = 0;
753
754 area.height += interior_focus ? (focus_width + focus_pad) * 2 : 0;
755 area.height = MAX (area.height, expander_size + 2 * expander_spacing);
756 area.height += !interior_focus ? (focus_width + focus_pad) * 2 : 0;
757
758 gtk_paint_flat_box (widget->style, widget->window,
759 GTK_STATE_PRELIGHT,
760 GTK_SHADOW_ETCHED_OUT,
761 &area, widget, "expander",
762 area.x, area.y,
763 area.width, area.height);
764 }
765
766 static void
767 gtk_expander_paint (GtkExpander *expander)
768 {
769 GtkWidget *widget;
770 GdkRectangle clip;
771 GtkStateType state;
772
773 widget = GTK_WIDGET (expander);
774
775 get_expander_bounds (expander, &clip);
776
777 state = widget->state;
778 if (expander->priv->prelight)
779 {
780 state = GTK_STATE_PRELIGHT;
781
782 gtk_expander_paint_prelight (expander);
783 }
784
785 gtk_paint_expander (widget->style,
786 widget->window,
787 state,
788 &clip,
789 widget,
790 "expander",
791 clip.x + clip.width / 2,
792 clip.y + clip.height / 2,
793 expander->priv->expander_style);
794 }
795
796 static void
797 gtk_expander_paint_focus (GtkExpander *expander,
798 GdkRectangle *area)
799 {
800 GtkWidget *widget;
801 GtkExpanderPrivate *priv;
802 gint x, y, width, height;
803 gboolean interior_focus;
804 gint border_width;
805 gint focus_width;
806 gint focus_pad;
807 gint expander_size;
808 gint expander_spacing;
809 gboolean ltr;
810
811 widget = GTK_WIDGET (expander);
812 priv = expander->priv;
813
814 border_width = GTK_CONTAINER (widget)->border_width;
815
816 gtk_widget_style_get (widget,
817 "interior-focus", &interior_focus,
818 "focus-line-width", &focus_width,
819 "focus-padding", &focus_pad,
820 "expander-size", &expander_size,
821 "expander-spacing", &expander_spacing,
822 NULL);
823
824 ltr = gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL;
825
826 x = widget->allocation.x + border_width;
827 y = widget->allocation.y + border_width;
828
829 if (ltr && interior_focus)
830 x += expander_spacing * 2 + expander_size;
831
832 width = height = 0;
833
834 if (priv->label_widget && GTK_WIDGET_VISIBLE (priv->label_widget))
835 {
836 GtkAllocation label_allocation = priv->label_widget->allocation;
837
838 width = label_allocation.width;
839 height = label_allocation.height;
840 }
841
842 if (!interior_focus)
843 {
844 width += expander_size + 2 * expander_spacing;
845 height = MAX (height, expander_size + 2 * expander_spacing);
846 }
847
848 width += 2 * focus_pad + 2 * focus_width;
849 height += 2 * focus_pad + 2 * focus_width;
850
851 gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
852 area, widget, "expander",
853 x, y, width, height);
854 }
855
856 static gboolean
857 gtk_expander_expose (GtkWidget *widget,
858 GdkEventExpose *event)
859 {
860 if (GTK_WIDGET_DRAWABLE (widget))
861 {
862 GtkExpander *expander = GTK_EXPANDER (widget);
863
864 gtk_expander_paint (expander);
865
866 if (GTK_WIDGET_HAS_FOCUS (expander))
867 gtk_expander_paint_focus (expander, &event->area);
868
869 GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
870 }
871
872 return FALSE;
873 }
874
875 static gboolean
876 gtk_expander_button_press (GtkWidget *widget,
877 GdkEventButton *event)
878 {
879 GtkExpander *expander = GTK_EXPANDER (widget);
880
881 if (event->button == 1 && event->window == expander->priv->event_window)
882 {
883 expander->priv->button_down = TRUE;
884 return TRUE;
885 }
886
887 return FALSE;
888 }
889
890 static gboolean
891 gtk_expander_button_release (GtkWidget *widget,
892 GdkEventButton *event)
893 {
894 GtkExpander *expander = GTK_EXPANDER (widget);
895
896 if (event->button == 1 && expander->priv->button_down)
897 {
898 gtk_widget_activate (widget);
899 expander->priv->button_down = FALSE;
900 return TRUE;
901 }
902
903 return FALSE;
904 }
905
906 static void
907 gtk_expander_grab_notify (GtkWidget *widget,
908 gboolean was_grabbed)
909 {
910 if (!was_grabbed)
911 GTK_EXPANDER (widget)->priv->button_down = FALSE;
912 }
913
914 static void
915 gtk_expander_state_changed (GtkWidget *widget,
916 GtkStateType previous_state)
917 {
918 if (!GTK_WIDGET_IS_SENSITIVE (widget))
919 GTK_EXPANDER (widget)->priv->button_down = FALSE;
920 }
921
922 static void
923 gtk_expander_redraw_expander (GtkExpander *expander)
924 {
925 GtkWidget *widget;
926
927 widget = GTK_WIDGET (expander);
928
929 if (GTK_WIDGET_REALIZED (widget))
930 gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
931 }
932
933 static gboolean
934 gtk_expander_enter_notify (GtkWidget *widget,
935 GdkEventCrossing *event)
936 {
937 GtkExpander *expander = GTK_EXPANDER (widget);
938 GtkWidget *event_widget;
939
940 event_widget = gtk_get_event_widget ((GdkEvent *) event);
941
942 if (event_widget == widget &&
943 event->detail != GDK_NOTIFY_INFERIOR)
944 {
945 expander->priv->prelight = TRUE;
946
947 if (expander->priv->label_widget)
948 gtk_widget_set_state (expander->priv->label_widget, GTK_STATE_PRELIGHT);
949
950 gtk_expander_redraw_expander (expander);
951 }
952
953 return FALSE;
954 }
955
956 static gboolean
957 gtk_expander_leave_notify (GtkWidget *widget,
958 GdkEventCrossing *event)
959 {
960 GtkExpander *expander = GTK_EXPANDER (widget);
961 GtkWidget *event_widget;
962
963 event_widget = gtk_get_event_widget ((GdkEvent *) event);
964
965 if (event_widget == widget &&
966 event->detail != GDK_NOTIFY_INFERIOR)
967 {
968 expander->priv->prelight = FALSE;
969
970 if (expander->priv->label_widget)
971 gtk_widget_set_state (expander->priv->label_widget, GTK_STATE_NORMAL);
972
973 gtk_expander_redraw_expander (expander);
974 }
975
976 return FALSE;
977 }
978
979 typedef enum
980 {
981 FOCUS_NONE,
982 FOCUS_WIDGET,
983 FOCUS_LABEL,
984 FOCUS_CHILD
985 } FocusSite;
986
987 static gboolean
988 focus_current_site (GtkExpander *expander,
989 GtkDirectionType direction)
990 {
991 GtkWidget *current_focus;
992
993 current_focus = GTK_CONTAINER (expander)->focus_child;
994
995 if (!current_focus)
996 return FALSE;
997
998 return gtk_widget_child_focus (current_focus, direction);
999 }
1000
1001 static gboolean
1002 focus_in_site (GtkExpander *expander,
1003 FocusSite site,
1004 GtkDirectionType direction)
1005 {
1006 switch (site)
1007 {
1008 case FOCUS_WIDGET:
1009 gtk_widget_grab_focus (GTK_WIDGET (expander));
1010 return TRUE;
1011 case FOCUS_LABEL:
1012 if (expander->priv->label_widget)
1013 return gtk_widget_child_focus (expander->priv->label_widget, direction);
1014 else
1015 return FALSE;
1016 case FOCUS_CHILD:
1017 {
1018 GtkWidget *child = gtk_bin_get_child (GTK_BIN (expander));
1019
1020 if (child && GTK_WIDGET_CHILD_VISIBLE (child))
1021 return gtk_widget_child_focus (child, direction);
1022 else
1023 return FALSE;
1024 }
1025 case FOCUS_NONE:
1026 break;
1027 }
1028
1029 g_assert_not_reached ();
1030 return FALSE;
1031 }
1032
1033 static FocusSite
1034 get_next_site (GtkExpander *expander,
1035 FocusSite site,
1036 GtkDirectionType direction)
1037 {
1038 gboolean ltr;
1039
1040 ltr = gtk_widget_get_direction (GTK_WIDGET (expander)) != GTK_TEXT_DIR_RTL;
1041
1042 switch (site)
1043 {
1044 case FOCUS_NONE:
1045 switch (direction)
1046 {
1047 case GTK_DIR_TAB_BACKWARD:
1048 case GTK_DIR_LEFT:
1049 case GTK_DIR_UP:
1050 return FOCUS_CHILD;
1051 case GTK_DIR_TAB_FORWARD:
1052 case GTK_DIR_DOWN:
1053 case GTK_DIR_RIGHT:
1054 return FOCUS_WIDGET;
1055 }
1056 case FOCUS_WIDGET:
1057 switch (direction)
1058 {
1059 case GTK_DIR_TAB_BACKWARD:
1060 case GTK_DIR_UP:
1061 return FOCUS_NONE;
1062 case GTK_DIR_LEFT:
1063 return ltr ? FOCUS_NONE : FOCUS_LABEL;
1064 case GTK_DIR_TAB_FORWARD:
1065 case GTK_DIR_DOWN:
1066 return FOCUS_LABEL;
1067 case GTK_DIR_RIGHT:
1068 return ltr ? FOCUS_LABEL : FOCUS_NONE;
1069 break;
1070 }
1071 case FOCUS_LABEL:
1072 switch (direction)
1073 {
1074 case GTK_DIR_TAB_BACKWARD:
1075 case GTK_DIR_UP:
1076 return FOCUS_WIDGET;
1077 case GTK_DIR_LEFT:
1078 return ltr ? FOCUS_WIDGET : FOCUS_CHILD;
1079 case GTK_DIR_TAB_FORWARD:
1080 case GTK_DIR_DOWN:
1081 return FOCUS_CHILD;
1082 case GTK_DIR_RIGHT:
1083 return ltr ? FOCUS_CHILD : FOCUS_WIDGET;
1084 break;
1085 }
1086 case FOCUS_CHILD:
1087 switch (direction)
1088 {
1089 case GTK_DIR_TAB_BACKWARD:
1090 case GTK_DIR_LEFT:
1091 case GTK_DIR_UP:
1092 return FOCUS_LABEL;
1093 case GTK_DIR_TAB_FORWARD:
1094 case GTK_DIR_DOWN:
1095 case GTK_DIR_RIGHT:
1096 return FOCUS_NONE;
1097 }
1098 }
1099
1100 g_assert_not_reached ();
1101 return FOCUS_NONE;
1102 }
1103
1104 static gboolean
1105 gtk_expander_focus (GtkWidget *widget,
1106 GtkDirectionType direction)
1107 {
1108 GtkExpander *expander = GTK_EXPANDER (widget);
1109
1110 if (!focus_current_site (expander, direction))
1111 {
1112 GtkWidget *old_focus_child;
1113 gboolean widget_is_focus;
1114 FocusSite site = FOCUS_NONE;
1115
1116 widget_is_focus = gtk_widget_is_focus (widget);
1117 old_focus_child = GTK_CONTAINER (widget)->focus_child;
1118
1119 if (old_focus_child && old_focus_child == expander->priv->label_widget)
1120 site = FOCUS_LABEL;
1121 else if (old_focus_child)
1122 site = FOCUS_CHILD;
1123 else if (widget_is_focus)
1124 site = FOCUS_WIDGET;
1125
1126 while ((site = get_next_site (expander, site, direction)) != FOCUS_NONE)
1127 {
1128 if (focus_in_site (expander, site, direction))
1129 return TRUE;
1130 }
1131
1132 return FALSE;
1133 }
1134
1135 return TRUE;
1136 }
1137
1138 static void
1139 gtk_expander_add (GtkContainer *container,
1140 GtkWidget *widget)
1141 {
1142 GTK_CONTAINER_CLASS (parent_class)->add (container, widget);
1143
1144 gtk_widget_set_child_visible (widget, GTK_EXPANDER (container)->priv->expanded);
1145 gtk_widget_queue_resize (GTK_WIDGET (container));
1146 }
1147
1148 static void
1149 gtk_expander_remove (GtkContainer *container,
1150 GtkWidget *widget)
1151 {
1152 GtkExpander *expander = GTK_EXPANDER (container);
1153
1154 if (GTK_EXPANDER (expander)->priv->label_widget == widget)
1155 gtk_expander_set_label_widget (expander, NULL);
1156 else
1157 GTK_CONTAINER_CLASS (parent_class)->remove (container, widget);
1158 }
1159
1160 static void
1161 gtk_expander_forall (GtkContainer *container,
1162 gboolean include_internals,
1163 GtkCallback callback,
1164 gpointer callback_data)
1165 {
1166 GtkBin *bin = GTK_BIN (container);
1167 GtkExpanderPrivate *priv = GTK_EXPANDER (container)->priv;
1168
1169 if (bin->child)
1170 (* callback) (bin->child, callback_data);
1171
1172 if (priv->label_widget)
1173 (* callback) (priv->label_widget, callback_data);
1174 }
1175
1176 static void
1177 gtk_expander_activate (GtkExpander *expander)
1178 {
1179 gtk_expander_set_expanded (expander, !expander->priv->expanded);
1180 }
1181
1182
1183 /**
1184 * gtk_expander_new:
1185 * @label: the text of the label
1186 *
1187 * Creates a new expander using @label as the text of the label.
1188 *
1189 * Return value: a new #GtkExpander widget.
1190 *
1191 * Since: 2.4
1192 **/
1193 GtkWidget *
1194 gtk_expander_new (const gchar *label)
1195 {
1196 return g_object_new (GTK_TYPE_EXPANDER, "label", label, NULL);
1197 }
1198
1199 /**
1200 * gtk_expander_new_with_mnemonic:
1201 * @label: the text of the label with an underscore in front of the
1202 * mnemonic character
1203 *
1204 * Creates a new expander using @label as the text of the label.
1205 * If characters in @label are preceded by an underscore, they are underlined.
1206 * If you need a literal underscore character in a label, use '__' (two
1207 * underscores). The first underlined character represents a keyboard
1208 * accelerator called a mnemonic.
1209 * Pressing Alt and that key activates the button.
1210 *
1211 * Return value: a new #GtkExpander widget.
1212 *
1213 * Since: 2.4
1214 **/
1215 GtkWidget *
1216 gtk_expander_new_with_mnemonic (const gchar *label)
1217 {
1218 return g_object_new (GTK_TYPE_EXPANDER,
1219 "label", label,
1220 "use_underline", TRUE,
1221 NULL);
1222 }
1223
1224 static gboolean
1225 gtk_expander_animation_timeout (GtkExpander *expander)
1226 {
1227 GtkExpanderPrivate *priv = expander->priv;
1228 GdkRectangle area;
1229 gboolean finish = FALSE;
1230
1231 GDK_THREADS_ENTER();
1232
1233 if (GTK_WIDGET_REALIZED (expander))
1234 {
1235 get_expander_bounds (expander, &area);
1236 gdk_window_invalidate_rect (GTK_WIDGET (expander)->window, &area, TRUE);
1237 }
1238
1239 if (priv->expanded)
1240 {
1241 if (priv->expander_style == GTK_EXPANDER_COLLAPSED)
1242 {
1243 priv->expander_style = GTK_EXPANDER_SEMI_EXPANDED;
1244 }
1245 else
1246 {
1247 priv->expander_style = GTK_EXPANDER_EXPANDED;
1248 finish = TRUE;
1249 }
1250 }
1251 else
1252 {
1253 if (priv->expander_style == GTK_EXPANDER_EXPANDED)
1254 {
1255 priv->expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
1256 }
1257 else
1258 {
1259 priv->expander_style = GTK_EXPANDER_COLLAPSED;
1260 finish = TRUE;
1261 }
1262 }
1263
1264 if (finish)
1265 {
1266 priv->animation_timeout = 0;
1267 if (GTK_BIN (expander)->child)
1268 gtk_widget_set_child_visible (GTK_BIN (expander)->child, priv->expanded);
1269 gtk_widget_queue_resize (GTK_WIDGET (expander));
1270 }
1271
1272 GDK_THREADS_LEAVE();
1273
1274 return !finish;
1275 }
1276
1277 static void
1278 gtk_expander_start_animation (GtkExpander *expander)
1279 {
1280 GtkExpanderPrivate *priv = expander->priv;
1281
1282 if (priv->animation_timeout)
1283 g_source_remove (priv->animation_timeout);
1284
1285 priv->animation_timeout =
1286 g_timeout_add (50,
1287 (GSourceFunc) gtk_expander_animation_timeout,
1288 expander);
1289 }
1290
1291 /**
1292 * gtk_expander_set_expanded:
1293 * @expander: a #GtkExpander
1294 * @expanded: whether the child widget is revealed
1295 *
1296 * Sets the state of the expander. Set to %TRUE, if you want
1297 * the child widget to be revealed, and %FALSE if you want the
1298 * child widget to be hidden.
1299 *
1300 * Since: 2.4
1301 **/
1302 void
1303 gtk_expander_set_expanded (GtkExpander *expander,
1304 gboolean expanded)
1305 {
1306 GtkExpanderPrivate *priv;
1307
1308 g_return_if_fail (GTK_IS_EXPANDER (expander));
1309
1310 priv = expander->priv;
1311
1312 expanded = expanded != FALSE;
1313
1314 if (priv->expanded != expanded)
1315 {
1316 priv->expanded = expanded;
1317
1318 if (GTK_WIDGET_REALIZED (expander))
1319 {
1320 gtk_expander_start_animation (expander);
1321 }
1322 else
1323 {
1324 priv->expander_style = expanded ? GTK_EXPANDER_EXPANDED :
1325 GTK_EXPANDER_COLLAPSED;
1326
1327 if (GTK_BIN (expander)->child)
1328 {
1329 gtk_widget_set_child_visible (GTK_BIN (expander)->child, priv->expanded);
1330 gtk_widget_queue_resize (GTK_WIDGET (expander));
1331 }
1332 }
1333
1334 g_object_notify (G_OBJECT (expander), "expanded");
1335 }
1336 }
1337
1338 /**
1339 * gtk_expander_get_expanded:
1340 * @expander:a #GtkExpander
1341 *
1342 * Queries a #GtkExpander and returns its current state. Returns %TRUE
1343 * if the child widget is revealed.
1344 *
1345 * See gtk_expander_set_expanded().
1346 *
1347 * Return value: the current state of the expander.
1348 *
1349 * Since: 2.4
1350 **/
1351 gboolean
1352 gtk_expander_get_expanded (GtkExpander *expander)
1353 {
1354 g_return_val_if_fail (GTK_IS_EXPANDER (expander), FALSE);
1355
1356 return expander->priv->expanded;
1357 }
1358
1359 /**
1360 * gtk_expander_set_spacing:
1361 * @expander: a #GtkExpander
1362 * @spacing: distance between the expander and child in pixels.
1363 *
1364 * Sets the spacing field of @expander, which is the number of pixels to
1365 * place between expander and the child.
1366 *
1367 * Since: 2.4
1368 **/
1369 void
1370 gtk_expander_set_spacing (GtkExpander *expander,
1371 gint spacing)
1372 {
1373 g_return_if_fail (GTK_IS_EXPANDER (expander));
1374 g_return_if_fail (spacing >= 0);
1375
1376 if (expander->priv->spacing != spacing)
1377 {
1378 expander->priv->spacing = spacing;
1379
1380 gtk_widget_queue_resize (GTK_WIDGET (expander));
1381
1382 g_object_notify (G_OBJECT (expander), "spacing");
1383 }
1384 }
1385
1386 /**
1387 * gtk_expander_get_spacing:
1388 * @expander: a #GtkExpander
1389 *
1390 * Gets the value set by gtk_expander_set_spacing().
1391 *
1392 * Return value: spacing between the expander and child.
1393 *
1394 * Since: 2.4
1395 **/
1396 gint
1397 gtk_expander_get_spacing (GtkExpander *expander)
1398 {
1399 g_return_val_if_fail (GTK_IS_EXPANDER (expander), 0);
1400
1401 return expander->priv->spacing;
1402 }
1403
1404 /**
1405 * gtk_expander_set_label:
1406 * @expander: a #GtkExpander
1407 * @label: a string
1408 *
1409 * Sets the text of the label of the expander to @label.
1410 *
1411 * This will also clear any previously set labels.
1412 *
1413 * Since: 2.4
1414 **/
1415 void
1416 gtk_expander_set_label (GtkExpander *expander,
1417 const gchar *label)
1418 {
1419 g_return_if_fail (GTK_IS_EXPANDER (expander));
1420
1421 if (!label)
1422 {
1423 gtk_expander_set_label_widget (expander, NULL);
1424 }
1425 else
1426 {
1427 GtkWidget *child;
1428
1429 child = gtk_label_new (label);
1430 gtk_label_set_use_underline (GTK_LABEL (child), expander->priv->use_underline);
1431 gtk_label_set_use_markup (GTK_LABEL (child), expander->priv->use_markup);
1432 gtk_widget_show (child);
1433
1434 gtk_expander_set_label_widget (expander, child);
1435 }
1436
1437 g_object_notify (G_OBJECT (expander), "label");
1438 }
1439
1440 /**
1441 * gtk_expander_get_label:
1442 * @expander: a #GtkExpander
1443 *
1444 * Fetches the text from the label of the expander, as set by
1445 * gtk_expander_set_label(). If the label text has not
1446 * been set the return value will be %NULL. This will be the
1447 * case if you create an empty button with gtk_button_new() to
1448 * use as a container.
1449 *
1450 * Return value: The text of the label widget. This string is owned
1451 * by the widget and must not be modified or freed.
1452 *
1453 * Since: 2.4
1454 **/
1455 G_CONST_RETURN char *
1456 gtk_expander_get_label (GtkExpander *expander)
1457 {
1458 GtkExpanderPrivate *priv;
1459
1460 g_return_val_if_fail (GTK_IS_EXPANDER (expander), NULL);
1461
1462 priv = expander->priv;
1463
1464 if (priv->label_widget && GTK_IS_LABEL (priv->label_widget))
1465 return gtk_label_get_text (GTK_LABEL (priv->label_widget));
1466 else
1467 return NULL;
1468 }
1469
1470 /**
1471 * gtk_expander_set_use_underline:
1472 * @expander: a #GtkExpander
1473 * @use_underline: %TRUE if underlines in the text indicate mnemonics
1474 *
1475 * If true, an underline in the text of the expander label indicates
1476 * the next character should be used for the mnemonic accelerator key.
1477 *
1478 * Since: 2.4
1479 **/
1480 void
1481 gtk_expander_set_use_underline (GtkExpander *expander,
1482 gboolean use_underline)
1483 {
1484 GtkExpanderPrivate *priv;
1485
1486 g_return_if_fail (GTK_IS_EXPANDER (expander));
1487
1488 priv = expander->priv;
1489
1490 use_underline = use_underline != FALSE;
1491
1492 if (priv->use_underline != use_underline)
1493 {
1494 priv->use_underline = use_underline;
1495
1496 if (priv->label_widget && GTK_IS_LABEL (priv->label_widget))
1497 gtk_label_set_use_underline (GTK_LABEL (priv->label_widget), use_underline);
1498
1499 g_object_notify (G_OBJECT (expander), "use-underline");
1500 }
1501 }
1502
1503 /**
1504 * gtk_expander_get_use_underline:
1505 * @expander: a #GtkExpander
1506 *
1507 * Returns whether an embedded underline in the expander label indicates a
1508 * mnemonic. See gtk_expander_set_use_underline().
1509 *
1510 * Return value: %TRUE if an embedded underline in the expander label
1511 * indicates the mnemonic accelerator keys.
1512 *
1513 * Since: 2.4
1514 **/
1515 gboolean
1516 gtk_expander_get_use_underline (GtkExpander *expander)
1517 {
1518 g_return_val_if_fail (GTK_IS_EXPANDER (expander), FALSE);
1519
1520 return expander->priv->use_underline;
1521 }
1522
1523 /**
1524 * gtk_expander_set_use_markup:
1525 * @expander: a #GtkExpander
1526 * @use_markup: %TRUE if the label's text should be parsed for markup
1527 *
1528 * Sets whether the text of the label contains markup in <link
1529 * linkend="PangoMarkupFormat">Pango's text markup
1530 * language</link>. See gtk_label_set_markup().
1531 *
1532 * Since: 2.4
1533 **/
1534 void
1535 gtk_expander_set_use_markup (GtkExpander *expander,
1536 gboolean use_markup)
1537 {
1538 GtkExpanderPrivate *priv;
1539
1540 g_return_if_fail (GTK_IS_EXPANDER (expander));
1541
1542 priv = expander->priv;
1543
1544 use_markup = use_markup != FALSE;
1545
1546 if (priv->use_markup != use_markup)
1547 {
1548 priv->use_markup = use_markup;
1549
1550 if (priv->label_widget && GTK_IS_LABEL (priv->label_widget))
1551 gtk_label_set_use_markup (GTK_LABEL (priv->label_widget), use_markup);
1552
1553 g_object_notify (G_OBJECT (expander), "use-markup");
1554 }
1555 }
1556
1557 /**
1558 * gtk_expander_get_use_markup:
1559 * @expander: a #GtkExpander
1560 *
1561 * Returns whether the label's text is interpreted as marked up with
1562 * the <link linkend="PangoMarkupFormat">Pango text markup
1563 * language</link>. See gtk_expander_set_use_markup ().
1564 *
1565 * Return value: %TRUE if the label's text will be parsed for markup
1566 *
1567 * Since: 2.4
1568 **/
1569 gboolean
1570 gtk_expander_get_use_markup (GtkExpander *expander)
1571 {
1572 g_return_val_if_fail (GTK_IS_EXPANDER (expander), FALSE);
1573
1574 return expander->priv->use_markup;
1575 }
1576
1577 /**
1578 * gtk_expander_set_label_widget:
1579 * @expander: a #GtkExpander
1580 * @label_widget: the new label widget
1581 *
1582 * Set the label widget for the expander. This is the widget
1583 * that will appear embedded alongside the expander arrow.
1584 *
1585 * Since: 2.4
1586 **/
1587 void
1588 gtk_expander_set_label_widget (GtkExpander *expander,
1589 GtkWidget *label_widget)
1590 {
1591 GtkExpanderPrivate *priv;
1592
1593 g_return_if_fail (GTK_IS_EXPANDER (expander));
1594 g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget));
1595 g_return_if_fail (label_widget == NULL || label_widget->parent == NULL);
1596
1597 priv = expander->priv;
1598
1599 if (priv->label_widget == label_widget)
1600 return;
1601
1602 if (priv->label_widget)
1603 {
1604 gtk_widget_set_state (priv->label_widget, GTK_STATE_NORMAL);
1605 gtk_widget_unparent (priv->label_widget);
1606 }
1607
1608 priv->label_widget = label_widget;
1609
1610 if (label_widget)
1611 {
1612 priv->label_widget = label_widget;
1613
1614 gtk_widget_set_parent (label_widget, GTK_WIDGET (expander));
1615
1616 if (priv->prelight)
1617 gtk_widget_set_state (label_widget, GTK_STATE_PRELIGHT);
1618 }
1619
1620 if (GTK_WIDGET_VISIBLE (expander))
1621 gtk_widget_queue_resize (GTK_WIDGET (expander));
1622
1623 g_object_freeze_notify (G_OBJECT (expander));
1624 g_object_notify (G_OBJECT (expander), "label-widget");
1625 g_object_notify (G_OBJECT (expander), "label");
1626 g_object_thaw_notify (G_OBJECT (expander));
1627 }
1628
1629 /**
1630 * gtk_expander_get_label_widget:
1631 * @expander: a #GtkExpander
1632 *
1633 * Retrieves the label widget for the frame. See
1634 * gtk_expander_set_label_widget().
1635 *
1636 * Return value: the label widget, or %NULL if there is none.
1637 *
1638 * Since: 2.4
1639 **/
1640 GtkWidget *
1641 gtk_expander_get_label_widget (GtkExpander *expander)
1642 {
1643 g_return_val_if_fail (GTK_IS_EXPANDER (expander), NULL);
1644
1645 return expander->priv->label_widget;
1646 }
1647
1648 #define __GTK_EXPANDER_C__
1649 #include <gtk/gtkaliasdef.c>
1650
1651 #endif /* Gtk 2.4 */

Mercurial Repository: pidgin3

mercurial