dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Some dock refactoring which separates the docking logic from active image 

2005-05-11  Michael Natterer  <mitch@gimp.org>

	Some dock refactoring which separates the docking logic from
	active image and UI manager stuff:

	* app/widgets/gimpmenudock.[ch]: new widget renamed from
	GimpImageDock, zero changes except the name change.

	* app/widgets/gimpimagedock.[ch]: new widget derived from
	GimpDock. Keeps the UI manager.

	* app/widgets/gimpdock.[ch]: removed the UI manager. GimpDock only
	contains the basic docking logic again.

	* app/widgets/gimpmenudock.[ch]
	* app/widgets/gimptoolbox.[ch]: derive them from GimpImageDock.

	* app/widgets/Makefile.am
	* app/widgets/widgets-types.h
	* app/actions/dialogs-commands.c
	* app/actions/dock-actions.c
	* app/actions/dock-commands.c
	* app/actions/dockable-commands.c
	* app/dialogs/dialogs-constructors.c: changed accordingly.
This commit is contained in:
Michael Natterer 2005-05-11 20:26:12 +00:00 committed by Michael Natterer
parent 5c4278d003
commit 1f1305c372
16 changed files with 370 additions and 930 deletions

25
ChangeLog
View File

@ -1,3 +1,28 @@
2005-05-11 Michael Natterer <mitch@gimp.org>
Some dock refactoring which separates the docking logic from
active image and UI manager stuff:
* app/widgets/gimpmenudock.[ch]: new widget renamed from
GimpImageDock, zero changes except the name change.
* app/widgets/gimpimagedock.[ch]: new widget derived from
GimpDock. Keeps the UI manager.
* app/widgets/gimpdock.[ch]: removed the UI manager. GimpDock only
contains the basic docking logic again.
* app/widgets/gimpmenudock.[ch]
* app/widgets/gimptoolbox.[ch]: derive them from GimpImageDock.
* app/widgets/Makefile.am
* app/widgets/widgets-types.h
* app/actions/dialogs-commands.c
* app/actions/dock-actions.c
* app/actions/dock-commands.c
* app/actions/dockable-commands.c
* app/dialogs/dialogs-constructors.c: changed accordingly.
2005-05-11 Sven Neumann <sven@gimp.org>
* app/display/gimpdisplayshell-scale.c (gimp_display_shell_scale):

4
app/actions/dialogs-commands.c
View File

@ -31,7 +31,7 @@
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpdockable.h"
#include "widgets/gimpdockbook.h"
#include "widgets/gimpimagedock.h"
#include "widgets/gimpmenudock.h"
#include "dialogs/dialogs.h"
@ -176,7 +176,7 @@ dialogs_create_dock (GdkScreen *screen,
dock = gimp_dialog_factory_dock_new (global_dock_factory, screen);
gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dock), show_image_menu);
gimp_menu_dock_set_show_image_menu (GIMP_MENU_DOCK (dock), show_image_menu);
dockbook = gimp_dockbook_new (global_dock_factory->menu_factory);

14
app/actions/dock-actions.c
View File

@ -26,7 +26,7 @@
#include "widgets/gimpactiongroup.h"
#include "widgets/gimphelp-ids.h"
#include "widgets/gimpimagedock.h"
#include "widgets/gimpmenudock.h"
#include "actions.h"
#include "dock-actions.h"
@ -84,8 +84,8 @@ void
dock_actions_update (GimpActionGroup *group,
gpointer data)
{
GtkWidget *widget = action_data_get_widget (data);
GtkWidget *toplevel = NULL;
GtkWidget *widget = action_data_get_widget (data);
GtkWidget *toplevel = NULL;
if (widget)
toplevel = gtk_widget_get_toplevel (widget);
@ -95,15 +95,15 @@ dock_actions_update (GimpActionGroup *group,
#define SET_VISIBLE(action,active) \
gimp_action_group_set_action_visible (group, action, (active) != 0)
if (GIMP_IS_IMAGE_DOCK (toplevel))
if (GIMP_IS_MENU_DOCK (toplevel))
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (toplevel);
GimpMenuDock *menu_dock = GIMP_MENU_DOCK (toplevel);
SET_VISIBLE ("dock-show-image-menu", TRUE);
SET_VISIBLE ("dock-auto-follow-active", TRUE);
SET_ACTIVE ("dock-show-image-menu", image_dock->show_image_menu);
SET_ACTIVE ("dock-auto-follow-active", image_dock->auto_follow_active);
SET_ACTIVE ("dock-show-image-menu", menu_dock->show_image_menu);
SET_ACTIVE ("dock-auto-follow-active", menu_dock->auto_follow_active);
}
else
{

10
app/actions/dock-commands.c
View File

@ -24,7 +24,7 @@
#include "actions-types.h"
#include "widgets/gimpimagedock.h"
#include "widgets/gimpmenudock.h"
#include "actions.h"
#include "dock-commands.h"
@ -94,8 +94,8 @@ dock_toggle_image_menu_cmd_callback (GtkAction *action,
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
if (GIMP_IS_IMAGE_DOCK (widget))
gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (widget), active);
if (GIMP_IS_MENU_DOCK (widget))
gimp_menu_dock_set_show_image_menu (GIMP_MENU_DOCK (widget), active);
}
void
@ -111,6 +111,6 @@ dock_toggle_auto_cmd_callback (GtkAction *action,
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
if (GIMP_IS_IMAGE_DOCK (widget))
gimp_image_dock_set_auto_follow_active (GIMP_IMAGE_DOCK (widget), active);
if (GIMP_IS_MENU_DOCK (widget))
gimp_menu_dock_set_auto_follow_active (GIMP_MENU_DOCK (widget), active);
}

2
app/actions/dockable-commands.c
View File

@ -29,9 +29,9 @@
#include "widgets/gimpcontainerview.h"
#include "widgets/gimpcontainerview-utils.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpdock.h"
#include "widgets/gimpdockable.h"
#include "widgets/gimpdockbook.h"
#include "widgets/gimpimagedock.h"
#include "widgets/gimpsessioninfo.h"
#include "dialogs/dialogs.h"

8
app/dialogs/dialogs-constructors.c
View File

@ -52,9 +52,9 @@
#include "widgets/gimpgradienteditor.h"
#include "widgets/gimphelp-ids.h"
#include "widgets/gimphistogrameditor.h"
#include "widgets/gimpimagedock.h"
#include "widgets/gimpimageview.h"
#include "widgets/gimplayertreeview.h"
#include "widgets/gimpmenudock.h"
#include "widgets/gimppaletteeditor.h"
#include "widgets/gimppatternfactoryview.h"
#include "widgets/gimpsamplepointeditor.h"
@ -196,9 +196,9 @@ dialogs_dock_new (GimpDialogFactory *factory,
GimpContext *context,
gint preview_size)
{
return gimp_image_dock_new (factory,
context->gimp->images,
context->gimp->displays);
return gimp_menu_dock_new (factory,
context->gimp->images,
context->gimp->displays);
}

2
app/widgets/Makefile.am
View File

@ -173,6 +173,8 @@ libappwidgets_a_sources = \
gimpitemtreeview.h \
gimplayertreeview.c \
gimplayertreeview.h \
gimpmenudock.c \
gimpmenudock.h \
gimpmenufactory.c \
gimpmenufactory.h \
gimpmessagebox.c \

92
app/widgets/gimpdock.c
View File

@ -2,7 +2,7 @@
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpdock.c
* Copyright (C) 2001-2003 Michael Natterer <mitch@gimp.org>
* Copyright (C) 2001-2005 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -30,7 +30,6 @@
#include "config/gimpguiconfig.h"
#include "core/gimp.h"
#include "core/gimpcontainer.h"
#include "core/gimpcontext.h"
#include "core/gimpmarshal.h"
@ -40,10 +39,8 @@
#include "gimpdockable.h"
#include "gimpdockbook.h"
#include "gimphelp-ids.h"
#include "gimpmenufactory.h"
#include "gimpmessagebox.h"
#include "gimpmessagedialog.h"
#include "gimpuimanager.h"
#include "gimpwidgets-utils.h"
#include "gimp-intl.h"
@ -97,12 +94,6 @@ static void gimp_dock_real_book_added (GimpDock *dock,
static void gimp_dock_real_book_removed (GimpDock *dock,
GimpDockbook *dockbook);
static void gimp_dock_display_changed (GimpContext *context,
GimpObject *display,
GimpDock *dock);
static void gimp_dock_image_flush (GimpImage *image,
GimpDock *dock);
static GtkWidget * gimp_dock_separator_new (GimpDock *dock);
static void gimp_dock_separator_drag_leave (GtkWidget *widget,
GdkDragContext *context,
@ -124,10 +115,7 @@ static gboolean gimp_dock_separator_drag_drop (GtkWidget *widget,
static GtkWindowClass *parent_class = NULL;
static guint dock_signals[LAST_SIGNAL] = { 0 };
static GtkTargetEntry dialog_target_table[] =
{
GIMP_TARGET_DIALOG
};
static GtkTargetEntry dialog_target_table[] = { GIMP_TARGET_DIALOG };
GType
@ -201,8 +189,6 @@ gimp_dock_class_init (GimpDockClass *klass)
klass->book_added = gimp_dock_real_book_added;
klass->book_removed = gimp_dock_real_book_removed;
klass->ui_manager_name = "<Dock>";
g_object_class_install_property (object_class, PROP_CONTEXT,
g_param_spec_object ("context", NULL, NULL,
GIMP_TYPE_CONTEXT,
@ -215,14 +201,14 @@ gimp_dock_class_init (GimpDockClass *klass)
G_PARAM_CONSTRUCT_ONLY));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("default_height",
g_param_spec_int ("default-height",
NULL, NULL,
-1,
G_MAXINT,
DEFAULT_DOCK_HEIGHT,
G_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("separator_height",
g_param_spec_int ("separator-height",
NULL, NULL,
0,
G_MAXINT,
@ -235,7 +221,8 @@ gimp_dock_init (GimpDock *dock)
{
GtkWidget *separator;
dock->context = NULL;
dock->context = NULL;
dock->dialog_factory = NULL;
gtk_window_set_role (GTK_WINDOW (dock), "gimp-dock");
gtk_window_set_resizable (GTK_WINDOW (dock), TRUE);
@ -261,7 +248,6 @@ gimp_dock_constructor (GType type,
GObject *object;
GimpDock *dock;
GimpGuiConfig *config;
GtkAccelGroup *accel_group;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
@ -274,26 +260,6 @@ gimp_dock_constructor (GType type,
gimp_window_set_hint (GTK_WINDOW (dock), config->dock_window_hint);
dock->ui_manager =
gimp_menu_factory_manager_new (dock->dialog_factory->menu_factory,
GIMP_DOCK_GET_CLASS (dock)->ui_manager_name,
dock,
config->tearoff_menus);
accel_group =
gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (dock->ui_manager));
gtk_window_add_accel_group (GTK_WINDOW (object), accel_group);
dock->image_flush_handler_id =
gimp_container_add_handler (dock->context->gimp->images, "flush",
G_CALLBACK (gimp_dock_image_flush),
dock);
g_signal_connect_object (dock->context, "display-changed",
G_CALLBACK (gimp_dock_display_changed),
dock, 0);
return object;
}
@ -349,19 +315,6 @@ gimp_dock_destroy (GtkObject *object)
while (dock->dockbooks)
gimp_dock_remove_book (dock, GIMP_DOCKBOOK (dock->dockbooks->data));
if (dock->image_flush_handler_id)
{
gimp_container_remove_handler (dock->context->gimp->images,
dock->image_flush_handler_id);
dock->image_flush_handler_id = 0;
}
if (dock->ui_manager)
{
g_object_unref (dock->ui_manager);
dock->ui_manager = NULL;
}
if (dock->context)
{
g_object_unref (dock->context);
@ -375,9 +328,9 @@ static gboolean
gimp_dock_delete_event (GtkWidget *widget,
GdkEventAny *event)
{
GimpDock *dock = GIMP_DOCK (widget);
GList *list;
GimpDock *dock = GIMP_DOCK (widget);
gboolean retval = FALSE;
GList *list;
gint n;
for (list = dock->dockbooks, n = 0; list; list = list->next)
@ -445,20 +398,18 @@ static void
gimp_dock_style_set (GtkWidget *widget,
GtkStyle *prev_style)
{
GimpDock *dock;
GimpDock *dock = GIMP_DOCK (widget);
GList *children;
GList *list;
gint default_height;
gint separator_height;
dock = GIMP_DOCK (widget);
if (GTK_WIDGET_CLASS (parent_class)->style_set)
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
gtk_widget_style_get (widget,
"default_height", &default_height,
"separator_height", &separator_height,
"default-height", &default_height,
"separator-height", &separator_height,
NULL);
gtk_window_set_default_size (GTK_WINDOW (widget), -1, default_height);
@ -713,27 +664,6 @@ gimp_dock_remove_book (GimpDock *dock,
/* private functions */
static void
gimp_dock_display_changed (GimpContext *context,
GimpObject *display,
GimpDock *dock)
{
gimp_ui_manager_update (dock->ui_manager, display);
}
static void
gimp_dock_image_flush (GimpImage *image,
GimpDock *dock)
{
if (image == gimp_context_get_image (dock->context))
{
GimpObject *display = gimp_context_get_display (dock->context);
if (display)
gimp_ui_manager_update (dock->ui_manager, display);
}
}
static GtkWidget *
gimp_dock_separator_new (GimpDock *dock)
{

7
app/widgets/gimpdock.h
View File

@ -2,7 +2,7 @@
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpdock.h
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
* Copyright (C) 2001-2005 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -43,9 +43,6 @@ struct _GimpDock
GimpDialogFactory *dialog_factory;
GimpContext *context;
GimpUIManager *ui_manager;
GQuark image_flush_handler_id;
GtkWidget *main_vbox;
GtkWidget *vbox;
@ -68,8 +65,6 @@ struct _GimpDockClass
GimpDockbook *dockbook);
void (* book_removed) (GimpDock *dock,
GimpDockbook *dockbook);
const gchar *ui_manager_name;
};

621
app/widgets/gimpimagedock.c
View File

@ -2,7 +2,7 @@
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpimagedock.c
* Copyright (C) 2001-2004 Michael Natterer <mitch@gimp.org>
* Copyright (C) 2001-2005 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -21,74 +21,36 @@
#include "config.h"
#include <string.h>
#include <gtk/gtk.h>
#include "libgimpbase/gimpbase.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "config/gimpguiconfig.h"
#include "core/gimp.h"
#include "core/gimpcontainer.h"
#include "core/gimpcontext.h"
#include "core/gimpimage.h"
#include "core/gimplist.h"
#include "core/gimptoolinfo.h"
#include "gimpdialogfactory.h"
#include "gimpimagedock.h"
#include "gimpcontainercombobox.h"
#include "gimpcontainerview.h"
#include "gimpdockable.h"
#include "gimpdockbook.h"
#include "gimphelp-ids.h"
#include "gimpsessioninfo.h"
#include "gimp-intl.h"
#include "gimpmenufactory.h"
#include "gimpuimanager.h"
#define DEFAULT_MINIMAL_WIDTH 250
#define DEFAULT_MENU_PREVIEW_SIZE GTK_ICON_SIZE_SMALL_TOOLBAR
static void gimp_image_dock_class_init (GimpImageDockClass *klass);
static void gimp_image_dock_init (GimpImageDock *dock);
static GObject * gimp_image_dock_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_image_dock_class_init (GimpImageDockClass *klass);
static void gimp_image_dock_init (GimpImageDock *dock);
static void gimp_image_dock_destroy (GtkObject *object);
static GObject * gimp_image_dock_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_image_dock_destroy (GtkObject *object);
static void gimp_image_dock_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static void gimp_image_dock_setup (GimpDock *dock,
const GimpDock *template);
static void gimp_image_dock_set_aux_info (GimpDock *dock,
GList *aux_info);
static GList *gimp_image_dock_get_aux_info (GimpDock *dock);
static void gimp_image_dock_book_added (GimpDock *dock,
GimpDockbook *dockbook);
static void gimp_image_dock_book_removed (GimpDock *dock,
GimpDockbook *dockbook);
static void gimp_image_dock_dockbook_changed (GimpDockbook *dockbook,
GimpDockable *dockable,
GimpImageDock *dock);
static void gimp_image_dock_update_title (GimpImageDock *dock);
static void gimp_image_dock_factory_display_changed (GimpContext *context,
GimpObject *display,
GimpDock *dock);
static void gimp_image_dock_factory_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock);
static void gimp_image_dock_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock);
static void gimp_image_dock_auto_clicked (GtkWidget *widget,
GimpDock *dock);
static void gimp_image_dock_display_changed (GimpContext *context,
GimpObject *display,
GimpImageDock *dock);
static void gimp_image_dock_image_flush (GimpImage *image,
GimpImageDock *dock);
static GimpDockClass *parent_class = NULL;
@ -127,8 +89,6 @@ gimp_image_dock_class_init (GimpImageDockClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GimpDockClass *dock_class = GIMP_DOCK_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
@ -136,72 +96,14 @@ gimp_image_dock_class_init (GimpImageDockClass *klass)
gtk_object_class->destroy = gimp_image_dock_destroy;
widget_class->style_set = gimp_image_dock_style_set;
dock_class->setup = gimp_image_dock_setup;
dock_class->set_aux_info = gimp_image_dock_set_aux_info;
dock_class->get_aux_info = gimp_image_dock_get_aux_info;
dock_class->book_added = gimp_image_dock_book_added;
dock_class->book_removed = gimp_image_dock_book_removed;
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("minimal-width",
NULL, NULL,
0,
G_MAXINT,
DEFAULT_MINIMAL_WIDTH,
G_PARAM_READABLE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_enum ("menu-preview-size",
NULL, NULL,
GTK_TYPE_ICON_SIZE,
DEFAULT_MENU_PREVIEW_SIZE,
G_PARAM_READABLE));
klass->ui_manager_name = "<Dock>";
}
static void
gimp_image_dock_init (GimpImageDock *dock)
{
GtkWidget *hbox;
dock->image_container = NULL;
dock->display_container = NULL;
dock->show_image_menu = FALSE;
dock->auto_follow_active = TRUE;
dock->update_title_idle_id = 0;
hbox = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (GIMP_DOCK (dock)->main_vbox), hbox,
FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (GIMP_DOCK (dock)->main_vbox), hbox, 0);
if (dock->show_image_menu)
gtk_widget_show (hbox);
dock->image_combo = gimp_container_combo_box_new (NULL, NULL, 16, 1);
gtk_box_pack_start (GTK_BOX (hbox), dock->image_combo, TRUE, TRUE, 0);
gtk_widget_show (dock->image_combo);
g_signal_connect (dock->image_combo, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&dock->image_combo);
gimp_help_set_help_data (dock->image_combo, NULL, GIMP_HELP_DOCK_IMAGE_MENU);
dock->auto_button = gtk_toggle_button_new_with_label (_("Auto"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dock->auto_button),
dock->auto_follow_active);
gtk_box_pack_start (GTK_BOX (hbox), dock->auto_button, FALSE, FALSE, 0);
gtk_widget_show (dock->auto_button);
g_signal_connect (dock->auto_button, "clicked",
G_CALLBACK (gimp_image_dock_auto_clicked),
dock);
gimp_help_set_help_data (dock->auto_button,
_("When enabled the dialog automatically "
"follows the image you are working on."),
GIMP_HELP_DOCK_AUTO_BUTTON);
dock->ui_manager = NULL;
dock->image_flush_handler_id = 0;
}
static GObject *
@ -211,11 +113,35 @@ gimp_image_dock_constructor (GType type,
{
GObject *object;
GimpImageDock *dock;
GimpGuiConfig *config;
GtkAccelGroup *accel_group;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
dock = GIMP_IMAGE_DOCK (object);
config = GIMP_GUI_CONFIG (GIMP_DOCK (dock)->context->gimp->config);
dock->ui_manager =
gimp_menu_factory_manager_new (GIMP_DOCK (dock)->dialog_factory->menu_factory,
GIMP_IMAGE_DOCK_GET_CLASS (dock)->ui_manager_name,
dock,
config->tearoff_menus);
accel_group =
gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (dock->ui_manager));
gtk_window_add_accel_group (GTK_WINDOW (object), accel_group);
dock->image_flush_handler_id =
gimp_container_add_handler (GIMP_DOCK (dock)->context->gimp->images, "flush",
G_CALLBACK (gimp_image_dock_image_flush),
dock);
g_signal_connect_object (GIMP_DOCK (dock)->context, "display-changed",
G_CALLBACK (gimp_image_dock_display_changed),
dock, 0);
return object;
}
@ -224,464 +150,39 @@ gimp_image_dock_destroy (GtkObject *object)
{
GimpImageDock *dock = GIMP_IMAGE_DOCK (object);
if (dock->update_title_idle_id)
if (dock->image_flush_handler_id)
{
g_source_remove (dock->update_title_idle_id);
dock->update_title_idle_id = 0;
gimp_container_remove_handler (GIMP_DOCK (dock)->context->gimp->images,
dock->image_flush_handler_id);
dock->image_flush_handler_id = 0;
}
/* remove the image menu and the auto button manually here because
* of weird cross-connections with GimpDock's context
*/
if (GIMP_DOCK (dock)->main_vbox &&
dock->image_combo &&
dock->image_combo->parent)
if (dock->ui_manager)
{
gtk_container_remove (GTK_CONTAINER (GIMP_DOCK (dock)->main_vbox),
dock->image_combo->parent);
g_object_unref (dock->ui_manager);
dock->ui_manager = NULL;
}
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
gimp_image_dock_style_set (GtkWidget *widget,
GtkStyle *prev_style)
gimp_image_dock_display_changed (GimpContext *context,
GimpObject *display,
GimpImageDock *dock)
{
GimpImageDock *image_dock;
gint minimal_width;
GtkIconSize menu_preview_size;
GdkScreen *screen;
gint menu_preview_width = 18;
gint menu_preview_height = 18;
gint focus_line_width;
gint focus_padding;
gint ythickness;
image_dock = GIMP_IMAGE_DOCK (widget);
if (GTK_WIDGET_CLASS (parent_class)->style_set)
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
gtk_widget_style_get (widget,
"minimal_width", &minimal_width,
"menu_preview_size", &menu_preview_size,
NULL);
screen = gtk_widget_get_screen (image_dock->image_combo);
gtk_icon_size_lookup_for_settings (gtk_settings_get_for_screen (screen),
menu_preview_size,
&menu_preview_width,
&menu_preview_height);
gtk_widget_style_get (image_dock->auto_button,
"focus_line_width", &focus_line_width,
"focus_padding", &focus_padding,
NULL);
ythickness = image_dock->auto_button->style->ythickness;
gtk_widget_set_size_request (widget, minimal_width, -1);
gimp_container_view_set_preview_size (GIMP_CONTAINER_VIEW (image_dock->image_combo),
menu_preview_height, 1);
gtk_widget_set_size_request (image_dock->auto_button, -1,
menu_preview_height +
2 * (1 /* CHILD_SPACING */ +
ythickness +
focus_padding +
focus_line_width));
gimp_ui_manager_update (dock->ui_manager, display);
}
static void
gimp_image_dock_setup (GimpDock *dock,
const GimpDock *template)
gimp_image_dock_image_flush (GimpImage *image,
GimpImageDock *dock)
{
if (GIMP_IS_IMAGE_DOCK (template))
if (image == gimp_context_get_image (GIMP_DOCK (dock)->context))
{
gboolean auto_follow_active;
gboolean show_image_menu;
GimpObject *display = gimp_context_get_display (GIMP_DOCK (dock)->context);
auto_follow_active = GIMP_IMAGE_DOCK (template)->auto_follow_active;
show_image_menu = GIMP_IMAGE_DOCK (template)->show_image_menu;
gimp_image_dock_set_auto_follow_active (GIMP_IMAGE_DOCK (dock),
auto_follow_active);
gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dock),
show_image_menu);
}
}
#define AUX_INFO_SHOW_IMAGE_MENU "show-image-menu"
#define AUX_INFO_FOLLOW_ACTIVE_IMAGE "follow-active-image"
static void
gimp_image_dock_set_aux_info (GimpDock *dock,
GList *aux_info)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
GList *list;
gboolean menu_shown = image_dock->show_image_menu;
gboolean auto_follow = image_dock->auto_follow_active;
for (list = aux_info; list; list = g_list_next (list))
{
GimpSessionInfoAux *aux = list->data;
if (! strcmp (aux->name, AUX_INFO_SHOW_IMAGE_MENU))
{
menu_shown = ! g_ascii_strcasecmp (aux->value, "true");
}
else if (! strcmp (aux->name, AUX_INFO_FOLLOW_ACTIVE_IMAGE))
{
auto_follow = ! g_ascii_strcasecmp (aux->value, "true");
}
}
if (menu_shown != image_dock->show_image_menu)
gimp_image_dock_set_show_image_menu (image_dock, menu_shown);
if (auto_follow != image_dock->auto_follow_active)
gimp_image_dock_set_auto_follow_active (image_dock, auto_follow);
}
static GList *
gimp_image_dock_get_aux_info (GimpDock *dock)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
GList *aux_info = NULL;
GimpSessionInfoAux *aux;
aux = gimp_session_info_aux_new (AUX_INFO_SHOW_IMAGE_MENU,
image_dock->show_image_menu ?
"true" : "false");
aux_info = g_list_append (aux_info, aux);
aux = gimp_session_info_aux_new (AUX_INFO_FOLLOW_ACTIVE_IMAGE,
image_dock->auto_follow_active ?
"true" : "false");
aux_info = g_list_append (aux_info, aux);
return aux_info;
}
static void
gimp_image_dock_book_added (GimpDock *dock,
GimpDockbook *dockbook)
{
g_signal_connect (dockbook, "dockable_added",
G_CALLBACK (gimp_image_dock_dockbook_changed),
dock);
g_signal_connect (dockbook, "dockable_removed",
G_CALLBACK (gimp_image_dock_dockbook_changed),
dock);
g_signal_connect (dockbook, "dockable_reordered",
G_CALLBACK (gimp_image_dock_dockbook_changed),
dock);
gimp_image_dock_update_title (GIMP_IMAGE_DOCK (dock));
GIMP_DOCK_CLASS (parent_class)->book_added (dock, dockbook);
}
static void
gimp_image_dock_book_removed (GimpDock *dock,
GimpDockbook *dockbook)
{
g_signal_handlers_disconnect_by_func (dockbook,
gimp_image_dock_dockbook_changed,
dock);
gimp_image_dock_update_title (GIMP_IMAGE_DOCK (dock));
GIMP_DOCK_CLASS (parent_class)->book_removed (dock, dockbook);
}
GtkWidget *
gimp_image_dock_new (GimpDialogFactory *dialog_factory,
GimpContainer *image_container,
GimpContainer *display_container)
{
GimpImageDock *image_dock;
GimpContext *context;
GdkScreen *screen;
gint menu_preview_width;
gint menu_preview_height;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (dialog_factory), NULL);
g_return_val_if_fail (GIMP_IS_CONTAINER (image_container), NULL);
g_return_val_if_fail (GIMP_IS_CONTAINER (display_container), NULL);
context = gimp_context_new (dialog_factory->context->gimp,
"Dock Context", NULL);
image_dock = g_object_new (GIMP_TYPE_IMAGE_DOCK,
"context", context,
"dialog-factory", dialog_factory,
NULL);
image_dock->image_container = image_container;
image_dock->display_container = display_container;
gimp_help_connect (GTK_WIDGET (image_dock), gimp_standard_help_func,
GIMP_HELP_DOCK, NULL);
gimp_context_define_properties (context,
GIMP_CONTEXT_ALL_PROPS_MASK &
~(GIMP_CONTEXT_IMAGE_MASK |
GIMP_CONTEXT_DISPLAY_MASK),
FALSE);
gimp_context_set_parent (context, dialog_factory->context);
if (image_dock->auto_follow_active)
{
if (gimp_context_get_display (dialog_factory->context))
gimp_context_copy_property (dialog_factory->context, context,
GIMP_CONTEXT_PROP_DISPLAY);
else
gimp_context_copy_property (dialog_factory->context, context,
GIMP_CONTEXT_PROP_IMAGE);
}
g_signal_connect_object (dialog_factory->context, "display_changed",
G_CALLBACK (gimp_image_dock_factory_display_changed),
image_dock,
0);
g_signal_connect_object (dialog_factory->context, "image_changed",
G_CALLBACK (gimp_image_dock_factory_image_changed),
image_dock,
0);
g_signal_connect_object (context, "image_changed",
G_CALLBACK (gimp_image_dock_image_changed),
image_dock,
0);
screen = gtk_widget_get_screen (GTK_WIDGET (image_dock));
gtk_icon_size_lookup_for_settings (gtk_settings_get_for_screen (screen),
DEFAULT_MENU_PREVIEW_SIZE,
&menu_preview_width,
&menu_preview_height);
g_object_set (image_dock->image_combo,
"container", image_container,
"context", context,
NULL);
return GTK_WIDGET (image_dock);
}
void
gimp_image_dock_set_auto_follow_active (GimpImageDock *image_dock,
gboolean auto_follow_active)
{
g_return_if_fail (GIMP_IS_IMAGE_DOCK (image_dock));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (image_dock->auto_button),
auto_follow_active ? TRUE : FALSE);
}
void
gimp_image_dock_set_show_image_menu (GimpImageDock *image_dock,
gboolean show)
{
g_return_if_fail (GIMP_IS_IMAGE_DOCK (image_dock));
if (show)
gtk_widget_show (image_dock->image_combo->parent);
else
gtk_widget_hide (image_dock->image_combo->parent);
image_dock->show_image_menu = show ? TRUE : FALSE;
}
static void
gimp_image_dock_dockbook_changed (GimpDockbook *dockbook,
GimpDockable *dockable,
GimpImageDock *dock)
{
gimp_image_dock_update_title (dock);
}
static gboolean
gimp_image_dock_update_title_idle (GimpImageDock *image_dock)
{
GString *title;
GList *list;
title = g_string_new (NULL);
for (list = GIMP_DOCK (image_dock)->dockbooks;
list;
list = g_list_next (list))
{
GimpDockbook *dockbook = list->data;
GList *children;
GList *child;
children = gtk_container_get_children (GTK_CONTAINER (dockbook));
for (child = children; child; child = g_list_next (child))
{
GimpDockable *dockable = child->data;
g_string_append (title, dockable->name);
if (g_list_next (child))
g_string_append (title, ", ");
}
g_list_free (children);
if (g_list_next (list))
g_string_append (title, " | ");
}
gtk_window_set_title (GTK_WINDOW (image_dock), title->str);
g_string_free (title, TRUE);
image_dock->update_title_idle_id = 0;
return FALSE;
}
static void
gimp_image_dock_update_title (GimpImageDock *image_dock)
{
if (image_dock->update_title_idle_id)
g_source_remove (image_dock->update_title_idle_id);
image_dock->update_title_idle_id =
g_idle_add ((GSourceFunc) gimp_image_dock_update_title_idle,
image_dock);
}
static void
gimp_image_dock_factory_display_changed (GimpContext *context,
GimpObject *display,
GimpDock *dock)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
if (display && image_dock->auto_follow_active)
gimp_context_set_display (dock->context, display);
}
static void
gimp_image_dock_factory_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
/* won't do anything if we already set the display above */
if (gimage && image_dock->auto_follow_active)
gimp_context_set_image (dock->context, gimage);
}
static void
gimp_image_dock_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
GimpContainer *image_container = image_dock->image_container;
GimpContainer *display_container = image_dock->display_container;
if (gimage == NULL && ! gimp_container_is_empty (image_container))
{
gimage = GIMP_IMAGE (gimp_container_get_child_by_index (image_container,
0));
if (gimage)
{
/* this invokes this function recursively but we don't enter
* the if() branch the second time
*/
gimp_context_set_image (context, gimage);
/* stop the emission of the original signal (the emission of
* the recursive signal is finished)
*/
g_signal_stop_emission_by_name (context, "image_changed");
}
}
else if (gimage != NULL && ! gimp_container_is_empty (display_container))
{
GimpObject *gdisp;
GimpImage *gdisp_gimage;
gboolean find_display = TRUE;
gdisp = gimp_context_get_display (context);
if (gdisp)
{
g_object_get (gdisp, "image", &gdisp_gimage, NULL);
if (gdisp_gimage)
{
g_object_unref (gdisp_gimage);
if (gdisp_gimage == gimage)
find_display = FALSE;
}
}
if (find_display)
{
GList *list;
for (list = GIMP_LIST (display_container)->list;
list;
list = g_list_next (list))
{
gdisp = GIMP_OBJECT (list->data);
g_object_get (gdisp, "image", &gdisp_gimage, NULL);
if (gdisp_gimage)
{
g_object_unref (gdisp_gimage);
if (gdisp_gimage == gimage)
{
/* this invokes this function recursively but we
* don't enter the if(find_display) branch the
* second time
*/
gimp_context_set_display (context, gdisp);
/* don't stop signal emission here because the
* context's image was not changed by the
* recursive call
*/
break;
}
}
}
}
}
}
static void
gimp_image_dock_auto_clicked (GtkWidget *widget,
GimpDock *dock)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
gimp_toggle_button_update (widget, &image_dock->auto_follow_active);
if (image_dock->auto_follow_active)
{
if (gimp_context_get_display (dock->dialog_factory->context))
gimp_context_copy_property (dock->dialog_factory->context,
dock->context,
GIMP_CONTEXT_PROP_DISPLAY);
else
gimp_context_copy_property (dock->dialog_factory->context,
dock->context,
GIMP_CONTEXT_PROP_IMAGE);
if (display)
gimp_ui_manager_update (dock->ui_manager, display);
}
}

31
app/widgets/gimpimagedock.h
View File

@ -2,7 +2,7 @@
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpimagedock.h
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
* Copyright (C) 2001-2005 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -38,36 +38,21 @@ typedef struct _GimpImageDockClass GimpImageDockClass;
struct _GimpImageDock
{
GimpDock parent_instance;
GimpDock parent_instance;
GimpContainer *image_container;
GimpContainer *display_container;
gboolean show_image_menu;
gboolean auto_follow_active;
GtkWidget *image_combo;
GtkWidget *auto_button;
guint update_title_idle_id;
GimpUIManager *ui_manager;
GQuark image_flush_handler_id;
};
struct _GimpImageDockClass
{
GimpDockClass parent_class;
GimpDockClass parent_class;
const gchar *ui_manager_name;
};
GType gimp_image_dock_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_image_dock_new (GimpDialogFactory *dialog_factory,
GimpContainer *image_container,
GimpContainer *display_container);
void gimp_image_dock_set_auto_follow_active (GimpImageDock *image_dock,
gboolean show);
void gimp_image_dock_set_show_image_menu (GimpImageDock *image_dock,
gboolean show);
GType gimp_image_dock_get_type (void) G_GNUC_CONST;
#endif /* __GIMP_IMAGE_DOCK_H__ */

362
app/widgets/gimpmenudock.c
View File

@ -1,7 +1,7 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpimagedock.c
* gimpmenudock.c
* Copyright (C) 2001-2004 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
@ -37,12 +37,12 @@
#include "core/gimptoolinfo.h"
#include "gimpdialogfactory.h"
#include "gimpimagedock.h"
#include "gimpcontainercombobox.h"
#include "gimpcontainerview.h"
#include "gimpdockable.h"
#include "gimpdockbook.h"
#include "gimphelp-ids.h"
#include "gimpmenudock.h"
#include "gimpsessioninfo.h"
#include "gimp-intl.h"
@ -52,50 +52,50 @@
#define DEFAULT_MENU_PREVIEW_SIZE GTK_ICON_SIZE_SMALL_TOOLBAR
static void gimp_image_dock_class_init (GimpImageDockClass *klass);
static void gimp_image_dock_init (GimpImageDock *dock);
static void gimp_menu_dock_class_init (GimpMenuDockClass *klass);
static void gimp_menu_dock_init (GimpMenuDock *dock);
static GObject * gimp_image_dock_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_image_dock_destroy (GtkObject *object);
static GObject * gimp_menu_dock_constructor (GType type,
guint n_params,
GObjectConstructParam *params);
static void gimp_menu_dock_destroy (GtkObject *object);
static void gimp_image_dock_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static void gimp_menu_dock_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static void gimp_image_dock_setup (GimpDock *dock,
const GimpDock *template);
static void gimp_image_dock_set_aux_info (GimpDock *dock,
GList *aux_info);
static GList *gimp_image_dock_get_aux_info (GimpDock *dock);
static void gimp_image_dock_book_added (GimpDock *dock,
GimpDockbook *dockbook);
static void gimp_image_dock_book_removed (GimpDock *dock,
GimpDockbook *dockbook);
static void gimp_menu_dock_setup (GimpDock *dock,
const GimpDock *template);
static void gimp_menu_dock_set_aux_info (GimpDock *dock,
GList *aux_info);
static GList *gimp_menu_dock_get_aux_info (GimpDock *dock);
static void gimp_menu_dock_book_added (GimpDock *dock,
GimpDockbook *dockbook);
static void gimp_menu_dock_book_removed (GimpDock *dock,
GimpDockbook *dockbook);
static void gimp_image_dock_dockbook_changed (GimpDockbook *dockbook,
GimpDockable *dockable,
GimpImageDock *dock);
static void gimp_image_dock_update_title (GimpImageDock *dock);
static void gimp_menu_dock_dockbook_changed (GimpDockbook *dockbook,
GimpDockable *dockable,
GimpMenuDock *dock);
static void gimp_menu_dock_update_title (GimpMenuDock *dock);
static void gimp_image_dock_factory_display_changed (GimpContext *context,
GimpObject *display,
GimpDock *dock);
static void gimp_image_dock_factory_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock);
static void gimp_image_dock_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock);
static void gimp_image_dock_auto_clicked (GtkWidget *widget,
GimpDock *dock);
static void gimp_menu_dock_factory_display_changed (GimpContext *context,
GimpObject *display,
GimpDock *dock);
static void gimp_menu_dock_factory_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock);
static void gimp_menu_dock_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock);
static void gimp_menu_dock_auto_clicked (GtkWidget *widget,
GimpDock *dock);
static GimpDockClass *parent_class = NULL;
GType
gimp_image_dock_get_type (void)
gimp_menu_dock_get_type (void)
{
static GType dock_type = 0;
@ -103,19 +103,19 @@ gimp_image_dock_get_type (void)
{
static const GTypeInfo dock_info =
{
sizeof (GimpImageDockClass),
sizeof (GimpMenuDockClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_image_dock_class_init,
(GClassInitFunc) gimp_menu_dock_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpImageDock),
sizeof (GimpMenuDock),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_image_dock_init,
(GInstanceInitFunc) gimp_menu_dock_init,
};
dock_type = g_type_register_static (GIMP_TYPE_DOCK,
"GimpImageDock",
dock_type = g_type_register_static (GIMP_TYPE_IMAGE_DOCK,
"GimpMenuDock",
&dock_info, 0);
}
@ -123,7 +123,7 @@ gimp_image_dock_get_type (void)
}
static void
gimp_image_dock_class_init (GimpImageDockClass *klass)
gimp_menu_dock_class_init (GimpMenuDockClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
@ -132,17 +132,17 @@ gimp_image_dock_class_init (GimpImageDockClass *klass)
parent_class = g_type_class_peek_parent (klass);
object_class->constructor = gimp_image_dock_constructor;
object_class->constructor = gimp_menu_dock_constructor;
gtk_object_class->destroy = gimp_image_dock_destroy;
gtk_object_class->destroy = gimp_menu_dock_destroy;
widget_class->style_set = gimp_image_dock_style_set;
widget_class->style_set = gimp_menu_dock_style_set;
dock_class->setup = gimp_image_dock_setup;
dock_class->set_aux_info = gimp_image_dock_set_aux_info;
dock_class->get_aux_info = gimp_image_dock_get_aux_info;
dock_class->book_added = gimp_image_dock_book_added;
dock_class->book_removed = gimp_image_dock_book_removed;
dock_class->setup = gimp_menu_dock_setup;
dock_class->set_aux_info = gimp_menu_dock_set_aux_info;
dock_class->get_aux_info = gimp_menu_dock_get_aux_info;
dock_class->book_added = gimp_menu_dock_book_added;
dock_class->book_removed = gimp_menu_dock_book_removed;
gtk_widget_class_install_style_property (widget_class,
g_param_spec_int ("minimal-width",
@ -160,7 +160,7 @@ gimp_image_dock_class_init (GimpImageDockClass *klass)
}
static void
gimp_image_dock_init (GimpImageDock *dock)
gimp_menu_dock_init (GimpMenuDock *dock)
{
GtkWidget *hbox;
@ -195,7 +195,7 @@ gimp_image_dock_init (GimpImageDock *dock)
gtk_widget_show (dock->auto_button);
g_signal_connect (dock->auto_button, "clicked",
G_CALLBACK (gimp_image_dock_auto_clicked),
G_CALLBACK (gimp_menu_dock_auto_clicked),
dock);
gimp_help_set_help_data (dock->auto_button,
@ -205,24 +205,24 @@ gimp_image_dock_init (GimpImageDock *dock)
}
static GObject *
gimp_image_dock_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
gimp_menu_dock_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
GimpImageDock *dock;
GObject *object;
GimpMenuDock *dock;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
dock = GIMP_IMAGE_DOCK (object);
dock = GIMP_MENU_DOCK (object);
return object;
}
static void
gimp_image_dock_destroy (GtkObject *object)
gimp_menu_dock_destroy (GtkObject *object)
{
GimpImageDock *dock = GIMP_IMAGE_DOCK (object);
GimpMenuDock *dock = GIMP_MENU_DOCK (object);
if (dock->update_title_idle_id)
{
@ -245,20 +245,20 @@ gimp_image_dock_destroy (GtkObject *object)
}
static void
gimp_image_dock_style_set (GtkWidget *widget,
GtkStyle *prev_style)
gimp_menu_dock_style_set (GtkWidget *widget,
GtkStyle *prev_style)
{
GimpImageDock *image_dock;
gint minimal_width;
GtkIconSize menu_preview_size;
GdkScreen *screen;
gint menu_preview_width = 18;
gint menu_preview_height = 18;
gint focus_line_width;
gint focus_padding;
gint ythickness;
GimpMenuDock *menu_dock;
gint minimal_width;
GtkIconSize menu_preview_size;
GdkScreen *screen;
gint menu_preview_width = 18;
gint menu_preview_height = 18;
gint focus_line_width;
gint focus_padding;
gint ythickness;
image_dock = GIMP_IMAGE_DOCK (widget);
menu_dock = GIMP_MENU_DOCK (widget);
if (GTK_WIDGET_CLASS (parent_class)->style_set)
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
@ -268,25 +268,25 @@ gimp_image_dock_style_set (GtkWidget *widget,
"menu_preview_size", &menu_preview_size,
NULL);
screen = gtk_widget_get_screen (image_dock->image_combo);
screen = gtk_widget_get_screen (menu_dock->image_combo);
gtk_icon_size_lookup_for_settings (gtk_settings_get_for_screen (screen),
menu_preview_size,
&menu_preview_width,
&menu_preview_height);
gtk_widget_style_get (image_dock->auto_button,
gtk_widget_style_get (menu_dock->auto_button,
"focus_line_width", &focus_line_width,
"focus_padding", &focus_padding,
NULL);
ythickness = image_dock->auto_button->style->ythickness;
ythickness = menu_dock->auto_button->style->ythickness;
gtk_widget_set_size_request (widget, minimal_width, -1);
gimp_container_view_set_preview_size (GIMP_CONTAINER_VIEW (image_dock->image_combo),
gimp_container_view_set_preview_size (GIMP_CONTAINER_VIEW (menu_dock->image_combo),
menu_preview_height, 1);
gtk_widget_set_size_request (image_dock->auto_button, -1,
gtk_widget_set_size_request (menu_dock->auto_button, -1,
menu_preview_height +
2 * (1 /* CHILD_SPACING */ +
ythickness +
@ -295,21 +295,21 @@ gimp_image_dock_style_set (GtkWidget *widget,
}
static void
gimp_image_dock_setup (GimpDock *dock,
const GimpDock *template)
gimp_menu_dock_setup (GimpDock *dock,
const GimpDock *template)
{
if (GIMP_IS_IMAGE_DOCK (template))
if (GIMP_IS_MENU_DOCK (template))
{
gboolean auto_follow_active;
gboolean show_image_menu;
auto_follow_active = GIMP_IMAGE_DOCK (template)->auto_follow_active;
show_image_menu = GIMP_IMAGE_DOCK (template)->show_image_menu;
auto_follow_active = GIMP_MENU_DOCK (template)->auto_follow_active;
show_image_menu = GIMP_MENU_DOCK (template)->show_image_menu;
gimp_image_dock_set_auto_follow_active (GIMP_IMAGE_DOCK (dock),
auto_follow_active);
gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dock),
show_image_menu);
gimp_menu_dock_set_auto_follow_active (GIMP_MENU_DOCK (dock),
auto_follow_active);
gimp_menu_dock_set_show_image_menu (GIMP_MENU_DOCK (dock),
show_image_menu);
}
}
@ -317,13 +317,13 @@ gimp_image_dock_setup (GimpDock *dock,
#define AUX_INFO_FOLLOW_ACTIVE_IMAGE "follow-active-image"
static void
gimp_image_dock_set_aux_info (GimpDock *dock,
GList *aux_info)
gimp_menu_dock_set_aux_info (GimpDock *dock,
GList *aux_info)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
GList *list;
gboolean menu_shown = image_dock->show_image_menu;
gboolean auto_follow = image_dock->auto_follow_active;
GimpMenuDock *menu_dock = GIMP_MENU_DOCK (dock);
GList *list;
gboolean menu_shown = menu_dock->show_image_menu;
gboolean auto_follow = menu_dock->auto_follow_active;
for (list = aux_info; list; list = g_list_next (list))
{
@ -339,27 +339,27 @@ gimp_image_dock_set_aux_info (GimpDock *dock,
}
}
if (menu_shown != image_dock->show_image_menu)
gimp_image_dock_set_show_image_menu (image_dock, menu_shown);
if (menu_shown != menu_dock->show_image_menu)
gimp_menu_dock_set_show_image_menu (menu_dock, menu_shown);
if (auto_follow != image_dock->auto_follow_active)
gimp_image_dock_set_auto_follow_active (image_dock, auto_follow);
if (auto_follow != menu_dock->auto_follow_active)
gimp_menu_dock_set_auto_follow_active (menu_dock, auto_follow);
}
static GList *
gimp_image_dock_get_aux_info (GimpDock *dock)
gimp_menu_dock_get_aux_info (GimpDock *dock)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
GList *aux_info = NULL;
GimpMenuDock *menu_dock = GIMP_MENU_DOCK (dock);
GList *aux_info = NULL;
GimpSessionInfoAux *aux;
aux = gimp_session_info_aux_new (AUX_INFO_SHOW_IMAGE_MENU,
image_dock->show_image_menu ?
menu_dock->show_image_menu ?
"true" : "false");
aux_info = g_list_append (aux_info, aux);
aux = gimp_session_info_aux_new (AUX_INFO_FOLLOW_ACTIVE_IMAGE,
image_dock->auto_follow_active ?
menu_dock->auto_follow_active ?
"true" : "false");
aux_info = g_list_append (aux_info, aux);
@ -367,47 +367,47 @@ gimp_image_dock_get_aux_info (GimpDock *dock)
}
static void
gimp_image_dock_book_added (GimpDock *dock,
GimpDockbook *dockbook)
gimp_menu_dock_book_added (GimpDock *dock,
GimpDockbook *dockbook)
{
g_signal_connect (dockbook, "dockable_added",
G_CALLBACK (gimp_image_dock_dockbook_changed),
G_CALLBACK (gimp_menu_dock_dockbook_changed),
dock);
g_signal_connect (dockbook, "dockable_removed",
G_CALLBACK (gimp_image_dock_dockbook_changed),
G_CALLBACK (gimp_menu_dock_dockbook_changed),
dock);
g_signal_connect (dockbook, "dockable_reordered",
G_CALLBACK (gimp_image_dock_dockbook_changed),
G_CALLBACK (gimp_menu_dock_dockbook_changed),
dock);
gimp_image_dock_update_title (GIMP_IMAGE_DOCK (dock));
gimp_menu_dock_update_title (GIMP_MENU_DOCK (dock));
GIMP_DOCK_CLASS (parent_class)->book_added (dock, dockbook);
}
static void
gimp_image_dock_book_removed (GimpDock *dock,
GimpDockbook *dockbook)
gimp_menu_dock_book_removed (GimpDock *dock,
GimpDockbook *dockbook)
{
g_signal_handlers_disconnect_by_func (dockbook,
gimp_image_dock_dockbook_changed,
gimp_menu_dock_dockbook_changed,
dock);
gimp_image_dock_update_title (GIMP_IMAGE_DOCK (dock));
gimp_menu_dock_update_title (GIMP_MENU_DOCK (dock));
GIMP_DOCK_CLASS (parent_class)->book_removed (dock, dockbook);
}
GtkWidget *
gimp_image_dock_new (GimpDialogFactory *dialog_factory,
GimpContainer *image_container,
GimpContainer *display_container)
gimp_menu_dock_new (GimpDialogFactory *dialog_factory,
GimpContainer *image_container,
GimpContainer *display_container)
{
GimpImageDock *image_dock;
GimpContext *context;
GdkScreen *screen;
gint menu_preview_width;
gint menu_preview_height;
GimpMenuDock *menu_dock;
GimpContext *context;
GdkScreen *screen;
gint menu_preview_width;
gint menu_preview_height;
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (dialog_factory), NULL);
g_return_val_if_fail (GIMP_IS_CONTAINER (image_container), NULL);
@ -416,15 +416,15 @@ gimp_image_dock_new (GimpDialogFactory *dialog_factory,
context = gimp_context_new (dialog_factory->context->gimp,
"Dock Context", NULL);
image_dock = g_object_new (GIMP_TYPE_IMAGE_DOCK,
"context", context,
"dialog-factory", dialog_factory,
NULL);
menu_dock = g_object_new (GIMP_TYPE_MENU_DOCK,
"context", context,
"dialog-factory", dialog_factory,
NULL);
image_dock->image_container = image_container;
image_dock->display_container = display_container;
menu_dock->image_container = image_container;
menu_dock->display_container = display_container;
gimp_help_connect (GTK_WIDGET (image_dock), gimp_standard_help_func,
gimp_help_connect (GTK_WIDGET (menu_dock), gimp_standard_help_func,
GIMP_HELP_DOCK, NULL);
gimp_context_define_properties (context,
@ -434,7 +434,7 @@ gimp_image_dock_new (GimpDialogFactory *dialog_factory,
FALSE);
gimp_context_set_parent (context, dialog_factory->context);
if (image_dock->auto_follow_active)
if (menu_dock->auto_follow_active)
{
if (gimp_context_get_display (dialog_factory->context))
gimp_context_copy_property (dialog_factory->context, context,
@ -445,74 +445,74 @@ gimp_image_dock_new (GimpDialogFactory *dialog_factory,
}
g_signal_connect_object (dialog_factory->context, "display_changed",
G_CALLBACK (gimp_image_dock_factory_display_changed),
image_dock,
G_CALLBACK (gimp_menu_dock_factory_display_changed),
menu_dock,
0);
g_signal_connect_object (dialog_factory->context, "image_changed",
G_CALLBACK (gimp_image_dock_factory_image_changed),
image_dock,
G_CALLBACK (gimp_menu_dock_factory_image_changed),
menu_dock,
0);
g_signal_connect_object (context, "image_changed",
G_CALLBACK (gimp_image_dock_image_changed),
image_dock,
G_CALLBACK (gimp_menu_dock_image_changed),
menu_dock,
0);
screen = gtk_widget_get_screen (GTK_WIDGET (image_dock));
screen = gtk_widget_get_screen (GTK_WIDGET (menu_dock));
gtk_icon_size_lookup_for_settings (gtk_settings_get_for_screen (screen),
DEFAULT_MENU_PREVIEW_SIZE,
&menu_preview_width,
&menu_preview_height);
g_object_set (image_dock->image_combo,
g_object_set (menu_dock->image_combo,
"container", image_container,
"context", context,
NULL);
return GTK_WIDGET (image_dock);
return GTK_WIDGET (menu_dock);
}
void
gimp_image_dock_set_auto_follow_active (GimpImageDock *image_dock,
gboolean auto_follow_active)
gimp_menu_dock_set_auto_follow_active (GimpMenuDock *menu_dock,
gboolean auto_follow_active)
{
g_return_if_fail (GIMP_IS_IMAGE_DOCK (image_dock));
g_return_if_fail (GIMP_IS_MENU_DOCK (menu_dock));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (image_dock->auto_button),
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menu_dock->auto_button),
auto_follow_active ? TRUE : FALSE);
}
void
gimp_image_dock_set_show_image_menu (GimpImageDock *image_dock,
gboolean show)
gimp_menu_dock_set_show_image_menu (GimpMenuDock *menu_dock,
gboolean show)
{
g_return_if_fail (GIMP_IS_IMAGE_DOCK (image_dock));
g_return_if_fail (GIMP_IS_MENU_DOCK (menu_dock));
if (show)
gtk_widget_show (image_dock->image_combo->parent);
gtk_widget_show (menu_dock->image_combo->parent);
else
gtk_widget_hide (image_dock->image_combo->parent);
gtk_widget_hide (menu_dock->image_combo->parent);
image_dock->show_image_menu = show ? TRUE : FALSE;
menu_dock->show_image_menu = show ? TRUE : FALSE;
}
static void
gimp_image_dock_dockbook_changed (GimpDockbook *dockbook,
GimpDockable *dockable,
GimpImageDock *dock)
gimp_menu_dock_dockbook_changed (GimpDockbook *dockbook,
GimpDockable *dockable,
GimpMenuDock *dock)
{
gimp_image_dock_update_title (dock);
gimp_menu_dock_update_title (dock);
}
static gboolean
gimp_image_dock_update_title_idle (GimpImageDock *image_dock)
gimp_menu_dock_update_title_idle (GimpMenuDock *menu_dock)
{
GString *title;
GList *list;
title = g_string_new (NULL);
for (list = GIMP_DOCK (image_dock)->dockbooks;
for (list = GIMP_DOCK (menu_dock)->dockbooks;
list;
list = g_list_next (list))
{
@ -538,57 +538,57 @@ gimp_image_dock_update_title_idle (GimpImageDock *image_dock)
g_string_append (title, " | ");
}
gtk_window_set_title (GTK_WINDOW (image_dock), title->str);
gtk_window_set_title (GTK_WINDOW (menu_dock), title->str);
g_string_free (title, TRUE);
image_dock->update_title_idle_id = 0;
menu_dock->update_title_idle_id = 0;
return FALSE;
}
static void
gimp_image_dock_update_title (GimpImageDock *image_dock)
gimp_menu_dock_update_title (GimpMenuDock *menu_dock)
{
if (image_dock->update_title_idle_id)
g_source_remove (image_dock->update_title_idle_id);
if (menu_dock->update_title_idle_id)
g_source_remove (menu_dock->update_title_idle_id);
image_dock->update_title_idle_id =
g_idle_add ((GSourceFunc) gimp_image_dock_update_title_idle,
image_dock);
menu_dock->update_title_idle_id =
g_idle_add ((GSourceFunc) gimp_menu_dock_update_title_idle,
menu_dock);
}
static void
gimp_image_dock_factory_display_changed (GimpContext *context,
GimpObject *display,
GimpDock *dock)
gimp_menu_dock_factory_display_changed (GimpContext *context,
GimpObject *display,
GimpDock *dock)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
GimpMenuDock *menu_dock = GIMP_MENU_DOCK (dock);
if (display && image_dock->auto_follow_active)
if (display && menu_dock->auto_follow_active)
gimp_context_set_display (dock->context, display);
}
static void
gimp_image_dock_factory_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock)
gimp_menu_dock_factory_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
GimpMenuDock *menu_dock = GIMP_MENU_DOCK (dock);
/* won't do anything if we already set the display above */
if (gimage && image_dock->auto_follow_active)
if (gimage && menu_dock->auto_follow_active)
gimp_context_set_image (dock->context, gimage);
}
static void
gimp_image_dock_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock)
gimp_menu_dock_image_changed (GimpContext *context,
GimpImage *gimage,
GimpDock *dock)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
GimpContainer *image_container = image_dock->image_container;
GimpContainer *display_container = image_dock->display_container;
GimpMenuDock *menu_dock = GIMP_MENU_DOCK (dock);
GimpContainer *image_container = menu_dock->image_container;
GimpContainer *display_container = menu_dock->display_container;
if (gimage == NULL && ! gimp_container_is_empty (image_container))
{
@ -666,14 +666,14 @@ gimp_image_dock_image_changed (GimpContext *context,
}
static void
gimp_image_dock_auto_clicked (GtkWidget *widget,
GimpDock *dock)
gimp_menu_dock_auto_clicked (GtkWidget *widget,
GimpDock *dock)
{
GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
GimpMenuDock *menu_dock = GIMP_MENU_DOCK (dock);
gimp_toggle_button_update (widget, &image_dock->auto_follow_active);
gimp_toggle_button_update (widget, &menu_dock->auto_follow_active);
if (image_dock->auto_follow_active)
if (menu_dock->auto_follow_active)
{
if (gimp_context_get_display (dock->dialog_factory->context))
gimp_context_copy_property (dock->dialog_factory->context,

64
app/widgets/gimpmenudock.h
View File

@ -1,8 +1,8 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpimagedock.h
* Copyright (C) 2001 Michael Natterer <mitch@gimp.org>
* gimpmenudock.h
* Copyright (C) 2001-2005 Michael Natterer <mitch@gimp.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -19,55 +19,55 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_IMAGE_DOCK_H__
#define __GIMP_IMAGE_DOCK_H__
#ifndef __GIMP_MENU_DOCK_H__
#define __GIMP_MENU_DOCK_H__
#include "gimpdock.h"
#include "gimpimagedock.h"
#define GIMP_TYPE_IMAGE_DOCK (gimp_image_dock_get_type ())
#define GIMP_IMAGE_DOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_IMAGE_DOCK, GimpImageDock))
#define GIMP_IMAGE_DOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_IMAGE_DOCK, GimpImageDockClass))
#define GIMP_IS_IMAGE_DOCK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_IMAGE_DOCK))
#define GIMP_IS_IMAGE_DOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_IMAGE_DOCK))
#define GIMP_IMAGE_DOCK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_IMAGE_DOCK, GimpImageDockClass))
#define GIMP_TYPE_MENU_DOCK (gimp_menu_dock_get_type ())
#define GIMP_MENU_DOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_MENU_DOCK, GimpMenuDock))
#define GIMP_MENU_DOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_MENU_DOCK, GimpMenuDockClass))
#define GIMP_IS_MENU_DOCK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_MENU_DOCK))
#define GIMP_IS_MENU_DOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_MENU_DOCK))
#define GIMP_MENU_DOCK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_MENU_DOCK, GimpMenuDockClass))
typedef struct _GimpImageDockClass GimpImageDockClass;
typedef struct _GimpMenuDockClass GimpMenuDockClass;
struct _GimpImageDock
struct _GimpMenuDock
{
GimpDock parent_instance;
GimpImageDock parent_instance;
GimpContainer *image_container;
GimpContainer *display_container;
GimpContainer *image_container;
GimpContainer *display_container;
gboolean show_image_menu;
gboolean auto_follow_active;
gboolean show_image_menu;
gboolean auto_follow_active;
GtkWidget *image_combo;
GtkWidget *auto_button;
GtkWidget *image_combo;
GtkWidget *auto_button;
guint update_title_idle_id;
guint update_title_idle_id;
};
struct _GimpImageDockClass
struct _GimpMenuDockClass
{
GimpDockClass parent_class;
GimpImageDockClass parent_class;
};
GType gimp_image_dock_get_type (void) G_GNUC_CONST;
GType gimp_menu_dock_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_image_dock_new (GimpDialogFactory *dialog_factory,
GimpContainer *image_container,
GimpContainer *display_container);
GtkWidget * gimp_menu_dock_new (GimpDialogFactory *dialog_factory,
GimpContainer *image_container,
GimpContainer *display_container);
void gimp_image_dock_set_auto_follow_active (GimpImageDock *image_dock,
gboolean show);
void gimp_image_dock_set_show_image_menu (GimpImageDock *image_dock,
gboolean show);
void gimp_menu_dock_set_auto_follow_active (GimpMenuDock *menu_dock,
gboolean show);
void gimp_menu_dock_set_show_image_menu (GimpMenuDock *menu_dock,
gboolean show);
#endif /* __GIMP_IMAGE_DOCK_H__ */
#endif /* __GIMP_MENU_DOCK_H__ */

31
app/widgets/gimptoolbox.c
View File

@ -121,7 +121,7 @@ static void toolbox_paste_received (GtkClipboard *clipboard,
/* local variables */
static GimpDockClass *parent_class = NULL;
static GimpImageDockClass *parent_class = NULL;
GType
@ -144,7 +144,7 @@ gimp_toolbox_get_type (void)
(GInstanceInitFunc) gimp_toolbox_init,
};
type = g_type_register_static (GIMP_TYPE_DOCK,
type = g_type_register_static (GIMP_TYPE_IMAGE_DOCK,
"GimpToolbox",
&type_info, 0);
}
@ -155,22 +155,23 @@ gimp_toolbox_get_type (void)
static void
gimp_toolbox_class_init (GimpToolboxClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GimpDockClass *dock_class = GIMP_DOCK_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GimpDockClass *dock_class = GIMP_DOCK_CLASS (klass);
GimpImageDockClass *image_dock_class = GIMP_IMAGE_DOCK_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->constructor = gimp_toolbox_constructor;
object_class->constructor = gimp_toolbox_constructor;
widget_class->delete_event = gimp_toolbox_delete_event;
widget_class->size_allocate = gimp_toolbox_size_allocate;
widget_class->style_set = gimp_toolbox_style_set;
widget_class->delete_event = gimp_toolbox_delete_event;
widget_class->size_allocate = gimp_toolbox_size_allocate;
widget_class->style_set = gimp_toolbox_style_set;
dock_class->book_added = gimp_toolbox_book_added;
dock_class->book_removed = gimp_toolbox_book_removed;
dock_class->book_added = gimp_toolbox_book_added;
dock_class->book_removed = gimp_toolbox_book_removed;
dock_class->ui_manager_name = "<Toolbox>";
image_dock_class->ui_manager_name = "<Toolbox>";
gtk_widget_class_install_style_property
(widget_class, g_param_spec_enum ("tool-icon-size",
@ -227,7 +228,7 @@ gimp_toolbox_constructor (GType type,
gtk_box_reorder_child (GTK_BOX (main_vbox), vbox, 0);
gtk_widget_show (vbox);
manager = GTK_UI_MANAGER (GIMP_DOCK (toolbox)->ui_manager);
manager = GTK_UI_MANAGER (GIMP_IMAGE_DOCK (toolbox)->ui_manager);
toolbox->menu_bar = gtk_ui_manager_get_widget (manager, "/toolbox-menubar");
@ -749,7 +750,7 @@ toolbox_create_tools (GimpToolbox *toolbox,
G_CALLBACK (toolbox_tool_button_press),
toolbox);
if (GIMP_DOCK (toolbox)->ui_manager)
if (GIMP_IMAGE_DOCK (toolbox)->ui_manager)
{
GtkAction *action;
const gchar *identifier;
@ -764,7 +765,7 @@ toolbox_create_tools (GimpToolbox *toolbox,
name = g_strdup_printf ("tools-%s", tmp);
g_free (tmp);
action = gimp_ui_manager_find_action (GIMP_DOCK (toolbox)->ui_manager,
action = gimp_ui_manager_find_action (GIMP_IMAGE_DOCK (toolbox)->ui_manager,
"tools", name);
g_free (name);

26
app/widgets/gimptoolbox.h
View File

@ -20,7 +20,7 @@
#define __GIMP_TOOLBOX_H__
#include "gimpdock.h"
#include "gimpimagedock.h"
#define GIMP_TYPE_TOOLBOX (gimp_toolbox_get_type ())
@ -35,24 +35,24 @@ typedef struct _GimpToolboxClass GimpToolboxClass;
struct _GimpToolbox
{
GimpDock parent_instance;
GimpImageDock parent_instance;
GtkWidget *menu_bar;
GtkWidget *tool_wbox;
GtkWidget *area_wbox;
GtkWidget *color_area;
GtkWidget *foo_area;
GtkWidget *image_area;
GtkWidget *menu_bar;
GtkWidget *tool_wbox;
GtkWidget *area_wbox;
GtkWidget *color_area;
GtkWidget *foo_area;
GtkWidget *image_area;
gint tool_rows;
gint tool_columns;
gint area_rows;
gint area_columns;
gint tool_rows;
gint tool_columns;
gint area_rows;
gint area_columns;
};
struct _GimpToolboxClass
{
GimpDockClass parent_class;
GimpImageDockClass parent_class;
};

1
app/widgets/widgets-types.h
View File

@ -39,6 +39,7 @@ typedef struct _GimpControllerWheel GimpControllerWheel;
typedef struct _GimpDock GimpDock;
typedef struct _GimpImageDock GimpImageDock;
typedef struct _GimpMenuDock GimpMenuDock;
typedef struct _GimpToolbox GimpToolbox;
typedef struct _GimpDockbook GimpDockbook;
typedef struct _GimpDockable GimpDockable;