summaryrefslogtreecommitdiffstats
path: root/app/widgets/gimpdockwindow.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/widgets/gimpdockwindow.c')
-rw-r--r--app/widgets/gimpdockwindow.c1250
1 files changed, 1250 insertions, 0 deletions
diff --git a/app/widgets/gimpdockwindow.c b/app/widgets/gimpdockwindow.c
new file mode 100644
index 0000000..e8d9556
--- /dev/null
+++ b/app/widgets/gimpdockwindow.c
@@ -0,0 +1,1250 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpdockwindow.c
+ * Copyright (C) 2001-2005 Michael Natterer <mitch@gimp.org>
+ * Copyright (C) 2009 Martin Nordholts <martinn@src.gnome.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
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+
+#include <gtk/gtk.h>
+
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "widgets-types.h"
+
+#include "dialogs/dialogs.h" /* FIXME, we are in the widget layer */
+
+#include "config/gimpguiconfig.h"
+
+#include "core/gimp.h"
+#include "core/gimpcontext.h"
+#include "core/gimpcontainer.h"
+#include "core/gimpcontainer.h"
+#include "core/gimplist.h"
+#include "core/gimpimage.h"
+
+#include "gimpcontainercombobox.h"
+#include "gimpcontainerview.h"
+#include "gimpdialogfactory.h"
+#include "gimpdock.h"
+#include "gimpdockbook.h"
+#include "gimpdockcolumns.h"
+#include "gimpdockcontainer.h"
+#include "gimpdockwindow.h"
+#include "gimphelp-ids.h"
+#include "gimpmenufactory.h"
+#include "gimpsessioninfo-aux.h"
+#include "gimpsessioninfo.h"
+#include "gimpsessionmanaged.h"
+#include "gimptoolbox.h"
+#include "gimpuimanager.h"
+#include "gimpwidgets-utils.h"
+#include "gimpwindow.h"
+
+#include "gimp-intl.h"
+
+
+#define DEFAULT_DOCK_HEIGHT 300
+#define DEFAULT_MENU_VIEW_SIZE GTK_ICON_SIZE_SMALL_TOOLBAR
+#define AUX_INFO_SHOW_IMAGE_MENU "show-image-menu"
+#define AUX_INFO_FOLLOW_ACTIVE_IMAGE "follow-active-image"
+
+
+enum
+{
+ PROP_0,
+ PROP_CONTEXT,
+ PROP_DIALOG_FACTORY,
+ PROP_UI_MANAGER_NAME,
+ PROP_IMAGE_CONTAINER,
+ PROP_DISPLAY_CONTAINER,
+ PROP_ALLOW_DOCKBOOK_ABSENCE
+};
+
+
+struct _GimpDockWindowPrivate
+{
+ GimpContext *context;
+
+ GimpDialogFactory *dialog_factory;
+
+ gchar *ui_manager_name;
+ GimpUIManager *ui_manager;
+ GQuark image_flush_handler_id;
+
+ GimpDockColumns *dock_columns;
+
+ gboolean allow_dockbook_absence;
+
+ guint update_title_idle_id;
+
+ gint ID;
+
+ GimpContainer *image_container;
+ GimpContainer *display_container;
+
+ gboolean show_image_menu;
+ gboolean auto_follow_active;
+
+ GtkWidget *image_combo;
+ GtkWidget *auto_button;
+};
+
+
+static void gimp_dock_window_dock_container_iface_init (GimpDockContainerInterface *iface);
+static void gimp_dock_window_session_managed_iface_init(GimpSessionManagedInterface*iface);
+static void gimp_dock_window_constructed (GObject *object);
+static void gimp_dock_window_dispose (GObject *object);
+static void gimp_dock_window_finalize (GObject *object);
+static void gimp_dock_window_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gimp_dock_window_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void gimp_dock_window_style_set (GtkWidget *widget,
+ GtkStyle *prev_style);
+static gboolean gimp_dock_window_delete_event (GtkWidget *widget,
+ GdkEventAny *event);
+static GList * gimp_dock_window_get_docks (GimpDockContainer *dock_container);
+static GimpDialogFactory * gimp_dock_window_get_dialog_factory (GimpDockContainer *dock_container);
+static GimpUIManager * gimp_dock_window_get_ui_manager (GimpDockContainer *dock_container);
+static void gimp_dock_window_add_dock_from_session (GimpDockContainer *dock_container,
+ GimpDock *dock,
+ GimpSessionInfoDock *dock_info);
+static GList * gimp_dock_window_get_aux_info (GimpSessionManaged *session_managed);
+static void gimp_dock_window_set_aux_info (GimpSessionManaged *session_managed,
+ GList *aux_info);
+static GimpAlignmentType
+ gimp_dock_window_get_dock_side (GimpDockContainer *dock_container,
+ GimpDock *dock);
+static gboolean gimp_dock_window_should_add_to_recent (GimpDockWindow *dock_window);
+static void gimp_dock_window_display_changed (GimpDockWindow *dock_window,
+ GimpObject *display,
+ GimpContext *context);
+static void gimp_dock_window_image_changed (GimpDockWindow *dock_window,
+ GimpImage *image,
+ GimpContext *context);
+static void gimp_dock_window_image_flush (GimpImage *image,
+ gboolean invalidate_preview,
+ GimpDockWindow *dock_window);
+static void gimp_dock_window_update_title (GimpDockWindow *dock_window);
+static gboolean gimp_dock_window_update_title_idle (GimpDockWindow *dock_window);
+static gchar * gimp_dock_window_get_description (GimpDockWindow *dock_window,
+ gboolean complete);
+static void gimp_dock_window_dock_removed (GimpDockWindow *dock_window,
+ GimpDock *dock,
+ GimpDockColumns *dock_columns);
+static void gimp_dock_window_factory_display_changed (GimpContext *context,
+ GimpObject *display,
+ GimpDock *dock);
+static void gimp_dock_window_factory_image_changed (GimpContext *context,
+ GimpImage *image,
+ GimpDock *dock);
+static void gimp_dock_window_auto_clicked (GtkWidget *widget,
+ GimpDock *dock);
+
+
+G_DEFINE_TYPE_WITH_CODE (GimpDockWindow, gimp_dock_window, GIMP_TYPE_WINDOW,
+ G_ADD_PRIVATE (GimpDockWindow)
+ G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCK_CONTAINER,
+ gimp_dock_window_dock_container_iface_init)
+ G_IMPLEMENT_INTERFACE (GIMP_TYPE_SESSION_MANAGED,
+ gimp_dock_window_session_managed_iface_init))
+
+#define parent_class gimp_dock_window_parent_class
+
+static void
+gimp_dock_window_class_init (GimpDockWindowClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class->constructed = gimp_dock_window_constructed;
+ object_class->dispose = gimp_dock_window_dispose;
+ object_class->finalize = gimp_dock_window_finalize;
+ object_class->set_property = gimp_dock_window_set_property;
+ object_class->get_property = gimp_dock_window_get_property;
+
+ widget_class->style_set = gimp_dock_window_style_set;
+ widget_class->delete_event = gimp_dock_window_delete_event;
+
+ g_object_class_install_property (object_class, PROP_CONTEXT,
+ g_param_spec_object ("context", NULL, NULL,
+ GIMP_TYPE_CONTEXT,
+ GIMP_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY));
+
+ g_object_class_install_property (object_class, PROP_DIALOG_FACTORY,
+ g_param_spec_object ("dialog-factory",
+ NULL, NULL,
+ GIMP_TYPE_DIALOG_FACTORY,
+ GIMP_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY));
+
+ g_object_class_install_property (object_class, PROP_UI_MANAGER_NAME,
+ g_param_spec_string ("ui-manager-name",
+ NULL, NULL,
+ NULL,
+ GIMP_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY));
+
+ g_object_class_install_property (object_class, PROP_IMAGE_CONTAINER,
+ g_param_spec_object ("image-container",
+ NULL, NULL,
+ GIMP_TYPE_CONTAINER,
+ GIMP_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY));
+
+ g_object_class_install_property (object_class, PROP_DISPLAY_CONTAINER,
+ g_param_spec_object ("display-container",
+ NULL, NULL,
+ GIMP_TYPE_CONTAINER,
+ GIMP_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY));
+
+ g_object_class_install_property (object_class, PROP_ALLOW_DOCKBOOK_ABSENCE,
+ g_param_spec_boolean ("allow-dockbook-absence",
+ NULL, NULL,
+ FALSE,
+ GIMP_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY));
+
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_int ("default-height",
+ NULL, NULL,
+ -1, G_MAXINT,
+ DEFAULT_DOCK_HEIGHT,
+ GIMP_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_VIEW_SIZE,
+ GIMP_PARAM_READABLE));
+}
+
+static void
+gimp_dock_window_init (GimpDockWindow *dock_window)
+{
+ static gint dock_window_ID = 1;
+ gchar *name = NULL;
+
+ dock_window->p = gimp_dock_window_get_instance_private (dock_window);
+ dock_window->p->ID = dock_window_ID++;
+ dock_window->p->auto_follow_active = TRUE;
+
+ name = g_strdup_printf ("gimp-dock-%d", dock_window->p->ID);
+ gtk_widget_set_name (GTK_WIDGET (dock_window), name);
+ g_free (name);
+
+ gtk_window_set_resizable (GTK_WINDOW (dock_window), TRUE);
+ gtk_window_set_focus_on_map (GTK_WINDOW (dock_window), FALSE);
+ gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dock_window), FALSE);
+}
+
+static void
+gimp_dock_window_dock_container_iface_init (GimpDockContainerInterface *iface)
+{
+ iface->get_docks = gimp_dock_window_get_docks;
+ iface->get_dialog_factory = gimp_dock_window_get_dialog_factory;
+ iface->get_ui_manager = gimp_dock_window_get_ui_manager;
+ iface->add_dock = gimp_dock_window_add_dock_from_session;
+ iface->get_dock_side = gimp_dock_window_get_dock_side;
+}
+
+static void
+gimp_dock_window_session_managed_iface_init (GimpSessionManagedInterface *iface)
+{
+ iface->get_aux_info = gimp_dock_window_get_aux_info;
+ iface->set_aux_info = gimp_dock_window_set_aux_info;
+}
+
+static void
+gimp_dock_window_constructed (GObject *object)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (object);
+ GimpGuiConfig *config;
+ GimpContext *factory_context;
+ GimpMenuFactory *menu_factory;
+ GtkAccelGroup *accel_group;
+ Gimp *gimp;
+ GtkSettings *settings;
+ gint menu_view_width = -1;
+ gint menu_view_height = -1;
+
+ G_OBJECT_CLASS (parent_class)->constructed (object);
+
+ gimp = GIMP (dock_window->p->context->gimp);
+ config = GIMP_GUI_CONFIG (gimp->config);
+
+ /* Create a separate context per dock so that docks can be bound to
+ * a specific image and does not necessarily have to follow the
+ * active image in the user context
+ */
+ g_object_unref (dock_window->p->context);
+ dock_window->p->context = gimp_context_new (gimp, "Dock Context", NULL);
+ dock_window->p->image_container = gimp->images;
+ dock_window->p->display_container = gimp->displays;
+
+ factory_context =
+ gimp_dialog_factory_get_context (dock_window->p->dialog_factory);
+
+ /* Setup hints */
+ gimp_window_set_hint (GTK_WINDOW (dock_window), config->dock_window_hint);
+
+ menu_factory =
+ gimp_dialog_factory_get_menu_factory (dock_window->p->dialog_factory);
+
+ /* Make image window related keyboard shortcuts work also when a
+ * dock window is the focused window
+ */
+ dock_window->p->ui_manager =
+ gimp_menu_factory_manager_new (menu_factory,
+ dock_window->p->ui_manager_name,
+ dock_window,
+ config->tearoff_menus);
+ accel_group = gimp_ui_manager_get_accel_group (dock_window->p->ui_manager);
+ gtk_window_add_accel_group (GTK_WINDOW (dock_window), accel_group);
+
+ g_signal_connect_object (dock_window->p->context, "display-changed",
+ G_CALLBACK (gimp_dock_window_display_changed),
+ dock_window,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (dock_window->p->context, "image-changed",
+ G_CALLBACK (gimp_dock_window_image_changed),
+ dock_window,
+ G_CONNECT_SWAPPED);
+
+ dock_window->p->image_flush_handler_id =
+ gimp_container_add_handler (gimp->images, "flush",
+ G_CALLBACK (gimp_dock_window_image_flush),
+ dock_window);
+
+ gimp_context_define_properties (dock_window->p->context,
+ GIMP_CONTEXT_PROP_MASK_ALL &
+ ~(GIMP_CONTEXT_PROP_MASK_IMAGE |
+ GIMP_CONTEXT_PROP_MASK_DISPLAY),
+ FALSE);
+ gimp_context_set_parent (dock_window->p->context,
+ factory_context);
+
+ /* Setup widget hierarchy */
+ {
+ GtkWidget *vbox = NULL;
+
+ /* Top-level GtkVBox */
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+ gtk_container_add (GTK_CONTAINER (dock_window), vbox);
+ gtk_widget_show (vbox);
+
+ /* Image selection menu */
+ {
+ GtkWidget *hbox = NULL;
+
+ /* GtkHBox */
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+ if (dock_window->p->show_image_menu)
+ gtk_widget_show (hbox);
+
+ /* Image combo */
+ dock_window->p->image_combo = gimp_container_combo_box_new (NULL, NULL, 16, 1);
+ gtk_box_pack_start (GTK_BOX (hbox), dock_window->p->image_combo, TRUE, TRUE, 0);
+ g_signal_connect (dock_window->p->image_combo, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &dock_window->p->image_combo);
+ gimp_help_set_help_data (dock_window->p->image_combo,
+ NULL, GIMP_HELP_DOCK_IMAGE_MENU);
+ gtk_widget_show (dock_window->p->image_combo);
+
+ /* Auto button */
+ dock_window->p->auto_button = gtk_toggle_button_new_with_label (_("Auto"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dock_window->p->auto_button),
+ dock_window->p->auto_follow_active);
+ gtk_box_pack_start (GTK_BOX (hbox), dock_window->p->auto_button, FALSE, FALSE, 0);
+ gtk_widget_show (dock_window->p->auto_button);
+
+ g_signal_connect (dock_window->p->auto_button, "clicked",
+ G_CALLBACK (gimp_dock_window_auto_clicked),
+ dock_window);
+
+ gimp_help_set_help_data (dock_window->p->auto_button,
+ _("When enabled, the dialog automatically "
+ "follows the image you are working on."),
+ GIMP_HELP_DOCK_AUTO_BUTTON);
+ }
+
+ /* GimpDockColumns */
+ /* Let the GimpDockColumns mirror the context so that a GimpDock can
+ * get it when inside a dock window. We do the same thing in the
+ * GimpImageWindow so docks can get the GimpContext there as well
+ */
+ dock_window->p->dock_columns =
+ GIMP_DOCK_COLUMNS (gimp_dock_columns_new (dock_window->p->context,
+ dock_window->p->dialog_factory,
+ dock_window->p->ui_manager));
+ gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (dock_window->p->dock_columns),
+ TRUE, TRUE, 0);
+ gtk_widget_show (GTK_WIDGET (dock_window->p->dock_columns));
+ g_signal_connect_object (dock_window->p->dock_columns, "dock-removed",
+ G_CALLBACK (gimp_dock_window_dock_removed),
+ dock_window,
+ G_CONNECT_SWAPPED);
+
+ g_signal_connect_object (dock_window->p->dock_columns, "dock-added",
+ G_CALLBACK (gimp_dock_window_update_title),
+ dock_window,
+ G_CONNECT_SWAPPED);
+ g_signal_connect_object (dock_window->p->dock_columns, "dock-removed",
+ G_CALLBACK (gimp_dock_window_update_title),
+ dock_window,
+ G_CONNECT_SWAPPED);
+ }
+
+ if (dock_window->p->auto_follow_active)
+ {
+ if (gimp_context_get_display (factory_context))
+ gimp_context_copy_property (factory_context,
+ dock_window->p->context,
+ GIMP_CONTEXT_PROP_DISPLAY);
+ else
+ gimp_context_copy_property (factory_context,
+ dock_window->p->context,
+ GIMP_CONTEXT_PROP_IMAGE);
+ }
+
+ g_signal_connect_object (factory_context, "display-changed",
+ G_CALLBACK (gimp_dock_window_factory_display_changed),
+ dock_window,
+ 0);
+ g_signal_connect_object (factory_context, "image-changed",
+ G_CALLBACK (gimp_dock_window_factory_image_changed),
+ dock_window,
+ 0);
+
+ settings = gtk_widget_get_settings (GTK_WIDGET (dock_window));
+ gtk_icon_size_lookup_for_settings (settings,
+ DEFAULT_MENU_VIEW_SIZE,
+ &menu_view_width,
+ &menu_view_height);
+
+ g_object_set (dock_window->p->image_combo,
+ "container", dock_window->p->image_container,
+ "context", dock_window->p->context,
+ NULL);
+
+ gimp_help_connect (GTK_WIDGET (dock_window), gimp_standard_help_func,
+ GIMP_HELP_DOCK, NULL);
+
+ if (dock_window->p->auto_follow_active)
+ {
+ if (gimp_context_get_display (factory_context))
+ gimp_context_copy_property (factory_context,
+ dock_window->p->context,
+ GIMP_CONTEXT_PROP_DISPLAY);
+ else
+ gimp_context_copy_property (factory_context,
+ dock_window->p->context,
+ GIMP_CONTEXT_PROP_IMAGE);
+ }
+}
+
+static void
+gimp_dock_window_dispose (GObject *object)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (object);
+
+ if (dock_window->p->update_title_idle_id)
+ {
+ g_source_remove (dock_window->p->update_title_idle_id);
+ dock_window->p->update_title_idle_id = 0;
+ }
+
+ if (dock_window->p->image_flush_handler_id)
+ {
+ gimp_container_remove_handler (dock_window->p->context->gimp->images,
+ dock_window->p->image_flush_handler_id);
+ dock_window->p->image_flush_handler_id = 0;
+ }
+
+ g_clear_object (&dock_window->p->ui_manager);
+ g_clear_object (&dock_window->p->dialog_factory);
+ g_clear_object (&dock_window->p->context);
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gimp_dock_window_finalize (GObject *object)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (object);
+
+ g_clear_pointer (&dock_window->p->ui_manager_name, g_free);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_dock_window_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (object);
+
+ switch (property_id)
+ {
+ case PROP_CONTEXT:
+ dock_window->p->context = g_value_dup_object (value);
+ break;
+
+ case PROP_DIALOG_FACTORY:
+ dock_window->p->dialog_factory = g_value_dup_object (value);
+ break;
+
+ case PROP_UI_MANAGER_NAME:
+ g_free (dock_window->p->ui_manager_name);
+ dock_window->p->ui_manager_name = g_value_dup_string (value);
+ break;
+
+ case PROP_IMAGE_CONTAINER:
+ dock_window->p->image_container = g_value_dup_object (value);
+ break;
+
+ case PROP_DISPLAY_CONTAINER:
+ dock_window->p->display_container = g_value_dup_object (value);
+ break;
+
+ case PROP_ALLOW_DOCKBOOK_ABSENCE:
+ dock_window->p->allow_dockbook_absence = g_value_get_boolean (value);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+gimp_dock_window_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (object);
+
+ switch (property_id)
+ {
+ case PROP_CONTEXT:
+ g_value_set_object (value, dock_window->p->context);
+ break;
+
+ case PROP_DIALOG_FACTORY:
+ g_value_set_object (value, dock_window->p->dialog_factory);
+ break;
+
+ case PROP_UI_MANAGER_NAME:
+ g_value_set_string (value, dock_window->p->ui_manager_name);
+ break;
+
+ case PROP_IMAGE_CONTAINER:
+ g_value_set_object (value, dock_window->p->image_container);
+ break;
+
+ case PROP_DISPLAY_CONTAINER:
+ g_value_set_object (value, dock_window->p->display_container);
+ break;
+
+ case PROP_ALLOW_DOCKBOOK_ABSENCE:
+ g_value_set_boolean (value, dock_window->p->allow_dockbook_absence);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+gimp_dock_window_style_set (GtkWidget *widget,
+ GtkStyle *prev_style)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (widget);
+ GtkStyle *button_style;
+ GtkIconSize menu_view_size;
+ GtkSettings *settings;
+ gint menu_view_width = 18;
+ gint menu_view_height = 18;
+ gint focus_line_width;
+ gint focus_padding;
+ gint ythickness;
+
+ gint default_height = DEFAULT_DOCK_HEIGHT;
+
+ GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
+
+ gtk_widget_style_get (widget,
+ "default-height", &default_height,
+ "menu-preview-size", &menu_view_size,
+ NULL);
+
+ gtk_window_set_default_size (GTK_WINDOW (widget), -1, default_height);
+
+ settings = gtk_widget_get_settings (dock_window->p->image_combo);
+ gtk_icon_size_lookup_for_settings (settings,
+ menu_view_size,
+ &menu_view_width,
+ &menu_view_height);
+
+ gtk_widget_style_get (dock_window->p->auto_button,
+ "focus-line-width", &focus_line_width,
+ "focus-padding", &focus_padding,
+ NULL);
+
+ button_style = gtk_widget_get_style (widget);
+ ythickness = button_style->ythickness;
+
+ gimp_container_view_set_view_size (GIMP_CONTAINER_VIEW (dock_window->p->image_combo),
+ menu_view_height, 1);
+
+ gtk_widget_set_size_request (dock_window->p->auto_button, -1,
+ menu_view_height +
+ 2 * (1 /* CHILD_SPACING */ +
+ ythickness +
+ focus_padding +
+ focus_line_width));
+}
+
+/**
+ * gimp_dock_window_delete_event:
+ * @widget:
+ * @event:
+ *
+ * Makes sure that when dock windows are closed they are added to the
+ * list of recently closed docks so that they are easy to bring back.
+ **/
+static gboolean
+gimp_dock_window_delete_event (GtkWidget *widget,
+ GdkEventAny *event)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (widget);
+ GimpSessionInfo *info = NULL;
+ const gchar *entry_name = NULL;
+ GimpDialogFactoryEntry *entry = NULL;
+ gchar *name = NULL;
+
+ /* Don't add docks with just a single dockable to the list of
+ * recently closed dock since those can be brought back through the
+ * normal Windows->Dockable Dialogs menu
+ */
+ if (! gimp_dock_window_should_add_to_recent (dock_window))
+ return FALSE;
+
+ info = gimp_session_info_new ();
+
+ name = gimp_dock_window_get_description (dock_window, TRUE /*complete*/);
+ gimp_object_set_name (GIMP_OBJECT (info), name);
+ g_free (name);
+
+ gimp_session_info_get_info_with_widget (info, GTK_WIDGET (dock_window));
+
+ entry_name = (gimp_dock_window_has_toolbox (dock_window) ?
+ "gimp-toolbox-window" :
+ "gimp-dock-window");
+ entry = gimp_dialog_factory_find_entry (dock_window->p->dialog_factory,
+ entry_name);
+ gimp_session_info_set_factory_entry (info, entry);
+
+ gimp_container_add (global_recent_docks, GIMP_OBJECT (info));
+ g_object_unref (info);
+
+ return FALSE;
+}
+
+static GList *
+gimp_dock_window_get_docks (GimpDockContainer *dock_container)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (dock_container);
+
+ return g_list_copy (gimp_dock_columns_get_docks (dock_window->p->dock_columns));
+}
+
+static GimpDialogFactory *
+gimp_dock_window_get_dialog_factory (GimpDockContainer *dock_container)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (dock_container);
+
+ return dock_window->p->dialog_factory;
+}
+
+static GimpUIManager *
+gimp_dock_window_get_ui_manager (GimpDockContainer *dock_container)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (dock_container);
+
+ return dock_window->p->ui_manager;
+}
+
+static void
+gimp_dock_window_add_dock_from_session (GimpDockContainer *dock_container,
+ GimpDock *dock,
+ GimpSessionInfoDock *dock_info)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (dock_container);
+
+ gimp_dock_window_add_dock (dock_window,
+ dock,
+ -1 /*index*/);
+}
+
+static GList *
+gimp_dock_window_get_aux_info (GimpSessionManaged *session_managed)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (session_managed);
+ GList *aux_info = NULL;
+ GimpSessionInfoAux *aux;
+
+ if (dock_window->p->allow_dockbook_absence)
+ {
+ /* Assume it is the toolbox; it does not have aux info */
+ return NULL;
+ }
+
+ g_return_val_if_fail (GIMP_IS_DOCK_WINDOW (dock_window), NULL);
+
+ aux = gimp_session_info_aux_new (AUX_INFO_SHOW_IMAGE_MENU,
+ dock_window->p->show_image_menu ?
+ "true" : "false");
+ aux_info = g_list_append (aux_info, aux);
+
+ aux = gimp_session_info_aux_new (AUX_INFO_FOLLOW_ACTIVE_IMAGE,
+ dock_window->p->auto_follow_active ?
+ "true" : "false");
+ aux_info = g_list_append (aux_info, aux);
+
+ return aux_info;
+}
+
+static void
+gimp_dock_window_set_aux_info (GimpSessionManaged *session_managed,
+ GList *aux_info)
+{
+ GimpDockWindow *dock_window;
+ GList *list;
+ gboolean menu_shown;
+ gboolean auto_follow;
+
+ g_return_if_fail (GIMP_IS_DOCK_WINDOW (session_managed));
+
+ dock_window = GIMP_DOCK_WINDOW (session_managed);
+ menu_shown = dock_window->p->show_image_menu;
+ auto_follow = dock_window->p->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 != dock_window->p->show_image_menu)
+ gimp_dock_window_set_show_image_menu (dock_window, menu_shown);
+
+ if (auto_follow != dock_window->p->auto_follow_active)
+ gimp_dock_window_set_auto_follow_active (dock_window, auto_follow);
+}
+
+static GimpAlignmentType
+gimp_dock_window_get_dock_side (GimpDockContainer *dock_container,
+ GimpDock *dock)
+{
+ g_return_val_if_fail (GIMP_IS_DOCK_WINDOW (dock_container), -1);
+ g_return_val_if_fail (GIMP_IS_DOCK (dock), -1);
+
+ /* A GimpDockWindow don't have docks on different sides, it's just
+ * one set of columns
+ */
+ return -1;
+}
+
+/**
+ * gimp_dock_window_should_add_to_recent:
+ * @dock_window:
+ *
+ * Returns: %FALSE if the dock window can be recreated with one
+ * Windows menu item such as Windows->Toolbox or
+ * Windows->Dockable Dialogs->Layers, %TRUE if not. It should
+ * then be added to the list of recently closed docks.
+ **/
+static gboolean
+gimp_dock_window_should_add_to_recent (GimpDockWindow *dock_window)
+{
+ GList *docks;
+ gboolean should_add = TRUE;
+
+ docks = gimp_dock_container_get_docks (GIMP_DOCK_CONTAINER (dock_window));
+
+ if (! docks)
+ {
+ should_add = FALSE;
+ }
+ else if (g_list_length (docks) == 1)
+ {
+ GimpDock *dock = GIMP_DOCK (g_list_nth_data (docks, 0));
+
+ if (GIMP_IS_TOOLBOX (dock) &&
+ gimp_dock_get_n_dockables (dock) == 0)
+ {
+ should_add = FALSE;
+ }
+ else if (! GIMP_IS_TOOLBOX (dock) &&
+ gimp_dock_get_n_dockables (dock) == 1)
+ {
+ should_add = FALSE;
+ }
+ }
+
+ g_list_free (docks);
+
+ return should_add;
+}
+
+static void
+gimp_dock_window_image_flush (GimpImage *image,
+ gboolean invalidate_preview,
+ GimpDockWindow *dock_window)
+{
+ if (image == gimp_context_get_image (dock_window->p->context))
+ {
+ GimpObject *display = gimp_context_get_display (dock_window->p->context);
+
+ if (display)
+ gimp_ui_manager_update (dock_window->p->ui_manager, display);
+ }
+}
+
+static void
+gimp_dock_window_update_title (GimpDockWindow *dock_window)
+{
+ if (dock_window->p->update_title_idle_id)
+ g_source_remove (dock_window->p->update_title_idle_id);
+
+ dock_window->p->update_title_idle_id =
+ g_idle_add ((GSourceFunc) gimp_dock_window_update_title_idle,
+ dock_window);
+}
+
+static gboolean
+gimp_dock_window_update_title_idle (GimpDockWindow *dock_window)
+{
+ gchar *desc = gimp_dock_window_get_description (dock_window,
+ FALSE /*complete*/);
+ if (desc)
+ {
+ gtk_window_set_title (GTK_WINDOW (dock_window), desc);
+ g_free (desc);
+ }
+
+ dock_window->p->update_title_idle_id = 0;
+
+ return FALSE;
+}
+
+static gchar *
+gimp_dock_window_get_description (GimpDockWindow *dock_window,
+ gboolean complete)
+{
+ GString *complete_desc = g_string_new (NULL);
+ GList *docks = NULL;
+ GList *iter = NULL;
+
+ docks = gimp_dock_container_get_docks (GIMP_DOCK_CONTAINER (dock_window));
+
+ for (iter = docks;
+ iter;
+ iter = g_list_next (iter))
+ {
+ gchar *desc = gimp_dock_get_description (GIMP_DOCK (iter->data), complete);
+ g_string_append (complete_desc, desc);
+ g_free (desc);
+
+ if (g_list_next (iter))
+ g_string_append (complete_desc, GIMP_DOCK_COLUMN_SEPARATOR);
+ }
+
+ g_list_free (docks);
+
+ return g_string_free (complete_desc, FALSE /*free_segment*/);
+}
+
+static void
+gimp_dock_window_dock_removed (GimpDockWindow *dock_window,
+ GimpDock *dock,
+ GimpDockColumns *dock_columns)
+{
+ g_return_if_fail (GIMP_IS_DOCK (dock));
+
+ if (gimp_dock_columns_get_docks (dock_columns) == NULL &&
+ ! dock_window->p->allow_dockbook_absence)
+ gtk_widget_destroy (GTK_WIDGET (dock_window));
+}
+
+static void
+gimp_dock_window_factory_display_changed (GimpContext *context,
+ GimpObject *display,
+ GimpDock *dock)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (dock);
+
+ if (display && dock_window->p->auto_follow_active)
+ gimp_context_set_display (dock_window->p->context, display);
+}
+
+static void
+gimp_dock_window_factory_image_changed (GimpContext *context,
+ GimpImage *image,
+ GimpDock *dock)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (dock);
+
+ /* won't do anything if we already set the display above */
+ if (image && dock_window->p->auto_follow_active)
+ gimp_context_set_image (dock_window->p->context, image);
+}
+
+static void
+gimp_dock_window_display_changed (GimpDockWindow *dock_window,
+ GimpObject *display,
+ GimpContext *context)
+{
+ /* make sure auto-follow-active works both ways */
+ if (display && dock_window->p->auto_follow_active)
+ {
+ GimpContext *factory_context =
+ gimp_dialog_factory_get_context (dock_window->p->dialog_factory);
+
+ gimp_context_set_display (factory_context, display);
+ }
+
+ gimp_ui_manager_update (dock_window->p->ui_manager,
+ display);
+}
+
+static void
+gimp_dock_window_image_changed (GimpDockWindow *dock_window,
+ GimpImage *image,
+ GimpContext *context)
+{
+ GimpContainer *image_container = dock_window->p->image_container;
+ GimpContainer *display_container = dock_window->p->display_container;
+
+ /* make sure auto-follow-active works both ways */
+ if (image && dock_window->p->auto_follow_active)
+ {
+ GimpContext *factory_context =
+ gimp_dialog_factory_get_context (dock_window->p->dialog_factory);
+
+ gimp_context_set_image (factory_context, image);
+ }
+
+ if (image == NULL && ! gimp_container_is_empty (image_container))
+ {
+ image = GIMP_IMAGE (gimp_container_get_first_child (image_container));
+
+ /* this invokes this function recursively but we don't enter
+ * the if() branch the second time
+ */
+ gimp_context_set_image (context, image);
+
+ /* 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 (image != NULL && ! gimp_container_is_empty (display_container))
+ {
+ GimpObject *display;
+ GimpImage *display_image;
+ gboolean find_display = TRUE;
+
+ display = gimp_context_get_display (context);
+
+ if (display)
+ {
+ g_object_get (display, "image", &display_image, NULL);
+
+ if (display_image)
+ {
+ g_object_unref (display_image);
+
+ if (display_image == image)
+ find_display = FALSE;
+ }
+ }
+
+ if (find_display)
+ {
+ GList *list;
+
+ for (list = GIMP_LIST (display_container)->queue->head;
+ list;
+ list = g_list_next (list))
+ {
+ display = GIMP_OBJECT (list->data);
+
+ g_object_get (display, "image", &display_image, NULL);
+
+ if (display_image)
+ {
+ g_object_unref (display_image);
+
+ if (display_image == image)
+ {
+ /* this invokes this function recursively but we
+ * don't enter the if(find_display) branch the
+ * second time
+ */
+ gimp_context_set_display (context, display);
+
+ /* don't stop signal emission here because the
+ * context's image was not changed by the
+ * recursive call
+ */
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ gimp_ui_manager_update (dock_window->p->ui_manager,
+ gimp_context_get_display (context));
+}
+
+static void
+gimp_dock_window_auto_clicked (GtkWidget *widget,
+ GimpDock *dock)
+{
+ GimpDockWindow *dock_window = GIMP_DOCK_WINDOW (dock);
+
+ gimp_toggle_button_update (widget, &dock_window->p->auto_follow_active);
+
+ if (dock_window->p->auto_follow_active)
+ {
+ GimpContext *context;
+
+ context = gimp_dialog_factory_get_context (dock_window->p->dialog_factory);
+
+ gimp_context_copy_properties (context,
+ dock_window->p->context,
+ GIMP_CONTEXT_PROP_MASK_DISPLAY |
+ GIMP_CONTEXT_PROP_MASK_IMAGE);
+ }
+}
+
+
+void
+gimp_dock_window_add_dock (GimpDockWindow *dock_window,
+ GimpDock *dock,
+ gint index)
+{
+ g_return_if_fail (GIMP_IS_DOCK_WINDOW (dock_window));
+ g_return_if_fail (GIMP_IS_DOCK (dock));
+
+ gimp_dock_columns_add_dock (dock_window->p->dock_columns,
+ GIMP_DOCK (dock),
+ index);
+
+ g_signal_connect_object (dock, "description-invalidated",
+ G_CALLBACK (gimp_dock_window_update_title),
+ dock_window,
+ G_CONNECT_SWAPPED);
+
+ /* Some docks like the toolbox dock needs to maintain special hints
+ * on its container GtkWindow, allow those to do so
+ */
+ gimp_dock_set_host_geometry_hints (dock, GTK_WINDOW (dock_window));
+ g_signal_connect_object (dock, "geometry-invalidated",
+ G_CALLBACK (gimp_dock_set_host_geometry_hints),
+ dock_window, 0);
+}
+
+void
+gimp_dock_window_remove_dock (GimpDockWindow *dock_window,
+ GimpDock *dock)
+{
+ gimp_dock_columns_remove_dock (dock_window->p->dock_columns,
+ GIMP_DOCK (dock));
+
+ g_signal_handlers_disconnect_by_func (dock,
+ gimp_dock_window_update_title,
+ dock_window);
+ g_signal_handlers_disconnect_by_func (dock,
+ gimp_dock_set_host_geometry_hints,
+ dock_window);
+}
+
+GtkWidget *
+gimp_dock_window_new (const gchar *role,
+ const gchar *ui_manager_name,
+ gboolean allow_dockbook_absence,
+ GimpDialogFactory *dialog_factory,
+ GimpContext *context)
+{
+ g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (dialog_factory), NULL);
+ g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
+
+ return g_object_new (GIMP_TYPE_DOCK_WINDOW,
+ "role", role,
+ "ui-manager-name", ui_manager_name,
+ "allow-dockbook-absence", allow_dockbook_absence,
+ "dialog-factory", dialog_factory,
+ "context", context,
+ NULL);
+}
+
+gint
+gimp_dock_window_get_id (GimpDockWindow *dock_window)
+{
+ g_return_val_if_fail (GIMP_IS_DOCK_WINDOW (dock_window), 0);
+
+ return dock_window->p->ID;
+}
+
+GimpContext *
+gimp_dock_window_get_context (GimpDockWindow *dock_window)
+{
+ g_return_val_if_fail (GIMP_IS_DOCK_WINDOW (dock_window), NULL);
+
+ return dock_window->p->context;
+}
+
+gboolean
+gimp_dock_window_get_auto_follow_active (GimpDockWindow *dock_window)
+{
+ g_return_val_if_fail (GIMP_IS_DOCK_WINDOW (dock_window), FALSE);
+
+ return dock_window->p->auto_follow_active;
+}
+
+void
+gimp_dock_window_set_auto_follow_active (GimpDockWindow *dock_window,
+ gboolean auto_follow_active)
+{
+ g_return_if_fail (GIMP_IS_DOCK_WINDOW (dock_window));
+
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dock_window->p->auto_button),
+ auto_follow_active ? TRUE : FALSE);
+}
+
+gboolean
+gimp_dock_window_get_show_image_menu (GimpDockWindow *dock_window)
+{
+ g_return_val_if_fail (GIMP_IS_DOCK_WINDOW (dock_window), FALSE);
+
+ return dock_window->p->show_image_menu;
+}
+
+void
+gimp_dock_window_set_show_image_menu (GimpDockWindow *dock_window,
+ gboolean show)
+{
+ GtkWidget *parent;
+
+ g_return_if_fail (GIMP_IS_DOCK_WINDOW (dock_window));
+
+ parent = gtk_widget_get_parent (dock_window->p->image_combo);
+
+ gtk_widget_set_visible (parent, show);
+
+ dock_window->p->show_image_menu = show ? TRUE : FALSE;
+}
+
+void
+gimp_dock_window_setup (GimpDockWindow *dock_window,
+ GimpDockWindow *template)
+{
+ gimp_dock_window_set_auto_follow_active (GIMP_DOCK_WINDOW (dock_window),
+ template->p->auto_follow_active);
+ gimp_dock_window_set_show_image_menu (GIMP_DOCK_WINDOW (dock_window),
+ template->p->show_image_menu);
+}
+
+/**
+ * gimp_dock_window_has_toolbox:
+ * @dock_window:
+ *
+ * Returns: %TRUE if the dock window has a GimpToolbox dock, %FALSE
+ * otherwise.
+ **/
+gboolean
+gimp_dock_window_has_toolbox (GimpDockWindow *dock_window)
+{
+ GList *iter = NULL;
+
+ g_return_val_if_fail (GIMP_IS_DOCK_WINDOW (dock_window), FALSE);
+
+ for (iter = gimp_dock_columns_get_docks (dock_window->p->dock_columns);
+ iter;
+ iter = g_list_next (iter))
+ {
+ if (GIMP_IS_TOOLBOX (iter->data))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+/**
+ * gimp_dock_window_from_dock:
+ * @dock:
+ *
+ * For convenience.
+ *
+ * Returns: If the toplevel widget for the dock is a GimpDockWindow,
+ * return that. Otherwise return %NULL.
+ **/
+GimpDockWindow *
+gimp_dock_window_from_dock (GimpDock *dock)
+{
+ GtkWidget *toplevel = NULL;
+
+ g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
+
+ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (dock));
+
+ if (GIMP_IS_DOCK_WINDOW (toplevel))
+ return GIMP_DOCK_WINDOW (toplevel);
+ else
+ return NULL;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-26 12:18:38 +0000