diff --git a/plug-ins/common/Makefile.am b/plug-ins/common/Makefile.am index 1f1766ee11..c9a4f9440b 100644 --- a/plug-ins/common/Makefile.am +++ b/plug-ins/common/Makefile.am @@ -388,8 +388,6 @@ colormap_remap_LDADD = \ $(INTLLIBS) \ $(colormap_remap_RC) -compose_CPPFLAGS = $(AM_CPPFLAGS) -DGIMP_DEPRECATED_REPLACE_NEW_API - compose_SOURCES = \ compose.c diff --git a/plug-ins/common/compose.c b/plug-ins/common/compose.c index 902375b673..ea245e7fa6 100644 --- a/plug-ins/common/compose.c +++ b/plug-ins/common/compose.c @@ -55,12 +55,13 @@ typedef struct { + gboolean is_object; + union - { - gint32 ID; /* Image ID of input images or drawable */ - guchar val; /* Mask value to compose with */ - } comp; - gboolean is_ID; + { + gpointer object; /* Input images or drawable */ + guchar val; /* Mask value to compose with */ + } comp; } ComposeInput; /* Description of a component */ @@ -86,64 +87,113 @@ typedef struct } COMPOSE_DSC; +typedef struct +{ + ComposeInput inputs[MAX_COMPOSE_IMAGES]; /* Image or mask value of input */ + gchar compose_type[32]; /* type of composition */ + gboolean do_recompose; + GimpLayer *source_layer; /* for recomposing */ +} ComposeVals; -/* Declare local functions - */ -static void query (void); -static void run (const gchar *name, - gint nparams, - const GimpParam *param, - gint *nreturn_vals, - GimpParam **return_vals); +/* Dialog structure */ +typedef struct +{ + gint width, height; /* Size of selected image */ -static void cpn_affine_transform (GeglBuffer *buffer, - gdouble min, - gdouble max); + GtkWidget *channel_label[MAX_COMPOSE_IMAGES]; /* The labels to change */ + GtkWidget *channel_icon[MAX_COMPOSE_IMAGES]; /* The icons */ + GtkWidget *channel_menu[MAX_COMPOSE_IMAGES]; /* The menus */ + GtkWidget *color_scales[MAX_COMPOSE_IMAGES]; /* The values color scales */ + GtkWidget *color_spins[MAX_COMPOSE_IMAGES]; /* The values spin buttons */ -static void fill_buffer_from_components (GeglBuffer *temp[MAX_COMPOSE_IMAGES], - GeglBuffer *dst, - gint num_cpn, - ComposeInput *inputs, - gdouble mask_vals[MAX_COMPOSE_IMAGES]); + ComposeInput selected[MAX_COMPOSE_IMAGES]; /* Image Ids or mask values from menus */ -static void perform_composition (COMPOSE_DSC curr_compose_dsc, - GeglBuffer *buffer_src[MAX_COMPOSE_IMAGES], - GeglBuffer *buffer_dst, - ComposeInput *inputs, - gint num_images); + gint compose_idx; /* Compose type */ +} ComposeInterface; -static gint32 compose (const gchar *compose_type, - ComposeInput *inputs, - gboolean compose_by_drawable); -static gint32 create_new_image (const gchar *filename, - guint width, - guint height, - GimpImageType gdtype, - GimpPrecision precision, - gint32 *layer_ID, - GeglBuffer **drawable); +typedef struct _Compose Compose; +typedef struct _ComposeClass ComposeClass; -static gboolean compose_dialog (const gchar *compose_type, - gint32 drawable_ID); +struct _Compose +{ + GimpPlugIn parent_instance; +}; -static gboolean check_gray (gint32 image_id, - gint32 drawable_id, - gpointer data); +struct _ComposeClass +{ + GimpPlugInClass parent_class; +}; -static void combo_callback (GimpIntComboBox *cbox, - gpointer data); -static void scale_callback (GtkAdjustment *adj, - ComposeInput *input); +#define COMPOSE_TYPE (compose_get_type ()) +#define COMPOSE (obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), COMPOSE_TYPE, Compose)) -static void check_response (GtkWidget *dialog, - gint response, - gpointer data); +GType compose_get_type (void) G_GNUC_CONST; -static void type_combo_callback (GimpIntComboBox *combo, - gpointer data); +static GList * compose_query_procedures (GimpPlugIn *plug_in); +static GimpProcedure * compose_create_procedure (GimpPlugIn *plug_in, + const gchar *name); +static GimpValueArray * compose_run (GimpProcedure *procedure, + GimpRunMode run_mode, + GimpImage *image, + GimpDrawable *drawable, + const GimpValueArray *args, + gpointer run_data); + +static void cpn_affine_transform (GeglBuffer *buffer, + gdouble min, + gdouble max); + +static void fill_buffer_from_components (GeglBuffer *temp[MAX_COMPOSE_IMAGES], + GeglBuffer *dst, + gint num_cpn, + ComposeInput *inputs, + gdouble mask_vals[MAX_COMPOSE_IMAGES]); + +static void perform_composition (COMPOSE_DSC curr_compose_dsc, + GeglBuffer *buffer_src[MAX_COMPOSE_IMAGES], + GeglBuffer *buffer_dst, + ComposeInput *inputs, + gint num_images); + +static GimpImage * compose (const gchar *compose_type, + ComposeInput *inputs, + gboolean compose_by_drawable); + +static GimpImage * create_new_image (const gchar *filename, + guint width, + guint height, + GimpImageType gdtype, + GimpPrecision precision, + GimpLayer **layer, + GeglBuffer **buffer); + +static gboolean compose_dialog (const gchar *compose_type, + GimpDrawable *drawable); + +static gboolean check_gray (GimpImage *image, + GimpItem *drawable, + gpointer data); + +static void combo_callback (GimpIntComboBox *cbox, + gpointer data); + +static void scale_callback (GtkAdjustment *adj, + ComposeInput *input); + +static void check_response (GtkWidget *dialog, + gint response, + gpointer data); + +static void type_combo_callback (GimpIntComboBox *combo, + gpointer data); + + +G_DEFINE_TYPE (Compose, compose, GIMP_TYPE_PLUG_IN) + +GIMP_MAIN (COMPOSE_TYPE) /* Decompositions availables. @@ -278,45 +328,12 @@ static COMPOSE_DSC compose_dsc[] = "ycbcr709F-compose" } }; - -typedef struct -{ - ComposeInput inputs[MAX_COMPOSE_IMAGES]; /* Image IDs or mask value of input */ - gchar compose_type[32]; /* type of composition */ - gboolean do_recompose; - gint32 source_layer_ID; /* for recomposing */ -} ComposeVals; - -/* Dialog structure */ -typedef struct -{ - gint width, height; /* Size of selected image */ - - GtkWidget *channel_label[MAX_COMPOSE_IMAGES]; /* The labels to change */ - GtkWidget *channel_icon[MAX_COMPOSE_IMAGES]; /* The icons */ - GtkWidget *channel_menu[MAX_COMPOSE_IMAGES]; /* The menus */ - GtkWidget *color_scales[MAX_COMPOSE_IMAGES]; /* The values color scales */ - GtkWidget *color_spins[MAX_COMPOSE_IMAGES]; /* The values spin buttons */ - - ComposeInput selected[MAX_COMPOSE_IMAGES]; /* Image Ids or mask values from menus */ - - gint compose_idx; /* Compose type */ -} ComposeInterface; - -const GimpPlugInInfo PLUG_IN_INFO = -{ - NULL, /* init_proc */ - NULL, /* quit_proc */ - query, /* query_proc */ - run, /* run_proc */ -}; - static ComposeVals composevals = { - {{{ 0 }}}, /* Image IDs of images to compose or mask values */ - "rgb", /* Type of composition */ - FALSE, /* Do recompose */ - -1 /* source layer ID */ + {{ 0, }}, /* Image IDs of images to compose or mask values */ + "rgb", /* Type of composition */ + FALSE, /* Do recompose */ + NULL /* source layer */ }; static ComposeInterface composeint = @@ -327,58 +344,44 @@ static ComposeInterface composeint = { NULL }, /* Menu Widgets */ { NULL }, /* Color Scale Widgets */ { NULL }, /* Color Spin Widgets */ - {{{ 0 }}}, /* Image Ids or mask values from menus */ + {{ 0, }}, /* Image Ids or mask values from menus */ 0 /* Compose type */ }; -MAIN () +static void +compose_class_init (ComposeClass *klass) +{ + GimpPlugInClass *plug_in_class = GIMP_PLUG_IN_CLASS (klass); + plug_in_class->query_procedures = compose_query_procedures; + plug_in_class->create_procedure = compose_create_procedure; +} static void -query (void) +compose_init (Compose *compose) { - static GimpParamDef args[] = - { - { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, - { GIMP_PDB_IMAGE, "image1", "First input image" }, - { GIMP_PDB_DRAWABLE, "drawable", "Input drawable (not used)" }, - { GIMP_PDB_IMAGE, "image2", "Second input image" }, - { GIMP_PDB_IMAGE, "image3", "Third input image" }, - { GIMP_PDB_IMAGE, "image4", "Fourth input image" }, - { GIMP_PDB_STRING, "compose-type", NULL } - }; +} - static const GimpParamDef return_vals[] = - { - { GIMP_PDB_IMAGE, "new_image", "Output image" } - }; +static GList * +compose_query_procedures (GimpPlugIn *plug_in) +{ + GList *list = NULL; - static GimpParamDef drw_args[] = - { - { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, - { GIMP_PDB_IMAGE, "image1", "First input image (not used)" }, - { GIMP_PDB_DRAWABLE, "drawable1", "First input drawable" }, - { GIMP_PDB_DRAWABLE, "drawable2", "Second input drawable" }, - { GIMP_PDB_DRAWABLE, "drawable3", "Third input drawable" }, - { GIMP_PDB_DRAWABLE, "drawable4", "Fourth input drawable" }, - { GIMP_PDB_STRING, "compose-type", NULL } - }; + list = g_list_append (list, g_strdup (COMPOSE_PROC)); + list = g_list_append (list, g_strdup (DRAWABLE_COMPOSE_PROC)); + list = g_list_append (list, g_strdup (RECOMPOSE_PROC)); - static const GimpParamDef drw_return_vals[] = - { - { GIMP_PDB_IMAGE, "new_image", "Output image" } - }; + return list; +} - static const GimpParamDef recompose_args[] = - { - { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, - { GIMP_PDB_IMAGE, "image", "Image to recompose from" }, - { GIMP_PDB_DRAWABLE, "drawable", "Not used" }, - }; - - GString *type_desc; - gint i; +static GimpProcedure * +compose_create_procedure (GimpPlugIn *plug_in, + const gchar *name) +{ + GimpProcedure *procedure = NULL; + GString *type_desc; + gint i; type_desc = g_string_new ("What to compose: "); g_string_append_c (type_desc, '"'); @@ -393,128 +396,229 @@ query (void) g_string_append_c (type_desc, '"'); } - args[6].description = type_desc->str; - drw_args[6].description = type_desc->str; + if (! strcmp (name, COMPOSE_PROC)) + { + procedure = gimp_image_procedure_new (plug_in, name, GIMP_PLUGIN, + compose_run, NULL, NULL); - gimp_install_procedure (COMPOSE_PROC, - N_("Create an image using multiple gray images as color channels"), - "This function creates a new image from " - "multiple gray images", - "Peter Kirchgessner", - "Peter Kirchgessner (peter@kirchgessner.net)", - "1997", - N_("C_ompose..."), - "GRAY*", - GIMP_PLUGIN, - G_N_ELEMENTS (args), - G_N_ELEMENTS (return_vals), - args, return_vals); + gimp_procedure_set_image_types (procedure, "GRAY*"); - gimp_plugin_menu_register (COMPOSE_PROC, "/Colors/Components"); + gimp_procedure_set_menu_label (procedure, N_("C_ompose...")); + gimp_procedure_add_menu_path (procedure, "/Colors/Components"); - gimp_install_procedure (DRAWABLE_COMPOSE_PROC, - "Compose an image from multiple drawables of gray images", - "This function creates a new image from " - "multiple drawables of gray images", - "Peter Kirchgessner", - "Peter Kirchgessner (peter@kirchgessner.net)", - "1998", - NULL, /* It is not available in interactive mode */ - "GRAY*", - GIMP_PLUGIN, - G_N_ELEMENTS (drw_args), - G_N_ELEMENTS (drw_return_vals), - drw_args, drw_return_vals); + gimp_procedure_set_documentation (procedure, + N_("Create an image using multiple " + "gray images as color channels"), + "This function creates a new image from " + "multiple gray images", + name); + gimp_procedure_set_attribution (procedure, + "Peter Kirchgessner", + "Peter Kirchgessner (peter@kirchgessner.net)", + "1997"); - gimp_install_procedure (RECOMPOSE_PROC, - N_("Recompose an image that was previously decomposed"), - "This function recombines the grayscale layers produced " - "by Decompose into a single RGB or RGBA layer, and " - "replaces the originally decomposed layer with the " - "result.", - "Bill Skaggs", - "Bill Skaggs", - "2004", - N_("R_ecompose"), - "GRAY*", - GIMP_PLUGIN, - G_N_ELEMENTS (recompose_args), 0, - recompose_args, NULL); + GIMP_PROC_ARG_IMAGE (procedure, "image-2", + "Image 2", + "Second input image", + TRUE, + G_PARAM_READWRITE); - gimp_plugin_menu_register (RECOMPOSE_PROC, "/Colors/Components"); + GIMP_PROC_ARG_IMAGE (procedure, "image-3", + "Image 3", + "Third input image", + TRUE, + G_PARAM_READWRITE); + + GIMP_PROC_ARG_IMAGE (procedure, "image-4", + "Image 4", + "Fourth input image", + TRUE, + G_PARAM_READWRITE); + + GIMP_PROC_ARG_STRING (procedure, "compose-type", + "Compose type", + type_desc->str, + NULL, + G_PARAM_READWRITE); + + GIMP_PROC_VAL_IMAGE (procedure, "new-image", + "New image", + "Output image", + FALSE, + G_PARAM_READWRITE); + } + else if (! strcmp (name, DRAWABLE_COMPOSE_PROC)) + { + procedure = gimp_image_procedure_new (plug_in, name, GIMP_PLUGIN, + compose_run, NULL, NULL); + + gimp_procedure_set_image_types (procedure, "GRAY*"); + + gimp_procedure_set_documentation (procedure, + "Compose an image from multiple " + "drawables of gray images", + "This function creates a new image from " + "multiple drawables of gray images", + name); + gimp_procedure_set_attribution (procedure, + "Peter Kirchgessner", + "Peter Kirchgessner (peter@kirchgessner.net)", + "1998"); + + GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-2", + "Drawable 2", + "Second input drawable", + TRUE, + G_PARAM_READWRITE); + + GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-3", + "Drawable 3", + "Third input drawable", + TRUE, + G_PARAM_READWRITE); + + GIMP_PROC_ARG_DRAWABLE (procedure, "drawable-4", + "Drawable 4", + "Fourth input drawable", + TRUE, + G_PARAM_READWRITE); + + GIMP_PROC_ARG_STRING (procedure, "compose-type", + "Compose type", + type_desc->str, + NULL, + G_PARAM_READWRITE); + + GIMP_PROC_VAL_IMAGE (procedure, "new-image", + "New image", + "Output image", + FALSE, + G_PARAM_READWRITE); + } + else if (! strcmp (name, RECOMPOSE_PROC)) + { + procedure = gimp_image_procedure_new (plug_in, name, GIMP_PLUGIN, + compose_run, NULL, NULL); + + gimp_procedure_set_image_types (procedure, "GRAY*"); + + gimp_procedure_set_menu_label (procedure, N_("R_ecompose")); + gimp_procedure_add_menu_path (procedure, "/Colors/Components"); + + gimp_procedure_set_documentation (procedure, + N_("Recompose an image that was " + "previously decomposed"), + "This function recombines the grayscale " + "layers produced by Decompose " + "into a single RGB or RGBA layer, and " + "replaces the originally decomposed " + "layer with the result.", + name); + gimp_procedure_set_attribution (procedure, + "Bill Skaggs", + "Bill Skaggs", + "2004"); + } g_string_free (type_desc, TRUE); + + return procedure; } - -static void -run (const gchar *name, - gint nparams, - const GimpParam *param, - gint *nreturn_vals, - GimpParam **return_vals) +static GimpValueArray * +compose_run (GimpProcedure *procedure, + GimpRunMode run_mode, + GimpImage *image, + GimpDrawable *drawable, + const GimpValueArray *args, + gpointer run_data) { - static GimpParam values[2]; - GimpPDBStatusType status = GIMP_PDB_SUCCESS; - GimpRunMode run_mode; - gint32 image_ID; - gint32 drawable_ID = -1; - gint compose_by_drawable; - gint i; + GimpValueArray *return_vals; + const gchar *name = gimp_procedure_get_name (procedure); + gint compose_by_drawable; + gint i; INIT_I18N (); gegl_init (NULL, NULL); - run_mode = param[0].data.d_int32; - compose_by_drawable = (strcmp (name, DRAWABLE_COMPOSE_PROC) == 0); + compose_by_drawable = ! strcmp (name, DRAWABLE_COMPOSE_PROC); - *nreturn_vals = 1; - *return_vals = values; - - values[0].type = GIMP_PDB_STATUS; - values[0].data.d_status = status; - values[1].type = GIMP_PDB_IMAGE; - values[1].data.d_int32 = -1; - - if (strcmp (name, RECOMPOSE_PROC) == 0) + if (! strcmp (name, RECOMPOSE_PROC)) { - GimpParasite *parasite = gimp_image_get_parasite (param[1].data.d_image, + GimpParasite *parasite = gimp_image_get_parasite (image, "decompose-data"); if (! parasite) { g_message (_("You can only run 'Recompose' if the active image " "was originally produced by 'Decompose'.")); - status = GIMP_PDB_EXECUTION_ERROR; + + return gimp_procedure_new_return_values (procedure, + GIMP_PDB_EXECUTION_ERROR, + NULL); } else { + gint source; + gint input[4] = { 0, }; gint nret; nret = sscanf (gimp_parasite_data (parasite), "source=%d type=%31s %d %d %d %d", - &composevals.source_layer_ID, + &source, composevals.compose_type, - &composevals.inputs[0].comp.ID, - &composevals.inputs[1].comp.ID, - &composevals.inputs[2].comp.ID, - &composevals.inputs[3].comp.ID); + input, + input + 1, + input + 2, + input + 3); gimp_parasite_free (parasite); - for (i = 0; i < MAX_COMPOSE_IMAGES; i++) - composevals.inputs[i].is_ID = TRUE; - if (nret < 5) { g_message (_("Error scanning 'decompose-data' parasite: " "too few layers found")); - status = GIMP_PDB_EXECUTION_ERROR; + + return gimp_procedure_new_return_values (procedure, + GIMP_PDB_EXECUTION_ERROR, + NULL); } - else + + compose_by_drawable = TRUE; + + composevals.do_recompose = TRUE; + composevals.source_layer = GIMP_LAYER (gimp_item_get_by_id (source)); + + if (! composevals.source_layer) { - composevals.do_recompose = TRUE; - compose_by_drawable = TRUE; + g_message (_("Cannot recompose: Specified source layer ID %d " + "not found"), + source); + + return gimp_procedure_new_return_values (procedure, + GIMP_PDB_EXECUTION_ERROR, + NULL); + } + + for (i = 0; i < MAX_COMPOSE_IMAGES; i++) + { + composevals.inputs[i].is_object = TRUE; + composevals.inputs[i].comp.object = gimp_item_get_by_id (input[i]); + + /* fourth input is optional */ + if (i == 2 && nret == 5) + break; + + if (! composevals.inputs[i].comp.object) + { + g_message (_("Cannot recompose: Specified layer #%d ID %d " + "not found"), + i + 1, input[i]); + + return gimp_procedure_new_return_values (procedure, + GIMP_PDB_EXECUTION_ERROR, + NULL); + } } } } @@ -525,75 +629,74 @@ run (const gchar *name, switch (run_mode) { case GIMP_RUN_INTERACTIVE: - /* Possibly retrieve data */ gimp_get_data (name, &composevals); compose_by_drawable = TRUE; - /* The dialog is now drawable based. Get a drawable-ID of the image */ - if (strcmp (name, COMPOSE_PROC) == 0) + /* Get a drawable-ID of the image */ + if (! strcmp (name, COMPOSE_PROC)) { - gint32 *layer_list; - gint nlayers; + GimpLayer **layers; + gint nlayers; - layer_list = gimp_image_get_layers (param[1].data.d_int32, - &nlayers); - if ((layer_list == NULL) || (nlayers <= 0)) + layers = gimp_image_get_layers (image, &nlayers); + + if (! layers) { g_message (_("Could not get layers for image %d"), - (gint) param[1].data.d_int32); - return; + (gint) gimp_image_get_id (image)); + + return gimp_procedure_new_return_values (procedure, + GIMP_PDB_EXECUTION_ERROR, + NULL); } - drawable_ID = layer_list[0]; - g_free (layer_list); - } - else - { - drawable_ID = param[2].data.d_int32; + drawable = GIMP_DRAWABLE (layers[0]); + + g_free (layers); } - /* First acquire information with a dialog */ - if (! compose_dialog (composevals.compose_type, drawable_ID)) - return; - + if (! compose_dialog (composevals.compose_type, drawable)) + return gimp_procedure_new_return_values (procedure, + GIMP_PDB_CANCEL, + NULL); break; case GIMP_RUN_NONINTERACTIVE: - /* Make sure all the arguments are there! */ - if (nparams < 7) + if (compose_by_drawable) { - status = GIMP_PDB_CALLING_ERROR; + composevals.inputs[0].comp.object = drawable; + composevals.inputs[1].comp.object = GIMP_VALUES_GET_DRAWABLE (args, 0); + composevals.inputs[2].comp.object = GIMP_VALUES_GET_DRAWABLE (args, 1); + composevals.inputs[3].comp.object = GIMP_VALUES_GET_DRAWABLE (args, 2); } else { - composevals.inputs[0].comp.ID = (compose_by_drawable ? - param[2].data.d_int32 : - param[1].data.d_int32); - composevals.inputs[1].comp.ID = param[3].data.d_int32; - composevals.inputs[2].comp.ID = param[4].data.d_int32; - composevals.inputs[3].comp.ID = param[5].data.d_int32; + composevals.inputs[0].comp.object = image; + composevals.inputs[1].comp.object = GIMP_VALUES_GET_IMAGE (args, 0); + composevals.inputs[2].comp.object = GIMP_VALUES_GET_IMAGE (args, 1); + composevals.inputs[3].comp.object = GIMP_VALUES_GET_IMAGE (args, 2); + } - g_strlcpy (composevals.compose_type, param[6].data.d_string, - sizeof (composevals.compose_type)); + g_strlcpy (composevals.compose_type, + GIMP_VALUES_GET_STRING (args, 3), + sizeof (composevals.compose_type)); - for (i = 0; i < MAX_COMPOSE_IMAGES; i++) + for (i = 0; i < MAX_COMPOSE_IMAGES; i++) + { + if (! composevals.inputs[i].comp.object) { - if (composevals.inputs[i].comp.ID == -1) - { - composevals.inputs[i].is_ID = FALSE; - composevals.inputs[i].comp.val = 0; - } - else - { - composevals.inputs[i].is_ID = TRUE; - } + composevals.inputs[i].is_object = FALSE; + composevals.inputs[i].comp.val = 0; + } + else + { + composevals.inputs[i].is_object = TRUE; } } break; case GIMP_RUN_WITH_LAST_VALS: - /* Possibly retrieve data */ gimp_get_data (name, &composevals); compose_by_drawable = TRUE; @@ -604,44 +707,41 @@ run (const gchar *name, } } - if (status == GIMP_PDB_SUCCESS) + gimp_progress_init (_("Composing")); + + image = compose (composevals.compose_type, + composevals.inputs, + compose_by_drawable); + + if (! image) + return gimp_procedure_new_return_values (procedure, + GIMP_PDB_EXECUTION_ERROR, + NULL); + + if (composevals.do_recompose) { - gimp_progress_init (_("Composing")); + gimp_displays_flush (); + } + else + { + gimp_image_undo_enable (image); + gimp_image_clean_all (image); - image_ID = compose (composevals.compose_type, - composevals.inputs, - compose_by_drawable); - - if (image_ID < 0) - { - status = GIMP_PDB_EXECUTION_ERROR; - } - else - { - values[1].data.d_int32 = image_ID; - - if (composevals.do_recompose) - { - gimp_displays_flush (); - } - else - { - gimp_image_undo_enable (image_ID); - gimp_image_clean_all (image_ID); - - if (run_mode != GIMP_RUN_NONINTERACTIVE) - gimp_display_new (image_ID); - } - } - - /* Store data */ - if (run_mode == GIMP_RUN_INTERACTIVE) - gimp_set_data (name, &composevals, sizeof (ComposeVals)); + if (run_mode != GIMP_RUN_NONINTERACTIVE) + gimp_display_new (image); } - *nreturn_vals = composevals.do_recompose ? 1 : 2; + if (run_mode == GIMP_RUN_INTERACTIVE) + gimp_set_data (name, &composevals, sizeof (ComposeVals)); - values[0].data.d_status = status; + return_vals = gimp_procedure_new_return_values (procedure, + GIMP_PDB_SUCCESS, + NULL); + + if (strcmp (name, RECOMPOSE_PROC)) + GIMP_VALUES_SET_IMAGE (return_vals, 1, image); + + return return_vals; } static void @@ -686,7 +786,7 @@ fill_buffer_from_components (GeglBuffer *temp[MAX_COMPOSE_IMAGES], for (j = 0; j < num_cpn; j++) { - if (inputs[j].is_ID) + if (inputs[j].is_object) gegl_buffer_iterator_add (gi, temp[j], NULL, 0, NULL, GEGL_ACCESS_READ, GEGL_ABYSS_NONE); } @@ -699,7 +799,7 @@ fill_buffer_from_components (GeglBuffer *temp[MAX_COMPOSE_IMAGES], count = 1; for (j = 0; j < num_cpn; j++) - if (inputs[j].is_ID) + if (inputs[j].is_object) src_data[j] = (gdouble*) gi->items[count++].data; for (k = 0; k < gi->length; k++) @@ -708,7 +808,7 @@ fill_buffer_from_components (GeglBuffer *temp[MAX_COMPOSE_IMAGES], for (j = 0; j < num_cpn; j++) { - if (inputs[j].is_ID) + if (inputs[j].is_object) dst_data[pos+j] = src_data[j][k]; else dst_data[pos+j] = mask_vals[j]; @@ -746,7 +846,7 @@ perform_composition (COMPOSE_DSC curr_compose_dsc, else gray_format = babl_format ("Y double"); - if (! inputs[i].is_ID) + if (! inputs[i].is_object) { const Babl *fish = babl_fish (babl_format ("Y' u8"), gray_format); @@ -789,14 +889,14 @@ perform_composition (COMPOSE_DSC curr_compose_dsc, gegl_buffer_copy (dst_temp, NULL, GEGL_ABYSS_NONE, buffer_dst, NULL); for (i = 0; i< num_images; i++) - if (inputs[i].is_ID) + if (inputs[i].is_object) g_object_unref (temp[i]); g_object_unref (dst_temp); } /* Compose an image from several gray-images */ -static gint32 +static GimpImage * compose (const gchar *compose_type, ComposeInput *inputs, gboolean compose_by_drawable) @@ -805,8 +905,9 @@ compose (const gchar *compose_type, gint num_images, compose_idx; gint i, j; gint num_layers; - gint32 layer_ID_dst, image_ID_dst; - gint first_ID; + GimpLayer *layer_dst; + GimpImage *image_dst; + gint first_object; GimpImageType gdtype_dst; GeglBuffer *buffer_src[MAX_COMPOSE_IMAGES]; GeglBuffer *buffer_dst; @@ -824,88 +925,74 @@ compose (const gchar *compose_type, } if (compose_idx < 0) - return -1; + return NULL; num_images = compose_dsc[compose_idx].num_images; /* Check that at least one image or one drawable is provided */ - first_ID = -1; + first_object = -1; for (i = 0; i < num_images; i++) { - if (inputs[i].is_ID) + if (inputs[i].is_object) { - first_ID = i; + first_object = i; break; } } - if (-1 == first_ID) + if (first_object == -1) { g_message (_("At least one image is needed to compose")); - return -1; + return NULL; } /* Check image sizes */ if (compose_by_drawable) { - gint32 first_image = gimp_item_get_image (inputs[first_ID].comp.ID); + GimpImage *first_image = gimp_item_get_image (inputs[first_object].comp.object); - if (! gimp_item_is_valid (inputs[first_ID].comp.ID)) - { - g_message (_("Specified layer %d not found"), - inputs[first_ID].comp.ID); - return -1; - } - - width = gimp_drawable_width (inputs[first_ID].comp.ID); - height = gimp_drawable_height (inputs[first_ID].comp.ID); + width = gimp_drawable_width (inputs[first_object].comp.object); + height = gimp_drawable_height (inputs[first_object].comp.object); precision = gimp_image_get_precision (first_image); - for (j = first_ID + 1; j < num_images; j++) + for (j = first_object + 1; j < num_images; j++) { - if (inputs[j].is_ID) + if (inputs[j].is_object) { - if (! gimp_item_is_valid (inputs[j].comp.ID)) - { - g_message (_("Specified layer %d not found"), - inputs[j].comp.ID); - return -1; - } - - if ((width != gimp_drawable_width (inputs[j].comp.ID)) || - (height != gimp_drawable_height (inputs[j].comp.ID))) + if ((width != gimp_drawable_width (inputs[j].comp.object)) || + (height != gimp_drawable_height (inputs[j].comp.object))) { g_message (_("Drawables have different size")); - return -1; + return NULL; } } } for (j = 0; j < num_images; j++) { - if (inputs[j].is_ID) - buffer_src[j] = gimp_drawable_get_buffer (inputs[j].comp.ID); + if (inputs[j].is_object) + buffer_src[j] = gimp_drawable_get_buffer (inputs[j].comp.object); else buffer_src[j] = NULL; } } - else /* Compose by image ID */ + else /* Compose by image */ { - width = gimp_image_width (inputs[first_ID].comp.ID); - height = gimp_image_height (inputs[first_ID].comp.ID); + width = gimp_image_width (inputs[first_object].comp.object); + height = gimp_image_height (inputs[first_object].comp.object); - precision = gimp_image_get_precision (inputs[first_ID].comp.ID); + precision = gimp_image_get_precision (inputs[first_object].comp.object); - for (j = first_ID + 1; j < num_images; j++) + for (j = first_object + 1; j < num_images; j++) { - if (inputs[j].is_ID) + if (inputs[j].is_object) { - if ((width != gimp_image_width (inputs[j].comp.ID)) || - (height != gimp_image_height (inputs[j].comp.ID))) + if ((width != gimp_image_width (inputs[j].comp.object)) || + (height != gimp_image_height (inputs[j].comp.object))) { g_message (_("Images have different size")); - return -1; + return NULL; } } } @@ -913,21 +1000,21 @@ compose (const gchar *compose_type, /* Get first layer/drawable for all input images */ for (j = 0; j < num_images; j++) { - if (inputs[j].is_ID) + if (inputs[j].is_object) { - gint32 *layers; + GimpLayer **layers; /* Get first layer of image */ - layers = gimp_image_get_layers (inputs[j].comp.ID, &num_layers); + layers = gimp_image_get_layers (inputs[j].comp.object, &num_layers); - if (! layers || (num_layers <= 0)) + if (! layers) { g_message (_("Error in getting layer IDs")); - return -1; + return NULL; } /* Get drawable for layer */ - buffer_src[j] = gimp_drawable_get_buffer (layers[0]); + buffer_src[j] = gimp_drawable_get_buffer (GIMP_DRAWABLE (layers[0])); g_free (layers); } } @@ -936,34 +1023,26 @@ compose (const gchar *compose_type, /* Unless recomposing, create new image */ if (composevals.do_recompose) { - layer_ID_dst = composevals.source_layer_ID; - - if (! gimp_item_is_valid (layer_ID_dst)) - { - g_message (_("Unable to recompose, source layer not found")); - return -1; - } - - image_ID_dst = gimp_item_get_image (layer_ID_dst); - - buffer_dst = gimp_drawable_get_shadow_buffer (layer_ID_dst); + layer_dst = composevals.source_layer; + image_dst = gimp_item_get_image (GIMP_ITEM (layer_dst)); + buffer_dst = gimp_drawable_get_shadow_buffer (GIMP_DRAWABLE (layer_dst)); } else { gdtype_dst = ((babl_model (compose_dsc[compose_idx].babl_model) == babl_model ("RGBA")) ? GIMP_RGBA_IMAGE : GIMP_RGB_IMAGE); - image_ID_dst = create_new_image (compose_dsc[compose_idx].filename, - width, height, gdtype_dst, precision, - &layer_ID_dst, &buffer_dst); + image_dst = create_new_image (compose_dsc[compose_idx].filename, + width, height, gdtype_dst, precision, + &layer_dst, &buffer_dst); } if (! compose_by_drawable) { gdouble xres, yres; - gimp_image_get_resolution (inputs[first_ID].comp.ID, &xres, &yres); - gimp_image_set_resolution (image_ID_dst, xres, yres); + gimp_image_get_resolution (inputs[first_object].comp.object, &xres, &yres); + gimp_image_set_resolution (image_dst, xres, yres); } perform_composition (compose_dsc[compose_idx], @@ -976,35 +1055,35 @@ compose (const gchar *compose_type, for (j = 0; j < num_images; j++) { - if (inputs[j].is_ID) + if (inputs[j].is_object) g_object_unref (buffer_src[j]); } g_object_unref (buffer_dst); if (composevals.do_recompose) - gimp_drawable_merge_shadow (layer_ID_dst, TRUE); + gimp_drawable_merge_shadow (GIMP_DRAWABLE (layer_dst), TRUE); - gimp_drawable_update (layer_ID_dst, 0, 0, - gimp_drawable_width (layer_ID_dst), - gimp_drawable_height (layer_ID_dst)); + gimp_drawable_update (GIMP_DRAWABLE (layer_dst), 0, 0, + gimp_drawable_width (GIMP_DRAWABLE (layer_dst)), + gimp_drawable_height (GIMP_DRAWABLE (layer_dst))); - return image_ID_dst; + return image_dst; } -/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */ -static gint32 +/* Create an image. Sets layer_ID, drawable and rgn. Returns image */ +static GimpImage * create_new_image (const gchar *filename, guint width, guint height, GimpImageType gdtype, GimpPrecision precision, - gint32 *layer_ID, + GimpLayer **layer, GeglBuffer **buffer) { - gint32 image_ID; - GimpImageBaseType gitype; + GimpImage *image; + GimpImageBaseType gitype; if ((gdtype == GIMP_GRAY_IMAGE) || (gdtype == GIMP_GRAYA_IMAGE)) gitype = GIMP_GRAY; @@ -1013,26 +1092,26 @@ create_new_image (const gchar *filename, else gitype = GIMP_RGB; - image_ID = gimp_image_new_with_precision (width, height, gitype, precision); + image = gimp_image_new_with_precision (width, height, gitype, precision); - gimp_image_undo_disable (image_ID); - gimp_image_set_filename (image_ID, filename); + gimp_image_undo_disable (image); + gimp_image_set_filename (image, filename); - *layer_ID = gimp_layer_new (image_ID, _("Background"), width, height, - gdtype, - 100, - gimp_image_get_default_new_layer_mode (image_ID)); - gimp_image_insert_layer (image_ID, *layer_ID, -1, 0); + *layer = gimp_layer_new (image, _("Background"), width, height, + gdtype, + 100, + gimp_image_get_default_new_layer_mode (image)); + gimp_image_insert_layer (image, *layer, NULL, 0); - *buffer = gimp_drawable_get_buffer (*layer_ID); + *buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (*layer)); - return image_ID; + return image; } static gboolean -compose_dialog (const gchar *compose_type, - gint32 drawable_ID) +compose_dialog (const gchar *compose_type, + GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; @@ -1043,7 +1122,7 @@ compose_dialog (const gchar *compose_type, GtkWidget *combo; GtkWidget *grid; GtkSizeGroup *size_group; - gint32 *layer_list; + GimpLayer **layer_list; gint nlayers; gint j; gboolean run; @@ -1060,12 +1139,12 @@ compose_dialog (const gchar *compose_type, } /* Save original image width/height */ - composeint.width = gimp_drawable_width (drawable_ID); - composeint.height = gimp_drawable_height (drawable_ID); + composeint.width = gimp_drawable_width (drawable); + composeint.height = gimp_drawable_height (drawable); gimp_ui_init (PLUG_IN_BINARY, TRUE); - layer_list = gimp_image_get_layers (gimp_item_get_image (drawable_ID), + layer_list = gimp_image_get_layers (gimp_item_get_image (GIMP_ITEM (drawable)), &nlayers); dialog = gimp_dialog_new (_("Compose"), PLUG_IN_ROLE, @@ -1181,14 +1260,14 @@ compose_dialog (const gchar *compose_type, nlayers >= compose_dsc[composeint.compose_idx].num_images && j < nlayers) { - composeint.selected[j].comp.ID = layer_list[j]; + composeint.selected[j].comp.object = layer_list[j]; } else { - composeint.selected[j].comp.ID = drawable_ID; + composeint.selected[j].comp.object = drawable; } - composeint.selected[j].is_ID = TRUE; + composeint.selected[j].is_object = TRUE; combo = gimp_drawable_combo_box_new (check_gray, NULL, NULL); composeint.channel_menu[j] = combo; @@ -1224,7 +1303,7 @@ compose_dialog (const gchar *compose_type, * combo_callback has any scale and spinbutton to work with */ gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), - composeint.selected[j].comp.ID, + gimp_item_get_id (composeint.selected[j].comp.object), G_CALLBACK (combo_callback), GINT_TO_POINTER (j), NULL); } @@ -1249,10 +1328,10 @@ compose_dialog (const gchar *compose_type, for (j = 0; j < MAX_COMPOSE_IMAGES; j++) { - composevals.inputs[j].is_ID = composeint.selected[j].is_ID; + composevals.inputs[j].is_object = composeint.selected[j].is_object; - if (composevals.inputs[j].is_ID) - composevals.inputs[j].comp.ID = composeint.selected[j].comp.ID; + if (composevals.inputs[j].is_object) + composevals.inputs[j].comp.object = composeint.selected[j].comp.object; else composevals.inputs[j].comp.val = composeint.selected[j].comp.val; } @@ -1267,14 +1346,14 @@ compose_dialog (const gchar *compose_type, /* Compose interface functions */ static gboolean -check_gray (gint32 image_id, - gint32 drawable_id, - gpointer data) +check_gray (GimpImage *image, + GimpItem *drawable, + gpointer data) { - return ((gimp_image_base_type (image_id) == GIMP_GRAY) && - (gimp_image_width (image_id) == composeint.width) && - (gimp_image_height (image_id) == composeint.height)); + return ((gimp_image_base_type (image) == GIMP_GRAY) && + (gimp_image_width (image) == composeint.width) && + (gimp_image_height (image) == composeint.height)); } static void @@ -1294,7 +1373,7 @@ check_response (GtkWidget *dialog, for (i = 0; i < nb; i++) { - if (composeint.selected[i].is_ID) + if (composeint.selected[i].is_object) { has_image = TRUE; break; @@ -1339,17 +1418,17 @@ combo_callback (GimpIntComboBox *widget, gtk_widget_set_sensitive (composeint.color_scales[n], TRUE); gtk_widget_set_sensitive (composeint.color_spins[n], TRUE); - composeint.selected[n].is_ID = FALSE; - composeint.selected[n].comp.val = - gtk_range_get_value (GTK_RANGE (composeint.color_scales[n])); + composeint.selected[n].is_object = FALSE; + composeint.selected[n].comp.val = + gtk_range_get_value (GTK_RANGE (composeint.color_scales[n])); } else { gtk_widget_set_sensitive (composeint.color_scales[n], FALSE); gtk_widget_set_sensitive (composeint.color_spins[n], FALSE); - composeint.selected[n].is_ID = TRUE; - composeint.selected[n].comp.ID = id; + composeint.selected[n].is_object = TRUE; + composeint.selected[n].comp.object = gimp_item_get_by_id (id); } } @@ -1400,7 +1479,7 @@ type_combo_callback (GimpIntComboBox *combo, combo4 = (compose_dsc[compose_idx].num_images == 4); gtk_widget_set_sensitive (composeint.channel_menu[3], combo4); - scale4 = combo4 && !composeint.selected[3].is_ID; + scale4 = combo4 && !composeint.selected[3].is_object; gtk_widget_set_sensitive (composeint.color_scales[3], scale4); gtk_widget_set_sensitive (composeint.color_spins[3], scale4); } diff --git a/plug-ins/common/plugin-defs.pl b/plug-ins/common/plugin-defs.pl index 657683aa75..b6eda61dec 100644 --- a/plug-ins/common/plugin-defs.pl +++ b/plug-ins/common/plugin-defs.pl @@ -8,7 +8,7 @@ 'checkerboard' => { ui => 1, gegl => 1 }, 'cml-explorer' => { ui => 1, gegl => 1, old_api => 1 }, 'colormap-remap' => { ui => 1, gegl => 1 }, - 'compose' => { ui => 1, gegl => 1, old_api => 1 }, + 'compose' => { ui => 1, gegl => 1 }, 'contrast-retinex' => { ui => 1, gegl => 1 }, 'crop-zealous' => { gegl => 1, old_api => 1 }, 'curve-bend' => { ui => 1, gegl => 1, old_api => 1 },