dallasgroot/Gimp
dallasgroot/Gimp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Gimp/app/widgets/gimpdock.c
Jehan 38d0abc026 app: prevent multiple registrations of a same action. 
Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or
GimpUIManager for no good reason. While it was still working with old GtkAction
code, with our new GAction-based code, we were ending up overriding an action
with a new version of the same action, while keeping reference to old actions.
This made for discrepancies of the enabled or visible state of actions.

The new code keeps singleton of some objects and references to already
registered GimpUIManager or GimpActionGroups objects and make sure no actions
with the same name are created twice.
2023-04-12 22:07:09 +02:00

629 lines
17 KiB
C
Raw Blame History

/* 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 "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_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);
}
Reference in a new issue View git blame Copy permalink