diff --git a/ChangeLog b/ChangeLog index fa590a4c2b..f8360bed68 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,120 @@ +2002-02-25 Michael Natterer + + * app/core/Makefile.am + * app/core/core-types.h + * app/core/gimpitem.[ch]: new base class for something which is a + child of an image, has a PDB ID, a tattoo, parasites and emits + a "removed" signal. + + * app/core/gimpdrawable.[ch] + * app/vectors/gimpvectors.[ch]: derive from GimpItem. Removed + lots of stuff from GimpDrawable. + + * app/core/gimp.[ch]: changed gimp->drawable_table and + gimp->next_drawable_ID to gimp->item_table and gimp->next_item_id. + + * app/undo.[ch]: s/undo_push_drawable_parasite/undo_push_item_parasite/, + minor cleanups. + + * app/core/gimplayer.[ch]: changed gimp_layer_new_from_tiles() and + gimp_layer_new_from_drawable() to take the "dest_gimage" as + second, not first parameter. + + * app/image_map.c + * app/core/gimpchannel.c + * app/core/gimpdrawable-blend.c + * app/core/gimpdrawable-bucket-fill.c + * app/core/gimpdrawable-histogram.c + * app/core/gimpdrawable-offset.c + * app/core/gimpdrawable-preview.c + * app/core/gimpdrawable-transform.c + * app/core/gimpedit.c + * app/core/gimpimage-duplicate.c + * app/core/gimpimage-mask.c + * app/core/gimpimage-merge.c + * app/core/gimpimage-pick-color.c + * app/core/gimpimage.c + * app/core/gimplayer-floating-sel.c + * app/display/gimpdisplayshell-dnd.c + * app/file/file-save.c + * app/gui/channels-commands.c + * app/gui/file-save-dialog.c + * app/gui/layers-commands.c + * app/gui/offset-dialog.c + * app/gui/paths-dialog.c + * app/gui/toolbox.c + * app/paint/gimpairbrush.c + * app/paint/gimpclone.c + * app/paint/gimpconvolve.c + * app/paint/gimpdodgeburn.c + * app/paint/gimperaser.c + * app/paint/gimppaintbrush.c + * app/paint/gimppaintcore.c + * app/paint/gimppencil.c + * app/paint/gimpsmudge.c + * app/plug-in/plug-in.c + * app/tools/gimpbezierselecttool.c + * app/tools/gimpbycolorselecttool.c + * app/tools/gimpinktool.c + * app/tools/gimppainttool.c + * app/xcf/xcf-load.c + * app/xcf/xcf-save.c + * app/widgets/gimpdrawablepreview.c: changed accordingly. + + * app/widgets/Makefile.am + * app/widgets/widgets-types.h + * app/widgets/gimpitemlistview.[ch]: new widget implementing most + of the stuff formerly done by GimpDrawableListView. + + * app/widgets/gimpchannellistview.c + * app/widgets/gimpdrawablelistitem.c + * app/widgets/gimpdrawablelistview.[ch] + * app/widgets/gimplayerlistview.c: changed accordingly. + + * app/widgets/gimpdnd.[ch]: added a vectors DND type. + + * app/gui/menus.c + * app/gui/dialogs.c + * app/gui/dialogs-constructors.[ch]: added a vectors dialog and + a vectors item_factory. + + * app/gui/Makefile.am + * app/gui/vectors-commands.[ch]: new files implementing the + callbacks for the new vectors dialog and item_factory. + + * app/pdb/pdb_glue.h: some more ugly hacks to keep intermediate + perl code working... + + * tools/pdbgen/pdb.pl: added a vectors type, use GimpItem for all + ID lookups. + + * tools/pdbgen/pdb/channel.pdb + * tools/pdbgen/pdb/color.pdb + * tools/pdbgen/pdb/drawable.pdb + * tools/pdbgen/pdb/edit.pdb + * tools/pdbgen/pdb/image.pdb + * tools/pdbgen/pdb/layer.pdb + * tools/pdbgen/pdb/misc_tools.pdb + * tools/pdbgen/pdb/parasite.pdb + * tools/pdbgen/pdb/selection.pdb + * tools/pdbgen/pdb/selection_tools.pdb: misc changes according to + stuff above. + + * app/pdb/channel_cmds.c + * app/pdb/color_cmds.c + * app/pdb/drawable_cmds.c + * app/pdb/edit_cmds.c + * app/pdb/floating_sel_cmds.c + * app/pdb/image_cmds.c + * app/pdb/layer_cmds.c + * app/pdb/misc_tools_cmds.c + * app/pdb/paint_tools_cmds.c + * app/pdb/parasite_cmds.c + * app/pdb/selection_cmds.c + * app/pdb/selection_tools_cmds.c + * app/pdb/text_tool_cmds.c + * app/pdb/transform_tools_cmds.c: regenerated. + 2002-02-25 Simon Budig * app/vectors/gimpbezierstroke.c diff --git a/app/actions/channels-commands.c b/app/actions/channels-commands.c index 215319ca81..b221b38178 100644 --- a/app/actions/channels-commands.c +++ b/app/actions/channels-commands.c @@ -531,7 +531,7 @@ channels_edit_channel_query (GimpChannel *channel) options = g_new0 (EditChannelOptions, 1); options->channel = channel; - options->gimage = gimp_drawable_gimage (GIMP_DRAWABLE (channel)); + options->gimage = gimp_item_get_image (GIMP_ITEM (channel)); channel_color = channel->color; diff --git a/app/actions/layers-commands.c b/app/actions/layers-commands.c index d376378f30..fbbedfbec2 100644 --- a/app/actions/layers-commands.c +++ b/app/actions/layers-commands.c @@ -283,7 +283,7 @@ layers_invert_cmd_callback (GtkWidget *widget, procedural_db_run_proc (gimage->gimp, "gimp_invert", &nreturn_vals, - GIMP_PDB_DRAWABLE, gimp_drawable_get_ID (drawable), + GIMP_PDB_DRAWABLE, gimp_item_get_ID (GIMP_ITEM (drawable)), GIMP_PDB_END); if (!return_vals || return_vals[0].value.pdb_int != GIMP_PDB_SUCCESS) @@ -775,10 +775,10 @@ layers_edit_layer_query (GimpLayer *layer) GtkWidget *hbox; GtkWidget *label; - /* The new options structure */ - options = g_new (EditLayerOptions, 1); + options = g_new0 (EditLayerOptions, 1); + options->layer = layer; - options->gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)); + options->gimage = gimp_item_get_image (GIMP_ITEM (layer)); /* The dialog */ options->query_box = @@ -861,8 +861,7 @@ add_mask_query_ok_callback (GtkWidget *widget, options = (AddMaskOptions *) data; - if ((layer = (options->layer)) && - (gimage = GIMP_DRAWABLE (layer)->gimage)) + if ((layer = (options->layer)) && (gimage = GIMP_ITEM (layer)->gimage)) { mask = gimp_layer_create_mask (layer, options->add_mask_type); gimp_layer_add_mask (layer, mask, TRUE); @@ -884,7 +883,7 @@ layers_add_mask_query (GimpLayer *layer) options->layer = layer; options->add_mask_type = ADD_WHITE_MASK; - gimage = GIMP_DRAWABLE (layer)->gimage; + gimage = gimp_item_get_image (GIMP_ITEM (layer)); /* The dialog */ options->query_box = @@ -990,7 +989,6 @@ scale_layer_query_ok_callback (GtkWidget *widget, gpointer data) { ScaleLayerOptions *options; - GimpImage *gimage; GimpLayer *layer; options = (ScaleLayerOptions *) data; @@ -998,9 +996,13 @@ scale_layer_query_ok_callback (GtkWidget *widget, if (options->resize->width > 0 && options->resize->height > 0 && (layer = (options->layer))) { + GimpImage *gimage; + gtk_widget_set_sensitive (options->resize->resize_shell, FALSE); - if ((gimage = GIMP_DRAWABLE (layer)->gimage) != NULL) + gimage = gimp_item_get_image (GIMP_ITEM (layer)); + + if (gimage) { undo_push_group_start (gimage, LAYER_SCALE_UNDO_GROUP); @@ -1079,7 +1081,6 @@ resize_layer_query_ok_callback (GtkWidget *widget, gpointer data) { ResizeLayerOptions *options; - GimpImage *gimage; GimpLayer *layer; options = (ResizeLayerOptions *) data; @@ -1087,9 +1088,13 @@ resize_layer_query_ok_callback (GtkWidget *widget, if (options->resize->width > 0 && options->resize->height > 0 && (layer = (options->layer))) { + GimpImage *gimage; + gtk_widget_set_sensitive (options->resize->resize_shell, FALSE); - if ((gimage = GIMP_DRAWABLE (layer)->gimage) != NULL) + gimage = gimp_item_get_image (GIMP_ITEM (layer)); + + if (gimage) { undo_push_group_start (gimage, LAYER_RESIZE_UNDO_GROUP); diff --git a/app/actions/plug-in-commands.c b/app/actions/plug-in-commands.c index d3b99fe777..842e28fba9 100644 --- a/app/actions/plug-in-commands.c +++ b/app/actions/plug-in-commands.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/actions/vectors-commands.c b/app/actions/vectors-commands.c new file mode 100644 index 0000000000..9814bf1bd8 --- /dev/null +++ b/app/actions/vectors-commands.c @@ -0,0 +1,636 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "config.h" + +#include + +#include "libgimpwidgets/gimpwidgets.h" + +#include "gui-types.h" + +#include "core/gimp.h" +#include "core/gimpchannel.h" +#include "core/gimpimage.h" +#include "core/gimpimage-mask.h" +#include "core/gimplist.h" + +#include "vectors/gimpvectors.h" + +#include "display/gimpdisplay-foreach.h" + +#include "widgets/gimpitemfactory.h" +#include "widgets/gimpwidgets-utils.h" + +#include "vectors-commands.h" + +#include "undo.h" + +#include "libgimp/gimpintl.h" + + +/* public functions */ + +void +vectors_new_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + vectors_new_vectors_query (gimage, NULL); +} + +void +vectors_raise_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + if (gimp_image_get_active_vectors (gimage)) + { + gimp_image_raise_vectors (gimage, gimp_image_get_active_vectors (gimage)); + gdisplays_flush (); + } +} + +void +vectors_lower_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + if (gimp_image_get_active_vectors (gimage)) + { + gimp_image_lower_vectors (gimage, gimp_image_get_active_vectors (gimage)); + gdisplays_flush (); + } +} + +void +vectors_duplicate_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + GimpVectors *new_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + new_vectors = NULL; /*gimp_vectors_copy (active_vectors, + G_TYPE_FROM_INSTANCE (active_vectors), + TRUE);*/ + gimp_image_add_vectors (gimage, new_vectors, -1); + gdisplays_flush (); + } +} + +void +vectors_delete_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + gimp_image_remove_vectors (gimage, active_vectors); + gdisplays_flush (); + } +} + +void +vectors_vectors_to_sel_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + GimpChannel *vectors_mask; + + vectors_mask = NULL; /*gimp_vectors_to_channel (active_vectors);*/ + + gimp_image_mask_load (gimage, vectors_mask); + + g_object_unref (G_OBJECT (vectors_mask)); + + gdisplays_flush (); + } +} + +void +vectors_add_vectors_to_sel_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + GimpChannel *vectors_mask; + GimpChannel *new_mask; + + vectors_mask = NULL; /*gimp_vectors_to_channel (active_vectors);*/ + + new_mask = gimp_channel_copy (gimp_image_get_mask (gimage), + G_TYPE_FROM_INSTANCE (gimp_image_get_mask (gimage)), + TRUE); + + gimp_channel_combine_mask (new_mask, + vectors_mask, + CHANNEL_OP_ADD, + 0, 0); /* off x/y */ + + gimp_image_mask_load (gimage, new_mask); + + g_object_unref (G_OBJECT (new_mask)); + + gdisplays_flush (); + } +} + +void +vectors_sub_vectors_from_sel_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + GimpChannel *vectors_mask; + GimpChannel *new_mask; + + vectors_mask = NULL; /*gimp_vectors_to_channel (active_vectors);*/ + + new_mask = gimp_channel_copy (gimp_image_get_mask (gimage), + G_TYPE_FROM_INSTANCE (gimp_image_get_mask (gimage)), + TRUE); + + gimp_channel_combine_mask (new_mask, + vectors_mask, + CHANNEL_OP_SUB, + 0, 0); /* off x/y */ + + gimp_image_mask_load (gimage, new_mask); + + g_object_unref (G_OBJECT (new_mask)); + + gdisplays_flush (); + } +} + +void +vectors_intersect_vectors_with_sel_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + GimpChannel *vectors_mask; + GimpChannel *new_mask; + + vectors_mask = NULL; /*gimp_vectors_to_channel (active_vectors);*/ + + new_mask = gimp_channel_copy (gimp_image_get_mask (gimage), + G_TYPE_FROM_INSTANCE (gimp_image_get_mask (gimage)), + TRUE); + + gimp_channel_combine_mask (new_mask, + vectors_mask, + CHANNEL_OP_INTERSECT, + 0, 0); /* off x/y */ + + gimp_image_mask_load (gimage, new_mask); + + g_object_unref (G_OBJECT (new_mask)); + + gdisplays_flush (); + } +} + +void +vectors_sel_to_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + } +} + +void +vectors_stroke_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + } +} + +void +vectors_edit_vectors_attributes_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + vectors_edit_vectors_query (active_vectors); + } +} + + +/**********************************/ +/* The new vectors query dialog */ +/**********************************/ + +typedef struct _NewVectorsOptions NewVectorsOptions; + +struct _NewVectorsOptions +{ + GtkWidget *query_box; + GtkWidget *name_entry; + + GimpImage *gimage; +}; + +static gchar *vectors_name = NULL; + + +static void +new_vectors_query_ok_callback (GtkWidget *widget, + gpointer data) +{ + NewVectorsOptions *options; + GimpVectors *new_vectors; + GimpImage *gimage; + + options = (NewVectorsOptions *) data; + + if (vectors_name) + g_free (vectors_name); + vectors_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (options->name_entry))); + + if ((gimage = options->gimage)) + { + new_vectors = g_object_new (GIMP_TYPE_VECTORS, NULL); + + gimp_image_add_vectors (gimage, new_vectors, -1); + + gimp_object_set_name (GIMP_OBJECT (new_vectors), vectors_name); + + gdisplays_flush (); + } + + gtk_widget_destroy (options->query_box); +} + +void +vectors_new_vectors_query (GimpImage *gimage, + GimpVectors *template) +{ + NewVectorsOptions *options; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *table; + GtkWidget *label; + + g_return_if_fail (GIMP_IS_IMAGE (gimage)); + g_return_if_fail (! template || GIMP_IS_VECTORS (template)); + + if (template) + { + GimpVectors *new_vectors; + + /* undo_push_group_start (gimage, EDIT_PASTE_UNDO_GROUP); */ + + new_vectors = NULL; /*gimp_vectors_new (gimage, _("Empty Vectors Copy"));*/ + + gimp_image_add_vectors (gimage, new_vectors, -1); + + /* undo_push_group_end (gimage); */ + + gdisplays_flush (); + return; + } + + /* the new options structure */ + options = g_new (NewVectorsOptions, 1); + options->gimage = gimage; + + /* The dialog */ + options->query_box = + gimp_dialog_new (_("New Vectors Options"), "new_vectors_options", + gimp_standard_help_func, + "dialogs/vectors/new_vectors.html", + GTK_WIN_POS_MOUSE, + FALSE, TRUE, FALSE, + + GTK_STOCK_CANCEL, gtk_widget_destroy, + NULL, 1, NULL, FALSE, TRUE, + + GTK_STOCK_OK, new_vectors_query_ok_callback, + options, NULL, NULL, TRUE, FALSE, + + NULL); + + g_object_weak_ref (G_OBJECT (options->query_box), + (GWeakNotify) g_free, + options); + + /* The main hbox */ + hbox = gtk_hbox_new (FALSE, 2); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 4); + gtk_container_add (GTK_CONTAINER (GTK_DIALOG (options->query_box)->vbox), + hbox); + + /* The vbox */ + vbox = gtk_vbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); + + /* The table */ + table = gtk_table_new (2, 3, FALSE); + gtk_table_set_col_spacings (GTK_TABLE (table), 4); + gtk_table_set_row_spacings (GTK_TABLE (table), 2); + gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); + + /* The name entry hbox, label and entry */ + label = gtk_label_new (_("Vectors name:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + options->name_entry = gtk_entry_new (); + gtk_widget_set_size_request (options->name_entry, 150, -1); + gtk_table_attach_defaults (GTK_TABLE (table), options->name_entry, + 1, 2, 0, 1); + gtk_entry_set_text (GTK_ENTRY (options->name_entry), + (vectors_name ? vectors_name : _("New Vectors"))); + gtk_widget_show (options->name_entry); + + gtk_widget_show (table); + gtk_widget_show (vbox); + gtk_widget_show (hbox); + gtk_widget_show (options->query_box); +} + +/****************************************/ +/* The edit vectors attributes dialog */ +/****************************************/ + +typedef struct _EditVectorsOptions EditVectorsOptions; + +struct _EditVectorsOptions +{ + GtkWidget *query_box; + GtkWidget *name_entry; + + GimpVectors *vectors; + GimpImage *gimage; +}; + +static void +edit_vectors_query_ok_callback (GtkWidget *widget, + gpointer data) +{ + EditVectorsOptions *options; + GimpVectors *vectors; + + options = (EditVectorsOptions *) data; + vectors = options->vectors; + + if (options->gimage) + { + /* Set the new vectors name */ + gimp_object_set_name (GIMP_OBJECT (vectors), + gtk_entry_get_text (GTK_ENTRY (options->name_entry))); + } + + gtk_widget_destroy (options->query_box); +} + +void +vectors_edit_vectors_query (GimpVectors *vectors) +{ + EditVectorsOptions *options; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *table; + GtkWidget *label; + + options = g_new0 (EditVectorsOptions, 1); + + options->vectors = vectors; + options->gimage = gimp_item_get_image (GIMP_ITEM (vectors)); + + /* The dialog */ + options->query_box = + gimp_dialog_new (_("Edit Vectors Attributes"), "edit_vectors_attributes", + gimp_standard_help_func, + "dialogs/vectors/edit_vectors_attributes.html", + GTK_WIN_POS_MOUSE, + FALSE, TRUE, FALSE, + + GTK_STOCK_CANCEL, gtk_widget_destroy, + NULL, 1, NULL, FALSE, TRUE, + + GTK_STOCK_OK, edit_vectors_query_ok_callback, + options, NULL, NULL, TRUE, FALSE, + + NULL); + + g_object_weak_ref (G_OBJECT (options->query_box), + (GWeakNotify) g_free, + options); + + g_signal_connect_object (G_OBJECT (vectors), "removed", + G_CALLBACK (gtk_widget_destroy), + G_OBJECT (options->query_box), + G_CONNECT_SWAPPED); + + /* The main hbox */ + hbox = gtk_hbox_new (FALSE, 2); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 4); + gtk_container_add (GTK_CONTAINER (GTK_DIALOG (options->query_box)->vbox), + hbox); + + /* The vbox */ + vbox = gtk_vbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); + + /* The table */ + table = gtk_table_new (2, 3, FALSE); + gtk_table_set_col_spacings (GTK_TABLE (table), 4); + gtk_table_set_row_spacings (GTK_TABLE (table), 2); + gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); + + /* The name entry */ + label = gtk_label_new (_("Vectors name:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, + GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); + gtk_widget_show (label); + + options->name_entry = gtk_entry_new (); + gtk_widget_set_size_request (options->name_entry, 150, -1); + gtk_table_attach_defaults (GTK_TABLE (table), options->name_entry, + 1, 2, 0, 1); + gtk_entry_set_text (GTK_ENTRY (options->name_entry), + gimp_object_get_name (GIMP_OBJECT (vectors))); + gtk_widget_show (options->name_entry); + + gtk_widget_show (table); + gtk_widget_show (vbox); + gtk_widget_show (hbox); + gtk_widget_show (options->query_box); +} + +void +vectors_menu_update (GtkItemFactory *factory, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *vectors; + gboolean fs; + GList *list; + GList *next = NULL; + GList *prev = NULL; + + gimage = GIMP_IMAGE (data); + + vectors = gimp_image_get_active_vectors (gimage); + + fs = (gimp_image_floating_sel (gimage) != NULL); + + for (list = GIMP_LIST (gimage->vectors)->list; + list; + list = g_list_next (list)) + { + if (vectors == (GimpVectors *) list->data) + { + prev = g_list_previous (list); + next = g_list_next (list); + break; + } + } + +#define SET_SENSITIVE(menu,condition) \ + gimp_item_factory_set_sensitive (factory, menu, (condition) != 0) + + SET_SENSITIVE ("/New Vectors...", !fs); + SET_SENSITIVE ("/Raise Vectors", !fs && vectors && prev); + SET_SENSITIVE ("/Lower Vectors", !fs && vectors && next); + SET_SENSITIVE ("/Duplicate Vectors", !fs && vectors); + SET_SENSITIVE ("/Vectors to Selection", !fs && vectors); + SET_SENSITIVE ("/Add to Selection", !fs && vectors); + SET_SENSITIVE ("/Subtract from Selection", !fs && vectors); + SET_SENSITIVE ("/Intersect with Selection", !fs && vectors); + SET_SENSITIVE ("/Delete Vectors", !fs && vectors); + SET_SENSITIVE ("/Edit Vectors Attributes...", !fs && vectors); + +#undef SET_OPS_SENSITIVE +} diff --git a/app/actions/vectors-commands.h b/app/actions/vectors-commands.h new file mode 100644 index 0000000000..f6b0f8d582 --- /dev/null +++ b/app/actions/vectors-commands.h @@ -0,0 +1,56 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __VECTORS_COMMANDS_H__ +#define __VECTORS_COMMANDS_H__ + + +void vectors_new_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_raise_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_lower_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_duplicate_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_delete_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_vectors_to_sel_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_add_vectors_to_sel_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_sub_vectors_from_sel_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_intersect_vectors_with_sel_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_sel_to_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_stroke_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_edit_vectors_attributes_cmd_callback (GtkWidget *widget, + gpointer data); + +void vectors_new_vectors_query (GimpImage *gimage, + GimpVectors *template); +void vectors_edit_vectors_query (GimpVectors *vectors); + +void vectors_menu_update (GtkItemFactory *factory, + gpointer data); + + +#endif /* __VECTORS_COMMANDS_H__ */ diff --git a/app/core/Makefile.am b/app/core/Makefile.am index 74270b4b18..9046276501 100644 --- a/app/core/Makefile.am +++ b/app/core/Makefile.am @@ -114,6 +114,8 @@ libappcore_a_sources = @STRIP_BEGIN@ \ gimpimage-undo.h \ gimpimagefile.c \ gimpimagefile.h \ + gimpitem.c \ + gimpitem.h \ gimplayer.c \ gimplayer.h \ gimplayer-floating-sel.c \ diff --git a/app/core/core-types.h b/app/core/core-types.h index 811e3279cd..9bf93cec6b 100644 --- a/app/core/core-types.h +++ b/app/core/core-types.h @@ -181,6 +181,7 @@ typedef struct _GimpDataFactory GimpDataFactory; typedef struct _GimpContext GimpContext; typedef struct _GimpViewable GimpViewable; +typedef struct _GimpItem GimpItem; typedef struct _GimpBuffer GimpBuffer; diff --git a/app/core/gimp-edit.c b/app/core/gimp-edit.c index a83c681727..93b1cac2eb 100644 --- a/app/core/gimp-edit.c +++ b/app/core/gimp-edit.c @@ -173,13 +173,13 @@ gimp_edit_paste (GimpImage *gimage, */ if (drawable != NULL) - layer = gimp_layer_new_from_tiles (gimage, - paste->tiles, + layer = gimp_layer_new_from_tiles (paste->tiles, + gimage, _("Pasted Layer"), OPAQUE_OPACITY, GIMP_NORMAL_MODE); else - layer = gimp_layer_new_from_tiles (gimage, - paste->tiles, + layer = gimp_layer_new_from_tiles (paste->tiles, + gimage, _("Pasted Layer"), OPAQUE_OPACITY, GIMP_NORMAL_MODE); @@ -220,7 +220,7 @@ gimp_edit_paste (GimpImage *gimage, } else { - gimp_drawable_set_gimage (GIMP_DRAWABLE (layer), gimage); + gimp_item_set_image (GIMP_ITEM (layer), gimage); gimp_image_add_layer (gimage, layer, 0); } @@ -253,15 +253,14 @@ gimp_edit_paste_as_new (Gimp *gimp, gimp_image_set_unit (gimage, invoke->unit); } - layer = gimp_layer_new_from_tiles (gimage, - paste->tiles, + layer = gimp_layer_new_from_tiles (paste->tiles, + gimage, _("Pasted Layer"), OPAQUE_OPACITY, GIMP_NORMAL_MODE); if (layer) { - /* add the new layer to the image */ - gimp_drawable_set_gimage (GIMP_DRAWABLE (layer), gimage); + gimp_item_set_image (GIMP_ITEM (layer), gimage); gimp_image_add_layer (gimage, layer, 0); gimp_image_undo_enable (gimage); diff --git a/app/core/gimp-transform-region.c b/app/core/gimp-transform-region.c index 95a084386d..9342dd8e92 100644 --- a/app/core/gimp-transform-region.c +++ b/app/core/gimp-transform-region.c @@ -116,7 +116,7 @@ gimp_drawable_transform_tiles_affine (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (float_tiles != NULL, NULL); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL); @@ -607,7 +607,7 @@ gimp_drawable_transform_affine (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); @@ -654,7 +654,7 @@ gimp_drawable_transform_flip (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); @@ -696,7 +696,7 @@ gimp_drawable_transform_cut (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (new_layer != NULL, NULL); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL); @@ -738,15 +738,15 @@ gimp_drawable_transform_paste (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (tiles != NULL, FALSE); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); if (new_layer) { layer = - gimp_layer_new_from_tiles (gimage, - tiles, + gimp_layer_new_from_tiles (tiles, + gimage, _("Transformation"), OPAQUE_OPACITY, GIMP_NORMAL_MODE); if (! layer) diff --git a/app/core/gimp.c b/app/core/gimp.c index af35a4c019..d5d6ba7a22 100644 --- a/app/core/gimp.c +++ b/app/core/gimp.c @@ -150,8 +150,8 @@ gimp_init (Gimp *gimp) gimp->next_guide_ID = 1; gimp->image_table = g_hash_table_new (g_direct_hash, NULL); - gimp->next_drawable_ID = 1; - gimp->drawable_table = g_hash_table_new (g_direct_hash, NULL); + gimp->next_item_ID = 1; + gimp->item_table = g_hash_table_new (g_direct_hash, NULL); gimp->global_buffer = NULL; gimp->named_buffers = gimp_list_new (GIMP_TYPE_BUFFER, @@ -299,10 +299,10 @@ gimp_finalize (GObject *object) gimp->global_buffer = NULL; } - if (gimp->drawable_table) + if (gimp->item_table) { - g_hash_table_destroy (gimp->drawable_table); - gimp->drawable_table = NULL; + g_hash_table_destroy (gimp->item_table); + gimp->item_table = NULL; } if (gimp->image_table) @@ -344,7 +344,7 @@ gimp_get_memsize (GimpObject *object) memsize += (g_hash_table_size (gimp->image_table) * 3 * sizeof (gpointer)); /* FIXME */ - memsize += (g_hash_table_size (gimp->drawable_table) * + memsize += (g_hash_table_size (gimp->item_table) * 3 * sizeof (gpointer)); /* FIXME */ if (gimp->global_buffer) diff --git a/app/core/gimp.h b/app/core/gimp.h index 424c3ae583..a0a839f704 100644 --- a/app/core/gimp.h +++ b/app/core/gimp.h @@ -79,8 +79,8 @@ struct _Gimp guint32 next_guide_ID; GHashTable *image_table; - gint next_drawable_ID; - GHashTable *drawable_table; + gint next_item_ID; + GHashTable *item_table; GimpBuffer *global_buffer; GimpContainer *named_buffers; diff --git a/app/core/gimpchannel-combine.c b/app/core/gimpchannel-combine.c index 49bfb01cca..100b8d830f 100644 --- a/app/core/gimpchannel-combine.c +++ b/app/core/gimpchannel-combine.c @@ -316,7 +316,7 @@ gimp_channel_scale (GimpChannel *channel, scale_region (&srcPR, &destPR, interpolation_type); /* Push the channel on the undo stack */ - undo_push_channel_mod (GIMP_DRAWABLE (channel)->gimage, channel); + undo_push_channel_mod (gimp_item_get_image (GIMP_ITEM (channel)), channel); /* Configure the new channel */ GIMP_DRAWABLE (channel)->tiles = new_tiles; @@ -419,7 +419,7 @@ gimp_channel_resize (GimpChannel *channel, copy_region (&srcPR, &destPR); /* Push the channel on the undo stack */ - undo_push_channel_mod (GIMP_DRAWABLE (channel)->gimage, channel); + undo_push_channel_mod (gimp_item_get_image (GIMP_ITEM (channel)), channel); /* Configure the new channel */ GIMP_DRAWABLE (channel)->tiles = new_tiles; @@ -1180,7 +1180,7 @@ gimp_channel_feather (GimpChannel *mask, PixelRegion srcPR; g_return_if_fail (GIMP_IS_CHANNEL (mask)); - g_return_if_fail (push_undo && gimp_drawable_gimage (GIMP_DRAWABLE (mask))); + g_return_if_fail (push_undo && gimp_item_get_image (GIMP_ITEM (mask))); if (push_undo) gimp_channel_push_undo (mask); @@ -1214,7 +1214,7 @@ gimp_channel_push_undo (GimpChannel *mask) else undo_tiles = NULL; - gimage = GIMP_DRAWABLE (mask)->gimage; + gimage = gimp_item_get_image (GIMP_ITEM (mask)); undo_push_image_mask (gimage, undo_tiles, x1, y1); @@ -1518,7 +1518,7 @@ gimp_channel_translate (GimpChannel *mask, /* copy the portion of the mask we will keep to a * temporary buffer */ - tmp_mask = gimp_channel_new_mask (GIMP_DRAWABLE (mask)->gimage, + tmp_mask = gimp_channel_new_mask (gimp_item_get_image (GIMP_ITEM (mask)), width, height); pixel_region_init (&srcPR, GIMP_DRAWABLE (mask)->tiles, diff --git a/app/core/gimpchannel.c b/app/core/gimpchannel.c index 49bfb01cca..100b8d830f 100644 --- a/app/core/gimpchannel.c +++ b/app/core/gimpchannel.c @@ -316,7 +316,7 @@ gimp_channel_scale (GimpChannel *channel, scale_region (&srcPR, &destPR, interpolation_type); /* Push the channel on the undo stack */ - undo_push_channel_mod (GIMP_DRAWABLE (channel)->gimage, channel); + undo_push_channel_mod (gimp_item_get_image (GIMP_ITEM (channel)), channel); /* Configure the new channel */ GIMP_DRAWABLE (channel)->tiles = new_tiles; @@ -419,7 +419,7 @@ gimp_channel_resize (GimpChannel *channel, copy_region (&srcPR, &destPR); /* Push the channel on the undo stack */ - undo_push_channel_mod (GIMP_DRAWABLE (channel)->gimage, channel); + undo_push_channel_mod (gimp_item_get_image (GIMP_ITEM (channel)), channel); /* Configure the new channel */ GIMP_DRAWABLE (channel)->tiles = new_tiles; @@ -1180,7 +1180,7 @@ gimp_channel_feather (GimpChannel *mask, PixelRegion srcPR; g_return_if_fail (GIMP_IS_CHANNEL (mask)); - g_return_if_fail (push_undo && gimp_drawable_gimage (GIMP_DRAWABLE (mask))); + g_return_if_fail (push_undo && gimp_item_get_image (GIMP_ITEM (mask))); if (push_undo) gimp_channel_push_undo (mask); @@ -1214,7 +1214,7 @@ gimp_channel_push_undo (GimpChannel *mask) else undo_tiles = NULL; - gimage = GIMP_DRAWABLE (mask)->gimage; + gimage = gimp_item_get_image (GIMP_ITEM (mask)); undo_push_image_mask (gimage, undo_tiles, x1, y1); @@ -1518,7 +1518,7 @@ gimp_channel_translate (GimpChannel *mask, /* copy the portion of the mask we will keep to a * temporary buffer */ - tmp_mask = gimp_channel_new_mask (GIMP_DRAWABLE (mask)->gimage, + tmp_mask = gimp_channel_new_mask (gimp_item_get_image (GIMP_ITEM (mask)), width, height); pixel_region_init (&srcPR, GIMP_DRAWABLE (mask)->tiles, diff --git a/app/core/gimpdrawable-blend.c b/app/core/gimpdrawable-blend.c index 8da61b2c7e..d0f1b81d89 100644 --- a/app/core/gimpdrawable-blend.c +++ b/app/core/gimpdrawable-blend.c @@ -192,7 +192,7 @@ gimp_drawable_blend (GimpDrawable *drawable, g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_if_fail (GIMP_IS_IMAGE (gimage)); diff --git a/app/core/gimpdrawable-bucket-fill.c b/app/core/gimpdrawable-bucket-fill.c index a2a8eb080c..54252dc874 100644 --- a/app/core/gimpdrawable-bucket-fill.c +++ b/app/core/gimpdrawable-bucket-fill.c @@ -91,7 +91,7 @@ gimp_drawable_bucket_fill (GimpDrawable *drawable, g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_if_fail (GIMP_IS_IMAGE (gimage)); @@ -163,7 +163,7 @@ gimp_drawable_bucket_fill_full (GimpDrawable *drawable, g_return_if_fail ((fill_mode != FG_BUCKET_FILL && fill_mode != BG_BUCKET_FILL) || color != NULL); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_if_fail (GIMP_IS_IMAGE (gimage)); diff --git a/app/core/gimpdrawable-histogram.c b/app/core/gimpdrawable-histogram.c index 28c5cb9c6f..5fd044fba4 100644 --- a/app/core/gimpdrawable-histogram.c +++ b/app/core/gimpdrawable-histogram.c @@ -56,7 +56,7 @@ gimp_drawable_calculate_histogram (GimpDrawable *drawable, GimpChannel *sel_mask; GimpImage *gimage; - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); sel_mask = gimp_image_get_mask (gimage); gimp_drawable_offsets (drawable, &off_x, &off_y); diff --git a/app/core/gimpdrawable-offset.c b/app/core/gimpdrawable-offset.c index 8a6ac8b9e8..29ce4d0e96 100644 --- a/app/core/gimpdrawable-offset.c +++ b/app/core/gimpdrawable-offset.c @@ -227,7 +227,7 @@ gimp_drawable_offset (GimpDrawable *drawable, Gimp *gimp; GimpRGB color; - gimp = gimp_drawable_gimage (drawable)->gimp; + gimp = gimp_item_get_image (GIMP_ITEM (drawable))->gimp; gimp_context_get_background (gimp_get_current_context (gimp), &color); diff --git a/app/core/gimpdrawable-preview.c b/app/core/gimpdrawable-preview.c index 6cde2c6f9e..cc12823e52 100644 --- a/app/core/gimpdrawable-preview.c +++ b/app/core/gimpdrawable-preview.c @@ -60,16 +60,19 @@ gimp_drawable_get_preview (GimpViewable *viewable, gint height) { GimpDrawable *drawable; + GimpImage *gimage; drawable = GIMP_DRAWABLE (viewable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); + /* Ok prime the cache with a large preview if the cache is invalid */ - if (! drawable->preview_valid && - width <= PREVIEW_CACHE_PRIME_WIDTH && - height <= PREVIEW_CACHE_PRIME_HEIGHT && - drawable->gimage && - drawable->gimage->width > PREVIEW_CACHE_PRIME_WIDTH && - drawable->gimage->height > PREVIEW_CACHE_PRIME_HEIGHT) + if (! drawable->preview_valid && + width <= PREVIEW_CACHE_PRIME_WIDTH && + height <= PREVIEW_CACHE_PRIME_HEIGHT && + gimage && + gimage->width > PREVIEW_CACHE_PRIME_WIDTH && + gimage->height > PREVIEW_CACHE_PRIME_HEIGHT) { TempBuf *tb = gimp_drawable_preview_private (drawable, PREVIEW_CACHE_PRIME_WIDTH, @@ -159,7 +162,7 @@ gimp_drawable_preview_private (GimpDrawable *drawable, { GimpImage *gimage; - gimage = drawable->gimage; + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); gimp_drawable_preview_scale (type, gimage->cmap, &srcPR, &destPR, diff --git a/app/core/gimpdrawable-transform.c b/app/core/gimpdrawable-transform.c index 95a084386d..9342dd8e92 100644 --- a/app/core/gimpdrawable-transform.c +++ b/app/core/gimpdrawable-transform.c @@ -116,7 +116,7 @@ gimp_drawable_transform_tiles_affine (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (float_tiles != NULL, NULL); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL); @@ -607,7 +607,7 @@ gimp_drawable_transform_affine (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); @@ -654,7 +654,7 @@ gimp_drawable_transform_flip (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); @@ -696,7 +696,7 @@ gimp_drawable_transform_cut (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (new_layer != NULL, NULL); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL); @@ -738,15 +738,15 @@ gimp_drawable_transform_paste (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (tiles != NULL, FALSE); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); if (new_layer) { layer = - gimp_layer_new_from_tiles (gimage, - tiles, + gimp_layer_new_from_tiles (tiles, + gimage, _("Transformation"), OPAQUE_OPACITY, GIMP_NORMAL_MODE); if (! layer) diff --git a/app/core/gimpdrawable.c b/app/core/gimpdrawable.c index 99cfb43e18..c788b4fd43 100644 --- a/app/core/gimpdrawable.c +++ b/app/core/gimpdrawable.c @@ -58,7 +58,6 @@ enum { VISIBILITY_CHANGED, - REMOVED, LAST_SIGNAL }; @@ -70,7 +69,6 @@ static void gimp_drawable_init (GimpDrawable *drawable); static void gimp_drawable_finalize (GObject *object); -static void gimp_drawable_name_changed (GimpObject *object); static gsize gimp_drawable_get_memsize (GimpObject *object); static void gimp_drawable_invalidate_preview (GimpViewable *viewable); @@ -80,7 +78,7 @@ static void gimp_drawable_invalidate_preview (GimpViewable *viewable); static guint gimp_drawable_signals[LAST_SIGNAL] = { 0 }; -static GimpViewableClass *parent_class = NULL; +static GimpItemClass *parent_class = NULL; GType @@ -103,7 +101,7 @@ gimp_drawable_get_type (void) (GInstanceInitFunc) gimp_drawable_init, }; - drawable_type = g_type_register_static (GIMP_TYPE_VIEWABLE, + drawable_type = g_type_register_static (GIMP_TYPE_ITEM, "GimpDrawable", &drawable_info, 0); } @@ -133,25 +131,14 @@ gimp_drawable_class_init (GimpDrawableClass *klass) gimp_marshal_VOID__VOID, G_TYPE_NONE, 0); - gimp_drawable_signals[REMOVED] = - g_signal_new ("removed", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_FIRST, - G_STRUCT_OFFSET (GimpDrawableClass, removed), - NULL, NULL, - gimp_marshal_VOID__VOID, - G_TYPE_NONE, 0); - object_class->finalize = gimp_drawable_finalize; - gimp_object_class->name_changed = gimp_drawable_name_changed; gimp_object_class->get_memsize = gimp_drawable_get_memsize; viewable_class->invalidate_preview = gimp_drawable_invalidate_preview; viewable_class->get_preview = gimp_drawable_get_preview; klass->visibility_changed = NULL; - klass->removed = NULL; } static void @@ -164,14 +151,10 @@ gimp_drawable_init (GimpDrawable *drawable) drawable->offset_x = 0; drawable->offset_y = 0; drawable->bytes = 0; - drawable->ID = 0; - drawable->tattoo = 0; - drawable->gimage = NULL; drawable->type = -1; drawable->has_alpha = FALSE; drawable->preview_cache = NULL; drawable->preview_valid = FALSE; - drawable->parasites = gimp_parasite_list_new (); drawable->preview_cache = NULL; drawable->preview_valid = FALSE; } @@ -185,13 +168,6 @@ gimp_drawable_finalize (GObject *object) drawable = GIMP_DRAWABLE (object); - if (drawable->gimage && drawable->gimage->gimp) - { - g_hash_table_remove (drawable->gimage->gimp->drawable_table, - GINT_TO_POINTER (drawable->ID)); - drawable->gimage = NULL; - } - if (drawable->tiles) { tile_manager_destroy (drawable->tiles); @@ -201,112 +177,9 @@ gimp_drawable_finalize (GObject *object) if (drawable->preview_cache) gimp_preview_cache_invalidate (&drawable->preview_cache); - if (drawable->parasites) - { - g_object_unref (G_OBJECT (drawable->parasites)); - drawable->parasites = NULL; - } - G_OBJECT_CLASS (parent_class)->finalize (object); } -static void -gimp_drawable_name_changed (GimpObject *object) -{ - GimpDrawable *drawable; - GimpDrawable *drawable2; - GList *list, *list2, *base_list; - gint unique_ext = 0; - gchar *ext; - gchar *new_name = NULL; - - g_return_if_fail (GIMP_IS_DRAWABLE (object)); - - drawable = GIMP_DRAWABLE (object); - - /* if no other layers to check name against */ - if (drawable->gimage == NULL || - gimp_image_is_empty (drawable->gimage)) - return; - - if (GIMP_IS_LAYER (drawable)) - base_list = GIMP_LIST (drawable->gimage->layers)->list; - else if (GIMP_IS_CHANNEL (drawable)) - base_list = GIMP_LIST (drawable->gimage->channels)->list; - else - base_list = NULL; - - for (list = base_list; - list; - list = g_list_next (list)) - { - drawable2 = GIMP_DRAWABLE (list->data); - - if (drawable != drawable2 && - strcmp (gimp_object_get_name (GIMP_OBJECT (drawable)), - gimp_object_get_name (GIMP_OBJECT (drawable2))) == 0) - { - ext = strrchr (GIMP_OBJECT (drawable)->name, '#'); - - if (ext) - { - gchar *ext_str; - - unique_ext = atoi (ext + 1); - - ext_str = g_strdup_printf ("%d", unique_ext); - - /* check if the extension really is of the form "#" */ - if (! strcmp (ext_str, ext + 1)) - { - *ext = '\0'; - } - else - { - unique_ext = 0; - } - - g_free (ext_str); - } - else - { - unique_ext = 0; - } - - do - { - unique_ext++; - - g_free (new_name); - - new_name = g_strdup_printf ("%s#%d", - GIMP_OBJECT (drawable)->name, - unique_ext); - - for (list2 = base_list; list2; list2 = g_list_next (list2)) - { - drawable2 = GIMP_DRAWABLE (list2->data); - - if (drawable == drawable2) - continue; - - if (! strcmp (GIMP_OBJECT (drawable2)->name, new_name)) - { - break; - } - } - } - while (list2); - - g_free (GIMP_OBJECT (drawable)->name); - - GIMP_OBJECT (drawable)->name = new_name; - - break; - } - } -} - static gsize gimp_drawable_get_memsize (GimpObject *object) { @@ -318,8 +191,6 @@ gimp_drawable_get_memsize (GimpObject *object) if (drawable->tiles) memsize += tile_manager_get_memsize (drawable->tiles); - memsize += gimp_object_get_memsize (GIMP_OBJECT (drawable->parasites)); - if (drawable->preview_cache) memsize += gimp_preview_cache_get_memsize (drawable->preview_cache); @@ -339,7 +210,7 @@ gimp_drawable_invalidate_preview (GimpViewable *viewable) drawable->preview_valid = FALSE; - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); if (gimage) gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage)); @@ -357,10 +228,10 @@ gimp_drawable_configure (GimpDrawable *drawable, g_return_if_fail (GIMP_IS_IMAGE (gimage)); g_return_if_fail (name != NULL); - drawable->ID = gimage->gimp->next_drawable_ID++; + GIMP_ITEM (drawable)->ID = gimage->gimp->next_item_ID++; - g_hash_table_insert (gimage->gimp->drawable_table, - GINT_TO_POINTER (drawable->ID), + g_hash_table_insert (gimage->gimp->item_table, + GINT_TO_POINTER (GIMP_ITEM (drawable)->ID), drawable); drawable->width = width; @@ -379,7 +250,7 @@ gimp_drawable_configure (GimpDrawable *drawable, drawable->visible = TRUE; - gimp_drawable_set_gimage (drawable, gimage); + gimp_item_set_image (GIMP_ITEM (drawable), gimage); gimp_object_set_name (GIMP_OBJECT (drawable), name); @@ -440,7 +311,7 @@ gimp_drawable_copy (GimpDrawable *drawable, new_drawable = g_object_new (new_type, NULL); gimp_drawable_configure (new_drawable, - gimp_drawable_gimage (drawable), + gimp_item_get_image (GIMP_ITEM (drawable)), gimp_drawable_width (drawable), gimp_drawable_height (drawable), new_image_type, @@ -470,56 +341,13 @@ gimp_drawable_copy (GimpDrawable *drawable, add_alpha_region (&srcPR, &destPR); } - g_object_unref (G_OBJECT (new_drawable->parasites)); - new_drawable->parasites = gimp_parasite_list_copy (drawable->parasites); + g_object_unref (G_OBJECT (GIMP_ITEM (new_drawable)->parasites)); + GIMP_ITEM (new_drawable)->parasites = + gimp_parasite_list_copy (GIMP_ITEM (drawable)->parasites); return new_drawable; } -gint -gimp_drawable_get_ID (GimpDrawable *drawable) -{ - g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), -1); - - return drawable->ID; -} - -GimpDrawable * -gimp_drawable_get_by_ID (Gimp *gimp, - gint drawable_id) -{ - g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); - - if (gimp->drawable_table == NULL) - return NULL; - - return (GimpDrawable *) g_hash_table_lookup (gimp->drawable_table, - GINT_TO_POINTER (drawable_id)); -} - -GimpImage * -gimp_drawable_gimage (const GimpDrawable *drawable) -{ - g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); - - return drawable->gimage; -} - -void -gimp_drawable_set_gimage (GimpDrawable *drawable, - GimpImage *gimage) -{ - g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage));; - - if (gimage == NULL) - drawable->tattoo = 0; - else if (drawable->tattoo == 0 || drawable->gimage != gimage ) - drawable->tattoo = gimp_image_get_new_tattoo (gimage); - - drawable->gimage = gimage; -} - void gimp_drawable_update (GimpDrawable *drawable, gint x, @@ -533,7 +361,7 @@ gimp_drawable_update (GimpDrawable *drawable, g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_if_fail (gimage != NULL); @@ -558,11 +386,14 @@ gimp_drawable_apply_image (GimpDrawable *drawable, g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); if (! tiles) - undo_push_image (drawable->gimage, drawable, + undo_push_image (gimp_item_get_image (GIMP_ITEM (drawable)), + drawable, x1, y1, x2, y2); else - undo_push_image_mod (drawable->gimage, drawable, - x1, y1, x2, y2, tiles, sparse); + undo_push_image_mod (gimp_item_get_image (GIMP_ITEM (drawable)), + drawable, + x1, y1, x2, y2, + tiles, sparse); } void @@ -575,7 +406,7 @@ gimp_drawable_merge_shadow (GimpDrawable *drawable, g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_if_fail (GIMP_IS_IMAGE (gimage)); g_return_if_fail (gimage->shadow != NULL); @@ -602,7 +433,7 @@ gimp_drawable_fill (GimpDrawable *drawable, g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_if_fail (gimage != NULL); @@ -715,7 +546,7 @@ gimp_drawable_mask_bounds (GimpDrawable *drawable, g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); g_return_val_if_fail (gimage != NULL, FALSE); @@ -736,20 +567,6 @@ gimp_drawable_mask_bounds (GimpDrawable *drawable, } } -/* The removed signal is sent out when the layer is no longer - * associcated with an image. It's needed because layers aren't - * destroyed immediately, but kept around for undo purposes. Connect - * to the removed signal to update bits of UI that are tied to a - * particular layer. - */ -void -gimp_drawable_removed (GimpDrawable *drawable) -{ - g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - - g_signal_emit (G_OBJECT (drawable), gimp_drawable_signals[REMOVED], 0); -} - gboolean gimp_drawable_has_alpha (const GimpDrawable *drawable) { @@ -813,7 +630,7 @@ gimp_drawable_shadow (GimpDrawable *drawable) g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); - if (! (gimage = gimp_drawable_gimage (drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable)))) return NULL; return gimp_image_shadow (gimage, drawable->width, drawable->height, @@ -904,7 +721,7 @@ gimp_drawable_cmap (const GimpDrawable *drawable) g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); - if (! (gimage = gimp_drawable_gimage (drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable)))) return NULL; return gimage->cmap; @@ -920,7 +737,7 @@ gimp_drawable_get_color_at (GimpDrawable *drawable, guchar *dest; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); - g_return_val_if_fail (gimp_drawable_gimage (drawable) || + g_return_val_if_fail (gimp_item_get_image (GIMP_ITEM (drawable)) || ! gimp_drawable_is_indexed (drawable), NULL); /* do not make this a g_return_if_fail() */ @@ -933,7 +750,7 @@ gimp_drawable_get_color_at (GimpDrawable *drawable, TRUE, FALSE); src = tile_data_pointer (tile, x % TILE_WIDTH, y % TILE_HEIGHT); - gimp_image_get_color (gimp_drawable_gimage (drawable), + gimp_image_get_color (gimp_item_get_image (GIMP_ITEM (drawable)), gimp_drawable_type (drawable), dest, src); if (GIMP_IMAGE_TYPE_HAS_ALPHA (gimp_drawable_type (drawable))) @@ -950,120 +767,3 @@ gimp_drawable_get_color_at (GimpDrawable *drawable, return dest; } - -void -gimp_drawable_parasite_attach (GimpDrawable *drawable, - GimpParasite *parasite) -{ - g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - - /* only set the dirty bit manually if we can be saved and the new - parasite differs from the current one and we arn't undoable */ - if (gimp_parasite_is_undoable (parasite)) - { - /* do a group in case we have attach_parent set */ - undo_push_group_start (drawable->gimage, PARASITE_ATTACH_UNDO_GROUP); - - undo_push_drawable_parasite (drawable->gimage, drawable, parasite); - } - else if (gimp_parasite_is_persistent (parasite) && - ! gimp_parasite_compare (parasite, - gimp_drawable_parasite_find - (drawable, gimp_parasite_name (parasite)))) - { - undo_push_cantundo (drawable->gimage, _("parasite attached to drawable")); - } - - gimp_parasite_list_add (drawable->parasites, parasite); - - if (gimp_parasite_has_flag (parasite, GIMP_PARASITE_ATTACH_PARENT)) - { - gimp_parasite_shift_parent (parasite); - gimp_image_parasite_attach (drawable->gimage, parasite); - } - else if (gimp_parasite_has_flag (parasite, GIMP_PARASITE_ATTACH_GRANDPARENT)) - { - gimp_parasite_shift_parent (parasite); - gimp_parasite_shift_parent (parasite); - gimp_parasite_attach (drawable->gimage->gimp, parasite); - } - - if (gimp_parasite_is_undoable (parasite)) - { - undo_push_group_end (drawable->gimage); - } -} - -void -gimp_drawable_parasite_detach (GimpDrawable *drawable, - const gchar *parasite) -{ - GimpParasite *p; - - g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - - if (! (p = gimp_parasite_list_find (drawable->parasites, parasite))) - return; - - if (gimp_parasite_is_undoable (p)) - undo_push_drawable_parasite_remove (drawable->gimage, drawable, - gimp_parasite_name (p)); - else if (gimp_parasite_is_persistent (p)) - undo_push_cantundo (drawable->gimage, _("parasite detached from drawable")); - - gimp_parasite_list_remove (drawable->parasites, parasite); -} - -GimpParasite * -gimp_drawable_parasite_find (const GimpDrawable *drawable, - const gchar *name) -{ - g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); - - return gimp_parasite_list_find (drawable->parasites, name); -} - -static void -gimp_drawable_parasite_list_foreach_func (gchar *key, - GimpParasite *p, - gchar ***cur) -{ - *(*cur)++ = (gchar *) g_strdup (key); -} - -gchar ** -gimp_drawable_parasite_list (const GimpDrawable *drawable, - gint *count) -{ - gchar **list; - gchar **cur; - - g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); - g_return_val_if_fail (count != NULL, NULL); - - *count = gimp_parasite_list_length (drawable->parasites); - cur = list = g_new (gchar *, *count); - - gimp_parasite_list_foreach (drawable->parasites, - (GHFunc) gimp_drawable_parasite_list_foreach_func, - &cur); - - return list; -} - -GimpTattoo -gimp_drawable_get_tattoo (const GimpDrawable *drawable) -{ - g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), 0); - - return drawable->tattoo; -} - -void -gimp_drawable_set_tattoo (GimpDrawable *drawable, - GimpTattoo tattoo) -{ - g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - - drawable->tattoo = tattoo; -} diff --git a/app/core/gimpdrawable.h b/app/core/gimpdrawable.h index 5ada8f7113..3ce8227c61 100644 --- a/app/core/gimpdrawable.h +++ b/app/core/gimpdrawable.h @@ -20,7 +20,7 @@ #define __GIMP_DRAWABLE_H__ -#include "gimpviewable.h" +#include "gimpitem.h" #define GIMP_TYPE_DRAWABLE (gimp_drawable_get_type ()) @@ -35,33 +35,27 @@ typedef struct _GimpDrawableClass GimpDrawableClass; struct _GimpDrawable { - GimpViewable parent_instance; + GimpItem parent_instance; - TileManager *tiles; /* tiles for drawable data */ - gboolean visible; /* controls visibility */ - gint width, height; /* size of drawable */ - gint offset_x, offset_y; /* offset of layer in image */ + TileManager *tiles; /* tiles for drawable data */ + gboolean visible; /* controls visibility */ + gint width, height; /* size of drawable */ + gint offset_x, offset_y; /* offset of layer in image */ - gint bytes; /* bytes per pixel */ - gint ID; /* provides a unique ID */ - guint32 tattoo; /* provides a perminant ID */ - GimpImage *gimage; /* gimage owner */ - GimpImageType type; /* type of drawable */ - gboolean has_alpha; /* drawable has alpha */ - - GimpParasiteList *parasites; /* Plug-in parasite data */ + gint bytes; /* bytes per pixel */ + GimpImageType type; /* type of drawable */ + gboolean has_alpha; /* drawable has alpha */ /* Preview variables */ - GSList *preview_cache; /* preview caches of the channel */ - gboolean preview_valid; /* is the preview valid? */ + GSList *preview_cache; /* preview caches of the channel */ + gboolean preview_valid; /* is the preview valid? */ }; struct _GimpDrawableClass { - GimpViewableClass parent_class; + GimpItemClass parent_class; void (* visibility_changed) (GimpDrawable *drawable); - void (* removed) (GimpDrawable *drawable); }; @@ -79,14 +73,6 @@ GimpDrawable * gimp_drawable_copy (GimpDrawable *drawable, GType new_type, gboolean add_alpha); -gint gimp_drawable_get_ID (GimpDrawable *drawable); -GimpDrawable * gimp_drawable_get_by_ID (Gimp *gimp, - gint id); - -GimpImage * gimp_drawable_gimage (const GimpDrawable *drawable); -void gimp_drawable_set_gimage (GimpDrawable *drawable, - GimpImage *gimage); - void gimp_drawable_update (GimpDrawable *drawable, gint x, gint y, @@ -116,8 +102,6 @@ gboolean gimp_drawable_mask_bounds (GimpDrawable *drawable, gint *x2, gint *y2); -void gimp_drawable_removed (GimpDrawable *drawable); - gboolean gimp_drawable_has_alpha (const GimpDrawable *drawable); GimpImageType gimp_drawable_type (const GimpDrawable *drawable); GimpImageType gimp_drawable_type_with_alpha (const GimpDrawable *drawable); @@ -145,17 +129,5 @@ guchar * gimp_drawable_get_color_at (GimpDrawable *drawable, gint x, gint y); -void gimp_drawable_parasite_attach (GimpDrawable *drawable, - GimpParasite *parasite); -void gimp_drawable_parasite_detach (GimpDrawable *drawable, - const gchar *parasite); -GimpParasite * gimp_drawable_parasite_find (const GimpDrawable *drawable, - const gchar *name); -gchar ** gimp_drawable_parasite_list (const GimpDrawable *drawable, - gint *count); -GimpTattoo gimp_drawable_get_tattoo (const GimpDrawable *drawable); -void gimp_drawable_set_tattoo (GimpDrawable *drawable, - GimpTattoo tattoo); - #endif /* __GIMP_DRAWABLE_H__ */ diff --git a/app/core/gimpedit.c b/app/core/gimpedit.c index a83c681727..93b1cac2eb 100644 --- a/app/core/gimpedit.c +++ b/app/core/gimpedit.c @@ -173,13 +173,13 @@ gimp_edit_paste (GimpImage *gimage, */ if (drawable != NULL) - layer = gimp_layer_new_from_tiles (gimage, - paste->tiles, + layer = gimp_layer_new_from_tiles (paste->tiles, + gimage, _("Pasted Layer"), OPAQUE_OPACITY, GIMP_NORMAL_MODE); else - layer = gimp_layer_new_from_tiles (gimage, - paste->tiles, + layer = gimp_layer_new_from_tiles (paste->tiles, + gimage, _("Pasted Layer"), OPAQUE_OPACITY, GIMP_NORMAL_MODE); @@ -220,7 +220,7 @@ gimp_edit_paste (GimpImage *gimage, } else { - gimp_drawable_set_gimage (GIMP_DRAWABLE (layer), gimage); + gimp_item_set_image (GIMP_ITEM (layer), gimage); gimp_image_add_layer (gimage, layer, 0); } @@ -253,15 +253,14 @@ gimp_edit_paste_as_new (Gimp *gimp, gimp_image_set_unit (gimage, invoke->unit); } - layer = gimp_layer_new_from_tiles (gimage, - paste->tiles, + layer = gimp_layer_new_from_tiles (paste->tiles, + gimage, _("Pasted Layer"), OPAQUE_OPACITY, GIMP_NORMAL_MODE); if (layer) { - /* add the new layer to the image */ - gimp_drawable_set_gimage (GIMP_DRAWABLE (layer), gimage); + gimp_item_set_image (GIMP_ITEM (layer), gimage); gimp_image_add_layer (gimage, layer, 0); gimp_image_undo_enable (gimage); diff --git a/app/core/gimpimage-duplicate.c b/app/core/gimpimage-duplicate.c index 53a21aa62b..ad1cc3f282 100644 --- a/app/core/gimpimage-duplicate.c +++ b/app/core/gimpimage-duplicate.c @@ -102,7 +102,7 @@ gimp_image_duplicate (GimpImage *gimage) new_layer = gimp_layer_copy (layer, G_TYPE_FROM_INSTANCE (layer), FALSE); - gimp_drawable_set_gimage (GIMP_DRAWABLE (new_layer), new_gimage); + gimp_item_set_image (GIMP_ITEM (new_layer), new_gimage); /* Make sure the copied layer doesn't say: " copy" */ gimp_object_set_name (GIMP_OBJECT (new_layer), @@ -139,7 +139,7 @@ gimp_image_duplicate (GimpImage *gimage) new_channel = gimp_channel_copy (channel, G_TYPE_FROM_INSTANCE (channel), TRUE); - gimp_drawable_set_gimage (GIMP_DRAWABLE (new_channel), new_gimage); + gimp_item_set_image (GIMP_ITEM (new_channel), new_gimage); /* Make sure the copied channel doesn't say: " copy" */ gimp_object_set_name (GIMP_OBJECT (new_channel), diff --git a/app/core/gimpimage-mask.c b/app/core/gimpimage-mask.c index 1d769c944e..e4e399a97f 100644 --- a/app/core/gimpimage-mask.c +++ b/app/core/gimpimage-mask.c @@ -391,8 +391,8 @@ gimp_image_mask_float (GimpImage *gimage, tiles = gimp_image_mask_extract (gimage, drawable, TRUE, FALSE, TRUE); /* Create a new layer from the buffer */ - layer = gimp_layer_new_from_tiles (gimage, - tiles, + layer = gimp_layer_new_from_tiles (tiles, + gimage, _("Floating Selection"), OPAQUE_OPACITY, GIMP_NORMAL_MODE); @@ -532,7 +532,7 @@ void gimp_image_mask_layer_mask (GimpImage *gimage, GimpLayer *layer) { - /* extract the layer's alpha channel */ + /* get the layer's mask */ if (gimp_layer_get_mask (layer)) { /* load the mask with the given layer's alpha channel */ @@ -649,7 +649,7 @@ gimp_image_mask_stroke (GimpImage *gimage, procedural_db_run_proc (gimage->gimp, pdb_string, &nreturn_vals, - GIMP_PDB_DRAWABLE, gimp_drawable_get_ID (drawable), + GIMP_PDB_DRAWABLE, gimp_item_get_ID (GIMP_ITEM (drawable)), GIMP_PDB_INT32, (gint32) cpnt, GIMP_PDB_FLOATARRAY, stroke_points, GIMP_PDB_END); diff --git a/app/core/gimpimage-merge.c b/app/core/gimpimage-merge.c index f6df40697c..fd46c62c46 100644 --- a/app/core/gimpimage-merge.c +++ b/app/core/gimpimage-merge.c @@ -395,10 +395,10 @@ gimp_image_merge_layers (GimpImage *gimage, } /* Copy the tattoo and parasites of the bottom layer to the new layer */ - gimp_drawable_set_tattoo (GIMP_DRAWABLE (merge_layer), - gimp_drawable_get_tattoo (GIMP_DRAWABLE (layer))); - GIMP_DRAWABLE (merge_layer)->parasites = - gimp_parasite_list_copy (GIMP_DRAWABLE (layer)->parasites); + gimp_item_set_tattoo (GIMP_ITEM (merge_layer), + gimp_item_get_tattoo (GIMP_ITEM (layer))); + GIMP_ITEM (merge_layer)->parasites = + gimp_parasite_list_copy (GIMP_ITEM (layer)->parasites); while (reverse_list) { diff --git a/app/core/gimpimage-pick-color.c b/app/core/gimpimage-pick-color.c index 1641a08c38..7303256978 100644 --- a/app/core/gimpimage-pick-color.c +++ b/app/core/gimpimage-pick-color.c @@ -57,7 +57,8 @@ gimp_image_pick_color (GimpImage *gimage, g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); g_return_val_if_fail (sample_merged || GIMP_IS_DRAWABLE (drawable), FALSE); - g_return_val_if_fail (! drawable || gimp_drawable_gimage (drawable) == gimage, + g_return_val_if_fail (! drawable || + gimp_item_get_image (GIMP_ITEM (drawable)) == gimage, FALSE); if (! sample_merged) diff --git a/app/core/gimpimage-undo-push.c b/app/core/gimpimage-undo-push.c index 2182b94ed9..2a3032192b 100644 --- a/app/core/gimpimage-undo-push.c +++ b/app/core/gimpimage-undo-push.c @@ -1723,9 +1723,9 @@ undo_pop_layer_mod (GimpImage *gimage, } if (GIMP_DRAWABLE (layer)->has_alpha != old_has_alpha && - GIMP_DRAWABLE (layer)->gimage->layers->num_children == 1) + GIMP_ITEM (layer)->gimage->layers->num_children == 1) { - gimp_image_alpha_changed (GIMP_DRAWABLE (layer)->gimage); + gimp_image_alpha_changed (GIMP_ITEM (layer)->gimage); } /* Set the new tile manager */ @@ -2038,7 +2038,7 @@ undo_push_layer_displace (GimpImage *gimage, new->pop_func = undo_pop_layer_displace; new->free_func = undo_free_layer_displace; - ldu->info[0] = gimp_drawable_get_ID (GIMP_DRAWABLE (layer)); + ldu->info[0] = gimp_item_get_ID (GIMP_ITEM (layer)); ldu->info[1] = GIMP_DRAWABLE (layer)->offset_x; ldu->info[2] = GIMP_DRAWABLE (layer)->offset_y; ldu->path_undo = path_transform_start_undo (gimage); @@ -2061,7 +2061,7 @@ undo_pop_layer_displace (GimpImage *gimage, LayerDisplaceUndo *ldu; ldu = (LayerDisplaceUndo *) info_ptr; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimage->gimp, ldu->info[0]); + layer = (GimpLayer *) gimp_item_get_by_ID (gimage->gimp, ldu->info[0]); if (layer) { old_offsets[0] = GIMP_DRAWABLE (layer)->offset_x; @@ -2222,8 +2222,11 @@ undo_pop_channel (GimpImage *gimage, /* remove the channel */ gimp_container_remove (gimage->channels, GIMP_OBJECT (cu->channel)); - /* set the previous channel */ - gimp_image_set_active_channel (gimage, cu->prev_channel); + if (cu->prev_channel) + { + /* set the previous channel */ + gimp_image_set_active_channel (gimage, cu->prev_channel); + } /* update the area */ gimp_drawable_update (GIMP_DRAWABLE (cu->channel), @@ -2241,8 +2244,11 @@ undo_pop_channel (GimpImage *gimage, gimp_container_insert (gimage->channels, GIMP_OBJECT (cu->channel), cu->prev_position); - /* set the new channel */ - gimp_image_set_active_channel (gimage, cu->channel); + if (cu->channel) + { + /* set the new channel */ + gimp_image_set_active_channel (gimage, cu->channel); + } /* update the area */ gimp_drawable_update (GIMP_DRAWABLE (cu->channel), @@ -2545,8 +2551,11 @@ undo_pop_vectors (GimpImage *gimage, /* remove the vectors */ gimp_container_remove (gimage->vectors, GIMP_OBJECT (vu->vectors)); - /* set the previous vectors */ - gimp_image_set_active_vectors (gimage, vu->prev_vectors); + if (vu->prev_vectors) + { + /* set the previous vectors */ + gimp_image_set_active_vectors (gimage, vu->prev_vectors); + } } else { @@ -2559,8 +2568,11 @@ undo_pop_vectors (GimpImage *gimage, gimp_container_insert (gimage->vectors, GIMP_OBJECT (vu->vectors), vu->prev_position); - /* set the new vectors */ - gimp_image_set_active_vectors (gimage, vu->vectors); + if (vu->vectors) + { + /* set the new vectors */ + gimp_image_set_active_vectors (gimage, vu->vectors); + } } return TRUE; @@ -2899,7 +2911,7 @@ undo_pop_fs_rigor (GimpImage *gimage, layer_ID = *((gint32 *) layer_ptr); - if ((floating_layer = (GimpLayer *) gimp_drawable_get_by_ID (gimage->gimp, layer_ID)) == NULL) + if ((floating_layer = (GimpLayer *) gimp_item_get_by_ID (gimage->gimp, layer_ID)) == NULL) return FALSE; if (! gimp_layer_is_floating_sel (floating_layer)) @@ -2982,7 +2994,7 @@ undo_pop_fs_relax (GimpImage *gimage, layer_ID = *((gint32 *) layer_ptr); - if ((floating_layer = (GimpLayer *) gimp_drawable_get_by_ID (gimage->gimp, layer_ID)) == NULL) + if ((floating_layer = (GimpLayer *) gimp_item_get_by_ID (gimage->gimp, layer_ID)) == NULL) return FALSE; if (! gimp_layer_is_floating_sel (floating_layer)) @@ -3250,7 +3262,7 @@ typedef struct _ParasiteUndo ParasiteUndo; struct _ParasiteUndo { GimpImage *gimage; - GimpDrawable *drawable; + GimpItem *item; GimpParasite *parasite; gchar *name; }; @@ -3277,7 +3289,7 @@ undo_push_image_parasite (GimpImage *gimage, new->free_func = undo_free_parasite; pu->gimage = gimage; - pu->drawable = NULL; + pu->item = NULL; pu->name = g_strdup (gimp_parasite_name (parasite)); pu->parasite = gimp_parasite_copy (gimp_image_parasite_find (gimage, pu->name)); @@ -3306,7 +3318,7 @@ undo_push_image_parasite_remove (GimpImage *gimage, new->free_func = undo_free_parasite; pu->gimage = gimage; - pu->drawable = NULL; + pu->item = NULL; pu->name = g_strdup (name); pu->parasite = gimp_parasite_copy (gimp_image_parasite_find (gimage, pu->name)); @@ -3318,9 +3330,9 @@ undo_push_image_parasite_remove (GimpImage *gimage, } gboolean -undo_push_drawable_parasite (GimpImage *gimage, - GimpDrawable *drawable, - gpointer parasite) +undo_push_item_parasite (GimpImage *gimage, + GimpItem *item, + gpointer parasite) { Undo *new; @@ -3336,10 +3348,10 @@ undo_push_drawable_parasite (GimpImage *gimage, new->free_func = undo_free_parasite; pu->gimage = NULL; - pu->drawable = drawable; + pu->item = item; pu->name = g_strdup (gimp_parasite_name (parasite)); - pu->parasite = gimp_parasite_copy (gimp_drawable_parasite_find (drawable, - pu->name)); + pu->parasite = gimp_parasite_copy (gimp_item_parasite_find (item, + pu->name)); return TRUE; } @@ -3347,9 +3359,9 @@ undo_push_drawable_parasite (GimpImage *gimage, } gboolean -undo_push_drawable_parasite_remove (GimpImage *gimage, - GimpDrawable *drawable, - const gchar *name) +undo_push_item_parasite_remove (GimpImage *gimage, + GimpItem *item, + const gchar *name) { Undo *new; @@ -3365,10 +3377,10 @@ undo_push_drawable_parasite_remove (GimpImage *gimage, new->free_func = undo_free_parasite; pu->gimage = NULL; - pu->drawable = drawable; + pu->item = item; pu->name = g_strdup (name); - pu->parasite = gimp_parasite_copy (gimp_drawable_parasite_find (drawable, - pu->name)); + pu->parasite = gimp_parasite_copy (gimp_item_parasite_find (item, + pu->name)); return TRUE; } @@ -3399,15 +3411,15 @@ undo_pop_parasite (GimpImage *gimage, else gimp_parasite_list_remove (data->gimage->parasites, data->name); } - else if (data->drawable) + else if (data->item) { data->parasite = - gimp_parasite_copy (gimp_drawable_parasite_find (data->drawable, - data->name)); + gimp_parasite_copy (gimp_item_parasite_find (data->item, + data->name)); if (tmp) - gimp_parasite_list_add (data->drawable->parasites, tmp); + gimp_parasite_list_add (data->item->parasites, tmp); else - gimp_parasite_list_remove (data->drawable->parasites, data->name); + gimp_parasite_list_remove (data->item->parasites, data->name); } else { diff --git a/app/core/gimpimage-undo-push.h b/app/core/gimpimage-undo-push.h index 442019fd7e..41263eac3f 100644 --- a/app/core/gimpimage-undo-push.h +++ b/app/core/gimpimage-undo-push.h @@ -67,136 +67,134 @@ gboolean undo_push_group_end (GimpImage *gimage); /* image undos */ -gboolean undo_push_image (GimpImage *gimage, - GimpDrawable *drawable, - gint x1, - gint y1, - gint x2, - gint y2); -gboolean undo_push_image_mod (GimpImage *gimage, - GimpDrawable *drawable, - gint x1, - gint y1, - gint x2, - gint y2, - TileManager *tiles, - gboolean sparse); -gboolean undo_push_image_type (GimpImage *gimage); -gboolean undo_push_image_size (GimpImage *gimage); -gboolean undo_push_image_resolution (GimpImage *gimage); -gboolean undo_push_image_mask (GimpImage *gimage, - TileManager *tiles, - gint x, - gint y); -gboolean undo_push_image_qmask (GimpImage *gimage); -gboolean undo_push_image_guide (GimpImage *gimage, - GimpGuide *guide); +gboolean undo_push_image (GimpImage *gimage, + GimpDrawable *drawable, + gint x1, + gint y1, + gint x2, + gint y2); +gboolean undo_push_image_mod (GimpImage *gimage, + GimpDrawable *drawable, + gint x1, + gint y1, + gint x2, + gint y2, + TileManager *tiles, + gboolean sparse); +gboolean undo_push_image_type (GimpImage *gimage); +gboolean undo_push_image_size (GimpImage *gimage); +gboolean undo_push_image_resolution (GimpImage *gimage); +gboolean undo_push_image_mask (GimpImage *gimage, + TileManager *tiles, + gint x, + gint y); +gboolean undo_push_image_qmask (GimpImage *gimage); +gboolean undo_push_image_guide (GimpImage *gimage, + GimpGuide *guide); /* layer undos */ -gboolean undo_push_layer_add (GimpImage *gimage, - GimpLayer *layer, - gint prev_position, - GimpLayer *prev_layer); -gboolean undo_push_layer_remove (GimpImage *gimage, - GimpLayer *layer, - gint prev_position, - GimpLayer *prev_layer); -gboolean undo_push_layer_mod (GimpImage *gimage, - GimpLayer *layer); -gboolean undo_push_layer_mask_add (GimpImage *gimage, - GimpLayer *layer, - GimpLayerMask *mask); -gboolean undo_push_layer_mask_remove (GimpImage *gimage, - GimpLayer *layer, - GimpLayerMask *mask); -gboolean undo_push_layer_rename (GimpImage *gimage, - GimpLayer *layer); -gboolean undo_push_layer_reposition (GimpImage *gimage, - GimpLayer *layer); -gboolean undo_push_layer_displace (GimpImage *gimage, - GimpLayer *layer); +gboolean undo_push_layer_add (GimpImage *gimage, + GimpLayer *layer, + gint prev_position, + GimpLayer *prev_layer); +gboolean undo_push_layer_remove (GimpImage *gimage, + GimpLayer *layer, + gint prev_position, + GimpLayer *prev_layer); +gboolean undo_push_layer_mod (GimpImage *gimage, + GimpLayer *layer); +gboolean undo_push_layer_mask_add (GimpImage *gimage, + GimpLayer *layer, + GimpLayerMask *mask); +gboolean undo_push_layer_mask_remove (GimpImage *gimage, + GimpLayer *layer, + GimpLayerMask *mask); +gboolean undo_push_layer_rename (GimpImage *gimage, + GimpLayer *layer); +gboolean undo_push_layer_reposition (GimpImage *gimage, + GimpLayer *layer); +gboolean undo_push_layer_displace (GimpImage *gimage, + GimpLayer *layer); /* channel undos */ -gboolean undo_push_channel_add (GimpImage *gimage, - GimpChannel *channel, - gint prev_position, - GimpChannel *prev_channel); -gboolean undo_push_channel_remove (GimpImage *gimage, - GimpChannel *channel, - gint prev_position, - GimpChannel *prev_channel); -gboolean undo_push_channel_mod (GimpImage *gimage, - GimpChannel *channel); -gboolean undo_push_channel_reposition (GimpImage *gimage, - GimpChannel *channel); +gboolean undo_push_channel_add (GimpImage *gimage, + GimpChannel *channel, + gint prev_position, + GimpChannel *prev_channel); +gboolean undo_push_channel_remove (GimpImage *gimage, + GimpChannel *channel, + gint prev_position, + GimpChannel *prev_channel); +gboolean undo_push_channel_mod (GimpImage *gimage, + GimpChannel *channel); +gboolean undo_push_channel_reposition (GimpImage *gimage, + GimpChannel *channel); /* vectors undos */ -gboolean undo_push_vectors_add (GimpImage *gimage, - GimpVectors *vectors, - gint prev_position, - GimpVectors *prev_vectors); -gboolean undo_push_vectors_remove (GimpImage *gimage, - GimpVectors *channel, - gint prev_position, - GimpVectors *prev_vectors); -gboolean undo_push_vectors_mod (GimpImage *gimage, - GimpVectors *vectors); -gboolean undo_push_vectors_reposition (GimpImage *gimage, - GimpVectors *vectors); +gboolean undo_push_vectors_add (GimpImage *gimage, + GimpVectors *vectors, + gint prev_position, + GimpVectors *prev_vectors); +gboolean undo_push_vectors_remove (GimpImage *gimage, + GimpVectors *channel, + gint prev_position, + GimpVectors *prev_vectors); +gboolean undo_push_vectors_mod (GimpImage *gimage, + GimpVectors *vectors); +gboolean undo_push_vectors_reposition (GimpImage *gimage, + GimpVectors *vectors); /* floating selection undos */ -gboolean undo_push_fs_to_layer (GimpImage *gimage, - GimpLayer *floating_layer, - GimpDrawable *drawable); -gboolean undo_push_fs_rigor (GimpImage *gimage, - gint32 layer_ID); -gboolean undo_push_fs_relax (GimpImage *gimage, - gint32 layer_ID); +gboolean undo_push_fs_to_layer (GimpImage *gimage, + GimpLayer *floating_layer, + GimpDrawable *drawable); +gboolean undo_push_fs_rigor (GimpImage *gimage, + gint32 layer_ID); +gboolean undo_push_fs_relax (GimpImage *gimage, + gint32 layer_ID); /* transform/paint drawable undos */ -gboolean undo_push_transform (GimpImage *gimage, - gint tool_ID, - GType tool_type, - gdouble *trans_info, - TileManager *original, - GSList *path_undo); -gboolean undo_push_paint (GimpImage *gimage, - gint core_ID, - GType core_type, - GimpCoords *last_coords); +gboolean undo_push_transform (GimpImage *gimage, + gint tool_ID, + GType tool_type, + gdouble *trans_info, + TileManager *original, + GSList *path_undo); +gboolean undo_push_paint (GimpImage *gimage, + gint core_ID, + GType core_type, + GimpCoords *last_coords); /* parasite undos */ -gboolean undo_push_image_parasite (GimpImage *gimage, - gpointer parasite); -gboolean undo_push_image_parasite_remove - (GimpImage *gimage, - const gchar *name); +gboolean undo_push_image_parasite (GimpImage *gimage, + gpointer parasite); +gboolean undo_push_image_parasite_remove (GimpImage *gimage, + const gchar *name); -gboolean undo_push_drawable_parasite (GimpImage *gimage, - GimpDrawable *drawable, - gpointer parasite); -gboolean undo_push_drawable_parasite_remove - (GimpImage *gimage, - GimpDrawable *drabable, - const gchar *name); +gboolean undo_push_item_parasite (GimpImage *gimage, + GimpItem *item, + gpointer parasite); +gboolean undo_push_item_parasite_remove (GimpImage *gimage, + GimpItem *item, + const gchar *name); /* EEK undo */ -gboolean undo_push_cantundo (GimpImage *gimage, - const gchar *action); +gboolean undo_push_cantundo (GimpImage *gimage, + const gchar *action); #endif /* __UNDO_H__ */ diff --git a/app/core/gimpimage.c b/app/core/gimpimage.c index 5e51c0356d..553e0fd02e 100644 --- a/app/core/gimpimage.c +++ b/app/core/gimpimage.c @@ -1753,7 +1753,7 @@ void gimp_image_apply_image (GimpImage *gimage, GimpDrawable *drawable, PixelRegion *src2PR, - gboolean undo, + gboolean push_undo, gint opacity, GimpLayerModeEffects mode, /* alternative to using drawable tiles as src1: */ @@ -1810,8 +1810,10 @@ gimp_image_apply_image (GimpImage *gimage, } /* If the calling procedure specified an undo step... */ - if (undo) - undo_push_image (gimp_drawable_gimage (drawable), drawable, x1, y1, x2, y2); + if (push_undo) + undo_push_image (gimp_item_get_image (GIMP_ITEM (drawable)), + drawable, + x1, y1, x2, y2); /* configure the pixel regions * If an alternative to using the drawable's data as src1 was provided... @@ -1864,7 +1866,7 @@ void gimp_image_replace_image (GimpImage *gimage, GimpDrawable *drawable, PixelRegion *src2PR, - gboolean undo, + gboolean push_undo, gint opacity, PixelRegion *maskPR, gint x, @@ -1920,7 +1922,7 @@ gimp_image_replace_image (GimpImage *gimage, } /* If the calling procedure specified an undo step... */ - if (undo) + if (push_undo) gimp_drawable_apply_image (drawable, x1, y1, x2, y2, NULL, FALSE); /* configure the pixel regions @@ -2104,8 +2106,6 @@ gimp_image_set_tattoo_state (GimpImage *gimage, gboolean retval = TRUE; GimpChannel *channel; GimpTattoo maxval = 0; - Path *pptr = NULL; - PathList *plist; g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); @@ -2115,16 +2115,16 @@ gimp_image_set_tattoo_state (GimpImage *gimage, { GimpTattoo ltattoo; - ltattoo = gimp_drawable_get_tattoo (GIMP_DRAWABLE (list->data)); + ltattoo = gimp_item_get_tattoo (GIMP_ITEM (list->data)); if (ltattoo > maxval) maxval = ltattoo; + if (gimp_image_get_channel_by_tattoo (gimage, ltattoo) != NULL) { retval = FALSE; /* Oopps duplicated tattoo in channel */ } - /* Now check path an't got this tattoo */ - if (path_get_path_by_tattoo (gimage, ltattoo) != NULL) + if (gimp_image_get_vectors_by_tattoo (gimage, ltattoo) != NULL) { retval = FALSE; /* Oopps duplicated tattoo in layer */ } @@ -2139,33 +2139,26 @@ gimp_image_set_tattoo_state (GimpImage *gimage, channel = (GimpChannel *) list->data; - ctattoo = gimp_drawable_get_tattoo (GIMP_DRAWABLE (channel)); + ctattoo = gimp_item_get_tattoo (GIMP_ITEM (channel)); if (ctattoo > maxval) maxval = ctattoo; - /* Now check path an't got this tattoo */ - if (path_get_path_by_tattoo (gimage, ctattoo) != NULL) + + if (gimp_image_get_vectors_by_tattoo (gimage, ctattoo) != NULL) { retval = FALSE; /* Oopps duplicated tattoo in layer */ } } - /* Find the max tatto value in the paths */ - plist = gimage->paths; - - if (plist && plist->bz_paths) + /* Find the max tatto value in the vectors */ + for (list = GIMP_LIST (gimage->channels)->list; + list; + list = g_list_next (list)) { - GimpTattoo ptattoo; - GSList *pl; + GimpTattoo vtattoo; - for (pl = plist->bz_paths; pl; pl = g_slist_next (pl)) - { - pptr = pl->data; - - ptattoo = path_get_tattoo (pptr); - - if (ptattoo > maxval) - maxval = ptattoo; - } + vtattoo = gimp_item_get_tattoo (GIMP_ITEM (list->data)); + if (vtattoo > maxval) + maxval = vtattoo; } if (val < maxval) @@ -2454,7 +2447,7 @@ gimp_image_get_layer_by_tattoo (const GimpImage *gimage, { layer = (GimpLayer *) list->data; - if (gimp_drawable_get_tattoo (GIMP_DRAWABLE (layer)) == tattoo) + if (gimp_item_get_tattoo (GIMP_ITEM (layer)) == tattoo) return layer; } @@ -2476,7 +2469,7 @@ gimp_image_get_channel_by_tattoo (const GimpImage *gimage, { channel = (GimpChannel *) list->data; - if (gimp_drawable_get_tattoo (GIMP_DRAWABLE (channel)) == tattoo) + if (gimp_item_get_tattoo (GIMP_ITEM (channel)) == tattoo) return channel; } @@ -2498,10 +2491,8 @@ gimp_image_get_vectors_by_tattoo (const GimpImage *gimage, { vectors = (GimpVectors *) list->data; -#if 0 - if (gimp_vectors_get_tattoo (GIMP_VECTORS (vectors)) == tattoo) + if (gimp_item_get_tattoo (GIMP_ITEM (vectors)) == tattoo) return vectors; -#endif } return NULL; @@ -2581,8 +2572,8 @@ gimp_image_add_layer (GimpImage *gimage, g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE); - if (GIMP_DRAWABLE (layer)->gimage != NULL && - GIMP_DRAWABLE (layer)->gimage != gimage) + if (GIMP_ITEM (layer)->gimage != NULL && + GIMP_ITEM (layer)->gimage != gimage) { g_warning ("%s: attempting to add layer to wrong image.", G_GNUC_PRETTY_FUNCTION); @@ -2606,12 +2597,12 @@ gimp_image_add_layer (GimpImage *gimage, gimage->floating_sel = layer; /* let the layer know about the gimage */ - gimp_drawable_set_gimage (GIMP_DRAWABLE (layer), gimage); - + gimp_item_set_image (GIMP_ITEM (layer), gimage); + /* If the layer has a mask, set the mask's gimage */ if (layer->mask) { - gimp_drawable_set_gimage (GIMP_DRAWABLE (layer->mask), gimage); + gimp_item_set_image (GIMP_ITEM (layer->mask), gimage); } /* add the layer to the list at the specified position */ @@ -2704,7 +2695,7 @@ gimp_image_remove_layer (GimpImage *gimage, } /* Send out REMOVED signal from layer */ - gimp_drawable_removed (GIMP_DRAWABLE (layer)); + gimp_item_removed (GIMP_ITEM (layer)); gimp_drawable_offsets (GIMP_DRAWABLE (layer), &x, &y); w = gimp_drawable_width (GIMP_DRAWABLE (layer)); @@ -2885,8 +2876,8 @@ gimp_image_add_channel (GimpImage *gimage, g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); g_return_val_if_fail (GIMP_IS_CHANNEL (channel), FALSE); - if (GIMP_DRAWABLE (channel)->gimage != NULL && - GIMP_DRAWABLE (channel)->gimage != gimage) + if (GIMP_ITEM (channel)->gimage != NULL && + GIMP_ITEM (channel)->gimage != gimage) { g_warning ("%s: attempting to add channel to wrong image.", G_GNUC_PRETTY_FUNCTION); @@ -2905,8 +2896,25 @@ gimp_image_add_channel (GimpImage *gimage, 0, gimp_image_get_active_channel (gimage)); - /* add the channel to the list */ - gimp_container_add (gimage->channels, GIMP_OBJECT (channel)); + /* add the layer to the list at the specified position */ + if (position == -1) + { + GimpChannel *active_channel; + + active_channel = gimp_image_get_active_channel (gimage); + + if (active_channel) + { + position = gimp_container_get_child_index (gimage->channels, + GIMP_OBJECT (active_channel)); + } + else + { + position = 0; + } + } + + gimp_container_insert (gimage->channels, GIMP_OBJECT (channel), position); g_object_unref (G_OBJECT (channel)); /* notify this gimage of the currently active channel */ @@ -2943,7 +2951,7 @@ gimp_image_remove_channel (GimpImage *gimage, gimp_container_remove (gimage->channels, GIMP_OBJECT (channel)); /* Send out REMOVED signal from channel */ - gimp_drawable_removed (GIMP_DRAWABLE (channel)); + gimp_item_removed (GIMP_ITEM (channel)); if (channel == gimp_image_get_active_channel (gimage)) { @@ -3053,15 +3061,13 @@ gimp_image_add_vectors (GimpImage *gimage, g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE); -#if 0 - if (GIMP_VECTORS (vectors)->gimage != NULL && - GIMP_VECTORS (vectors)->gimage != gimage) + if (GIMP_ITEM (vectors)->gimage != NULL && + GIMP_ITEM (vectors)->gimage != gimage) { g_warning ("%s: attempting to add vectors to wrong image.", G_GNUC_PRETTY_FUNCTION); return FALSE; } -#endif if (gimp_container_have (gimage->vectors, GIMP_OBJECT (vectors))) { @@ -3075,8 +3081,27 @@ gimp_image_add_vectors (GimpImage *gimage, 0, gimp_image_get_active_vectors (gimage)); - /* add the vectors to the list */ - gimp_container_add (gimage->vectors, GIMP_OBJECT (vectors)); + gimp_item_set_image (GIMP_ITEM (vectors), gimage); + + /* add the layer to the list at the specified position */ + if (position == -1) + { + GimpVectors *active_vectors; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + position = gimp_container_get_child_index (gimage->vectors, + GIMP_OBJECT (active_vectors)); + } + else + { + position = 0; + } + } + + gimp_container_insert (gimage->vectors, GIMP_OBJECT (vectors), position); g_object_unref (G_OBJECT (vectors)); /* notify this gimage of the currently active vectors */ @@ -3105,10 +3130,10 @@ gimp_image_remove_vectors (GimpImage *gimage, gimp_container_remove (gimage->vectors, GIMP_OBJECT (vectors)); -#if 0 + gimp_item_set_image (GIMP_ITEM (vectors), NULL); + /* Send out REMOVED signal from vectors */ - gimp_vectors_removed (GIMP_VECTORS (vectors)); -#endif + gimp_item_removed (GIMP_ITEM (vectors)); if (vectors == gimp_image_get_active_vectors (gimage)) { @@ -3119,6 +3144,13 @@ gimp_image_remove_vectors (GimpImage *gimage, GIMP_VECTORS (gimp_container_get_child_by_index (gimage->vectors, 0))); } + else + { + gimage->active_vectors = NULL; + + g_signal_emit (G_OBJECT (gimage), + gimp_image_signals[ACTIVE_VECTORS_CHANGED], 0); + } } g_object_unref (G_OBJECT (vectors)); diff --git a/app/core/gimpimagemap.c b/app/core/gimpimagemap.c index cb939e35a1..888defc636 100644 --- a/app/core/gimpimagemap.c +++ b/app/core/gimpimagemap.c @@ -126,7 +126,7 @@ image_map_apply (ImageMap *image_map, } /* Make sure the drawable is still valid */ - if (! gimp_drawable_gimage (image_map->drawable)) + if (! gimp_item_get_image (GIMP_ITEM (image_map->drawable))) return; /* The application should occur only within selection bounds */ @@ -227,7 +227,7 @@ image_map_commit (ImageMap *image_map) } /* Make sure the drawable is still valid */ - if (! gimp_drawable_gimage (image_map->drawable)) + if (! gimp_item_get_image (GIMP_ITEM (image_map->drawable))) return; /* Interactive phase ends: we can commit an undo frame now */ @@ -268,7 +268,7 @@ image_map_clear (ImageMap *image_map) image_map->state = IMAGE_MAP_WAITING; /* Make sure the drawable is still valid */ - if (! gimp_drawable_gimage (image_map->drawable)) + if (! gimp_item_get_image (GIMP_ITEM (image_map->drawable))) return; /* restore the original image */ @@ -344,7 +344,7 @@ image_map_get_color_at (ImageMap *image_map, return (gimp_drawable_get_color_at (image_map->drawable, x, y)); if (! image_map || - (! gimp_drawable_gimage (image_map->drawable) && + (! gimp_item_get_image (GIMP_ITEM (image_map->drawable)) && gimp_drawable_is_indexed (image_map->drawable)) || x < 0 || y < 0 || x >= tile_manager_width (image_map->undo_tiles) || @@ -357,7 +357,7 @@ image_map_get_color_at (ImageMap *image_map, read_pixel_data_1 (image_map->undo_tiles, x, y, src); - gimp_image_get_color (gimp_drawable_gimage (image_map->drawable), + gimp_image_get_color (gimp_item_get_image (GIMP_ITEM (image_map->drawable)), gimp_drawable_type (image_map->drawable), dest, src); @@ -392,7 +392,7 @@ image_map_do (gpointer data) image_map = (ImageMap *) data; - if (! (gimage = gimp_drawable_gimage (image_map->drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (image_map->drawable)))) { image_map->state = IMAGE_MAP_WAITING; diff --git a/app/core/gimpitem.c b/app/core/gimpitem.c new file mode 100644 index 0000000000..8c9e8ad27e --- /dev/null +++ b/app/core/gimpitem.c @@ -0,0 +1,441 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "config.h" + +#include +#include +#include + +#include + +#include "libgimpbase/gimpbase.h" + +#include "core-types.h" + +#include "gimp.h" +#include "gimpchannel.h" +#include "gimpimage.h" +#include "gimpitem.h" +#include "gimplayer.h" +#include "gimplist.h" +#include "gimpmarshal.h" +#include "gimpparasite.h" +#include "gimpparasitelist.h" + +#include "vectors/gimpvectors.h" + +#include "undo.h" + +#include "libgimp/gimpintl.h" + + +enum +{ + REMOVED, + LAST_SIGNAL +}; + + +/* local function prototypes */ + +static void gimp_item_class_init (GimpItemClass *klass); +static void gimp_item_init (GimpItem *item); + +static void gimp_item_finalize (GObject *object); + +static void gimp_item_name_changed (GimpObject *object); +static gsize gimp_item_get_memsize (GimpObject *object); + + +/* private variables */ + +static guint gimp_item_signals[LAST_SIGNAL] = { 0 }; + +static GimpViewableClass *parent_class = NULL; + + +GType +gimp_item_get_type (void) +{ + static GType item_type = 0; + + if (! item_type) + { + static const GTypeInfo item_info = + { + sizeof (GimpItemClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) gimp_item_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GimpItem), + 0, /* n_preallocs */ + (GInstanceInitFunc) gimp_item_init, + }; + + item_type = g_type_register_static (GIMP_TYPE_VIEWABLE, + "GimpItem", + &item_info, 0); + } + + return item_type; +} + +static void +gimp_item_class_init (GimpItemClass *klass) +{ + GObjectClass *object_class; + GimpObjectClass *gimp_object_class; + + object_class = G_OBJECT_CLASS (klass); + gimp_object_class = GIMP_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + gimp_item_signals[REMOVED] = + g_signal_new ("removed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GimpItemClass, removed), + NULL, NULL, + gimp_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + object_class->finalize = gimp_item_finalize; + + gimp_object_class->name_changed = gimp_item_name_changed; + gimp_object_class->get_memsize = gimp_item_get_memsize; + + klass->removed = NULL; +} + +static void +gimp_item_init (GimpItem *item) +{ + item->ID = 0; + item->tattoo = 0; + item->gimage = NULL; + item->parasites = gimp_parasite_list_new (); +} + +static void +gimp_item_finalize (GObject *object) +{ + GimpItem *item; + + g_return_if_fail (GIMP_IS_ITEM (object)); + + item = GIMP_ITEM (object); + + if (item->gimage && item->gimage->gimp) + { + g_hash_table_remove (item->gimage->gimp->item_table, + GINT_TO_POINTER (item->ID)); + item->gimage = NULL; + } + + if (item->parasites) + { + g_object_unref (G_OBJECT (item->parasites)); + item->parasites = NULL; + } + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gimp_item_name_changed (GimpObject *object) +{ + GimpItem *item; + GimpItem *item2; + GList *list, *list2, *base_list; + gint unique_ext = 0; + gchar *ext; + gchar *new_name = NULL; + + g_return_if_fail (GIMP_IS_ITEM (object)); + + item = GIMP_ITEM (object); + + /* if no other items to check name against */ + if (item->gimage == NULL) + return; + + if (GIMP_IS_LAYER (item)) + base_list = GIMP_LIST (item->gimage->layers)->list; + else if (GIMP_IS_CHANNEL (item)) + base_list = GIMP_LIST (item->gimage->channels)->list; + else if (GIMP_IS_VECTORS (item)) + base_list = GIMP_LIST (item->gimage->vectors)->list; + else + base_list = NULL; + + for (list = base_list; + list; + list = g_list_next (list)) + { + item2 = GIMP_ITEM (list->data); + + if (item != item2 && + strcmp (gimp_object_get_name (GIMP_OBJECT (item)), + gimp_object_get_name (GIMP_OBJECT (item2))) == 0) + { + ext = strrchr (GIMP_OBJECT (item)->name, '#'); + + if (ext) + { + gchar *ext_str; + + unique_ext = atoi (ext + 1); + + ext_str = g_strdup_printf ("%d", unique_ext); + + /* check if the extension really is of the form "#" */ + if (! strcmp (ext_str, ext + 1)) + { + *ext = '\0'; + } + else + { + unique_ext = 0; + } + + g_free (ext_str); + } + else + { + unique_ext = 0; + } + + do + { + unique_ext++; + + g_free (new_name); + + new_name = g_strdup_printf ("%s#%d", + GIMP_OBJECT (item)->name, + unique_ext); + + for (list2 = base_list; list2; list2 = g_list_next (list2)) + { + item2 = GIMP_ITEM (list2->data); + + if (item == item2) + continue; + + if (! strcmp (GIMP_OBJECT (item2)->name, new_name)) + { + break; + } + } + } + while (list2); + + g_free (GIMP_OBJECT (item)->name); + + GIMP_OBJECT (item)->name = new_name; + + break; + } + } +} + +static gsize +gimp_item_get_memsize (GimpObject *object) +{ + GimpItem *item; + gsize memsize = 0; + + item = GIMP_ITEM (object); + + memsize += gimp_object_get_memsize (GIMP_OBJECT (item->parasites)); + + return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object); +} + +void +gimp_item_removed (GimpItem *item) +{ + g_return_if_fail (GIMP_IS_ITEM (item)); + + g_signal_emit (G_OBJECT (item), gimp_item_signals[REMOVED], 0); +} + +gint +gimp_item_get_ID (GimpItem *item) +{ + g_return_val_if_fail (GIMP_IS_ITEM (item), -1); + + return item->ID; +} + +GimpItem * +gimp_item_get_by_ID (Gimp *gimp, + gint item_id) +{ + g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); + + if (gimp->item_table == NULL) + return NULL; + + return (GimpItem *) g_hash_table_lookup (gimp->item_table, + GINT_TO_POINTER (item_id)); +} + +GimpTattoo +gimp_item_get_tattoo (const GimpItem *item) +{ + g_return_val_if_fail (GIMP_IS_ITEM (item), 0); + + return item->tattoo; +} + +void +gimp_item_set_tattoo (GimpItem *item, + GimpTattoo tattoo) +{ + g_return_if_fail (GIMP_IS_ITEM (item)); + + item->tattoo = tattoo; +} + +GimpImage * +gimp_item_get_image (const GimpItem *item) +{ + g_return_val_if_fail (GIMP_IS_ITEM (item), NULL); + + return item->gimage; +} + +void +gimp_item_set_image (GimpItem *item, + GimpImage *gimage) +{ + g_return_if_fail (GIMP_IS_ITEM (item)); + g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage));; + + if (gimage == NULL) + item->tattoo = 0; + else if (item->tattoo == 0 || item->gimage != gimage ) + item->tattoo = gimp_image_get_new_tattoo (gimage); + + item->gimage = gimage; +} + +void +gimp_item_parasite_attach (GimpItem *item, + GimpParasite *parasite) +{ + g_return_if_fail (GIMP_IS_ITEM (item)); + + /* only set the dirty bit manually if we can be saved and the new + parasite differs from the current one and we arn't undoable */ + if (gimp_parasite_is_undoable (parasite)) + { + /* do a group in case we have attach_parent set */ + undo_push_group_start (item->gimage, PARASITE_ATTACH_UNDO_GROUP); + + undo_push_item_parasite (item->gimage, item, parasite); + } + else if (gimp_parasite_is_persistent (parasite) && + ! gimp_parasite_compare (parasite, + gimp_item_parasite_find + (item, gimp_parasite_name (parasite)))) + { + undo_push_cantundo (item->gimage, _("parasite attached to item")); + } + + gimp_parasite_list_add (item->parasites, parasite); + + if (gimp_parasite_has_flag (parasite, GIMP_PARASITE_ATTACH_PARENT)) + { + gimp_parasite_shift_parent (parasite); + gimp_image_parasite_attach (item->gimage, parasite); + } + else if (gimp_parasite_has_flag (parasite, GIMP_PARASITE_ATTACH_GRANDPARENT)) + { + gimp_parasite_shift_parent (parasite); + gimp_parasite_shift_parent (parasite); + gimp_parasite_attach (item->gimage->gimp, parasite); + } + + if (gimp_parasite_is_undoable (parasite)) + { + undo_push_group_end (item->gimage); + } +} + +void +gimp_item_parasite_detach (GimpItem *item, + const gchar *parasite) +{ + GimpParasite *p; + + g_return_if_fail (GIMP_IS_ITEM (item)); + + if (! (p = gimp_parasite_list_find (item->parasites, parasite))) + return; + + if (gimp_parasite_is_undoable (p)) + undo_push_item_parasite_remove (item->gimage, item, + gimp_parasite_name (p)); + else if (gimp_parasite_is_persistent (p)) + undo_push_cantundo (item->gimage, _("parasite detached from item")); + + gimp_parasite_list_remove (item->parasites, parasite); +} + +GimpParasite * +gimp_item_parasite_find (const GimpItem *item, + const gchar *name) +{ + g_return_val_if_fail (GIMP_IS_ITEM (item), NULL); + + return gimp_parasite_list_find (item->parasites, name); +} + +static void +gimp_item_parasite_list_foreach_func (gchar *key, + GimpParasite *p, + gchar ***cur) +{ + *(*cur)++ = (gchar *) g_strdup (key); +} + +gchar ** +gimp_item_parasite_list (const GimpItem *item, + gint *count) +{ + gchar **list; + gchar **cur; + + g_return_val_if_fail (GIMP_IS_ITEM (item), NULL); + g_return_val_if_fail (count != NULL, NULL); + + *count = gimp_parasite_list_length (item->parasites); + cur = list = g_new (gchar *, *count); + + gimp_parasite_list_foreach (item->parasites, + (GHFunc) gimp_item_parasite_list_foreach_func, + &cur); + + return list; +} diff --git a/app/core/gimpitem.h b/app/core/gimpitem.h new file mode 100644 index 0000000000..26340355f1 --- /dev/null +++ b/app/core/gimpitem.h @@ -0,0 +1,82 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __GIMP_ITEM_H__ +#define __GIMP_ITEM_H__ + + +#include "gimpviewable.h" + + +#define GIMP_TYPE_ITEM (gimp_item_get_type ()) +#define GIMP_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_ITEM, GimpItem)) +#define GIMP_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_ITEM, GimpItemClass)) +#define GIMP_IS_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_ITEM)) +#define GIMP_IS_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_ITEM)) +#define GIMP_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_ITEM, GimpItemClass)) + + +typedef struct _GimpItemClass GimpItemClass; + +struct _GimpItem +{ + GimpViewable parent_instance; + + gint ID; /* provides a unique ID */ + guint32 tattoo; /* provides a perminant ID */ + + GimpImage *gimage; /* gimage owner */ + + GimpParasiteList *parasites; /* Plug-in parasite data */ +}; + +struct _GimpItemClass +{ + GimpViewableClass parent_class; + + void (* removed) (GimpItem *item); +}; + + +GType gimp_item_get_type (void) G_GNUC_CONST; + +void gimp_item_removed (GimpItem *item); + +gint gimp_item_get_ID (GimpItem *item); +GimpItem * gimp_item_get_by_ID (Gimp *gimp, + gint id); + +GimpTattoo gimp_item_get_tattoo (const GimpItem *item); +void gimp_item_set_tattoo (GimpItem *item, + GimpTattoo tattoo); + +GimpImage * gimp_item_get_image (const GimpItem *item); +void gimp_item_set_image (GimpItem *item, + GimpImage *gimage); + +void gimp_item_parasite_attach (GimpItem *item, + GimpParasite *parasite); +void gimp_item_parasite_detach (GimpItem *item, + const gchar *parasite); +GimpParasite * gimp_item_parasite_find (const GimpItem *item, + const gchar *name); +gchar ** gimp_item_parasite_list (const GimpItem *item, + gint *count); + + +#endif /* __GIMP_ITEM_H__ */ diff --git a/app/core/gimplayer-floating-sel.c b/app/core/gimplayer-floating-sel.c index 66227e22c5..e145efffe1 100644 --- a/app/core/gimplayer-floating-sel.c +++ b/app/core/gimplayer-floating-sel.c @@ -48,7 +48,7 @@ floating_sel_attach (GimpLayer *layer, GimpImage *gimage; GimpLayer *floating_sel; - if (! (gimage = gimp_drawable_gimage (drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable)))) return; /* If there is already a floating selection, anchor it */ @@ -93,7 +93,7 @@ floating_sel_remove (GimpLayer *layer) { GimpImage *gimage; - if (! (gimage = gimp_drawable_gimage (layer->fs.drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (layer->fs.drawable)))) return; /* store the affected area from the drawable in the backing store */ @@ -116,7 +116,7 @@ floating_sel_anchor (GimpLayer *layer) { GimpImage *gimage; - if (! (gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (layer)))) return; if (! gimp_layer_is_floating_sel (layer)) @@ -161,7 +161,7 @@ floating_sel_reset (GimpLayer *layer) { GimpImage *gimage; - if (! (gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (layer)))) return; /* set the underlying drawable to active */ @@ -189,7 +189,7 @@ floating_sel_to_layer (GimpLayer *layer) g_return_if_fail (GIMP_IS_LAYER (layer)); - if (! (gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (layer)))) return; /* Check if the floating layer belongs to a channel... */ @@ -340,7 +340,7 @@ void floating_sel_rigor (GimpLayer *layer, gboolean undo) { - GimpImage *gimage = GIMP_DRAWABLE (layer)->gimage; + GimpImage *gimage = gimp_item_get_image (GIMP_ITEM (layer)); /* store the affected area from the drawable in the backing store */ floating_sel_store (layer, @@ -351,14 +351,14 @@ floating_sel_rigor (GimpLayer *layer, layer->fs.initial = TRUE; if (undo) - undo_push_fs_rigor (gimage, GIMP_DRAWABLE (layer)->ID); + undo_push_fs_rigor (gimage, GIMP_ITEM (layer)->ID); } void floating_sel_relax (GimpLayer *layer, gboolean undo) { - GimpImage *gimage = GIMP_DRAWABLE (layer)->gimage; + GimpImage *gimage = gimp_item_get_image (GIMP_ITEM (layer)); /* restore the contents of drawable the floating layer is attached to */ if (layer->fs.initial == FALSE) @@ -370,7 +370,7 @@ floating_sel_relax (GimpLayer *layer, layer->fs.initial = TRUE; if (undo) - undo_push_fs_relax (gimage, GIMP_DRAWABLE (layer)->ID); + undo_push_fs_relax (gimage, GIMP_ITEM (layer)->ID); } void @@ -392,7 +392,7 @@ floating_sel_composite (GimpLayer *layer, d_layer = NULL; - if (! (gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (layer)))) return; /* What this function does is composite the specified area of the diff --git a/app/core/gimplayer.c b/app/core/gimplayer.c index b5941997c8..49f9ebc853 100644 --- a/app/core/gimplayer.c +++ b/app/core/gimplayer.c @@ -367,8 +367,8 @@ gimp_layer_copy (const GimpLayer *layer, } GimpLayer * -gimp_layer_new_from_tiles (GimpImage *gimage, - TileManager *tiles, +gimp_layer_new_from_tiles (TileManager *tiles, + GimpImage *dest_gimage, const gchar *name, gint opacity, GimpLayerModeEffects mode) @@ -382,14 +382,14 @@ gimp_layer_new_from_tiles (GimpImage *gimage, * the contents to meet the requirements of the target image type */ - g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL); g_return_val_if_fail (tiles != NULL, NULL); + g_return_val_if_fail (GIMP_IS_IMAGE (dest_gimage), NULL); g_return_val_if_fail (name != NULL, NULL); - new_layer = gimp_layer_new (gimage, + new_layer = gimp_layer_new (dest_gimage, tile_manager_width (tiles), tile_manager_height (tiles), - gimp_image_base_type_with_alpha (gimage), + gimp_image_base_type_with_alpha (dest_gimage), name, opacity, mode); @@ -423,7 +423,7 @@ gimp_layer_new_from_tiles (GimpImage *gimage, else { /* Transform the contents of the buf to the new_layer */ - gimp_layer_transform_color (gimage, + gimp_layer_transform_color (dest_gimage, &layerPR, &bufPR, GIMP_DRAWABLE (new_layer), ((tile_manager_bpp (tiles) == 4) ? @@ -434,18 +434,18 @@ gimp_layer_new_from_tiles (GimpImage *gimage, } GimpLayer * -gimp_layer_new_from_drawable (GimpImage *dest_image, - GimpDrawable *drawable) +gimp_layer_new_from_drawable (GimpDrawable *drawable, + GimpImage *dest_image) { GimpImage *src_image; GimpImageBaseType old_base_type; GimpDrawable *new_drawable; GimpImageBaseType new_base_type; - g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), NULL); g_return_val_if_fail (GIMP_DRAWABLE (drawable), NULL); + g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), NULL); - src_image = gimp_drawable_gimage (drawable); + src_image = gimp_item_get_image (GIMP_ITEM (drawable)); old_base_type = gimp_image_base_type (src_image); new_base_type = gimp_image_base_type (dest_image); @@ -523,7 +523,7 @@ gimp_layer_new_from_drawable (GimpImage *dest_image, new_drawable->has_alpha = GIMP_IMAGE_TYPE_HAS_ALPHA (new_type); } - gimp_drawable_set_gimage (new_drawable, dest_image); + gimp_item_set_image (GIMP_ITEM (new_drawable), dest_image); return GIMP_LAYER (new_drawable); } @@ -538,7 +538,7 @@ gimp_layer_add_mask (GimpLayer *layer, g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (GIMP_IS_LAYER_MASK (mask), NULL); - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)); + gimage = gimp_item_get_image (GIMP_ITEM (layer)); if (! gimage) { @@ -606,12 +606,12 @@ gimp_layer_create_mask (const GimpLayer *layer, gchar *mask_name; GimpRGB black = { 0.0, 0.0, 0.0, 1.0 }; - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)); + gimage = gimp_item_get_image (GIMP_ITEM (layer)); mask_name = g_strdup_printf (_("%s mask"), gimp_object_get_name (GIMP_OBJECT (layer))); - mask = gimp_layer_mask_new (GIMP_DRAWABLE (layer)->gimage, + mask = gimp_layer_mask_new (gimp_item_get_image (GIMP_ITEM (layer)), GIMP_DRAWABLE (layer)->width, GIMP_DRAWABLE (layer)->height, mask_name, &black); @@ -752,7 +752,7 @@ gimp_layer_apply_mask (GimpLayer *layer, if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer))) return; - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)); + gimage = gimp_item_get_image (GIMP_ITEM (layer)); if (! gimage) return; @@ -829,7 +829,7 @@ gimp_layer_translate (GimpLayer *layer, gint off_y) { /* the undo call goes here */ - undo_push_layer_displace (GIMP_DRAWABLE (layer)->gimage, layer); + undo_push_layer_displace (gimp_item_get_image (GIMP_ITEM (layer)), layer); /* update the affected region */ gimp_drawable_update (GIMP_DRAWABLE (layer), @@ -894,7 +894,7 @@ gimp_layer_add_alpha (GimpLayer *layer) add_alpha_region (&srcPR, &destPR); /* Push the layer on the undo stack */ - undo_push_layer_mod (GIMP_DRAWABLE (layer)->gimage, layer); + undo_push_layer_mod (gimp_item_get_image (GIMP_ITEM (layer)), layer); /* Configure the new layer */ GIMP_DRAWABLE (layer)->tiles = new_tiles; @@ -903,7 +903,7 @@ gimp_layer_add_alpha (GimpLayer *layer) GIMP_DRAWABLE (layer)->has_alpha = GIMP_IMAGE_TYPE_HAS_ALPHA (type); GIMP_DRAWABLE (layer)->preview_valid = FALSE; - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)); + gimage = gimp_item_get_image (GIMP_ITEM (layer)); if (gimage->layers->num_children == 1) { @@ -958,7 +958,7 @@ gimp_layer_scale_lowlevel (GimpLayer *layer, } /* Push the layer on the undo stack */ - undo_push_layer_mod (GIMP_DRAWABLE (layer)->gimage, layer); + undo_push_layer_mod (gimp_item_get_image (GIMP_ITEM (layer)), layer); /* Configure the new layer */ @@ -1010,7 +1010,7 @@ gimp_layer_check_scaling (const GimpLayer *layer, gint new_layer_width; gint new_layer_height; - gimage = GIMP_DRAWABLE (layer)->gimage; + gimage = gimp_item_get_image (GIMP_ITEM (layer)); img_scale_w = (gdouble) new_width / (gdouble) gimage->width; img_scale_h = (gdouble) new_height / (gdouble) gimage->height; new_layer_width = ROUND (img_scale_w * @@ -1224,7 +1224,7 @@ gimp_layer_resize (GimpLayer *layer, { guchar bg[3]; - gimp_image_get_background (GIMP_DRAWABLE (layer)->gimage, + gimp_image_get_background (gimp_item_get_image (GIMP_ITEM (layer)), GIMP_DRAWABLE (layer), bg); color_region (&destPR, bg); } @@ -1239,7 +1239,7 @@ gimp_layer_resize (GimpLayer *layer, copy_region (&srcPR, &destPR); /* Push the layer on the undo stack */ - undo_push_layer_mod (GIMP_DRAWABLE(layer)->gimage, layer); + undo_push_layer_mod (gimp_item_get_image (GIMP_ITEM (layer)), layer); /* Configure the new layer */ GIMP_DRAWABLE (layer)->tiles = new_tiles; @@ -1274,7 +1274,7 @@ gimp_layer_resize_to_image (GimpLayer *layer) gint offset_x; gint offset_y; - if (!(gimage = GIMP_DRAWABLE (layer)->gimage)) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (layer)))) return; undo_push_group_start (gimage, LAYER_RESIZE_UNDO_GROUP); @@ -1355,7 +1355,7 @@ gimp_layer_invalidate_boundary (GimpLayer *layer) GimpImage *gimage; GimpChannel *mask; - if (! (gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (layer)))) return; /* Turn the current selection off */ diff --git a/app/core/gimplayer.h b/app/core/gimplayer.h index 9620efc1b9..6eb504b607 100644 --- a/app/core/gimplayer.h +++ b/app/core/gimplayer.h @@ -85,13 +85,13 @@ GimpLayer * gimp_layer_copy (const GimpLayer *layer, GType new_type, gboolean add_alpha); -GimpLayer * gimp_layer_new_from_tiles (GimpImage *gimage, - TileManager *tiles, +GimpLayer * gimp_layer_new_from_tiles (TileManager *tiles, + GimpImage *dest_gimage, const gchar *name, gint opacity, GimpLayerModeEffects mode); -GimpLayer * gimp_layer_new_from_drawable (GimpImage *dest_image, - GimpDrawable *drawable); +GimpLayer * gimp_layer_new_from_drawable (GimpDrawable *drawable, + GimpImage *dest_image); gboolean gimp_layer_check_scaling (const GimpLayer *layer, gint new_width, diff --git a/app/dialogs/dialogs-constructors.c b/app/dialogs/dialogs-constructors.c index 373bbc8721..e91c7ae20a 100644 --- a/app/dialogs/dialogs-constructors.c +++ b/app/dialogs/dialogs-constructors.c @@ -35,6 +35,8 @@ #include "core/gimppalette.h" #include "core/gimptoolinfo.h" +#include "vectors/gimpvectors.h" + #include "widgets/gimpbrushfactoryview.h" #include "widgets/gimpbufferview.h" #include "widgets/gimpcontainerlistview.h" @@ -43,10 +45,10 @@ #include "widgets/gimpdialogfactory.h" #include "widgets/gimpimagedock.h" #include "widgets/gimpitemfactory.h" +#include "widgets/gimpitemlistview.h" #include "widgets/gimpdockable.h" #include "widgets/gimpdockbook.h" #include "widgets/gimpdocumentview.h" -#include "widgets/gimpdrawablelistview.h" #include "widgets/gimplistitem.h" #include "widgets/gimppreview.h" @@ -80,6 +82,7 @@ #include "tips-dialog.h" #include "tool-options-dialog.h" #include "toolbox.h" +#include "vectors-commands.h" #include "gimprc.h" #include "undo_history.h" @@ -93,33 +96,33 @@ /* local function prototypes */ -static void dialogs_indexed_palette_selected (GimpColormapDialog *dialog, - GimpDockable *dockable); +static void dialogs_indexed_palette_selected (GimpColormapDialog *dialog, + GimpDockable *dockable); -static GtkWidget * dialogs_brush_tab_func (GimpDockable *dockable, - GimpDockbook *dockbook, - gint size); -static GtkWidget * dialogs_pattern_tab_func (GimpDockable *dockable, - GimpDockbook *dockbook, - gint size); -static GtkWidget * dialogs_gradient_tab_func (GimpDockable *dockable, - GimpDockbook *dockbook, - gint size); -static GtkWidget * dialogs_palette_tab_func (GimpDockable *dockable, - GimpDockbook *dockbook, - gint size); -static GtkWidget * dialogs_tool_tab_func (GimpDockable *dockable, - GimpDockbook *dockbook, - gint size); +static GtkWidget * dialogs_brush_tab_func (GimpDockable *dockable, + GimpDockbook *dockbook, + gint size); +static GtkWidget * dialogs_pattern_tab_func (GimpDockable *dockable, + GimpDockbook *dockbook, + gint size); +static GtkWidget * dialogs_gradient_tab_func (GimpDockable *dockable, + GimpDockbook *dockbook, + gint size); +static GtkWidget * dialogs_palette_tab_func (GimpDockable *dockable, + GimpDockbook *dockbook, + gint size); +static GtkWidget * dialogs_tool_tab_func (GimpDockable *dockable, + GimpDockbook *dockbook, + gint size); -static void dialogs_set_view_context_func (GimpDockable *dockable, - GimpContext *context); -static void dialogs_set_editor_context_func (GimpDockable *dockable, - GimpContext *context); -static void dialogs_set_drawable_context_func (GimpDockable *dockable, - GimpContext *context); -static void dialogs_set_path_context_func (GimpDockable *dockable, - GimpContext *context); +static void dialogs_set_view_context_func (GimpDockable *dockable, + GimpContext *context); +static void dialogs_set_editor_context_func (GimpDockable *dockable, + GimpContext *context); +static void dialogs_set_image_item_context_func (GimpDockable *dockable, + GimpContext *context); +static void dialogs_set_path_context_func (GimpDockable *dockable, + GimpContext *context); static void dialogs_set_indexed_palette_context_func (GimpDockable *dockable, GimpContext *context); @@ -129,12 +132,12 @@ static GtkWidget * dialogs_dockable_new (GtkWidget *widget, GimpDockableGetTabFunc get_tab_func, GimpDockableSetContextFunc set_context_func); -static void dialogs_drawable_view_image_changed (GimpContext *context, - GimpImage *gimage, - GimpDrawableListView *view); -static void dialogs_path_view_image_changed (GimpContext *context, - GimpImage *gimage, - GtkWidget *view); +static void dialogs_image_item_view_image_changed (GimpContext *context, + GimpImage *gimage, + GimpItemListView *view); +static void dialogs_path_view_image_changed (GimpContext *context, + GimpImage *gimage, + GtkWidget *view); static void dialogs_indexed_palette_image_changed (GimpContext *context, GimpImage *gimage, GimpColormapDialog *ipal); @@ -717,27 +720,27 @@ dialogs_layer_list_view_new (GimpDialogFactory *factory, gimage = gimp_context_get_image (context); - view = gimp_drawable_list_view_new - (preview_size, - gimage, - GIMP_TYPE_LAYER, - "active_layer_changed", - (GimpGetContainerFunc) gimp_image_get_layers, - (GimpGetDrawableFunc) gimp_image_get_active_layer, - (GimpSetDrawableFunc) gimp_image_set_active_layer, - (GimpReorderDrawableFunc) gimp_image_position_layer, - (GimpAddDrawableFunc) gimp_image_add_layer, - (GimpRemoveDrawableFunc) gimp_image_remove_layer, - (GimpCopyDrawableFunc) gimp_layer_copy, - (GimpConvertDrawableFunc) gimp_layer_new_from_drawable, - (GimpNewDrawableFunc) layers_new_layer_query, - (GimpEditDrawableFunc) layers_edit_layer_query, - gimp_item_factory_from_path ("")); + view = + gimp_item_list_view_new (preview_size, + gimage, + GIMP_TYPE_LAYER, + "active_layer_changed", + (GimpGetContainerFunc) gimp_image_get_layers, + (GimpGetItemFunc) gimp_image_get_active_layer, + (GimpSetItemFunc) gimp_image_set_active_layer, + (GimpReorderItemFunc) gimp_image_position_layer, + (GimpAddItemFunc) gimp_image_add_layer, + (GimpRemoveItemFunc) gimp_image_remove_layer, + (GimpCopyItemFunc) gimp_layer_copy, + (GimpConvertItemFunc) gimp_layer_new_from_drawable, + (GimpNewItemFunc) layers_new_layer_query, + (GimpEditItemFunc) layers_edit_layer_query, + gimp_item_factory_from_path ("")); dockable = dialogs_dockable_new (view, "Layer List", "Layers", NULL, - dialogs_set_drawable_context_func); + dialogs_set_image_item_context_func); gimp_dockable_set_context (GIMP_DOCKABLE (dockable), context); @@ -755,27 +758,76 @@ dialogs_channel_list_view_new (GimpDialogFactory *factory, gimage = gimp_context_get_image (context); - view = gimp_drawable_list_view_new - (preview_size, - gimage, - GIMP_TYPE_CHANNEL, - "active_channel_changed", - (GimpGetContainerFunc) gimp_image_get_channels, - (GimpGetDrawableFunc) gimp_image_get_active_channel, - (GimpSetDrawableFunc) gimp_image_set_active_channel, - (GimpReorderDrawableFunc) gimp_image_position_channel, - (GimpAddDrawableFunc) gimp_image_add_channel, - (GimpRemoveDrawableFunc) gimp_image_remove_channel, - (GimpCopyDrawableFunc) gimp_channel_copy, - (GimpConvertDrawableFunc) NULL, - (GimpNewDrawableFunc) channels_new_channel_query, - (GimpEditDrawableFunc) channels_edit_channel_query, - gimp_item_factory_from_path ("")); + view = + gimp_item_list_view_new (preview_size, + gimage, + GIMP_TYPE_CHANNEL, + "active_channel_changed", + (GimpGetContainerFunc) gimp_image_get_channels, + (GimpGetItemFunc) gimp_image_get_active_channel, + (GimpSetItemFunc) gimp_image_set_active_channel, + (GimpReorderItemFunc) gimp_image_position_channel, + (GimpAddItemFunc) gimp_image_add_channel, + (GimpRemoveItemFunc) gimp_image_remove_channel, + (GimpCopyItemFunc) gimp_channel_copy, + (GimpConvertItemFunc) NULL, + (GimpNewItemFunc) channels_new_channel_query, + (GimpEditItemFunc) channels_edit_channel_query, + gimp_item_factory_from_path ("")); dockable = dialogs_dockable_new (view, "Channel List", "Channels", NULL, - dialogs_set_drawable_context_func); + dialogs_set_image_item_context_func); + + gimp_dockable_set_context (GIMP_DOCKABLE (dockable), context); + + return dockable; +} + +static GimpVectors * +gimp_vectors_copy (const GimpVectors *vectors, + GType new_type, + gboolean add_alpha /* unused */) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_VECTORS), NULL); + + return NULL; +} + +GtkWidget * +dialogs_vectors_list_view_new (GimpDialogFactory *factory, + GimpContext *context, + gint preview_size) +{ + GimpImage *gimage; + GtkWidget *view; + GtkWidget *dockable; + + gimage = gimp_context_get_image (context); + + view = + gimp_item_list_view_new (preview_size, + gimage, + GIMP_TYPE_VECTORS, + "active_vectors_changed", + (GimpGetContainerFunc) gimp_image_get_vectors, + (GimpGetItemFunc) gimp_image_get_active_vectors, + (GimpSetItemFunc) gimp_image_set_active_vectors, + (GimpReorderItemFunc) gimp_image_position_vectors, + (GimpAddItemFunc) gimp_image_add_vectors, + (GimpRemoveItemFunc) gimp_image_remove_vectors, + (GimpCopyItemFunc) gimp_vectors_copy, + (GimpConvertItemFunc) NULL, + (GimpNewItemFunc) vectors_new_vectors_query, + (GimpEditItemFunc) vectors_edit_vectors_query, + gimp_item_factory_from_path ("")); + + dockable = dialogs_dockable_new (view, + "Paths List", "Paths", + NULL, + dialogs_set_image_item_context_func); gimp_dockable_set_context (GIMP_DOCKABLE (dockable), context); @@ -799,7 +851,7 @@ dialogs_path_list_view_new (GimpDialogFactory *factory, g_object_add_weak_pointer (G_OBJECT (view), (gpointer *) &view); dockable = dialogs_dockable_new (view, - "Path List", "Paths", + "Old Path List", "Old Paths", NULL, dialogs_set_path_context_func); @@ -1058,36 +1110,36 @@ dialogs_set_editor_context_func (GimpDockable *dockable, } static void -dialogs_set_drawable_context_func (GimpDockable *dockable, - GimpContext *context) +dialogs_set_image_item_context_func (GimpDockable *dockable, + GimpContext *context) { - GimpDrawableListView *view; + GimpItemListView *view; - view = (GimpDrawableListView *) g_object_get_data (G_OBJECT (dockable), - "gimp-dialogs-view"); + view = (GimpItemListView *) g_object_get_data (G_OBJECT (dockable), + "gimp-dialogs-view"); if (view) { if (dockable->context) { g_signal_handlers_disconnect_by_func (G_OBJECT (dockable->context), - dialogs_drawable_view_image_changed, + dialogs_image_item_view_image_changed, view); } if (context) { g_signal_connect (G_OBJECT (context), "image_changed", - G_CALLBACK (dialogs_drawable_view_image_changed), + G_CALLBACK (dialogs_image_item_view_image_changed), view); - dialogs_drawable_view_image_changed (context, - gimp_context_get_image (context), - view); + dialogs_image_item_view_image_changed (context, + gimp_context_get_image (context), + view); } else { - dialogs_drawable_view_image_changed (NULL, NULL, view); + dialogs_image_item_view_image_changed (NULL, NULL, view); } } } @@ -1184,11 +1236,11 @@ dialogs_dockable_new (GtkWidget *widget, } static void -dialogs_drawable_view_image_changed (GimpContext *context, - GimpImage *gimage, - GimpDrawableListView *view) +dialogs_image_item_view_image_changed (GimpContext *context, + GimpImage *gimage, + GimpItemListView *view) { - gimp_drawable_list_view_set_image (view, gimage); + gimp_item_list_view_set_image (view, gimage); } static void diff --git a/app/dialogs/dialogs-constructors.h b/app/dialogs/dialogs-constructors.h index b8bc55a3cc..f0c25735c0 100644 --- a/app/dialogs/dialogs-constructors.h +++ b/app/dialogs/dialogs-constructors.h @@ -132,6 +132,9 @@ GtkWidget * dialogs_layer_list_view_new (GimpDialogFactory *factory, GtkWidget * dialogs_channel_list_view_new (GimpDialogFactory *factory, GimpContext *context, gint preview_size); +GtkWidget * dialogs_vectors_list_view_new (GimpDialogFactory *factory, + GimpContext *context, + gint preview_size); GtkWidget * dialogs_path_list_view_new (GimpDialogFactory *factory, GimpContext *context, gint preview_size); diff --git a/app/dialogs/dialogs.c b/app/dialogs/dialogs.c index c8f8fafbdb..27ddb5eb39 100644 --- a/app/dialogs/dialogs.c +++ b/app/dialogs/dialogs.c @@ -77,7 +77,8 @@ static const GimpDialogFactoryEntry dock_entries[] = { "gimp:buffer-grid", dialogs_buffer_grid_view_new, 32, FALSE, FALSE, FALSE, TRUE }, { "gimp:layer-list", dialogs_layer_list_view_new, 32, FALSE, FALSE, FALSE, TRUE }, - { "gimp:channel-list", dialogs_channel_list_view_new, 32,FALSE, FALSE, FALSE, TRUE }, + { "gimp:channel-list", dialogs_channel_list_view_new, 32, FALSE, FALSE, FALSE, TRUE }, + { "gimp:vectors-list", dialogs_vectors_list_view_new, 32, FALSE, FALSE, FALSE, TRUE }, { "gimp:path-list", dialogs_path_list_view_new, 32, TRUE, FALSE, FALSE, TRUE }, { "gimp:indexed-palette", dialogs_indexed_palette_new, 32, FALSE, FALSE, FALSE, TRUE }, diff --git a/app/dialogs/file-save-dialog.c b/app/dialogs/file-save-dialog.c index edf3d269d3..b4c9d61f57 100644 --- a/app/dialogs/file-save-dialog.c +++ b/app/dialogs/file-save-dialog.c @@ -346,7 +346,7 @@ file_save_ok_callback (GtkWidget *widget, args[1].arg_type = GIMP_PDB_IMAGE; args[1].value.pdb_int = gimp_image_get_ID (the_gimage); args[2].arg_type = GIMP_PDB_DRAWABLE; - args[2].value.pdb_int = gimp_drawable_get_ID (the_drawable); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (the_drawable)); plug_in_run (proc_rec, args, 3, FALSE, TRUE, 0); diff --git a/app/dialogs/offset-dialog.c b/app/dialogs/offset-dialog.c index 41dc91d8fc..1c609c9127 100644 --- a/app/dialogs/offset-dialog.c +++ b/app/dialogs/offset-dialog.c @@ -85,7 +85,7 @@ offset_dialog_create (GimpDrawable *drawable) off_d->wrap_around = TRUE; off_d->fill_type = gimp_drawable_has_alpha (drawable); - off_d->gimage = gimp_drawable_gimage (drawable); + off_d->gimage = gimp_item_get_image (GIMP_ITEM (drawable)); if (GIMP_IS_LAYER (drawable)) title = _("Offset Layer"); diff --git a/app/display/gimpdisplayshell-dnd.c b/app/display/gimpdisplayshell-dnd.c index 410687b330..1d218969c7 100644 --- a/app/display/gimpdisplayshell-dnd.c +++ b/app/display/gimpdisplayshell-dnd.c @@ -63,7 +63,7 @@ gimp_display_shell_drop_drawable (GtkWidget *widget, undo_push_group_start (gdisp->gimage, EDIT_PASTE_UNDO_GROUP); - new_layer = gimp_layer_new_from_drawable (gdisp->gimage, drawable); + new_layer = gimp_layer_new_from_drawable (drawable, gdisp->gimage); off_x = (gdisp->gimage->width - gimp_drawable_width (drawable)) / 2; off_y = (gdisp->gimage->height - gimp_drawable_height (drawable)) / 2; diff --git a/app/file/file-save.c b/app/file/file-save.c index f7584cb21f..619ff12147 100644 --- a/app/file/file-save.c +++ b/app/file/file-save.c @@ -142,7 +142,7 @@ file_save (GimpImage *gimage, args[0].value.pdb_int = run_mode; args[1].value.pdb_int = gimp_image_get_ID (gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gimage))); args[3].value.pdb_pointer = (gpointer) filename; args[4].value.pdb_pointer = (gpointer) raw_filename; diff --git a/app/gui/Makefile.am b/app/gui/Makefile.am index fa0e88b198..9e93a53781 100644 --- a/app/gui/Makefile.am +++ b/app/gui/Makefile.am @@ -125,6 +125,8 @@ libappgui_a_SOURCES = @STRIP_BEGIN@ \ tools-commands.h \ user-install-dialog.c \ user-install-dialog.h \ + vectors-commands.c \ + vectors-commands.h \ view-commands.c \ view-commands.h \ @STRIP_END@ diff --git a/app/gui/channels-commands.c b/app/gui/channels-commands.c index 215319ca81..b221b38178 100644 --- a/app/gui/channels-commands.c +++ b/app/gui/channels-commands.c @@ -531,7 +531,7 @@ channels_edit_channel_query (GimpChannel *channel) options = g_new0 (EditChannelOptions, 1); options->channel = channel; - options->gimage = gimp_drawable_gimage (GIMP_DRAWABLE (channel)); + options->gimage = gimp_item_get_image (GIMP_ITEM (channel)); channel_color = channel->color; diff --git a/app/gui/dialogs-constructors.c b/app/gui/dialogs-constructors.c index 373bbc8721..e91c7ae20a 100644 --- a/app/gui/dialogs-constructors.c +++ b/app/gui/dialogs-constructors.c @@ -35,6 +35,8 @@ #include "core/gimppalette.h" #include "core/gimptoolinfo.h" +#include "vectors/gimpvectors.h" + #include "widgets/gimpbrushfactoryview.h" #include "widgets/gimpbufferview.h" #include "widgets/gimpcontainerlistview.h" @@ -43,10 +45,10 @@ #include "widgets/gimpdialogfactory.h" #include "widgets/gimpimagedock.h" #include "widgets/gimpitemfactory.h" +#include "widgets/gimpitemlistview.h" #include "widgets/gimpdockable.h" #include "widgets/gimpdockbook.h" #include "widgets/gimpdocumentview.h" -#include "widgets/gimpdrawablelistview.h" #include "widgets/gimplistitem.h" #include "widgets/gimppreview.h" @@ -80,6 +82,7 @@ #include "tips-dialog.h" #include "tool-options-dialog.h" #include "toolbox.h" +#include "vectors-commands.h" #include "gimprc.h" #include "undo_history.h" @@ -93,33 +96,33 @@ /* local function prototypes */ -static void dialogs_indexed_palette_selected (GimpColormapDialog *dialog, - GimpDockable *dockable); +static void dialogs_indexed_palette_selected (GimpColormapDialog *dialog, + GimpDockable *dockable); -static GtkWidget * dialogs_brush_tab_func (GimpDockable *dockable, - GimpDockbook *dockbook, - gint size); -static GtkWidget * dialogs_pattern_tab_func (GimpDockable *dockable, - GimpDockbook *dockbook, - gint size); -static GtkWidget * dialogs_gradient_tab_func (GimpDockable *dockable, - GimpDockbook *dockbook, - gint size); -static GtkWidget * dialogs_palette_tab_func (GimpDockable *dockable, - GimpDockbook *dockbook, - gint size); -static GtkWidget * dialogs_tool_tab_func (GimpDockable *dockable, - GimpDockbook *dockbook, - gint size); +static GtkWidget * dialogs_brush_tab_func (GimpDockable *dockable, + GimpDockbook *dockbook, + gint size); +static GtkWidget * dialogs_pattern_tab_func (GimpDockable *dockable, + GimpDockbook *dockbook, + gint size); +static GtkWidget * dialogs_gradient_tab_func (GimpDockable *dockable, + GimpDockbook *dockbook, + gint size); +static GtkWidget * dialogs_palette_tab_func (GimpDockable *dockable, + GimpDockbook *dockbook, + gint size); +static GtkWidget * dialogs_tool_tab_func (GimpDockable *dockable, + GimpDockbook *dockbook, + gint size); -static void dialogs_set_view_context_func (GimpDockable *dockable, - GimpContext *context); -static void dialogs_set_editor_context_func (GimpDockable *dockable, - GimpContext *context); -static void dialogs_set_drawable_context_func (GimpDockable *dockable, - GimpContext *context); -static void dialogs_set_path_context_func (GimpDockable *dockable, - GimpContext *context); +static void dialogs_set_view_context_func (GimpDockable *dockable, + GimpContext *context); +static void dialogs_set_editor_context_func (GimpDockable *dockable, + GimpContext *context); +static void dialogs_set_image_item_context_func (GimpDockable *dockable, + GimpContext *context); +static void dialogs_set_path_context_func (GimpDockable *dockable, + GimpContext *context); static void dialogs_set_indexed_palette_context_func (GimpDockable *dockable, GimpContext *context); @@ -129,12 +132,12 @@ static GtkWidget * dialogs_dockable_new (GtkWidget *widget, GimpDockableGetTabFunc get_tab_func, GimpDockableSetContextFunc set_context_func); -static void dialogs_drawable_view_image_changed (GimpContext *context, - GimpImage *gimage, - GimpDrawableListView *view); -static void dialogs_path_view_image_changed (GimpContext *context, - GimpImage *gimage, - GtkWidget *view); +static void dialogs_image_item_view_image_changed (GimpContext *context, + GimpImage *gimage, + GimpItemListView *view); +static void dialogs_path_view_image_changed (GimpContext *context, + GimpImage *gimage, + GtkWidget *view); static void dialogs_indexed_palette_image_changed (GimpContext *context, GimpImage *gimage, GimpColormapDialog *ipal); @@ -717,27 +720,27 @@ dialogs_layer_list_view_new (GimpDialogFactory *factory, gimage = gimp_context_get_image (context); - view = gimp_drawable_list_view_new - (preview_size, - gimage, - GIMP_TYPE_LAYER, - "active_layer_changed", - (GimpGetContainerFunc) gimp_image_get_layers, - (GimpGetDrawableFunc) gimp_image_get_active_layer, - (GimpSetDrawableFunc) gimp_image_set_active_layer, - (GimpReorderDrawableFunc) gimp_image_position_layer, - (GimpAddDrawableFunc) gimp_image_add_layer, - (GimpRemoveDrawableFunc) gimp_image_remove_layer, - (GimpCopyDrawableFunc) gimp_layer_copy, - (GimpConvertDrawableFunc) gimp_layer_new_from_drawable, - (GimpNewDrawableFunc) layers_new_layer_query, - (GimpEditDrawableFunc) layers_edit_layer_query, - gimp_item_factory_from_path ("")); + view = + gimp_item_list_view_new (preview_size, + gimage, + GIMP_TYPE_LAYER, + "active_layer_changed", + (GimpGetContainerFunc) gimp_image_get_layers, + (GimpGetItemFunc) gimp_image_get_active_layer, + (GimpSetItemFunc) gimp_image_set_active_layer, + (GimpReorderItemFunc) gimp_image_position_layer, + (GimpAddItemFunc) gimp_image_add_layer, + (GimpRemoveItemFunc) gimp_image_remove_layer, + (GimpCopyItemFunc) gimp_layer_copy, + (GimpConvertItemFunc) gimp_layer_new_from_drawable, + (GimpNewItemFunc) layers_new_layer_query, + (GimpEditItemFunc) layers_edit_layer_query, + gimp_item_factory_from_path ("")); dockable = dialogs_dockable_new (view, "Layer List", "Layers", NULL, - dialogs_set_drawable_context_func); + dialogs_set_image_item_context_func); gimp_dockable_set_context (GIMP_DOCKABLE (dockable), context); @@ -755,27 +758,76 @@ dialogs_channel_list_view_new (GimpDialogFactory *factory, gimage = gimp_context_get_image (context); - view = gimp_drawable_list_view_new - (preview_size, - gimage, - GIMP_TYPE_CHANNEL, - "active_channel_changed", - (GimpGetContainerFunc) gimp_image_get_channels, - (GimpGetDrawableFunc) gimp_image_get_active_channel, - (GimpSetDrawableFunc) gimp_image_set_active_channel, - (GimpReorderDrawableFunc) gimp_image_position_channel, - (GimpAddDrawableFunc) gimp_image_add_channel, - (GimpRemoveDrawableFunc) gimp_image_remove_channel, - (GimpCopyDrawableFunc) gimp_channel_copy, - (GimpConvertDrawableFunc) NULL, - (GimpNewDrawableFunc) channels_new_channel_query, - (GimpEditDrawableFunc) channels_edit_channel_query, - gimp_item_factory_from_path ("")); + view = + gimp_item_list_view_new (preview_size, + gimage, + GIMP_TYPE_CHANNEL, + "active_channel_changed", + (GimpGetContainerFunc) gimp_image_get_channels, + (GimpGetItemFunc) gimp_image_get_active_channel, + (GimpSetItemFunc) gimp_image_set_active_channel, + (GimpReorderItemFunc) gimp_image_position_channel, + (GimpAddItemFunc) gimp_image_add_channel, + (GimpRemoveItemFunc) gimp_image_remove_channel, + (GimpCopyItemFunc) gimp_channel_copy, + (GimpConvertItemFunc) NULL, + (GimpNewItemFunc) channels_new_channel_query, + (GimpEditItemFunc) channels_edit_channel_query, + gimp_item_factory_from_path ("")); dockable = dialogs_dockable_new (view, "Channel List", "Channels", NULL, - dialogs_set_drawable_context_func); + dialogs_set_image_item_context_func); + + gimp_dockable_set_context (GIMP_DOCKABLE (dockable), context); + + return dockable; +} + +static GimpVectors * +gimp_vectors_copy (const GimpVectors *vectors, + GType new_type, + gboolean add_alpha /* unused */) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_VECTORS), NULL); + + return NULL; +} + +GtkWidget * +dialogs_vectors_list_view_new (GimpDialogFactory *factory, + GimpContext *context, + gint preview_size) +{ + GimpImage *gimage; + GtkWidget *view; + GtkWidget *dockable; + + gimage = gimp_context_get_image (context); + + view = + gimp_item_list_view_new (preview_size, + gimage, + GIMP_TYPE_VECTORS, + "active_vectors_changed", + (GimpGetContainerFunc) gimp_image_get_vectors, + (GimpGetItemFunc) gimp_image_get_active_vectors, + (GimpSetItemFunc) gimp_image_set_active_vectors, + (GimpReorderItemFunc) gimp_image_position_vectors, + (GimpAddItemFunc) gimp_image_add_vectors, + (GimpRemoveItemFunc) gimp_image_remove_vectors, + (GimpCopyItemFunc) gimp_vectors_copy, + (GimpConvertItemFunc) NULL, + (GimpNewItemFunc) vectors_new_vectors_query, + (GimpEditItemFunc) vectors_edit_vectors_query, + gimp_item_factory_from_path ("")); + + dockable = dialogs_dockable_new (view, + "Paths List", "Paths", + NULL, + dialogs_set_image_item_context_func); gimp_dockable_set_context (GIMP_DOCKABLE (dockable), context); @@ -799,7 +851,7 @@ dialogs_path_list_view_new (GimpDialogFactory *factory, g_object_add_weak_pointer (G_OBJECT (view), (gpointer *) &view); dockable = dialogs_dockable_new (view, - "Path List", "Paths", + "Old Path List", "Old Paths", NULL, dialogs_set_path_context_func); @@ -1058,36 +1110,36 @@ dialogs_set_editor_context_func (GimpDockable *dockable, } static void -dialogs_set_drawable_context_func (GimpDockable *dockable, - GimpContext *context) +dialogs_set_image_item_context_func (GimpDockable *dockable, + GimpContext *context) { - GimpDrawableListView *view; + GimpItemListView *view; - view = (GimpDrawableListView *) g_object_get_data (G_OBJECT (dockable), - "gimp-dialogs-view"); + view = (GimpItemListView *) g_object_get_data (G_OBJECT (dockable), + "gimp-dialogs-view"); if (view) { if (dockable->context) { g_signal_handlers_disconnect_by_func (G_OBJECT (dockable->context), - dialogs_drawable_view_image_changed, + dialogs_image_item_view_image_changed, view); } if (context) { g_signal_connect (G_OBJECT (context), "image_changed", - G_CALLBACK (dialogs_drawable_view_image_changed), + G_CALLBACK (dialogs_image_item_view_image_changed), view); - dialogs_drawable_view_image_changed (context, - gimp_context_get_image (context), - view); + dialogs_image_item_view_image_changed (context, + gimp_context_get_image (context), + view); } else { - dialogs_drawable_view_image_changed (NULL, NULL, view); + dialogs_image_item_view_image_changed (NULL, NULL, view); } } } @@ -1184,11 +1236,11 @@ dialogs_dockable_new (GtkWidget *widget, } static void -dialogs_drawable_view_image_changed (GimpContext *context, - GimpImage *gimage, - GimpDrawableListView *view) +dialogs_image_item_view_image_changed (GimpContext *context, + GimpImage *gimage, + GimpItemListView *view) { - gimp_drawable_list_view_set_image (view, gimage); + gimp_item_list_view_set_image (view, gimage); } static void diff --git a/app/gui/dialogs-constructors.h b/app/gui/dialogs-constructors.h index b8bc55a3cc..f0c25735c0 100644 --- a/app/gui/dialogs-constructors.h +++ b/app/gui/dialogs-constructors.h @@ -132,6 +132,9 @@ GtkWidget * dialogs_layer_list_view_new (GimpDialogFactory *factory, GtkWidget * dialogs_channel_list_view_new (GimpDialogFactory *factory, GimpContext *context, gint preview_size); +GtkWidget * dialogs_vectors_list_view_new (GimpDialogFactory *factory, + GimpContext *context, + gint preview_size); GtkWidget * dialogs_path_list_view_new (GimpDialogFactory *factory, GimpContext *context, gint preview_size); diff --git a/app/gui/dialogs.c b/app/gui/dialogs.c index c8f8fafbdb..27ddb5eb39 100644 --- a/app/gui/dialogs.c +++ b/app/gui/dialogs.c @@ -77,7 +77,8 @@ static const GimpDialogFactoryEntry dock_entries[] = { "gimp:buffer-grid", dialogs_buffer_grid_view_new, 32, FALSE, FALSE, FALSE, TRUE }, { "gimp:layer-list", dialogs_layer_list_view_new, 32, FALSE, FALSE, FALSE, TRUE }, - { "gimp:channel-list", dialogs_channel_list_view_new, 32,FALSE, FALSE, FALSE, TRUE }, + { "gimp:channel-list", dialogs_channel_list_view_new, 32, FALSE, FALSE, FALSE, TRUE }, + { "gimp:vectors-list", dialogs_vectors_list_view_new, 32, FALSE, FALSE, FALSE, TRUE }, { "gimp:path-list", dialogs_path_list_view_new, 32, TRUE, FALSE, FALSE, TRUE }, { "gimp:indexed-palette", dialogs_indexed_palette_new, 32, FALSE, FALSE, FALSE, TRUE }, diff --git a/app/gui/file-save-dialog.c b/app/gui/file-save-dialog.c index edf3d269d3..b4c9d61f57 100644 --- a/app/gui/file-save-dialog.c +++ b/app/gui/file-save-dialog.c @@ -346,7 +346,7 @@ file_save_ok_callback (GtkWidget *widget, args[1].arg_type = GIMP_PDB_IMAGE; args[1].value.pdb_int = gimp_image_get_ID (the_gimage); args[2].arg_type = GIMP_PDB_DRAWABLE; - args[2].value.pdb_int = gimp_drawable_get_ID (the_drawable); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (the_drawable)); plug_in_run (proc_rec, args, 3, FALSE, TRUE, 0); diff --git a/app/gui/layers-commands.c b/app/gui/layers-commands.c index d376378f30..fbbedfbec2 100644 --- a/app/gui/layers-commands.c +++ b/app/gui/layers-commands.c @@ -283,7 +283,7 @@ layers_invert_cmd_callback (GtkWidget *widget, procedural_db_run_proc (gimage->gimp, "gimp_invert", &nreturn_vals, - GIMP_PDB_DRAWABLE, gimp_drawable_get_ID (drawable), + GIMP_PDB_DRAWABLE, gimp_item_get_ID (GIMP_ITEM (drawable)), GIMP_PDB_END); if (!return_vals || return_vals[0].value.pdb_int != GIMP_PDB_SUCCESS) @@ -775,10 +775,10 @@ layers_edit_layer_query (GimpLayer *layer) GtkWidget *hbox; GtkWidget *label; - /* The new options structure */ - options = g_new (EditLayerOptions, 1); + options = g_new0 (EditLayerOptions, 1); + options->layer = layer; - options->gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)); + options->gimage = gimp_item_get_image (GIMP_ITEM (layer)); /* The dialog */ options->query_box = @@ -861,8 +861,7 @@ add_mask_query_ok_callback (GtkWidget *widget, options = (AddMaskOptions *) data; - if ((layer = (options->layer)) && - (gimage = GIMP_DRAWABLE (layer)->gimage)) + if ((layer = (options->layer)) && (gimage = GIMP_ITEM (layer)->gimage)) { mask = gimp_layer_create_mask (layer, options->add_mask_type); gimp_layer_add_mask (layer, mask, TRUE); @@ -884,7 +883,7 @@ layers_add_mask_query (GimpLayer *layer) options->layer = layer; options->add_mask_type = ADD_WHITE_MASK; - gimage = GIMP_DRAWABLE (layer)->gimage; + gimage = gimp_item_get_image (GIMP_ITEM (layer)); /* The dialog */ options->query_box = @@ -990,7 +989,6 @@ scale_layer_query_ok_callback (GtkWidget *widget, gpointer data) { ScaleLayerOptions *options; - GimpImage *gimage; GimpLayer *layer; options = (ScaleLayerOptions *) data; @@ -998,9 +996,13 @@ scale_layer_query_ok_callback (GtkWidget *widget, if (options->resize->width > 0 && options->resize->height > 0 && (layer = (options->layer))) { + GimpImage *gimage; + gtk_widget_set_sensitive (options->resize->resize_shell, FALSE); - if ((gimage = GIMP_DRAWABLE (layer)->gimage) != NULL) + gimage = gimp_item_get_image (GIMP_ITEM (layer)); + + if (gimage) { undo_push_group_start (gimage, LAYER_SCALE_UNDO_GROUP); @@ -1079,7 +1081,6 @@ resize_layer_query_ok_callback (GtkWidget *widget, gpointer data) { ResizeLayerOptions *options; - GimpImage *gimage; GimpLayer *layer; options = (ResizeLayerOptions *) data; @@ -1087,9 +1088,13 @@ resize_layer_query_ok_callback (GtkWidget *widget, if (options->resize->width > 0 && options->resize->height > 0 && (layer = (options->layer))) { + GimpImage *gimage; + gtk_widget_set_sensitive (options->resize->resize_shell, FALSE); - if ((gimage = GIMP_DRAWABLE (layer)->gimage) != NULL) + gimage = gimp_item_get_image (GIMP_ITEM (layer)); + + if (gimage) { undo_push_group_start (gimage, LAYER_RESIZE_UNDO_GROUP); diff --git a/app/gui/menus.c b/app/gui/menus.c index 5427d7ed47..01f75b0d9f 100644 --- a/app/gui/menus.c +++ b/app/gui/menus.c @@ -68,6 +68,7 @@ #include "select-commands.h" #include "test-commands.h" #include "tools-commands.h" +#include "vectors-commands.h" #include "view-commands.h" #include "gimphelp.h" @@ -1166,6 +1167,77 @@ static GimpItemFactoryEntry channels_entries[] = }; +/***** *****/ + +static GimpItemFactoryEntry vectors_entries[] = +{ + { { N_("/New Path"), "N", + vectors_new_vectors_cmd_callback, 0, + "", GTK_STOCK_NEW }, + NULL, + "new_path.html", NULL }, + { { N_("/Raise Path"), "F", + vectors_raise_vectors_cmd_callback, 0, + "", GTK_STOCK_GO_UP }, + NULL, + "raise_path.html", NULL }, + { { N_("/Lower Path"), "B", + vectors_lower_vectors_cmd_callback, 0, + "", GTK_STOCK_GO_DOWN }, + NULL, + "lower_path.html", NULL }, + { { N_("/Duplicate Path"), "U", + vectors_duplicate_vectors_cmd_callback, 0, + "", GIMP_STOCK_DUPLICATE }, + NULL, + "duplicate_path.html", NULL }, + { { N_("/Path to Selection"), "S", + vectors_vectors_to_sel_cmd_callback, 0, + "", GIMP_STOCK_TO_SELECTION }, + NULL, + "path_to_selection.html", NULL }, + { { N_("/Add to Selection"), NULL, + vectors_add_vectors_to_sel_cmd_callback, 0, + "", GIMP_STOCK_TO_SELECTION }, + NULL, + "path_to_selection.html#add", NULL }, + { { N_("/Subtract from Selection"), NULL, + vectors_sub_vectors_from_sel_cmd_callback, 0, + "", GIMP_STOCK_TO_SELECTION }, + NULL, + "path_to_selection.html#subtract", NULL }, + { { N_("/Intersect with Selection"), NULL, + vectors_intersect_vectors_with_sel_cmd_callback, 0, + "", GIMP_STOCK_TO_SELECTION }, + NULL, + "path_to_selection.html#intersect", NULL }, + + { { N_("/Selection to Path"), "P", + vectors_sel_to_vectors_cmd_callback, 0, + "", GIMP_STOCK_TO_PATH }, + NULL, + "filters/sel2path.html", NULL }, + { { N_("/Stroke Path"), "T", + vectors_stroke_vectors_cmd_callback, 0, + "", GIMP_STOCK_STROKE }, + NULL, + "stroke_path.html", NULL }, + { { N_("/Delete Path"), "X", + vectors_delete_vectors_cmd_callback, 0, + "", GTK_STOCK_DELETE }, + NULL, + "delete_path.html", NULL }, + + SEPARATOR ("/---"), + + { { N_("/Edit Path Attributes..."), NULL, + vectors_edit_vectors_attributes_cmd_callback, 0, + "", GIMP_STOCK_EDIT }, + NULL, + "dialogs/edit_path_attributes.html", NULL } +}; + + /***** *****/ static GimpItemFactoryEntry paths_entries[] = @@ -1252,7 +1324,8 @@ static GimpItemFactoryEntry dialogs_entries[] = ADD_TAB (N_("/Add Tab/Layers..."), "gimp:layer-list", NULL, NULL), ADD_TAB (N_("/Add Tab/Channels..."), "gimp:channel-list", NULL, NULL), - ADD_TAB (N_("/Add Tab/Paths..."), "gimp:path-list", NULL, NULL), + ADD_TAB (N_("/Add Tab/Paths..."), "gimp:vectors-list", NULL, NULL), + ADD_TAB (N_("/Add Tab/Old Paths..."), "gimp:path-list", NULL, NULL), ADD_TAB (N_("/Add Tab/Document History..."), "gimp:document-history", NULL, NULL), ADD_TAB (N_("/Add Tab/Error Console..."), "gimp:error-console", NULL, NULL), @@ -1792,6 +1865,7 @@ static GimpItemFactory *load_factory = NULL; static GimpItemFactory *save_factory = NULL; static GimpItemFactory *layers_factory = NULL; static GimpItemFactory *channels_factory = NULL; +static GimpItemFactory *vectors_factory = NULL; static GimpItemFactory *paths_factory = NULL; static GimpItemFactory *dialogs_factory = NULL; static GimpItemFactory *brushes_factory = NULL; @@ -1919,6 +1993,14 @@ menus_init (Gimp *gimp) gimp, FALSE); + vectors_factory = gimp_item_factory_new (GTK_TYPE_MENU, + "", "vectors", + NULL, + G_N_ELEMENTS (vectors_entries), + vectors_entries, + gimp, + FALSE); + paths_factory = gimp_item_factory_new (GTK_TYPE_MENU, "", "paths", NULL, diff --git a/app/gui/offset-dialog.c b/app/gui/offset-dialog.c index 41dc91d8fc..1c609c9127 100644 --- a/app/gui/offset-dialog.c +++ b/app/gui/offset-dialog.c @@ -85,7 +85,7 @@ offset_dialog_create (GimpDrawable *drawable) off_d->wrap_around = TRUE; off_d->fill_type = gimp_drawable_has_alpha (drawable); - off_d->gimage = gimp_drawable_gimage (drawable); + off_d->gimage = gimp_item_get_image (GIMP_ITEM (drawable)); if (GIMP_IS_LAYER (drawable)) title = _("Offset Layer"); diff --git a/app/gui/paths-dialog.c b/app/gui/paths-dialog.c index abcbbb3bcb..627bc022e1 100644 --- a/app/gui/paths-dialog.c +++ b/app/gui/paths-dialog.c @@ -1327,10 +1327,10 @@ paths_dialog_advanced_to_path_callback (GtkWidget *widget, args[1].arg_type = GIMP_PDB_IMAGE; args[1].value.pdb_int = (gint32) gimp_image_get_ID (gimage); args[2].arg_type = GIMP_PDB_DRAWABLE; - args[2].value.pdb_int = (gint32) gimp_drawable_get_ID (gimp_image_active_drawable (gimage)); + args[2].value.pdb_int = (gint32) gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gimage))); plug_in_run (proc_rec, args, 3, FALSE, TRUE, - gimp_drawable_get_ID (gimp_image_active_drawable (gimage))); + gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gimage)))); g_free (args); @@ -1364,7 +1364,7 @@ paths_dialog_sel_to_path_callback (GtkWidget *widget, args[1].arg_type = GIMP_PDB_IMAGE; args[1].value.pdb_int = (gint32) gimp_image_get_ID (gimage); args[2].arg_type = GIMP_PDB_DRAWABLE; - args[2].value.pdb_int = (gint32) gimp_drawable_get_ID (gimp_image_active_drawable (gimage)); + args[2].value.pdb_int = (gint32) gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gimage))); /* get the display by asking the current context */ gdisp = gimp_context_get_display (gimp_get_user_context (gimage->gimp)); diff --git a/app/gui/plug-in-commands.c b/app/gui/plug-in-commands.c index d3b99fe777..842e28fba9 100644 --- a/app/gui/plug-in-commands.c +++ b/app/gui/plug-in-commands.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/gui/plug-in-menus.c b/app/gui/plug-in-menus.c index d3b99fe777..842e28fba9 100644 --- a/app/gui/plug-in-menus.c +++ b/app/gui/plug-in-menus.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/gui/toolbox.c b/app/gui/toolbox.c index cda12ef8ad..2c73183a51 100644 --- a/app/gui/toolbox.c +++ b/app/gui/toolbox.c @@ -526,7 +526,7 @@ toolbox_drop_drawable (GtkWidget *widget, drawable = GIMP_DRAWABLE (viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); width = gimp_drawable_width (drawable); height = gimp_drawable_height (drawable); bytes = gimp_drawable_bytes (drawable); @@ -562,7 +562,7 @@ toolbox_drop_drawable (GtkWidget *widget, TRUE)); } - gimp_drawable_set_gimage (GIMP_DRAWABLE (new_layer), new_gimage); + gimp_item_set_image (GIMP_ITEM (new_layer), new_gimage); gimp_object_set_name (GIMP_OBJECT (new_layer), gimp_object_get_name (GIMP_OBJECT (drawable))); diff --git a/app/gui/vectors-commands.c b/app/gui/vectors-commands.c new file mode 100644 index 0000000000..9814bf1bd8 --- /dev/null +++ b/app/gui/vectors-commands.c @@ -0,0 +1,636 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "config.h" + +#include + +#include "libgimpwidgets/gimpwidgets.h" + +#include "gui-types.h" + +#include "core/gimp.h" +#include "core/gimpchannel.h" +#include "core/gimpimage.h" +#include "core/gimpimage-mask.h" +#include "core/gimplist.h" + +#include "vectors/gimpvectors.h" + +#include "display/gimpdisplay-foreach.h" + +#include "widgets/gimpitemfactory.h" +#include "widgets/gimpwidgets-utils.h" + +#include "vectors-commands.h" + +#include "undo.h" + +#include "libgimp/gimpintl.h" + + +/* public functions */ + +void +vectors_new_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + vectors_new_vectors_query (gimage, NULL); +} + +void +vectors_raise_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + if (gimp_image_get_active_vectors (gimage)) + { + gimp_image_raise_vectors (gimage, gimp_image_get_active_vectors (gimage)); + gdisplays_flush (); + } +} + +void +vectors_lower_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + if (gimp_image_get_active_vectors (gimage)) + { + gimp_image_lower_vectors (gimage, gimp_image_get_active_vectors (gimage)); + gdisplays_flush (); + } +} + +void +vectors_duplicate_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + GimpVectors *new_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + new_vectors = NULL; /*gimp_vectors_copy (active_vectors, + G_TYPE_FROM_INSTANCE (active_vectors), + TRUE);*/ + gimp_image_add_vectors (gimage, new_vectors, -1); + gdisplays_flush (); + } +} + +void +vectors_delete_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + gimp_image_remove_vectors (gimage, active_vectors); + gdisplays_flush (); + } +} + +void +vectors_vectors_to_sel_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + GimpChannel *vectors_mask; + + vectors_mask = NULL; /*gimp_vectors_to_channel (active_vectors);*/ + + gimp_image_mask_load (gimage, vectors_mask); + + g_object_unref (G_OBJECT (vectors_mask)); + + gdisplays_flush (); + } +} + +void +vectors_add_vectors_to_sel_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + GimpChannel *vectors_mask; + GimpChannel *new_mask; + + vectors_mask = NULL; /*gimp_vectors_to_channel (active_vectors);*/ + + new_mask = gimp_channel_copy (gimp_image_get_mask (gimage), + G_TYPE_FROM_INSTANCE (gimp_image_get_mask (gimage)), + TRUE); + + gimp_channel_combine_mask (new_mask, + vectors_mask, + CHANNEL_OP_ADD, + 0, 0); /* off x/y */ + + gimp_image_mask_load (gimage, new_mask); + + g_object_unref (G_OBJECT (new_mask)); + + gdisplays_flush (); + } +} + +void +vectors_sub_vectors_from_sel_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + GimpChannel *vectors_mask; + GimpChannel *new_mask; + + vectors_mask = NULL; /*gimp_vectors_to_channel (active_vectors);*/ + + new_mask = gimp_channel_copy (gimp_image_get_mask (gimage), + G_TYPE_FROM_INSTANCE (gimp_image_get_mask (gimage)), + TRUE); + + gimp_channel_combine_mask (new_mask, + vectors_mask, + CHANNEL_OP_SUB, + 0, 0); /* off x/y */ + + gimp_image_mask_load (gimage, new_mask); + + g_object_unref (G_OBJECT (new_mask)); + + gdisplays_flush (); + } +} + +void +vectors_intersect_vectors_with_sel_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + GimpChannel *vectors_mask; + GimpChannel *new_mask; + + vectors_mask = NULL; /*gimp_vectors_to_channel (active_vectors);*/ + + new_mask = gimp_channel_copy (gimp_image_get_mask (gimage), + G_TYPE_FROM_INSTANCE (gimp_image_get_mask (gimage)), + TRUE); + + gimp_channel_combine_mask (new_mask, + vectors_mask, + CHANNEL_OP_INTERSECT, + 0, 0); /* off x/y */ + + gimp_image_mask_load (gimage, new_mask); + + g_object_unref (G_OBJECT (new_mask)); + + gdisplays_flush (); + } +} + +void +vectors_sel_to_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + } +} + +void +vectors_stroke_vectors_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + } +} + +void +vectors_edit_vectors_attributes_cmd_callback (GtkWidget *widget, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *active_vectors; + + gimage = (GimpImage *) gimp_widget_get_callback_context (widget); + + if (! gimage) + return; + + active_vectors = gimp_image_get_active_vectors (gimage); + + if (active_vectors) + { + vectors_edit_vectors_query (active_vectors); + } +} + + +/**********************************/ +/* The new vectors query dialog */ +/**********************************/ + +typedef struct _NewVectorsOptions NewVectorsOptions; + +struct _NewVectorsOptions +{ + GtkWidget *query_box; + GtkWidget *name_entry; + + GimpImage *gimage; +}; + +static gchar *vectors_name = NULL; + + +static void +new_vectors_query_ok_callback (GtkWidget *widget, + gpointer data) +{ + NewVectorsOptions *options; + GimpVectors *new_vectors; + GimpImage *gimage; + + options = (NewVectorsOptions *) data; + + if (vectors_name) + g_free (vectors_name); + vectors_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (options->name_entry))); + + if ((gimage = options->gimage)) + { + new_vectors = g_object_new (GIMP_TYPE_VECTORS, NULL); + + gimp_image_add_vectors (gimage, new_vectors, -1); + + gimp_object_set_name (GIMP_OBJECT (new_vectors), vectors_name); + + gdisplays_flush (); + } + + gtk_widget_destroy (options->query_box); +} + +void +vectors_new_vectors_query (GimpImage *gimage, + GimpVectors *template) +{ + NewVectorsOptions *options; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *table; + GtkWidget *label; + + g_return_if_fail (GIMP_IS_IMAGE (gimage)); + g_return_if_fail (! template || GIMP_IS_VECTORS (template)); + + if (template) + { + GimpVectors *new_vectors; + + /* undo_push_group_start (gimage, EDIT_PASTE_UNDO_GROUP); */ + + new_vectors = NULL; /*gimp_vectors_new (gimage, _("Empty Vectors Copy"));*/ + + gimp_image_add_vectors (gimage, new_vectors, -1); + + /* undo_push_group_end (gimage); */ + + gdisplays_flush (); + return; + } + + /* the new options structure */ + options = g_new (NewVectorsOptions, 1); + options->gimage = gimage; + + /* The dialog */ + options->query_box = + gimp_dialog_new (_("New Vectors Options"), "new_vectors_options", + gimp_standard_help_func, + "dialogs/vectors/new_vectors.html", + GTK_WIN_POS_MOUSE, + FALSE, TRUE, FALSE, + + GTK_STOCK_CANCEL, gtk_widget_destroy, + NULL, 1, NULL, FALSE, TRUE, + + GTK_STOCK_OK, new_vectors_query_ok_callback, + options, NULL, NULL, TRUE, FALSE, + + NULL); + + g_object_weak_ref (G_OBJECT (options->query_box), + (GWeakNotify) g_free, + options); + + /* The main hbox */ + hbox = gtk_hbox_new (FALSE, 2); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 4); + gtk_container_add (GTK_CONTAINER (GTK_DIALOG (options->query_box)->vbox), + hbox); + + /* The vbox */ + vbox = gtk_vbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); + + /* The table */ + table = gtk_table_new (2, 3, FALSE); + gtk_table_set_col_spacings (GTK_TABLE (table), 4); + gtk_table_set_row_spacings (GTK_TABLE (table), 2); + gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); + + /* The name entry hbox, label and entry */ + label = gtk_label_new (_("Vectors name:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, + GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); + gtk_widget_show (label); + + options->name_entry = gtk_entry_new (); + gtk_widget_set_size_request (options->name_entry, 150, -1); + gtk_table_attach_defaults (GTK_TABLE (table), options->name_entry, + 1, 2, 0, 1); + gtk_entry_set_text (GTK_ENTRY (options->name_entry), + (vectors_name ? vectors_name : _("New Vectors"))); + gtk_widget_show (options->name_entry); + + gtk_widget_show (table); + gtk_widget_show (vbox); + gtk_widget_show (hbox); + gtk_widget_show (options->query_box); +} + +/****************************************/ +/* The edit vectors attributes dialog */ +/****************************************/ + +typedef struct _EditVectorsOptions EditVectorsOptions; + +struct _EditVectorsOptions +{ + GtkWidget *query_box; + GtkWidget *name_entry; + + GimpVectors *vectors; + GimpImage *gimage; +}; + +static void +edit_vectors_query_ok_callback (GtkWidget *widget, + gpointer data) +{ + EditVectorsOptions *options; + GimpVectors *vectors; + + options = (EditVectorsOptions *) data; + vectors = options->vectors; + + if (options->gimage) + { + /* Set the new vectors name */ + gimp_object_set_name (GIMP_OBJECT (vectors), + gtk_entry_get_text (GTK_ENTRY (options->name_entry))); + } + + gtk_widget_destroy (options->query_box); +} + +void +vectors_edit_vectors_query (GimpVectors *vectors) +{ + EditVectorsOptions *options; + GtkWidget *hbox; + GtkWidget *vbox; + GtkWidget *table; + GtkWidget *label; + + options = g_new0 (EditVectorsOptions, 1); + + options->vectors = vectors; + options->gimage = gimp_item_get_image (GIMP_ITEM (vectors)); + + /* The dialog */ + options->query_box = + gimp_dialog_new (_("Edit Vectors Attributes"), "edit_vectors_attributes", + gimp_standard_help_func, + "dialogs/vectors/edit_vectors_attributes.html", + GTK_WIN_POS_MOUSE, + FALSE, TRUE, FALSE, + + GTK_STOCK_CANCEL, gtk_widget_destroy, + NULL, 1, NULL, FALSE, TRUE, + + GTK_STOCK_OK, edit_vectors_query_ok_callback, + options, NULL, NULL, TRUE, FALSE, + + NULL); + + g_object_weak_ref (G_OBJECT (options->query_box), + (GWeakNotify) g_free, + options); + + g_signal_connect_object (G_OBJECT (vectors), "removed", + G_CALLBACK (gtk_widget_destroy), + G_OBJECT (options->query_box), + G_CONNECT_SWAPPED); + + /* The main hbox */ + hbox = gtk_hbox_new (FALSE, 2); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 4); + gtk_container_add (GTK_CONTAINER (GTK_DIALOG (options->query_box)->vbox), + hbox); + + /* The vbox */ + vbox = gtk_vbox_new (FALSE, 2); + gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); + + /* The table */ + table = gtk_table_new (2, 3, FALSE); + gtk_table_set_col_spacings (GTK_TABLE (table), 4); + gtk_table_set_row_spacings (GTK_TABLE (table), 2); + gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); + + /* The name entry */ + label = gtk_label_new (_("Vectors name:")); + gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, + GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); + gtk_widget_show (label); + + options->name_entry = gtk_entry_new (); + gtk_widget_set_size_request (options->name_entry, 150, -1); + gtk_table_attach_defaults (GTK_TABLE (table), options->name_entry, + 1, 2, 0, 1); + gtk_entry_set_text (GTK_ENTRY (options->name_entry), + gimp_object_get_name (GIMP_OBJECT (vectors))); + gtk_widget_show (options->name_entry); + + gtk_widget_show (table); + gtk_widget_show (vbox); + gtk_widget_show (hbox); + gtk_widget_show (options->query_box); +} + +void +vectors_menu_update (GtkItemFactory *factory, + gpointer data) +{ + GimpImage *gimage; + GimpVectors *vectors; + gboolean fs; + GList *list; + GList *next = NULL; + GList *prev = NULL; + + gimage = GIMP_IMAGE (data); + + vectors = gimp_image_get_active_vectors (gimage); + + fs = (gimp_image_floating_sel (gimage) != NULL); + + for (list = GIMP_LIST (gimage->vectors)->list; + list; + list = g_list_next (list)) + { + if (vectors == (GimpVectors *) list->data) + { + prev = g_list_previous (list); + next = g_list_next (list); + break; + } + } + +#define SET_SENSITIVE(menu,condition) \ + gimp_item_factory_set_sensitive (factory, menu, (condition) != 0) + + SET_SENSITIVE ("/New Vectors...", !fs); + SET_SENSITIVE ("/Raise Vectors", !fs && vectors && prev); + SET_SENSITIVE ("/Lower Vectors", !fs && vectors && next); + SET_SENSITIVE ("/Duplicate Vectors", !fs && vectors); + SET_SENSITIVE ("/Vectors to Selection", !fs && vectors); + SET_SENSITIVE ("/Add to Selection", !fs && vectors); + SET_SENSITIVE ("/Subtract from Selection", !fs && vectors); + SET_SENSITIVE ("/Intersect with Selection", !fs && vectors); + SET_SENSITIVE ("/Delete Vectors", !fs && vectors); + SET_SENSITIVE ("/Edit Vectors Attributes...", !fs && vectors); + +#undef SET_OPS_SENSITIVE +} diff --git a/app/gui/vectors-commands.h b/app/gui/vectors-commands.h new file mode 100644 index 0000000000..f6b0f8d582 --- /dev/null +++ b/app/gui/vectors-commands.h @@ -0,0 +1,56 @@ +/* The GIMP -- an image manipulation program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * 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 2 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, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __VECTORS_COMMANDS_H__ +#define __VECTORS_COMMANDS_H__ + + +void vectors_new_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_raise_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_lower_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_duplicate_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_delete_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_vectors_to_sel_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_add_vectors_to_sel_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_sub_vectors_from_sel_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_intersect_vectors_with_sel_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_sel_to_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_stroke_vectors_cmd_callback (GtkWidget *widget, + gpointer data); +void vectors_edit_vectors_attributes_cmd_callback (GtkWidget *widget, + gpointer data); + +void vectors_new_vectors_query (GimpImage *gimage, + GimpVectors *template); +void vectors_edit_vectors_query (GimpVectors *vectors); + +void vectors_menu_update (GtkItemFactory *factory, + gpointer data); + + +#endif /* __VECTORS_COMMANDS_H__ */ diff --git a/app/image_map.c b/app/image_map.c index cb939e35a1..888defc636 100644 --- a/app/image_map.c +++ b/app/image_map.c @@ -126,7 +126,7 @@ image_map_apply (ImageMap *image_map, } /* Make sure the drawable is still valid */ - if (! gimp_drawable_gimage (image_map->drawable)) + if (! gimp_item_get_image (GIMP_ITEM (image_map->drawable))) return; /* The application should occur only within selection bounds */ @@ -227,7 +227,7 @@ image_map_commit (ImageMap *image_map) } /* Make sure the drawable is still valid */ - if (! gimp_drawable_gimage (image_map->drawable)) + if (! gimp_item_get_image (GIMP_ITEM (image_map->drawable))) return; /* Interactive phase ends: we can commit an undo frame now */ @@ -268,7 +268,7 @@ image_map_clear (ImageMap *image_map) image_map->state = IMAGE_MAP_WAITING; /* Make sure the drawable is still valid */ - if (! gimp_drawable_gimage (image_map->drawable)) + if (! gimp_item_get_image (GIMP_ITEM (image_map->drawable))) return; /* restore the original image */ @@ -344,7 +344,7 @@ image_map_get_color_at (ImageMap *image_map, return (gimp_drawable_get_color_at (image_map->drawable, x, y)); if (! image_map || - (! gimp_drawable_gimage (image_map->drawable) && + (! gimp_item_get_image (GIMP_ITEM (image_map->drawable)) && gimp_drawable_is_indexed (image_map->drawable)) || x < 0 || y < 0 || x >= tile_manager_width (image_map->undo_tiles) || @@ -357,7 +357,7 @@ image_map_get_color_at (ImageMap *image_map, read_pixel_data_1 (image_map->undo_tiles, x, y, src); - gimp_image_get_color (gimp_drawable_gimage (image_map->drawable), + gimp_image_get_color (gimp_item_get_image (GIMP_ITEM (image_map->drawable)), gimp_drawable_type (image_map->drawable), dest, src); @@ -392,7 +392,7 @@ image_map_do (gpointer data) image_map = (ImageMap *) data; - if (! (gimage = gimp_drawable_gimage (image_map->drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (image_map->drawable)))) { image_map->state = IMAGE_MAP_WAITING; diff --git a/app/menus/menus.c b/app/menus/menus.c index 5427d7ed47..01f75b0d9f 100644 --- a/app/menus/menus.c +++ b/app/menus/menus.c @@ -68,6 +68,7 @@ #include "select-commands.h" #include "test-commands.h" #include "tools-commands.h" +#include "vectors-commands.h" #include "view-commands.h" #include "gimphelp.h" @@ -1166,6 +1167,77 @@ static GimpItemFactoryEntry channels_entries[] = }; +/***** *****/ + +static GimpItemFactoryEntry vectors_entries[] = +{ + { { N_("/New Path"), "N", + vectors_new_vectors_cmd_callback, 0, + "", GTK_STOCK_NEW }, + NULL, + "new_path.html", NULL }, + { { N_("/Raise Path"), "F", + vectors_raise_vectors_cmd_callback, 0, + "", GTK_STOCK_GO_UP }, + NULL, + "raise_path.html", NULL }, + { { N_("/Lower Path"), "B", + vectors_lower_vectors_cmd_callback, 0, + "", GTK_STOCK_GO_DOWN }, + NULL, + "lower_path.html", NULL }, + { { N_("/Duplicate Path"), "U", + vectors_duplicate_vectors_cmd_callback, 0, + "", GIMP_STOCK_DUPLICATE }, + NULL, + "duplicate_path.html", NULL }, + { { N_("/Path to Selection"), "S", + vectors_vectors_to_sel_cmd_callback, 0, + "", GIMP_STOCK_TO_SELECTION }, + NULL, + "path_to_selection.html", NULL }, + { { N_("/Add to Selection"), NULL, + vectors_add_vectors_to_sel_cmd_callback, 0, + "", GIMP_STOCK_TO_SELECTION }, + NULL, + "path_to_selection.html#add", NULL }, + { { N_("/Subtract from Selection"), NULL, + vectors_sub_vectors_from_sel_cmd_callback, 0, + "", GIMP_STOCK_TO_SELECTION }, + NULL, + "path_to_selection.html#subtract", NULL }, + { { N_("/Intersect with Selection"), NULL, + vectors_intersect_vectors_with_sel_cmd_callback, 0, + "", GIMP_STOCK_TO_SELECTION }, + NULL, + "path_to_selection.html#intersect", NULL }, + + { { N_("/Selection to Path"), "P", + vectors_sel_to_vectors_cmd_callback, 0, + "", GIMP_STOCK_TO_PATH }, + NULL, + "filters/sel2path.html", NULL }, + { { N_("/Stroke Path"), "T", + vectors_stroke_vectors_cmd_callback, 0, + "", GIMP_STOCK_STROKE }, + NULL, + "stroke_path.html", NULL }, + { { N_("/Delete Path"), "X", + vectors_delete_vectors_cmd_callback, 0, + "", GTK_STOCK_DELETE }, + NULL, + "delete_path.html", NULL }, + + SEPARATOR ("/---"), + + { { N_("/Edit Path Attributes..."), NULL, + vectors_edit_vectors_attributes_cmd_callback, 0, + "", GIMP_STOCK_EDIT }, + NULL, + "dialogs/edit_path_attributes.html", NULL } +}; + + /***** *****/ static GimpItemFactoryEntry paths_entries[] = @@ -1252,7 +1324,8 @@ static GimpItemFactoryEntry dialogs_entries[] = ADD_TAB (N_("/Add Tab/Layers..."), "gimp:layer-list", NULL, NULL), ADD_TAB (N_("/Add Tab/Channels..."), "gimp:channel-list", NULL, NULL), - ADD_TAB (N_("/Add Tab/Paths..."), "gimp:path-list", NULL, NULL), + ADD_TAB (N_("/Add Tab/Paths..."), "gimp:vectors-list", NULL, NULL), + ADD_TAB (N_("/Add Tab/Old Paths..."), "gimp:path-list", NULL, NULL), ADD_TAB (N_("/Add Tab/Document History..."), "gimp:document-history", NULL, NULL), ADD_TAB (N_("/Add Tab/Error Console..."), "gimp:error-console", NULL, NULL), @@ -1792,6 +1865,7 @@ static GimpItemFactory *load_factory = NULL; static GimpItemFactory *save_factory = NULL; static GimpItemFactory *layers_factory = NULL; static GimpItemFactory *channels_factory = NULL; +static GimpItemFactory *vectors_factory = NULL; static GimpItemFactory *paths_factory = NULL; static GimpItemFactory *dialogs_factory = NULL; static GimpItemFactory *brushes_factory = NULL; @@ -1919,6 +1993,14 @@ menus_init (Gimp *gimp) gimp, FALSE); + vectors_factory = gimp_item_factory_new (GTK_TYPE_MENU, + "", "vectors", + NULL, + G_N_ELEMENTS (vectors_entries), + vectors_entries, + gimp, + FALSE); + paths_factory = gimp_item_factory_new (GTK_TYPE_MENU, "", "paths", NULL, diff --git a/app/menus/plug-in-menus.c b/app/menus/plug-in-menus.c index d3b99fe777..842e28fba9 100644 --- a/app/menus/plug-in-menus.c +++ b/app/menus/plug-in-menus.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/paint/gimpairbrush.c b/app/paint/gimpairbrush.c index d828b1103d..697b2f98f0 100644 --- a/app/paint/gimpairbrush.c +++ b/app/paint/gimpairbrush.c @@ -254,7 +254,7 @@ gimp_airbrush_motion (GimpPaintCore *paint_core, PaintApplicationMode paint_appl_mode; gdouble pressure; - if (! (gimage = gimp_drawable_gimage (drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable)))) return; context = gimp_get_current_context (gimage->gimp); diff --git a/app/paint/gimpclone.c b/app/paint/gimpclone.c index 8477c5d113..31fff8cf09 100644 --- a/app/paint/gimpclone.c +++ b/app/paint/gimpclone.c @@ -169,7 +169,7 @@ gimp_clone_paint (GimpPaintCore *paint_core, options = (GimpCloneOptions *) paint_options; - context = gimp_get_current_context (drawable->gimage->gimp); + context = gimp_get_current_context (GIMP_ITEM (drawable)->gimage->gimp); switch (paint_state) { @@ -295,14 +295,16 @@ gimp_clone_motion (GimpPaintCore *paint_core, { if (!src_drawable) return; - if (! (src_gimage = gimp_drawable_gimage (src_drawable))) + + if (! (src_gimage = gimp_item_get_image (GIMP_ITEM (src_drawable)))) return; + /* Determine whether the source image has an alpha channel */ has_alpha = gimp_drawable_has_alpha (src_drawable); } /* We always need a destination image */ - if (! (gimage = gimp_drawable_gimage (drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable)))) return; context = gimp_get_current_context (gimage->gimp); diff --git a/app/paint/gimpconvolve.c b/app/paint/gimpconvolve.c index ccaa38a0f9..3bc2473d01 100644 --- a/app/paint/gimpconvolve.c +++ b/app/paint/gimpconvolve.c @@ -201,7 +201,7 @@ gimp_convolve_motion (GimpPaintCore *paint_core, gint marginy = 0; GimpContext *context; - if (! gimp_drawable_gimage (drawable)) + if (! gimp_item_get_image (GIMP_ITEM (drawable))) return; /* If the image type is indexed, don't convolve */ @@ -403,7 +403,8 @@ gimp_convolve_motion (GimpPaintCore *paint_core, g_free(fillcolor); } - context = gimp_get_current_context (gimp_drawable_gimage (drawable)->gimp); + context = + gimp_get_current_context (gimp_item_get_image (GIMP_ITEM (drawable))->gimp); /* paste the newly painted canvas to the gimage which is being worked on */ gimp_paint_core_replace_canvas (paint_core, drawable, diff --git a/app/paint/gimpdodgeburn.c b/app/paint/gimpdodgeburn.c index d93497e246..46cfa01174 100644 --- a/app/paint/gimpdodgeburn.c +++ b/app/paint/gimpdodgeburn.c @@ -220,7 +220,7 @@ gimp_dodgeburn_motion (GimpPaintCore *paint_core, gint opacity; gdouble scale; - if (! (gimage = gimp_drawable_gimage (drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable)))) return; /* If the image type is indexed, don't dodgeburn */ diff --git a/app/paint/gimperaser.c b/app/paint/gimperaser.c index 75a735130e..562d91a418 100644 --- a/app/paint/gimperaser.c +++ b/app/paint/gimperaser.c @@ -141,7 +141,7 @@ gimp_eraser_motion (GimpPaintCore *paint_core, guchar col[MAX_CHANNELS]; gdouble scale; - if (! (gimage = gimp_drawable_gimage (drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable)))) return; options = (GimpEraserOptions *) paint_options; diff --git a/app/paint/gimpink.c b/app/paint/gimpink.c index e67417fa12..d51023549c 100644 --- a/app/paint/gimpink.c +++ b/app/paint/gimpink.c @@ -1246,7 +1246,7 @@ ink_paste (GimpInkTool *ink_tool, gint offx, offy; gchar col[MAX_CHANNELS]; - if (! (gimage = gimp_drawable_gimage (drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable)))) return; context = gimp_get_current_context (gimage->gimp); diff --git a/app/paint/gimppaintbrush.c b/app/paint/gimppaintbrush.c index f8a648b271..84c805990e 100644 --- a/app/paint/gimppaintbrush.c +++ b/app/paint/gimppaintbrush.c @@ -126,10 +126,7 @@ gimp_paintbrush_paint (GimpPaintCore *paint_core, gdouble gradient_length; gdouble unit_factor; - gimage = gimp_drawable_gimage (drawable); - - if (! gimage) - return; + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); pressure_options = paint_options->pressure_options; gradient_options = paint_options->gradient_options; @@ -215,8 +212,7 @@ gimp_paintbrush_motion (GimpPaintCore *paint_core, gdouble scale; PaintApplicationMode paint_appl_mode = incremental ? INCREMENTAL : CONSTANT; - if (! (gimage = gimp_drawable_gimage (drawable))) - return; + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); context = gimp_get_current_context (gimage->gimp); diff --git a/app/paint/gimppaintcore.c b/app/paint/gimppaintcore.c index 55594d4d5d..0f848dcf9b 100644 --- a/app/paint/gimppaintcore.c +++ b/app/paint/gimppaintcore.c @@ -341,12 +341,17 @@ gimp_paint_core_start (GimpPaintCore *core, GimpCoords *coords) { GimpContext *context; + GimpImage *gimage; g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), FALSE); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (coords != NULL, FALSE); - context = gimp_get_current_context (gimp_drawable_gimage (drawable)->gimp); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); + + g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); + + context = gimp_get_current_context (gimage->gimp); core->cur_coords = *coords; @@ -414,8 +419,9 @@ gimp_paint_core_finish (GimpPaintCore *core, g_return_if_fail (GIMP_IS_PAINT_CORE (core)); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); - if (! (gimage = gimp_drawable_gimage (drawable))) - return; + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); + + g_return_if_fail (GIMP_IS_IMAGE (gimage)); /* Determine if any part of the image has been altered-- * if nothing has, then just return... @@ -1242,8 +1248,7 @@ gimp_paint_core_paste (GimpPaintCore *core, gint offx; gint offy; - if (! (gimage = gimp_drawable_gimage (drawable))) - return; + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); /* set undo blocks */ set_undo_tiles (core, @@ -1340,8 +1345,7 @@ gimp_paint_core_replace (GimpPaintCore *core, return; } - if (! (gimage = gimp_drawable_gimage (drawable))) - return; + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); /* set undo blocks */ set_undo_tiles (core, diff --git a/app/paint/gimppencil.c b/app/paint/gimppencil.c index 547d534220..662b8efd10 100644 --- a/app/paint/gimppencil.c +++ b/app/paint/gimppencil.c @@ -141,8 +141,7 @@ gimp_pencil_motion (GimpPaintCore *paint_core, gdouble scale; PaintApplicationMode paint_appl_mode; - if (! (gimage = gimp_drawable_gimage (drawable))) - return; + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); context = gimp_get_current_context (gimage->gimp); diff --git a/app/paint/gimpsmudge.c b/app/paint/gimpsmudge.c index adb7765de1..05a08d046c 100644 --- a/app/paint/gimpsmudge.c +++ b/app/paint/gimpsmudge.c @@ -171,8 +171,7 @@ gimp_smudge_start (GimpPaintCore *paint_core, gint was_clipped; guchar *do_fill = NULL; - if (! (gimage = gimp_drawable_gimage (drawable))) - return FALSE; + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); /* If the image type is indexed, don't smudge */ if (gimp_drawable_is_indexed (drawable)) @@ -255,8 +254,7 @@ gimp_smudge_motion (GimpPaintCore *paint_core, gint opacity; gint x, y, w, h; - if (! (gimage = gimp_drawable_gimage (drawable))) - return; + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); context = gimp_get_current_context (gimage->gimp); diff --git a/app/paint/gimpsourcecore.c b/app/paint/gimpsourcecore.c index 8477c5d113..31fff8cf09 100644 --- a/app/paint/gimpsourcecore.c +++ b/app/paint/gimpsourcecore.c @@ -169,7 +169,7 @@ gimp_clone_paint (GimpPaintCore *paint_core, options = (GimpCloneOptions *) paint_options; - context = gimp_get_current_context (drawable->gimage->gimp); + context = gimp_get_current_context (GIMP_ITEM (drawable)->gimage->gimp); switch (paint_state) { @@ -295,14 +295,16 @@ gimp_clone_motion (GimpPaintCore *paint_core, { if (!src_drawable) return; - if (! (src_gimage = gimp_drawable_gimage (src_drawable))) + + if (! (src_gimage = gimp_item_get_image (GIMP_ITEM (src_drawable)))) return; + /* Determine whether the source image has an alpha channel */ has_alpha = gimp_drawable_has_alpha (src_drawable); } /* We always need a destination image */ - if (! (gimage = gimp_drawable_gimage (drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable)))) return; context = gimp_get_current_context (gimage->gimp); diff --git a/app/pdb/channel_cmds.c b/app/pdb/channel_cmds.c index a5fffc6529..209ad4f3ea 100644 --- a/app/pdb/channel_cmds.c +++ b/app/pdb/channel_cmds.c @@ -121,7 +121,7 @@ channel_new_invoker (Gimp *gimp, return_args = procedural_db_return_args (&channel_new_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (channel)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (channel)); return return_args; } @@ -194,7 +194,7 @@ channel_copy_invoker (Gimp *gimp, GimpChannel *channel; GimpChannel *copy = NULL; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -204,7 +204,7 @@ channel_copy_invoker (Gimp *gimp, return_args = procedural_db_return_args (&channel_copy_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (copy)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (copy)); return return_args; } @@ -250,13 +250,13 @@ channel_delete_invoker (Gimp *gimp, gboolean success = TRUE; GimpChannel *channel; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; if (success) { - if (! gimp_drawable_gimage (GIMP_DRAWABLE (channel))) + if (! gimp_item_get_image (GIMP_ITEM (channel))) { g_object_unref (G_OBJECT (channel)); success = TRUE; @@ -303,11 +303,11 @@ channel_combine_masks_invoker (Gimp *gimp, gint32 offx; gint32 offy; - channel1 = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel1 = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel1 == NULL) success = FALSE; - channel2 = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + channel2 = (GimpChannel *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (channel2 == NULL) success = FALSE; @@ -380,7 +380,7 @@ channel_get_name_invoker (Gimp *gimp, Argument *return_args; GimpChannel *channel; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -434,7 +434,7 @@ channel_set_name_invoker (Gimp *gimp, GimpChannel *channel; gchar *name; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -486,7 +486,7 @@ channel_get_visible_invoker (Gimp *gimp, Argument *return_args; GimpChannel *channel; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -540,7 +540,7 @@ channel_set_visible_invoker (Gimp *gimp, GimpChannel *channel; gboolean visible; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -590,7 +590,7 @@ channel_get_show_masked_invoker (Gimp *gimp, Argument *return_args; GimpChannel *channel; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -644,7 +644,7 @@ channel_set_show_masked_invoker (Gimp *gimp, GimpChannel *channel; gboolean show_masked; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -694,7 +694,7 @@ channel_get_opacity_invoker (Gimp *gimp, Argument *return_args; GimpChannel *channel; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -748,7 +748,7 @@ channel_set_opacity_invoker (Gimp *gimp, GimpChannel *channel; gdouble opacity; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -801,7 +801,7 @@ channel_get_color_invoker (Gimp *gimp, GimpChannel *channel; GimpRGB color; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -860,7 +860,7 @@ channel_set_color_invoker (Gimp *gimp, GimpChannel *channel; GimpRGB color; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -915,7 +915,7 @@ channel_get_tattoo_invoker (Gimp *gimp, Argument *return_args; GimpChannel *channel; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -969,7 +969,7 @@ channel_set_tattoo_invoker (Gimp *gimp, GimpChannel *channel; gint32 tattoo; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; diff --git a/app/pdb/color_cmds.c b/app/pdb/color_cmds.c index 53dbd44be4..67c581c708 100644 --- a/app/pdb/color_cmds.c +++ b/app/pdb/color_cmds.c @@ -89,7 +89,7 @@ brightness_contrast_invoker (Gimp *gimp, PixelRegion srcPR, destPR; int x1, y1, x2, y2; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -107,7 +107,7 @@ brightness_contrast_invoker (Gimp *gimp, success = FALSE; else { - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); lut = brightness_contrast_lut_new (brightness / 255.0, contrast / 127.0, @@ -190,7 +190,7 @@ levels_invoker (Gimp *gimp, int low_output[5]; int high_output[5]; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -334,7 +334,7 @@ posterize_invoker (Gimp *gimp, PixelRegion srcPR, destPR; int x1, y1, x2, y2; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -348,7 +348,7 @@ posterize_invoker (Gimp *gimp, success = FALSE; else { - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); lut = posterize_lut_new (levels, gimp_drawable_bytes (drawable)); @@ -409,7 +409,7 @@ desaturate_invoker (Gimp *gimp, gboolean success = TRUE; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -457,7 +457,7 @@ equalize_invoker (Gimp *gimp, GimpDrawable *drawable; gboolean mask_only; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -511,7 +511,7 @@ invert_invoker (Gimp *gimp, gboolean success = TRUE; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -565,7 +565,7 @@ curves_spline_invoker (Gimp *gimp, int i, j; PixelRegion srcPR, destPR; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -687,7 +687,7 @@ curves_explicit_invoker (Gimp *gimp, int i, j; PixelRegion srcPR, destPR; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -799,7 +799,7 @@ color_balance_invoker (Gimp *gimp, PixelRegion srcPR, destPR; int x1, y1, x2, y2; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -934,7 +934,7 @@ histogram_invoker (Gimp *gimp, gboolean no_mask; GimpChannel *mask; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -966,7 +966,7 @@ histogram_invoker (Gimp *gimp, x1, y1, (x2 - x1), (y2 - y1), FALSE); /* Configure the mask from the gimage's selection mask */ - mask = gimp_image_get_mask (gimp_drawable_gimage (drawable)); + mask = gimp_image_get_mask (gimp_item_get_image (GIMP_ITEM (drawable))); pixel_region_init (&maskPR, gimp_drawable_data (GIMP_DRAWABLE (mask)), x1 + off_x, y1 + off_y, (x2 - x1), (y2 - y1), FALSE); @@ -1098,7 +1098,7 @@ hue_saturation_invoker (Gimp *gimp, PixelRegion srcPR, destPR; int x1, y1, x2, y2; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1215,7 +1215,7 @@ threshold_invoker (Gimp *gimp, int x1, y1, x2, y2; PixelRegion srcPR, destPR; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; diff --git a/app/pdb/drawable_cmds.c b/app/pdb/drawable_cmds.c index f05aa07e57..27866633fb 100644 --- a/app/pdb/drawable_cmds.c +++ b/app/pdb/drawable_cmds.c @@ -103,7 +103,7 @@ drawable_merge_shadow_invoker (Gimp *gimp, GimpDrawable *drawable; gboolean undo; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -153,7 +153,7 @@ drawable_fill_invoker (Gimp *gimp, GimpDrawable *drawable; gint32 fill_type; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -208,7 +208,7 @@ drawable_update_invoker (Gimp *gimp, gint32 width; gint32 height; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -284,7 +284,7 @@ drawable_mask_bounds_invoker (Gimp *gimp, gint32 x2; gint32 y2; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -368,12 +368,12 @@ drawable_image_invoker (Gimp *gimp, GimpDrawable *drawable; GimpImage *gimage = NULL; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; if (success) - success = (gimage = gimp_drawable_gimage (drawable)) != NULL; + success = (gimage = gimp_item_get_image (GIMP_ITEM (drawable))) != NULL; return_args = procedural_db_return_args (&drawable_image_proc, success); @@ -425,7 +425,7 @@ drawable_type_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -479,7 +479,7 @@ drawable_has_alpha_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -533,7 +533,7 @@ drawable_type_with_alpha_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -587,7 +587,7 @@ drawable_is_rgb_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -641,7 +641,7 @@ drawable_is_gray_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -695,7 +695,7 @@ drawable_is_indexed_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -749,7 +749,7 @@ drawable_bytes_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -803,7 +803,7 @@ drawable_width_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -857,7 +857,7 @@ drawable_height_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -913,7 +913,7 @@ drawable_offsets_invoker (Gimp *gimp, gint32 offset_x; gint32 offset_y; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -978,7 +978,7 @@ drawable_is_layer_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1032,7 +1032,7 @@ drawable_is_layer_mask_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1086,7 +1086,7 @@ drawable_is_channel_invoker (Gimp *gimp, Argument *return_args; GimpDrawable *drawable; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1147,7 +1147,7 @@ drawable_get_pixel_invoker (Gimp *gimp, gint b; Tile *tile; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1256,7 +1256,7 @@ drawable_set_pixel_invoker (Gimp *gimp, gint b; Tile *tile; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1350,7 +1350,7 @@ drawable_set_image_invoker (Gimp *gimp, GimpDrawable *drawable; GimpImage *gimage; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1359,7 +1359,7 @@ drawable_set_image_invoker (Gimp *gimp, success = FALSE; if (success) - gimp_drawable_set_gimage (drawable, gimage); + gimp_item_set_image (GIMP_ITEM (drawable), gimage); return procedural_db_return_args (&drawable_set_image_proc, success); } @@ -1409,7 +1409,7 @@ drawable_thumbnail_invoker (Gimp *gimp, gint32 num_pixels = 0; guint8 *thumbnail_data = NULL; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1538,7 +1538,7 @@ drawable_offset_invoker (Gimp *gimp, gint32 offset_x; gint32 offset_y; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; diff --git a/app/pdb/edit_cmds.c b/app/pdb/edit_cmds.c index 296df5c8b3..0b5c69efe2 100644 --- a/app/pdb/edit_cmds.c +++ b/app/pdb/edit_cmds.c @@ -62,13 +62,13 @@ edit_cut_invoker (Gimp *gimp, GimpDrawable *drawable; GimpImage *gimage; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable)); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); success = gimp_edit_cut (gimage, drawable) != NULL; } @@ -108,13 +108,13 @@ edit_copy_invoker (Gimp *gimp, GimpDrawable *drawable; GimpImage *gimage; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable)); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); success = gimp_edit_copy (gimage, drawable) != NULL; } @@ -157,7 +157,7 @@ edit_paste_invoker (Gimp *gimp, GimpLayer *layer = NULL; GimpImage *gimage; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -165,7 +165,7 @@ edit_paste_invoker (Gimp *gimp, if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable)); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); layer = gimp_edit_paste (gimage, drawable, gimp->global_buffer, paste_into); success = layer != NULL; } @@ -173,7 +173,7 @@ edit_paste_invoker (Gimp *gimp, return_args = procedural_db_return_args (&edit_paste_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (layer)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (layer)); return return_args; } @@ -225,13 +225,13 @@ edit_clear_invoker (Gimp *gimp, GimpDrawable *drawable; GimpImage *gimage; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable)); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); success = gimp_edit_clear (gimage, drawable); } @@ -272,7 +272,7 @@ edit_fill_invoker (Gimp *gimp, gint32 fill_type; GimpImage *gimage; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -282,7 +282,7 @@ edit_fill_invoker (Gimp *gimp, if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable)); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); success = gimp_edit_fill (gimage, drawable, (GimpFillType) fill_type); } @@ -327,13 +327,13 @@ edit_stroke_invoker (Gimp *gimp, GimpDrawable *drawable; GimpImage *gimage; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable)); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); success = gimp_image_mask_stroke (gimage, drawable, gimp_get_current_context (gimage->gimp)); } diff --git a/app/pdb/floating_sel_cmds.c b/app/pdb/floating_sel_cmds.c index 291f9fa0a0..bd043c51ba 100644 --- a/app/pdb/floating_sel_cmds.c +++ b/app/pdb/floating_sel_cmds.c @@ -57,7 +57,7 @@ floating_sel_remove_invoker (Gimp *gimp, gboolean success = TRUE; GimpLayer *floating_sel; - floating_sel = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + floating_sel = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (floating_sel == NULL) success = FALSE; @@ -104,7 +104,7 @@ floating_sel_anchor_invoker (Gimp *gimp, gboolean success = TRUE; GimpLayer *floating_sel; - floating_sel = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + floating_sel = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (floating_sel == NULL) success = FALSE; @@ -151,7 +151,7 @@ floating_sel_to_layer_invoker (Gimp *gimp, gboolean success = TRUE; GimpLayer *floating_sel; - floating_sel = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + floating_sel = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (floating_sel == NULL) success = FALSE; @@ -199,11 +199,11 @@ floating_sel_attach_invoker (Gimp *gimp, GimpLayer *layer; GimpDrawable *drawable; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; - drawable = gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -251,7 +251,7 @@ floating_sel_rigor_invoker (Gimp *gimp, GimpLayer *floating_sel; gboolean undo; - floating_sel = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + floating_sel = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (floating_sel == NULL) success = FALSE; @@ -306,7 +306,7 @@ floating_sel_relax_invoker (Gimp *gimp, GimpLayer *floating_sel; gboolean undo; - floating_sel = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + floating_sel = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (floating_sel == NULL) success = FALSE; diff --git a/app/pdb/image_cmds.c b/app/pdb/image_cmds.c index 23a5cab5f2..c8603d0475 100644 --- a/app/pdb/image_cmds.c +++ b/app/pdb/image_cmds.c @@ -735,7 +735,7 @@ image_get_layers_invoker (Gimp *gimp, { layer_ids = g_new (gint32, num_layers); for (i = 0; i < num_layers; i++, list = g_list_next (list)) - layer_ids[i] = gimp_drawable_get_ID (GIMP_DRAWABLE (list->data)); + layer_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data)); } } @@ -814,7 +814,7 @@ image_get_channels_invoker (Gimp *gimp, { channel_ids = g_new (gint32, num_channels); for (i = 0; i < num_channels; i++, list = g_list_next (list)) - channel_ids[i] = gimp_drawable_get_ID (GIMP_DRAWABLE (list->data)); + channel_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data)); } } @@ -887,7 +887,7 @@ image_active_drawable_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_active_drawable_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (drawable)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (drawable)); return return_args; } @@ -993,7 +993,7 @@ image_pick_correlate_layer_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_pick_correlate_layer_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (layer)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (layer)); return return_args; } @@ -1054,7 +1054,7 @@ image_raise_layer_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1106,7 +1106,7 @@ image_lower_layer_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1158,7 +1158,7 @@ image_raise_layer_to_top_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1210,7 +1210,7 @@ image_lower_layer_to_bottom_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1277,7 +1277,7 @@ image_merge_visible_layers_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_merge_visible_layers_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (layer)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (layer)); return return_args; } @@ -1336,7 +1336,7 @@ image_merge_down_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - merge_layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + merge_layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (merge_layer == NULL) success = FALSE; @@ -1353,7 +1353,7 @@ image_merge_down_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_merge_down_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (layer)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (layer)); return return_args; } @@ -1421,7 +1421,7 @@ image_flatten_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_flatten_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (layer)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (layer)); return return_args; } @@ -1473,7 +1473,7 @@ image_add_layer_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1542,7 +1542,7 @@ image_remove_layer_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1595,11 +1595,11 @@ image_add_layer_mask_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (layer == NULL) success = FALSE; - mask = (GimpLayerMask *) gimp_drawable_get_by_ID (gimp, args[2].value.pdb_int); + mask = (GimpLayerMask *) gimp_item_get_by_ID (gimp, args[2].value.pdb_int); if (mask == NULL) success = FALSE; @@ -1657,7 +1657,7 @@ image_remove_layer_mask_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1718,7 +1718,7 @@ image_raise_channel_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (channel == NULL) success = FALSE; @@ -1770,7 +1770,7 @@ image_lower_channel_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1823,7 +1823,7 @@ image_add_channel_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (channel == NULL) success = FALSE; @@ -1882,7 +1882,7 @@ image_remove_channel_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (channel == NULL) success = FALSE; @@ -2410,7 +2410,7 @@ image_floating_selection_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_floating_selection_proc, success); if (success) - return_args[1].value.pdb_int = floating_sel ? gimp_drawable_get_ID (GIMP_DRAWABLE (floating_sel)) : -1; + return_args[1].value.pdb_int = floating_sel ? gimp_item_get_ID (GIMP_ITEM (floating_sel)) : -1; return return_args; } @@ -2476,7 +2476,7 @@ image_floating_sel_attached_to_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_floating_sel_attached_to_proc, success); if (success) - return_args[1].value.pdb_int = drawable ? gimp_drawable_get_ID (GIMP_DRAWABLE (drawable)) : -1; + return_args[1].value.pdb_int = drawable ? gimp_item_get_ID (GIMP_ITEM (drawable)) : -1; return return_args; } @@ -2946,7 +2946,7 @@ image_get_active_layer_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_get_active_layer_proc, success); if (success) - return_args[1].value.pdb_int = active_layer ? gimp_drawable_get_ID (GIMP_DRAWABLE (active_layer)) : -1; + return_args[1].value.pdb_int = active_layer ? gimp_item_get_ID (GIMP_ITEM (active_layer)) : -1; return return_args; } @@ -2997,7 +2997,7 @@ image_set_active_layer_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - active_layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + active_layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (active_layer == NULL) success = FALSE; @@ -3056,7 +3056,7 @@ image_get_active_channel_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_get_active_channel_proc, success); if (success) - return_args[1].value.pdb_int = active_channel ? gimp_drawable_get_ID (GIMP_DRAWABLE (active_channel)) : -1; + return_args[1].value.pdb_int = active_channel ? gimp_item_get_ID (GIMP_ITEM (active_channel)) : -1; return return_args; } @@ -3107,7 +3107,7 @@ image_set_active_channel_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - active_channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + active_channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (active_channel == NULL) success = FALSE; @@ -3166,7 +3166,7 @@ image_get_selection_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_get_selection_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (selection)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (selection)); return return_args; } @@ -3867,7 +3867,7 @@ image_get_layer_by_tattoo_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_get_layer_by_tattoo_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (layer)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (layer)); return return_args; } @@ -3938,7 +3938,7 @@ image_get_channel_by_tattoo_invoker (Gimp *gimp, return_args = procedural_db_return_args (&image_get_channel_by_tattoo_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (channel)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (channel)); return return_args; } diff --git a/app/pdb/layer_cmds.c b/app/pdb/layer_cmds.c index 6748606b32..128c922732 100644 --- a/app/pdb/layer_cmds.c +++ b/app/pdb/layer_cmds.c @@ -163,7 +163,7 @@ layer_new_invoker (Gimp *gimp, return_args = procedural_db_return_args (&layer_new_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (layer)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (layer)); return return_args; } @@ -242,7 +242,7 @@ layer_copy_invoker (Gimp *gimp, gboolean add_alpha; GimpLayer *copy = NULL; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -254,7 +254,7 @@ layer_copy_invoker (Gimp *gimp, return_args = procedural_db_return_args (&layer_copy_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (copy)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (copy)); return return_args; } @@ -308,7 +308,7 @@ layer_create_mask_invoker (Gimp *gimp, gint32 mask_type; GimpLayerMask *mask = NULL; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -322,7 +322,7 @@ layer_create_mask_invoker (Gimp *gimp, return_args = procedural_db_return_args (&layer_create_mask_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (mask)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (mask)); return return_args; } @@ -378,7 +378,7 @@ layer_scale_invoker (Gimp *gimp, GimpImage *gimage; GimpLayer *floating_layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -394,7 +394,7 @@ layer_scale_invoker (Gimp *gimp, if (success) { - if ((gimage = GIMP_DRAWABLE(layer)->gimage)) + if ((gimage = gimp_item_get_image (GIMP_ITEM (layer)))) { floating_layer = gimp_image_floating_sel (gimage); @@ -470,7 +470,7 @@ layer_resize_invoker (Gimp *gimp, GimpImage *gimage; GimpLayer *floating_layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -488,7 +488,7 @@ layer_resize_invoker (Gimp *gimp, if (success) { - if ((gimage = GIMP_DRAWABLE(layer)->gimage)) + if ((gimage = gimp_item_get_image (GIMP_ITEM (layer)))) { floating_layer = gimp_image_floating_sel (gimage); @@ -563,13 +563,13 @@ layer_delete_invoker (Gimp *gimp, gboolean success = TRUE; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; if (success) { - if (! gimp_drawable_gimage (GIMP_DRAWABLE (layer))) + if (! gimp_item_get_image (GIMP_ITEM (layer))) { g_object_unref (G_OBJECT (layer)); success = TRUE; @@ -617,7 +617,7 @@ layer_translate_invoker (Gimp *gimp, GimpLayer *tmp_layer; GList *layer_list; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -627,7 +627,7 @@ layer_translate_invoker (Gimp *gimp, if (success) { - if ((gimage = GIMP_DRAWABLE(layer)->gimage)) + if ((gimage = gimp_item_get_image (GIMP_ITEM (layer)))) { floating_layer = gimp_image_floating_sel (gimage); @@ -700,7 +700,7 @@ layer_add_alpha_invoker (Gimp *gimp, gboolean success = TRUE; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -748,7 +748,7 @@ layer_set_offsets_invoker (Gimp *gimp, GimpLayer *tmp_layer; GList *layer_list; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -758,7 +758,7 @@ layer_set_offsets_invoker (Gimp *gimp, if (success) { - if ((gimage = GIMP_DRAWABLE(layer)->gimage)) + if ((gimage = gimp_item_get_image (GIMP_ITEM (layer)))) { floating_layer = gimp_image_floating_sel (gimage); @@ -834,14 +834,14 @@ layer_mask_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; return_args = procedural_db_return_args (&layer_mask_proc, success); if (success) - return_args[1].value.pdb_int = layer->mask ? gimp_drawable_get_ID (GIMP_DRAWABLE (layer->mask)) : -1; + return_args[1].value.pdb_int = layer->mask ? gimp_item_get_ID (GIMP_ITEM (layer->mask)) : -1; return return_args; } @@ -888,7 +888,7 @@ layer_is_floating_sel_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -942,7 +942,7 @@ layer_get_name_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -996,7 +996,7 @@ layer_set_name_invoker (Gimp *gimp, GimpLayer *layer; gchar *name; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1048,7 +1048,7 @@ layer_get_visible_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1102,7 +1102,7 @@ layer_set_visible_invoker (Gimp *gimp, GimpLayer *layer; gboolean visible; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1152,7 +1152,7 @@ layer_get_preserve_trans_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1206,7 +1206,7 @@ layer_set_preserve_trans_invoker (Gimp *gimp, GimpLayer *layer; gboolean preserve_trans; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1256,7 +1256,7 @@ layer_get_apply_mask_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1310,7 +1310,7 @@ layer_set_apply_mask_invoker (Gimp *gimp, GimpLayer *layer; gboolean apply_mask; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1360,7 +1360,7 @@ layer_get_show_mask_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1414,7 +1414,7 @@ layer_set_show_mask_invoker (Gimp *gimp, GimpLayer *layer; gboolean show_mask; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1464,7 +1464,7 @@ layer_get_edit_mask_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1518,7 +1518,7 @@ layer_set_edit_mask_invoker (Gimp *gimp, GimpLayer *layer; gboolean edit_mask; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1568,7 +1568,7 @@ layer_get_opacity_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1622,7 +1622,7 @@ layer_set_opacity_invoker (Gimp *gimp, GimpLayer *layer; gdouble opacity; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1674,7 +1674,7 @@ layer_get_mode_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1728,7 +1728,7 @@ layer_set_mode_invoker (Gimp *gimp, GimpLayer *layer; gint32 mode; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1780,7 +1780,7 @@ layer_get_linked_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1834,7 +1834,7 @@ layer_set_linked_invoker (Gimp *gimp, GimpLayer *layer; gboolean linked; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1884,7 +1884,7 @@ layer_get_tattoo_invoker (Gimp *gimp, Argument *return_args; GimpLayer *layer; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; @@ -1938,7 +1938,7 @@ layer_set_tattoo_invoker (Gimp *gimp, GimpLayer *layer; gint32 tattoo; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; diff --git a/app/pdb/misc_tools_cmds.c b/app/pdb/misc_tools_cmds.c index a50c6f37cb..0a667daf18 100644 --- a/app/pdb/misc_tools_cmds.c +++ b/app/pdb/misc_tools_cmds.c @@ -72,7 +72,7 @@ blend_invoker (Gimp *gimp, gdouble x2; gdouble y2; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -120,7 +120,7 @@ blend_invoker (Gimp *gimp, if (success) { - if (! gimp_drawable_gimage (drawable)) + if (! gimp_item_get_image (GIMP_ITEM (drawable))) { success = FALSE; } @@ -246,7 +246,7 @@ bucket_fill_invoker (Gimp *gimp, gdouble x; gdouble y; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -274,7 +274,7 @@ bucket_fill_invoker (Gimp *gimp, if (success) { - if (! gimp_drawable_gimage (GIMP_DRAWABLE (drawable))) + if (! gimp_item_get_image (GIMP_ITEM (drawable))) { success = FALSE; } @@ -369,7 +369,7 @@ color_picker_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - drawable = gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); x = args[2].value.pdb_float; @@ -386,7 +386,7 @@ color_picker_invoker (Gimp *gimp, if (success) { if (!sample_merged) - if (!drawable || (gimp_drawable_gimage (drawable) != gimage)) + if (!drawable || (gimp_item_get_image (GIMP_ITEM (drawable)) != gimage)) success = FALSE; if (success) diff --git a/app/pdb/paint_tools_cmds.c b/app/pdb/paint_tools_cmds.c index c8f8d80b52..070f3730af 100644 --- a/app/pdb/paint_tools_cmds.c +++ b/app/pdb/paint_tools_cmds.c @@ -110,7 +110,7 @@ airbrush_invoker (Gimp *gimp, gdouble *strokes; GimpAirbrushOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -192,7 +192,7 @@ airbrush_default_invoker (Gimp *gimp, gdouble *strokes; GimpAirbrushOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -267,11 +267,11 @@ clone_invoker (Gimp *gimp, gdouble *strokes; GimpCloneOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; - src_drawable = gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + src_drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); if (src_drawable == NULL) success = FALSE; @@ -380,7 +380,7 @@ clone_default_invoker (Gimp *gimp, gdouble *strokes; GimpCloneOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -453,7 +453,7 @@ convolve_invoker (Gimp *gimp, gdouble *strokes; GimpConvolveOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -545,7 +545,7 @@ convolve_default_invoker (Gimp *gimp, gdouble *strokes; GimpConvolveOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -619,7 +619,7 @@ dodgeburn_invoker (Gimp *gimp, gdouble *strokes; GimpDodgeBurnOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -721,7 +721,7 @@ dodgeburn_default_invoker (Gimp *gimp, gdouble *strokes; GimpDodgeBurnOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -794,7 +794,7 @@ eraser_invoker (Gimp *gimp, gint32 method; GimpEraserOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -887,7 +887,7 @@ eraser_default_invoker (Gimp *gimp, gdouble *strokes; GimpEraserOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -961,7 +961,7 @@ paintbrush_invoker (Gimp *gimp, gdouble gradient_length; GimpPaintOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1064,7 +1064,7 @@ paintbrush_default_invoker (Gimp *gimp, gdouble *strokes; GimpPaintOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1135,7 +1135,7 @@ pencil_invoker (Gimp *gimp, gdouble *strokes; GimpPaintOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1207,7 +1207,7 @@ smudge_invoker (Gimp *gimp, gdouble *strokes; GimpSmudgeOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -1289,7 +1289,7 @@ smudge_default_invoker (Gimp *gimp, gdouble *strokes; GimpSmudgeOptions *options; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; diff --git a/app/pdb/parasite_cmds.c b/app/pdb/parasite_cmds.c index d8f64334c7..771f09f76d 100644 --- a/app/pdb/parasite_cmds.c +++ b/app/pdb/parasite_cmds.c @@ -31,6 +31,7 @@ #include "core/gimpdrawable.h" #include "core/gimpimage.h" #include "core/gimpparasite.h" +#include "pdb_glue.h" #include "libgimpbase/gimpparasite.h" @@ -267,7 +268,7 @@ drawable_parasite_find_invoker (Gimp *gimp, gchar *name; GimpParasite *parasite = NULL; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -336,7 +337,7 @@ drawable_parasite_attach_invoker (Gimp *gimp, GimpDrawable *drawable; GimpParasite *parasite; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -388,7 +389,7 @@ drawable_parasite_detach_invoker (Gimp *gimp, GimpDrawable *drawable; gchar *name; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -442,7 +443,7 @@ drawable_parasite_list_invoker (Gimp *gimp, gint32 num_parasites; gchar **parasites = NULL; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; diff --git a/app/pdb/pdb_glue.h b/app/pdb/pdb_glue.h index e9b0215747..19fa34a5a2 100644 --- a/app/pdb/pdb_glue.h +++ b/app/pdb/pdb_glue.h @@ -28,15 +28,15 @@ #define gimp_layer_get_name(l) gimp_object_get_name(GIMP_OBJECT(l)) #define gimp_layer_get_visible(l) gimp_drawable_get_visible(GIMP_DRAWABLE(l)) #define gimp_layer_set_visible(l,v) gimp_drawable_set_visible(GIMP_DRAWABLE(l),(v)) -#define gimp_layer_set_tattoo(l,t) gimp_drawable_set_tattoo(GIMP_DRAWABLE(l),(t)) -#define gimp_layer_get_tattoo(l) gimp_drawable_get_tattoo(GIMP_DRAWABLE(l)) +#define gimp_layer_set_tattoo(l,t) gimp_item_set_tattoo(GIMP_ITEM(l),(t)) +#define gimp_layer_get_tattoo(l) gimp_item_get_tattoo(GIMP_ITEM(l)) #define gimp_channel_set_name(c,n) gimp_object_set_name(GIMP_OBJECT(c),(n)) #define gimp_channel_get_name(c) gimp_object_get_name(GIMP_OBJECT(c)) #define gimp_channel_get_visible(c) gimp_drawable_get_visible(GIMP_DRAWABLE(c)) #define gimp_channel_set_visible(c,v) gimp_drawable_set_visible(GIMP_DRAWABLE(c),(v)) -#define gimp_channel_set_tattoo(c,t) gimp_drawable_set_tattoo(GIMP_DRAWABLE(c),(t)) -#define gimp_channel_get_tattoo(c) gimp_drawable_get_tattoo(GIMP_DRAWABLE(c)) +#define gimp_channel_set_tattoo(c,t) gimp_item_set_tattoo(GIMP_ITEM(c),(t)) +#define gimp_channel_get_tattoo(c) gimp_item_get_tattoo(GIMP_ITEM(c)) #define gimp_layer_get_apply_mask(l) (l)->mask ? gimp_layer_mask_get_apply((l)->mask) : FALSE; #define gimp_layer_get_show_mask(l) (l)->mask ? gimp_layer_mask_get_show((l)->mask) : FALSE; @@ -46,5 +46,10 @@ #define gimp_layer_set_show_mask(l,s) { if((l)->mask) gimp_layer_mask_set_show((l)->mask,(s)); else success = FALSE; } #define gimp_layer_set_edit_mask(l,e) { if((l)->mask) gimp_layer_mask_set_edit((l)->mask,(e)); else success = FALSE; } +#define gimp_drawable_parasite_attach(d,p) gimp_item_parasite_attach(GIMP_ITEM(d),p) +#define gimp_drawable_parasite_detach(d,p) gimp_item_parasite_detach(GIMP_ITEM(d),p) +#define gimp_drawable_parasite_list(d,c) gimp_item_parasite_list(GIMP_ITEM(d),c) +#define gimp_drawable_parasite_find(d,p) gimp_item_parasite_find(GIMP_ITEM(d),p) + #endif /* __PDB_GLUE_H__ */ diff --git a/app/pdb/selection_cmds.c b/app/pdb/selection_cmds.c index f0a9ab758a..4b5530f334 100644 --- a/app/pdb/selection_cmds.c +++ b/app/pdb/selection_cmds.c @@ -359,7 +359,7 @@ selection_float_invoker (Gimp *gimp, GimpLayer *layer = NULL; GimpImage *gimage; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -369,7 +369,7 @@ selection_float_invoker (Gimp *gimp, if (success) { - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); layer = gimp_image_mask_float (gimage, drawable, offx, offy); success = layer != NULL; } @@ -377,7 +377,7 @@ selection_float_invoker (Gimp *gimp, return_args = procedural_db_return_args (&selection_float_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (layer)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (layer)); return return_args; } @@ -852,13 +852,13 @@ selection_layer_alpha_invoker (Gimp *gimp, GimpLayer *layer; GimpImage *gimage; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + layer = (GimpLayer *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (layer == NULL) success = FALSE; if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)); + gimage = gimp_item_get_image (GIMP_ITEM (layer)); gimp_image_mask_layer_alpha (gimage, layer); } @@ -898,13 +898,13 @@ selection_load_invoker (Gimp *gimp, GimpChannel *channel; GimpImage *gimage; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (channel)); + gimage = gimp_item_get_image (GIMP_ITEM (channel)); if (gimp_drawable_width (GIMP_DRAWABLE (channel)) == gimage->width && gimp_drawable_height (GIMP_DRAWABLE (channel)) == gimage->height) @@ -960,7 +960,7 @@ selection_save_invoker (Gimp *gimp, return_args = procedural_db_return_args (&selection_save_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (channel)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (channel)); return return_args; } @@ -1009,7 +1009,7 @@ selection_combine_invoker (Gimp *gimp, GimpImage *gimage; GimpChannel *new_channel; - channel = (GimpChannel *) gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + channel = (GimpChannel *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (channel == NULL) success = FALSE; @@ -1019,7 +1019,7 @@ selection_combine_invoker (Gimp *gimp, if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (channel)); + gimage = gimp_item_get_image (GIMP_ITEM (channel)); if (gimp_drawable_width (GIMP_DRAWABLE (channel)) == gimage->width && gimp_drawable_height (GIMP_DRAWABLE (channel)) == gimage->height) diff --git a/app/pdb/selection_tools_cmds.c b/app/pdb/selection_tools_cmds.c index 610819cbb3..7c7bd12251 100644 --- a/app/pdb/selection_tools_cmds.c +++ b/app/pdb/selection_tools_cmds.c @@ -66,7 +66,7 @@ by_color_select_invoker (Gimp *gimp, gboolean sample_merged; GimpImage *gimage; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -90,7 +90,7 @@ by_color_select_invoker (Gimp *gimp, if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable)); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); gimp_image_mask_select_by_color (gimage, drawable, sample_merged, @@ -405,7 +405,7 @@ fuzzy_select_invoker (Gimp *gimp, gboolean sample_merged; GimpImage *gimage; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -431,7 +431,7 @@ fuzzy_select_invoker (Gimp *gimp, if (success) { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable)); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); gimp_image_mask_select_fuzzy (gimage, drawable, diff --git a/app/pdb/text_tool_cmds.c b/app/pdb/text_tool_cmds.c index 600deda384..bfedb2cf2b 100644 --- a/app/pdb/text_tool_cmds.c +++ b/app/pdb/text_tool_cmds.c @@ -90,7 +90,7 @@ text_fontname_invoker (Gimp *gimp, if (gimage == NULL) success = FALSE; - drawable = gimp_drawable_get_by_ID (gimp, args[1].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[1].value.pdb_int); x = args[2].value.pdb_float; @@ -133,7 +133,7 @@ text_fontname_invoker (Gimp *gimp, return_args = procedural_db_return_args (&text_fontname_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (text_layer)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (text_layer)); return return_args; } diff --git a/app/pdb/transform_tools_cmds.c b/app/pdb/transform_tools_cmds.c index 84080c1e98..cd4e1284b0 100644 --- a/app/pdb/transform_tools_cmds.c +++ b/app/pdb/transform_tools_cmds.c @@ -64,7 +64,7 @@ flip_invoker (Gimp *gimp, GimpDrawable *drawable; gint32 flip_type; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -84,7 +84,7 @@ flip_invoker (Gimp *gimp, return_args = procedural_db_return_args (&flip_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (drawable)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (drawable)); return return_args; } @@ -141,7 +141,7 @@ perspective_invoker (Gimp *gimp, GimpMatrix3 matrix; GimpInterpolationType interpolation_type; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -195,7 +195,7 @@ perspective_invoker (Gimp *gimp, return_args = procedural_db_return_args (&perspective_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (drawable)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (drawable)); return return_args; } @@ -293,7 +293,7 @@ rotate_invoker (Gimp *gimp, GimpMatrix3 matrix; GimpInterpolationType interpolation_type; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -326,7 +326,7 @@ rotate_invoker (Gimp *gimp, return_args = procedural_db_return_args (&rotate_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (drawable)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (drawable)); return return_args; } @@ -388,7 +388,7 @@ scale_invoker (Gimp *gimp, GimpMatrix3 matrix; GimpInterpolationType interpolation_type; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -438,7 +438,7 @@ scale_invoker (Gimp *gimp, return_args = procedural_db_return_args (&scale_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (drawable)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (drawable)); return return_args; } @@ -516,7 +516,7 @@ shear_invoker (Gimp *gimp, GimpMatrix3 matrix; GimpInterpolationType interpolation_type; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -558,7 +558,7 @@ shear_invoker (Gimp *gimp, return_args = procedural_db_return_args (&shear_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (drawable)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (drawable)); return return_args; } @@ -630,7 +630,7 @@ transform_2d_invoker (Gimp *gimp, GimpMatrix3 matrix; GimpInterpolationType interpolation_type; - drawable = gimp_drawable_get_by_ID (gimp, args[0].value.pdb_int); + drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int); if (drawable == NULL) success = FALSE; @@ -675,7 +675,7 @@ transform_2d_invoker (Gimp *gimp, return_args = procedural_db_return_args (&transform_2d_proc, success); if (success) - return_args[1].value.pdb_int = gimp_drawable_get_ID (GIMP_DRAWABLE (drawable)); + return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (drawable)); return return_args; } diff --git a/app/plug-in/gimpplugin-message.c b/app/plug-in/gimpplugin-message.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/gimpplugin-message.c +++ b/app/plug-in/gimpplugin-message.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/gimpplugin-progress.c b/app/plug-in/gimpplugin-progress.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/gimpplugin-progress.c +++ b/app/plug-in/gimpplugin-progress.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/gimpplugin.c b/app/plug-in/gimpplugin.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/gimpplugin.c +++ b/app/plug-in/gimpplugin.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/gimppluginmanager-call.c b/app/plug-in/gimppluginmanager-call.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/gimppluginmanager-call.c +++ b/app/plug-in/gimppluginmanager-call.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/gimppluginmanager-run.c b/app/plug-in/gimppluginmanager-run.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/gimppluginmanager-run.c +++ b/app/plug-in/gimppluginmanager-run.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/gimppluginmanager.c b/app/plug-in/gimppluginmanager.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/gimppluginmanager.c +++ b/app/plug-in/gimppluginmanager.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/gimppluginshm.c b/app/plug-in/gimppluginshm.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/gimppluginshm.c +++ b/app/plug-in/gimppluginshm.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/plug-in-def.c b/app/plug-in/plug-in-def.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/plug-in-def.c +++ b/app/plug-in/plug-in-def.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/plug-in-message.c b/app/plug-in/plug-in-message.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/plug-in-message.c +++ b/app/plug-in/plug-in-message.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/plug-in-params.c b/app/plug-in/plug-in-params.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/plug-in-params.c +++ b/app/plug-in/plug-in-params.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/plug-in-progress.c b/app/plug-in/plug-in-progress.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/plug-in-progress.c +++ b/app/plug-in/plug-in-progress.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/plug-in-run.c b/app/plug-in/plug-in-run.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/plug-in-run.c +++ b/app/plug-in/plug-in-run.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/plug-in-shm.c b/app/plug-in/plug-in-shm.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/plug-in-shm.c +++ b/app/plug-in/plug-in-shm.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/plug-in.c b/app/plug-in/plug-in.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/plug-in.c +++ b/app/plug-in/plug-in.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/plug-in/plug-ins.c b/app/plug-in/plug-ins.c index d3b99fe777..842e28fba9 100644 --- a/app/plug-in/plug-ins.c +++ b/app/plug-in/plug-ins.c @@ -1386,7 +1386,7 @@ plug_in_repeat (gboolean with_interface) args[0].value.pdb_int = (with_interface ? GIMP_RUN_INTERACTIVE : GIMP_RUN_WITH_LAST_VALS); args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); /* run the plug-in procedure */ plug_in_run (last_plug_in, args, 3, FALSE, TRUE, gdisplay->ID); @@ -1676,9 +1676,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) tile_info = msg.data; if (tile_info->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_info->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_info->drawable_ID)); if (!tm) { @@ -1713,9 +1713,9 @@ plug_in_handle_tile_req (GPTileReq *tile_req) else { if (tile_req->shadow) - tm = gimp_drawable_shadow (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_shadow ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); else - tm = gimp_drawable_data (gimp_drawable_get_by_ID (the_gimp, tile_req->drawable_ID)); + tm = gimp_drawable_data ((GimpDrawable *) gimp_item_get_by_ID (the_gimp, tile_req->drawable_ID)); if (!tm) { @@ -2696,7 +2696,7 @@ plug_in_callback (GtkWidget *widget, /* initialize the first 3 plug-in arguments */ args[0].value.pdb_int = GIMP_RUN_INTERACTIVE; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else @@ -2719,7 +2719,7 @@ plug_in_callback (GtkWidget *widget, gdisp_ID = gdisplay->ID; args[1].value.pdb_int = gimp_image_get_ID (gdisplay->gimage); - args[2].value.pdb_int = gimp_drawable_get_ID (gimp_image_active_drawable (gdisplay->gimage)); + args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (gimp_image_active_drawable (gdisplay->gimage))); argc = 3; } else diff --git a/app/tools/gimpbezierselecttool.c b/app/tools/gimpbezierselecttool.c index a78ba1fff1..6ae9f504fd 100644 --- a/app/tools/gimpbezierselecttool.c +++ b/app/tools/gimpbezierselecttool.c @@ -3446,7 +3446,7 @@ bezier_stroke (GimpBezierSelectTool *bezier_sel, procedural_db_run_proc (gdisp->gimage->gimp, pdb_string, &nreturn_vals, - GIMP_PDB_DRAWABLE, gimp_drawable_get_ID (drawable), + GIMP_PDB_DRAWABLE, (GimpDrawable *) gimp_item_get_ID (GIMP_ITEM (drawable)), GIMP_PDB_INT32, (gint32) rpnts->num_stroke_points * 2, GIMP_PDB_FLOATARRAY, rpnts->stroke_points, GIMP_PDB_END); diff --git a/app/tools/gimpbrushtool.c b/app/tools/gimpbrushtool.c index aa91f3721a..a438434ec3 100644 --- a/app/tools/gimpbrushtool.c +++ b/app/tools/gimpbrushtool.c @@ -680,7 +680,7 @@ gimp_paint_tool_sample_color (GimpDrawable *drawable, GimpImage *gimage; GimpRGB color; - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); picker_info = tool_manager_get_info_by_type (gimage->gimp, GIMP_TYPE_COLOR_PICKER_TOOL); diff --git a/app/tools/gimpbycolorselecttool.c b/app/tools/gimpbycolorselecttool.c index 396651a27b..c66726491f 100644 --- a/app/tools/gimpbycolorselecttool.c +++ b/app/tools/gimpbycolorselecttool.c @@ -758,7 +758,7 @@ by_color_select_invert_callback (GtkWidget *widget, return; /* check if the image associated to the mask still exists */ - if (! gimp_drawable_gimage (GIMP_DRAWABLE (gimp_image_get_mask (bcd->gimage)))) + if (! gimp_item_get_image (GIMP_ITEM (gimp_image_get_mask (bcd->gimage)))) return; /* invert the mask */ @@ -784,7 +784,7 @@ by_color_select_select_all_callback (GtkWidget *widget, return; /* check if the image associated to the mask still exists */ - if (! gimp_drawable_gimage (GIMP_DRAWABLE (gimp_image_get_mask (bcd->gimage)))) + if (! gimp_item_get_image (GIMP_ITEM (gimp_image_get_mask (bcd->gimage)))) return; /* fill the mask */ @@ -810,7 +810,7 @@ by_color_select_select_none_callback (GtkWidget *widget, return; /* check if the image associated to the mask still exists */ - if (! gimp_drawable_gimage (GIMP_DRAWABLE (gimp_image_get_mask (bcd->gimage)))) + if (! gimp_item_get_image (GIMP_ITEM (gimp_image_get_mask (bcd->gimage)))) return; /* reset the mask */ @@ -868,7 +868,7 @@ by_color_select_preview_button_press (ByColorDialog *bcd, drawable = gimp_image_active_drawable (bcd->gimage); /* check if the gimage associated to the drawable still exists */ - if (! gimp_drawable_gimage (drawable)) + if (! gimp_item_get_image (GIMP_ITEM (drawable))) return; /* Defaults */ diff --git a/app/tools/gimpinktool.c b/app/tools/gimpinktool.c index e67417fa12..d51023549c 100644 --- a/app/tools/gimpinktool.c +++ b/app/tools/gimpinktool.c @@ -1246,7 +1246,7 @@ ink_paste (GimpInkTool *ink_tool, gint offx, offy; gchar col[MAX_CHANNELS]; - if (! (gimage = gimp_drawable_gimage (drawable))) + if (! (gimage = gimp_item_get_image (GIMP_ITEM (drawable)))) return; context = gimp_get_current_context (gimage->gimp); diff --git a/app/tools/gimppainttool.c b/app/tools/gimppainttool.c index aa91f3721a..a438434ec3 100644 --- a/app/tools/gimppainttool.c +++ b/app/tools/gimppainttool.c @@ -680,7 +680,7 @@ gimp_paint_tool_sample_color (GimpDrawable *drawable, GimpImage *gimage; GimpRGB color; - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); picker_info = tool_manager_get_info_by_type (gimage->gimp, GIMP_TYPE_COLOR_PICKER_TOOL); diff --git a/app/undo.c b/app/undo.c index 2182b94ed9..2a3032192b 100644 --- a/app/undo.c +++ b/app/undo.c @@ -1723,9 +1723,9 @@ undo_pop_layer_mod (GimpImage *gimage, } if (GIMP_DRAWABLE (layer)->has_alpha != old_has_alpha && - GIMP_DRAWABLE (layer)->gimage->layers->num_children == 1) + GIMP_ITEM (layer)->gimage->layers->num_children == 1) { - gimp_image_alpha_changed (GIMP_DRAWABLE (layer)->gimage); + gimp_image_alpha_changed (GIMP_ITEM (layer)->gimage); } /* Set the new tile manager */ @@ -2038,7 +2038,7 @@ undo_push_layer_displace (GimpImage *gimage, new->pop_func = undo_pop_layer_displace; new->free_func = undo_free_layer_displace; - ldu->info[0] = gimp_drawable_get_ID (GIMP_DRAWABLE (layer)); + ldu->info[0] = gimp_item_get_ID (GIMP_ITEM (layer)); ldu->info[1] = GIMP_DRAWABLE (layer)->offset_x; ldu->info[2] = GIMP_DRAWABLE (layer)->offset_y; ldu->path_undo = path_transform_start_undo (gimage); @@ -2061,7 +2061,7 @@ undo_pop_layer_displace (GimpImage *gimage, LayerDisplaceUndo *ldu; ldu = (LayerDisplaceUndo *) info_ptr; - layer = (GimpLayer *) gimp_drawable_get_by_ID (gimage->gimp, ldu->info[0]); + layer = (GimpLayer *) gimp_item_get_by_ID (gimage->gimp, ldu->info[0]); if (layer) { old_offsets[0] = GIMP_DRAWABLE (layer)->offset_x; @@ -2222,8 +2222,11 @@ undo_pop_channel (GimpImage *gimage, /* remove the channel */ gimp_container_remove (gimage->channels, GIMP_OBJECT (cu->channel)); - /* set the previous channel */ - gimp_image_set_active_channel (gimage, cu->prev_channel); + if (cu->prev_channel) + { + /* set the previous channel */ + gimp_image_set_active_channel (gimage, cu->prev_channel); + } /* update the area */ gimp_drawable_update (GIMP_DRAWABLE (cu->channel), @@ -2241,8 +2244,11 @@ undo_pop_channel (GimpImage *gimage, gimp_container_insert (gimage->channels, GIMP_OBJECT (cu->channel), cu->prev_position); - /* set the new channel */ - gimp_image_set_active_channel (gimage, cu->channel); + if (cu->channel) + { + /* set the new channel */ + gimp_image_set_active_channel (gimage, cu->channel); + } /* update the area */ gimp_drawable_update (GIMP_DRAWABLE (cu->channel), @@ -2545,8 +2551,11 @@ undo_pop_vectors (GimpImage *gimage, /* remove the vectors */ gimp_container_remove (gimage->vectors, GIMP_OBJECT (vu->vectors)); - /* set the previous vectors */ - gimp_image_set_active_vectors (gimage, vu->prev_vectors); + if (vu->prev_vectors) + { + /* set the previous vectors */ + gimp_image_set_active_vectors (gimage, vu->prev_vectors); + } } else { @@ -2559,8 +2568,11 @@ undo_pop_vectors (GimpImage *gimage, gimp_container_insert (gimage->vectors, GIMP_OBJECT (vu->vectors), vu->prev_position); - /* set the new vectors */ - gimp_image_set_active_vectors (gimage, vu->vectors); + if (vu->vectors) + { + /* set the new vectors */ + gimp_image_set_active_vectors (gimage, vu->vectors); + } } return TRUE; @@ -2899,7 +2911,7 @@ undo_pop_fs_rigor (GimpImage *gimage, layer_ID = *((gint32 *) layer_ptr); - if ((floating_layer = (GimpLayer *) gimp_drawable_get_by_ID (gimage->gimp, layer_ID)) == NULL) + if ((floating_layer = (GimpLayer *) gimp_item_get_by_ID (gimage->gimp, layer_ID)) == NULL) return FALSE; if (! gimp_layer_is_floating_sel (floating_layer)) @@ -2982,7 +2994,7 @@ undo_pop_fs_relax (GimpImage *gimage, layer_ID = *((gint32 *) layer_ptr); - if ((floating_layer = (GimpLayer *) gimp_drawable_get_by_ID (gimage->gimp, layer_ID)) == NULL) + if ((floating_layer = (GimpLayer *) gimp_item_get_by_ID (gimage->gimp, layer_ID)) == NULL) return FALSE; if (! gimp_layer_is_floating_sel (floating_layer)) @@ -3250,7 +3262,7 @@ typedef struct _ParasiteUndo ParasiteUndo; struct _ParasiteUndo { GimpImage *gimage; - GimpDrawable *drawable; + GimpItem *item; GimpParasite *parasite; gchar *name; }; @@ -3277,7 +3289,7 @@ undo_push_image_parasite (GimpImage *gimage, new->free_func = undo_free_parasite; pu->gimage = gimage; - pu->drawable = NULL; + pu->item = NULL; pu->name = g_strdup (gimp_parasite_name (parasite)); pu->parasite = gimp_parasite_copy (gimp_image_parasite_find (gimage, pu->name)); @@ -3306,7 +3318,7 @@ undo_push_image_parasite_remove (GimpImage *gimage, new->free_func = undo_free_parasite; pu->gimage = gimage; - pu->drawable = NULL; + pu->item = NULL; pu->name = g_strdup (name); pu->parasite = gimp_parasite_copy (gimp_image_parasite_find (gimage, pu->name)); @@ -3318,9 +3330,9 @@ undo_push_image_parasite_remove (GimpImage *gimage, } gboolean -undo_push_drawable_parasite (GimpImage *gimage, - GimpDrawable *drawable, - gpointer parasite) +undo_push_item_parasite (GimpImage *gimage, + GimpItem *item, + gpointer parasite) { Undo *new; @@ -3336,10 +3348,10 @@ undo_push_drawable_parasite (GimpImage *gimage, new->free_func = undo_free_parasite; pu->gimage = NULL; - pu->drawable = drawable; + pu->item = item; pu->name = g_strdup (gimp_parasite_name (parasite)); - pu->parasite = gimp_parasite_copy (gimp_drawable_parasite_find (drawable, - pu->name)); + pu->parasite = gimp_parasite_copy (gimp_item_parasite_find (item, + pu->name)); return TRUE; } @@ -3347,9 +3359,9 @@ undo_push_drawable_parasite (GimpImage *gimage, } gboolean -undo_push_drawable_parasite_remove (GimpImage *gimage, - GimpDrawable *drawable, - const gchar *name) +undo_push_item_parasite_remove (GimpImage *gimage, + GimpItem *item, + const gchar *name) { Undo *new; @@ -3365,10 +3377,10 @@ undo_push_drawable_parasite_remove (GimpImage *gimage, new->free_func = undo_free_parasite; pu->gimage = NULL; - pu->drawable = drawable; + pu->item = item; pu->name = g_strdup (name); - pu->parasite = gimp_parasite_copy (gimp_drawable_parasite_find (drawable, - pu->name)); + pu->parasite = gimp_parasite_copy (gimp_item_parasite_find (item, + pu->name)); return TRUE; } @@ -3399,15 +3411,15 @@ undo_pop_parasite (GimpImage *gimage, else gimp_parasite_list_remove (data->gimage->parasites, data->name); } - else if (data->drawable) + else if (data->item) { data->parasite = - gimp_parasite_copy (gimp_drawable_parasite_find (data->drawable, - data->name)); + gimp_parasite_copy (gimp_item_parasite_find (data->item, + data->name)); if (tmp) - gimp_parasite_list_add (data->drawable->parasites, tmp); + gimp_parasite_list_add (data->item->parasites, tmp); else - gimp_parasite_list_remove (data->drawable->parasites, data->name); + gimp_parasite_list_remove (data->item->parasites, data->name); } else { diff --git a/app/undo.h b/app/undo.h index 442019fd7e..41263eac3f 100644 --- a/app/undo.h +++ b/app/undo.h @@ -67,136 +67,134 @@ gboolean undo_push_group_end (GimpImage *gimage); /* image undos */ -gboolean undo_push_image (GimpImage *gimage, - GimpDrawable *drawable, - gint x1, - gint y1, - gint x2, - gint y2); -gboolean undo_push_image_mod (GimpImage *gimage, - GimpDrawable *drawable, - gint x1, - gint y1, - gint x2, - gint y2, - TileManager *tiles, - gboolean sparse); -gboolean undo_push_image_type (GimpImage *gimage); -gboolean undo_push_image_size (GimpImage *gimage); -gboolean undo_push_image_resolution (GimpImage *gimage); -gboolean undo_push_image_mask (GimpImage *gimage, - TileManager *tiles, - gint x, - gint y); -gboolean undo_push_image_qmask (GimpImage *gimage); -gboolean undo_push_image_guide (GimpImage *gimage, - GimpGuide *guide); +gboolean undo_push_image (GimpImage *gimage, + GimpDrawable *drawable, + gint x1, + gint y1, + gint x2, + gint y2); +gboolean undo_push_image_mod (GimpImage *gimage, + GimpDrawable *drawable, + gint x1, + gint y1, + gint x2, + gint y2, + TileManager *tiles, + gboolean sparse); +gboolean undo_push_image_type (GimpImage *gimage); +gboolean undo_push_image_size (GimpImage *gimage); +gboolean undo_push_image_resolution (GimpImage *gimage); +gboolean undo_push_image_mask (GimpImage *gimage, + TileManager *tiles, + gint x, + gint y); +gboolean undo_push_image_qmask (GimpImage *gimage); +gboolean undo_push_image_guide (GimpImage *gimage, + GimpGuide *guide); /* layer undos */ -gboolean undo_push_layer_add (GimpImage *gimage, - GimpLayer *layer, - gint prev_position, - GimpLayer *prev_layer); -gboolean undo_push_layer_remove (GimpImage *gimage, - GimpLayer *layer, - gint prev_position, - GimpLayer *prev_layer); -gboolean undo_push_layer_mod (GimpImage *gimage, - GimpLayer *layer); -gboolean undo_push_layer_mask_add (GimpImage *gimage, - GimpLayer *layer, - GimpLayerMask *mask); -gboolean undo_push_layer_mask_remove (GimpImage *gimage, - GimpLayer *layer, - GimpLayerMask *mask); -gboolean undo_push_layer_rename (GimpImage *gimage, - GimpLayer *layer); -gboolean undo_push_layer_reposition (GimpImage *gimage, - GimpLayer *layer); -gboolean undo_push_layer_displace (GimpImage *gimage, - GimpLayer *layer); +gboolean undo_push_layer_add (GimpImage *gimage, + GimpLayer *layer, + gint prev_position, + GimpLayer *prev_layer); +gboolean undo_push_layer_remove (GimpImage *gimage, + GimpLayer *layer, + gint prev_position, + GimpLayer *prev_layer); +gboolean undo_push_layer_mod (GimpImage *gimage, + GimpLayer *layer); +gboolean undo_push_layer_mask_add (GimpImage *gimage, + GimpLayer *layer, + GimpLayerMask *mask); +gboolean undo_push_layer_mask_remove (GimpImage *gimage, + GimpLayer *layer, + GimpLayerMask *mask); +gboolean undo_push_layer_rename (GimpImage *gimage, + GimpLayer *layer); +gboolean undo_push_layer_reposition (GimpImage *gimage, + GimpLayer *layer); +gboolean undo_push_layer_displace (GimpImage *gimage, + GimpLayer *layer); /* channel undos */ -gboolean undo_push_channel_add (GimpImage *gimage, - GimpChannel *channel, - gint prev_position, - GimpChannel *prev_channel); -gboolean undo_push_channel_remove (GimpImage *gimage, - GimpChannel *channel, - gint prev_position, - GimpChannel *prev_channel); -gboolean undo_push_channel_mod (GimpImage *gimage, - GimpChannel *channel); -gboolean undo_push_channel_reposition (GimpImage *gimage, - GimpChannel *channel); +gboolean undo_push_channel_add (GimpImage *gimage, + GimpChannel *channel, + gint prev_position, + GimpChannel *prev_channel); +gboolean undo_push_channel_remove (GimpImage *gimage, + GimpChannel *channel, + gint prev_position, + GimpChannel *prev_channel); +gboolean undo_push_channel_mod (GimpImage *gimage, + GimpChannel *channel); +gboolean undo_push_channel_reposition (GimpImage *gimage, + GimpChannel *channel); /* vectors undos */ -gboolean undo_push_vectors_add (GimpImage *gimage, - GimpVectors *vectors, - gint prev_position, - GimpVectors *prev_vectors); -gboolean undo_push_vectors_remove (GimpImage *gimage, - GimpVectors *channel, - gint prev_position, - GimpVectors *prev_vectors); -gboolean undo_push_vectors_mod (GimpImage *gimage, - GimpVectors *vectors); -gboolean undo_push_vectors_reposition (GimpImage *gimage, - GimpVectors *vectors); +gboolean undo_push_vectors_add (GimpImage *gimage, + GimpVectors *vectors, + gint prev_position, + GimpVectors *prev_vectors); +gboolean undo_push_vectors_remove (GimpImage *gimage, + GimpVectors *channel, + gint prev_position, + GimpVectors *prev_vectors); +gboolean undo_push_vectors_mod (GimpImage *gimage, + GimpVectors *vectors); +gboolean undo_push_vectors_reposition (GimpImage *gimage, + GimpVectors *vectors); /* floating selection undos */ -gboolean undo_push_fs_to_layer (GimpImage *gimage, - GimpLayer *floating_layer, - GimpDrawable *drawable); -gboolean undo_push_fs_rigor (GimpImage *gimage, - gint32 layer_ID); -gboolean undo_push_fs_relax (GimpImage *gimage, - gint32 layer_ID); +gboolean undo_push_fs_to_layer (GimpImage *gimage, + GimpLayer *floating_layer, + GimpDrawable *drawable); +gboolean undo_push_fs_rigor (GimpImage *gimage, + gint32 layer_ID); +gboolean undo_push_fs_relax (GimpImage *gimage, + gint32 layer_ID); /* transform/paint drawable undos */ -gboolean undo_push_transform (GimpImage *gimage, - gint tool_ID, - GType tool_type, - gdouble *trans_info, - TileManager *original, - GSList *path_undo); -gboolean undo_push_paint (GimpImage *gimage, - gint core_ID, - GType core_type, - GimpCoords *last_coords); +gboolean undo_push_transform (GimpImage *gimage, + gint tool_ID, + GType tool_type, + gdouble *trans_info, + TileManager *original, + GSList *path_undo); +gboolean undo_push_paint (GimpImage *gimage, + gint core_ID, + GType core_type, + GimpCoords *last_coords); /* parasite undos */ -gboolean undo_push_image_parasite (GimpImage *gimage, - gpointer parasite); -gboolean undo_push_image_parasite_remove - (GimpImage *gimage, - const gchar *name); +gboolean undo_push_image_parasite (GimpImage *gimage, + gpointer parasite); +gboolean undo_push_image_parasite_remove (GimpImage *gimage, + const gchar *name); -gboolean undo_push_drawable_parasite (GimpImage *gimage, - GimpDrawable *drawable, - gpointer parasite); -gboolean undo_push_drawable_parasite_remove - (GimpImage *gimage, - GimpDrawable *drabable, - const gchar *name); +gboolean undo_push_item_parasite (GimpImage *gimage, + GimpItem *item, + gpointer parasite); +gboolean undo_push_item_parasite_remove (GimpImage *gimage, + GimpItem *item, + const gchar *name); /* EEK undo */ -gboolean undo_push_cantundo (GimpImage *gimage, - const gchar *action); +gboolean undo_push_cantundo (GimpImage *gimage, + const gchar *action); #endif /* __UNDO_H__ */ diff --git a/app/vectors/gimpvectors.c b/app/vectors/gimpvectors.c index 26c35ba6b1..29285ece6e 100644 --- a/app/vectors/gimpvectors.c +++ b/app/vectors/gimpvectors.c @@ -37,7 +37,7 @@ /* private variables */ -static GimpViewableClass *parent_class = NULL; +static GimpItemClass *parent_class = NULL; static void gimp_vectors_class_init (GimpVectorsClass *klass); @@ -66,7 +66,7 @@ gimp_vectors_get_type (void) (GInstanceInitFunc) gimp_vectors_init, }; - vectors_type = g_type_register_static (GIMP_TYPE_VIEWABLE, + vectors_type = g_type_register_static (GIMP_TYPE_ITEM, "GimpVectors", &vectors_info, 0); } @@ -89,12 +89,11 @@ gimp_vectors_class_init (GimpVectorsClass *klass) object_class->finalize = gimp_vectors_finalize; - /* gimp_object_class->name_changed = gimp_vectors_name_changed; */ + /* gimp_object_class->get_memsize = gimp_vectors_get_memsize; */ viewable_class->get_new_preview = gimp_vectors_get_new_preview; klass->changed = NULL; - klass->removed = NULL; klass->stroke_add = NULL; klass->stroke_get = NULL; @@ -113,7 +112,6 @@ gimp_vectors_class_init (GimpVectorsClass *klass) static void gimp_vectors_init (GimpVectors *vectors) { - vectors->gimage = NULL; vectors->strokes = NULL; }; @@ -123,23 +121,6 @@ gimp_vectors_finalize (GObject *object) G_OBJECT_CLASS (parent_class)->finalize (object); } -void -gimp_vectors_set_image (GimpVectors *vectors, - GimpImage *gimage) -{ - g_return_if_fail (GIMP_IS_VECTORS (vectors)); - g_return_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage)); - - vectors->gimage = gimage; -} - -GimpImage * -gimp_vectors_get_image (const GimpVectors *vectors) -{ - g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); - - return vectors->gimage; -} /* Calling the virtual functions */ diff --git a/app/vectors/gimpvectors.h b/app/vectors/gimpvectors.h index 1de7952515..91429bd582 100644 --- a/app/vectors/gimpvectors.h +++ b/app/vectors/gimpvectors.h @@ -22,7 +22,7 @@ #ifndef __GIMP_VECTORS_H__ #define __GIMP_VECTORS_H__ -#include "core/gimpviewable.h" +#include "core/gimpitem.h" #define GIMP_TYPE_VECTORS (gimp_vectors_get_type ()) @@ -35,9 +35,7 @@ struct _GimpVectors { - GimpViewable parent_instance; - - GimpImage * gimage; + GimpItem parent_instance; gboolean visible; /* controls visibility */ gboolean locked; /* transformation locking */ @@ -50,12 +48,9 @@ struct _GimpVectors struct _GimpVectorsClass { - GimpViewableClass parent_class; + GimpItemClass parent_class; void (* changed) (GimpVectors *vectors); - - void (* removed) (GimpVectors *vectors); - void (* stroke_add) (GimpVectors *vectors, const GimpStroke *stroke); @@ -97,10 +92,6 @@ struct _GimpVectorsClass GType gimp_vectors_get_type (void) G_GNUC_CONST; -void gimp_vectors_set_image (GimpVectors *vectors, - GimpImage *gimage); -GimpImage * gimp_vectors_get_image (const GimpVectors *vectors); - /* accessing / modifying the anchors */ diff --git a/app/widgets/Makefile.am b/app/widgets/Makefile.am index 64a97ab335..c1ff4b6cdc 100644 --- a/app/widgets/Makefile.am +++ b/app/widgets/Makefile.am @@ -76,6 +76,8 @@ libappwidgets_a_SOURCES = @STRIP_BEGIN@ \ gimpimagepreview.h \ gimpitemfactory.c \ gimpitemfactory.h \ + gimpitemlistview.c \ + gimpitemlistview.h \ gimplayerlistitem.c \ gimplayerlistitem.h \ gimplayerlistview.c \ diff --git a/app/widgets/gimpchannellistview.c b/app/widgets/gimpchannellistview.c index ef455bd902..bffcbdc368 100644 --- a/app/widgets/gimpchannellistview.c +++ b/app/widgets/gimpchannellistview.c @@ -52,7 +52,7 @@ static void gimp_channel_list_view_class_init (GimpChannelListViewClass *klass); static void gimp_channel_list_view_init (GimpChannelListView *view); -static void gimp_channel_list_view_set_image (GimpDrawableListView *view, +static void gimp_channel_list_view_set_image (GimpItemListView *item_view, GimpImage *gimage); static void gimp_channel_list_view_select_item (GimpContainerView *view, @@ -121,18 +121,18 @@ gimp_channel_list_view_get_type (void) static void gimp_channel_list_view_class_init (GimpChannelListViewClass *klass) { - GimpContainerViewClass *container_view_class; - GimpDrawableListViewClass *drawable_view_class; + GimpContainerViewClass *container_view_class; + GimpItemListViewClass *item_view_class; container_view_class = GIMP_CONTAINER_VIEW_CLASS (klass); - drawable_view_class = GIMP_DRAWABLE_LIST_VIEW_CLASS (klass); + item_view_class = GIMP_ITEM_LIST_VIEW_CLASS (klass); parent_class = g_type_class_peek_parent (klass); container_view_class->select_item = gimp_channel_list_view_select_item; container_view_class->set_preview_size = gimp_channel_list_view_set_preview_size; - drawable_view_class->set_image = gimp_channel_list_view_set_image; + item_view_class->set_image = gimp_channel_list_view_set_image; } static void @@ -190,42 +190,42 @@ gimp_channel_list_view_init (GimpChannelListView *view) /* GimpChannelListView methods */ static void -gimp_channel_list_view_set_image (GimpDrawableListView *view, - GimpImage *gimage) +gimp_channel_list_view_set_image (GimpItemListView *item_view, + GimpImage *gimage) { GimpChannelListView *channel_view; - channel_view = GIMP_CHANNEL_LIST_VIEW (view); + channel_view = GIMP_CHANNEL_LIST_VIEW (item_view); - if (view->gimage) + if (item_view->gimage) { if (! gimage) gtk_widget_hide (channel_view->component_frame); gimp_channel_list_view_clear_components (channel_view); - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), + g_signal_handlers_disconnect_by_func (G_OBJECT (item_view->gimage), gimp_channel_list_view_mode_changed, channel_view); - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), + g_signal_handlers_disconnect_by_func (G_OBJECT (item_view->gimage), gimp_channel_list_view_alpha_changed, channel_view); } - if (GIMP_DRAWABLE_LIST_VIEW_CLASS (parent_class)->set_image) - GIMP_DRAWABLE_LIST_VIEW_CLASS (parent_class)->set_image (view, gimage); + if (GIMP_ITEM_LIST_VIEW_CLASS (parent_class)->set_image) + GIMP_ITEM_LIST_VIEW_CLASS (parent_class)->set_image (item_view, gimage); - if (view->gimage) + if (item_view->gimage) { if (! GTK_WIDGET_VISIBLE (channel_view->component_frame)) gtk_widget_show (channel_view->component_frame); gimp_channel_list_view_create_components (channel_view); - g_signal_connect (G_OBJECT (view->gimage), "mode_changed", + g_signal_connect (G_OBJECT (item_view->gimage), "mode_changed", G_CALLBACK (gimp_channel_list_view_mode_changed), channel_view); - g_signal_connect (G_OBJECT (view->gimage), "alpha_changed", + g_signal_connect (G_OBJECT (item_view->gimage), "alpha_changed", G_CALLBACK (gimp_channel_list_view_alpha_changed), channel_view); } @@ -239,22 +239,22 @@ gimp_channel_list_view_select_item (GimpContainerView *view, GimpViewable *item, gpointer insert_data) { - GimpDrawableListView *drawable_view; - GimpChannelListView *list_view; + GimpItemListView *item_view; + GimpChannelListView *list_view; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); - list_view = GIMP_CHANNEL_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); + list_view = GIMP_CHANNEL_LIST_VIEW (view); if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, item, insert_data); - if (drawable_view->gimage) + if (item_view->gimage) { gboolean floating_sel; - floating_sel = (gimp_image_floating_sel (drawable_view->gimage) != NULL); + floating_sel = (gimp_image_floating_sel (item_view->gimage) != NULL); gtk_widget_set_sensitive (view->button_box, !floating_sel); } @@ -297,7 +297,7 @@ gimp_channel_list_view_to_selection (GimpChannelListView *view, GimpImage *gimage; GimpChannel *new_channel; - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (channel)); + gimage = gimp_item_get_image (GIMP_ITEM (channel)); if (operation == CHANNEL_OP_REPLACE) { @@ -329,15 +329,15 @@ static void gimp_channel_list_view_toselection_clicked (GtkWidget *widget, GimpChannelListView *view) { - GimpDrawableListView *drawable_view; - GimpDrawable *drawable; + GimpItemListView *item_view; + GimpViewable *viewable; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - drawable = drawable_view->get_drawable_func (drawable_view->gimage); + viewable = item_view->get_item_func (item_view->gimage); - if (drawable) - gimp_channel_list_view_to_selection (view, GIMP_CHANNEL (drawable), + if (viewable) + gimp_channel_list_view_to_selection (view, GIMP_CHANNEL (viewable), CHANNEL_OP_REPLACE); } @@ -346,14 +346,14 @@ gimp_channel_list_view_toselection_extended_clicked (GtkWidget *widget guint state, GimpChannelListView *view) { - GimpDrawableListView *drawable_view; - GimpDrawable *drawable; + GimpItemListView *item_view; + GimpViewable *viewable; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - drawable = drawable_view->get_drawable_func (drawable_view->gimage); + viewable = item_view->get_item_func (item_view->gimage); - if (drawable) + if (viewable) { ChannelOps operation = CHANNEL_OP_REPLACE; @@ -369,7 +369,7 @@ gimp_channel_list_view_toselection_extended_clicked (GtkWidget *widget operation = CHANNEL_OP_SUB; } - gimp_channel_list_view_to_selection (view, GIMP_CHANNEL (drawable), + gimp_channel_list_view_to_selection (view, GIMP_CHANNEL (viewable), operation); } } @@ -384,7 +384,7 @@ gimp_channel_list_view_create_components (GimpChannelListView *view) GList *list = NULL; gint i; - gimage = GIMP_DRAWABLE_LIST_VIEW (view)->gimage; + gimage = GIMP_ITEM_LIST_VIEW (view)->gimage; switch (gimp_image_base_type (gimage)) { @@ -471,7 +471,7 @@ gimp_channel_list_view_component_toggle (GtkList *list, gimp_channel_list_view_component_toggle, view); - gimp_image_set_component_active (GIMP_DRAWABLE_LIST_VIEW (view)->gimage, + gimp_image_set_component_active (GIMP_ITEM_LIST_VIEW (view)->gimage, component_item->channel, child->state == GTK_STATE_SELECTED); diff --git a/app/widgets/gimpchanneltreeview.c b/app/widgets/gimpchanneltreeview.c index ef455bd902..bffcbdc368 100644 --- a/app/widgets/gimpchanneltreeview.c +++ b/app/widgets/gimpchanneltreeview.c @@ -52,7 +52,7 @@ static void gimp_channel_list_view_class_init (GimpChannelListViewClass *klass); static void gimp_channel_list_view_init (GimpChannelListView *view); -static void gimp_channel_list_view_set_image (GimpDrawableListView *view, +static void gimp_channel_list_view_set_image (GimpItemListView *item_view, GimpImage *gimage); static void gimp_channel_list_view_select_item (GimpContainerView *view, @@ -121,18 +121,18 @@ gimp_channel_list_view_get_type (void) static void gimp_channel_list_view_class_init (GimpChannelListViewClass *klass) { - GimpContainerViewClass *container_view_class; - GimpDrawableListViewClass *drawable_view_class; + GimpContainerViewClass *container_view_class; + GimpItemListViewClass *item_view_class; container_view_class = GIMP_CONTAINER_VIEW_CLASS (klass); - drawable_view_class = GIMP_DRAWABLE_LIST_VIEW_CLASS (klass); + item_view_class = GIMP_ITEM_LIST_VIEW_CLASS (klass); parent_class = g_type_class_peek_parent (klass); container_view_class->select_item = gimp_channel_list_view_select_item; container_view_class->set_preview_size = gimp_channel_list_view_set_preview_size; - drawable_view_class->set_image = gimp_channel_list_view_set_image; + item_view_class->set_image = gimp_channel_list_view_set_image; } static void @@ -190,42 +190,42 @@ gimp_channel_list_view_init (GimpChannelListView *view) /* GimpChannelListView methods */ static void -gimp_channel_list_view_set_image (GimpDrawableListView *view, - GimpImage *gimage) +gimp_channel_list_view_set_image (GimpItemListView *item_view, + GimpImage *gimage) { GimpChannelListView *channel_view; - channel_view = GIMP_CHANNEL_LIST_VIEW (view); + channel_view = GIMP_CHANNEL_LIST_VIEW (item_view); - if (view->gimage) + if (item_view->gimage) { if (! gimage) gtk_widget_hide (channel_view->component_frame); gimp_channel_list_view_clear_components (channel_view); - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), + g_signal_handlers_disconnect_by_func (G_OBJECT (item_view->gimage), gimp_channel_list_view_mode_changed, channel_view); - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), + g_signal_handlers_disconnect_by_func (G_OBJECT (item_view->gimage), gimp_channel_list_view_alpha_changed, channel_view); } - if (GIMP_DRAWABLE_LIST_VIEW_CLASS (parent_class)->set_image) - GIMP_DRAWABLE_LIST_VIEW_CLASS (parent_class)->set_image (view, gimage); + if (GIMP_ITEM_LIST_VIEW_CLASS (parent_class)->set_image) + GIMP_ITEM_LIST_VIEW_CLASS (parent_class)->set_image (item_view, gimage); - if (view->gimage) + if (item_view->gimage) { if (! GTK_WIDGET_VISIBLE (channel_view->component_frame)) gtk_widget_show (channel_view->component_frame); gimp_channel_list_view_create_components (channel_view); - g_signal_connect (G_OBJECT (view->gimage), "mode_changed", + g_signal_connect (G_OBJECT (item_view->gimage), "mode_changed", G_CALLBACK (gimp_channel_list_view_mode_changed), channel_view); - g_signal_connect (G_OBJECT (view->gimage), "alpha_changed", + g_signal_connect (G_OBJECT (item_view->gimage), "alpha_changed", G_CALLBACK (gimp_channel_list_view_alpha_changed), channel_view); } @@ -239,22 +239,22 @@ gimp_channel_list_view_select_item (GimpContainerView *view, GimpViewable *item, gpointer insert_data) { - GimpDrawableListView *drawable_view; - GimpChannelListView *list_view; + GimpItemListView *item_view; + GimpChannelListView *list_view; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); - list_view = GIMP_CHANNEL_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); + list_view = GIMP_CHANNEL_LIST_VIEW (view); if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, item, insert_data); - if (drawable_view->gimage) + if (item_view->gimage) { gboolean floating_sel; - floating_sel = (gimp_image_floating_sel (drawable_view->gimage) != NULL); + floating_sel = (gimp_image_floating_sel (item_view->gimage) != NULL); gtk_widget_set_sensitive (view->button_box, !floating_sel); } @@ -297,7 +297,7 @@ gimp_channel_list_view_to_selection (GimpChannelListView *view, GimpImage *gimage; GimpChannel *new_channel; - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (channel)); + gimage = gimp_item_get_image (GIMP_ITEM (channel)); if (operation == CHANNEL_OP_REPLACE) { @@ -329,15 +329,15 @@ static void gimp_channel_list_view_toselection_clicked (GtkWidget *widget, GimpChannelListView *view) { - GimpDrawableListView *drawable_view; - GimpDrawable *drawable; + GimpItemListView *item_view; + GimpViewable *viewable; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - drawable = drawable_view->get_drawable_func (drawable_view->gimage); + viewable = item_view->get_item_func (item_view->gimage); - if (drawable) - gimp_channel_list_view_to_selection (view, GIMP_CHANNEL (drawable), + if (viewable) + gimp_channel_list_view_to_selection (view, GIMP_CHANNEL (viewable), CHANNEL_OP_REPLACE); } @@ -346,14 +346,14 @@ gimp_channel_list_view_toselection_extended_clicked (GtkWidget *widget guint state, GimpChannelListView *view) { - GimpDrawableListView *drawable_view; - GimpDrawable *drawable; + GimpItemListView *item_view; + GimpViewable *viewable; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - drawable = drawable_view->get_drawable_func (drawable_view->gimage); + viewable = item_view->get_item_func (item_view->gimage); - if (drawable) + if (viewable) { ChannelOps operation = CHANNEL_OP_REPLACE; @@ -369,7 +369,7 @@ gimp_channel_list_view_toselection_extended_clicked (GtkWidget *widget operation = CHANNEL_OP_SUB; } - gimp_channel_list_view_to_selection (view, GIMP_CHANNEL (drawable), + gimp_channel_list_view_to_selection (view, GIMP_CHANNEL (viewable), operation); } } @@ -384,7 +384,7 @@ gimp_channel_list_view_create_components (GimpChannelListView *view) GList *list = NULL; gint i; - gimage = GIMP_DRAWABLE_LIST_VIEW (view)->gimage; + gimage = GIMP_ITEM_LIST_VIEW (view)->gimage; switch (gimp_image_base_type (gimage)) { @@ -471,7 +471,7 @@ gimp_channel_list_view_component_toggle (GtkList *list, gimp_channel_list_view_component_toggle, view); - gimp_image_set_component_active (GIMP_DRAWABLE_LIST_VIEW (view)->gimage, + gimp_image_set_component_active (GIMP_ITEM_LIST_VIEW (view)->gimage, component_item->channel, child->state == GTK_STATE_SELECTED); diff --git a/app/widgets/gimpdnd.c b/app/widgets/gimpdnd.c index 0b7508cf1a..3f349828ad 100644 --- a/app/widgets/gimpdnd.c +++ b/app/widgets/gimpdnd.c @@ -45,6 +45,8 @@ #include "core/gimppattern.h" #include "core/gimptoolinfo.h" +#include "vectors/gimpvectors.h" + #include "file/file-open.h" #include "app_procs.h" @@ -126,14 +128,14 @@ static void gimp_dnd_set_image_data (GtkWidget *widget, gint format, gint length); -static guchar * gimp_dnd_get_drawable_data (GtkWidget *widget, - GCallback get_drawable_func, - gpointer get_drawable_data, +static guchar * gimp_dnd_get_item_data (GtkWidget *widget, + GCallback get_item_func, + gpointer get_item_data, gint *format, gint *length); -static void gimp_dnd_set_drawable_data (GtkWidget *widget, - GCallback set_drawable_func, - gpointer set_drawable_data, +static void gimp_dnd_set_item_data (GtkWidget *widget, + GCallback set_item_func, + gpointer set_item_data, guchar *vals, gint format, gint length); @@ -263,8 +265,8 @@ static GimpDndDataDef dnd_data_defs[] = "gimp_dnd_set_layer_data", gimp_dnd_get_viewable_icon, - gimp_dnd_get_drawable_data, - gimp_dnd_set_drawable_data, + gimp_dnd_get_item_data, + gimp_dnd_set_item_data, }, { @@ -274,8 +276,8 @@ static GimpDndDataDef dnd_data_defs[] = "gimp_dnd_set_channel_data", gimp_dnd_get_viewable_icon, - gimp_dnd_get_drawable_data, - gimp_dnd_set_drawable_data, + gimp_dnd_get_item_data, + gimp_dnd_set_item_data, }, { @@ -285,8 +287,8 @@ static GimpDndDataDef dnd_data_defs[] = "gimp_dnd_set_layer_mask_data", gimp_dnd_get_viewable_icon, - gimp_dnd_get_drawable_data, - gimp_dnd_set_drawable_data, + gimp_dnd_get_item_data, + gimp_dnd_set_item_data, }, { @@ -301,14 +303,14 @@ static GimpDndDataDef dnd_data_defs[] = }, { - GIMP_TARGET_PATH, + GIMP_TARGET_VECTORS, - NULL, - NULL, + "gimp_dnd_set_vectors_func", + "gimp_dnd_set_vectors_data", - NULL, - NULL, - NULL, + gimp_dnd_get_viewable_icon, + gimp_dnd_get_item_data, + gimp_dnd_set_item_data, }, { @@ -925,6 +927,10 @@ gimp_dnd_data_type_get_by_g_type (GType type) { dnd_type = GIMP_DND_TYPE_CHANNEL; } + else if (g_type_is_a (type, GIMP_TYPE_VECTORS)) + { + dnd_type = GIMP_DND_TYPE_VECTORS; + } else if (g_type_is_a (type, GIMP_TYPE_BRUSH)) { dnd_type = GIMP_DND_TYPE_BRUSH; @@ -1171,27 +1177,27 @@ gimp_dnd_set_image_data (GtkWidget *widget, } -/****************************/ -/* drawable dnd functions */ -/****************************/ +/************************/ +/* item dnd functions */ +/************************/ static guchar * -gimp_dnd_get_drawable_data (GtkWidget *widget, - GCallback get_drawable_func, - gpointer get_drawable_data, - gint *format, - gint *length) +gimp_dnd_get_item_data (GtkWidget *widget, + GCallback get_item_func, + gpointer get_item_data, + gint *format, + gint *length) { - GimpDrawable *drawable; - gchar *id; + GimpItem *item; + gchar *id; - drawable = (GimpDrawable *) - (* (GimpDndDragViewableFunc) get_drawable_func) (widget, get_drawable_data); + item = (GimpItem *) + (* (GimpDndDragViewableFunc) get_item_func) (widget, get_item_data); - if (! drawable) + if (! item) return NULL; - id = g_strdup_printf ("%d", gimp_drawable_get_ID (drawable)); + id = g_strdup_printf ("%d", gimp_item_get_ID (item)); *format = 8; *length = strlen (id) + 1; @@ -1200,20 +1206,20 @@ gimp_dnd_get_drawable_data (GtkWidget *widget, } static void -gimp_dnd_set_drawable_data (GtkWidget *widget, - GCallback set_drawable_func, - gpointer set_drawable_data, - guchar *vals, - gint format, - gint length) +gimp_dnd_set_item_data (GtkWidget *widget, + GCallback set_item_func, + gpointer set_item_data, + guchar *vals, + gint format, + gint length) { - GimpDrawable *drawable; - gchar *id; - gint ID; + GimpItem *item; + gchar *id; + gint ID; if ((format != 8) || (length < 1)) { - g_warning ("Received invalid drawable ID data"); + g_warning ("Received invalid item ID data"); return; } @@ -1224,12 +1230,12 @@ gimp_dnd_set_drawable_data (GtkWidget *widget, if (! ID) return; - drawable = gimp_drawable_get_by_ID (the_gimp, ID); + item = gimp_item_get_by_ID (the_gimp, ID); - if (drawable) - (* (GimpDndDropViewableFunc) set_drawable_func) (widget, - GIMP_VIEWABLE (drawable), - set_drawable_data); + if (item) + (* (GimpDndDropViewableFunc) set_item_func) (widget, + GIMP_VIEWABLE (item), + set_item_data); } diff --git a/app/widgets/gimpdnd.h b/app/widgets/gimpdnd.h index e74c5b2667..0a0d742f48 100644 --- a/app/widgets/gimpdnd.h +++ b/app/widgets/gimpdnd.h @@ -32,7 +32,7 @@ typedef enum GIMP_DND_TYPE_CHANNEL = 7, GIMP_DND_TYPE_LAYER_MASK = 8, GIMP_DND_TYPE_COMPONENT = 9, - GIMP_DND_TYPE_PATH = 10, + GIMP_DND_TYPE_VECTORS = 10, GIMP_DND_TYPE_BRUSH = 11, GIMP_DND_TYPE_PATTERN = 12, GIMP_DND_TYPE_GRADIENT = 13, @@ -70,8 +70,8 @@ typedef enum #define GIMP_TARGET_COMPONENT \ { "GIMP_COMPONENT", GTK_TARGET_SAME_APP, GIMP_DND_TYPE_COMPONENT } -#define GIMP_TARGET_PATH \ - { "GIMP_PATH", GTK_TARGET_SAME_APP, GIMP_DND_TYPE_PATH } +#define GIMP_TARGET_VECTORS \ + { "GIMP_VECTORS", GTK_TARGET_SAME_APP, GIMP_DND_TYPE_VECTORS } #define GIMP_TARGET_COLOR \ { "application/x-color", 0, GIMP_DND_TYPE_COLOR } diff --git a/app/widgets/gimpdrawablelistitem.c b/app/widgets/gimpdrawablelistitem.c index 6b133a8bc3..536cfa9ba0 100644 --- a/app/widgets/gimpdrawablelistitem.c +++ b/app/widgets/gimpdrawablelistitem.c @@ -212,33 +212,30 @@ gimp_drawable_list_item_drag_drop (GtkWidget *widget, widget->parent->parent && /* EEEEK */ widget->parent->parent->parent && /* EEEEEEK */ widget->parent->parent->parent->parent && /* EEEEEEEEK */ - GIMP_IS_DRAWABLE_LIST_VIEW (widget->parent->parent->parent->parent)) + GIMP_IS_ITEM_LIST_VIEW (widget->parent->parent->parent->parent)) { - GimpDrawableListView *list_view; - GimpDrawable *src_drawable; + GimpItemListView *item_view; - list_view = - GIMP_DRAWABLE_LIST_VIEW (widget->parent->parent->parent->parent); + item_view = + GIMP_ITEM_LIST_VIEW (widget->parent->parent->parent->parent); - src_drawable = GIMP_DRAWABLE (src_viewable); - - if (list_view->gimage == gimp_drawable_gimage (src_drawable)) + if (item_view->gimage == gimp_item_get_image (GIMP_ITEM (src_viewable))) { - list_view->reorder_drawable_func (list_view->gimage, - src_drawable, - dest_index, - TRUE); + item_view->reorder_item_func (item_view->gimage, + src_viewable, + dest_index, + TRUE); } - else if (list_view->convert_drawable_func) + else if (item_view->convert_item_func) { - GimpDrawable *new_drawable; + GimpViewable *new_viewable; - new_drawable = list_view->convert_drawable_func (list_view->gimage, - src_drawable); + new_viewable = item_view->convert_item_func (src_viewable, + item_view->gimage); - list_view->add_drawable_func (list_view->gimage, - new_drawable, - dest_index); + item_view->add_item_func (item_view->gimage, + new_viewable, + dest_index); } gdisplays_flush (); @@ -246,7 +243,7 @@ gimp_drawable_list_item_drag_drop (GtkWidget *widget, else { g_warning ("%s(): GimpDrawableListItem is not " - "part of a GimpDrawableListView", G_GNUC_FUNCTION); + "part of a GimpItemListView", G_GNUC_FUNCTION); } } diff --git a/app/widgets/gimpdrawablelistview.c b/app/widgets/gimpdrawablelistview.c index 48e6ab3928..ca98fe4e59 100644 --- a/app/widgets/gimpdrawablelistview.c +++ b/app/widgets/gimpdrawablelistview.c @@ -53,68 +53,18 @@ #include "libgimp/gimpintl.h" -enum -{ - SET_IMAGE, - LAST_SIGNAL -}; - - static void gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass); static void gimp_drawable_list_view_init (GimpDrawableListView *view); -static void gimp_drawable_list_view_destroy (GtkObject *object); -static void gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, - GimpImage *gimage); +static void gimp_drawable_list_view_set_image (GimpItemListView *view, + GimpImage *gimage); -static void gimp_drawable_list_view_select_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); -static void gimp_drawable_list_view_activate_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); -static void gimp_drawable_list_view_context_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); - -static void gimp_drawable_list_view_new_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_new_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data); - -static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_raise_extended_clicked - (GtkWidget *widget, - guint state, - GimpDrawableListView *view); -static void gimp_drawable_list_view_lower_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_lower_extended_clicked - (GtkWidget *widget, - guint state, - GimpDrawableListView *view); - -static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_edit_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_delete_clicked (GtkWidget *widget, - GimpDrawableListView *view); - -static void gimp_drawable_list_view_drawable_changed (GimpImage *gimage, - GimpDrawableListView *view); -static void gimp_drawable_list_view_size_changed (GimpImage *gimage, - GimpDrawableListView *view); static void gimp_drawable_list_view_floating_selection_changed - (GimpImage *gimage, - GimpDrawableListView *view); + (GimpImage *gimage, + GimpDrawableListView *view); -static guint view_signals[LAST_SIGNAL] = { 0 }; - -static GimpContainerListViewClass *parent_class = NULL; +static GimpItemListViewClass *parent_class = NULL; GType @@ -137,7 +87,7 @@ gimp_drawable_list_view_get_type (void) (GInstanceInitFunc) gimp_drawable_list_view_init, }; - view_type = g_type_register_static (GIMP_TYPE_CONTAINER_LIST_VIEW, + view_type = g_type_register_static (GIMP_TYPE_ITEM_LIST_VIEW, "GimpDrawableListView", &view_info, 0); } @@ -148,576 +98,51 @@ gimp_drawable_list_view_get_type (void) static void gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass) { - GtkObjectClass *object_class; - GimpContainerViewClass *container_view_class; + GimpItemListViewClass *item_view_class; - object_class = GTK_OBJECT_CLASS (klass); - container_view_class = GIMP_CONTAINER_VIEW_CLASS (klass); + item_view_class = GIMP_ITEM_LIST_VIEW_CLASS (klass); parent_class = g_type_class_peek_parent (klass); - view_signals[SET_IMAGE] = - g_signal_new ("set_image", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (GimpDrawableListViewClass, set_image), - NULL, NULL, - gimp_marshal_VOID__OBJECT, - G_TYPE_NONE, 1, - GIMP_TYPE_OBJECT); - - object_class->destroy = gimp_drawable_list_view_destroy; - - container_view_class->select_item = gimp_drawable_list_view_select_item; - container_view_class->activate_item = gimp_drawable_list_view_activate_item; - container_view_class->context_item = gimp_drawable_list_view_context_item; - - klass->set_image = gimp_drawable_list_view_real_set_image; + item_view_class->set_image = gimp_drawable_list_view_set_image; } static void gimp_drawable_list_view_init (GimpDrawableListView *view) { - GimpContainerView *container_view; - - container_view = GIMP_CONTAINER_VIEW (view); - - view->gimage = NULL; - view->drawable_type = G_TYPE_NONE; - view->signal_name = NULL; - - view->new_button = - gimp_container_view_add_button (container_view, - GTK_STOCK_NEW, - _("New"), NULL, - G_CALLBACK (gimp_drawable_list_view_new_clicked), - NULL, - view); - - view->raise_button = - gimp_container_view_add_button (container_view, - GTK_STOCK_GO_UP, - _("Raise\n" - " To Top"), NULL, - G_CALLBACK (gimp_drawable_list_view_raise_clicked), - G_CALLBACK (gimp_drawable_list_view_raise_extended_clicked), - view); - - view->lower_button = - gimp_container_view_add_button (container_view, - GTK_STOCK_GO_DOWN, - _("Lower\n" - " To Bottom"), NULL, - G_CALLBACK (gimp_drawable_list_view_lower_clicked), - G_CALLBACK (gimp_drawable_list_view_lower_extended_clicked), - view); - - view->duplicate_button = - gimp_container_view_add_button (container_view, - GIMP_STOCK_DUPLICATE, - _("Duplicate"), NULL, - G_CALLBACK (gimp_drawable_list_view_duplicate_clicked), - NULL, - view); - - view->edit_button = - gimp_container_view_add_button (container_view, - GIMP_STOCK_EDIT, - _("Edit"), NULL, - G_CALLBACK (gimp_drawable_list_view_edit_clicked), - NULL, - view); - - view->delete_button = - gimp_container_view_add_button (container_view, - GTK_STOCK_DELETE, - _("Delete"), NULL, - G_CALLBACK (gimp_drawable_list_view_delete_clicked), - NULL, - view); - - gtk_widget_set_sensitive (view->new_button, FALSE); - gtk_widget_set_sensitive (view->raise_button, FALSE); - gtk_widget_set_sensitive (view->lower_button, FALSE); - gtk_widget_set_sensitive (view->duplicate_button, FALSE); - gtk_widget_set_sensitive (view->edit_button, FALSE); - gtk_widget_set_sensitive (view->delete_button, FALSE); } static void -gimp_drawable_list_view_destroy (GtkObject *object) +gimp_drawable_list_view_set_image (GimpItemListView *item_view, + GimpImage *gimage) { GimpDrawableListView *view; - view = GIMP_DRAWABLE_LIST_VIEW (object); - - if (view->gimage) - gimp_drawable_list_view_set_image (view, NULL); - - if (view->signal_name) - { - g_free (view->signal_name); - view->signal_name = NULL; - } - - if (view->item_factory) - { - g_object_unref (G_OBJECT (view->item_factory)); - view->item_factory = NULL; - } - - if (GTK_OBJECT_CLASS (parent_class)->destroy) - GTK_OBJECT_CLASS (parent_class)->destroy (object); -} - -GtkWidget * -gimp_drawable_list_view_new (gint preview_size, - GimpImage *gimage, - GType drawable_type, - const gchar *signal_name, - GimpGetContainerFunc get_container_func, - GimpGetDrawableFunc get_drawable_func, - GimpSetDrawableFunc set_drawable_func, - GimpReorderDrawableFunc reorder_drawable_func, - GimpAddDrawableFunc add_drawable_func, - GimpRemoveDrawableFunc remove_drawable_func, - GimpCopyDrawableFunc copy_drawable_func, - GimpConvertDrawableFunc convert_drawable_func, - GimpNewDrawableFunc new_drawable_func, - GimpEditDrawableFunc edit_drawable_func, - GimpItemFactory *item_factory) -{ - GimpDrawableListView *list_view; - GimpContainerView *view; - - g_return_val_if_fail (preview_size > 0 && preview_size <= 64, NULL); - g_return_val_if_fail (! gimage || GIMP_IS_IMAGE (gimage), NULL); - g_return_val_if_fail (signal_name != NULL, NULL); - g_return_val_if_fail (get_container_func != NULL, NULL); - g_return_val_if_fail (get_drawable_func != NULL, NULL); - g_return_val_if_fail (get_drawable_func != NULL, NULL); - g_return_val_if_fail (reorder_drawable_func != NULL, NULL); - g_return_val_if_fail (add_drawable_func != NULL, NULL); - g_return_val_if_fail (remove_drawable_func != NULL, NULL); - g_return_val_if_fail (copy_drawable_func != NULL, NULL); - /* convert_drawable_func may be NULL */ - g_return_val_if_fail (new_drawable_func != NULL, NULL); - g_return_val_if_fail (edit_drawable_func != NULL, NULL); - g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), NULL); - - if (drawable_type == GIMP_TYPE_LAYER) - { - list_view = g_object_new (GIMP_TYPE_LAYER_LIST_VIEW, NULL); - } - else if (drawable_type == GIMP_TYPE_CHANNEL) - { - list_view = g_object_new (GIMP_TYPE_CHANNEL_LIST_VIEW, NULL); - } - else - { - list_view = g_object_new (GIMP_TYPE_DRAWABLE_LIST_VIEW, NULL); - } - - view = GIMP_CONTAINER_VIEW (list_view); - - view->preview_size = preview_size; - view->reorderable = TRUE; - - list_view->drawable_type = drawable_type; - list_view->signal_name = g_strdup (signal_name); - list_view->get_container_func = get_container_func; - list_view->get_drawable_func = get_drawable_func; - list_view->set_drawable_func = set_drawable_func; - list_view->reorder_drawable_func = reorder_drawable_func; - list_view->add_drawable_func = add_drawable_func; - list_view->remove_drawable_func = remove_drawable_func; - list_view->copy_drawable_func = copy_drawable_func; - list_view->convert_drawable_func = convert_drawable_func; - list_view->new_drawable_func = new_drawable_func; - list_view->edit_drawable_func = edit_drawable_func; - - list_view->item_factory = item_factory; - g_object_ref (G_OBJECT (list_view->item_factory)); - - /* connect "drop to new" manually as it makes a difference whether - * it was clicked or dropped - */ - gimp_gtk_drag_dest_set_by_type (list_view->new_button, - GTK_DEST_DEFAULT_ALL, - drawable_type, - GDK_ACTION_COPY); - gimp_dnd_viewable_dest_set (list_view->new_button, - drawable_type, - gimp_drawable_list_view_new_dropped, - view); - - gimp_container_view_enable_dnd (view, - GTK_BUTTON (list_view->duplicate_button), - drawable_type); - gimp_container_view_enable_dnd (view, - GTK_BUTTON (list_view->edit_button), - drawable_type); - gimp_container_view_enable_dnd (view, - GTK_BUTTON (list_view->delete_button), - drawable_type); - - gimp_drawable_list_view_set_image (list_view, gimage); - - return GTK_WIDGET (list_view); -} - -void -gimp_drawable_list_view_set_image (GimpDrawableListView *view, - GimpImage *gimage) -{ - g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (view)); + g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (item_view)); g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage)); - g_signal_emit (G_OBJECT (view), view_signals[SET_IMAGE], 0, - gimage); -} + view = GIMP_DRAWABLE_LIST_VIEW (item_view); -static void -gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, - GimpImage *gimage) -{ - g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (view)); - g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage)); - - if (view->gimage == gimage) - return; - - if (view->gimage) + if (item_view->gimage) { - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), - gimp_drawable_list_view_drawable_changed, - view); - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), - gimp_drawable_list_view_size_changed, - view); - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), + g_signal_handlers_disconnect_by_func (G_OBJECT (item_view->gimage), gimp_drawable_list_view_floating_selection_changed, view); - - gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), NULL); } - view->gimage = gimage; + GIMP_ITEM_LIST_VIEW_CLASS (parent_class)->set_image (item_view, gimage); - if (view->gimage) + if (item_view->gimage) { - GimpContainer *container; - - container = view->get_container_func (view->gimage); - - gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), container); - - g_signal_connect (G_OBJECT (view->gimage), view->signal_name, - G_CALLBACK (gimp_drawable_list_view_drawable_changed), - view); - g_signal_connect (G_OBJECT (view->gimage), "size_changed", - G_CALLBACK (gimp_drawable_list_view_size_changed), - view); - g_signal_connect (G_OBJECT (view->gimage), "floating_selection_changed", + g_signal_connect (G_OBJECT (item_view->gimage), + "floating_selection_changed", G_CALLBACK (gimp_drawable_list_view_floating_selection_changed), view); - gimp_drawable_list_view_drawable_changed (view->gimage, view); - - if (gimp_image_floating_sel (view->gimage)) - gimp_drawable_list_view_floating_selection_changed (view->gimage, view); + if (gimp_image_floating_sel (item_view->gimage)) + gimp_drawable_list_view_floating_selection_changed (item_view->gimage, + view); } - - gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL)); -} - - -/* GimpContainerView methods */ - -static void -gimp_drawable_list_view_select_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) -{ - GimpDrawableListView *list_view; - gboolean raise_sensitive = FALSE; - gboolean lower_sensitive = FALSE; - gboolean duplicate_sensitive = FALSE; - gboolean edit_sensitive = FALSE; - gboolean delete_sensitive = FALSE; - - list_view = GIMP_DRAWABLE_LIST_VIEW (view); - - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) - GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, - item, - insert_data); - - if (item) - { - GimpDrawable *drawable; - gint index; - - drawable = list_view->get_drawable_func (list_view->gimage); - - if (drawable != GIMP_DRAWABLE (item)) - { - list_view->set_drawable_func (list_view->gimage, - GIMP_DRAWABLE (item)); - - gdisplays_flush (); - } - - index = gimp_container_get_child_index (view->container, - GIMP_OBJECT (item)); - - if (view->container->num_children > 1) - { - if (index > 0) - raise_sensitive = TRUE; - - if (index < (view->container->num_children - 1)) - lower_sensitive = TRUE; - } - - duplicate_sensitive = TRUE; - edit_sensitive = TRUE; - delete_sensitive = TRUE; - } - - gtk_widget_set_sensitive (list_view->raise_button, raise_sensitive); - gtk_widget_set_sensitive (list_view->lower_button, lower_sensitive); - gtk_widget_set_sensitive (list_view->duplicate_button, duplicate_sensitive); - gtk_widget_set_sensitive (list_view->edit_button, edit_sensitive); - gtk_widget_set_sensitive (list_view->delete_button, delete_sensitive); -} - -static void -gimp_drawable_list_view_activate_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) -{ - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->activate_item) - GIMP_CONTAINER_VIEW_CLASS (parent_class)->activate_item (view, - item, - insert_data); - - gtk_button_clicked (GTK_BUTTON (GIMP_DRAWABLE_LIST_VIEW (view)->edit_button)); -} - -static void -gimp_drawable_list_view_context_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) -{ - GimpDrawableListView *drawable_view; - - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->context_item) - GIMP_CONTAINER_VIEW_CLASS (parent_class)->context_item (view, - item, - insert_data); - - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); - - if (drawable_view->item_factory) - { - gimp_item_factory_popup_with_data (drawable_view->item_factory, - gimp_drawable_gimage (GIMP_DRAWABLE (item)), - NULL); - } -} - - -/* "New" functions */ - -static void -gimp_drawable_list_view_new_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - view->new_drawable_func (view->gimage, NULL); -} - -static void -gimp_drawable_list_view_new_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data) -{ - GimpDrawableListView *view; - - view = (GimpDrawableListView *) data; - - if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container, - GIMP_OBJECT (viewable))) - { - view->new_drawable_func (view->gimage, GIMP_DRAWABLE (viewable)); - } -} - - -/* "Duplicate" functions */ - -static void -gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - GimpDrawable *drawable; - GimpDrawable *new_drawable; - - drawable = view->get_drawable_func (view->gimage); - - new_drawable = view->copy_drawable_func (drawable, - G_TYPE_FROM_INSTANCE (drawable), - TRUE); - view->add_drawable_func (view->gimage, new_drawable, -1); - - gdisplays_flush (); -} - - -/* "Raise/Lower" functions */ - -static void -gimp_drawable_list_view_raise_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - GimpContainer *container; - GimpDrawable *drawable; - gint index; - - container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); - - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); - - if (index > 0) - { - view->reorder_drawable_func (view->gimage, drawable, index - 1, TRUE); - - gdisplays_flush (); - } -} - -static void -gimp_drawable_list_view_raise_extended_clicked (GtkWidget *widget, - guint state, - GimpDrawableListView *view) -{ - GimpContainer *container; - GimpDrawable *drawable; - gint index; - - container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); - - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); - - if ((state & GDK_SHIFT_MASK) && (index > 0)) - { - view->reorder_drawable_func (view->gimage, drawable, 0, TRUE); - - gdisplays_flush (); - } -} - -static void -gimp_drawable_list_view_lower_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - GimpContainer *container; - GimpDrawable *drawable; - gint index; - - container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); - - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); - - if (index < container->num_children - 1) - { - view->reorder_drawable_func (view->gimage, drawable, index + 1, TRUE); - - gdisplays_flush (); - } -} - -static void -gimp_drawable_list_view_lower_extended_clicked (GtkWidget *widget, - guint state, - GimpDrawableListView *view) -{ - GimpContainer *container; - GimpDrawable *drawable; - gint index; - - container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); - - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); - - if ((state & GDK_SHIFT_MASK) && (index < container->num_children - 1)) - { - view->reorder_drawable_func (view->gimage, drawable, - container->num_children - 1, TRUE); - - gdisplays_flush (); - } -} - - -/* "Edit" functions */ - -static void -gimp_drawable_list_view_edit_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - GimpDrawable *drawable; - - drawable = view->get_drawable_func (view->gimage); - - view->edit_drawable_func (drawable); -} - - -/* "Delete" functions */ - -static void -gimp_drawable_list_view_delete_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - GimpDrawable *drawable; - - drawable = view->get_drawable_func (view->gimage); - - view->remove_drawable_func (view->gimage, drawable); - - gdisplays_flush (); -} - - -/* GimpImage callbacks */ - -static void -gimp_drawable_list_view_drawable_changed (GimpImage *gimage, - GimpDrawableListView *view) -{ - GimpDrawable *drawable; - - drawable = view->get_drawable_func (gimage); - - gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view), - (GimpViewable *) drawable); -} - -static void -gimp_drawable_list_view_size_changed (GimpImage *gimage, - GimpDrawableListView *view) -{ - gint preview_size; - - preview_size = GIMP_CONTAINER_VIEW (view)->preview_size; - - gimp_container_view_set_preview_size (GIMP_CONTAINER_VIEW (view), - preview_size); } static void @@ -746,5 +171,5 @@ gimp_drawable_list_view_floating_selection_changed (GimpImage *gimage g_list_free (free_list); /* update button states */ - gimp_drawable_list_view_drawable_changed (gimage, view); + /* gimp_drawable_list_view_drawable_changed (gimage, view); */ } diff --git a/app/widgets/gimpdrawablelistview.h b/app/widgets/gimpdrawablelistview.h index 74cf856bf6..07a55c0d9b 100644 --- a/app/widgets/gimpdrawablelistview.h +++ b/app/widgets/gimpdrawablelistview.h @@ -23,31 +23,7 @@ #define __GIMP_DRAWABLE_LIST_VIEW_H__ -#include "gimpcontainerlistview.h" - - -typedef GimpContainer * (* GimpGetContainerFunc) (const GimpImage *gimage); -typedef GimpDrawable * (* GimpGetDrawableFunc) (const GimpImage *gimage); -typedef void (* GimpSetDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable); -typedef void (* GimpReorderDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable, - gint new_index, - gboolean push_undo); -typedef void (* GimpAddDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable, - gint index); -typedef void (* GimpRemoveDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable); -typedef GimpDrawable * (* GimpCopyDrawableFunc) (GimpDrawable *drawable, - GType new_type, - gboolean add_alpha); -typedef GimpDrawable * (* GimpConvertDrawableFunc) (GimpImage *dest_gimage, - GimpDrawable *drawable); - -typedef void (* GimpNewDrawableFunc) (GimpImage *gimage, - GimpDrawable *template); -typedef void (* GimpEditDrawableFunc) (GimpDrawable *drawable); +#include "gimpitemlistview.h" #define GIMP_TYPE_DRAWABLE_LIST_VIEW (gimp_drawable_list_view_get_type ()) @@ -62,64 +38,16 @@ typedef struct _GimpDrawableListViewClass GimpDrawableListViewClass; struct _GimpDrawableListView { - GimpContainerListView parent_instance; - - GimpImage *gimage; - - GType drawable_type; - gchar *signal_name; - - GimpGetContainerFunc get_container_func; - GimpGetDrawableFunc get_drawable_func; - GimpSetDrawableFunc set_drawable_func; - GimpReorderDrawableFunc reorder_drawable_func; - GimpAddDrawableFunc add_drawable_func; - GimpRemoveDrawableFunc remove_drawable_func; - GimpCopyDrawableFunc copy_drawable_func; - GimpConvertDrawableFunc convert_drawable_func; - - GimpNewDrawableFunc new_drawable_func; - GimpEditDrawableFunc edit_drawable_func; - - GimpItemFactory *item_factory; - - GtkWidget *new_button; - GtkWidget *raise_button; - GtkWidget *lower_button; - GtkWidget *duplicate_button; - GtkWidget *edit_button; - GtkWidget *delete_button; + GimpItemListView parent_instance; }; struct _GimpDrawableListViewClass { - GimpContainerListViewClass parent_class; - - void (* set_image) (GimpDrawableListView *view, - GimpImage *gimage); + GimpItemListViewClass parent_class; }; -GType gimp_drawable_list_view_get_type (void) G_GNUC_CONST; - -GtkWidget * gimp_drawable_list_view_new (gint preview_size, - GimpImage *gimage, - GType drawable_type, - const gchar *signal_name, - GimpGetContainerFunc get_container_func, - GimpGetDrawableFunc get_drawable_func, - GimpSetDrawableFunc set_drawable_func, - GimpReorderDrawableFunc reorder_drawable_func, - GimpAddDrawableFunc add_drawable_func, - GimpRemoveDrawableFunc remove_drawable_func, - GimpCopyDrawableFunc copy_drawable_func, - GimpConvertDrawableFunc convert_drawable_func, - GimpNewDrawableFunc new_drawable_func, - GimpEditDrawableFunc edit_drawable_func, - GimpItemFactory *item_facotry); - -void gimp_drawable_list_view_set_image (GimpDrawableListView *view, - GimpImage *gimage); +GType gimp_drawable_list_view_get_type (void) G_GNUC_CONST; #endif /* __GIMP_DRAWABLE_LIST_VIEW_H__ */ diff --git a/app/widgets/gimpdrawablepreview.c b/app/widgets/gimpdrawablepreview.c index 1606b81477..07f3c1faf4 100644 --- a/app/widgets/gimpdrawablepreview.c +++ b/app/widgets/gimpdrawablepreview.c @@ -107,7 +107,7 @@ gimp_drawable_preview_get_size (GimpPreview *preview, gboolean scaling_up; drawable = GIMP_DRAWABLE (preview->viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); if (gimage && ! preview->is_popup) { @@ -150,7 +150,7 @@ gimp_drawable_preview_render (GimpPreview *preview) TempBuf *render_buf; drawable = GIMP_DRAWABLE (preview->viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); width = preview->width; height = preview->height; @@ -271,7 +271,7 @@ gimp_drawable_preview_create_popup (GimpPreview *preview) gboolean scaling_up; drawable = GIMP_DRAWABLE (preview->viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); gimp_preview_calc_size (preview, drawable->width, diff --git a/app/widgets/gimpdrawabletreeview.c b/app/widgets/gimpdrawabletreeview.c index 48e6ab3928..ca98fe4e59 100644 --- a/app/widgets/gimpdrawabletreeview.c +++ b/app/widgets/gimpdrawabletreeview.c @@ -53,68 +53,18 @@ #include "libgimp/gimpintl.h" -enum -{ - SET_IMAGE, - LAST_SIGNAL -}; - - static void gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass); static void gimp_drawable_list_view_init (GimpDrawableListView *view); -static void gimp_drawable_list_view_destroy (GtkObject *object); -static void gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, - GimpImage *gimage); +static void gimp_drawable_list_view_set_image (GimpItemListView *view, + GimpImage *gimage); -static void gimp_drawable_list_view_select_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); -static void gimp_drawable_list_view_activate_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); -static void gimp_drawable_list_view_context_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); - -static void gimp_drawable_list_view_new_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_new_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data); - -static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_raise_extended_clicked - (GtkWidget *widget, - guint state, - GimpDrawableListView *view); -static void gimp_drawable_list_view_lower_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_lower_extended_clicked - (GtkWidget *widget, - guint state, - GimpDrawableListView *view); - -static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_edit_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_delete_clicked (GtkWidget *widget, - GimpDrawableListView *view); - -static void gimp_drawable_list_view_drawable_changed (GimpImage *gimage, - GimpDrawableListView *view); -static void gimp_drawable_list_view_size_changed (GimpImage *gimage, - GimpDrawableListView *view); static void gimp_drawable_list_view_floating_selection_changed - (GimpImage *gimage, - GimpDrawableListView *view); + (GimpImage *gimage, + GimpDrawableListView *view); -static guint view_signals[LAST_SIGNAL] = { 0 }; - -static GimpContainerListViewClass *parent_class = NULL; +static GimpItemListViewClass *parent_class = NULL; GType @@ -137,7 +87,7 @@ gimp_drawable_list_view_get_type (void) (GInstanceInitFunc) gimp_drawable_list_view_init, }; - view_type = g_type_register_static (GIMP_TYPE_CONTAINER_LIST_VIEW, + view_type = g_type_register_static (GIMP_TYPE_ITEM_LIST_VIEW, "GimpDrawableListView", &view_info, 0); } @@ -148,576 +98,51 @@ gimp_drawable_list_view_get_type (void) static void gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass) { - GtkObjectClass *object_class; - GimpContainerViewClass *container_view_class; + GimpItemListViewClass *item_view_class; - object_class = GTK_OBJECT_CLASS (klass); - container_view_class = GIMP_CONTAINER_VIEW_CLASS (klass); + item_view_class = GIMP_ITEM_LIST_VIEW_CLASS (klass); parent_class = g_type_class_peek_parent (klass); - view_signals[SET_IMAGE] = - g_signal_new ("set_image", - G_TYPE_FROM_CLASS (klass), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (GimpDrawableListViewClass, set_image), - NULL, NULL, - gimp_marshal_VOID__OBJECT, - G_TYPE_NONE, 1, - GIMP_TYPE_OBJECT); - - object_class->destroy = gimp_drawable_list_view_destroy; - - container_view_class->select_item = gimp_drawable_list_view_select_item; - container_view_class->activate_item = gimp_drawable_list_view_activate_item; - container_view_class->context_item = gimp_drawable_list_view_context_item; - - klass->set_image = gimp_drawable_list_view_real_set_image; + item_view_class->set_image = gimp_drawable_list_view_set_image; } static void gimp_drawable_list_view_init (GimpDrawableListView *view) { - GimpContainerView *container_view; - - container_view = GIMP_CONTAINER_VIEW (view); - - view->gimage = NULL; - view->drawable_type = G_TYPE_NONE; - view->signal_name = NULL; - - view->new_button = - gimp_container_view_add_button (container_view, - GTK_STOCK_NEW, - _("New"), NULL, - G_CALLBACK (gimp_drawable_list_view_new_clicked), - NULL, - view); - - view->raise_button = - gimp_container_view_add_button (container_view, - GTK_STOCK_GO_UP, - _("Raise\n" - " To Top"), NULL, - G_CALLBACK (gimp_drawable_list_view_raise_clicked), - G_CALLBACK (gimp_drawable_list_view_raise_extended_clicked), - view); - - view->lower_button = - gimp_container_view_add_button (container_view, - GTK_STOCK_GO_DOWN, - _("Lower\n" - " To Bottom"), NULL, - G_CALLBACK (gimp_drawable_list_view_lower_clicked), - G_CALLBACK (gimp_drawable_list_view_lower_extended_clicked), - view); - - view->duplicate_button = - gimp_container_view_add_button (container_view, - GIMP_STOCK_DUPLICATE, - _("Duplicate"), NULL, - G_CALLBACK (gimp_drawable_list_view_duplicate_clicked), - NULL, - view); - - view->edit_button = - gimp_container_view_add_button (container_view, - GIMP_STOCK_EDIT, - _("Edit"), NULL, - G_CALLBACK (gimp_drawable_list_view_edit_clicked), - NULL, - view); - - view->delete_button = - gimp_container_view_add_button (container_view, - GTK_STOCK_DELETE, - _("Delete"), NULL, - G_CALLBACK (gimp_drawable_list_view_delete_clicked), - NULL, - view); - - gtk_widget_set_sensitive (view->new_button, FALSE); - gtk_widget_set_sensitive (view->raise_button, FALSE); - gtk_widget_set_sensitive (view->lower_button, FALSE); - gtk_widget_set_sensitive (view->duplicate_button, FALSE); - gtk_widget_set_sensitive (view->edit_button, FALSE); - gtk_widget_set_sensitive (view->delete_button, FALSE); } static void -gimp_drawable_list_view_destroy (GtkObject *object) +gimp_drawable_list_view_set_image (GimpItemListView *item_view, + GimpImage *gimage) { GimpDrawableListView *view; - view = GIMP_DRAWABLE_LIST_VIEW (object); - - if (view->gimage) - gimp_drawable_list_view_set_image (view, NULL); - - if (view->signal_name) - { - g_free (view->signal_name); - view->signal_name = NULL; - } - - if (view->item_factory) - { - g_object_unref (G_OBJECT (view->item_factory)); - view->item_factory = NULL; - } - - if (GTK_OBJECT_CLASS (parent_class)->destroy) - GTK_OBJECT_CLASS (parent_class)->destroy (object); -} - -GtkWidget * -gimp_drawable_list_view_new (gint preview_size, - GimpImage *gimage, - GType drawable_type, - const gchar *signal_name, - GimpGetContainerFunc get_container_func, - GimpGetDrawableFunc get_drawable_func, - GimpSetDrawableFunc set_drawable_func, - GimpReorderDrawableFunc reorder_drawable_func, - GimpAddDrawableFunc add_drawable_func, - GimpRemoveDrawableFunc remove_drawable_func, - GimpCopyDrawableFunc copy_drawable_func, - GimpConvertDrawableFunc convert_drawable_func, - GimpNewDrawableFunc new_drawable_func, - GimpEditDrawableFunc edit_drawable_func, - GimpItemFactory *item_factory) -{ - GimpDrawableListView *list_view; - GimpContainerView *view; - - g_return_val_if_fail (preview_size > 0 && preview_size <= 64, NULL); - g_return_val_if_fail (! gimage || GIMP_IS_IMAGE (gimage), NULL); - g_return_val_if_fail (signal_name != NULL, NULL); - g_return_val_if_fail (get_container_func != NULL, NULL); - g_return_val_if_fail (get_drawable_func != NULL, NULL); - g_return_val_if_fail (get_drawable_func != NULL, NULL); - g_return_val_if_fail (reorder_drawable_func != NULL, NULL); - g_return_val_if_fail (add_drawable_func != NULL, NULL); - g_return_val_if_fail (remove_drawable_func != NULL, NULL); - g_return_val_if_fail (copy_drawable_func != NULL, NULL); - /* convert_drawable_func may be NULL */ - g_return_val_if_fail (new_drawable_func != NULL, NULL); - g_return_val_if_fail (edit_drawable_func != NULL, NULL); - g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), NULL); - - if (drawable_type == GIMP_TYPE_LAYER) - { - list_view = g_object_new (GIMP_TYPE_LAYER_LIST_VIEW, NULL); - } - else if (drawable_type == GIMP_TYPE_CHANNEL) - { - list_view = g_object_new (GIMP_TYPE_CHANNEL_LIST_VIEW, NULL); - } - else - { - list_view = g_object_new (GIMP_TYPE_DRAWABLE_LIST_VIEW, NULL); - } - - view = GIMP_CONTAINER_VIEW (list_view); - - view->preview_size = preview_size; - view->reorderable = TRUE; - - list_view->drawable_type = drawable_type; - list_view->signal_name = g_strdup (signal_name); - list_view->get_container_func = get_container_func; - list_view->get_drawable_func = get_drawable_func; - list_view->set_drawable_func = set_drawable_func; - list_view->reorder_drawable_func = reorder_drawable_func; - list_view->add_drawable_func = add_drawable_func; - list_view->remove_drawable_func = remove_drawable_func; - list_view->copy_drawable_func = copy_drawable_func; - list_view->convert_drawable_func = convert_drawable_func; - list_view->new_drawable_func = new_drawable_func; - list_view->edit_drawable_func = edit_drawable_func; - - list_view->item_factory = item_factory; - g_object_ref (G_OBJECT (list_view->item_factory)); - - /* connect "drop to new" manually as it makes a difference whether - * it was clicked or dropped - */ - gimp_gtk_drag_dest_set_by_type (list_view->new_button, - GTK_DEST_DEFAULT_ALL, - drawable_type, - GDK_ACTION_COPY); - gimp_dnd_viewable_dest_set (list_view->new_button, - drawable_type, - gimp_drawable_list_view_new_dropped, - view); - - gimp_container_view_enable_dnd (view, - GTK_BUTTON (list_view->duplicate_button), - drawable_type); - gimp_container_view_enable_dnd (view, - GTK_BUTTON (list_view->edit_button), - drawable_type); - gimp_container_view_enable_dnd (view, - GTK_BUTTON (list_view->delete_button), - drawable_type); - - gimp_drawable_list_view_set_image (list_view, gimage); - - return GTK_WIDGET (list_view); -} - -void -gimp_drawable_list_view_set_image (GimpDrawableListView *view, - GimpImage *gimage) -{ - g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (view)); + g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (item_view)); g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage)); - g_signal_emit (G_OBJECT (view), view_signals[SET_IMAGE], 0, - gimage); -} + view = GIMP_DRAWABLE_LIST_VIEW (item_view); -static void -gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, - GimpImage *gimage) -{ - g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (view)); - g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage)); - - if (view->gimage == gimage) - return; - - if (view->gimage) + if (item_view->gimage) { - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), - gimp_drawable_list_view_drawable_changed, - view); - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), - gimp_drawable_list_view_size_changed, - view); - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), + g_signal_handlers_disconnect_by_func (G_OBJECT (item_view->gimage), gimp_drawable_list_view_floating_selection_changed, view); - - gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), NULL); } - view->gimage = gimage; + GIMP_ITEM_LIST_VIEW_CLASS (parent_class)->set_image (item_view, gimage); - if (view->gimage) + if (item_view->gimage) { - GimpContainer *container; - - container = view->get_container_func (view->gimage); - - gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), container); - - g_signal_connect (G_OBJECT (view->gimage), view->signal_name, - G_CALLBACK (gimp_drawable_list_view_drawable_changed), - view); - g_signal_connect (G_OBJECT (view->gimage), "size_changed", - G_CALLBACK (gimp_drawable_list_view_size_changed), - view); - g_signal_connect (G_OBJECT (view->gimage), "floating_selection_changed", + g_signal_connect (G_OBJECT (item_view->gimage), + "floating_selection_changed", G_CALLBACK (gimp_drawable_list_view_floating_selection_changed), view); - gimp_drawable_list_view_drawable_changed (view->gimage, view); - - if (gimp_image_floating_sel (view->gimage)) - gimp_drawable_list_view_floating_selection_changed (view->gimage, view); + if (gimp_image_floating_sel (item_view->gimage)) + gimp_drawable_list_view_floating_selection_changed (item_view->gimage, + view); } - - gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL)); -} - - -/* GimpContainerView methods */ - -static void -gimp_drawable_list_view_select_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) -{ - GimpDrawableListView *list_view; - gboolean raise_sensitive = FALSE; - gboolean lower_sensitive = FALSE; - gboolean duplicate_sensitive = FALSE; - gboolean edit_sensitive = FALSE; - gboolean delete_sensitive = FALSE; - - list_view = GIMP_DRAWABLE_LIST_VIEW (view); - - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) - GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, - item, - insert_data); - - if (item) - { - GimpDrawable *drawable; - gint index; - - drawable = list_view->get_drawable_func (list_view->gimage); - - if (drawable != GIMP_DRAWABLE (item)) - { - list_view->set_drawable_func (list_view->gimage, - GIMP_DRAWABLE (item)); - - gdisplays_flush (); - } - - index = gimp_container_get_child_index (view->container, - GIMP_OBJECT (item)); - - if (view->container->num_children > 1) - { - if (index > 0) - raise_sensitive = TRUE; - - if (index < (view->container->num_children - 1)) - lower_sensitive = TRUE; - } - - duplicate_sensitive = TRUE; - edit_sensitive = TRUE; - delete_sensitive = TRUE; - } - - gtk_widget_set_sensitive (list_view->raise_button, raise_sensitive); - gtk_widget_set_sensitive (list_view->lower_button, lower_sensitive); - gtk_widget_set_sensitive (list_view->duplicate_button, duplicate_sensitive); - gtk_widget_set_sensitive (list_view->edit_button, edit_sensitive); - gtk_widget_set_sensitive (list_view->delete_button, delete_sensitive); -} - -static void -gimp_drawable_list_view_activate_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) -{ - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->activate_item) - GIMP_CONTAINER_VIEW_CLASS (parent_class)->activate_item (view, - item, - insert_data); - - gtk_button_clicked (GTK_BUTTON (GIMP_DRAWABLE_LIST_VIEW (view)->edit_button)); -} - -static void -gimp_drawable_list_view_context_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) -{ - GimpDrawableListView *drawable_view; - - if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->context_item) - GIMP_CONTAINER_VIEW_CLASS (parent_class)->context_item (view, - item, - insert_data); - - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); - - if (drawable_view->item_factory) - { - gimp_item_factory_popup_with_data (drawable_view->item_factory, - gimp_drawable_gimage (GIMP_DRAWABLE (item)), - NULL); - } -} - - -/* "New" functions */ - -static void -gimp_drawable_list_view_new_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - view->new_drawable_func (view->gimage, NULL); -} - -static void -gimp_drawable_list_view_new_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data) -{ - GimpDrawableListView *view; - - view = (GimpDrawableListView *) data; - - if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container, - GIMP_OBJECT (viewable))) - { - view->new_drawable_func (view->gimage, GIMP_DRAWABLE (viewable)); - } -} - - -/* "Duplicate" functions */ - -static void -gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - GimpDrawable *drawable; - GimpDrawable *new_drawable; - - drawable = view->get_drawable_func (view->gimage); - - new_drawable = view->copy_drawable_func (drawable, - G_TYPE_FROM_INSTANCE (drawable), - TRUE); - view->add_drawable_func (view->gimage, new_drawable, -1); - - gdisplays_flush (); -} - - -/* "Raise/Lower" functions */ - -static void -gimp_drawable_list_view_raise_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - GimpContainer *container; - GimpDrawable *drawable; - gint index; - - container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); - - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); - - if (index > 0) - { - view->reorder_drawable_func (view->gimage, drawable, index - 1, TRUE); - - gdisplays_flush (); - } -} - -static void -gimp_drawable_list_view_raise_extended_clicked (GtkWidget *widget, - guint state, - GimpDrawableListView *view) -{ - GimpContainer *container; - GimpDrawable *drawable; - gint index; - - container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); - - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); - - if ((state & GDK_SHIFT_MASK) && (index > 0)) - { - view->reorder_drawable_func (view->gimage, drawable, 0, TRUE); - - gdisplays_flush (); - } -} - -static void -gimp_drawable_list_view_lower_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - GimpContainer *container; - GimpDrawable *drawable; - gint index; - - container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); - - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); - - if (index < container->num_children - 1) - { - view->reorder_drawable_func (view->gimage, drawable, index + 1, TRUE); - - gdisplays_flush (); - } -} - -static void -gimp_drawable_list_view_lower_extended_clicked (GtkWidget *widget, - guint state, - GimpDrawableListView *view) -{ - GimpContainer *container; - GimpDrawable *drawable; - gint index; - - container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); - - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); - - if ((state & GDK_SHIFT_MASK) && (index < container->num_children - 1)) - { - view->reorder_drawable_func (view->gimage, drawable, - container->num_children - 1, TRUE); - - gdisplays_flush (); - } -} - - -/* "Edit" functions */ - -static void -gimp_drawable_list_view_edit_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - GimpDrawable *drawable; - - drawable = view->get_drawable_func (view->gimage); - - view->edit_drawable_func (drawable); -} - - -/* "Delete" functions */ - -static void -gimp_drawable_list_view_delete_clicked (GtkWidget *widget, - GimpDrawableListView *view) -{ - GimpDrawable *drawable; - - drawable = view->get_drawable_func (view->gimage); - - view->remove_drawable_func (view->gimage, drawable); - - gdisplays_flush (); -} - - -/* GimpImage callbacks */ - -static void -gimp_drawable_list_view_drawable_changed (GimpImage *gimage, - GimpDrawableListView *view) -{ - GimpDrawable *drawable; - - drawable = view->get_drawable_func (gimage); - - gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view), - (GimpViewable *) drawable); -} - -static void -gimp_drawable_list_view_size_changed (GimpImage *gimage, - GimpDrawableListView *view) -{ - gint preview_size; - - preview_size = GIMP_CONTAINER_VIEW (view)->preview_size; - - gimp_container_view_set_preview_size (GIMP_CONTAINER_VIEW (view), - preview_size); } static void @@ -746,5 +171,5 @@ gimp_drawable_list_view_floating_selection_changed (GimpImage *gimage g_list_free (free_list); /* update button states */ - gimp_drawable_list_view_drawable_changed (gimage, view); + /* gimp_drawable_list_view_drawable_changed (gimage, view); */ } diff --git a/app/widgets/gimpdrawabletreeview.h b/app/widgets/gimpdrawabletreeview.h index 74cf856bf6..07a55c0d9b 100644 --- a/app/widgets/gimpdrawabletreeview.h +++ b/app/widgets/gimpdrawabletreeview.h @@ -23,31 +23,7 @@ #define __GIMP_DRAWABLE_LIST_VIEW_H__ -#include "gimpcontainerlistview.h" - - -typedef GimpContainer * (* GimpGetContainerFunc) (const GimpImage *gimage); -typedef GimpDrawable * (* GimpGetDrawableFunc) (const GimpImage *gimage); -typedef void (* GimpSetDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable); -typedef void (* GimpReorderDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable, - gint new_index, - gboolean push_undo); -typedef void (* GimpAddDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable, - gint index); -typedef void (* GimpRemoveDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable); -typedef GimpDrawable * (* GimpCopyDrawableFunc) (GimpDrawable *drawable, - GType new_type, - gboolean add_alpha); -typedef GimpDrawable * (* GimpConvertDrawableFunc) (GimpImage *dest_gimage, - GimpDrawable *drawable); - -typedef void (* GimpNewDrawableFunc) (GimpImage *gimage, - GimpDrawable *template); -typedef void (* GimpEditDrawableFunc) (GimpDrawable *drawable); +#include "gimpitemlistview.h" #define GIMP_TYPE_DRAWABLE_LIST_VIEW (gimp_drawable_list_view_get_type ()) @@ -62,64 +38,16 @@ typedef struct _GimpDrawableListViewClass GimpDrawableListViewClass; struct _GimpDrawableListView { - GimpContainerListView parent_instance; - - GimpImage *gimage; - - GType drawable_type; - gchar *signal_name; - - GimpGetContainerFunc get_container_func; - GimpGetDrawableFunc get_drawable_func; - GimpSetDrawableFunc set_drawable_func; - GimpReorderDrawableFunc reorder_drawable_func; - GimpAddDrawableFunc add_drawable_func; - GimpRemoveDrawableFunc remove_drawable_func; - GimpCopyDrawableFunc copy_drawable_func; - GimpConvertDrawableFunc convert_drawable_func; - - GimpNewDrawableFunc new_drawable_func; - GimpEditDrawableFunc edit_drawable_func; - - GimpItemFactory *item_factory; - - GtkWidget *new_button; - GtkWidget *raise_button; - GtkWidget *lower_button; - GtkWidget *duplicate_button; - GtkWidget *edit_button; - GtkWidget *delete_button; + GimpItemListView parent_instance; }; struct _GimpDrawableListViewClass { - GimpContainerListViewClass parent_class; - - void (* set_image) (GimpDrawableListView *view, - GimpImage *gimage); + GimpItemListViewClass parent_class; }; -GType gimp_drawable_list_view_get_type (void) G_GNUC_CONST; - -GtkWidget * gimp_drawable_list_view_new (gint preview_size, - GimpImage *gimage, - GType drawable_type, - const gchar *signal_name, - GimpGetContainerFunc get_container_func, - GimpGetDrawableFunc get_drawable_func, - GimpSetDrawableFunc set_drawable_func, - GimpReorderDrawableFunc reorder_drawable_func, - GimpAddDrawableFunc add_drawable_func, - GimpRemoveDrawableFunc remove_drawable_func, - GimpCopyDrawableFunc copy_drawable_func, - GimpConvertDrawableFunc convert_drawable_func, - GimpNewDrawableFunc new_drawable_func, - GimpEditDrawableFunc edit_drawable_func, - GimpItemFactory *item_facotry); - -void gimp_drawable_list_view_set_image (GimpDrawableListView *view, - GimpImage *gimage); +GType gimp_drawable_list_view_get_type (void) G_GNUC_CONST; #endif /* __GIMP_DRAWABLE_LIST_VIEW_H__ */ diff --git a/app/widgets/gimpitemlistview.c b/app/widgets/gimpitemlistview.c index 48e6ab3928..c6ea6a62a0 100644 --- a/app/widgets/gimpitemlistview.c +++ b/app/widgets/gimpitemlistview.c @@ -1,7 +1,7 @@ /* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimpdrawablelistview.c + * gimpitemlistview.c * Copyright (C) 2001 Michael Natterer * * This program is free software; you can redistribute it and/or modify @@ -35,7 +35,6 @@ #include "core/gimpchannel.h" #include "core/gimpcontainer.h" -#include "core/gimpdrawable.h" #include "core/gimpimage.h" #include "core/gimplayer.h" #include "core/gimpmarshal.h" @@ -44,7 +43,7 @@ #include "gimpchannellistview.h" #include "gimpdnd.h" -#include "gimpdrawablelistview.h" +#include "gimpitemlistview.h" #include "gimpitemfactory.h" #include "gimplayerlistview.h" #include "gimplistitem.h" @@ -60,56 +59,53 @@ enum }; -static void gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass); -static void gimp_drawable_list_view_init (GimpDrawableListView *view); -static void gimp_drawable_list_view_destroy (GtkObject *object); +static void gimp_item_list_view_class_init (GimpItemListViewClass *klass); +static void gimp_item_list_view_init (GimpItemListView *view); +static void gimp_item_list_view_destroy (GtkObject *object); -static void gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, - GimpImage *gimage); +static void gimp_item_list_view_real_set_image (GimpItemListView *view, + GimpImage *gimage); -static void gimp_drawable_list_view_select_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); -static void gimp_drawable_list_view_activate_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); -static void gimp_drawable_list_view_context_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); +static void gimp_item_list_view_select_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data); +static void gimp_item_list_view_activate_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data); +static void gimp_item_list_view_context_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data); -static void gimp_drawable_list_view_new_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_new_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data); +static void gimp_item_list_view_new_clicked (GtkWidget *widget, + GimpItemListView *view); +static void gimp_item_list_view_new_dropped (GtkWidget *widget, + GimpViewable *viewable, + gpointer data); -static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_raise_extended_clicked - (GtkWidget *widget, - guint state, - GimpDrawableListView *view); -static void gimp_drawable_list_view_lower_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_lower_extended_clicked - (GtkWidget *widget, - guint state, - GimpDrawableListView *view); +static void gimp_item_list_view_raise_clicked (GtkWidget *widget, + GimpItemListView *view); +static void gimp_item_list_view_raise_extended_clicked + (GtkWidget *widget, + guint state, + GimpItemListView *view); +static void gimp_item_list_view_lower_clicked (GtkWidget *widget, + GimpItemListView *view); +static void gimp_item_list_view_lower_extended_clicked + (GtkWidget *widget, + guint state, + GimpItemListView *view); -static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_edit_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_delete_clicked (GtkWidget *widget, - GimpDrawableListView *view); +static void gimp_item_list_view_duplicate_clicked (GtkWidget *widget, + GimpItemListView *view); +static void gimp_item_list_view_edit_clicked (GtkWidget *widget, + GimpItemListView *view); +static void gimp_item_list_view_delete_clicked (GtkWidget *widget, + GimpItemListView *view); -static void gimp_drawable_list_view_drawable_changed (GimpImage *gimage, - GimpDrawableListView *view); -static void gimp_drawable_list_view_size_changed (GimpImage *gimage, - GimpDrawableListView *view); -static void gimp_drawable_list_view_floating_selection_changed - (GimpImage *gimage, - GimpDrawableListView *view); +static void gimp_item_list_view_item_changed (GimpImage *gimage, + GimpItemListView *view); +static void gimp_item_list_view_size_changed (GimpImage *gimage, + GimpItemListView *view); static guint view_signals[LAST_SIGNAL] = { 0 }; @@ -118,7 +114,7 @@ static GimpContainerListViewClass *parent_class = NULL; GType -gimp_drawable_list_view_get_type (void) +gimp_item_list_view_get_type (void) { static GType view_type = 0; @@ -126,19 +122,19 @@ gimp_drawable_list_view_get_type (void) { static const GTypeInfo view_info = { - sizeof (GimpDrawableListViewClass), + sizeof (GimpItemListViewClass), NULL, /* base_init */ NULL, /* base_finalize */ - (GClassInitFunc) gimp_drawable_list_view_class_init, + (GClassInitFunc) gimp_item_list_view_class_init, NULL, /* class_finalize */ NULL, /* class_data */ - sizeof (GimpDrawableListView), + sizeof (GimpItemListView), 0, /* n_preallocs */ - (GInstanceInitFunc) gimp_drawable_list_view_init, + (GInstanceInitFunc) gimp_item_list_view_init, }; view_type = g_type_register_static (GIMP_TYPE_CONTAINER_LIST_VIEW, - "GimpDrawableListView", + "GimpItemListView", &view_info, 0); } @@ -146,7 +142,7 @@ gimp_drawable_list_view_get_type (void) } static void -gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass) +gimp_item_list_view_class_init (GimpItemListViewClass *klass) { GtkObjectClass *object_class; GimpContainerViewClass *container_view_class; @@ -160,37 +156,37 @@ gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass) g_signal_new ("set_image", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (GimpDrawableListViewClass, set_image), + G_STRUCT_OFFSET (GimpItemListViewClass, set_image), NULL, NULL, gimp_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GIMP_TYPE_OBJECT); - object_class->destroy = gimp_drawable_list_view_destroy; + object_class->destroy = gimp_item_list_view_destroy; - container_view_class->select_item = gimp_drawable_list_view_select_item; - container_view_class->activate_item = gimp_drawable_list_view_activate_item; - container_view_class->context_item = gimp_drawable_list_view_context_item; + container_view_class->select_item = gimp_item_list_view_select_item; + container_view_class->activate_item = gimp_item_list_view_activate_item; + container_view_class->context_item = gimp_item_list_view_context_item; - klass->set_image = gimp_drawable_list_view_real_set_image; + klass->set_image = gimp_item_list_view_real_set_image; } static void -gimp_drawable_list_view_init (GimpDrawableListView *view) +gimp_item_list_view_init (GimpItemListView *view) { GimpContainerView *container_view; container_view = GIMP_CONTAINER_VIEW (view); view->gimage = NULL; - view->drawable_type = G_TYPE_NONE; + view->item_type = G_TYPE_NONE; view->signal_name = NULL; view->new_button = gimp_container_view_add_button (container_view, GTK_STOCK_NEW, _("New"), NULL, - G_CALLBACK (gimp_drawable_list_view_new_clicked), + G_CALLBACK (gimp_item_list_view_new_clicked), NULL, view); @@ -199,8 +195,8 @@ gimp_drawable_list_view_init (GimpDrawableListView *view) GTK_STOCK_GO_UP, _("Raise\n" " To Top"), NULL, - G_CALLBACK (gimp_drawable_list_view_raise_clicked), - G_CALLBACK (gimp_drawable_list_view_raise_extended_clicked), + G_CALLBACK (gimp_item_list_view_raise_clicked), + G_CALLBACK (gimp_item_list_view_raise_extended_clicked), view); view->lower_button = @@ -208,15 +204,15 @@ gimp_drawable_list_view_init (GimpDrawableListView *view) GTK_STOCK_GO_DOWN, _("Lower\n" " To Bottom"), NULL, - G_CALLBACK (gimp_drawable_list_view_lower_clicked), - G_CALLBACK (gimp_drawable_list_view_lower_extended_clicked), + G_CALLBACK (gimp_item_list_view_lower_clicked), + G_CALLBACK (gimp_item_list_view_lower_extended_clicked), view); view->duplicate_button = gimp_container_view_add_button (container_view, GIMP_STOCK_DUPLICATE, _("Duplicate"), NULL, - G_CALLBACK (gimp_drawable_list_view_duplicate_clicked), + G_CALLBACK (gimp_item_list_view_duplicate_clicked), NULL, view); @@ -224,7 +220,7 @@ gimp_drawable_list_view_init (GimpDrawableListView *view) gimp_container_view_add_button (container_view, GIMP_STOCK_EDIT, _("Edit"), NULL, - G_CALLBACK (gimp_drawable_list_view_edit_clicked), + G_CALLBACK (gimp_item_list_view_edit_clicked), NULL, view); @@ -232,7 +228,7 @@ gimp_drawable_list_view_init (GimpDrawableListView *view) gimp_container_view_add_button (container_view, GTK_STOCK_DELETE, _("Delete"), NULL, - G_CALLBACK (gimp_drawable_list_view_delete_clicked), + G_CALLBACK (gimp_item_list_view_delete_clicked), NULL, view); @@ -245,14 +241,14 @@ gimp_drawable_list_view_init (GimpDrawableListView *view) } static void -gimp_drawable_list_view_destroy (GtkObject *object) +gimp_item_list_view_destroy (GtkObject *object) { - GimpDrawableListView *view; + GimpItemListView *view; - view = GIMP_DRAWABLE_LIST_VIEW (object); + view = GIMP_ITEM_LIST_VIEW (object); if (view->gimage) - gimp_drawable_list_view_set_image (view, NULL); + gimp_item_list_view_set_image (view, NULL); if (view->signal_name) { @@ -271,51 +267,51 @@ gimp_drawable_list_view_destroy (GtkObject *object) } GtkWidget * -gimp_drawable_list_view_new (gint preview_size, - GimpImage *gimage, - GType drawable_type, - const gchar *signal_name, - GimpGetContainerFunc get_container_func, - GimpGetDrawableFunc get_drawable_func, - GimpSetDrawableFunc set_drawable_func, - GimpReorderDrawableFunc reorder_drawable_func, - GimpAddDrawableFunc add_drawable_func, - GimpRemoveDrawableFunc remove_drawable_func, - GimpCopyDrawableFunc copy_drawable_func, - GimpConvertDrawableFunc convert_drawable_func, - GimpNewDrawableFunc new_drawable_func, - GimpEditDrawableFunc edit_drawable_func, - GimpItemFactory *item_factory) +gimp_item_list_view_new (gint preview_size, + GimpImage *gimage, + GType item_type, + const gchar *signal_name, + GimpGetContainerFunc get_container_func, + GimpGetItemFunc get_item_func, + GimpSetItemFunc set_item_func, + GimpReorderItemFunc reorder_item_func, + GimpAddItemFunc add_item_func, + GimpRemoveItemFunc remove_item_func, + GimpCopyItemFunc copy_item_func, + GimpConvertItemFunc convert_item_func, + GimpNewItemFunc new_item_func, + GimpEditItemFunc edit_item_func, + GimpItemFactory *item_factory) { - GimpDrawableListView *list_view; - GimpContainerView *view; + GimpItemListView *list_view; + GimpContainerView *view; g_return_val_if_fail (preview_size > 0 && preview_size <= 64, NULL); g_return_val_if_fail (! gimage || GIMP_IS_IMAGE (gimage), NULL); g_return_val_if_fail (signal_name != NULL, NULL); g_return_val_if_fail (get_container_func != NULL, NULL); - g_return_val_if_fail (get_drawable_func != NULL, NULL); - g_return_val_if_fail (get_drawable_func != NULL, NULL); - g_return_val_if_fail (reorder_drawable_func != NULL, NULL); - g_return_val_if_fail (add_drawable_func != NULL, NULL); - g_return_val_if_fail (remove_drawable_func != NULL, NULL); - g_return_val_if_fail (copy_drawable_func != NULL, NULL); - /* convert_drawable_func may be NULL */ - g_return_val_if_fail (new_drawable_func != NULL, NULL); - g_return_val_if_fail (edit_drawable_func != NULL, NULL); + g_return_val_if_fail (get_item_func != NULL, NULL); + g_return_val_if_fail (get_item_func != NULL, NULL); + g_return_val_if_fail (reorder_item_func != NULL, NULL); + g_return_val_if_fail (add_item_func != NULL, NULL); + g_return_val_if_fail (remove_item_func != NULL, NULL); + g_return_val_if_fail (copy_item_func != NULL, NULL); + /* convert_item_func may be NULL */ + g_return_val_if_fail (new_item_func != NULL, NULL); + g_return_val_if_fail (edit_item_func != NULL, NULL); g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), NULL); - if (drawable_type == GIMP_TYPE_LAYER) + if (item_type == GIMP_TYPE_LAYER) { list_view = g_object_new (GIMP_TYPE_LAYER_LIST_VIEW, NULL); } - else if (drawable_type == GIMP_TYPE_CHANNEL) + else if (item_type == GIMP_TYPE_CHANNEL) { list_view = g_object_new (GIMP_TYPE_CHANNEL_LIST_VIEW, NULL); } else { - list_view = g_object_new (GIMP_TYPE_DRAWABLE_LIST_VIEW, NULL); + list_view = g_object_new (GIMP_TYPE_ITEM_LIST_VIEW, NULL); } view = GIMP_CONTAINER_VIEW (list_view); @@ -323,18 +319,18 @@ gimp_drawable_list_view_new (gint preview_size, view->preview_size = preview_size; view->reorderable = TRUE; - list_view->drawable_type = drawable_type; - list_view->signal_name = g_strdup (signal_name); - list_view->get_container_func = get_container_func; - list_view->get_drawable_func = get_drawable_func; - list_view->set_drawable_func = set_drawable_func; - list_view->reorder_drawable_func = reorder_drawable_func; - list_view->add_drawable_func = add_drawable_func; - list_view->remove_drawable_func = remove_drawable_func; - list_view->copy_drawable_func = copy_drawable_func; - list_view->convert_drawable_func = convert_drawable_func; - list_view->new_drawable_func = new_drawable_func; - list_view->edit_drawable_func = edit_drawable_func; + list_view->item_type = item_type; + list_view->signal_name = g_strdup (signal_name); + list_view->get_container_func = get_container_func; + list_view->get_item_func = get_item_func; + list_view->set_item_func = set_item_func; + list_view->reorder_item_func = reorder_item_func; + list_view->add_item_func = add_item_func; + list_view->remove_item_func = remove_item_func; + list_view->copy_item_func = copy_item_func; + list_view->convert_item_func = convert_item_func; + list_view->new_item_func = new_item_func; + list_view->edit_item_func = edit_item_func; list_view->item_factory = item_factory; g_object_ref (G_OBJECT (list_view->item_factory)); @@ -344,33 +340,33 @@ gimp_drawable_list_view_new (gint preview_size, */ gimp_gtk_drag_dest_set_by_type (list_view->new_button, GTK_DEST_DEFAULT_ALL, - drawable_type, + item_type, GDK_ACTION_COPY); gimp_dnd_viewable_dest_set (list_view->new_button, - drawable_type, - gimp_drawable_list_view_new_dropped, + item_type, + gimp_item_list_view_new_dropped, view); gimp_container_view_enable_dnd (view, GTK_BUTTON (list_view->duplicate_button), - drawable_type); + item_type); gimp_container_view_enable_dnd (view, GTK_BUTTON (list_view->edit_button), - drawable_type); + item_type); gimp_container_view_enable_dnd (view, GTK_BUTTON (list_view->delete_button), - drawable_type); + item_type); - gimp_drawable_list_view_set_image (list_view, gimage); + gimp_item_list_view_set_image (list_view, gimage); return GTK_WIDGET (list_view); } void -gimp_drawable_list_view_set_image (GimpDrawableListView *view, - GimpImage *gimage) +gimp_item_list_view_set_image (GimpItemListView *view, + GimpImage *gimage) { - g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (view)); + g_return_if_fail (GIMP_IS_ITEM_LIST_VIEW (view)); g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage)); g_signal_emit (G_OBJECT (view), view_signals[SET_IMAGE], 0, @@ -378,10 +374,10 @@ gimp_drawable_list_view_set_image (GimpDrawableListView *view, } static void -gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, - GimpImage *gimage) +gimp_item_list_view_real_set_image (GimpItemListView *view, + GimpImage *gimage) { - g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (view)); + g_return_if_fail (GIMP_IS_ITEM_LIST_VIEW (view)); g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage)); if (view->gimage == gimage) @@ -390,13 +386,10 @@ gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, if (view->gimage) { g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), - gimp_drawable_list_view_drawable_changed, + gimp_item_list_view_item_changed, view); g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), - gimp_drawable_list_view_size_changed, - view); - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), - gimp_drawable_list_view_floating_selection_changed, + gimp_item_list_view_size_changed, view); gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), NULL); @@ -413,19 +406,13 @@ gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), container); g_signal_connect (G_OBJECT (view->gimage), view->signal_name, - G_CALLBACK (gimp_drawable_list_view_drawable_changed), + G_CALLBACK (gimp_item_list_view_item_changed), view); g_signal_connect (G_OBJECT (view->gimage), "size_changed", - G_CALLBACK (gimp_drawable_list_view_size_changed), - view); - g_signal_connect (G_OBJECT (view->gimage), "floating_selection_changed", - G_CALLBACK (gimp_drawable_list_view_floating_selection_changed), + G_CALLBACK (gimp_item_list_view_size_changed), view); - gimp_drawable_list_view_drawable_changed (view->gimage, view); - - if (gimp_image_floating_sel (view->gimage)) - gimp_drawable_list_view_floating_selection_changed (view->gimage, view); + gimp_item_list_view_item_changed (view->gimage, view); } gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL)); @@ -435,18 +422,18 @@ gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, /* GimpContainerView methods */ static void -gimp_drawable_list_view_select_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) +gimp_item_list_view_select_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data) { - GimpDrawableListView *list_view; - gboolean raise_sensitive = FALSE; - gboolean lower_sensitive = FALSE; - gboolean duplicate_sensitive = FALSE; - gboolean edit_sensitive = FALSE; - gboolean delete_sensitive = FALSE; + GimpItemListView *list_view; + gboolean raise_sensitive = FALSE; + gboolean lower_sensitive = FALSE; + gboolean duplicate_sensitive = FALSE; + gboolean edit_sensitive = FALSE; + gboolean delete_sensitive = FALSE; - list_view = GIMP_DRAWABLE_LIST_VIEW (view); + list_view = GIMP_ITEM_LIST_VIEW (view); if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, @@ -455,15 +442,14 @@ gimp_drawable_list_view_select_item (GimpContainerView *view, if (item) { - GimpDrawable *drawable; - gint index; + GimpViewable *active_viewable; + gint index; - drawable = list_view->get_drawable_func (list_view->gimage); + active_viewable = list_view->get_item_func (list_view->gimage); - if (drawable != GIMP_DRAWABLE (item)) + if (active_viewable != item) { - list_view->set_drawable_func (list_view->gimage, - GIMP_DRAWABLE (item)); + list_view->set_item_func (list_view->gimage, item); gdisplays_flush (); } @@ -493,36 +479,40 @@ gimp_drawable_list_view_select_item (GimpContainerView *view, } static void -gimp_drawable_list_view_activate_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) +gimp_item_list_view_activate_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data) { if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->activate_item) GIMP_CONTAINER_VIEW_CLASS (parent_class)->activate_item (view, item, insert_data); - gtk_button_clicked (GTK_BUTTON (GIMP_DRAWABLE_LIST_VIEW (view)->edit_button)); + gtk_button_clicked (GTK_BUTTON (GIMP_ITEM_LIST_VIEW (view)->edit_button)); } static void -gimp_drawable_list_view_context_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) +gimp_item_list_view_context_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data) { - GimpDrawableListView *drawable_view; + GimpItemListView *item_view; if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->context_item) GIMP_CONTAINER_VIEW_CLASS (parent_class)->context_item (view, item, insert_data); - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - if (drawable_view->item_factory) + if (item_view->item_factory) { - gimp_item_factory_popup_with_data (drawable_view->item_factory, - gimp_drawable_gimage (GIMP_DRAWABLE (item)), + GimpImage *gimage; + + gimage = gimp_item_get_image (GIMP_ITEM (item)); + + gimp_item_factory_popup_with_data (item_view->item_factory, + gimage, NULL); } } @@ -531,25 +521,25 @@ gimp_drawable_list_view_context_item (GimpContainerView *view, /* "New" functions */ static void -gimp_drawable_list_view_new_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_new_clicked (GtkWidget *widget, + GimpItemListView *view) { - view->new_drawable_func (view->gimage, NULL); + view->new_item_func (view->gimage, NULL); } static void -gimp_drawable_list_view_new_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data) +gimp_item_list_view_new_dropped (GtkWidget *widget, + GimpViewable *viewable, + gpointer data) { - GimpDrawableListView *view; + GimpItemListView *view; - view = (GimpDrawableListView *) data; + view = (GimpItemListView *) data; if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container, GIMP_OBJECT (viewable))) { - view->new_drawable_func (view->gimage, GIMP_DRAWABLE (viewable)); + view->new_item_func (view->gimage, viewable); } } @@ -557,107 +547,111 @@ gimp_drawable_list_view_new_dropped (GtkWidget *widget, /* "Duplicate" functions */ static void -gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_duplicate_clicked (GtkWidget *widget, + GimpItemListView *view) { - GimpDrawable *drawable; - GimpDrawable *new_drawable; + GimpViewable *viewable; + GimpViewable *new_viewable; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - new_drawable = view->copy_drawable_func (drawable, - G_TYPE_FROM_INSTANCE (drawable), - TRUE); - view->add_drawable_func (view->gimage, new_drawable, -1); + new_viewable = view->copy_item_func (viewable, + G_TYPE_FROM_INSTANCE (viewable), + TRUE); - gdisplays_flush (); + if (GIMP_IS_VIEWABLE (new_viewable)) + { + view->add_item_func (view->gimage, new_viewable, -1); + + gdisplays_flush (); + } } /* "Raise/Lower" functions */ static void -gimp_drawable_list_view_raise_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_raise_clicked (GtkWidget *widget, + GimpItemListView *view) { GimpContainer *container; - GimpDrawable *drawable; + GimpViewable *viewable; gint index; container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); + index = gimp_container_get_child_index (container, GIMP_OBJECT (viewable)); if (index > 0) { - view->reorder_drawable_func (view->gimage, drawable, index - 1, TRUE); + view->reorder_item_func (view->gimage, viewable, index - 1, TRUE); gdisplays_flush (); } } static void -gimp_drawable_list_view_raise_extended_clicked (GtkWidget *widget, - guint state, - GimpDrawableListView *view) +gimp_item_list_view_raise_extended_clicked (GtkWidget *widget, + guint state, + GimpItemListView *view) { GimpContainer *container; - GimpDrawable *drawable; + GimpViewable *viewable; gint index; container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); + index = gimp_container_get_child_index (container, GIMP_OBJECT (viewable)); if ((state & GDK_SHIFT_MASK) && (index > 0)) { - view->reorder_drawable_func (view->gimage, drawable, 0, TRUE); + view->reorder_item_func (view->gimage, viewable, 0, TRUE); gdisplays_flush (); } } static void -gimp_drawable_list_view_lower_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_lower_clicked (GtkWidget *widget, + GimpItemListView *view) { GimpContainer *container; - GimpDrawable *drawable; + GimpViewable *viewable; gint index; container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); + index = gimp_container_get_child_index (container, GIMP_OBJECT (viewable)); if (index < container->num_children - 1) { - view->reorder_drawable_func (view->gimage, drawable, index + 1, TRUE); + view->reorder_item_func (view->gimage, viewable, index + 1, TRUE); gdisplays_flush (); } } static void -gimp_drawable_list_view_lower_extended_clicked (GtkWidget *widget, - guint state, - GimpDrawableListView *view) +gimp_item_list_view_lower_extended_clicked (GtkWidget *widget, + guint state, + GimpItemListView *view) { GimpContainer *container; - GimpDrawable *drawable; + GimpViewable *viewable; gint index; container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); + index = gimp_container_get_child_index (container, GIMP_OBJECT (viewable)); if ((state & GDK_SHIFT_MASK) && (index < container->num_children - 1)) { - view->reorder_drawable_func (view->gimage, drawable, - container->num_children - 1, TRUE); + view->reorder_item_func (view->gimage, viewable, + container->num_children - 1, TRUE); gdisplays_flush (); } @@ -667,28 +661,28 @@ gimp_drawable_list_view_lower_extended_clicked (GtkWidget *widget, /* "Edit" functions */ static void -gimp_drawable_list_view_edit_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_edit_clicked (GtkWidget *widget, + GimpItemListView *view) { - GimpDrawable *drawable; + GimpViewable *viewable; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - view->edit_drawable_func (drawable); + view->edit_item_func (viewable); } /* "Delete" functions */ static void -gimp_drawable_list_view_delete_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_delete_clicked (GtkWidget *widget, + GimpItemListView *view) { - GimpDrawable *drawable; + GimpViewable *viewable; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - view->remove_drawable_func (view->gimage, drawable); + view->remove_item_func (view->gimage, viewable); gdisplays_flush (); } @@ -697,20 +691,19 @@ gimp_drawable_list_view_delete_clicked (GtkWidget *widget, /* GimpImage callbacks */ static void -gimp_drawable_list_view_drawable_changed (GimpImage *gimage, - GimpDrawableListView *view) +gimp_item_list_view_item_changed (GimpImage *gimage, + GimpItemListView *view) { - GimpDrawable *drawable; + GimpViewable *viewable; - drawable = view->get_drawable_func (gimage); + viewable = view->get_item_func (gimage); - gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view), - (GimpViewable *) drawable); + gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view), viewable); } static void -gimp_drawable_list_view_size_changed (GimpImage *gimage, - GimpDrawableListView *view) +gimp_item_list_view_size_changed (GimpImage *gimage, + GimpItemListView *view) { gint preview_size; @@ -719,32 +712,3 @@ gimp_drawable_list_view_size_changed (GimpImage *gimage, gimp_container_view_set_preview_size (GIMP_CONTAINER_VIEW (view), preview_size); } - -static void -gimp_drawable_list_view_floating_selection_changed (GimpImage *gimage, - GimpDrawableListView *view) -{ - GimpViewable *floating_sel; - GList *list; - GList *free_list; - - floating_sel = (GimpViewable *) gimp_image_floating_sel (gimage); - - list = free_list = gtk_container_get_children - (GTK_CONTAINER (GIMP_CONTAINER_LIST_VIEW (view)->gtk_list)); - - for (; list; list = g_list_next (list)) - { - if (! (GIMP_PREVIEW (GIMP_LIST_ITEM (list->data)->preview)->viewable == - floating_sel)) - { - gtk_widget_set_sensitive (GTK_WIDGET (list->data), - floating_sel == NULL); - } - } - - g_list_free (free_list); - - /* update button states */ - gimp_drawable_list_view_drawable_changed (gimage, view); -} diff --git a/app/widgets/gimpitemlistview.h b/app/widgets/gimpitemlistview.h index 74cf856bf6..7083c4f32b 100644 --- a/app/widgets/gimpitemlistview.h +++ b/app/widgets/gimpitemlistview.h @@ -1,7 +1,7 @@ /* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimpdrawablelistview.h + * gimpitemlistview.h * Copyright (C) 2001 Michael Natterer * * This program is free software; you can redistribute it and/or modify @@ -19,107 +19,107 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#ifndef __GIMP_DRAWABLE_LIST_VIEW_H__ -#define __GIMP_DRAWABLE_LIST_VIEW_H__ +#ifndef __GIMP_ITEM_LIST_VIEW_H__ +#define __GIMP_ITEM_LIST_VIEW_H__ #include "gimpcontainerlistview.h" -typedef GimpContainer * (* GimpGetContainerFunc) (const GimpImage *gimage); -typedef GimpDrawable * (* GimpGetDrawableFunc) (const GimpImage *gimage); -typedef void (* GimpSetDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable); -typedef void (* GimpReorderDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable, - gint new_index, - gboolean push_undo); -typedef void (* GimpAddDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable, - gint index); -typedef void (* GimpRemoveDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable); -typedef GimpDrawable * (* GimpCopyDrawableFunc) (GimpDrawable *drawable, - GType new_type, - gboolean add_alpha); -typedef GimpDrawable * (* GimpConvertDrawableFunc) (GimpImage *dest_gimage, - GimpDrawable *drawable); +typedef GimpContainer * (* GimpGetContainerFunc) (const GimpImage *gimage); +typedef GimpViewable * (* GimpGetItemFunc) (const GimpImage *gimage); +typedef void (* GimpSetItemFunc) (GimpImage *gimage, + GimpViewable *viewable); +typedef void (* GimpReorderItemFunc) (GimpImage *gimage, + GimpViewable *viewable, + gint new_index, + gboolean push_undo); +typedef void (* GimpAddItemFunc) (GimpImage *gimage, + GimpViewable *viewable, + gint index); +typedef void (* GimpRemoveItemFunc) (GimpImage *gimage, + GimpViewable *viewable); +typedef GimpViewable * (* GimpCopyItemFunc) (GimpViewable *viewable, + GType new_type, + gboolean add_alpha); +typedef GimpViewable * (* GimpConvertItemFunc) (GimpViewable *viewable, + GimpImage *dest_gimage); -typedef void (* GimpNewDrawableFunc) (GimpImage *gimage, - GimpDrawable *template); -typedef void (* GimpEditDrawableFunc) (GimpDrawable *drawable); +typedef void (* GimpNewItemFunc) (GimpImage *gimage, + GimpViewable *template); +typedef void (* GimpEditItemFunc) (GimpViewable *viewable); -#define GIMP_TYPE_DRAWABLE_LIST_VIEW (gimp_drawable_list_view_get_type ()) -#define GIMP_DRAWABLE_LIST_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DRAWABLE_LIST_VIEW, GimpDrawableListView)) -#define GIMP_DRAWABLE_LIST_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DRAWABLE_LIST_VIEW, GimpDrawableListViewClass)) -#define GIMP_IS_DRAWABLE_LIST_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DRAWABLE_LIST_VIEW)) -#define GIMP_IS_DRAWABLE_LIST_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DRAWABLE_LIST_VIEW)) -#define GIMP_DRAWABLE_LIST_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DRAWABLE_LIST_VIEW, GimpDrawableListViewClass)) +#define GIMP_TYPE_ITEM_LIST_VIEW (gimp_item_list_view_get_type ()) +#define GIMP_ITEM_LIST_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_ITEM_LIST_VIEW, GimpItemListView)) +#define GIMP_ITEM_LIST_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_ITEM_LIST_VIEW, GimpItemListViewClass)) +#define GIMP_IS_ITEM_LIST_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_ITEM_LIST_VIEW)) +#define GIMP_IS_ITEM_LIST_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_ITEM_LIST_VIEW)) +#define GIMP_ITEM_LIST_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_ITEM_LIST_VIEW, GimpItemListViewClass)) -typedef struct _GimpDrawableListViewClass GimpDrawableListViewClass; +typedef struct _GimpItemListViewClass GimpItemListViewClass; -struct _GimpDrawableListView +struct _GimpItemListView { - GimpContainerListView parent_instance; + GimpContainerListView parent_instance; - GimpImage *gimage; + GimpImage *gimage; - GType drawable_type; - gchar *signal_name; + GType item_type; + gchar *signal_name; - GimpGetContainerFunc get_container_func; - GimpGetDrawableFunc get_drawable_func; - GimpSetDrawableFunc set_drawable_func; - GimpReorderDrawableFunc reorder_drawable_func; - GimpAddDrawableFunc add_drawable_func; - GimpRemoveDrawableFunc remove_drawable_func; - GimpCopyDrawableFunc copy_drawable_func; - GimpConvertDrawableFunc convert_drawable_func; + GimpGetContainerFunc get_container_func; + GimpGetItemFunc get_item_func; + GimpSetItemFunc set_item_func; + GimpReorderItemFunc reorder_item_func; + GimpAddItemFunc add_item_func; + GimpRemoveItemFunc remove_item_func; + GimpCopyItemFunc copy_item_func; + GimpConvertItemFunc convert_item_func; - GimpNewDrawableFunc new_drawable_func; - GimpEditDrawableFunc edit_drawable_func; + GimpNewItemFunc new_item_func; + GimpEditItemFunc edit_item_func; - GimpItemFactory *item_factory; + GimpItemFactory *item_factory; - GtkWidget *new_button; - GtkWidget *raise_button; - GtkWidget *lower_button; - GtkWidget *duplicate_button; - GtkWidget *edit_button; - GtkWidget *delete_button; + GtkWidget *new_button; + GtkWidget *raise_button; + GtkWidget *lower_button; + GtkWidget *duplicate_button; + GtkWidget *edit_button; + GtkWidget *delete_button; }; -struct _GimpDrawableListViewClass +struct _GimpItemListViewClass { GimpContainerListViewClass parent_class; - void (* set_image) (GimpDrawableListView *view, - GimpImage *gimage); + void (* set_image) (GimpItemListView *view, + GimpImage *gimage); }; -GType gimp_drawable_list_view_get_type (void) G_GNUC_CONST; +GType gimp_item_list_view_get_type (void) G_GNUC_CONST; -GtkWidget * gimp_drawable_list_view_new (gint preview_size, - GimpImage *gimage, - GType drawable_type, - const gchar *signal_name, - GimpGetContainerFunc get_container_func, - GimpGetDrawableFunc get_drawable_func, - GimpSetDrawableFunc set_drawable_func, - GimpReorderDrawableFunc reorder_drawable_func, - GimpAddDrawableFunc add_drawable_func, - GimpRemoveDrawableFunc remove_drawable_func, - GimpCopyDrawableFunc copy_drawable_func, - GimpConvertDrawableFunc convert_drawable_func, - GimpNewDrawableFunc new_drawable_func, - GimpEditDrawableFunc edit_drawable_func, - GimpItemFactory *item_facotry); +GtkWidget * gimp_item_list_view_new (gint preview_size, + GimpImage *gimage, + GType item_type, + const gchar *signal_name, + GimpGetContainerFunc get_container_func, + GimpGetItemFunc get_item_func, + GimpSetItemFunc set_item_func, + GimpReorderItemFunc reorder_item_func, + GimpAddItemFunc add_item_func, + GimpRemoveItemFunc remove_item_func, + GimpCopyItemFunc copy_item_func, + GimpConvertItemFunc convert_item_func, + GimpNewItemFunc new_item_func, + GimpEditItemFunc edit_item_func, + GimpItemFactory *item_facotry); -void gimp_drawable_list_view_set_image (GimpDrawableListView *view, - GimpImage *gimage); +void gimp_item_list_view_set_image (GimpItemListView *view, + GimpImage *gimage); -#endif /* __GIMP_DRAWABLE_LIST_VIEW_H__ */ +#endif /* __GIMP_ITEM_LIST_VIEW_H__ */ diff --git a/app/widgets/gimpitemtreeview.c b/app/widgets/gimpitemtreeview.c index 48e6ab3928..c6ea6a62a0 100644 --- a/app/widgets/gimpitemtreeview.c +++ b/app/widgets/gimpitemtreeview.c @@ -1,7 +1,7 @@ /* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimpdrawablelistview.c + * gimpitemlistview.c * Copyright (C) 2001 Michael Natterer * * This program is free software; you can redistribute it and/or modify @@ -35,7 +35,6 @@ #include "core/gimpchannel.h" #include "core/gimpcontainer.h" -#include "core/gimpdrawable.h" #include "core/gimpimage.h" #include "core/gimplayer.h" #include "core/gimpmarshal.h" @@ -44,7 +43,7 @@ #include "gimpchannellistview.h" #include "gimpdnd.h" -#include "gimpdrawablelistview.h" +#include "gimpitemlistview.h" #include "gimpitemfactory.h" #include "gimplayerlistview.h" #include "gimplistitem.h" @@ -60,56 +59,53 @@ enum }; -static void gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass); -static void gimp_drawable_list_view_init (GimpDrawableListView *view); -static void gimp_drawable_list_view_destroy (GtkObject *object); +static void gimp_item_list_view_class_init (GimpItemListViewClass *klass); +static void gimp_item_list_view_init (GimpItemListView *view); +static void gimp_item_list_view_destroy (GtkObject *object); -static void gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, - GimpImage *gimage); +static void gimp_item_list_view_real_set_image (GimpItemListView *view, + GimpImage *gimage); -static void gimp_drawable_list_view_select_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); -static void gimp_drawable_list_view_activate_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); -static void gimp_drawable_list_view_context_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data); +static void gimp_item_list_view_select_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data); +static void gimp_item_list_view_activate_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data); +static void gimp_item_list_view_context_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data); -static void gimp_drawable_list_view_new_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_new_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data); +static void gimp_item_list_view_new_clicked (GtkWidget *widget, + GimpItemListView *view); +static void gimp_item_list_view_new_dropped (GtkWidget *widget, + GimpViewable *viewable, + gpointer data); -static void gimp_drawable_list_view_raise_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_raise_extended_clicked - (GtkWidget *widget, - guint state, - GimpDrawableListView *view); -static void gimp_drawable_list_view_lower_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_lower_extended_clicked - (GtkWidget *widget, - guint state, - GimpDrawableListView *view); +static void gimp_item_list_view_raise_clicked (GtkWidget *widget, + GimpItemListView *view); +static void gimp_item_list_view_raise_extended_clicked + (GtkWidget *widget, + guint state, + GimpItemListView *view); +static void gimp_item_list_view_lower_clicked (GtkWidget *widget, + GimpItemListView *view); +static void gimp_item_list_view_lower_extended_clicked + (GtkWidget *widget, + guint state, + GimpItemListView *view); -static void gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_edit_clicked (GtkWidget *widget, - GimpDrawableListView *view); -static void gimp_drawable_list_view_delete_clicked (GtkWidget *widget, - GimpDrawableListView *view); +static void gimp_item_list_view_duplicate_clicked (GtkWidget *widget, + GimpItemListView *view); +static void gimp_item_list_view_edit_clicked (GtkWidget *widget, + GimpItemListView *view); +static void gimp_item_list_view_delete_clicked (GtkWidget *widget, + GimpItemListView *view); -static void gimp_drawable_list_view_drawable_changed (GimpImage *gimage, - GimpDrawableListView *view); -static void gimp_drawable_list_view_size_changed (GimpImage *gimage, - GimpDrawableListView *view); -static void gimp_drawable_list_view_floating_selection_changed - (GimpImage *gimage, - GimpDrawableListView *view); +static void gimp_item_list_view_item_changed (GimpImage *gimage, + GimpItemListView *view); +static void gimp_item_list_view_size_changed (GimpImage *gimage, + GimpItemListView *view); static guint view_signals[LAST_SIGNAL] = { 0 }; @@ -118,7 +114,7 @@ static GimpContainerListViewClass *parent_class = NULL; GType -gimp_drawable_list_view_get_type (void) +gimp_item_list_view_get_type (void) { static GType view_type = 0; @@ -126,19 +122,19 @@ gimp_drawable_list_view_get_type (void) { static const GTypeInfo view_info = { - sizeof (GimpDrawableListViewClass), + sizeof (GimpItemListViewClass), NULL, /* base_init */ NULL, /* base_finalize */ - (GClassInitFunc) gimp_drawable_list_view_class_init, + (GClassInitFunc) gimp_item_list_view_class_init, NULL, /* class_finalize */ NULL, /* class_data */ - sizeof (GimpDrawableListView), + sizeof (GimpItemListView), 0, /* n_preallocs */ - (GInstanceInitFunc) gimp_drawable_list_view_init, + (GInstanceInitFunc) gimp_item_list_view_init, }; view_type = g_type_register_static (GIMP_TYPE_CONTAINER_LIST_VIEW, - "GimpDrawableListView", + "GimpItemListView", &view_info, 0); } @@ -146,7 +142,7 @@ gimp_drawable_list_view_get_type (void) } static void -gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass) +gimp_item_list_view_class_init (GimpItemListViewClass *klass) { GtkObjectClass *object_class; GimpContainerViewClass *container_view_class; @@ -160,37 +156,37 @@ gimp_drawable_list_view_class_init (GimpDrawableListViewClass *klass) g_signal_new ("set_image", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (GimpDrawableListViewClass, set_image), + G_STRUCT_OFFSET (GimpItemListViewClass, set_image), NULL, NULL, gimp_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GIMP_TYPE_OBJECT); - object_class->destroy = gimp_drawable_list_view_destroy; + object_class->destroy = gimp_item_list_view_destroy; - container_view_class->select_item = gimp_drawable_list_view_select_item; - container_view_class->activate_item = gimp_drawable_list_view_activate_item; - container_view_class->context_item = gimp_drawable_list_view_context_item; + container_view_class->select_item = gimp_item_list_view_select_item; + container_view_class->activate_item = gimp_item_list_view_activate_item; + container_view_class->context_item = gimp_item_list_view_context_item; - klass->set_image = gimp_drawable_list_view_real_set_image; + klass->set_image = gimp_item_list_view_real_set_image; } static void -gimp_drawable_list_view_init (GimpDrawableListView *view) +gimp_item_list_view_init (GimpItemListView *view) { GimpContainerView *container_view; container_view = GIMP_CONTAINER_VIEW (view); view->gimage = NULL; - view->drawable_type = G_TYPE_NONE; + view->item_type = G_TYPE_NONE; view->signal_name = NULL; view->new_button = gimp_container_view_add_button (container_view, GTK_STOCK_NEW, _("New"), NULL, - G_CALLBACK (gimp_drawable_list_view_new_clicked), + G_CALLBACK (gimp_item_list_view_new_clicked), NULL, view); @@ -199,8 +195,8 @@ gimp_drawable_list_view_init (GimpDrawableListView *view) GTK_STOCK_GO_UP, _("Raise\n" " To Top"), NULL, - G_CALLBACK (gimp_drawable_list_view_raise_clicked), - G_CALLBACK (gimp_drawable_list_view_raise_extended_clicked), + G_CALLBACK (gimp_item_list_view_raise_clicked), + G_CALLBACK (gimp_item_list_view_raise_extended_clicked), view); view->lower_button = @@ -208,15 +204,15 @@ gimp_drawable_list_view_init (GimpDrawableListView *view) GTK_STOCK_GO_DOWN, _("Lower\n" " To Bottom"), NULL, - G_CALLBACK (gimp_drawable_list_view_lower_clicked), - G_CALLBACK (gimp_drawable_list_view_lower_extended_clicked), + G_CALLBACK (gimp_item_list_view_lower_clicked), + G_CALLBACK (gimp_item_list_view_lower_extended_clicked), view); view->duplicate_button = gimp_container_view_add_button (container_view, GIMP_STOCK_DUPLICATE, _("Duplicate"), NULL, - G_CALLBACK (gimp_drawable_list_view_duplicate_clicked), + G_CALLBACK (gimp_item_list_view_duplicate_clicked), NULL, view); @@ -224,7 +220,7 @@ gimp_drawable_list_view_init (GimpDrawableListView *view) gimp_container_view_add_button (container_view, GIMP_STOCK_EDIT, _("Edit"), NULL, - G_CALLBACK (gimp_drawable_list_view_edit_clicked), + G_CALLBACK (gimp_item_list_view_edit_clicked), NULL, view); @@ -232,7 +228,7 @@ gimp_drawable_list_view_init (GimpDrawableListView *view) gimp_container_view_add_button (container_view, GTK_STOCK_DELETE, _("Delete"), NULL, - G_CALLBACK (gimp_drawable_list_view_delete_clicked), + G_CALLBACK (gimp_item_list_view_delete_clicked), NULL, view); @@ -245,14 +241,14 @@ gimp_drawable_list_view_init (GimpDrawableListView *view) } static void -gimp_drawable_list_view_destroy (GtkObject *object) +gimp_item_list_view_destroy (GtkObject *object) { - GimpDrawableListView *view; + GimpItemListView *view; - view = GIMP_DRAWABLE_LIST_VIEW (object); + view = GIMP_ITEM_LIST_VIEW (object); if (view->gimage) - gimp_drawable_list_view_set_image (view, NULL); + gimp_item_list_view_set_image (view, NULL); if (view->signal_name) { @@ -271,51 +267,51 @@ gimp_drawable_list_view_destroy (GtkObject *object) } GtkWidget * -gimp_drawable_list_view_new (gint preview_size, - GimpImage *gimage, - GType drawable_type, - const gchar *signal_name, - GimpGetContainerFunc get_container_func, - GimpGetDrawableFunc get_drawable_func, - GimpSetDrawableFunc set_drawable_func, - GimpReorderDrawableFunc reorder_drawable_func, - GimpAddDrawableFunc add_drawable_func, - GimpRemoveDrawableFunc remove_drawable_func, - GimpCopyDrawableFunc copy_drawable_func, - GimpConvertDrawableFunc convert_drawable_func, - GimpNewDrawableFunc new_drawable_func, - GimpEditDrawableFunc edit_drawable_func, - GimpItemFactory *item_factory) +gimp_item_list_view_new (gint preview_size, + GimpImage *gimage, + GType item_type, + const gchar *signal_name, + GimpGetContainerFunc get_container_func, + GimpGetItemFunc get_item_func, + GimpSetItemFunc set_item_func, + GimpReorderItemFunc reorder_item_func, + GimpAddItemFunc add_item_func, + GimpRemoveItemFunc remove_item_func, + GimpCopyItemFunc copy_item_func, + GimpConvertItemFunc convert_item_func, + GimpNewItemFunc new_item_func, + GimpEditItemFunc edit_item_func, + GimpItemFactory *item_factory) { - GimpDrawableListView *list_view; - GimpContainerView *view; + GimpItemListView *list_view; + GimpContainerView *view; g_return_val_if_fail (preview_size > 0 && preview_size <= 64, NULL); g_return_val_if_fail (! gimage || GIMP_IS_IMAGE (gimage), NULL); g_return_val_if_fail (signal_name != NULL, NULL); g_return_val_if_fail (get_container_func != NULL, NULL); - g_return_val_if_fail (get_drawable_func != NULL, NULL); - g_return_val_if_fail (get_drawable_func != NULL, NULL); - g_return_val_if_fail (reorder_drawable_func != NULL, NULL); - g_return_val_if_fail (add_drawable_func != NULL, NULL); - g_return_val_if_fail (remove_drawable_func != NULL, NULL); - g_return_val_if_fail (copy_drawable_func != NULL, NULL); - /* convert_drawable_func may be NULL */ - g_return_val_if_fail (new_drawable_func != NULL, NULL); - g_return_val_if_fail (edit_drawable_func != NULL, NULL); + g_return_val_if_fail (get_item_func != NULL, NULL); + g_return_val_if_fail (get_item_func != NULL, NULL); + g_return_val_if_fail (reorder_item_func != NULL, NULL); + g_return_val_if_fail (add_item_func != NULL, NULL); + g_return_val_if_fail (remove_item_func != NULL, NULL); + g_return_val_if_fail (copy_item_func != NULL, NULL); + /* convert_item_func may be NULL */ + g_return_val_if_fail (new_item_func != NULL, NULL); + g_return_val_if_fail (edit_item_func != NULL, NULL); g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), NULL); - if (drawable_type == GIMP_TYPE_LAYER) + if (item_type == GIMP_TYPE_LAYER) { list_view = g_object_new (GIMP_TYPE_LAYER_LIST_VIEW, NULL); } - else if (drawable_type == GIMP_TYPE_CHANNEL) + else if (item_type == GIMP_TYPE_CHANNEL) { list_view = g_object_new (GIMP_TYPE_CHANNEL_LIST_VIEW, NULL); } else { - list_view = g_object_new (GIMP_TYPE_DRAWABLE_LIST_VIEW, NULL); + list_view = g_object_new (GIMP_TYPE_ITEM_LIST_VIEW, NULL); } view = GIMP_CONTAINER_VIEW (list_view); @@ -323,18 +319,18 @@ gimp_drawable_list_view_new (gint preview_size, view->preview_size = preview_size; view->reorderable = TRUE; - list_view->drawable_type = drawable_type; - list_view->signal_name = g_strdup (signal_name); - list_view->get_container_func = get_container_func; - list_view->get_drawable_func = get_drawable_func; - list_view->set_drawable_func = set_drawable_func; - list_view->reorder_drawable_func = reorder_drawable_func; - list_view->add_drawable_func = add_drawable_func; - list_view->remove_drawable_func = remove_drawable_func; - list_view->copy_drawable_func = copy_drawable_func; - list_view->convert_drawable_func = convert_drawable_func; - list_view->new_drawable_func = new_drawable_func; - list_view->edit_drawable_func = edit_drawable_func; + list_view->item_type = item_type; + list_view->signal_name = g_strdup (signal_name); + list_view->get_container_func = get_container_func; + list_view->get_item_func = get_item_func; + list_view->set_item_func = set_item_func; + list_view->reorder_item_func = reorder_item_func; + list_view->add_item_func = add_item_func; + list_view->remove_item_func = remove_item_func; + list_view->copy_item_func = copy_item_func; + list_view->convert_item_func = convert_item_func; + list_view->new_item_func = new_item_func; + list_view->edit_item_func = edit_item_func; list_view->item_factory = item_factory; g_object_ref (G_OBJECT (list_view->item_factory)); @@ -344,33 +340,33 @@ gimp_drawable_list_view_new (gint preview_size, */ gimp_gtk_drag_dest_set_by_type (list_view->new_button, GTK_DEST_DEFAULT_ALL, - drawable_type, + item_type, GDK_ACTION_COPY); gimp_dnd_viewable_dest_set (list_view->new_button, - drawable_type, - gimp_drawable_list_view_new_dropped, + item_type, + gimp_item_list_view_new_dropped, view); gimp_container_view_enable_dnd (view, GTK_BUTTON (list_view->duplicate_button), - drawable_type); + item_type); gimp_container_view_enable_dnd (view, GTK_BUTTON (list_view->edit_button), - drawable_type); + item_type); gimp_container_view_enable_dnd (view, GTK_BUTTON (list_view->delete_button), - drawable_type); + item_type); - gimp_drawable_list_view_set_image (list_view, gimage); + gimp_item_list_view_set_image (list_view, gimage); return GTK_WIDGET (list_view); } void -gimp_drawable_list_view_set_image (GimpDrawableListView *view, - GimpImage *gimage) +gimp_item_list_view_set_image (GimpItemListView *view, + GimpImage *gimage) { - g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (view)); + g_return_if_fail (GIMP_IS_ITEM_LIST_VIEW (view)); g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage)); g_signal_emit (G_OBJECT (view), view_signals[SET_IMAGE], 0, @@ -378,10 +374,10 @@ gimp_drawable_list_view_set_image (GimpDrawableListView *view, } static void -gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, - GimpImage *gimage) +gimp_item_list_view_real_set_image (GimpItemListView *view, + GimpImage *gimage) { - g_return_if_fail (GIMP_IS_DRAWABLE_LIST_VIEW (view)); + g_return_if_fail (GIMP_IS_ITEM_LIST_VIEW (view)); g_return_if_fail (! gimage || GIMP_IS_IMAGE (gimage)); if (view->gimage == gimage) @@ -390,13 +386,10 @@ gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, if (view->gimage) { g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), - gimp_drawable_list_view_drawable_changed, + gimp_item_list_view_item_changed, view); g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), - gimp_drawable_list_view_size_changed, - view); - g_signal_handlers_disconnect_by_func (G_OBJECT (view->gimage), - gimp_drawable_list_view_floating_selection_changed, + gimp_item_list_view_size_changed, view); gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), NULL); @@ -413,19 +406,13 @@ gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), container); g_signal_connect (G_OBJECT (view->gimage), view->signal_name, - G_CALLBACK (gimp_drawable_list_view_drawable_changed), + G_CALLBACK (gimp_item_list_view_item_changed), view); g_signal_connect (G_OBJECT (view->gimage), "size_changed", - G_CALLBACK (gimp_drawable_list_view_size_changed), - view); - g_signal_connect (G_OBJECT (view->gimage), "floating_selection_changed", - G_CALLBACK (gimp_drawable_list_view_floating_selection_changed), + G_CALLBACK (gimp_item_list_view_size_changed), view); - gimp_drawable_list_view_drawable_changed (view->gimage, view); - - if (gimp_image_floating_sel (view->gimage)) - gimp_drawable_list_view_floating_selection_changed (view->gimage, view); + gimp_item_list_view_item_changed (view->gimage, view); } gtk_widget_set_sensitive (view->new_button, (view->gimage != NULL)); @@ -435,18 +422,18 @@ gimp_drawable_list_view_real_set_image (GimpDrawableListView *view, /* GimpContainerView methods */ static void -gimp_drawable_list_view_select_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) +gimp_item_list_view_select_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data) { - GimpDrawableListView *list_view; - gboolean raise_sensitive = FALSE; - gboolean lower_sensitive = FALSE; - gboolean duplicate_sensitive = FALSE; - gboolean edit_sensitive = FALSE; - gboolean delete_sensitive = FALSE; + GimpItemListView *list_view; + gboolean raise_sensitive = FALSE; + gboolean lower_sensitive = FALSE; + gboolean duplicate_sensitive = FALSE; + gboolean edit_sensitive = FALSE; + gboolean delete_sensitive = FALSE; - list_view = GIMP_DRAWABLE_LIST_VIEW (view); + list_view = GIMP_ITEM_LIST_VIEW (view); if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, @@ -455,15 +442,14 @@ gimp_drawable_list_view_select_item (GimpContainerView *view, if (item) { - GimpDrawable *drawable; - gint index; + GimpViewable *active_viewable; + gint index; - drawable = list_view->get_drawable_func (list_view->gimage); + active_viewable = list_view->get_item_func (list_view->gimage); - if (drawable != GIMP_DRAWABLE (item)) + if (active_viewable != item) { - list_view->set_drawable_func (list_view->gimage, - GIMP_DRAWABLE (item)); + list_view->set_item_func (list_view->gimage, item); gdisplays_flush (); } @@ -493,36 +479,40 @@ gimp_drawable_list_view_select_item (GimpContainerView *view, } static void -gimp_drawable_list_view_activate_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) +gimp_item_list_view_activate_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data) { if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->activate_item) GIMP_CONTAINER_VIEW_CLASS (parent_class)->activate_item (view, item, insert_data); - gtk_button_clicked (GTK_BUTTON (GIMP_DRAWABLE_LIST_VIEW (view)->edit_button)); + gtk_button_clicked (GTK_BUTTON (GIMP_ITEM_LIST_VIEW (view)->edit_button)); } static void -gimp_drawable_list_view_context_item (GimpContainerView *view, - GimpViewable *item, - gpointer insert_data) +gimp_item_list_view_context_item (GimpContainerView *view, + GimpViewable *item, + gpointer insert_data) { - GimpDrawableListView *drawable_view; + GimpItemListView *item_view; if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->context_item) GIMP_CONTAINER_VIEW_CLASS (parent_class)->context_item (view, item, insert_data); - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - if (drawable_view->item_factory) + if (item_view->item_factory) { - gimp_item_factory_popup_with_data (drawable_view->item_factory, - gimp_drawable_gimage (GIMP_DRAWABLE (item)), + GimpImage *gimage; + + gimage = gimp_item_get_image (GIMP_ITEM (item)); + + gimp_item_factory_popup_with_data (item_view->item_factory, + gimage, NULL); } } @@ -531,25 +521,25 @@ gimp_drawable_list_view_context_item (GimpContainerView *view, /* "New" functions */ static void -gimp_drawable_list_view_new_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_new_clicked (GtkWidget *widget, + GimpItemListView *view) { - view->new_drawable_func (view->gimage, NULL); + view->new_item_func (view->gimage, NULL); } static void -gimp_drawable_list_view_new_dropped (GtkWidget *widget, - GimpViewable *viewable, - gpointer data) +gimp_item_list_view_new_dropped (GtkWidget *widget, + GimpViewable *viewable, + gpointer data) { - GimpDrawableListView *view; + GimpItemListView *view; - view = (GimpDrawableListView *) data; + view = (GimpItemListView *) data; if (viewable && gimp_container_have (GIMP_CONTAINER_VIEW (view)->container, GIMP_OBJECT (viewable))) { - view->new_drawable_func (view->gimage, GIMP_DRAWABLE (viewable)); + view->new_item_func (view->gimage, viewable); } } @@ -557,107 +547,111 @@ gimp_drawable_list_view_new_dropped (GtkWidget *widget, /* "Duplicate" functions */ static void -gimp_drawable_list_view_duplicate_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_duplicate_clicked (GtkWidget *widget, + GimpItemListView *view) { - GimpDrawable *drawable; - GimpDrawable *new_drawable; + GimpViewable *viewable; + GimpViewable *new_viewable; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - new_drawable = view->copy_drawable_func (drawable, - G_TYPE_FROM_INSTANCE (drawable), - TRUE); - view->add_drawable_func (view->gimage, new_drawable, -1); + new_viewable = view->copy_item_func (viewable, + G_TYPE_FROM_INSTANCE (viewable), + TRUE); - gdisplays_flush (); + if (GIMP_IS_VIEWABLE (new_viewable)) + { + view->add_item_func (view->gimage, new_viewable, -1); + + gdisplays_flush (); + } } /* "Raise/Lower" functions */ static void -gimp_drawable_list_view_raise_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_raise_clicked (GtkWidget *widget, + GimpItemListView *view) { GimpContainer *container; - GimpDrawable *drawable; + GimpViewable *viewable; gint index; container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); + index = gimp_container_get_child_index (container, GIMP_OBJECT (viewable)); if (index > 0) { - view->reorder_drawable_func (view->gimage, drawable, index - 1, TRUE); + view->reorder_item_func (view->gimage, viewable, index - 1, TRUE); gdisplays_flush (); } } static void -gimp_drawable_list_view_raise_extended_clicked (GtkWidget *widget, - guint state, - GimpDrawableListView *view) +gimp_item_list_view_raise_extended_clicked (GtkWidget *widget, + guint state, + GimpItemListView *view) { GimpContainer *container; - GimpDrawable *drawable; + GimpViewable *viewable; gint index; container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); + index = gimp_container_get_child_index (container, GIMP_OBJECT (viewable)); if ((state & GDK_SHIFT_MASK) && (index > 0)) { - view->reorder_drawable_func (view->gimage, drawable, 0, TRUE); + view->reorder_item_func (view->gimage, viewable, 0, TRUE); gdisplays_flush (); } } static void -gimp_drawable_list_view_lower_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_lower_clicked (GtkWidget *widget, + GimpItemListView *view) { GimpContainer *container; - GimpDrawable *drawable; + GimpViewable *viewable; gint index; container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); + index = gimp_container_get_child_index (container, GIMP_OBJECT (viewable)); if (index < container->num_children - 1) { - view->reorder_drawable_func (view->gimage, drawable, index + 1, TRUE); + view->reorder_item_func (view->gimage, viewable, index + 1, TRUE); gdisplays_flush (); } } static void -gimp_drawable_list_view_lower_extended_clicked (GtkWidget *widget, - guint state, - GimpDrawableListView *view) +gimp_item_list_view_lower_extended_clicked (GtkWidget *widget, + guint state, + GimpItemListView *view) { GimpContainer *container; - GimpDrawable *drawable; + GimpViewable *viewable; gint index; container = GIMP_CONTAINER_VIEW (view)->container; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - index = gimp_container_get_child_index (container, GIMP_OBJECT (drawable)); + index = gimp_container_get_child_index (container, GIMP_OBJECT (viewable)); if ((state & GDK_SHIFT_MASK) && (index < container->num_children - 1)) { - view->reorder_drawable_func (view->gimage, drawable, - container->num_children - 1, TRUE); + view->reorder_item_func (view->gimage, viewable, + container->num_children - 1, TRUE); gdisplays_flush (); } @@ -667,28 +661,28 @@ gimp_drawable_list_view_lower_extended_clicked (GtkWidget *widget, /* "Edit" functions */ static void -gimp_drawable_list_view_edit_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_edit_clicked (GtkWidget *widget, + GimpItemListView *view) { - GimpDrawable *drawable; + GimpViewable *viewable; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - view->edit_drawable_func (drawable); + view->edit_item_func (viewable); } /* "Delete" functions */ static void -gimp_drawable_list_view_delete_clicked (GtkWidget *widget, - GimpDrawableListView *view) +gimp_item_list_view_delete_clicked (GtkWidget *widget, + GimpItemListView *view) { - GimpDrawable *drawable; + GimpViewable *viewable; - drawable = view->get_drawable_func (view->gimage); + viewable = view->get_item_func (view->gimage); - view->remove_drawable_func (view->gimage, drawable); + view->remove_item_func (view->gimage, viewable); gdisplays_flush (); } @@ -697,20 +691,19 @@ gimp_drawable_list_view_delete_clicked (GtkWidget *widget, /* GimpImage callbacks */ static void -gimp_drawable_list_view_drawable_changed (GimpImage *gimage, - GimpDrawableListView *view) +gimp_item_list_view_item_changed (GimpImage *gimage, + GimpItemListView *view) { - GimpDrawable *drawable; + GimpViewable *viewable; - drawable = view->get_drawable_func (gimage); + viewable = view->get_item_func (gimage); - gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view), - (GimpViewable *) drawable); + gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view), viewable); } static void -gimp_drawable_list_view_size_changed (GimpImage *gimage, - GimpDrawableListView *view) +gimp_item_list_view_size_changed (GimpImage *gimage, + GimpItemListView *view) { gint preview_size; @@ -719,32 +712,3 @@ gimp_drawable_list_view_size_changed (GimpImage *gimage, gimp_container_view_set_preview_size (GIMP_CONTAINER_VIEW (view), preview_size); } - -static void -gimp_drawable_list_view_floating_selection_changed (GimpImage *gimage, - GimpDrawableListView *view) -{ - GimpViewable *floating_sel; - GList *list; - GList *free_list; - - floating_sel = (GimpViewable *) gimp_image_floating_sel (gimage); - - list = free_list = gtk_container_get_children - (GTK_CONTAINER (GIMP_CONTAINER_LIST_VIEW (view)->gtk_list)); - - for (; list; list = g_list_next (list)) - { - if (! (GIMP_PREVIEW (GIMP_LIST_ITEM (list->data)->preview)->viewable == - floating_sel)) - { - gtk_widget_set_sensitive (GTK_WIDGET (list->data), - floating_sel == NULL); - } - } - - g_list_free (free_list); - - /* update button states */ - gimp_drawable_list_view_drawable_changed (gimage, view); -} diff --git a/app/widgets/gimpitemtreeview.h b/app/widgets/gimpitemtreeview.h index 74cf856bf6..7083c4f32b 100644 --- a/app/widgets/gimpitemtreeview.h +++ b/app/widgets/gimpitemtreeview.h @@ -1,7 +1,7 @@ /* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimpdrawablelistview.h + * gimpitemlistview.h * Copyright (C) 2001 Michael Natterer * * This program is free software; you can redistribute it and/or modify @@ -19,107 +19,107 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#ifndef __GIMP_DRAWABLE_LIST_VIEW_H__ -#define __GIMP_DRAWABLE_LIST_VIEW_H__ +#ifndef __GIMP_ITEM_LIST_VIEW_H__ +#define __GIMP_ITEM_LIST_VIEW_H__ #include "gimpcontainerlistview.h" -typedef GimpContainer * (* GimpGetContainerFunc) (const GimpImage *gimage); -typedef GimpDrawable * (* GimpGetDrawableFunc) (const GimpImage *gimage); -typedef void (* GimpSetDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable); -typedef void (* GimpReorderDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable, - gint new_index, - gboolean push_undo); -typedef void (* GimpAddDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable, - gint index); -typedef void (* GimpRemoveDrawableFunc) (GimpImage *gimage, - GimpDrawable *drawable); -typedef GimpDrawable * (* GimpCopyDrawableFunc) (GimpDrawable *drawable, - GType new_type, - gboolean add_alpha); -typedef GimpDrawable * (* GimpConvertDrawableFunc) (GimpImage *dest_gimage, - GimpDrawable *drawable); +typedef GimpContainer * (* GimpGetContainerFunc) (const GimpImage *gimage); +typedef GimpViewable * (* GimpGetItemFunc) (const GimpImage *gimage); +typedef void (* GimpSetItemFunc) (GimpImage *gimage, + GimpViewable *viewable); +typedef void (* GimpReorderItemFunc) (GimpImage *gimage, + GimpViewable *viewable, + gint new_index, + gboolean push_undo); +typedef void (* GimpAddItemFunc) (GimpImage *gimage, + GimpViewable *viewable, + gint index); +typedef void (* GimpRemoveItemFunc) (GimpImage *gimage, + GimpViewable *viewable); +typedef GimpViewable * (* GimpCopyItemFunc) (GimpViewable *viewable, + GType new_type, + gboolean add_alpha); +typedef GimpViewable * (* GimpConvertItemFunc) (GimpViewable *viewable, + GimpImage *dest_gimage); -typedef void (* GimpNewDrawableFunc) (GimpImage *gimage, - GimpDrawable *template); -typedef void (* GimpEditDrawableFunc) (GimpDrawable *drawable); +typedef void (* GimpNewItemFunc) (GimpImage *gimage, + GimpViewable *template); +typedef void (* GimpEditItemFunc) (GimpViewable *viewable); -#define GIMP_TYPE_DRAWABLE_LIST_VIEW (gimp_drawable_list_view_get_type ()) -#define GIMP_DRAWABLE_LIST_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_DRAWABLE_LIST_VIEW, GimpDrawableListView)) -#define GIMP_DRAWABLE_LIST_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DRAWABLE_LIST_VIEW, GimpDrawableListViewClass)) -#define GIMP_IS_DRAWABLE_LIST_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_DRAWABLE_LIST_VIEW)) -#define GIMP_IS_DRAWABLE_LIST_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DRAWABLE_LIST_VIEW)) -#define GIMP_DRAWABLE_LIST_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_DRAWABLE_LIST_VIEW, GimpDrawableListViewClass)) +#define GIMP_TYPE_ITEM_LIST_VIEW (gimp_item_list_view_get_type ()) +#define GIMP_ITEM_LIST_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_ITEM_LIST_VIEW, GimpItemListView)) +#define GIMP_ITEM_LIST_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_ITEM_LIST_VIEW, GimpItemListViewClass)) +#define GIMP_IS_ITEM_LIST_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_ITEM_LIST_VIEW)) +#define GIMP_IS_ITEM_LIST_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_ITEM_LIST_VIEW)) +#define GIMP_ITEM_LIST_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_ITEM_LIST_VIEW, GimpItemListViewClass)) -typedef struct _GimpDrawableListViewClass GimpDrawableListViewClass; +typedef struct _GimpItemListViewClass GimpItemListViewClass; -struct _GimpDrawableListView +struct _GimpItemListView { - GimpContainerListView parent_instance; + GimpContainerListView parent_instance; - GimpImage *gimage; + GimpImage *gimage; - GType drawable_type; - gchar *signal_name; + GType item_type; + gchar *signal_name; - GimpGetContainerFunc get_container_func; - GimpGetDrawableFunc get_drawable_func; - GimpSetDrawableFunc set_drawable_func; - GimpReorderDrawableFunc reorder_drawable_func; - GimpAddDrawableFunc add_drawable_func; - GimpRemoveDrawableFunc remove_drawable_func; - GimpCopyDrawableFunc copy_drawable_func; - GimpConvertDrawableFunc convert_drawable_func; + GimpGetContainerFunc get_container_func; + GimpGetItemFunc get_item_func; + GimpSetItemFunc set_item_func; + GimpReorderItemFunc reorder_item_func; + GimpAddItemFunc add_item_func; + GimpRemoveItemFunc remove_item_func; + GimpCopyItemFunc copy_item_func; + GimpConvertItemFunc convert_item_func; - GimpNewDrawableFunc new_drawable_func; - GimpEditDrawableFunc edit_drawable_func; + GimpNewItemFunc new_item_func; + GimpEditItemFunc edit_item_func; - GimpItemFactory *item_factory; + GimpItemFactory *item_factory; - GtkWidget *new_button; - GtkWidget *raise_button; - GtkWidget *lower_button; - GtkWidget *duplicate_button; - GtkWidget *edit_button; - GtkWidget *delete_button; + GtkWidget *new_button; + GtkWidget *raise_button; + GtkWidget *lower_button; + GtkWidget *duplicate_button; + GtkWidget *edit_button; + GtkWidget *delete_button; }; -struct _GimpDrawableListViewClass +struct _GimpItemListViewClass { GimpContainerListViewClass parent_class; - void (* set_image) (GimpDrawableListView *view, - GimpImage *gimage); + void (* set_image) (GimpItemListView *view, + GimpImage *gimage); }; -GType gimp_drawable_list_view_get_type (void) G_GNUC_CONST; +GType gimp_item_list_view_get_type (void) G_GNUC_CONST; -GtkWidget * gimp_drawable_list_view_new (gint preview_size, - GimpImage *gimage, - GType drawable_type, - const gchar *signal_name, - GimpGetContainerFunc get_container_func, - GimpGetDrawableFunc get_drawable_func, - GimpSetDrawableFunc set_drawable_func, - GimpReorderDrawableFunc reorder_drawable_func, - GimpAddDrawableFunc add_drawable_func, - GimpRemoveDrawableFunc remove_drawable_func, - GimpCopyDrawableFunc copy_drawable_func, - GimpConvertDrawableFunc convert_drawable_func, - GimpNewDrawableFunc new_drawable_func, - GimpEditDrawableFunc edit_drawable_func, - GimpItemFactory *item_facotry); +GtkWidget * gimp_item_list_view_new (gint preview_size, + GimpImage *gimage, + GType item_type, + const gchar *signal_name, + GimpGetContainerFunc get_container_func, + GimpGetItemFunc get_item_func, + GimpSetItemFunc set_item_func, + GimpReorderItemFunc reorder_item_func, + GimpAddItemFunc add_item_func, + GimpRemoveItemFunc remove_item_func, + GimpCopyItemFunc copy_item_func, + GimpConvertItemFunc convert_item_func, + GimpNewItemFunc new_item_func, + GimpEditItemFunc edit_item_func, + GimpItemFactory *item_facotry); -void gimp_drawable_list_view_set_image (GimpDrawableListView *view, - GimpImage *gimage); +void gimp_item_list_view_set_image (GimpItemListView *view, + GimpImage *gimage); -#endif /* __GIMP_DRAWABLE_LIST_VIEW_H__ */ +#endif /* __GIMP_ITEM_LIST_VIEW_H__ */ diff --git a/app/widgets/gimplayerlistview.c b/app/widgets/gimplayerlistview.c index 140616c5a6..04b286805b 100644 --- a/app/widgets/gimplayerlistview.c +++ b/app/widgets/gimplayerlistview.c @@ -293,14 +293,14 @@ gimp_layer_list_view_select_item (GimpContainerView *view, GimpViewable *item, gpointer insert_data) { - GimpDrawableListView *drawable_view; - GimpLayerListView *list_view; - gboolean options_sensitive = FALSE; - gboolean anchor_sensitive = FALSE; - gboolean raise_sensitive = FALSE; + GimpItemListView *item_view; + GimpLayerListView *layer_view; + gboolean options_sensitive = FALSE; + gboolean anchor_sensitive = FALSE; + gboolean raise_sensitive = FALSE; - list_view = GIMP_LAYER_LIST_VIEW (view); - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); + layer_view = GIMP_LAYER_LIST_VIEW (view); if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, @@ -309,7 +309,7 @@ gimp_layer_list_view_select_item (GimpContainerView *view, if (item) { - gimp_layer_list_view_update_options (list_view, GIMP_LAYER (item)); + gimp_layer_list_view_update_options (layer_view, GIMP_LAYER (item)); options_sensitive = TRUE; @@ -317,9 +317,9 @@ gimp_layer_list_view_select_item (GimpContainerView *view, { anchor_sensitive = TRUE; - gtk_widget_set_sensitive (drawable_view->lower_button, FALSE); - gtk_widget_set_sensitive (drawable_view->duplicate_button, FALSE); - gtk_widget_set_sensitive (drawable_view->edit_button, FALSE); + gtk_widget_set_sensitive (item_view->lower_button, FALSE); + gtk_widget_set_sensitive (item_view->duplicate_button, FALSE); + gtk_widget_set_sensitive (item_view->edit_button, FALSE); } else { @@ -332,9 +332,9 @@ gimp_layer_list_view_select_item (GimpContainerView *view, } } - gtk_widget_set_sensitive (list_view->options_box, options_sensitive); - gtk_widget_set_sensitive (drawable_view->raise_button, raise_sensitive); - gtk_widget_set_sensitive (list_view->anchor_button, anchor_sensitive); + gtk_widget_set_sensitive (layer_view->options_box, options_sensitive); + gtk_widget_set_sensitive (item_view->raise_button, raise_sensitive); + gtk_widget_set_sensitive (layer_view->anchor_button, anchor_sensitive); } @@ -344,15 +344,17 @@ static void gimp_layer_list_view_anchor_clicked (GtkWidget *widget, GimpLayerListView *view) { - GimpDrawableListView *drawable_view; - GimpDrawable *drawable; + GimpItemListView *item_view; + GimpLayer *layer; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - drawable = drawable_view->get_drawable_func (drawable_view->gimage); + layer = (GimpLayer *) item_view->get_item_func (item_view->gimage); - if (drawable) - g_print ("anchor \"%s\"\n", GIMP_OBJECT (drawable)->name); + if (GIMP_IS_LAYER (layer)) + { + g_print ("anchor \"%s\"\n", GIMP_OBJECT (layer)->name); + } } @@ -371,14 +373,14 @@ static void gimp_layer_list_view_paint_mode_menu_callback (GtkWidget *widget, GimpLayerListView *view) { - GimpDrawableListView *drawable_view; - GimpLayer *layer; + GimpItemListView *item_view; + GimpLayer *layer; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + layer = (GimpLayer *) item_view->get_item_func (item_view->gimage); - if (layer) + if (GIMP_IS_LAYER (layer)) { GimpLayerModeEffects mode; @@ -401,14 +403,14 @@ static void gimp_layer_list_view_preserve_button_toggled (GtkWidget *widget, GimpLayerListView *view) { - GimpDrawableListView *drawable_view; - GimpLayer *layer; + GimpItemListView *item_view; + GimpLayer *layer; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + layer = (GimpLayer *) item_view->get_item_func (item_view->gimage); - if (layer) + if (GIMP_IS_LAYER (layer)) { gboolean preserve_trans; @@ -427,14 +429,14 @@ static void gimp_layer_list_view_opacity_scale_changed (GtkAdjustment *adjustment, GimpLayerListView *view) { - GimpDrawableListView *drawable_view; - GimpLayer *layer; + GimpItemListView *item_view; + GimpLayer *layer; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + layer = (GimpLayer *) item_view->get_item_func (item_view->gimage); - if (layer) + if (GIMP_IS_LAYER (layer)) { gdouble opacity; @@ -459,12 +461,11 @@ static void gimp_layer_list_view_layer_signal_handler (GimpLayer *layer, GimpLayerListView *view) { - GimpDrawableListView *drawable_view; + GimpItemListView *item_view; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - if (drawable_view->get_drawable_func (drawable_view->gimage) == - (GimpDrawable *) layer) + if (item_view->get_item_func (item_view->gimage) == (GimpViewable *) layer) { gimp_layer_list_view_update_options (view, layer); } diff --git a/app/widgets/gimplayertreeview.c b/app/widgets/gimplayertreeview.c index 140616c5a6..04b286805b 100644 --- a/app/widgets/gimplayertreeview.c +++ b/app/widgets/gimplayertreeview.c @@ -293,14 +293,14 @@ gimp_layer_list_view_select_item (GimpContainerView *view, GimpViewable *item, gpointer insert_data) { - GimpDrawableListView *drawable_view; - GimpLayerListView *list_view; - gboolean options_sensitive = FALSE; - gboolean anchor_sensitive = FALSE; - gboolean raise_sensitive = FALSE; + GimpItemListView *item_view; + GimpLayerListView *layer_view; + gboolean options_sensitive = FALSE; + gboolean anchor_sensitive = FALSE; + gboolean raise_sensitive = FALSE; - list_view = GIMP_LAYER_LIST_VIEW (view); - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); + layer_view = GIMP_LAYER_LIST_VIEW (view); if (GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item) GIMP_CONTAINER_VIEW_CLASS (parent_class)->select_item (view, @@ -309,7 +309,7 @@ gimp_layer_list_view_select_item (GimpContainerView *view, if (item) { - gimp_layer_list_view_update_options (list_view, GIMP_LAYER (item)); + gimp_layer_list_view_update_options (layer_view, GIMP_LAYER (item)); options_sensitive = TRUE; @@ -317,9 +317,9 @@ gimp_layer_list_view_select_item (GimpContainerView *view, { anchor_sensitive = TRUE; - gtk_widget_set_sensitive (drawable_view->lower_button, FALSE); - gtk_widget_set_sensitive (drawable_view->duplicate_button, FALSE); - gtk_widget_set_sensitive (drawable_view->edit_button, FALSE); + gtk_widget_set_sensitive (item_view->lower_button, FALSE); + gtk_widget_set_sensitive (item_view->duplicate_button, FALSE); + gtk_widget_set_sensitive (item_view->edit_button, FALSE); } else { @@ -332,9 +332,9 @@ gimp_layer_list_view_select_item (GimpContainerView *view, } } - gtk_widget_set_sensitive (list_view->options_box, options_sensitive); - gtk_widget_set_sensitive (drawable_view->raise_button, raise_sensitive); - gtk_widget_set_sensitive (list_view->anchor_button, anchor_sensitive); + gtk_widget_set_sensitive (layer_view->options_box, options_sensitive); + gtk_widget_set_sensitive (item_view->raise_button, raise_sensitive); + gtk_widget_set_sensitive (layer_view->anchor_button, anchor_sensitive); } @@ -344,15 +344,17 @@ static void gimp_layer_list_view_anchor_clicked (GtkWidget *widget, GimpLayerListView *view) { - GimpDrawableListView *drawable_view; - GimpDrawable *drawable; + GimpItemListView *item_view; + GimpLayer *layer; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - drawable = drawable_view->get_drawable_func (drawable_view->gimage); + layer = (GimpLayer *) item_view->get_item_func (item_view->gimage); - if (drawable) - g_print ("anchor \"%s\"\n", GIMP_OBJECT (drawable)->name); + if (GIMP_IS_LAYER (layer)) + { + g_print ("anchor \"%s\"\n", GIMP_OBJECT (layer)->name); + } } @@ -371,14 +373,14 @@ static void gimp_layer_list_view_paint_mode_menu_callback (GtkWidget *widget, GimpLayerListView *view) { - GimpDrawableListView *drawable_view; - GimpLayer *layer; + GimpItemListView *item_view; + GimpLayer *layer; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + layer = (GimpLayer *) item_view->get_item_func (item_view->gimage); - if (layer) + if (GIMP_IS_LAYER (layer)) { GimpLayerModeEffects mode; @@ -401,14 +403,14 @@ static void gimp_layer_list_view_preserve_button_toggled (GtkWidget *widget, GimpLayerListView *view) { - GimpDrawableListView *drawable_view; - GimpLayer *layer; + GimpItemListView *item_view; + GimpLayer *layer; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + layer = (GimpLayer *) item_view->get_item_func (item_view->gimage); - if (layer) + if (GIMP_IS_LAYER (layer)) { gboolean preserve_trans; @@ -427,14 +429,14 @@ static void gimp_layer_list_view_opacity_scale_changed (GtkAdjustment *adjustment, GimpLayerListView *view) { - GimpDrawableListView *drawable_view; - GimpLayer *layer; + GimpItemListView *item_view; + GimpLayer *layer; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - layer = (GimpLayer *) drawable_view->get_drawable_func (drawable_view->gimage); + layer = (GimpLayer *) item_view->get_item_func (item_view->gimage); - if (layer) + if (GIMP_IS_LAYER (layer)) { gdouble opacity; @@ -459,12 +461,11 @@ static void gimp_layer_list_view_layer_signal_handler (GimpLayer *layer, GimpLayerListView *view) { - GimpDrawableListView *drawable_view; + GimpItemListView *item_view; - drawable_view = GIMP_DRAWABLE_LIST_VIEW (view); + item_view = GIMP_ITEM_LIST_VIEW (view); - if (drawable_view->get_drawable_func (drawable_view->gimage) == - (GimpDrawable *) layer) + if (item_view->get_item_func (item_view->gimage) == (GimpViewable *) layer) { gimp_layer_list_view_update_options (view, layer); } diff --git a/app/widgets/gimppreviewrendererdrawable.c b/app/widgets/gimppreviewrendererdrawable.c index 1606b81477..07f3c1faf4 100644 --- a/app/widgets/gimppreviewrendererdrawable.c +++ b/app/widgets/gimppreviewrendererdrawable.c @@ -107,7 +107,7 @@ gimp_drawable_preview_get_size (GimpPreview *preview, gboolean scaling_up; drawable = GIMP_DRAWABLE (preview->viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); if (gimage && ! preview->is_popup) { @@ -150,7 +150,7 @@ gimp_drawable_preview_render (GimpPreview *preview) TempBuf *render_buf; drawable = GIMP_DRAWABLE (preview->viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); width = preview->width; height = preview->height; @@ -271,7 +271,7 @@ gimp_drawable_preview_create_popup (GimpPreview *preview) gboolean scaling_up; drawable = GIMP_DRAWABLE (preview->viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); gimp_preview_calc_size (preview, drawable->width, diff --git a/app/widgets/gimptoolbox.c b/app/widgets/gimptoolbox.c index cda12ef8ad..2c73183a51 100644 --- a/app/widgets/gimptoolbox.c +++ b/app/widgets/gimptoolbox.c @@ -526,7 +526,7 @@ toolbox_drop_drawable (GtkWidget *widget, drawable = GIMP_DRAWABLE (viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); width = gimp_drawable_width (drawable); height = gimp_drawable_height (drawable); bytes = gimp_drawable_bytes (drawable); @@ -562,7 +562,7 @@ toolbox_drop_drawable (GtkWidget *widget, TRUE)); } - gimp_drawable_set_gimage (GIMP_DRAWABLE (new_layer), new_gimage); + gimp_item_set_image (GIMP_ITEM (new_layer), new_gimage); gimp_object_set_name (GIMP_OBJECT (new_layer), gimp_object_get_name (GIMP_OBJECT (drawable))); diff --git a/app/widgets/gimpviewrendererdrawable.c b/app/widgets/gimpviewrendererdrawable.c index 1606b81477..07f3c1faf4 100644 --- a/app/widgets/gimpviewrendererdrawable.c +++ b/app/widgets/gimpviewrendererdrawable.c @@ -107,7 +107,7 @@ gimp_drawable_preview_get_size (GimpPreview *preview, gboolean scaling_up; drawable = GIMP_DRAWABLE (preview->viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); if (gimage && ! preview->is_popup) { @@ -150,7 +150,7 @@ gimp_drawable_preview_render (GimpPreview *preview) TempBuf *render_buf; drawable = GIMP_DRAWABLE (preview->viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); width = preview->width; height = preview->height; @@ -271,7 +271,7 @@ gimp_drawable_preview_create_popup (GimpPreview *preview) gboolean scaling_up; drawable = GIMP_DRAWABLE (preview->viewable); - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); gimp_preview_calc_size (preview, drawable->width, diff --git a/app/widgets/widgets-types.h b/app/widgets/widgets-types.h index 3ac3fd7020..d7968f0295 100644 --- a/app/widgets/widgets-types.h +++ b/app/widgets/widgets-types.h @@ -156,6 +156,7 @@ typedef struct _GimpContainerView GimpContainerView; typedef struct _GimpContainerListView GimpContainerListView; typedef struct _GimpContainerGridView GimpContainerGridView; +typedef struct _GimpItemListView GimpItemListView; typedef struct _GimpDrawableListView GimpDrawableListView; typedef struct _GimpLayerListView GimpLayerListView; typedef struct _GimpChannelListView GimpChannelListView; diff --git a/app/xcf/xcf-load.c b/app/xcf/xcf-load.c index 17c1bdd062..41797c5e97 100644 --- a/app/xcf/xcf-load.c +++ b/app/xcf/xcf-load.c @@ -685,22 +685,23 @@ xcf_load_layer_props (XcfInfo *info, break; case PROP_TATTOO: info->cp += xcf_read_int32 (info->fp, - (guint32*) &GIMP_DRAWABLE(layer)->tattoo, + (guint32*) &GIMP_ITEM (layer)->tattoo, 1); break; case PROP_PARASITES: - { - long base = info->cp; - GimpParasite *p; - while (info->cp - base < prop_size) - { - p = xcf_load_parasite(info); - gimp_drawable_parasite_attach(GIMP_DRAWABLE(layer), p); - gimp_parasite_free(p); - } - if (info->cp - base != prop_size) - g_message ("Error detected while loading a layer's parasites"); - } + { + glong base = info->cp; + GimpParasite *p; + + while (info->cp - base < prop_size) + { + p = xcf_load_parasite(info); + gimp_item_parasite_attach (GIMP_ITEM (layer), p); + gimp_parasite_free (p); + } + if (info->cp - base != prop_size) + g_message ("Error detected while loading a layer's parasites"); + } break; default: g_message ("unexpected/unknown layer property: %d (skipping)", @@ -708,7 +709,7 @@ xcf_load_layer_props (XcfInfo *info, { guint8 buf[16]; - guint amount; + guint amount; while (prop_size > 0) { @@ -783,22 +784,23 @@ xcf_load_channel_props (XcfInfo *info, break; case PROP_TATTOO: info->cp += - xcf_read_int32 (info->fp, &GIMP_DRAWABLE(channel)->tattoo, 1); + xcf_read_int32 (info->fp, &GIMP_ITEM (channel)->tattoo, 1); break; case PROP_PARASITES: - { - long base = info->cp; - GimpParasite *p; - while ((info->cp - base) < prop_size) - { - p = xcf_load_parasite(info); - gimp_drawable_parasite_attach(GIMP_DRAWABLE(channel), p); - gimp_parasite_free(p); - } - if (info->cp - base != prop_size) - g_message("Error detected while loading a channel's parasites"); - } - break; + { + glong base = info->cp; + GimpParasite *p; + + while ((info->cp - base) < prop_size) + { + p = xcf_load_parasite (info); + gimp_item_parasite_attach (GIMP_ITEM (channel), p); + gimp_parasite_free (p); + } + if (info->cp - base != prop_size) + g_message("Error detected while loading a channel's parasites"); + } + break; default: g_message ("unexpected/unknown channel property: %d (skipping)", prop_type); diff --git a/app/xcf/xcf-save.c b/app/xcf/xcf-save.c index 90ac7af8d9..22c377c263 100644 --- a/app/xcf/xcf-save.c +++ b/app/xcf/xcf-save.c @@ -318,11 +318,11 @@ xcf_save_layer_props (XcfInfo *info, GIMP_DRAWABLE (layer)->offset_x, GIMP_DRAWABLE (layer)->offset_y); xcf_save_prop (info, gimage, PROP_MODE, layer->mode); - xcf_save_prop (info, gimage, PROP_TATTOO, GIMP_DRAWABLE (layer)->tattoo); + xcf_save_prop (info, gimage, PROP_TATTOO, GIMP_ITEM (layer)->tattoo); - if (gimp_parasite_list_length (GIMP_DRAWABLE (layer)->parasites) > 0) + if (gimp_parasite_list_length (GIMP_ITEM (layer)->parasites) > 0) xcf_save_prop (info, gimage, PROP_PARASITES, - GIMP_DRAWABLE (layer)->parasites); + GIMP_ITEM (layer)->parasites); xcf_save_prop (info, gimage, PROP_END); } @@ -349,11 +349,11 @@ xcf_save_channel_props (XcfInfo *info, gimp_rgb_get_uchar (&channel->color, &col[0], &col[1], &col[2]); xcf_save_prop (info, gimage, PROP_COLOR, col); - xcf_save_prop (info, gimage, PROP_TATTOO, GIMP_DRAWABLE (channel)->tattoo); + xcf_save_prop (info, gimage, PROP_TATTOO, GIMP_ITEM (channel)->tattoo); - if (gimp_parasite_list_length (GIMP_DRAWABLE (channel)->parasites) > 0) + if (gimp_parasite_list_length (GIMP_ITEM (channel)->parasites) > 0) xcf_save_prop (info, gimage, PROP_PARASITES, - GIMP_DRAWABLE (channel)->parasites); + GIMP_ITEM (channel)->parasites); xcf_save_prop (info, gimage, PROP_END); } diff --git a/tools/pdbgen/pdb.pl b/tools/pdbgen/pdb.pl index d5ccc414ed..9b08583669 100644 --- a/tools/pdbgen/pdb.pl +++ b/tools/pdbgen/pdb.pl @@ -48,28 +48,33 @@ package Gimp::CodeGen::pdb; layer => { name => 'LAYER', type => 'GimpLayer *', headers => [ qw("core/gimplayer.h") ], - id_func => '(GimpLayer *) gimp_drawable_get_by_ID', - id_ret_func => 'gimp_drawable_get_ID (GIMP_DRAWABLE ($var))' }, + id_func => '(GimpLayer *) gimp_item_get_by_ID', + id_ret_func => 'gimp_item_get_ID (GIMP_ITEM ($var))' }, channel => { name => 'CHANNEL', type => 'GimpChannel *', headers => [ qw("core/gimpchannel.h") ], - id_func => '(GimpChannel *) gimp_drawable_get_by_ID', - id_ret_func => 'gimp_drawable_get_ID (GIMP_DRAWABLE ($var))' }, + id_func => '(GimpChannel *) gimp_item_get_by_ID', + id_ret_func => 'gimp_item_get_ID (GIMP_ITEM ($var))' }, drawable => { name => 'DRAWABLE', type => 'GimpDrawable *', headers => [ qw("core/gimpdrawable.h") ], - id_func => 'gimp_drawable_get_by_ID', - id_ret_func => 'gimp_drawable_get_ID (GIMP_DRAWABLE ($var))' }, + id_func => '(GimpDrawable *) gimp_item_get_by_ID', + id_ret_func => 'gimp_item_get_ID (GIMP_ITEM ($var))' }, selection => { name => 'SELECTION', type => 'GimpChannel *', headers => [ qw("core/gimpchannel.h") ], - id_func => '(GimpChannel *) gimp_drawable_get_by_ID', - id_ret_func => 'gimp_drawable_get_ID (GIMP_DRAWABLE ($var))' }, + id_func => '(GimpChannel *) gimp_item_get_by_ID', + id_ret_func => 'gimp_item_get_ID (GIMP_ITEM ($var))' }, layer_mask => { name => 'CHANNEL', type => 'GimpLayerMask *', headers => [ qw("core/gimplayermask.h") ], - id_func => '(GimpLayerMask *) gimp_drawable_get_by_ID', - id_ret_func => 'gimp_drawable_get_ID (GIMP_DRAWABLE ($var))' }, + id_func => '(GimpLayerMask *) gimp_item_get_by_ID', + id_ret_func => 'gimp_item_get_ID (GIMP_ITEM ($var))' }, + vectors => { name => 'VECTORS', + type => 'GimpVectors *', + headers => [ qw("vectors/gimpvectors.h") ], + id_func => '(GimpVectors *) gimp_item_get_by_ID', + id_ret_func => 'gimp_item_get_ID (GIMP_ITEM ($var))' }, parasite => { name => 'PARASITE', type => 'GimpParasite *', headers => [ qw("libgimpbase/gimpparasite.h") ] }, diff --git a/tools/pdbgen/pdb/channel.pdb b/tools/pdbgen/pdb/channel.pdb index 3070fa4989..c57f07c87e 100644 --- a/tools/pdbgen/pdb/channel.pdb +++ b/tools/pdbgen/pdb/channel.pdb @@ -212,7 +212,7 @@ HELP %invoke = ( code => <<'CODE' ); { - if (! gimp_drawable_gimage (GIMP_DRAWABLE (channel))) + if (! gimp_item_get_image (GIMP_ITEM (channel))) { g_object_unref (G_OBJECT (channel)); success = TRUE; diff --git a/tools/pdbgen/pdb/color.pdb b/tools/pdbgen/pdb/color.pdb index a8b1a670b8..efc5761804 100644 --- a/tools/pdbgen/pdb/color.pdb +++ b/tools/pdbgen/pdb/color.pdb @@ -56,7 +56,7 @@ HELP success = FALSE; else { - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); lut = brightness_contrast_lut_new (brightness / 255.0, contrast / 127.0, @@ -201,7 +201,7 @@ HELP success = FALSE; else { - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); lut = posterize_lut_new (levels, gimp_drawable_bytes (drawable)); @@ -607,7 +607,7 @@ HELP x1, y1, (x2 - x1), (y2 - y1), FALSE); /* Configure the mask from the gimage's selection mask */ - mask = gimp_image_get_mask (gimp_drawable_gimage (drawable)); + mask = gimp_image_get_mask (gimp_item_get_image (GIMP_ITEM (drawable))); pixel_region_init (&maskPR, gimp_drawable_data (GIMP_DRAWABLE (mask)), x1 + off_x, y1 + off_y, (x2 - x1), (y2 - y1), FALSE); diff --git a/tools/pdbgen/pdb/drawable.pdb b/tools/pdbgen/pdb/drawable.pdb index cf9d16b2c5..c05c5528a9 100644 --- a/tools/pdbgen/pdb/drawable.pdb +++ b/tools/pdbgen/pdb/drawable.pdb @@ -211,7 +211,7 @@ sub drawable_image { $outargs[0]->{init} = 1; %invoke = ( - code => 'success = (gimage = gimp_drawable_gimage (drawable)) != NULL;' + code => 'success = (gimage = gimp_item_get_image (GIMP_ITEM (drawable))) != NULL;' ); } @@ -419,7 +419,7 @@ HELP &std_image_arg ); - %invoke = ( code => 'gimp_drawable_set_gimage (drawable, gimage);' ); + %invoke = ( code => 'gimp_item_set_image (GIMP_ITEM (drawable), gimage);' ); } diff --git a/tools/pdbgen/pdb/edit.pdb b/tools/pdbgen/pdb/edit.pdb index 7a988596fb..1a8767aca2 100644 --- a/tools/pdbgen/pdb/edit.pdb +++ b/tools/pdbgen/pdb/edit.pdb @@ -32,7 +32,7 @@ sub invoke { vars => [ 'GimpImage *gimage' ], code => <data)); + ${type}_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data)); } } CODE @@ -227,8 +227,8 @@ HELP for ($invoke{code}) { s/list = .*$/gimp_container_foreach (gimp->images, gimlist_cb, &list);/m; - s/DRAWABLE/IMAGE/; - s/gimp_drawable_get_ID/gimp_image_get_ID/; + s/ITEM/IMAGE/; + s/gimp_item_get_ID/gimp_image_get_ID/; } } diff --git a/tools/pdbgen/pdb/layer.pdb b/tools/pdbgen/pdb/layer.pdb index b083814818..1ed2e41ace 100644 --- a/tools/pdbgen/pdb/layer.pdb +++ b/tools/pdbgen/pdb/layer.pdb @@ -45,7 +45,7 @@ sub layer_change_invoke { vars => [ 'GimpImage *gimage', 'GimpLayer *floating_layer' ], code => <gimage)) + if ((gimage = gimp_item_get_image (GIMP_ITEM (layer)))) { floating_layer = gimp_image_floating_sel (gimage); @@ -359,7 +359,7 @@ HELP %invoke = ( code => <<'CODE' ); { - if (! gimp_drawable_gimage (GIMP_DRAWABLE (layer))) + if (! gimp_item_get_image (GIMP_ITEM (layer))) { g_object_unref (G_OBJECT (layer)); success = TRUE; diff --git a/tools/pdbgen/pdb/misc_tools.pdb b/tools/pdbgen/pdb/misc_tools.pdb index 25970e48ad..3b9a4480bb 100644 --- a/tools/pdbgen/pdb/misc_tools.pdb +++ b/tools/pdbgen/pdb/misc_tools.pdb @@ -102,7 +102,7 @@ HELP headers => [ qw("core/gimpdrawable-blend.h") ], code => <<'CODE' { - if (! gimp_drawable_gimage (drawable)) + if (! gimp_item_get_image (GIMP_ITEM (drawable))) { success = FALSE; } @@ -173,7 +173,7 @@ HELP headers => [ qw ("core/gimpdrawable-bucket-fill.h") ], code => <<'CODE' { - if (! gimp_drawable_gimage (GIMP_DRAWABLE (drawable))) + if (! gimp_item_get_image (GIMP_ITEM (drawable))) { success = FALSE; } @@ -237,7 +237,7 @@ HELP code => <<'CODE' { if (!sample_merged) - if (!drawable || (gimp_drawable_gimage (drawable) != gimage)) + if (!drawable || (gimp_item_get_image (GIMP_ITEM (drawable)) != gimage)) success = FALSE; if (success) diff --git a/tools/pdbgen/pdb/parasite.pdb b/tools/pdbgen/pdb/parasite.pdb index 2f496bf450..6164aa8f11 100644 --- a/tools/pdbgen/pdb/parasite.pdb +++ b/tools/pdbgen/pdb/parasite.pdb @@ -137,7 +137,7 @@ sub parasite_list { %invoke = ( code => 'parasites = gimp_parasite_list (gimp, &num_parasites);' ); } -@headers = qw("core/gimpparasite.h" "core/gimpdrawable.h"); +@headers = qw("core/gimpparasite.h" "core/gimpdrawable.h" "pdb_glue.h"); @procs = qw(parasite_find parasite_attach parasite_detach parasite_list); diff --git a/tools/pdbgen/pdb/selection.pdb b/tools/pdbgen/pdb/selection.pdb index 4b07ed71d3..9193311601 100644 --- a/tools/pdbgen/pdb/selection.pdb +++ b/tools/pdbgen/pdb/selection.pdb @@ -185,7 +185,7 @@ HELP vars => [ 'GimpImage *gimage' ], code => <<'CODE' { - gimage = gimp_drawable_gimage (drawable); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); layer = gimp_image_mask_float (gimage, drawable, offx, offy); success = layer != NULL; } @@ -306,7 +306,7 @@ HELP vars => [ 'GimpImage *gimage' ], code => <<'CODE' { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (layer)); + gimage = gimp_item_get_image (GIMP_ITEM (layer)); gimp_image_mask_layer_alpha (gimage, layer); } CODE @@ -331,7 +331,7 @@ HELP vars => [ 'GimpImage *gimage' ], code => <<'CODE' { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (channel)); + gimage = gimp_item_get_image (GIMP_ITEM (channel)); if (gimp_drawable_width (GIMP_DRAWABLE (channel)) == gimage->width && gimp_drawable_height (GIMP_DRAWABLE (channel)) == gimage->height) @@ -361,7 +361,7 @@ HELP vars => [ 'GimpImage *gimage', 'GimpChannel *new_channel' ], code => <<'CODE' { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (channel)); + gimage = gimp_item_get_image (GIMP_ITEM (channel)); if (gimp_drawable_width (GIMP_DRAWABLE (channel)) == gimage->width && gimp_drawable_height (GIMP_DRAWABLE (channel)) == gimage->height) diff --git a/tools/pdbgen/pdb/selection_tools.pdb b/tools/pdbgen/pdb/selection_tools.pdb index 9d4d5bbd25..8e421b1c4b 100644 --- a/tools/pdbgen/pdb/selection_tools.pdb +++ b/tools/pdbgen/pdb/selection_tools.pdb @@ -100,7 +100,7 @@ HELP vars => [ 'GimpImage *gimage' ], code => <<'CODE' { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable)); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); gimp_image_mask_select_by_color (gimage, drawable, sample_merged, @@ -251,7 +251,7 @@ HELP vars => [ 'GimpImage *gimage' ], code => <<'CODE' { - gimage = gimp_drawable_gimage (GIMP_DRAWABLE (drawable)); + gimage = gimp_item_get_image (GIMP_ITEM (drawable)); gimp_image_mask_select_fuzzy (gimage, drawable,