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; INIT_I18N(); run_mode = param[0].data.d_int32; /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); image_ID = param[1].data.d_image; /* Make sure that the drawable is gray or RGB color */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id)) { gimp_progress_init (_("Auto-Stretching HSV")); gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1)); autostretch_hsv (drawable); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); } else if (gimp_drawable_is_indexed (drawable->drawable_id)) { indexed_autostretch_hsv (image_ID); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); } else { /* gimp_message ("autostretch_hsv: cannot operate on indexed color images"); */ status = GIMP_PDB_EXECUTION_ERROR; } *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; GimpDrawable *drawable; /* Setting mandatory output values */ *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Getting run_mode - we won't display a dialog if * we are in NONINTERACTIVE mode */ run_mode = param[0].data.d_int32; /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); blur (drawable); gimp_displays_flush (); gimp_drawable_detach (drawable); return; }
static void waves (GimpDrawable *drawable) { GimpPixelRgn srcPr, dstPr; guchar *src, *dst; guint width, height, bpp, has_alpha; width = drawable->width; height = drawable->height; bpp = drawable->bpp; has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); src = g_new (guchar, width * height * bpp); dst = g_new (guchar, width * height * bpp); gimp_pixel_rgn_init (&srcPr, drawable, 0, 0, width, height, FALSE, FALSE); gimp_pixel_rgn_init (&dstPr, drawable, 0, 0, width, height, TRUE, TRUE); gimp_pixel_rgn_get_rect (&srcPr, src, 0, 0, width, height); wave (src, dst, width, height, bpp, has_alpha, width / 2.0, height / 2.0, wvals.amplitude, wvals.wavelength, wvals.phase, wvals.type == MODE_SMEAR, wvals.reflective, TRUE); gimp_pixel_rgn_set_rect (&dstPr, dst, 0, 0, width, height); g_free (src); g_free (dst); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, 0, 0, width, height); gimp_displays_flush (); }
static void make_preview (void) { destroy_preview (); if (jsvals.preview) { gchar *tn = gimp_temp_name ("jpeg"); if (! undo_touched) { /* we freeze undo saving so that we can avoid sucking up * tile cache with our unneeded preview steps. */ gimp_image_undo_freeze (preview_image_ID); undo_touched = TRUE; } save_image (tn, preview_image_ID, drawable_ID_global, orig_image_ID_global, TRUE, NULL); if (display_ID == -1) display_ID = gimp_display_new (preview_image_ID); } else { gtk_label_set_text (GTK_LABEL (preview_size), _("File size: unknown")); gimp_displays_flush (); } }
static void compute_image (GimpDrawable *drawable) { GimpDrawable *effect; guchar *scalarfield = NULL; /* Get some useful info on the input drawable */ /* ========================================== */ if (! gimp_drawable_mask_intersect (drawable->drawable_id, &border_x, &border_y, &border_w, &border_h)) return; gimp_progress_init (_("Van Gogh (LIC)")); if (licvals.effect_convolve == 0) generatevectors (); if (licvals.filtlen < 0.1) licvals.filtlen = 0.1; l = licvals.filtlen; dx = dy = licvals.noisemag; minv = licvals.minv / 10.0; maxv = licvals.maxv / 10.0; isteps = licvals.intsteps; source_drw_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); effect = gimp_drawable_get (licvals.effect_image_id); effect_width = effect->width; effect_height = effect->height; switch (licvals.effect_channel) { case 0: scalarfield = rgb_to_hsl (effect, LIC_HUE); break; case 1: scalarfield = rgb_to_hsl (effect, LIC_SATURATION); break; case 2: scalarfield = rgb_to_hsl (effect, LIC_BRIGHTNESS); break; } compute_lic (drawable, scalarfield, licvals.effect_operator); g_free (scalarfield); /* Update image */ /* ============ */ gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, border_x, border_y, border_w, border_h); gimp_displays_flush (); }
static void callback_alarm_triggered (GtkWidget * size_entry, gpointer data) { gint new_width, new_height; gboolean render_success; InterfaceIData *p_data = INTERFACE_I_DATA (data); CarverData *c_data = p_data->carver_data; //gtk_widget_set_sensitive (p_data->size_frame, FALSE); new_width = ROUND (alt_size_entry_get_refval (ALT_SIZE_ENTRY (size_entry), 0)); new_height = ROUND (alt_size_entry_get_refval (ALT_SIZE_ENTRY (size_entry), 1)); state->new_width = new_width; state->new_height = new_height; gimp_image_undo_group_start (c_data->image_ID); render_success = render_interactive (state, p_data->carver_data); gimp_image_undo_group_end (c_data->image_ID); /* p_data->drawable_vals->layer_ID = c_data->layer_ID; */ if (!render_success) { dialog_I_response = RESPONSE_FATAL; gtk_main_quit(); } gimp_displays_flush(); set_info_label_text (p_data); //set_info_label_text (p_data->info_label, c_data->ref_w, c_data->ref_h, c_data->orientation, c_data->depth, c_data->enl_step); //gtk_widget_set_sensitive (p_data->dump_button, (c_data->depth != 0)); //gtk_widget_set_sensitive (p_data->size_frame, TRUE); }
static gboolean sel2path (gint32 image_ID) { gint32 selection_ID; pixel_outline_list_type olt; spline_list_array_type splines; gimp_selection_bounds (image_ID, &has_sel, &sel_x1, &sel_y1, &sel_x2, &sel_y2); sel_width = sel_x2 - sel_x1; sel_height = sel_y2 - sel_y1; /* Now get the selection channel */ selection_ID = gimp_image_get_selection (image_ID); if (selection_ID < 0) return FALSE; sel_buffer = gimp_drawable_get_buffer (selection_ID); olt = find_outline_pixels (); splines = fitted_splines (olt); do_points (splines, image_ID); g_object_unref (sel_buffer); gimp_displays_flush (); return TRUE; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; gint32 image_ID; GimpPDBStatusType status = GIMP_PDB_SUCCESS; *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; INIT_I18N(); image_ID = param[1].data.d_image; if (status == GIMP_PDB_SUCCESS) { gimp_progress_init (_("Guillotine")); guillotine (image_ID); gimp_displays_flush (); } values[0].data.d_status = status; }
void imgproc::dilate::run(GimpRunMode, gint32 /*imageId*/, gint32 drawableId) { boost::optional<Arguments> arguments = presentDialog(); if (!arguments) { return; } GimpDrawable* const drawable = gimp_drawable_get(drawableId); try { cv::Mat src = drawableToMat(drawable); cv::Mat dst; cv::dilate(src, dst, UNPACK_TUPLE(*arguments, 0, 4)); setMatToDrawable(dst, drawable); } catch (cv::Exception const& e) { messageDialog(e.what()); } catch (IncompatibleMat const& e) { messageDialog(e.what()); } gimp_displays_flush(); gimp_drawable_detach(drawable); }
static void run (const gchar *name, gint n_params, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 image_id; *nreturn_vals = 1; *return_vals = values; run_mode = param[0].data.d_int32; if (run_mode == GIMP_RUN_NONINTERACTIVE) { if (n_params != 3) { status = GIMP_PDB_CALLING_ERROR; } } if (status == GIMP_PDB_SUCCESS) { /* Get the specified drawable */ drawable = gimp_drawable_get(param[2].data.d_drawable); image_id = param[1].data.d_image; /* Make sure that the drawable is gray or RGB or indexed */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id) || gimp_drawable_is_indexed (drawable->drawable_id)) { gimp_progress_init ("Autocropping..."); gimp_tile_cache_ntiles (1 + (drawable->width > drawable->height ? (drawable->width / gimp_tile_width()) : (drawable->height / gimp_tile_height()))); do_acrop(drawable, image_id); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); gimp_drawable_detach (drawable); } else { status = GIMP_PDB_EXECUTION_ERROR; } } values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; }
static void run (const gchar *name, gint n_params, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 drawable_id; gint32 image_id; INIT_I18N (); gegl_init (NULL, NULL); *nreturn_vals = 1; *return_vals = values; run_mode = param[0].data.d_int32; if (run_mode == GIMP_RUN_NONINTERACTIVE) { if (n_params != 3) { status = GIMP_PDB_CALLING_ERROR; } } if (status == GIMP_PDB_SUCCESS) { /* Get the specified drawable */ image_id = param[1].data.d_int32; drawable_id = param[2].data.d_int32; /* Make sure that the drawable is gray or RGB or indexed */ if (gimp_drawable_is_rgb (drawable_id) || gimp_drawable_is_gray (drawable_id) || gimp_drawable_is_indexed (drawable_id)) { gimp_progress_init (_("Zealous cropping")); do_zcrop (drawable_id, image_id); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); } else { status = GIMP_PDB_EXECUTION_ERROR; } } values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; gegl_exit (); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR; GimpRunMode run_mode; gint image_id, layer_num; run_mode = param[0].data.d_int32; image_id = param[1].data.d_int32; INIT_I18N (); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; switch ( run_mode ) { case GIMP_RUN_INTERACTIVE: gimp_image_get_layers (image_id, &layer_num); if (layer_num < 2) { *nreturn_vals = 2; values[1].type = GIMP_PDB_STRING; values[1].data.d_string = _("There are not enough layers to align."); return; } gimp_get_data (PLUG_IN_PROC, &VALS); VALS.grid_size = MAX (VALS.grid_size, 1); if (! align_layers_dialog ()) return; break; case GIMP_RUN_NONINTERACTIVE: break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC, &VALS); break; } status = align_layers (image_id); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS) gimp_set_data (PLUG_IN_PROC, &VALS, sizeof (ValueType)); values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; GimpDrawable *drawable; INIT_I18N (); run_mode = param[0].data.d_int32; drawable = gimp_drawable_get (param[2].data.d_int32); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; switch (run_mode) { case GIMP_RUN_INTERACTIVE: gimp_get_data (HSV_NOISE_PROC, &VALS); if (!gimp_drawable_is_rgb (drawable->drawable_id)) { g_message (_("Can only operate on RGB drawables.")); return; } if (! scatter_hsv_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: VALS.holdness = CLAMP (param[3].data.d_int32, 1, 8); VALS.hue_distance = CLAMP (param[4].data.d_int32, 0, 180); VALS.saturation_distance = CLAMP (param[5].data.d_int32, 0, 255); VALS.value_distance = CLAMP (param[6].data.d_int32, 0, 255); break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (HSV_NOISE_PROC, &VALS); break; } scatter_hsv (drawable); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush(); if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS ) gimp_set_data (HSV_NOISE_PROC, &VALS, sizeof (ValueType)); values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; }
static void run (const gchar *name, gint n_params, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gboolean diff_only = FALSE; *nreturn_vals = 2; *return_vals = values; run_mode = param[0].data.d_int32; INIT_I18N (); if (run_mode == GIMP_RUN_NONINTERACTIVE && n_params != 3) { status = GIMP_PDB_CALLING_ERROR; } /* Check the procedure name we were called with, to decide what needs to be done. */ if (strcmp (name, OPTIMIZE_PROC) == 0) opmode = OPOPTIMIZE; else if (strcmp (name, OPTIMIZE_DIFF_PROC) == 0) { opmode = OPOPTIMIZE; diff_only = TRUE; } else if (strcmp (name, UNOPTIMIZE_PROC) == 0) opmode = OPUNOPTIMIZE; else if (strcmp (name, FIND_BACKDROP_PROC) == 0) opmode = OPBACKGROUND; else if (strcmp (name, REMOVE_BACKDROP_PROC) == 0) opmode = OPFOREGROUND; else g_error("GAH!!!"); if (status == GIMP_PDB_SUCCESS) { image_id = param[1].data.d_image; new_image_id = do_optimizations (run_mode, diff_only); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush(); } values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; values[1].type = GIMP_PDB_IMAGE; values[1].data.d_image = new_image_id; }
gint32 execute_plugin(GimpDrawable* d, const char *nome, param_type *p) { // gint i; guchar *img, *org; gint x,y,x2,y2,w,h; // guchar *work; GimpPixelRgn region, rgn_org; gint bpp = d->bpp; gimp_drawable_mask_bounds(d->drawable_id, &x, &y, &x2, &y2); w = x2 - x; h = y2 - y; img = malloc(w * h * bpp); org = malloc(w * h * bpp); // work = malloc(d.width * d.height * bpp); gimp_pixel_rgn_init(®ion, d, x, y, w, h, TRUE, TRUE); //este é buffer para gravar a imagem modificada. gimp_pixel_rgn_init(&rgn_org, d, x, y, w, h, FALSE, FALSE); // Esta é a imagem em si gimp_pixel_rgn_get_rect(®ion, img, x, y, w, h); gimp_pixel_rgn_get_rect(&rgn_org, org, x, y, w, h); switch (*nome) { case 'S': super_grow(p, org, img, w, h, bpp); break; case 'G': memcpy(img, org, w * h * bpp); grow(p, org, img, w, h, bpp); break; case 'A': find_iso(p, org, img, w, h, bpp); break; default: make_height_field(p, org, img, w, h, bpp); break; } gimp_pixel_rgn_set_rect(®ion, img, x, y, w, h); /* finish the process */ gimp_drawable_flush (d); gimp_drawable_merge_shadow (d->drawable_id, TRUE); gimp_drawable_update (d->drawable_id, x, y, w, h); gimp_displays_flush(); gimp_drawable_detach(d); free(img); free(org); return GIMP_PDB_SUCCESS; }
/* Update Gimp image from local pixmap. Canonical postlude for plugins. !!! Called in the postlude but also for debugging: animate results during processing. */ static void post_results_to_gimp( GimpDrawable *drawable, Map targetMap) { pixmap_to_drawable(targetMap, drawable, FIRST_PIXELEL_INDEX); // our pixels to region gimp_drawable_flush(drawable); // regions back to core gimp_drawable_merge_shadow(drawable->drawable_id,TRUE); // temp buffers merged gimp_drawable_update(drawable->drawable_id,0,0,targetMap.width,targetMap.height); gimp_displays_flush(); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { GimpDrawable *drawable; static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR; GimpRunMode run_mode; run_mode = param[0].data.d_int32; drawable = gimp_drawable_get (param[2].data.d_drawable); INIT_I18N (); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; switch (run_mode) { case GIMP_RUN_INTERACTIVE: gimp_get_data (PLUG_IN_PROC, &pvals); /* Since a channel might be selected, we must check wheter RGB or not. */ if (!gimp_drawable_is_rgb (drawable->drawable_id)) { g_message (_("Can only operate on RGB drawables.")); return; } if (! max_rgb_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* You must copy the values of parameters to pvals or dialog variables. */ pvals.max_p = param[3].data.d_int32; break; case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC, &pvals); break; } status = main_function (drawable, NULL); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS) gimp_set_data (PLUG_IN_PROC, &pvals, sizeof (ValueType)); values[0].data.d_status = status; }
static GimpPDBStatusType run_pspi (const gchar *pdb_name, gint n_params, const GimpParam *param) { GimpRunMode run_mode = param[0].data.d_int32; GimpDrawable *drawable; GimpPDBStatusType status = GIMP_PDB_SUCCESS; PSPlugInEntry *pspie; gint x1, y1, x2, y2; get_saved_plugin_data (); if ((pspie = g_hash_table_lookup (entry_hash, pdb_name)) != NULL) { gchar *name; if (run_mode == GIMP_RUN_NONINTERACTIVE) { if (n_params != standard_nargs) return GIMP_PDB_CALLING_ERROR; } else if (run_mode == GIMP_RUN_INTERACTIVE) { if ((status = pspi_params (pspie)) != GIMP_PDB_SUCCESS) return status; } drawable = gimp_drawable_get (param[2].data.d_drawable); gimp_ui_init (PLUGIN_NAME, TRUE); if ((status = pspi_prepare (pspie, drawable)) != GIMP_PDB_SUCCESS) return status; name = g_strdup_printf (_("Applying %s:"), strrchr (pspie->menu_path, '/') + 1); gimp_progress_init (name); g_free (name); if ((status = pspi_apply (pspie, drawable)) != GIMP_PDB_SUCCESS) return status; gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1)); gimp_displays_flush (); return GIMP_PDB_SUCCESS; } return GIMP_PDB_CALLING_ERROR; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[3]; GimpRunMode run_mode = param[0].data.d_int32; GimpPDBStatusType status = GIMP_PDB_SUCCESS; *nreturn_vals = 3; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; values[1].type = GIMP_PDB_INT32; values[1].data.d_int32 = 0; values[2].type = GIMP_PDB_INT32ARRAY; values[2].data.d_int32array = NULL; INIT_I18N(); if (status == GIMP_PDB_SUCCESS) { GList *images; GList *list; gint i; gimp_progress_init (_("Guillotine")); images = guillotine (param[1].data.d_image, run_mode == GIMP_RUN_INTERACTIVE); values[1].data.d_int32 = g_list_length (images); values[2].data.d_int32array = g_new (gint32, values[1].data.d_int32); for (list = images, i = 0; list; list = g_list_next (list), i++) { values[2].data.d_int32array[i] = GPOINTER_TO_INT (list->data); } g_list_free (images); if (run_mode == GIMP_RUN_INTERACTIVE) gimp_displays_flush (); } values[0].data.d_status = status; }
static gboolean sel2path (gint32 image_ID) { gint32 selection_ID; GimpDrawable *sel_drawable; pixel_outline_list_type olt; spline_list_array_type splines; gimp_selection_bounds (image_ID, &has_sel, &sel_x1, &sel_y1, &sel_x2, &sel_y2); sel_width = sel_x2 - sel_x1; sel_height = sel_y2 - sel_y1; /* Now get the selection channel */ selection_ID = gimp_image_get_selection (image_ID); if (selection_ID < 0) return FALSE; sel_drawable = gimp_drawable_get (selection_ID); if (gimp_drawable_bpp (selection_ID) != 1) { g_warning ("Internal error. Selection bpp > 1"); return FALSE; } gimp_pixel_rgn_init (&selection_rgn, sel_drawable, sel_x1, sel_y1, sel_width, sel_height, FALSE, FALSE); gimp_tile_cache_ntiles (2 * (sel_drawable->width + gimp_tile_width () - 1) / gimp_tile_width ()); olt = find_outline_pixels (); splines = fitted_splines (olt); do_points (splines, image_ID); gimp_drawable_detach (sel_drawable); gimp_displays_flush (); return TRUE; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; *nreturn_vals = 1; *return_vals = values; INIT_I18N (); values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; Current.drawable = gimp_drawable_get (param[2].data.d_drawable); Current.mask = gimp_drawable_get (gimp_image_get_selection (param[1].data.d_image)); if (gimp_drawable_is_rgb (Current.drawable->drawable_id)) { if (color_rotate_dialog ()) { gimp_progress_init (_("Rotating the colors")); gimp_tile_cache_ntiles (2 * (Current.drawable->width / gimp_tile_width () + 1)); color_rotate (Current.drawable); gimp_displays_flush (); } else { status = GIMP_PDB_CANCEL; } } else { status = GIMP_PDB_EXECUTION_ERROR; } values[0].data.d_status = status; if (status == GIMP_PDB_SUCCESS) gimp_drawable_detach (Current.drawable); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 drawable_id; gint x, y, width, height; *nreturn_vals = 1; *return_vals = values; gegl_init (NULL, NULL); values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; INIT_I18N(); drawable_id = param[2].data.d_drawable; if (gimp_drawable_mask_intersect (drawable_id, &x, &y, &width, &height)) { GeglBuffer *buffer; GeglBuffer *shadow_buffer; buffer = gimp_drawable_get_buffer (drawable_id); shadow_buffer = gimp_drawable_get_shadow_buffer (drawable_id); gegl_render_op (buffer, shadow_buffer, "gegl:invert", NULL); g_object_unref (shadow_buffer); /* flushes the shadow tiles */ g_object_unref (buffer); gimp_drawable_merge_shadow (drawable_id, TRUE); gimp_drawable_update (drawable_id, x, y, width, height); gimp_displays_flush (); } values[0].data.d_status = status; gegl_exit (); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; GimpDrawable *drawable; /* Setting mandatory output values */ *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Getting run_mode - we won't display a dialog if * we are in NONINTERACTIVE mode */ run_mode = param[0].data.d_int32; /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); gimp_progress_init ("Exponential Range ..."); /* * * GTimer timer = g_timer_new time (); */ exponentialrange (drawable); /* g_print ("blur() took %g seconds.\n", g_timer_elapsed (timer)); * g_timer_destroy (timer); */ gimp_displays_flush (); gimp_drawable_detach (drawable); }
static void callback_dump_button (GtkWidget * button, gpointer data) { gboolean render_success; InterfaceIData *p_data = INTERFACE_I_DATA (data); CarverData * c_data = p_data->carver_data; gimp_image_undo_group_start (c_data->image_ID); render_success = render_dump_vmap (state, p_data->col_vals, p_data->carver_data, &(p_data->vmap_layer_ID)); gimp_image_undo_group_end (c_data->image_ID); if (!render_success) { dialog_I_response = RESPONSE_FATAL; gtk_main_quit(); } gimp_displays_flush(); //set_info_label_text (p_data->info_label, c_data->ref_w, c_data->ref_h, c_data->orientation, c_data->depth, c_data->enl_step); }
/** * Close the tile stream, writing changes back (I hope). */ void tile_stream_close (int id) { if (! valid_stream_id (id)) return; TileStream *stream = streams[id]; gimp_drawable_flush (stream->target); gimp_drawable_merge_shadow (stream->drawable, TRUE); gimp_drawable_update (stream->drawable, stream->left, stream->top, stream->width, stream->height); gimp_displays_flush (); gimp_drawable_detach (stream->source); gimp_drawable_detach (stream->target); g_free (stream); streams[id] = NULL; #ifdef DEBUG fprintf (stderr, "closed %d\n", id); #endif } // tile_stream_close
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; INIT_I18N (); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PIXELIZE_PROC, &pvals); /* First acquire information with a dialog */ if (! pixelize_dialog (drawable)) { gimp_drawable_detach (drawable); return; } break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if ((! strcmp (name, PIXELIZE_PROC) && nparams != 4) || (! strcmp (name, PIXELIZE2_PROC) && nparams != 5)) { status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { pvals.pixelwidth = (gdouble) param[3].data.d_int32; if (nparams == 4) pvals.pixelheight = pvals.pixelwidth; else pvals.pixelheight = (gdouble) param[4].data.d_int32; } if ((status == GIMP_PDB_SUCCESS) && (pvals.pixelwidth <= 0 || pvals.pixelheight <= 0)) { status = GIMP_PDB_CALLING_ERROR; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PIXELIZE_PROC, &pvals); break; default: break; } if (status == GIMP_PDB_SUCCESS) { /* Make sure that the drawable is gray or RGB color */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id)) { gimp_progress_init (_("Pixelizing")); /* set the tile cache size */ gimp_tile_cache_ntiles (TILE_CACHE_SIZE); /* run the pixelize effect */ pixelize (drawable, NULL); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PIXELIZE_PROC, &pvals, sizeof (PixelizeValues)); } else { /* g_message ("pixelize: cannot operate on indexed color images"); */ status = GIMP_PDB_EXECUTION_ERROR; } } values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static void plugin_run (const gchar *name, gint numof_params, const GimpParam *params, gint *numof_return_vals, GimpParam **return_vals) { GimpPDBStatusType status = GIMP_PDB_SUCCESS; INIT_I18N (); p.run = FALSE; p.run_mode = params[0].data.d_int32; p.image = params[1].data.d_image; p.drawable = gimp_drawable_get(params[2].data.d_drawable); p.drawable_has_alpha = gimp_drawable_has_alpha(p.drawable->drawable_id); if (gimp_drawable_is_rgb (p.drawable->drawable_id)) { switch (p.run_mode) { case GIMP_RUN_INTERACTIVE: params_load_from_gimp (); open_dialog (); break; case GIMP_RUN_NONINTERACTIVE: if (numof_params == 11) { p.params.tile_width = params[3].data.d_int32; p.params.tile_height = params[3].data.d_int32; p.params.division_x = p.drawable->width / p.params.tile_width; p.params.division_y = p.drawable->height / p.params.tile_height; p.params.move_max_rate = params[4].data.d_float; p.params.fractional_type = (FractionalType)params[5].data.d_int32; p.params.wrap_around = params[6].data.d_int32; p.params.centering = params[7].data.d_int32; p.params.background_type = (BackgroundType)params[8].data.d_int32; p.params.background_color = params[9].data.d_color; /* FIXME: this used to be the alpha value params[10].data.d_int32 */ p.run = TRUE; } else { status = GIMP_PDB_CALLING_ERROR; } break; case GIMP_RUN_WITH_LAST_VALS: params_load_from_gimp (); p.run = TRUE; break; } } else { status = GIMP_PDB_EXECUTION_ERROR; } if (status == GIMP_PDB_SUCCESS && p.run) { params_save_to_gimp (); filter (); if (p.run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); } gimp_drawable_detach (p.drawable); { static GimpParam return_value[1]; return_value[0].type = GIMP_PDB_STATUS; return_value[0].data.d_status = status; *numof_return_vals = 1; *return_vals = return_value; } }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpRunMode run_mode; GimpDrawable *drawable; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); /* set the tile cache size */ gimp_tile_cache_ntiles (TILE_CACHE_SIZE); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; INIT_I18N(); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &cvals); /* First acquire information with a dialog */ if (! cartoon_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: cvals.mask_radius = param[3].data.d_float; cvals.pct_black = param[4].data.d_float; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &cvals); break; default: break; } if (status == GIMP_PDB_SUCCESS) { /* Make sure that the drawable is RGB or GRAY color */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id)) { gimp_progress_init ("Cartoon"); cartoon (drawable, NULL); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &cvals, sizeof (CartoonVals)); } else { status = GIMP_PDB_EXECUTION_ERROR; *nreturn_vals = 2; values[1].type = GIMP_PDB_STRING; values[1].data.d_string = _("Cannot operate on indexed color images."); } } values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[3]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 new_layer = -1; gint width; gint height; run_mode = param[0].data.d_int32; INIT_I18N (); *nreturn_vals = 3; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; values[1].type = GIMP_PDB_IMAGE; values[2].type = GIMP_PDB_LAYER; width = gimp_drawable_width (param[2].data.d_drawable); height = gimp_drawable_height (param[2].data.d_drawable); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &tvals); /* First acquire information with a dialog */ if (! tile_dialog (param[1].data.d_image, param[2].data.d_drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 6) { status = GIMP_PDB_CALLING_ERROR; } else { tvals.new_width = param[3].data.d_int32; tvals.new_height = param[4].data.d_int32; tvals.new_image = param[5].data.d_int32 ? TRUE : FALSE; if (tvals.new_width < 0 || tvals.new_height < 0) status = GIMP_PDB_CALLING_ERROR; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &tvals); break; default: break; } if (status == GIMP_PDB_SUCCESS) { gimp_progress_init (_("Tiling")); values[1].data.d_image = tile (param[1].data.d_image, param[2].data.d_drawable, &new_layer); values[2].data.d_layer = new_layer; /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &tvals, sizeof (TileVals)); if (run_mode != GIMP_RUN_NONINTERACTIVE) { if (tvals.new_image) gimp_display_new (values[1].data.d_image); else gimp_displays_flush (); } } values[0].data.d_status = status; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; gint32 image_ID; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; INIT_I18N (); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Get the specified image and drawable */ image_ID = param[1].data.d_image; drawable = gimp_drawable_get (param[2].data.d_drawable); /* set the tile cache size so that the gaussian blur works well */ gimp_tile_cache_ntiles (2 * (MAX (drawable->width, drawable->height) / gimp_tile_width () + 1)); if (strcmp (name, PLUG_IN_PROC) == 0) { switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &dogvals); /* First acquire information with a dialog */ if (! dog_dialog (image_ID, drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 7) status = GIMP_PDB_CALLING_ERROR; if (status == GIMP_PDB_SUCCESS) { dogvals.inner = param[3].data.d_float; dogvals.outer = param[4].data.d_float; dogvals.normalize = param[5].data.d_int32; dogvals.invert = param[6].data.d_int32; } if (status == GIMP_PDB_SUCCESS && (dogvals.inner <= 0.0 && dogvals.outer <= 0.0)) status = GIMP_PDB_CALLING_ERROR; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &dogvals); break; default: break; } } else { status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { /* Make sure that the drawable is gray or RGB color */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id)) { gimp_progress_init (_("DoG Edge Detect")); /* run the Difference of Gaussians */ gimp_image_undo_group_start (image_ID); dog (image_ID, drawable, dogvals.inner, dogvals.outer, TRUE); gimp_image_undo_group_end (image_ID); gimp_progress_update (1.0); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &dogvals, sizeof (DoGValues)); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); } else { g_message (_("Cannot operate on indexed color images.")); status = GIMP_PDB_EXECUTION_ERROR; } gimp_drawable_detach (drawable); } values[0].data.d_status = status; }