1 /* GtkToolPalette -- A tool palette with categories and DnD support
2 * Copyright (C) 2008 Openismus GmbH
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "gtktoolpaletteprivate.h"
23 #include "gtkmarshalers.h"
28 #define DEFAULT_ICON_SIZE GTK_ICON_SIZE_SMALL_TOOLBAR
29 #define DEFAULT_ORIENTATION GTK_ORIENTATION_VERTICAL
30 #define DEFAULT_TOOLBAR_STYLE GTK_TOOLBAR_ICONS
32 #define DEFAULT_CHILD_EXCLUSIVE FALSE
33 #define DEFAULT_CHILD_EXPAND FALSE
35 #define P_(msgid) (msgid)
38 * SECTION:GtkToolPalette
39 * @short_description: A tool palette with categories
40 * @include: gtktoolpalette.h
42 * An #GtkToolPalette allows it to add #GtkToolItem<!-- -->s to a palette like container
43 * with different categories and drag and drop support.
45 * An #GtkToolPalette is created with a call to gtk_tool_palette_new().
47 * #GtkToolItem<!-- -->s cannot be added directly to an #GtkToolPalette, instead they
48 * are added to an #GtkToolItemGroup which can than be added to an #GtkToolPalette. To add
49 * an #GtkToolItemGroup to an #GtkToolPalette use gtk_container_add().
52 * GtkWidget *palette, *group;
55 * palette = gtk_tool_palette_new ();
56 * group = gtk_tool_item_group_new (_("Test Category"));
57 * gtk_container_add (GTK_CONTAINER (palette), group);
59 * item = gtk_tool_button_new_from_stock (GTK_STOCK_OK);
60 * gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
63 * The easiest way to use drag and drop with GtkToolPalette is to call gtk_tool_palette_add_drag_dest()
64 * with the desired drag source @palette and the desired drag target @widget. Than gtk_tool_palette_get_drag_item()
65 * can be used to get the dragged item in the #GtkWidget::drag-data-received signal handler of the drag target.
69 * passive_canvas_drag_data_received (GtkWidget *widget,
70 * GdkDragContext *context,
73 * GtkSelectionData *selection,
81 * /<!-- -->* Get the dragged item *<!-- -->/
82 * palette = gtk_widget_get_ancestor (gtk_drag_get_source_widget (context), GTK_TYPE_TOOL_PALETTE);
83 * if (palette != NULL)
84 * item = gtk_tool_palette_get_drag_item (GTK_TOOL_PALETTE (palette), selection);
86 * /<!-- -->* Do something with item *<!-- -->/
89 * GtkWidget *target, palette;
91 * palette = gtk_tool_palette_new ();
92 * target = gtk_drawing_area_new ();
94 * g_signal_connect (G_OBJECT (target), "drag-data-received",
95 * G_CALLBACK (passive_canvas_drag_data_received), NULL);
96 * gtk_tool_palette_add_drag_dest (GTK_TOOL_PALETTE (palette), target,
97 * GTK_DEST_DEFAULT_ALL,
98 * GTK_TOOL_PALETTE_DRAG_ITEMS,
105 typedef struct _GtkToolItemGroupInfo GtkToolItemGroupInfo;
106 typedef struct _GtkToolPaletteDragData GtkToolPaletteDragData;
120 CHILD_PROP_EXCLUSIVE,
124 struct _GtkToolItemGroupInfo
126 GtkToolItemGroup *widget;
128 guint notify_collapsed;
133 struct _GtkToolPalettePrivate
135 GtkToolItemGroupInfo *groups;
139 GtkAdjustment *hadjustment;
140 GtkAdjustment *vadjustment;
142 GtkIconSize icon_size;
143 gboolean icon_size_set;
144 GtkOrientation orientation;
145 GtkToolbarStyle style;
148 GtkWidget *expanding_child;
150 GtkSizeGroup *text_size_group;
152 GtkSettings *settings;
153 gulong settings_connection;
155 guint sparse_groups : 1;
156 guint drag_source : 2;
159 struct _GtkToolPaletteDragData
161 GtkToolPalette *palette;
165 static GdkAtom dnd_target_atom_item = GDK_NONE;
166 static GdkAtom dnd_target_atom_group = GDK_NONE;
168 static const GtkTargetEntry dnd_targets[] =
170 { "application/x-GTK-tool-palette-item", GTK_TARGET_SAME_APP, 0 },
171 { "application/x-GTK-tool-palette-group", GTK_TARGET_SAME_APP, 0 },
174 G_DEFINE_TYPE_WITH_CODE (GtkToolPalette,
177 G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE, NULL));
180 gtk_tool_palette_init (GtkToolPalette *palette)
182 palette->priv = G_TYPE_INSTANCE_GET_PRIVATE (palette,
183 GTK_TYPE_TOOL_PALETTE,
184 GtkToolPalettePrivate);
186 palette->priv->groups_size = 4;
187 palette->priv->groups_length = 0;
188 palette->priv->groups = g_new0 (GtkToolItemGroupInfo, palette->priv->groups_size);
190 palette->priv->icon_size = DEFAULT_ICON_SIZE;
191 palette->priv->icon_size_set = FALSE;
192 palette->priv->orientation = DEFAULT_ORIENTATION;
193 palette->priv->style = DEFAULT_TOOLBAR_STYLE;
194 palette->priv->style_set = FALSE;
196 palette->priv->text_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
200 gtk_tool_palette_reconfigured (GtkToolPalette *palette)
204 for (i = 0; i < palette->priv->groups_length; ++i)
206 if (palette->priv->groups[i].widget)
207 _gtk_tool_item_group_palette_reconfigured (palette->priv->groups[i].widget);
210 gtk_widget_queue_resize_no_redraw (GTK_WIDGET (palette));
214 gtk_tool_palette_set_property (GObject *object,
219 GtkToolPalette *palette = GTK_TOOL_PALETTE (object);
224 if ((guint) g_value_get_enum (value) != palette->priv->icon_size)
226 palette->priv->icon_size = g_value_get_enum (value);
227 gtk_tool_palette_reconfigured (palette);
231 case PROP_ICON_SIZE_SET:
232 if ((guint) g_value_get_enum (value) != palette->priv->icon_size)
234 palette->priv->icon_size_set = g_value_get_enum (value);
235 gtk_tool_palette_reconfigured (palette);
239 case PROP_ORIENTATION:
240 if ((guint) g_value_get_enum (value) != palette->priv->orientation)
242 palette->priv->orientation = g_value_get_enum (value);
243 gtk_tool_palette_reconfigured (palette);
247 case PROP_TOOLBAR_STYLE:
248 if ((guint) g_value_get_enum (value) != palette->priv->style)
250 palette->priv->style = g_value_get_enum (value);
251 gtk_tool_palette_reconfigured (palette);
256 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
262 gtk_tool_palette_get_property (GObject *object,
267 GtkToolPalette *palette = GTK_TOOL_PALETTE (object);
272 g_value_set_enum (value, gtk_tool_palette_get_icon_size (palette));
275 case PROP_ICON_SIZE_SET:
276 g_value_set_boolean (value, palette->priv->icon_size_set);
279 case PROP_ORIENTATION:
280 g_value_set_enum (value, palette->priv->orientation);
283 case PROP_TOOLBAR_STYLE:
284 g_value_set_enum (value, gtk_tool_palette_get_style (palette));
288 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
294 gtk_tool_palette_dispose (GObject *object)
296 GtkToolPalette *palette = GTK_TOOL_PALETTE (object);
299 if (palette->priv->hadjustment)
301 g_object_unref (palette->priv->hadjustment);
302 palette->priv->hadjustment = NULL;
305 if (palette->priv->vadjustment)
307 g_object_unref (palette->priv->vadjustment);
308 palette->priv->vadjustment = NULL;
311 for (i = 0; i < palette->priv->groups_size; ++i)
313 GtkToolItemGroupInfo *group = &palette->priv->groups[i];
315 if (group->notify_collapsed)
317 g_signal_handler_disconnect (group->widget, group->notify_collapsed);
318 group->notify_collapsed = 0;
322 if (palette->priv->text_size_group)
324 g_object_unref (palette->priv->text_size_group);
325 palette->priv->text_size_group = NULL;
328 G_OBJECT_CLASS (gtk_tool_palette_parent_class)->dispose (object);
332 gtk_tool_palette_finalize (GObject *object)
334 GtkToolPalette *palette = GTK_TOOL_PALETTE (object);
336 if (palette->priv->groups)
338 palette->priv->groups_length = 0;
339 g_free (palette->priv->groups);
340 palette->priv->groups = NULL;
343 G_OBJECT_CLASS (gtk_tool_palette_parent_class)->finalize (object);
347 gtk_tool_palette_size_request (GtkWidget *widget,
348 GtkRequisition *requisition)
350 const gint border_width = GTK_CONTAINER (widget)->border_width;
351 GtkToolPalette *palette = GTK_TOOL_PALETTE (widget);
352 GtkRequisition child_requisition;
355 requisition->width = 0;
356 requisition->height = 0;
358 for (i = 0; i < palette->priv->groups_length; ++i)
360 GtkToolItemGroupInfo *group = &palette->priv->groups[i];
365 gtk_widget_size_request (GTK_WIDGET (group->widget), &child_requisition);
367 if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)
369 requisition->width = MAX (requisition->width, child_requisition.width);
370 requisition->height += child_requisition.height;
374 requisition->width += child_requisition.width;
375 requisition->height = MAX (requisition->height, child_requisition.height);
379 requisition->width += border_width * 2;
380 requisition->height += border_width * 2;
384 gtk_tool_palette_size_allocate (GtkWidget *widget,
385 GtkAllocation *allocation)
387 const gint border_width = GTK_CONTAINER (widget)->border_width;
388 GtkToolPalette *palette = GTK_TOOL_PALETTE (widget);
389 GtkAdjustment *adjustment = NULL;
390 GtkAllocation child_allocation;
392 gint n_expand_groups = 0;
393 gint remaining_space = 0;
394 gint expand_space = 0;
396 gint page_start, page_size = 0;
400 gint min_offset = -1, max_offset = -1;
404 gint *group_sizes = g_newa(gint, palette->priv->groups_length);
406 GtkTextDirection direction = gtk_widget_get_direction (widget);
408 GTK_WIDGET_CLASS (gtk_tool_palette_parent_class)->size_allocate (widget, allocation);
410 if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)
412 adjustment = palette->priv->vadjustment;
413 page_size = allocation->height;
417 adjustment = palette->priv->hadjustment;
418 page_size = allocation->width;
422 offset = gtk_adjustment_get_value (adjustment);
423 if (GTK_ORIENTATION_HORIZONTAL == palette->priv->orientation &&
424 GTK_TEXT_DIR_RTL == direction)
427 if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)
428 child_allocation.width = allocation->width - border_width * 2;
430 child_allocation.height = allocation->height - border_width * 2;
432 if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)
433 remaining_space = allocation->height;
435 remaining_space = allocation->width;
437 /* figure out the required size of all groups to be able to distribute the
438 * remaining space on allocation */
439 for (i = 0; i < palette->priv->groups_length; ++i)
441 GtkToolItemGroupInfo *group = &palette->priv->groups[i];
447 widget = GTK_WIDGET (group->widget);
449 if (gtk_tool_item_group_get_n_items (group->widget))
451 if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)
452 size = _gtk_tool_item_group_get_height_for_width (group->widget, child_allocation.width);
454 size = _gtk_tool_item_group_get_width_for_height (group->widget, child_allocation.height);
456 if (group->expand && !gtk_tool_item_group_get_collapsed (group->widget))
457 n_expand_groups += 1;
462 remaining_space -= size;
463 group_sizes[i] = size;
465 /* if the widget is currently expanding an offset which allows to display as much of the
466 * widget as possible is calculated */
467 if (widget == palette->priv->expanding_child)
470 GTK_ORIENTATION_VERTICAL == palette->priv->orientation ?
471 child_allocation.width : child_allocation.height;
478 for (j = 0; j < i; ++j)
479 min_offset += group_sizes[j];
481 max_offset = min_offset + group_sizes[i];
483 real_size = _gtk_tool_item_group_get_size_for_limit
484 (GTK_TOOL_ITEM_GROUP (widget), limit,
485 GTK_ORIENTATION_VERTICAL == palette->priv->orientation,
488 if (size == real_size)
489 palette->priv->expanding_child = NULL;
493 if (n_expand_groups > 0)
495 remaining_space = MAX (0, remaining_space);
496 expand_space = remaining_space / n_expand_groups;
499 if (max_offset != -1)
502 GTK_ORIENTATION_VERTICAL == palette->priv->orientation ?
503 allocation->height : allocation->width;
505 offset = MIN (MAX (offset, max_offset - limit), min_offset);
508 if (remaining_space > 0)
512 child_allocation.y = border_width;
514 if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)
515 child_allocation.y -= offset;
519 /* allocate all groups at the calculated positions */
520 for (i = 0; i < palette->priv->groups_length; ++i)
522 GtkToolItemGroupInfo *group = &palette->priv->groups[i];
528 widget = GTK_WIDGET (group->widget);
530 if (gtk_tool_item_group_get_n_items (group->widget))
532 gint size = group_sizes[i];
534 if (group->expand && !gtk_tool_item_group_get_collapsed (group->widget))
536 size += MIN (expand_space, remaining_space);
537 remaining_space -= expand_space;
540 if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)
541 child_allocation.height = size;
543 child_allocation.width = size;
545 if (GTK_ORIENTATION_HORIZONTAL == palette->priv->orientation &&
546 GTK_TEXT_DIR_RTL == direction)
547 child_allocation.x = allocation->width - x - child_allocation.width;
549 child_allocation.x = x;
551 gtk_widget_size_allocate (widget, &child_allocation);
552 gtk_widget_show (widget);
554 if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)
555 child_allocation.y += child_allocation.height;
557 x += child_allocation.width;
560 gtk_widget_hide (widget);
563 if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation)
565 child_allocation.y += border_width;
566 child_allocation.y += offset;
568 page_start = child_allocation.y;
578 /* update the scrollbar to match the displayed adjustment */
583 adjustment->page_increment = page_size * 0.9;
584 adjustment->step_increment = page_size * 0.1;
585 adjustment->page_size = page_size;
587 if (GTK_ORIENTATION_VERTICAL == palette->priv->orientation ||
588 GTK_TEXT_DIR_LTR == direction)
590 adjustment->lower = 0;
591 adjustment->upper = MAX (0, page_start);
593 value = MIN (offset, adjustment->upper - adjustment->page_size);
594 gtk_adjustment_clamp_page (adjustment, value, offset + page_size);
598 adjustment->lower = page_size - MAX (0, page_start);
599 adjustment->upper = page_size;
603 value = MAX (offset, adjustment->lower);
604 gtk_adjustment_clamp_page (adjustment, offset, value + page_size);
607 gtk_adjustment_changed (adjustment);
612 gtk_tool_palette_expose_event (GtkWidget *widget,
613 GdkEventExpose *event)
615 GtkToolPalette *palette = GTK_TOOL_PALETTE (widget);
620 display = gdk_drawable_get_display (widget->window);
622 if (!gdk_display_supports_composite (display))
625 cr = gdk_cairo_create (widget->window);
626 gdk_cairo_region (cr, event->region);
629 cairo_push_group (cr);
631 for (i = 0; i < palette->priv->groups_length; ++i)
632 if (palette->priv->groups[i].widget)
633 _gtk_tool_item_group_paint (palette->priv->groups[i].widget, cr);
635 cairo_pop_group_to_source (cr);
644 gtk_tool_palette_realize (GtkWidget *widget)
646 const gint border_width = GTK_CONTAINER (widget)->border_width;
647 gint attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
648 GdkWindowAttr attributes;
650 attributes.window_type = GDK_WINDOW_CHILD;
651 attributes.x = widget->allocation.x + border_width;
652 attributes.y = widget->allocation.y + border_width;
653 attributes.width = widget->allocation.width - border_width * 2;
654 attributes.height = widget->allocation.height - border_width * 2;
655 attributes.wclass = GDK_INPUT_OUTPUT;
656 attributes.visual = gtk_widget_get_visual (widget);
657 attributes.colormap = gtk_widget_get_colormap (widget);
658 attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK
659 | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
660 | GDK_BUTTON_MOTION_MASK;
662 widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
663 &attributes, attributes_mask);
665 gdk_window_set_user_data (widget->window, widget);
666 widget->style = gtk_style_attach (widget->style, widget->window);
667 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
668 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
670 gtk_container_forall (GTK_CONTAINER (widget),
671 (GtkCallback) gtk_widget_set_parent_window,
674 gtk_widget_queue_resize_no_redraw (widget);
678 gtk_tool_palette_adjustment_value_changed (GtkAdjustment *adjustment G_GNUC_UNUSED,
681 GtkWidget *widget = GTK_WIDGET (data);
682 gtk_tool_palette_size_allocate (widget, &widget->allocation);
686 gtk_tool_palette_set_scroll_adjustments (GtkWidget *widget,
687 GtkAdjustment *hadjustment,
688 GtkAdjustment *vadjustment)
690 GtkToolPalette *palette = GTK_TOOL_PALETTE (widget);
692 if (palette->priv->hadjustment)
693 g_object_unref (palette->priv->hadjustment);
694 if (palette->priv->vadjustment)
695 g_object_unref (palette->priv->vadjustment);
698 g_object_ref_sink (hadjustment);
700 g_object_ref_sink (vadjustment);
702 palette->priv->hadjustment = hadjustment;
703 palette->priv->vadjustment = vadjustment;
705 if (palette->priv->hadjustment)
706 g_signal_connect (palette->priv->hadjustment, "value-changed",
707 G_CALLBACK (gtk_tool_palette_adjustment_value_changed),
709 if (palette->priv->vadjustment)
710 g_signal_connect (palette->priv->vadjustment, "value-changed",
711 G_CALLBACK (gtk_tool_palette_adjustment_value_changed),
716 gtk_tool_palette_repack (GtkToolPalette *palette)
720 for (si = di = 0; di < palette->priv->groups_length; ++si)
722 if (palette->priv->groups[si].widget)
724 palette->priv->groups[di] = palette->priv->groups[si];
728 --palette->priv->groups_length;
731 palette->priv->sparse_groups = FALSE;
735 gtk_tool_palette_add (GtkContainer *container,
738 GtkToolPalette *palette;
740 g_return_if_fail (GTK_IS_TOOL_PALETTE (container));
741 g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (child));
743 palette = GTK_TOOL_PALETTE (container);
745 if (palette->priv->groups_length == palette->priv->groups_size)
746 gtk_tool_palette_repack (palette);
748 if (palette->priv->groups_length == palette->priv->groups_size)
750 gsize old_size = palette->priv->groups_size;
751 gsize new_size = old_size * 2;
753 palette->priv->groups = g_renew (GtkToolItemGroupInfo,
754 palette->priv->groups,
757 memset (palette->priv->groups + old_size, 0,
758 sizeof (GtkToolItemGroupInfo) * old_size);
760 palette->priv->groups_size = new_size;
763 palette->priv->groups[palette->priv->groups_length].widget = g_object_ref_sink (child);
764 palette->priv->groups_length += 1;
766 gtk_widget_set_parent (child, GTK_WIDGET (palette));
770 gtk_tool_palette_remove (GtkContainer *container,
773 GtkToolPalette *palette;
776 g_return_if_fail (GTK_IS_TOOL_PALETTE (container));
777 palette = GTK_TOOL_PALETTE (container);
779 for (i = 0; i < palette->priv->groups_length; ++i)
780 if ((GtkWidget*) palette->priv->groups[i].widget == child)
782 g_object_unref (child);
783 gtk_widget_unparent (child);
785 memset (&palette->priv->groups[i], 0, sizeof (GtkToolItemGroupInfo));
786 palette->priv->sparse_groups = TRUE;
791 gtk_tool_palette_forall (GtkContainer *container,
792 gboolean internals G_GNUC_UNUSED,
793 GtkCallback callback,
794 gpointer callback_data)
796 GtkToolPalette *palette = GTK_TOOL_PALETTE (container);
799 if (palette->priv->groups)
801 for (i = 0; i < palette->priv->groups_length; ++i)
802 if (palette->priv->groups[i].widget)
803 callback (GTK_WIDGET (palette->priv->groups[i].widget),
809 gtk_tool_palette_child_type (GtkContainer *container G_GNUC_UNUSED)
811 return GTK_TYPE_TOOL_ITEM_GROUP;
815 gtk_tool_palette_set_child_property (GtkContainer *container,
821 GtkToolPalette *palette = GTK_TOOL_PALETTE (container);
825 case CHILD_PROP_EXCLUSIVE:
826 gtk_tool_palette_set_exclusive (palette, child, g_value_get_boolean (value));
829 case CHILD_PROP_EXPAND:
830 gtk_tool_palette_set_expand (palette, child, g_value_get_boolean (value));
834 GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, prop_id, pspec);
840 gtk_tool_palette_get_child_property (GtkContainer *container,
846 GtkToolPalette *palette = GTK_TOOL_PALETTE (container);
850 case CHILD_PROP_EXCLUSIVE:
851 g_value_set_boolean (value, gtk_tool_palette_get_exclusive (palette, child));
854 case CHILD_PROP_EXPAND:
855 g_value_set_boolean (value, gtk_tool_palette_get_expand (palette, child));
859 GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, prop_id, pspec);
865 style_change_notify (GtkToolPalette *palette)
867 GtkToolPalettePrivate* priv = palette->priv;
869 if (!priv->style_set)
871 /* pretend it was set, then unset, thus reverting to new default */
872 priv->style_set = TRUE;
873 gtk_tool_palette_unset_style (palette);
878 icon_size_change_notify (GtkToolPalette *palette)
880 GtkToolPalettePrivate* priv = palette->priv;
882 if (!priv->icon_size_set)
884 /* pretend it was set, then unset, thus reverting to new default */
885 priv->icon_size_set = TRUE;
886 gtk_tool_palette_unset_icon_size (palette);
891 gtk_tool_palette_settings_change_notify (GtkSettings *settings,
892 const GParamSpec *pspec,
893 GtkToolPalette *palette)
895 if (! strcmp (pspec->name, "gtk-toolbar-style"))
896 style_change_notify (palette);
897 else if (! strcmp (pspec->name, "gtk-toolbar-icon-size"))
898 icon_size_change_notify (palette);
902 gtk_tool_palette_screen_changed (GtkWidget *widget,
903 GdkScreen *previous_screen)
905 GtkToolPalette *palette = GTK_TOOL_PALETTE (widget);
906 GtkToolPalettePrivate* priv = palette->priv;
907 GtkSettings *old_settings = priv->settings;
908 GtkSettings *settings;
910 if (gtk_widget_has_screen (GTK_WIDGET (palette)))
911 settings = gtk_widget_get_settings (GTK_WIDGET (palette));
915 if (settings == old_settings)
920 g_signal_handler_disconnect (old_settings, priv->settings_connection);
921 g_object_unref (old_settings);
926 priv->settings_connection =
927 g_signal_connect (settings, "notify",
928 G_CALLBACK (gtk_tool_palette_settings_change_notify),
930 priv->settings = g_object_ref (settings);
933 priv->settings = NULL;
935 gtk_tool_palette_reconfigured (palette);
940 gtk_tool_palette_class_init (GtkToolPaletteClass *cls)
942 GObjectClass *oclass = G_OBJECT_CLASS (cls);
943 GtkWidgetClass *wclass = GTK_WIDGET_CLASS (cls);
944 GtkContainerClass *cclass = GTK_CONTAINER_CLASS (cls);
946 oclass->set_property = gtk_tool_palette_set_property;
947 oclass->get_property = gtk_tool_palette_get_property;
948 oclass->dispose = gtk_tool_palette_dispose;
949 oclass->finalize = gtk_tool_palette_finalize;
951 wclass->size_request = gtk_tool_palette_size_request;
952 wclass->size_allocate = gtk_tool_palette_size_allocate;
953 wclass->expose_event = gtk_tool_palette_expose_event;
954 wclass->realize = gtk_tool_palette_realize;
956 cclass->add = gtk_tool_palette_add;
957 cclass->remove = gtk_tool_palette_remove;
958 cclass->forall = gtk_tool_palette_forall;
959 cclass->child_type = gtk_tool_palette_child_type;
960 cclass->set_child_property = gtk_tool_palette_set_child_property;
961 cclass->get_child_property = gtk_tool_palette_get_child_property;
963 cls->set_scroll_adjustments = gtk_tool_palette_set_scroll_adjustments;
965 /* Handle screen-changed so we can update our GtkSettings.
967 wclass->screen_changed = gtk_tool_palette_screen_changed;
970 * GtkToolPalette::set-scroll-adjustments:
971 * @widget: the GtkToolPalette that received the signal
972 * @hadjustment: The horizontal adjustment
973 * @vadjustment: The vertical adjustment
975 * The ::set-scroll-adjustments when FIXME
979 wclass->set_scroll_adjustments_signal =
980 g_signal_new ("set-scroll-adjustments",
981 G_TYPE_FROM_CLASS (oclass),
982 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
983 G_STRUCT_OFFSET (GtkToolPaletteClass, set_scroll_adjustments),
985 _gtk_marshal_VOID__OBJECT_OBJECT,
988 GTK_TYPE_ADJUSTMENT);
990 g_object_class_override_property (oclass, PROP_ORIENTATION,
994 * GtkToolPalette:icon-size:
996 * The size of the icons in a tool palette is normally determined by
997 * the toolbar-icon-size setting. When this property is set, it
998 * overrides the setting.
1000 * This should only be used for special-purpose toolbars, normal
1001 * application toolbars should respect the user preferences for the
1006 g_object_class_install_property (oclass,
1008 g_param_spec_enum ("icon-size",
1010 P_("Size of icons in this tool palette"),
1013 G_PARAM_READWRITE | G_PARAM_STATIC_NAME |
1014 G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
1017 * GtkToolbar:icon-size-set:
1019 * Is %TRUE if the icon-size property has been set.
1023 g_object_class_install_property (oclass,
1025 g_param_spec_boolean ("icon-size-set",
1026 P_("Icon size set"),
1027 P_("Whether the icon-size property has been set"),
1029 G_PARAM_READWRITE | G_PARAM_STATIC_NAME |
1030 G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
1032 g_object_class_install_property (oclass, PROP_TOOLBAR_STYLE,
1033 g_param_spec_enum ("toolbar-style",
1034 P_("Toolbar Style"),
1035 P_("Style of items in the tool palette"),
1036 GTK_TYPE_TOOLBAR_STYLE,
1037 DEFAULT_TOOLBAR_STYLE,
1038 G_PARAM_READWRITE | G_PARAM_STATIC_NAME |
1039 G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
1042 gtk_container_class_install_child_property (cclass, CHILD_PROP_EXCLUSIVE,
1043 g_param_spec_boolean ("exclusive",
1045 P_("Whether the item group should be the only expanded at a given time"),
1046 DEFAULT_CHILD_EXCLUSIVE,
1047 G_PARAM_READWRITE | G_PARAM_STATIC_NAME |
1048 G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
1050 gtk_container_class_install_child_property (cclass, CHILD_PROP_EXPAND,
1051 g_param_spec_boolean ("expand",
1053 P_("Whether the item group should receive extra space when the palette grows"),
1054 DEFAULT_CHILD_EXPAND,
1055 G_PARAM_READWRITE | G_PARAM_STATIC_NAME |
1056 G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
1058 g_type_class_add_private (cls, sizeof (GtkToolPalettePrivate));
1060 dnd_target_atom_item = gdk_atom_intern_static_string (dnd_targets[0].target);
1061 dnd_target_atom_group = gdk_atom_intern_static_string (dnd_targets[1].target);
1065 * gtk_tool_palette_new:
1067 * Creates a new tool palette.
1069 * Returns: a new #GtkToolPalette.
1074 gtk_tool_palette_new (void)
1076 return g_object_new (GTK_TYPE_TOOL_PALETTE, NULL);
1080 * gtk_tool_palette_set_icon_size:
1081 * @palette: an #GtkToolPalette.
1082 * @icon_size: the #GtkIconSize that icons in the tool palette shall have.
1084 * Sets the size of icons in the tool palette.
1089 gtk_tool_palette_set_icon_size (GtkToolPalette *palette,
1090 GtkIconSize icon_size)
1092 GtkToolPalettePrivate *priv;
1094 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1095 g_return_if_fail (icon_size != GTK_ICON_SIZE_INVALID);
1097 priv = palette->priv;
1099 if (!priv->icon_size_set)
1101 priv->icon_size_set = TRUE;
1102 g_object_notify (G_OBJECT (palette), "icon-size-set");
1105 if (priv->icon_size == icon_size)
1108 priv->icon_size = icon_size;
1109 g_object_notify (G_OBJECT (palette), "icon-size");
1111 gtk_tool_palette_reconfigured (palette);
1113 gtk_widget_queue_resize (GTK_WIDGET (palette));
1116 static GtkSettings *
1117 toolpalette_get_settings (GtkToolPalette *palette)
1119 GtkToolPalettePrivate *priv = palette->priv;
1120 return priv->settings;
1124 * gtk_tool_palette_unset_icon_size:
1125 * @palette: an #GtkToolPalette.
1127 * Unsets the tool palette icon size set with gtk_tool_palette_set_icon_size(), so that
1128 * user preferences will be used to determine the icon size.
1133 gtk_tool_palette_unset_icon_size (GtkToolPalette *palette)
1135 GtkToolPalettePrivate* priv = palette->priv;
1138 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1140 if (palette->priv->icon_size_set)
1142 GtkSettings *settings = toolpalette_get_settings (palette);
1146 g_object_get (settings,
1147 "gtk-toolbar-icon-size", &size,
1151 size = DEFAULT_ICON_SIZE;
1153 if (size != palette->priv->icon_size)
1155 gtk_tool_palette_set_icon_size (palette, size);
1156 g_object_notify (G_OBJECT (palette), "icon-size");
1159 priv->icon_size_set = FALSE;
1160 g_object_notify (G_OBJECT (palette), "icon-size-set");
1164 /* Set the "toolbar-style" property and do appropriate things.
1165 * GtkToolbar does this by emiting a signal instead of just calling a function,
1166 * but I don't see how that is useful. murrayc.
1169 gtk_tool_palette_change_style (GtkToolPalette *palette,
1170 GtkToolbarStyle style)
1172 GtkToolPalettePrivate* priv = palette->priv;
1174 if (priv->style != style)
1176 priv->style = style;
1178 gtk_tool_palette_reconfigured (palette);
1180 gtk_widget_queue_resize (GTK_WIDGET (palette));
1181 g_object_notify (G_OBJECT (palette), "toolbar-style");
1187 * gtk_tool_palette_set_style:
1188 * @palette: a #GtkToolPalette.
1189 * @style: the #GtkToolbarStyle that items in the tool palette shall have.
1191 * Sets the style (text, icons or both) of items in the tool palette.
1196 gtk_tool_palette_set_style (GtkToolPalette *palette,
1197 GtkToolbarStyle style)
1199 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1201 palette->pr->style_set = TRUE;
1202 gtk_tool_palette_change_style (palette, style);
1207 * gtk_tool_palette_unset_style:
1208 * @palette: a #GtkToolPalette.
1210 * Unsets a toolbar style set with gtk_tool_palette_set_style(), so that
1211 * user preferences will be used to determine the toolbar style.
1214 gtk_tool_palette_unset_style (GtkToolPalette *palette)
1216 GtkToolPalettePrivate* priv = palette->priv;
1217 GtkToolbarStyle style;
1219 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1221 if (priv->style_set)
1223 GtkSettings *settings = toolpalette_get_settings (palette);
1226 g_object_get (settings,
1227 "gtk-toolbar-style", &style,
1230 style = DEFAULT_TOOLBAR_STYLE;
1232 if (style != priv->style)
1233 gtk_tool_palette_change_style (palette, style);
1235 priv->style_set = FALSE;
1240 * gtk_tool_palette_get_icon_size:
1241 * @palette: an #GtkToolPalette.
1243 * Gets the size of icons in the tool palette. See gtk_tool_palette_set_icon_size().
1245 * Returns: the #GtkIconSize of icons in the tool palette.
1250 gtk_tool_palette_get_icon_size (GtkToolPalette *palette)
1252 g_return_val_if_fail (GTK_IS_TOOL_PALETTE (palette), DEFAULT_ICON_SIZE);
1253 return palette->priv->icon_size;
1257 * gtk_tool_palette_get_style:
1258 * @palette: an #GtkToolPalette.
1260 * Gets the style (icons, text or both) of items in the tool palette.
1262 * Returns: the #GtkToolbarStyle of items in the tool palette.
1267 gtk_tool_palette_get_style (GtkToolPalette *palette)
1269 g_return_val_if_fail (GTK_IS_TOOL_PALETTE (palette), DEFAULT_TOOLBAR_STYLE);
1270 return palette->priv->style;
1274 * gtk_tool_palette_set_group_position:
1275 * @palette: an #GtkToolPalette.
1276 * @group: an #GtkToolItemGroup which is a child of palette.
1277 * @position: a new index for group.
1279 * Sets the position of the group as an index of the tool palette.
1280 * If position is 0 the group will become the first child, if position is
1281 * -1 it will become the last child.
1286 gtk_tool_palette_set_group_position (GtkToolPalette *palette,
1290 GtkToolItemGroupInfo group_info;
1295 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1296 g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
1298 gtk_tool_palette_repack (palette);
1300 g_return_if_fail (position >= -1);
1303 position = palette->priv->groups_length - 1;
1305 g_return_if_fail ((guint) position < palette->priv->groups_length);
1307 if (GTK_TOOL_ITEM_GROUP (group) == palette->priv->groups[position].widget)
1310 old_position = gtk_tool_palette_get_group_position (palette, group);
1311 g_return_if_fail (old_position >= 0);
1313 group_info = palette->priv->groups[old_position];
1315 if (position < old_position)
1317 dst = palette->priv->groups + position + 1;
1318 src = palette->priv->groups + position;
1319 len = old_position - position;
1323 dst = palette->priv->groups + old_position;
1324 src = palette->priv->groups + old_position + 1;
1325 len = position - old_position;
1328 memmove (dst, src, len * sizeof (*palette->priv->groups));
1329 palette->priv->groups[position] = group_info;
1331 gtk_widget_queue_resize (GTK_WIDGET (palette));
1335 gtk_tool_palette_group_notify_collapsed (GtkToolItemGroup *group,
1336 GParamSpec *pspec G_GNUC_UNUSED,
1339 GtkToolPalette *palette = GTK_TOOL_PALETTE (data);
1342 if (gtk_tool_item_group_get_collapsed (group))
1345 for (i = 0; i < palette->priv->groups_size; ++i)
1347 GtkToolItemGroup *current_group = palette->priv->groups[i].widget;
1349 if (current_group && current_group != group)
1350 gtk_tool_item_group_set_collapsed (palette->priv->groups[i].widget, TRUE);
1355 * gtk_tool_palette_set_exclusive:
1356 * @palette: an #GtkToolPalette.
1357 * @group: an #GtkToolItemGroup which is a child of palette.
1358 * @exclusive: whether the group should be exclusive or not.
1360 * Sets whether the group should be exclusive or not. If an exclusive group is expanded
1361 * all other groups are collapsed.
1366 gtk_tool_palette_set_exclusive (GtkToolPalette *palette,
1370 GtkToolItemGroupInfo *group_info;
1373 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1374 g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
1376 position = gtk_tool_palette_get_group_position (palette, group);
1377 g_return_if_fail (position >= 0);
1379 group_info = &palette->priv->groups[position];
1381 if (exclusive == group_info->exclusive)
1384 group_info->exclusive = exclusive;
1386 if (group_info->exclusive != (0 != group_info->notify_collapsed))
1388 if (group_info->exclusive)
1390 group_info->notify_collapsed =
1391 g_signal_connect (group, "notify::collapsed",
1392 G_CALLBACK (gtk_tool_palette_group_notify_collapsed),
1397 g_signal_handler_disconnect (group, group_info->notify_collapsed);
1398 group_info->notify_collapsed = 0;
1402 gtk_tool_palette_group_notify_collapsed (group_info->widget, NULL, palette);
1403 gtk_widget_child_notify (group, "exclusive");
1407 * gtk_tool_palette_set_expand:
1408 * @palette: an #GtkToolPalette.
1409 * @group: an #GtkToolItemGroup which is a child of palette.
1410 * @expand: whether the group should be given extra space.
1412 * Sets whether the group should be given extra space.
1417 gtk_tool_palette_set_expand (GtkToolPalette *palette,
1421 GtkToolItemGroupInfo *group_info;
1424 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1425 g_return_if_fail (GTK_IS_TOOL_ITEM_GROUP (group));
1427 position = gtk_tool_palette_get_group_position (palette, group);
1428 g_return_if_fail (position >= 0);
1430 group_info = &palette->priv->groups[position];
1432 if (expand != group_info->expand)
1434 group_info->expand = expand;
1435 gtk_widget_queue_resize (GTK_WIDGET (palette));
1436 gtk_widget_child_notify (group, "expand");
1441 * gtk_tool_palette_get_group_position:
1442 * @palette: an #GtkToolPalette.
1443 * @group: an #GtkToolItemGroup.
1445 * Gets the position of @group in @palette as index. see gtk_tool_palette_set_group_position().
1447 * Returns: the index of group or -1 if @group is not a child of @palette.
1452 gtk_tool_palette_get_group_position (GtkToolPalette *palette,
1457 g_return_val_if_fail (GTK_IS_TOOL_PALETTE (palette), -1);
1458 g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), -1);
1460 for (i = 0; i < palette->priv->groups_length; ++i)
1461 if ((gpointer) group == palette->priv->groups[i].widget)
1468 * gtk_tool_palette_get_exclusive:
1469 * @palette: an #GtkToolPalette.
1470 * @group: an #GtkToolItemGroup which is a child of palette.
1472 * Gets whether group is exclusive or not. See gtk_tool_palette_set_exclusive().
1474 * Returns: %TRUE if group is exclusive.
1479 gtk_tool_palette_get_exclusive (GtkToolPalette *palette,
1484 g_return_val_if_fail (GTK_IS_TOOL_PALETTE (palette), DEFAULT_CHILD_EXCLUSIVE);
1485 g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), DEFAULT_CHILD_EXCLUSIVE);
1487 position = gtk_tool_palette_get_group_position (palette, group);
1488 g_return_val_if_fail (position >= 0, DEFAULT_CHILD_EXCLUSIVE);
1490 return palette->priv->groups[position].exclusive;
1494 * gtk_tool_palette_get_expand:
1495 * @palette: an #GtkToolPalette.
1496 * @group: an #GtkToolItemGroup which is a child of palette.
1498 * Gets whether group should be given extra space. See gtk_tool_palette_set_expand().
1500 * Returns: %TRUE if group should be given extra space, %FALSE otherwise.
1505 gtk_tool_palette_get_expand (GtkToolPalette *palette,
1510 g_return_val_if_fail (GTK_IS_TOOL_PALETTE (palette), DEFAULT_CHILD_EXPAND);
1511 g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (group), DEFAULT_CHILD_EXPAND);
1513 position = gtk_tool_palette_get_group_position (palette, group);
1514 g_return_val_if_fail (position >= 0, DEFAULT_CHILD_EXPAND);
1516 return palette->priv->groups[position].expand;
1520 * gtk_tool_palette_get_drop_item:
1521 * @palette: an #GtkToolPalette.
1522 * @x: the x position.
1523 * @y: the y position.
1525 * Gets the item at position (x, y). See gtk_tool_palette_get_drop_group().
1527 * Returns: the #GtkToolItem at position or %NULL if there is no such item.
1532 gtk_tool_palette_get_drop_item (GtkToolPalette *palette,
1536 GtkWidget *group = gtk_tool_palette_get_drop_group (palette, x, y);
1539 return gtk_tool_item_group_get_drop_item (GTK_TOOL_ITEM_GROUP (group),
1540 x - group->allocation.x,
1541 y - group->allocation.y);
1547 * gtk_tool_palette_get_drop_group:
1548 * @palette: an #GtkToolPalette.
1549 * @x: the x position.
1550 * @y: the y position.
1552 * Gets the group at position (x, y).
1554 * Returns: the #GtkToolItemGroup at position or %NULL if there is no such group.
1559 gtk_tool_palette_get_drop_group (GtkToolPalette *palette,
1563 GtkAllocation *allocation;
1566 g_return_val_if_fail (GTK_IS_TOOL_PALETTE (palette), NULL);
1568 allocation = >K_WIDGET (palette)->allocation;
1570 g_return_val_if_fail (x >= 0 && x < allocation->width, NULL);
1571 g_return_val_if_fail (y >= 0 && y < allocation->height, NULL);
1573 for (i = 0; i < palette->priv->groups_length; ++i)
1575 GtkToolItemGroupInfo *group = &palette->priv->groups[i];
1582 widget = GTK_WIDGET (group->widget);
1584 x0 = x - widget->allocation.x;
1585 y0 = y - widget->allocation.y;
1587 if (x0 >= 0 && x0 < widget->allocation.width &&
1588 y0 >= 0 && y0 < widget->allocation.height)
1596 * gtk_tool_palette_get_drag_item:
1597 * @palette: an #GtkToolPalette.
1598 * @selection: a #GtkSelectionData.
1600 * Get the dragged item from the selection. This could be a #GtkToolItem or
1601 * an #GtkToolItemGroup.
1603 * Returns: the dragged item in selection.
1608 gtk_tool_palette_get_drag_item (GtkToolPalette *palette,
1609 const GtkSelectionData *selection)
1611 GtkToolPaletteDragData *data;
1613 g_return_val_if_fail (GTK_IS_TOOL_PALETTE (palette), NULL);
1614 g_return_val_if_fail (NULL != selection, NULL);
1616 g_return_val_if_fail (selection->format == 8, NULL);
1617 g_return_val_if_fail (selection->length == sizeof (GtkToolPaletteDragData), NULL);
1618 g_return_val_if_fail (selection->target == dnd_target_atom_item ||
1619 selection->target == dnd_target_atom_group,
1622 data = (GtkToolPaletteDragData*) selection->data;
1624 g_return_val_if_fail (data->palette == palette, NULL);
1626 if (dnd_target_atom_item == selection->target)
1627 g_return_val_if_fail (GTK_IS_TOOL_ITEM (data->item), NULL);
1628 else if (dnd_target_atom_group == selection->target)
1629 g_return_val_if_fail (GTK_IS_TOOL_ITEM_GROUP (data->item), NULL);
1635 * gtk_tool_palette_set_drag_source:
1636 * @palette: an #GtkToolPalette.
1637 * @targets: the #GtkToolPaletteDragTargets which the widget should support.
1639 * Sets the tool palette as a drag source. Enables all groups and items in
1640 * the tool palette as drag sources on button 1 and button 3 press with copy
1643 * See gtk_drag_source_set().
1649 gtk_tool_palette_set_drag_source (GtkToolPalette *palette,
1650 GtkToolPaletteDragTargets targets)
1654 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1656 if ((palette->priv->drag_source & targets) == targets)
1659 palette->priv->drag_source |= targets;
1661 for (i = 0; i < palette->priv->groups_length; ++i)
1663 if (palette->priv->groups[i].widget)
1664 gtk_container_forall (GTK_CONTAINER (palette->priv->groups[i].widget),
1665 _gtk_tool_palette_child_set_drag_source,
1671 * gtk_tool_palette_add_drag_dest:
1672 * @palette: an #GtkToolPalette.
1673 * @widget: a #GtkWidget which should be a drag destination for palette.
1674 * @flags: the flags that specify what actions GTK+ should take for drops on that widget.
1675 * @targets: the #GtkToolPaletteDragTargets which the widget should support.
1676 * @actions: the #GdkDragAction<!-- -->s which the widget should suppport.
1678 * Sets the tool palette as drag source (see gtk_tool_palette_set_drag_source) and
1679 * sets widget as a drag destination for drags from palette. With flags the actions
1680 * (like highlighting and target checking) which should be performed by GTK+ for
1681 * drops on widget can be specified. With targets the supported drag targets
1682 * (groups and/or items) can be specified. With actions the supported drag actions
1683 * (copy and move) can be specified.
1685 * See gtk_drag_dest_set().
1690 gtk_tool_palette_add_drag_dest (GtkToolPalette *palette,
1692 GtkDestDefaults flags,
1693 GtkToolPaletteDragTargets targets,
1694 GdkDragAction actions)
1696 GtkTargetEntry entries[G_N_ELEMENTS (dnd_targets)];
1699 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1700 g_return_if_fail (GTK_IS_WIDGET (widget));
1702 gtk_tool_palette_set_drag_source (palette,
1705 if (targets & GTK_TOOL_PALETTE_DRAG_ITEMS)
1706 entries[n_entries++] = dnd_targets[0];
1707 if (targets & GTK_TOOL_PALETTE_DRAG_GROUPS)
1708 entries[n_entries++] = dnd_targets[1];
1710 gtk_drag_dest_set (widget, flags, entries, n_entries, actions);
1714 _gtk_tool_palette_get_item_size (GtkToolPalette *palette,
1715 GtkRequisition *item_size,
1716 gboolean homogeneous_only,
1717 gint *requested_rows)
1719 GtkRequisition max_requisition;
1723 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1724 g_return_if_fail (NULL != item_size);
1726 max_requisition.width = 0;
1727 max_requisition.height = 0;
1730 /* iterate over all groups and calculate the max item_size and max row request */
1731 for (i = 0; i < palette->priv->groups_length; ++i)
1733 GtkRequisition requisition;
1735 GtkToolItemGroupInfo *group = &palette->priv->groups[i];
1740 _gtk_tool_item_group_item_size_request (group->widget, &requisition, homogeneous_only, &rows);
1742 max_requisition.width = MAX (max_requisition.width, requisition.width);
1743 max_requisition.height = MAX (max_requisition.height, requisition.height);
1744 max_rows = MAX (max_rows, rows);
1747 *item_size = max_requisition;
1749 *requested_rows = max_rows;
1753 gtk_tool_palette_item_drag_data_get (GtkWidget *widget,
1754 GdkDragContext *context G_GNUC_UNUSED,
1755 GtkSelectionData *selection,
1756 guint info G_GNUC_UNUSED,
1757 guint time G_GNUC_UNUSED,
1760 GtkToolPaletteDragData drag_data = { GTK_TOOL_PALETTE (data), NULL };
1762 if (selection->target == dnd_target_atom_item)
1763 drag_data.item = gtk_widget_get_ancestor (widget, GTK_TYPE_TOOL_ITEM);
1766 gtk_selection_data_set (selection, selection->target, 8,
1767 (guchar*) &drag_data, sizeof (drag_data));
1771 gtk_tool_palette_child_drag_data_get (GtkWidget *widget,
1772 GdkDragContext *context G_GNUC_UNUSED,
1773 GtkSelectionData *selection,
1774 guint info G_GNUC_UNUSED,
1775 guint time G_GNUC_UNUSED,
1778 GtkToolPaletteDragData drag_data = { GTK_TOOL_PALETTE (data), NULL };
1780 if (selection->target == dnd_target_atom_group)
1781 drag_data.item = gtk_widget_get_ancestor (widget, GTK_TYPE_TOOL_ITEM_GROUP);
1784 gtk_selection_data_set (selection, selection->target, 8,
1785 (guchar*) &drag_data, sizeof (drag_data));
1789 _gtk_tool_palette_child_set_drag_source (GtkWidget *child,
1792 GtkToolPalette *palette = GTK_TOOL_PALETTE (data);
1794 /* Check drag_source,
1795 * to work properly when called from gtk_tool_item_group_insert().
1797 if (!palette->priv->drag_source)
1800 if (GTK_IS_TOOL_ITEM (child) &&
1801 (palette->priv->drag_source & GTK_TOOL_PALETTE_DRAG_ITEMS))
1803 /* Connect to child instead of the item itself,
1804 * to work arround bug 510377.
1806 if (GTK_IS_TOOL_BUTTON (child))
1807 child = gtk_bin_get_child (GTK_BIN (child));
1812 gtk_drag_source_set (child, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
1813 &dnd_targets[0], 1, GDK_ACTION_COPY | GDK_ACTION_MOVE);
1815 g_signal_connect (child, "drag-data-get",
1816 G_CALLBACK (gtk_tool_palette_item_drag_data_get),
1819 else if (GTK_IS_BUTTON (child) &&
1820 (palette->priv->drag_source & GTK_TOOL_PALETTE_DRAG_GROUPS))
1822 gtk_drag_source_set (child, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
1823 &dnd_targets[1], 1, GDK_ACTION_COPY | GDK_ACTION_MOVE);
1825 g_signal_connect (child, "drag-data-get",
1826 G_CALLBACK (gtk_tool_palette_child_drag_data_get),
1832 * gtk_tool_palette_get_drag_target_item:
1834 * Get the target entry for a dragged #GtkToolItem.
1836 * Returns: the #GtkTargetEntry for a dragged item.
1840 G_CONST_RETURN GtkTargetEntry*
1841 gtk_tool_palette_get_drag_target_item (void)
1843 return &dnd_targets[0];
1847 * gtk_tool_palette_get_drag_target_group:
1849 * Get the target entry for a dragged #GtkToolItemGroup.
1851 * Returns: the #GtkTargetEntry for a dragged group.
1855 G_CONST_RETURN GtkTargetEntry*
1856 gtk_tool_palette_get_drag_target_group (void)
1858 return &dnd_targets[1];
1862 _gtk_tool_palette_set_expanding_child (GtkToolPalette *palette,
1865 g_return_if_fail (GTK_IS_TOOL_PALETTE (palette));
1866 palette->priv->expanding_child = widget;
1870 gtk_tool_palette_get_hadjustment (GtkToolPalette *palette)
1872 g_return_val_if_fail (GTK_IS_TOOL_PALETTE (palette), NULL);
1873 return palette->priv->hadjustment;
1877 gtk_tool_palette_get_vadjustment (GtkToolPalette *palette)
1879 g_return_val_if_fail (GTK_IS_TOOL_PALETTE (palette), NULL);
1880 return palette->priv->vadjustment;
1884 _gtk_tool_palette_get_size_group (GtkToolPalette *palette)
1886 g_return_val_if_fail (GTK_IS_TOOL_PALETTE (palette), NULL);
1888 return palette->priv->text_size_group;