mirror of
https://gitlab.gnome.org/GNOME/gimp.git
synced 2025-07-04 01:43:24 +00:00
70ae12eb16
Inspired by Mark Sweeney's work. This patch allows the active image, brush, pattern, and gradient areas in the toolbox to scale based on user icon scale preferences. Note that if the pattern itself is smaller than the icon size, it currently won't scale larger. This is a separate issue in the renderer.
637 lines
18 KiB
C
637 lines
18 KiB
C
/* GIMP - The GNU Image Manipulation Program
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
*
|
|
* gimpdock.c
|
|
* Copyright (C) 2001-2018 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
|
|
* 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 "libgimpbase/gimpbase.h"
|
|
#include "libgimpwidgets/gimpwidgets.h"
|
|
|
|
#include "widgets-types.h"
|
|
|
|
#include "core/gimp.h"
|
|
#include "core/gimpcontext.h"
|
|
|
|
#include "menus/menus.h"
|
|
|
|
#include "gimpdialogfactory.h"
|
|
#include "gimpdock.h"
|
|
#include "gimpdockable.h"
|
|
#include "gimpdockbook.h"
|
|
#include "gimpdockcolumns.h"
|
|
#include "gimpdockcontainer.h"
|
|
#include "gimpdockwindow.h"
|
|
#include "gimppanedbox.h"
|
|
#include "gimpuimanager.h"
|
|
#include "gimpwidgets-utils.h"
|
|
|
|
#include "gimp-intl.h"
|
|
|
|
|
|
enum
|
|
{
|
|
BOOK_ADDED,
|
|
BOOK_REMOVED,
|
|
DESCRIPTION_INVALIDATED,
|
|
GEOMETRY_INVALIDATED,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
|
|
struct _GimpDockPrivate
|
|
{
|
|
GtkWidget *main_vbox;
|
|
GtkWidget *paned_vbox;
|
|
|
|
GList *dockbooks;
|
|
|
|
gint ID;
|
|
};
|
|
|
|
|
|
static void gimp_dock_dispose (GObject *object);
|
|
|
|
static gchar * gimp_dock_real_get_description (GimpDock *dock,
|
|
gboolean complete);
|
|
static void gimp_dock_real_book_added (GimpDock *dock,
|
|
GimpDockbook *dockbook);
|
|
static void gimp_dock_real_book_removed (GimpDock *dock,
|
|
GimpDockbook *dockbook);
|
|
static void gimp_dock_invalidate_description (GimpDock *dock);
|
|
static gboolean gimp_dock_dropped_cb (GtkWidget *notebook,
|
|
GtkWidget *child,
|
|
gint insert_index,
|
|
gpointer data);
|
|
|
|
|
|
G_DEFINE_TYPE_WITH_PRIVATE (GimpDock, gimp_dock, GTK_TYPE_BOX)
|
|
|
|
#define parent_class gimp_dock_parent_class
|
|
|
|
static guint dock_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
|
|
static void
|
|
gimp_dock_class_init (GimpDockClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
|
|
|
|
dock_signals[BOOK_ADDED] =
|
|
g_signal_new ("book-added",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST,
|
|
G_STRUCT_OFFSET (GimpDockClass, book_added),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1,
|
|
GIMP_TYPE_DOCKBOOK);
|
|
|
|
dock_signals[BOOK_REMOVED] =
|
|
g_signal_new ("book-removed",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST,
|
|
G_STRUCT_OFFSET (GimpDockClass, book_removed),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1,
|
|
GIMP_TYPE_DOCKBOOK);
|
|
|
|
dock_signals[DESCRIPTION_INVALIDATED] =
|
|
g_signal_new ("description-invalidated",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST,
|
|
G_STRUCT_OFFSET (GimpDockClass, description_invalidated),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 0);
|
|
|
|
dock_signals[GEOMETRY_INVALIDATED] =
|
|
g_signal_new ("geometry-invalidated",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST,
|
|
G_STRUCT_OFFSET (GimpDockClass, geometry_invalidated),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 0);
|
|
|
|
object_class->dispose = gimp_dock_dispose;
|
|
|
|
klass->get_description = gimp_dock_real_get_description;
|
|
klass->set_host_geometry_hints = NULL;
|
|
klass->book_added = gimp_dock_real_book_added;
|
|
klass->book_removed = gimp_dock_real_book_removed;
|
|
klass->description_invalidated = NULL;
|
|
klass->geometry_invalidated = NULL;
|
|
|
|
gtk_widget_class_install_style_property (widget_class,
|
|
g_param_spec_enum ("tool-icon-size",
|
|
NULL, NULL,
|
|
GTK_TYPE_ICON_SIZE,
|
|
GTK_ICON_SIZE_SMALL_TOOLBAR,
|
|
GIMP_PARAM_READABLE));
|
|
|
|
gtk_widget_class_set_css_name (widget_class, "GimpDock");
|
|
}
|
|
|
|
static void
|
|
gimp_dock_init (GimpDock *dock)
|
|
{
|
|
static gint dock_ID = 1;
|
|
gchar *name = NULL;
|
|
|
|
gtk_orientable_set_orientation (GTK_ORIENTABLE (dock),
|
|
GTK_ORIENTATION_VERTICAL);
|
|
|
|
dock->p = gimp_dock_get_instance_private (dock);
|
|
dock->p->ID = dock_ID++;
|
|
|
|
name = g_strdup_printf ("gimp-internal-dock-%d", dock->p->ID);
|
|
gtk_widget_set_name (GTK_WIDGET (dock), name);
|
|
g_free (name);
|
|
|
|
dock->p->main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
|
|
gtk_box_pack_start (GTK_BOX (dock), dock->p->main_vbox, TRUE, TRUE, 0);
|
|
gtk_widget_show (dock->p->main_vbox);
|
|
|
|
dock->p->paned_vbox = gimp_paned_box_new (FALSE, 0, GTK_ORIENTATION_VERTICAL);
|
|
gimp_paned_box_set_dropped_cb (GIMP_PANED_BOX (dock->p->paned_vbox),
|
|
gimp_dock_dropped_cb,
|
|
dock);
|
|
gtk_box_pack_start (GTK_BOX (dock->p->main_vbox), dock->p->paned_vbox,
|
|
TRUE, TRUE, 0);
|
|
gtk_widget_show (dock->p->paned_vbox);
|
|
}
|
|
|
|
static void
|
|
gimp_dock_dispose (GObject *object)
|
|
{
|
|
GimpDock *dock = GIMP_DOCK (object);
|
|
|
|
while (dock->p->dockbooks)
|
|
{
|
|
GimpDockbook *dockbook = dock->p->dockbooks->data;
|
|
|
|
g_object_ref (dockbook);
|
|
gimp_dock_remove_book (dock, dockbook);
|
|
gtk_widget_destroy (GTK_WIDGET (dockbook));
|
|
g_object_unref (dockbook);
|
|
}
|
|
|
|
G_OBJECT_CLASS (parent_class)->dispose (object);
|
|
}
|
|
|
|
static gchar *
|
|
gimp_dock_real_get_description (GimpDock *dock,
|
|
gboolean complete)
|
|
{
|
|
GString *desc;
|
|
GList *list;
|
|
|
|
desc = g_string_new (NULL);
|
|
|
|
for (list = gimp_dock_get_dockbooks (dock);
|
|
list;
|
|
list = g_list_next (list))
|
|
{
|
|
GimpDockbook *dockbook = list->data;
|
|
GList *children;
|
|
GList *child;
|
|
|
|
if (complete)
|
|
{
|
|
/* Include all dockables */
|
|
children = gtk_container_get_children (GTK_CONTAINER (dockbook));
|
|
}
|
|
else
|
|
{
|
|
GtkWidget *dockable = NULL;
|
|
gint page_num = 0;
|
|
|
|
page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (dockbook));
|
|
dockable = gtk_notebook_get_nth_page (GTK_NOTEBOOK (dockbook), page_num);
|
|
|
|
/* Only include active dockables */
|
|
children = g_list_append (NULL, dockable);
|
|
}
|
|
|
|
for (child = children; child; child = g_list_next (child))
|
|
{
|
|
GimpDockable *dockable = child->data;
|
|
|
|
g_string_append (desc, gimp_dockable_get_name (dockable));
|
|
|
|
if (g_list_next (child))
|
|
g_string_append (desc, GIMP_DOCK_DOCKABLE_SEPARATOR);
|
|
}
|
|
|
|
g_list_free (children);
|
|
|
|
if (g_list_next (list))
|
|
g_string_append (desc, GIMP_DOCK_BOOK_SEPARATOR);
|
|
}
|
|
|
|
return g_string_free (desc, FALSE);
|
|
}
|
|
|
|
static void
|
|
gimp_dock_real_book_added (GimpDock *dock,
|
|
GimpDockbook *dockbook)
|
|
{
|
|
g_signal_connect_object (dockbook, "switch-page",
|
|
G_CALLBACK (gimp_dock_invalidate_description),
|
|
dock, G_CONNECT_SWAPPED);
|
|
}
|
|
|
|
static void
|
|
gimp_dock_real_book_removed (GimpDock *dock,
|
|
GimpDockbook *dockbook)
|
|
{
|
|
g_signal_handlers_disconnect_by_func (dockbook,
|
|
gimp_dock_invalidate_description,
|
|
dock);
|
|
}
|
|
|
|
static void
|
|
gimp_dock_invalidate_description (GimpDock *dock)
|
|
{
|
|
g_return_if_fail (GIMP_IS_DOCK (dock));
|
|
|
|
g_signal_emit (dock, dock_signals[DESCRIPTION_INVALIDATED], 0);
|
|
}
|
|
|
|
static gboolean
|
|
gimp_dock_dropped_cb (GtkWidget *notebook,
|
|
GtkWidget *child,
|
|
gint insert_index,
|
|
gpointer data)
|
|
{
|
|
GimpDock *dock = GIMP_DOCK (data);
|
|
GimpDockbook *dockbook = GIMP_DOCKBOOK (notebook);
|
|
GimpDockable *dockable = GIMP_DOCKABLE (child);
|
|
GimpDialogFactory *factory;
|
|
GtkWidget *new_dockbook;
|
|
|
|
/* if dropping to the same dock, take care that we don't try
|
|
* to reorder the *only* dockable in the dock
|
|
*/
|
|
if (gimp_dockbook_get_dock (dockbook) == dock)
|
|
{
|
|
GList *children = gtk_container_get_children (GTK_CONTAINER (dockable));
|
|
gint n_dockables = g_list_length (children);
|
|
gint n_books = g_list_length (gimp_dock_get_dockbooks (dock));
|
|
|
|
g_list_free (children);
|
|
|
|
if (n_books == 1 && n_dockables == 1)
|
|
return TRUE; /* successfully do nothing */
|
|
}
|
|
|
|
/* Detach the dockable from the old dockbook */
|
|
g_object_ref (dockable);
|
|
gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), child);
|
|
|
|
/* Create a new dockbook */
|
|
factory = gimp_dock_get_dialog_factory (dock);
|
|
new_dockbook = gimp_dockbook_new (menus_get_global_menu_factory (gimp_dialog_factory_get_context (factory)->gimp));
|
|
gimp_dock_add_book (dock, GIMP_DOCKBOOK (new_dockbook), insert_index);
|
|
|
|
/* Add the dockable to new new dockbook */
|
|
gtk_notebook_append_page (GTK_NOTEBOOK (new_dockbook), child, NULL);
|
|
g_object_unref (dockable);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* public functions */
|
|
|
|
/**
|
|
* gimp_dock_get_description:
|
|
* @dock:
|
|
* @complete: If %TRUE, only includes the active dockables, i.e. not the
|
|
* dockables in a non-active GtkNotebook tab
|
|
*
|
|
* Returns: A string describing the contents of the dock.
|
|
**/
|
|
gchar *
|
|
gimp_dock_get_description (GimpDock *dock,
|
|
gboolean complete)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
|
|
|
|
if (GIMP_DOCK_GET_CLASS (dock)->get_description)
|
|
return GIMP_DOCK_GET_CLASS (dock)->get_description (dock, complete);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* gimp_dock_set_host_geometry_hints:
|
|
* @dock: The dock
|
|
* @window: The #GtkWindow to adapt to hosting the dock
|
|
*
|
|
* Some docks have some specific needs on the #GtkWindow they are
|
|
* in. This function allows such docks to perform any such setup on
|
|
* the #GtkWindow they are in/will be put in.
|
|
**/
|
|
void
|
|
gimp_dock_set_host_geometry_hints (GimpDock *dock,
|
|
GtkWindow *window)
|
|
{
|
|
g_return_if_fail (GIMP_IS_DOCK (dock));
|
|
g_return_if_fail (GTK_IS_WINDOW (window));
|
|
|
|
if (GIMP_DOCK_GET_CLASS (dock)->set_host_geometry_hints)
|
|
GIMP_DOCK_GET_CLASS (dock)->set_host_geometry_hints (dock, window);
|
|
}
|
|
|
|
/**
|
|
* gimp_dock_invalidate_geometry:
|
|
* @dock:
|
|
*
|
|
* Call when the dock needs to setup its host #GtkWindow with
|
|
* GtkDock::set_host_geometry_hints().
|
|
**/
|
|
void
|
|
gimp_dock_invalidate_geometry (GimpDock *dock)
|
|
{
|
|
g_return_if_fail (GIMP_IS_DOCK (dock));
|
|
|
|
g_signal_emit (dock, dock_signals[GEOMETRY_INVALIDATED], 0);
|
|
}
|
|
|
|
/**
|
|
* gimp_dock_update_with_context:
|
|
* @dock:
|
|
* @context:
|
|
*
|
|
* Set the @context on all dockables in the @dock.
|
|
**/
|
|
void
|
|
gimp_dock_update_with_context (GimpDock *dock,
|
|
GimpContext *context)
|
|
{
|
|
GList *iter = NULL;
|
|
|
|
for (iter = gimp_dock_get_dockbooks (dock);
|
|
iter;
|
|
iter = g_list_next (iter))
|
|
{
|
|
GimpDockbook *dockbook = GIMP_DOCKBOOK (iter->data);
|
|
|
|
gimp_dockbook_update_with_context (dockbook, context);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gimp_dock_get_context:
|
|
* @dock:
|
|
*
|
|
* Returns: The #GimpContext for the #GimpDockWindow the @dock is in.
|
|
**/
|
|
GimpContext *
|
|
gimp_dock_get_context (GimpDock *dock)
|
|
{
|
|
GimpContext *context = NULL;
|
|
|
|
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
|
|
|
|
/* First try GimpDockColumns */
|
|
if (! context)
|
|
{
|
|
GimpDockColumns *dock_columns;
|
|
|
|
dock_columns =
|
|
GIMP_DOCK_COLUMNS (gtk_widget_get_ancestor (GTK_WIDGET (dock),
|
|
GIMP_TYPE_DOCK_COLUMNS));
|
|
|
|
if (dock_columns)
|
|
context = gimp_dock_columns_get_context (dock_columns);
|
|
}
|
|
|
|
/* Then GimpDockWindow */
|
|
if (! context)
|
|
{
|
|
GimpDockWindow *dock_window = gimp_dock_window_from_dock (dock);
|
|
|
|
if (dock_window)
|
|
context = gimp_dock_window_get_context (dock_window);
|
|
}
|
|
|
|
return context;
|
|
}
|
|
|
|
/**
|
|
* gimp_dock_get_dialog_factory:
|
|
* @dock:
|
|
*
|
|
* Returns: The #GimpDialogFactory for the #GimpDockWindow the @dock
|
|
* is in.
|
|
**/
|
|
GimpDialogFactory *
|
|
gimp_dock_get_dialog_factory (GimpDock *dock)
|
|
{
|
|
GimpDialogFactory *dialog_factory = NULL;
|
|
|
|
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
|
|
|
|
/* First try GimpDockColumns */
|
|
if (! dialog_factory)
|
|
{
|
|
GimpDockColumns *dock_columns;
|
|
|
|
dock_columns =
|
|
GIMP_DOCK_COLUMNS (gtk_widget_get_ancestor (GTK_WIDGET (dock),
|
|
GIMP_TYPE_DOCK_COLUMNS));
|
|
|
|
if (dock_columns)
|
|
dialog_factory = gimp_dock_columns_get_dialog_factory (dock_columns);
|
|
}
|
|
|
|
/* Then GimpDockWindow */
|
|
if (! dialog_factory)
|
|
{
|
|
GimpDockWindow *dock_window = gimp_dock_window_from_dock (dock);
|
|
|
|
if (dock_window)
|
|
dialog_factory = gimp_dock_container_get_dialog_factory (GIMP_DOCK_CONTAINER (dock_window));
|
|
}
|
|
|
|
return dialog_factory;
|
|
}
|
|
|
|
/**
|
|
* gimp_dock_get_ui_manager:
|
|
* @dock:
|
|
*
|
|
* Returns: The #GimpUIManager for the #GimpDockWindow the @dock is
|
|
* in.
|
|
**/
|
|
GimpUIManager *
|
|
gimp_dock_get_ui_manager (GimpDock *dock)
|
|
{
|
|
GimpUIManager *ui_manager = NULL;
|
|
|
|
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
|
|
|
|
/* First try GimpDockColumns */
|
|
if (! ui_manager)
|
|
{
|
|
GimpDockColumns *dock_columns;
|
|
|
|
dock_columns =
|
|
GIMP_DOCK_COLUMNS (gtk_widget_get_ancestor (GTK_WIDGET (dock),
|
|
GIMP_TYPE_DOCK_COLUMNS));
|
|
|
|
if (dock_columns)
|
|
ui_manager = gimp_dock_columns_get_ui_manager (dock_columns);
|
|
}
|
|
|
|
/* Then GimpDockContainer */
|
|
if (! ui_manager)
|
|
{
|
|
GimpDockWindow *dock_window = gimp_dock_window_from_dock (dock);
|
|
|
|
if (dock_window)
|
|
{
|
|
GimpDockContainer *dock_container = GIMP_DOCK_CONTAINER (dock_window);
|
|
|
|
ui_manager = gimp_dock_container_get_ui_manager (dock_container);
|
|
}
|
|
}
|
|
|
|
return ui_manager;
|
|
}
|
|
|
|
GList *
|
|
gimp_dock_get_dockbooks (GimpDock *dock)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
|
|
|
|
return dock->p->dockbooks;
|
|
}
|
|
|
|
gint
|
|
gimp_dock_get_n_dockables (GimpDock *dock)
|
|
{
|
|
GList *list = NULL;
|
|
gint n = 0;
|
|
|
|
g_return_val_if_fail (GIMP_IS_DOCK (dock), 0);
|
|
|
|
for (list = dock->p->dockbooks; list; list = list->next)
|
|
n += gtk_notebook_get_n_pages (GTK_NOTEBOOK (list->data));
|
|
|
|
return n;
|
|
}
|
|
|
|
GtkWidget *
|
|
gimp_dock_get_main_vbox (GimpDock *dock)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
|
|
|
|
return dock->p->main_vbox;
|
|
}
|
|
|
|
GtkWidget *
|
|
gimp_dock_get_vbox (GimpDock *dock)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_DOCK (dock), NULL);
|
|
|
|
return dock->p->paned_vbox;
|
|
}
|
|
|
|
void
|
|
gimp_dock_set_id (GimpDock *dock,
|
|
gint ID)
|
|
{
|
|
g_return_if_fail (GIMP_IS_DOCK (dock));
|
|
|
|
dock->p->ID = ID;
|
|
}
|
|
|
|
gint
|
|
gimp_dock_get_id (GimpDock *dock)
|
|
{
|
|
g_return_val_if_fail (GIMP_IS_DOCK (dock), 0);
|
|
|
|
return dock->p->ID;
|
|
}
|
|
|
|
void
|
|
gimp_dock_add_book (GimpDock *dock,
|
|
GimpDockbook *dockbook,
|
|
gint index)
|
|
{
|
|
g_return_if_fail (GIMP_IS_DOCK (dock));
|
|
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
|
|
g_return_if_fail (gimp_dockbook_get_dock (dockbook) == NULL);
|
|
|
|
gimp_dockbook_set_dock (dockbook, dock);
|
|
|
|
g_signal_connect_object (dockbook, "dockable-added",
|
|
G_CALLBACK (gimp_dock_invalidate_description),
|
|
dock, G_CONNECT_SWAPPED);
|
|
g_signal_connect_object (dockbook, "dockable-removed",
|
|
G_CALLBACK (gimp_dock_invalidate_description),
|
|
dock, G_CONNECT_SWAPPED);
|
|
g_signal_connect_object (dockbook, "dockable-reordered",
|
|
G_CALLBACK (gimp_dock_invalidate_description),
|
|
dock, G_CONNECT_SWAPPED);
|
|
|
|
dock->p->dockbooks = g_list_insert (dock->p->dockbooks, dockbook, index);
|
|
gimp_paned_box_add_widget (GIMP_PANED_BOX (dock->p->paned_vbox),
|
|
GTK_WIDGET (dockbook),
|
|
index);
|
|
gtk_widget_show (GTK_WIDGET (dockbook));
|
|
|
|
gimp_dock_invalidate_description (dock);
|
|
|
|
g_signal_emit (dock, dock_signals[BOOK_ADDED], 0, dockbook);
|
|
}
|
|
|
|
void
|
|
gimp_dock_remove_book (GimpDock *dock,
|
|
GimpDockbook *dockbook)
|
|
{
|
|
g_return_if_fail (GIMP_IS_DOCK (dock));
|
|
g_return_if_fail (GIMP_IS_DOCKBOOK (dockbook));
|
|
g_return_if_fail (gimp_dockbook_get_dock (dockbook) == dock);
|
|
|
|
gimp_dockbook_set_dock (dockbook, NULL);
|
|
|
|
g_signal_handlers_disconnect_by_func (dockbook,
|
|
gimp_dock_invalidate_description,
|
|
dock);
|
|
|
|
/* Ref the dockbook so we can emit the "book-removed" signal and
|
|
* pass it as a parameter before it's destroyed
|
|
*/
|
|
g_object_ref (dockbook);
|
|
|
|
dock->p->dockbooks = g_list_remove (dock->p->dockbooks, dockbook);
|
|
gimp_paned_box_remove_widget (GIMP_PANED_BOX (dock->p->paned_vbox),
|
|
GTK_WIDGET (dockbook));
|
|
|
|
gimp_dock_invalidate_description (dock);
|
|
|
|
g_signal_emit (dock, dock_signals[BOOK_REMOVED], 0, dockbook);
|
|
|
|
g_object_unref (dockbook);
|
|
}
|