static gboolean gimp_threshold_tool_channel_sensitive (gint value, gpointer data) { GimpDrawable *drawable = GIMP_TOOL (data)->drawable; GimpHistogramChannel channel = value; if (!drawable) return FALSE; switch (channel) { case GIMP_HISTOGRAM_VALUE: return TRUE; case GIMP_HISTOGRAM_RED: case GIMP_HISTOGRAM_GREEN: case GIMP_HISTOGRAM_BLUE: return gimp_drawable_is_rgb (drawable); case GIMP_HISTOGRAM_ALPHA: return gimp_drawable_has_alpha (drawable); case GIMP_HISTOGRAM_RGB: return gimp_drawable_is_rgb (drawable); case GIMP_HISTOGRAM_LUMINANCE: return gimp_drawable_is_rgb (drawable); } return FALSE; }
static gboolean gimp_colorize_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpColorizeTool *col_tool = GIMP_COLORIZE_TOOL (tool); GimpDrawable *drawable = gimp_image_get_active_drawable (display->image); if (! drawable) return FALSE; if (! gimp_drawable_is_rgb (drawable)) { g_set_error (error, 0, 0, _("Colorize operates only on RGB color layers.")); return FALSE; } gimp_config_reset (GIMP_CONFIG (col_tool->config)); GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error); gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (tool)); return TRUE; }
static gboolean effect_image_constrain (gint32 image_id, gint32 drawable_id, gpointer data) { return gimp_drawable_is_rgb (drawable_id); }
static gboolean image_save_jpeg(image_output out, float quality, float smoothing, gboolean entropy, gboolean progressive, gchar* comment, int subsampling, gboolean baseline, int markers, int dct) { gint nreturn_vals; /* image needs to be RGB */ if (!gimp_drawable_is_rgb(out->drawable_id)) { gimp_image_convert_rgb(out->image_id); } GimpParam *return_vals = gimp_run_procedure( "file_jpeg_save", &nreturn_vals, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE, GIMP_PDB_IMAGE, out->image_id, GIMP_PDB_DRAWABLE, out->drawable_id, GIMP_PDB_STRING, out->filepath, GIMP_PDB_STRING, out->filename, GIMP_PDB_FLOAT, quality >= 3 ? quality/100 : 0.03, /* Quality of saved image (0 <= quality <= 1) + small fix because final image doesn't change when quality < 3 */ GIMP_PDB_FLOAT, smoothing, /* Smoothing factor for saved image (0 <= smoothing <= 1) */ GIMP_PDB_INT32, entropy ? 1 : 0, /* Optimization of entropy encoding parameters (0/1) */ GIMP_PDB_INT32, progressive ? 1 : 0, /* Enable progressive jpeg image loading - ignored if not compiled with HAVE_PROGRESSIVE_JPEG (0/1) */ GIMP_PDB_STRING, comment, /* Image comment */ GIMP_PDB_INT32, subsampling, /* The subsampling option number */ GIMP_PDB_INT32, baseline ? 1 : 0, /* Force creation of a baseline JPEG (non-baseline JPEGs can't be read by all decoders) (0/1) */ GIMP_PDB_INT32, markers, /* Frequency of restart markers (in rows, 0 = no restart markers) */ GIMP_PDB_INT32, dct, /* DCT algorithm to use (speed/quality tradeoff) */ GIMP_PDB_END ); return TRUE; }
static gboolean gimp_desaturate_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpDesaturateTool *desaturate_tool = GIMP_DESATURATE_TOOL (tool); GimpDrawable *drawable; drawable = gimp_image_get_active_drawable (display->image); if (! drawable) return FALSE; if (! gimp_drawable_is_rgb (drawable)) { g_set_error (error, 0, 0, _("Desaturate does only operate on RGB layers.")); return FALSE; } gimp_config_reset (GIMP_CONFIG (desaturate_tool->config)); GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (desaturate_tool->button), desaturate_tool->config->mode); gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (desaturate_tool)); return TRUE; }
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 gboolean validdrawable (gint32 imageid, gint32 drawableid, gpointer data) { return (gimp_drawable_is_rgb (drawableid) || gimp_drawable_is_gray (drawableid)); }
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[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 (); }
/* main function */ 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; GimpDrawable *drawable; run_mode = param[0].data.d_int32; INIT_I18N (); *nreturn_vals = 2; *return_vals = values; if (run_mode == GIMP_RUN_NONINTERACTIVE) { if (n_params != 3) status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { drawable = gimp_drawable_get (param[2].data.d_drawable); imageID = param[1].data.d_image; if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id) || gimp_drawable_is_indexed (drawable->drawable_id)) { memset (hist_red, 0, sizeof (hist_red)); memset (hist_green, 0, sizeof (hist_green)); memset (hist_blue, 0, sizeof (hist_blue)); gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1)); analyze (drawable); /* show dialog after we analyzed image */ if (run_mode != GIMP_RUN_NONINTERACTIVE) doDialog (); } else status = GIMP_PDB_EXECUTION_ERROR; gimp_drawable_detach (drawable); } values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; values[1].type = GIMP_PDB_INT32; values[1].data.d_int32 = uniques; }
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) { 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 gboolean gimp_levels_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpLevelsTool *l_tool = GIMP_LEVELS_TOOL (tool); GimpDrawable *drawable = gimp_image_get_active_drawable (display->image); if (! drawable) return FALSE; if (gimp_drawable_is_indexed (drawable)) { g_set_error (error, 0, 0, _("Levels does not operate on indexed layers.")); return FALSE; } if (! l_tool->hist) l_tool->hist = gimp_histogram_new (); levels_init (l_tool->levels); l_tool->channel = GIMP_HISTOGRAM_VALUE; l_tool->color = gimp_drawable_is_rgb (drawable); l_tool->alpha = gimp_drawable_has_alpha (drawable); if (l_tool->active_picker) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l_tool->active_picker), FALSE); GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error); gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (l_tool->channel_menu), levels_menu_sensitivity, l_tool, NULL); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (l_tool->channel_menu), l_tool->channel); /* FIXME: hack */ if (! l_tool->color) l_tool->channel = (l_tool->channel == GIMP_HISTOGRAM_ALPHA) ? 1 : 0; levels_update (l_tool, ALL); gimp_drawable_calculate_histogram (drawable, l_tool->hist); gimp_histogram_view_set_histogram (GIMP_HISTOGRAM_VIEW (l_tool->hist_view), l_tool->hist); return TRUE; }
static void gimp_levels_tool_map (GimpImageMapTool *image_map_tool) { GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool); GimpDrawable *drawable = image_map_tool->drawable; Levels levels; gimp_levels_config_to_cruft (tool->config, &levels, gimp_drawable_is_rgb (drawable)); gimp_lut_setup (tool->lut, (GimpLutFunc) levels_lut_func, &levels, gimp_drawable_bytes (drawable)); }
static void gimp_curves_tool_map (GimpImageMapTool *image_map_tool) { GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool); GimpDrawable *drawable = image_map_tool->drawable; Curves curves; gimp_curves_config_to_cruft (tool->config, &curves, gimp_drawable_is_rgb (drawable)); gimp_lut_setup (tool->lut, (GimpLutFunc) curves_lut_func, &curves, gimp_drawable_bytes (drawable)); }
static void gimp_threshold_tool_auto_clicked (GtkWidget *button, GimpThresholdTool *t_tool) { GimpDrawable *drawable = GIMP_IMAGE_MAP_TOOL (t_tool)->drawable; gdouble low; low = gimp_histogram_get_threshold (t_tool->histogram, gimp_drawable_is_rgb (drawable) ? GIMP_HISTOGRAM_RGB : GIMP_HISTOGRAM_VALUE, 0, 255); gimp_histogram_view_set_range (t_tool->histogram_box->view, low, 255.0); }
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 load_gui_defaults (JpegSaveGui *pg) { GtkAdjustment *restart_markers; load_defaults (); #define SET_ACTIVE_BTTN(field) \ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pg->field), jsvals.field) SET_ACTIVE_BTTN (optimize); SET_ACTIVE_BTTN (progressive); SET_ACTIVE_BTTN (use_orig_quality); SET_ACTIVE_BTTN (preview); SET_ACTIVE_BTTN (save_exif); SET_ACTIVE_BTTN (save_thumbnail); SET_ACTIVE_BTTN (save_xmp); SET_ACTIVE_BTTN (save_iptc); #undef SET_ACTIVE_BTTN /*spin button stuff*/ g_signal_handler_block (pg->use_restart_markers, pg->handler_id_restart); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pg->use_restart_markers), jsvals.restart); restart_markers = GTK_ADJUSTMENT (pg->scale_data); gtk_adjustment_set_value (restart_markers, jsvals.restart); g_signal_handler_unblock (pg->use_restart_markers, pg->handler_id_restart); gtk_adjustment_set_value (GTK_ADJUSTMENT (pg->quality), jsvals.quality); gtk_adjustment_set_value (GTK_ADJUSTMENT (pg->smoothing), jsvals.smoothing); if (gimp_drawable_is_rgb (drawable_ID_global)) { gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (pg->subsmp), jsvals.subsmp); } gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (pg->dct), jsvals.dct); }
/* Returns NGRADSAMPLES samples of active gradient. Each sample has (gimp_drawable_bpp (drawable_id)) bytes. "ripped" from gradmap.c. */ static guchar * get_gradient_samples (gint32 drawable_id, gboolean reverse) { gchar *gradient_name; gint n_f_samples; gdouble *f_samples, *f_samp; /* float samples */ guchar *b_samples, *b_samp; /* byte samples */ gint bpp, color, has_alpha, alpha; gint i, j; gradient_name = gimp_context_get_gradient (); gimp_gradient_get_uniform_samples (gradient_name, NGRADSAMPLES, reverse, &n_f_samples, &f_samples); g_free (gradient_name); bpp = gimp_drawable_bpp (drawable_id); color = gimp_drawable_is_rgb (drawable_id); has_alpha = gimp_drawable_has_alpha (drawable_id); alpha = (has_alpha ? bpp - 1 : bpp); b_samples = g_new (guchar, NGRADSAMPLES * bpp); for (i = 0; i < NGRADSAMPLES; i++) { b_samp = &b_samples[i * bpp]; f_samp = &f_samples[i * 4]; if (color) for (j = 0; j < 3; j++) b_samp[j] = f_samp[j] * 255; else b_samp[0] = GIMP_RGB_LUMINANCE (f_samp[0], f_samp[1], f_samp[2]) * 255; if (has_alpha) b_samp[alpha] = f_samp[3] * 255; } g_free (f_samples); return b_samples; }
static void webx_pipeline_create_background (WebxPipeline *pipeline) { g_return_if_fail (WEBX_IS_PIPELINE (pipeline)); if (gimp_drawable_is_rgb (pipeline->rgb_layer)) { pipeline->background = webx_drawable_to_pixbuf (pipeline->rgb_layer); } else { /* pipeline->rgb_image is still original image, which can be non rgb (as we create background early in pipeline). */ gint duplicate = gimp_image_duplicate (pipeline->rgb_image); gimp_image_undo_disable (duplicate); pipeline->background = webx_image_to_pixbuf (duplicate); gimp_image_delete (duplicate); } }
static gboolean gimp_color_balance_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (! drawable) return FALSE; if (! gimp_drawable_is_rgb (drawable)) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Color Balance operates only on RGB color layers.")); return FALSE; } return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error); }
/* Returns 2048 samples of the palette. Each sample is (R'G'B'A float) or (Y'A float), depending on the drawable */ static gdouble * get_samples_palette (gint32 drawable_id) { gchar *palette_name; GimpRGB color_sample; gdouble *d_samples, *d_samp; gboolean is_rgb; gdouble factor; gint pal_entry, num_colors; gint nb_color_chan, nb_chan, i; const Babl *format; palette_name = gimp_context_get_palette (); gimp_palette_get_info (palette_name, &num_colors); is_rgb = gimp_drawable_is_rgb (drawable_id); factor = ((double) num_colors) / NSAMPLES; format = is_rgb ? babl_format ("R'G'B'A double") : babl_format ("Y'A double"); nb_color_chan = is_rgb ? 3 : 1; nb_chan = nb_color_chan + 1; d_samples = g_new (gdouble, NSAMPLES * nb_chan); for (i = 0; i < NSAMPLES; i++) { d_samp = &d_samples[i * nb_chan]; pal_entry = CLAMP ((int)(i * factor), 0, num_colors - 1); gimp_palette_entry_get_color (palette_name, pal_entry, &color_sample); gimp_rgb_get_pixel (&color_sample, format, d_samp); } g_free (palette_name); return d_samples; }
static gboolean gimp_hue_saturation_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpHueSaturationTool *hs_tool = GIMP_HUE_SATURATION_TOOL (tool); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (! drawable) return FALSE; if (! gimp_drawable_is_rgb (drawable)) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Hue-Saturation operates only on RGB color layers.")); return FALSE; } gimp_config_reset (GIMP_CONFIG (hs_tool->config)); return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error); }
void drawable_levels_stretch_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpDrawable *drawable; GimpDisplay *display; GtkWidget *widget; return_if_no_drawable (image, drawable, data); return_if_no_display (display, data); return_if_no_widget (widget, data); if (! gimp_drawable_is_rgb (drawable)) { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, _("White Balance operates only on RGB color layers.")); return; } gimp_drawable_levels_stretch (drawable, GIMP_PROGRESS (display)); gimp_image_flush (image); }
static void gimp_drawable_curves (GimpDrawable *drawable, GimpProgress *progress, GimpCurvesConfig *config) { if (gimp_use_gegl (gimp_item_get_image (GIMP_ITEM (drawable))->gimp)) { GeglNode *node; node = g_object_new (GEGL_TYPE_NODE, "operation", "gimp:curves", NULL); gegl_node_set (node, "config", config, NULL); gimp_drawable_apply_operation (drawable, progress, C_("undo-type", "Curves"), node, TRUE); g_object_unref (node); } else { GimpLut *lut = gimp_lut_new (); Curves cruft; gimp_curves_config_to_cruft (config, &cruft, gimp_drawable_is_rgb (drawable)); gimp_lut_setup (lut, (GimpLutFunc) curves_lut_func, &cruft, gimp_drawable_bytes (drawable)); gimp_drawable_process_lut (drawable, progress, C_("undo-type", "Curves"), lut); gimp_lut_free (lut); } }
/* Returns 2048 samples of the gradient. Each sample is (R'G'B'A float) or (Y'A float), depending on the drawable */ static gdouble * get_samples_gradient (gint32 drawable_id) { gchar *gradient_name; gint n_d_samples; gdouble *d_samples = NULL; gradient_name = gimp_context_get_gradient (); /* FIXME: "reverse" hardcoded to FALSE. */ gimp_gradient_get_uniform_samples (gradient_name, NSAMPLES, FALSE, &n_d_samples, &d_samples); g_free (gradient_name); if (!gimp_drawable_is_rgb (drawable_id)) { const Babl *format_src = babl_format ("R'G'B'A double"); const Babl *format_dst = babl_format ("Y'A double"); const Babl *fish = babl_fish (format_src, format_dst); babl_process (fish, d_samples, d_samples, NSAMPLES); } return d_samples; }
static gboolean gimp_histogram_editor_channel_valid (GimpHistogramEditor *editor, GimpHistogramChannel channel) { if (editor->drawable) { switch (channel) { case GIMP_HISTOGRAM_VALUE: return TRUE; case GIMP_HISTOGRAM_RED: case GIMP_HISTOGRAM_GREEN: case GIMP_HISTOGRAM_BLUE: case GIMP_HISTOGRAM_RGB: return gimp_drawable_is_rgb (editor->drawable); case GIMP_HISTOGRAM_ALPHA: return gimp_drawable_has_alpha (editor->drawable); } } return TRUE; }
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[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; }