static gint32 tile (gint32 image_id, gint32 drawable_id, gint32 *layer_id) { GimpPixelRgn src_rgn; GimpPixelRgn dest_rgn; GimpDrawable *drawable; GimpDrawable *new_layer; GimpImageBaseType image_type = GIMP_RGB; gint32 new_image_id = 0; gint old_width; gint old_height; gint i, j; gint progress; gint max_progress; gpointer pr; /* sanity check parameters */ if (tvals.new_width < 1 || tvals.new_height < 1) { *layer_id = -1; return -1; } /* initialize */ old_width = gimp_drawable_width (drawable_id); old_height = gimp_drawable_height (drawable_id); if (tvals.new_image) { /* create a new image */ switch (gimp_drawable_type (drawable_id)) { case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE: image_type = GIMP_RGB; break; case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE: image_type = GIMP_GRAY; break; case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE: image_type = GIMP_INDEXED; break; } new_image_id = gimp_image_new (tvals.new_width, tvals.new_height, image_type); gimp_image_undo_disable (new_image_id); *layer_id = gimp_layer_new (new_image_id, _("Background"), tvals.new_width, tvals.new_height, gimp_drawable_type (drawable_id), 100, GIMP_NORMAL_MODE); if (*layer_id == -1) return -1; gimp_image_add_layer (new_image_id, *layer_id, 0); new_layer = gimp_drawable_get (*layer_id); /* Get the source drawable */ drawable = gimp_drawable_get (drawable_id); } else { gimp_image_undo_group_start (image_id); gimp_image_resize (image_id, tvals.new_width, tvals.new_height, 0, 0); if (gimp_drawable_is_layer (drawable_id)) gimp_layer_resize (drawable_id, tvals.new_width, tvals.new_height, 0, 0); /* Get the source drawable */ drawable = gimp_drawable_get (drawable_id); new_layer = drawable; } /* progress */ progress = 0; max_progress = tvals.new_width * tvals.new_height; /* tile... */ for (i = 0; i < tvals.new_height; i += old_height) { gint height = old_height; if (height + i > tvals.new_height) height = tvals.new_height - i; for (j = 0; j < tvals.new_width; j += old_width) { gint width = old_width; gint c; if (width + j > tvals.new_width) width = tvals.new_width - j; gimp_pixel_rgn_init (&src_rgn, drawable, 0, 0, width, height, FALSE, FALSE); gimp_pixel_rgn_init (&dest_rgn, new_layer, j, i, width, height, TRUE, FALSE); for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn), c = 0; pr != NULL; pr = gimp_pixel_rgns_process (pr), c++) { gint k; for (k = 0; k < src_rgn.h; k++) memcpy (dest_rgn.data + k * dest_rgn.rowstride, src_rgn.data + k * src_rgn.rowstride, src_rgn.w * src_rgn.bpp); progress += src_rgn.w * src_rgn.h; if (c % 16 == 0) gimp_progress_update ((gdouble) progress / (gdouble) max_progress); } } } gimp_drawable_update (new_layer->drawable_id, 0, 0, new_layer->width, new_layer->height); gimp_drawable_detach (drawable); if (tvals.new_image) { gimp_drawable_detach (new_layer); /* copy the colormap, if necessary */ if (image_type == GIMP_INDEXED) { guchar *cmap; gint ncols; cmap = gimp_image_get_colormap (image_id, &ncols); gimp_image_set_colormap (new_image_id, cmap, ncols); g_free (cmap); } gimp_image_undo_enable (new_image_id); } else { gimp_image_undo_group_end (image_id); } return new_image_id; }
gint dialog_I (PlugInImageVals * image_vals, PlugInDrawableVals * drawable_vals, PlugInVals * vals, PlugInUIVals * ui_vals, PlugInColVals * col_vals, PlugInDialogVals * dialog_vals) { gint32 image_ID; gint32 layer_ID; gint orig_width, orig_height; GtkWidget *main_hbox; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *vbox3; GtkWidget *hbox; GtkWidget *hbox2; GtkWidget *frame; GtkWidget *filler; GtkWidget *pres_use_image; GtkWidget *disc_use_image; GtkWidget *rigmask_use_image; //GtkWidget *noninter_button; GtkWidget *resetvalues_event_box; GtkWidget *resetvalues_button; GtkWidget *resetvalues_icon; GtkWidget *flatten_event_box; GtkWidget *flatten_button; GtkWidget *flatten_icon; GtkWidget *show_info_event_box; GtkWidget *show_info_button; GtkWidget *show_info_icon; GtkWidget *dump_event_box; GtkWidget *dump_button; GtkWidget *dump_icon; //GtkWidget *lastvalues_event_box; //GtkWidget *lastvalues_button; //GtkWidget *lastvalues_icon; gboolean has_mask = FALSE; GimpUnit unit; gdouble xres, yres; GtkWidget * v_separator; GtkWidget *info_title_label; GtkWidget * info_label; CarverData * carver_data; image_ID = image_vals->image_ID; layer_ID = drawable_vals->layer_ID; state = g_new (PlugInVals, 1); memcpy (state, vals, sizeof (PlugInVals)); ui_state = g_new (PlugInUIVals, 1); memcpy (ui_state, ui_vals, sizeof (PlugInUIVals)); dialog_state = dialog_vals; orig_width = gimp_drawable_width (layer_ID); orig_height = gimp_drawable_height (layer_ID); g_assert (gimp_drawable_is_layer (layer_ID) == TRUE); interface_I_data.orig_width = orig_width; interface_I_data.orig_height = orig_height; interface_I_data.col_vals = col_vals; interface_I_data.vmap_layer_ID = -1; reader_go = TRUE; if (gimp_layer_get_mask (layer_ID) != -1) { has_mask = TRUE; } dlg = gtk_dialog_new_with_buttons (_("GIMP LiquidRescale Plug-In"), NULL, 0, //GIMP_STOCK_RESET, RESPONSE_RESET, //GTK_STOCK_REFRESH, RESPONSE_REFRESH, GTK_STOCK_GO_BACK, RESPONSE_NONINTERACTIVE, GTK_STOCK_CLOSE, GTK_RESPONSE_OK, NULL); gtk_window_set_resizable (GTK_WINDOW (dlg), FALSE); gtk_window_set_keep_above(GTK_WINDOW (dlg), TRUE); if (dialog_state->has_pos) { //printf("move window, x,y=%i,%i\n", dialog_state->x, dialog_state->y); fflush(stdout); gtk_window_move (GTK_WINDOW(dlg), dialog_state->x, dialog_state->y); dialog_state->has_pos = FALSE; } g_signal_connect (dlg, "response", G_CALLBACK (callback_dialog_I_response), (gpointer) (NULL)); /* dlg_tips = gtk_tooltips_new (); */ main_hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG (dlg))), main_hbox); vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); /* New size */ frame = gimp_frame_new (_("Set width and height")); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); hbox = gtk_hbox_new (FALSE, 4); gtk_container_add (GTK_CONTAINER (frame), hbox); gtk_widget_show (hbox); vbox3 = gtk_vbox_new (FALSE, 4); gtk_box_pack_start (GTK_BOX (hbox), vbox3, FALSE, FALSE, 0); gtk_widget_show (vbox3); unit = gimp_image_get_unit (image_ID); gimp_image_get_resolution (image_ID, &xres, &yres); coordinates = alt_coordinates_new (unit, "%p", TRUE, TRUE, SPIN_BUTTON_WIDTH, ALT_SIZE_ENTRY_UPDATE_SIZE, ui_state->chain_active, TRUE, _("Width:"), state->new_width, xres, 2, GIMP_MAX_IMAGE_SIZE, 0, orig_width, _("Height:"), state->new_height, yres, 2, GIMP_MAX_IMAGE_SIZE, 0, orig_height); interface_I_data.coordinates = coordinates; g_signal_connect (ALT_SIZE_ENTRY (coordinates), "value-changed", G_CALLBACK (callback_size_changed), (gpointer) & interface_I_data); g_signal_connect (ALT_SIZE_ENTRY (coordinates), "refval-changed", G_CALLBACK (callback_size_changed), (gpointer) & interface_I_data); g_signal_connect (ALT_SIZE_ENTRY (coordinates), "coordinates-alarm", G_CALLBACK (callback_alarm_triggered), (gpointer) & interface_I_data); gtk_box_pack_start (GTK_BOX (vbox3), coordinates, FALSE, FALSE, 0); gtk_widget_show (coordinates); /* Aux layer usage icons */ hbox2 = gtk_hbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (hbox2), 4); gtk_box_pack_start (GTK_BOX (vbox3), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); filler = gtk_image_new (); gtk_box_pack_start (GTK_BOX (hbox2), filler, TRUE, TRUE, 0); gtk_widget_show (filler); filler = gtk_image_new (); gtk_box_pack_end (GTK_BOX (hbox2), filler, TRUE, TRUE, 0); gtk_widget_show (filler); pres_use_image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_GREEN, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox2), pres_use_image, FALSE, FALSE, 0); gtk_widget_show (pres_use_image); disc_use_image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_RED, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (hbox2), disc_use_image, FALSE, FALSE, 0); gtk_widget_show (disc_use_image); rigmask_use_image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_BLUE, GTK_ICON_SIZE_MENU); gtk_widget_show (rigmask_use_image); gtk_box_pack_start (GTK_BOX (hbox2), rigmask_use_image, FALSE, FALSE, 0); update_info_aux_use_icons(vals, ui_vals, pres_use_image, disc_use_image, rigmask_use_image); /* Reset size button */ vbox2 = gtk_vbox_new (FALSE, 4); gtk_box_pack_end (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0); gtk_widget_show (vbox2); resetvalues_event_box = gtk_event_box_new (); gtk_box_pack_start (GTK_BOX (vbox2), resetvalues_event_box, FALSE, FALSE, 0); gtk_widget_show (resetvalues_event_box); gimp_help_set_help_data (resetvalues_event_box, _ ("Reset width and height to their original values"), NULL); resetvalues_button = gtk_button_new (); resetvalues_icon = gtk_image_new_from_stock (GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_container_add (GTK_CONTAINER (resetvalues_button), resetvalues_icon); gtk_widget_show (resetvalues_icon); gtk_container_add (GTK_CONTAINER (resetvalues_event_box), resetvalues_button); gtk_widget_show (resetvalues_button); g_signal_connect (resetvalues_button, "clicked", G_CALLBACK (callback_resetvalues_button), (gpointer) & interface_I_data); /* Map info */ v_separator = gtk_vseparator_new(); gtk_box_pack_start (GTK_BOX (main_hbox), v_separator, TRUE, TRUE, 0); gtk_widget_show(v_separator); vbox = gtk_vbox_new (FALSE, 4); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); hbox2 = gtk_hbox_new (FALSE, 4); gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); info_title_label = gtk_label_new (""); /* Please keep the <b> and </b> tags in translations */ gtk_label_set_markup(GTK_LABEL(info_title_label), _("<b>Map</b>")); gtk_box_pack_start (GTK_BOX (hbox2), info_title_label, FALSE, FALSE, 0); gtk_widget_show (info_title_label); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); vbox2 = gtk_vbox_new (FALSE, 4); gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0); gtk_widget_show (vbox2); show_info_event_box = gtk_event_box_new (); gtk_box_pack_start (GTK_BOX (vbox2), show_info_event_box, FALSE, FALSE, 0); gtk_widget_show (show_info_event_box); gimp_help_set_help_data (show_info_event_box, _ ("Show/hide internal map information"), NULL); show_info_button = gtk_toggle_button_new (); show_info_icon = gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_MENU); gtk_container_add (GTK_CONTAINER (show_info_button), show_info_icon); gtk_widget_show (show_info_icon); gtk_container_add (GTK_CONTAINER (show_info_event_box), show_info_button); gtk_widget_show (show_info_button); g_signal_connect (show_info_button, "toggled", G_CALLBACK (callback_show_info_button), (gpointer) & interface_I_data); flatten_event_box = gtk_event_box_new (); gtk_box_pack_start (GTK_BOX (vbox2), flatten_event_box, FALSE, FALSE, 0); gtk_widget_show (flatten_event_box); gimp_help_set_help_data (flatten_event_box, _ ("Reset the internal map"), NULL); flatten_button = gtk_button_new (); flatten_icon = gtk_image_new_from_stock (GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU); gtk_container_add (GTK_CONTAINER (flatten_button), flatten_icon); gtk_widget_show (flatten_icon); gtk_container_add (GTK_CONTAINER (flatten_event_box), flatten_button); gtk_widget_show (flatten_button); g_signal_connect (flatten_button, "clicked", G_CALLBACK (callback_flatten_button), (gpointer) & interface_I_data); dump_event_box = gtk_event_box_new (); gtk_box_pack_start (GTK_BOX (vbox2), dump_event_box, FALSE, FALSE, 0); gtk_widget_show (dump_event_box); gimp_help_set_help_data (dump_event_box, _ ("Dump the internal map on a new layer (RGB images only)"), NULL); dump_button = gtk_button_new (); dump_icon = gtk_image_new_from_stock (GIMP_STOCK_VISIBLE, GTK_ICON_SIZE_MENU); gtk_container_add (GTK_CONTAINER (dump_button), dump_icon); gtk_widget_show (dump_icon); gtk_container_add (GTK_CONTAINER (dump_event_box), dump_button); gtk_widget_show (dump_button); g_signal_connect (dump_button, "clicked", G_CALLBACK (callback_dump_button), (gpointer) & interface_I_data); gtk_widget_set_sensitive(dump_button, FALSE); interface_I_data.dump_button = dump_button; info_label = gtk_label_new(""); //set_info_label_text (info_label, orig_width, orig_height, 0, 0, state->enl_step / 100); gtk_label_set_selectable(GTK_LABEL(info_label), TRUE); //gtk_container_add (GTK_CONTAINER (info_frame), info_label); gtk_box_pack_start (GTK_BOX (hbox), info_label, TRUE, TRUE, 0); gtk_label_set_justify(GTK_LABEL (info_label), GTK_JUSTIFY_LEFT); gtk_widget_show (info_label); //interface_I_data.info_frame = info_frame; interface_I_data.info_label = info_label; callback_show_info_button(show_info_button, (gpointer) &interface_I_data); /* noninter_button = gtk_button_new_with_mnemonic ("_Non-interactive"); g_signal_connect (GTK_BUTTON (noninter_button), "clicked", G_CALLBACK (callback_noninter_button), (gpointer) dlg); gtk_box_pack_start (GTK_BOX (vbox2), noninter_button, FALSE, FALSE, 0); gtk_widget_show (noninter_button); */ /* Initialize the carver */ AUX_LAYER_STATUS(state->pres_layer_ID, ui_state->pres_status); AUX_LAYER_STATUS(state->disc_layer_ID, ui_state->disc_status); AUX_LAYER_STATUS(state->rigmask_layer_ID, ui_state->rigmask_status); gimp_image_undo_group_start(image_ID); carver_data = render_init_carver(image_vals, drawable_vals, state, TRUE); gimp_image_undo_group_end(image_ID); if (carver_data == NULL) { return RESPONSE_FATAL; } interface_I_data.carver_data = carver_data; image_vals->image_ID = carver_data->image_ID; drawable_vals->layer_ID = carver_data->layer_ID; set_info_label_text (&interface_I_data); //set_alarm (ALARM_DELAY); size_changed = 1; /* register size reader */ g_timeout_add (READER_INTERVAL, check_size_changes, NULL); /* Show the main containers */ gtk_widget_show (main_hbox); gtk_widget_show (dlg); gtk_main (); lqr_carver_destroy (carver_data->carver); switch (dialog_I_response) { case RESPONSE_NONINTERACTIVE: switch (state->output_target) { case OUTPUT_TARGET_NEW_LAYER: case OUTPUT_TARGET_NEW_IMAGE: state->output_target = OUTPUT_TARGET_SAME_LAYER; break; case OUTPUT_TARGET_SAME_LAYER: default: break; } case GTK_RESPONSE_OK: /* Save ui values */ ui_state->chain_active = gimp_chain_button_get_active (GIMP_COORDINATES_CHAINBUTTON (coordinates)); /* save all */ memcpy (vals, state, sizeof (PlugInVals)); memcpy (ui_vals, ui_state, sizeof (PlugInUIVals)); break; default: break; } gtk_widget_destroy (dlg); reader_go = FALSE; return dialog_I_response; }
/* ----------------------------- * gap_fg_matting_exec_apply_run * ----------------------------- * handle undo, progress init and * apply the processing functions */ gint32 gap_fg_matting_exec_apply_run (gint32 image_id, gint32 drawable_id , gboolean doProgress, gboolean doFlush , GapFgExtractValues *fgValPtr) { gint32 retLayerId; gint32 oldLayerMaskId; gint32 triMapOrig; gint32 triMapRelevant; gint32 dummyLayerId; GimpDrawable *maskDrawable; GimpDrawable *activeDrawable; /* dont operate on other drawables than layers */ g_return_val_if_fail (gimp_drawable_is_layer(drawable_id), -1); globalDoProgress = doProgress; triMapOrig = fgValPtr->tri_map_drawable_id; /* try to use layermask as tri-mask * in case negative id was specified by the caller */ oldLayerMaskId = gimp_layer_get_mask(drawable_id); if (fgValPtr->tri_map_drawable_id < 0) { fgValPtr->tri_map_drawable_id = oldLayerMaskId; } gimp_image_undo_group_start (image_id); if (doProgress) { gimp_progress_init (_("Foreground Extract")); } activeDrawable = gimp_drawable_get (drawable_id); triMapRelevant = p_tri_map_preprocessing (activeDrawable, fgValPtr, &dummyLayerId); maskDrawable = gimp_drawable_get(triMapRelevant); if (maskDrawable == NULL) { gimp_image_undo_group_end (image_id); gimp_drawable_detach (activeDrawable); printf("ERROR: no valid tri-mask was specified\n"); return (-1); } if(gap_debug) { printf("gap_fg_matting_exec_apply_run START: drawableID:%d triMapOrig:%d tri_map_drawable_id:%d triMapRelevant:%d\n" " create_layermask:%d lock_color:%d " " create_result:%d colordiff_threshold:%.5f" "\n" , (int)drawable_id , (int)triMapOrig , (int)fgValPtr->tri_map_drawable_id , (int)triMapRelevant , (int)fgValPtr->create_layermask , (int)fgValPtr->lock_color , (int)fgValPtr->create_result , (float)fgValPtr->colordiff_threshold ); } retLayerId = gap_drawable_foreground_extract (activeDrawable, maskDrawable, fgValPtr); gimp_drawable_detach (maskDrawable); if(dummyLayerId >= 0) { if(gap_debug) { printf("removing dummy layer:%d\n" ,(int) dummyLayerId ); } gimp_image_remove_layer(image_id, dummyLayerId); } if (doProgress) { gimp_progress_update(1.0); } gimp_image_undo_group_end (image_id); if(gap_debug) { printf("gap_fg_matting_exec_apply_run DONE: retLayerId:%d\n" , (int)retLayerId ); } if (doFlush != FALSE) { gimp_drawable_flush (activeDrawable); } gimp_drawable_detach (activeDrawable); return (retLayerId); } /* end gap_fg_matting_exec_apply_run */
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpDrawable *drawable; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; gint32 image_ID; run_mode = param[0].data.d_int32; *nreturn_vals = 1; *return_vals = values; INIT_I18N (); values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; image_ID = param[1].data.d_image; drawable = gimp_drawable_get (param[2].data.d_drawable); switch (run_mode) { case GIMP_RUN_INTERACTIVE: gimp_get_data (PLUG_IN_PROC, &pvals); if (! color_to_alpha_dialog (drawable)) { gimp_drawable_detach (drawable); return; } break; case GIMP_RUN_NONINTERACTIVE: if (nparams != 4) status = GIMP_PDB_CALLING_ERROR; if (status == GIMP_PDB_SUCCESS) pvals.color = param[3].data.d_color; break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC, &pvals); break; default: break; } if (status == GIMP_PDB_SUCCESS && gimp_drawable_is_rgb (drawable->drawable_id) && gimp_drawable_is_layer (drawable->drawable_id)) { gboolean lock_alpha; gimp_image_undo_group_start (image_ID); /* Add alpha if not present */ gimp_layer_add_alpha (drawable->drawable_id); /* Reget the drawable, bpp might have changed */ drawable = gimp_drawable_get (drawable->drawable_id); /* Unset 'Lock alpha' */ lock_alpha = gimp_layer_get_lock_alpha (drawable->drawable_id); gimp_layer_set_lock_alpha (drawable->drawable_id, FALSE); gimp_progress_init (_("Removing color")); gimp_rgn_iterate2 (drawable, 0 /* unused */, to_alpha_func, NULL); gimp_layer_set_lock_alpha (drawable->drawable_id, lock_alpha); gimp_image_undo_group_end (image_ID); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); } gimp_drawable_detach (drawable); if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &pvals, sizeof (pvals)); values[0].data.d_status = status; }
static void run (const gchar *name, /* name of plugin */ gint nparams, /* number of in-paramters */ const GimpParam * param, /* in-parameters */ gint *nreturn_vals, /* number of out-parameters */ GimpParam ** return_vals) /* out-parameters */ { const gchar *l_env; gint32 image_id = -1; gint32 drawable_id = -1; gint32 trans_drawable_id = -1; /* Get the runmode from the in-parameters */ GimpRunMode run_mode = param[0].data.d_int32; /* status variable, use it to check for errors in invocation usualy only during non-interactive calling */ GimpPDBStatusType status = GIMP_PDB_SUCCESS; /* always return at least the status to the caller. */ static GimpParam values[2]; INIT_I18N(); l_env = g_getenv("GAP_DEBUG"); if(l_env != NULL) { if((*l_env != 'n') && (*l_env != 'N')) gap_debug = 1; } if(gap_debug) printf("\n\nDEBUG: run %s\n", name); /* initialize the return of the status */ values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; values[1].type = GIMP_PDB_DRAWABLE; values[1].data.d_drawable = -1; *nreturn_vals = 2; *return_vals = values; /* get image and drawable */ image_id = param[1].data.d_int32; drawable_id = param[2].data.d_int32; if (strcmp (name, PLUG_IN_PROC) == 0) { if(gimp_drawable_is_layer(drawable_id)) { gboolean run_flag; /* Initial values */ glob_vals.corpus_border_radius = 20; glob_vals.alt_selection = -1; run_flag = TRUE; /* Possibly retrieve data from a previous run */ gimp_get_data (name, &glob_vals); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Get information from the dialog */ run_flag = p_dialog(&glob_vals, drawable_id); break; case GIMP_RUN_NONINTERACTIVE: /* check to see if invoked with the correct number of parameters */ if (nparams >= global_number_in_args) { glob_vals.corpus_border_radius = param[3].data.d_int32; glob_vals.alt_selection = param[4].data.d_int32; glob_vals.seed = param[5].data.d_int32; } else { status = GIMP_PDB_CALLING_ERROR; } break; case GIMP_RUN_WITH_LAST_VALS: break; default: break; } /* here the action starts, we transform the drawable */ if(run_flag) { trans_drawable_id = p_process_layer(image_id , drawable_id , &glob_vals ); if (trans_drawable_id < 0) { status = GIMP_PDB_CALLING_ERROR; } else { values[1].data.d_drawable = drawable_id; /* Store variable states for next run * (the parameters for the transform wrapper plugins are stored * even if they contain just a dummy * this is done to fullfill the GIMP-GAP LAST_VALUES conventions * for filtermacro and animated calls) */ if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_set_data (name, &glob_vals, sizeof (TransValues)); } } } } else { status = GIMP_PDB_CALLING_ERROR; if (run_mode == GIMP_RUN_INTERACTIVE) { g_message(_("The plug-in %s\noperates only on layers\n" "(but was called on mask or channel)") , name ); } } } else { status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { /* If run mode is interactive, flush displays, else (script) don't * do it, as the screen updates would make the scripts slow */ if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); } values[0].data.d_status = status; } /* end run */