diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:30:19 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:30:19 +0000 |
commit | 5c1676dfe6d2f3c837a5e074117b45613fd29a72 (patch) | |
tree | cbffb45144febf451e54061db2b21395faf94bfe /app/widgets/gimptooleditor.c | |
parent | Initial commit. (diff) | |
download | gimp-5c1676dfe6d2f3c837a5e074117b45613fd29a72.tar.xz gimp-5c1676dfe6d2f3c837a5e074117b45613fd29a72.zip |
Adding upstream version 2.10.34.upstream/2.10.34upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | app/widgets/gimptooleditor.c | 844 |
1 files changed, 844 insertions, 0 deletions
diff --git a/app/widgets/gimptooleditor.c b/app/widgets/gimptooleditor.c new file mode 100644 index 0000000..eecc676 --- /dev/null +++ b/app/widgets/gimptooleditor.c @@ -0,0 +1,844 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimptooleditor.c + * Copyright (C) 2001-2009 Michael Natterer <mitch@gimp.org> + * Stephen Griffiths <scgmk5@gmail.com> + * + * 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 "libgimpconfig/gimpconfig.h" +#include "libgimpwidgets/gimpwidgets.h" + +#include "widgets-types.h" + +#include "core/gimp.h" +#include "core/gimpcontainer.h" +#include "core/gimpcontext.h" +#include "core/gimptoolgroup.h" +#include "core/gimptreehandler.h" + +#include "tools/gimp-tools.h" + +#include "gimpcontainertreestore.h" +#include "gimpcontainerview.h" +#include "gimpdnd.h" +#include "gimpviewrenderer.h" +#include "gimptooleditor.h" +#include "gimphelp-ids.h" +#include "gimpwidgets-utils.h" + +#include "gimp-intl.h" + + +struct _GimpToolEditorPrivate +{ + GimpContainer *container; + GimpContext *context; + + GtkWidget *scrolled; + + GtkWidget *new_group_button; + GtkWidget *raise_button; + GtkWidget *lower_button; + GtkWidget *delete_button; + GtkWidget *reset_button; + + GimpTreeHandler *tool_item_notify_handler; + + /* State of tools at creation of the editor, stored to support + * reverting changes + */ + gchar *initial_tool_state; +}; + + +/* local function prototypes */ + +static void gimp_tool_editor_view_iface_init (GimpContainerViewInterface *iface); + +static void gimp_tool_editor_constructed (GObject *object); + +static gboolean gimp_tool_editor_select_item (GimpContainerView *view, + GimpViewable *viewable, + gpointer insert_data); +static void gimp_tool_editor_set_container (GimpContainerView *container_view, + GimpContainer *container); +static void gimp_tool_editor_set_context (GimpContainerView *container_view, + GimpContext *context); + +static gboolean gimp_tool_editor_drop_possible (GimpContainerTreeView *tree_view, + GimpDndType src_type, + GimpViewable *src_viewable, + GimpViewable *dest_viewable, + GtkTreePath *drop_path, + GtkTreeViewDropPosition drop_pos, + GtkTreeViewDropPosition *return_drop_pos, + GdkDragAction *return_drag_action); +static void gimp_tool_editor_drop_viewable (GimpContainerTreeView *tree_view, + GimpViewable *src_viewable, + GimpViewable *dest_viewable, + GtkTreeViewDropPosition drop_pos); + +static void gimp_tool_editor_tool_item_notify (GimpToolItem *tool_item, + GParamSpec *pspec, + GimpToolEditor *tool_editor); + +static void gimp_tool_editor_eye_data_func (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell, + GtkTreeModel *tree_model, + GtkTreeIter *iter, + gpointer data); +static void gimp_tool_editor_eye_clicked (GtkCellRendererToggle *toggle, + gchar *path_str, + GdkModifierType state, + GimpToolEditor *tool_editor); + +static void gimp_tool_editor_new_group_clicked (GtkButton *button, + GimpToolEditor *tool_editor); +static void gimp_tool_editor_raise_clicked (GtkButton *button, + GimpToolEditor *tool_editor); +static void gimp_tool_editor_raise_extend_clicked (GtkButton *button, + GdkModifierType mask, + GimpToolEditor *tool_editor); +static void gimp_tool_editor_lower_clicked (GtkButton *button, + GimpToolEditor *tool_editor); +static void gimp_tool_editor_lower_extend_clicked (GtkButton *button, + GdkModifierType mask, + GimpToolEditor *tool_editor); +static void gimp_tool_editor_delete_clicked (GtkButton *button, + GimpToolEditor *tool_editor); +static void gimp_tool_editor_reset_clicked (GtkButton *button, + GimpToolEditor *tool_editor); + +static GimpToolItem * gimp_tool_editor_get_selected_tool_item (GimpToolEditor *tool_editor); +static GimpContainer * gimp_tool_editor_get_tool_item_container (GimpToolEditor *tool_editor, + GimpToolItem *tool_item); + +static void gimp_tool_editor_update_container (GimpToolEditor *tool_editor); +static void gimp_tool_editor_update_sensitivity (GimpToolEditor *tool_editor); + + +G_DEFINE_TYPE_WITH_CODE (GimpToolEditor, gimp_tool_editor, + GIMP_TYPE_CONTAINER_TREE_VIEW, + G_ADD_PRIVATE (GimpToolEditor) + G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW, + gimp_tool_editor_view_iface_init)) + +#define parent_class gimp_tool_editor_parent_class + +static GimpContainerViewInterface *parent_view_iface = NULL; + + +/* private functions */ + +static void +gimp_tool_editor_class_init (GimpToolEditorClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpContainerTreeViewClass *tree_view_class = GIMP_CONTAINER_TREE_VIEW_CLASS (klass); + + object_class->constructed = gimp_tool_editor_constructed; + + tree_view_class->drop_possible = gimp_tool_editor_drop_possible; + tree_view_class->drop_viewable = gimp_tool_editor_drop_viewable; +} + +static void +gimp_tool_editor_view_iface_init (GimpContainerViewInterface *iface) +{ + parent_view_iface = g_type_interface_peek_parent (iface); + + if (! parent_view_iface) + parent_view_iface = g_type_default_interface_peek (GIMP_TYPE_CONTAINER_VIEW); + + iface->select_item = gimp_tool_editor_select_item; + iface->set_container = gimp_tool_editor_set_container; + iface->set_context = gimp_tool_editor_set_context; +} + +static void +gimp_tool_editor_init (GimpToolEditor *tool_editor) +{ + tool_editor->priv = gimp_tool_editor_get_instance_private (tool_editor); +} + +static void +gimp_tool_editor_constructed (GObject *object) +{ + GimpToolEditor *tool_editor = GIMP_TOOL_EDITOR (object); + GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (object); + GimpContainerView *container_view = GIMP_CONTAINER_VIEW (object); + gint view_size; + gint border_width; + + G_OBJECT_CLASS (parent_class)->constructed (object); + + view_size = gimp_container_view_get_view_size (container_view, + &border_width); + + gimp_editor_set_show_name (GIMP_EDITOR (tool_editor), FALSE); + + gtk_tree_view_set_level_indentation (tree_view->view, + 0.8 * (view_size + 2 * border_width)); + + gimp_dnd_viewable_dest_add (GTK_WIDGET (tree_view->view), + GIMP_TYPE_TOOL_ITEM, + NULL, NULL); + + /* construct tree view */ + { + GtkTreeViewColumn *column; + GtkCellRenderer *eye_cell; + GtkStyle *tree_style; + GtkIconSize icon_size; + + tree_style = gtk_widget_get_style (GTK_WIDGET (tool_editor)); + + icon_size = gimp_get_icon_size (GTK_WIDGET (tool_editor), + GIMP_ICON_VISIBLE, + GTK_ICON_SIZE_BUTTON, + view_size - + 2 * tree_style->xthickness, + view_size - + 2 * tree_style->ythickness); + + column = gtk_tree_view_column_new (); + gtk_tree_view_insert_column (tree_view->view, column, 0); + + eye_cell = gimp_cell_renderer_toggle_new (GIMP_ICON_VISIBLE); + g_object_set (eye_cell, "stock-size", icon_size, NULL); + gtk_tree_view_column_pack_start (column, eye_cell, FALSE); + gtk_tree_view_column_set_cell_data_func (column, eye_cell, + gimp_tool_editor_eye_data_func, + tree_view, NULL); + + gimp_container_tree_view_add_toggle_cell (tree_view, eye_cell); + + g_signal_connect (eye_cell, "clicked", + G_CALLBACK (gimp_tool_editor_eye_clicked), + tool_editor); + } + + /* buttons */ + tool_editor->priv->new_group_button = + gimp_editor_add_button (GIMP_EDITOR (tool_editor), GIMP_ICON_FOLDER_NEW, + _("Create a new tool group"), NULL, + G_CALLBACK (gimp_tool_editor_new_group_clicked), + NULL, + G_OBJECT (tool_editor)); + + tool_editor->priv->raise_button = + gimp_editor_add_button (GIMP_EDITOR (tool_editor), GIMP_ICON_GO_UP, + _("Raise this item"), + _("Raise this item to the top"), + G_CALLBACK (gimp_tool_editor_raise_clicked), + G_CALLBACK (gimp_tool_editor_raise_extend_clicked), + G_OBJECT (tool_editor)); + + tool_editor->priv->lower_button = + gimp_editor_add_button (GIMP_EDITOR (tool_editor), GIMP_ICON_GO_DOWN, + _("Lower this item"), + _("Lower this item to the bottom"), + G_CALLBACK (gimp_tool_editor_lower_clicked), + G_CALLBACK (gimp_tool_editor_lower_extend_clicked), + G_OBJECT (tool_editor)); + + tool_editor->priv->delete_button = + gimp_editor_add_button (GIMP_EDITOR (tool_editor), GIMP_ICON_EDIT_DELETE, + _("Delete this tool group"), NULL, + G_CALLBACK (gimp_tool_editor_delete_clicked), + NULL, + G_OBJECT (tool_editor)); + + tool_editor->priv->reset_button = + gimp_editor_add_button (GIMP_EDITOR (tool_editor), GIMP_ICON_RESET, + _("Reset tool order and visibility"), NULL, + G_CALLBACK (gimp_tool_editor_reset_clicked), + NULL, + G_OBJECT (tool_editor)); + + gimp_tool_editor_update_sensitivity (tool_editor); +} + +static gboolean +gimp_tool_editor_select_item (GimpContainerView *container_view, + GimpViewable *viewable, + gpointer insert_data) +{ + GimpToolEditor *tool_editor = GIMP_TOOL_EDITOR (container_view); + gboolean result; + + result = parent_view_iface->select_item (container_view, + viewable, insert_data); + + gimp_tool_editor_update_sensitivity (tool_editor); + + return result; +} + +static void +gimp_tool_editor_set_container (GimpContainerView *container_view, + GimpContainer *container) +{ + GimpToolEditor *tool_editor = GIMP_TOOL_EDITOR (container_view); + + parent_view_iface->set_container (container_view, container); + + gimp_tool_editor_update_container (tool_editor); +} + +static void +gimp_tool_editor_set_context (GimpContainerView *container_view, + GimpContext *context) +{ + GimpToolEditor *tool_editor = GIMP_TOOL_EDITOR (container_view); + + parent_view_iface->set_context (container_view, context); + + gimp_tool_editor_update_container (tool_editor); +} + +static gboolean +gimp_tool_editor_drop_possible (GimpContainerTreeView *tree_view, + GimpDndType src_type, + GimpViewable *src_viewable, + GimpViewable *dest_viewable, + GtkTreePath *drop_path, + GtkTreeViewDropPosition drop_pos, + GtkTreeViewDropPosition *return_drop_pos, + GdkDragAction *return_drag_action) +{ + if (GIMP_CONTAINER_TREE_VIEW_CLASS (parent_class)->drop_possible ( + tree_view, + src_type, src_viewable, dest_viewable, drop_path, drop_pos, + return_drop_pos, return_drag_action)) + { + if (gimp_viewable_get_parent (dest_viewable) || + (gimp_viewable_get_children (dest_viewable) && + (drop_pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER || + drop_pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))) + { + return ! gimp_viewable_get_children (src_viewable); + } + + return TRUE; + } + + return FALSE; +} + +static void +gimp_tool_editor_drop_viewable (GimpContainerTreeView *tree_view, + GimpViewable *src_viewable, + GimpViewable *dest_viewable, + GtkTreeViewDropPosition drop_pos) +{ + GimpContainerView *container_view = GIMP_CONTAINER_VIEW (tree_view); + + GIMP_CONTAINER_TREE_VIEW_CLASS (parent_class)->drop_viewable (tree_view, + src_viewable, + dest_viewable, + drop_pos); + + gimp_container_view_select_item (container_view, src_viewable); +} + +static void +gimp_tool_editor_new_group_clicked (GtkButton *button, + GimpToolEditor *tool_editor) +{ + GimpContainerView *container_view = GIMP_CONTAINER_VIEW (tool_editor); + GimpContainer *container; + GimpToolItem *tool_item; + GimpToolGroup *group; + gint index = 0; + + tool_item = gimp_tool_editor_get_selected_tool_item (tool_editor); + + if (tool_item) + { + if (gimp_viewable_get_parent (GIMP_VIEWABLE (tool_item)) != NULL) + return; + + container = gimp_tool_editor_get_tool_item_container (tool_editor, + tool_item); + + index = gimp_container_get_child_index (container, + GIMP_OBJECT (tool_item)); + } + else + { + container = tool_editor->priv->container; + } + + if (container) + { + group = gimp_tool_group_new (); + + gimp_container_insert (container, GIMP_OBJECT (group), index); + + g_object_unref (group); + + gimp_container_view_select_item (container_view, GIMP_VIEWABLE (group)); + } +} + +static void +gimp_tool_editor_raise_clicked (GtkButton *button, + GimpToolEditor *tool_editor) +{ + GimpToolItem *tool_item; + + tool_item = gimp_tool_editor_get_selected_tool_item (tool_editor); + + if (tool_item) + { + GimpContainer *container; + gint index; + + container = gimp_tool_editor_get_tool_item_container (tool_editor, + tool_item); + + index = gimp_container_get_child_index (container, + GIMP_OBJECT (tool_item)); + + if (index > 0) + { + gimp_container_reorder (container, + GIMP_OBJECT (tool_item), index - 1); + } + } +} + +static void +gimp_tool_editor_raise_extend_clicked (GtkButton *button, + GdkModifierType mask, + GimpToolEditor *tool_editor) +{ + GimpToolItem *tool_item; + + tool_item = gimp_tool_editor_get_selected_tool_item (tool_editor); + + if (tool_item && (mask & GDK_SHIFT_MASK)) + { + GimpContainer *container; + gint index; + + container = gimp_tool_editor_get_tool_item_container (tool_editor, + tool_item); + + index = gimp_container_get_child_index (container, + GIMP_OBJECT (tool_item)); + + if (index > 0) + { + gimp_container_reorder (container, + GIMP_OBJECT (tool_item), 0); + } + } +} + +static void +gimp_tool_editor_lower_clicked (GtkButton *button, + GimpToolEditor *tool_editor) +{ + GimpToolItem *tool_item; + + tool_item = gimp_tool_editor_get_selected_tool_item (tool_editor); + + if (tool_item) + { + GimpContainer *container; + gint index; + + container = gimp_tool_editor_get_tool_item_container (tool_editor, + tool_item); + + index = gimp_container_get_child_index (container, + GIMP_OBJECT (tool_item)); + + if (index + 1 < gimp_container_get_n_children (container)) + { + gimp_container_reorder (container, + GIMP_OBJECT (tool_item), index + 1); + } + } +} + +static void +gimp_tool_editor_lower_extend_clicked (GtkButton *button, + GdkModifierType mask, + GimpToolEditor *tool_editor) +{ + GimpToolItem *tool_item; + + tool_item = gimp_tool_editor_get_selected_tool_item (tool_editor); + + if (tool_item && (mask & GDK_SHIFT_MASK)) + { + GimpContainer *container; + gint index; + + container = gimp_tool_editor_get_tool_item_container (tool_editor, + tool_item); + + index = gimp_container_get_n_children (container) - 1; + index = MAX (index, 0); + + gimp_container_reorder (container, + GIMP_OBJECT (tool_item), index); + } +} + +static void +gimp_tool_editor_delete_clicked (GtkButton *button, + GimpToolEditor *tool_editor) +{ + GimpContainerView *container_view = GIMP_CONTAINER_VIEW (tool_editor); + GimpToolItem *tool_item; + + tool_item = gimp_tool_editor_get_selected_tool_item (tool_editor); + + if (tool_item) + { + GimpContainer *src_container; + GimpContainer *dest_container; + gint index; + gint dest_index; + + src_container = gimp_viewable_get_children (GIMP_VIEWABLE (tool_item)); + dest_container = gimp_tool_editor_get_tool_item_container (tool_editor, + tool_item); + + if (! src_container) + return; + + index = gimp_container_get_child_index (dest_container, + GIMP_OBJECT (tool_item)); + dest_index = index; + + g_object_ref (tool_item); + + gimp_container_freeze (src_container); + gimp_container_freeze (dest_container); + + gimp_container_remove (dest_container, GIMP_OBJECT (tool_item)); + + while (! gimp_container_is_empty (src_container)) + { + GimpObject *object = gimp_container_get_first_child (src_container); + + g_object_ref (object); + + gimp_container_remove (src_container, object); + gimp_container_insert (dest_container, object, dest_index++); + + g_object_unref (object); + } + + gimp_container_thaw (dest_container); + gimp_container_thaw (src_container); + + gimp_container_view_select_item ( + container_view, + GIMP_VIEWABLE (gimp_container_get_child_by_index (dest_container, + index))); + + g_object_unref (tool_item); + } +} + +static void +gimp_tool_editor_reset_clicked (GtkButton *button, + GimpToolEditor *tool_editor) +{ + gimp_tools_reset (tool_editor->priv->context->gimp, + tool_editor->priv->container, + FALSE); +} + +static void +gimp_tool_editor_tool_item_notify (GimpToolItem *tool_item, + GParamSpec *pspec, + GimpToolEditor *tool_editor) +{ + GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (tool_editor); + GimpContainerView *container_view = GIMP_CONTAINER_VIEW (tool_editor); + GtkTreeIter *iter; + + iter = gimp_container_view_lookup (container_view, + GIMP_VIEWABLE (tool_item)); + + if (iter) + { + GtkTreePath *path; + + path = gtk_tree_model_get_path (tree_view->model, iter); + + gtk_tree_model_row_changed (tree_view->model, path, iter); + + gtk_tree_path_free (path); + } +} + +static void +gimp_tool_editor_eye_data_func (GtkTreeViewColumn *tree_column, + GtkCellRenderer *cell, + GtkTreeModel *tree_model, + GtkTreeIter *iter, + gpointer data) +{ + GimpViewRenderer *renderer; + GimpToolItem *tool_item; + + gtk_tree_model_get (tree_model, iter, + GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, &renderer, + -1); + + tool_item = GIMP_TOOL_ITEM (renderer->viewable); + + g_object_set (cell, + "active", gimp_tool_item_get_visible (tool_item), + "inconsistent", gimp_tool_item_get_visible (tool_item) && + ! gimp_tool_item_get_shown (tool_item), + NULL); + + g_object_unref (renderer); +} + +static void +gimp_tool_editor_eye_clicked (GtkCellRendererToggle *toggle, + gchar *path_str, + GdkModifierType state, + GimpToolEditor *tool_editor) +{ + GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (tool_editor); + GtkTreePath *path; + GtkTreeIter iter; + + path = gtk_tree_path_new_from_string (path_str); + + if (gtk_tree_model_get_iter (tree_view->model, &iter, path)) + { + GimpViewRenderer *renderer; + GimpToolItem *tool_item; + gboolean active; + + gtk_tree_model_get (tree_view->model, &iter, + GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, &renderer, + -1); + + tool_item = GIMP_TOOL_ITEM (renderer->viewable); + + g_object_get (toggle, + "active", &active, + NULL); + + gimp_tool_item_set_visible (tool_item, ! active); + + g_object_unref (renderer); + } + + gtk_tree_path_free (path); +} + +static GimpToolItem * +gimp_tool_editor_get_selected_tool_item (GimpToolEditor *tool_editor) +{ + GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (tool_editor); + + if (tool_editor->priv->container) + { + GimpViewRenderer *renderer; + GimpToolItem *tool_item; + GtkTreeSelection *selection; + GtkTreeModel *model; + GtkTreeIter iter; + + selection = gtk_tree_view_get_selection (tree_view->view); + + if (! gtk_tree_selection_get_selected (selection, &model, &iter)) + return NULL; + + gtk_tree_model_get (model, &iter, + GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, &renderer, + -1); + + tool_item = GIMP_TOOL_ITEM (renderer->viewable); + + g_object_unref (renderer); + + return tool_item; + } + + return NULL; +} + +static GimpContainer * +gimp_tool_editor_get_tool_item_container (GimpToolEditor *tool_editor, + GimpToolItem *tool_item) +{ + GimpViewable *parent; + + parent = gimp_viewable_get_parent (GIMP_VIEWABLE (tool_item)); + + if (parent) + { + return gimp_viewable_get_children (parent); + } + else + { + return tool_editor->priv->container; + } +} + +static void +gimp_tool_editor_update_container (GimpToolEditor *tool_editor) +{ + GimpContainerView *container_view = GIMP_CONTAINER_VIEW (tool_editor); + GimpContainer *container; + GimpContext *context; + + g_clear_pointer (&tool_editor->priv->tool_item_notify_handler, + gimp_tree_handler_disconnect); + + g_clear_pointer (&tool_editor->priv->initial_tool_state, g_free); + + container = gimp_container_view_get_container (container_view); + context = gimp_container_view_get_context (container_view); + + if (container && context) + { + GString *string; + GimpConfigWriter *writer; + + tool_editor->priv->container = container; + tool_editor->priv->context = context; + + tool_editor->priv->tool_item_notify_handler = gimp_tree_handler_connect ( + container, "notify", + G_CALLBACK (gimp_tool_editor_tool_item_notify), + tool_editor); + + /* save initial tool order */ + string = g_string_new (NULL); + + writer = gimp_config_writer_new_string (string); + + gimp_tools_serialize (context->gimp, container, writer); + + gimp_config_writer_finish (writer, NULL, NULL); + + tool_editor->priv->initial_tool_state = g_string_free (string, FALSE); + } +} + +static void +gimp_tool_editor_update_sensitivity (GimpToolEditor *tool_editor) +{ + GimpToolItem *tool_item; + + tool_item = gimp_tool_editor_get_selected_tool_item (tool_editor); + + if (tool_item) + { + GimpContainer *container; + gint index; + + container = gimp_tool_editor_get_tool_item_container (tool_editor, + tool_item); + + index = gimp_container_get_child_index (container, + GIMP_OBJECT (tool_item)); + + gtk_widget_set_sensitive ( + tool_editor->priv->new_group_button, + gimp_viewable_get_parent (GIMP_VIEWABLE (tool_item)) == NULL); + + gtk_widget_set_sensitive ( + tool_editor->priv->raise_button, + index > 0); + + gtk_widget_set_sensitive ( + tool_editor->priv->lower_button, + index < gimp_container_get_n_children (container) - 1); + + gtk_widget_set_sensitive ( + tool_editor->priv->delete_button, + gimp_viewable_get_children (GIMP_VIEWABLE (tool_item)) != NULL); + } + else + { + gtk_widget_set_sensitive (tool_editor->priv->new_group_button, TRUE); + gtk_widget_set_sensitive (tool_editor->priv->raise_button, FALSE); + gtk_widget_set_sensitive (tool_editor->priv->lower_button, FALSE); + gtk_widget_set_sensitive (tool_editor->priv->delete_button, FALSE); + } +} + + +/* public functions */ + +GtkWidget * +gimp_tool_editor_new (GimpContainer *container, + GimpContext *context, + gint view_size, + gint view_border_width) +{ + GimpContainerView *container_view; + + g_return_val_if_fail (GIMP_IS_CONTAINER (container), NULL); + g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); + + container_view = g_object_new (GIMP_TYPE_TOOL_EDITOR, + "view-size", view_size, + "view-border-width", view_border_width, + NULL); + + gimp_container_view_set_context (container_view, context); + gimp_container_view_set_container (container_view, container); + gimp_container_view_set_reorderable (container_view, TRUE); + + return GTK_WIDGET (container_view); +} + +/** + * gimp_tool_editor_revert_changes: + * @tool_editor: + * + * Reverts the tool order and visibility to the state at creation. + **/ +void +gimp_tool_editor_revert_changes (GimpToolEditor *tool_editor) +{ + GScanner *scanner; + + g_return_if_fail (GIMP_IS_TOOL_EDITOR (tool_editor)); + + scanner = gimp_scanner_new_string (tool_editor->priv->initial_tool_state, -1, + NULL); + + gimp_tools_deserialize (tool_editor->priv->context->gimp, + tool_editor->priv->container, + scanner); + + gimp_scanner_destroy (scanner); +} |