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; INIT_I18N (); run_mode = param[0].data.d_int32; *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 (PLUG_IN_PROC, &pvals); /* First acquire information with a dialog */ if (! nova_dialog (drawable)) { gimp_drawable_detach (drawable); return; } break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 9) status = GIMP_PDB_CALLING_ERROR; if (status == GIMP_PDB_SUCCESS) { pvals.xcenter = param[3].data.d_int32; pvals.ycenter = param[4].data.d_int32; pvals.color = param[5].data.d_color; pvals.radius = param[6].data.d_int32; pvals.nspoke = param[7].data.d_int32; pvals.randomhue = param[8].data.d_int32; } if ((status == GIMP_PDB_SUCCESS) && pvals.radius <= 0) status = GIMP_PDB_CALLING_ERROR; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_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 (_("Rendering supernova")); gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1)); nova (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, &pvals, sizeof (NovaValues)); } else { /* gimp_message ("nova: cannot operate on indexed color images"); */ status = GIMP_PDB_EXECUTION_ERROR; } } values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static void ico_dialog_update_icon_preview (GtkWidget *dialog, gint32 layer, gint bpp) { GtkWidget *preview = ico_dialog_get_layer_preview (dialog, layer); GdkPixbuf *pixbuf; const Babl *format; gint w = gimp_drawable_width (layer); gint h = gimp_drawable_height (layer); if (! preview) return; switch (gimp_drawable_type (layer)) { case GIMP_RGB_IMAGE: format = babl_format ("R'G'B' u8"); break; case GIMP_RGBA_IMAGE: format = babl_format ("R'G'B'A u8"); break; case GIMP_GRAY_IMAGE: format = babl_format ("Y' u8"); break; case GIMP_GRAYA_IMAGE: format = babl_format ("Y'A u8"); break; case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE: format = gimp_drawable_get_format (layer); default: g_return_if_reached (); } if (bpp <= 8) { GeglBuffer *buffer; GeglBuffer *tmp; gint32 image; gint32 tmp_image; gint32 tmp_layer; guchar *buf; guchar *cmap; gint num_colors; image = gimp_item_get_image (layer); tmp_image = gimp_image_new (w, h, gimp_image_base_type (image)); gimp_image_undo_disable (tmp_image); if (gimp_drawable_is_indexed (layer)) { cmap = gimp_image_get_colormap (image, &num_colors); gimp_image_set_colormap (tmp_image, cmap, num_colors); g_free (cmap); } tmp_layer = gimp_layer_new (tmp_image, "temporary", w, h, gimp_drawable_type (layer), 100, GIMP_NORMAL_MODE); gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0); buffer = gimp_drawable_get_buffer (layer); tmp = gimp_drawable_get_buffer (tmp_layer); buf = g_malloc (w * h * 4); gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, w, h), 1.0, format, buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); gegl_buffer_copy (buffer, NULL, tmp, NULL); g_object_unref (tmp); g_object_unref (buffer); if (gimp_drawable_is_indexed (layer)) gimp_image_convert_rgb (tmp_image); gimp_image_convert_indexed (tmp_image, GIMP_FS_DITHER, GIMP_MAKE_PALETTE, 1 << bpp, TRUE, FALSE, "dummy"); cmap = gimp_image_get_colormap (tmp_image, &num_colors); if (num_colors == (1 << bpp) && ! ico_cmap_contains_black (cmap, num_colors)) { /* Windows icons with color maps need the color black. * We need to eliminate one more color to make room for black. */ if (gimp_drawable_is_indexed (layer)) { g_free (cmap); cmap = gimp_image_get_colormap (image, &num_colors); gimp_image_set_colormap (tmp_image, cmap, num_colors); } else if (gimp_drawable_is_gray (layer)) { gimp_image_convert_grayscale (tmp_image); } else { gimp_image_convert_rgb (tmp_image); } tmp = gimp_drawable_get_buffer (tmp_layer); gegl_buffer_set (tmp, GEGL_RECTANGLE (0, 0, w, h), 0, format, buf, GEGL_AUTO_ROWSTRIDE); g_object_unref (tmp); if (!gimp_drawable_is_rgb (layer)) gimp_image_convert_rgb (tmp_image); gimp_image_convert_indexed (tmp_image, GIMP_FS_DITHER, GIMP_MAKE_PALETTE, (1 << bpp) - 1, TRUE, FALSE, "dummy"); } g_free (cmap); g_free (buf); pixbuf = gimp_drawable_get_thumbnail (tmp_layer, MIN (w, 128), MIN (h, 128), GIMP_PIXBUF_SMALL_CHECKS); gimp_image_delete (tmp_image); } else if (bpp == 24) { GeglBuffer *buffer; GeglBuffer *tmp; gint32 image; gint32 tmp_image; gint32 tmp_layer; GimpParam *return_vals; gint n_return_vals; image = gimp_item_get_image (layer); tmp_image = gimp_image_new (w, h, gimp_image_base_type (image)); gimp_image_undo_disable (tmp_image); if (gimp_drawable_is_indexed (layer)) { guchar *cmap; gint num_colors; cmap = gimp_image_get_colormap (image, &num_colors); gimp_image_set_colormap (tmp_image, cmap, num_colors); g_free (cmap); } tmp_layer = gimp_layer_new (tmp_image, "temporary", w, h, gimp_drawable_type (layer), 100, GIMP_NORMAL_MODE); gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0); buffer = gimp_drawable_get_buffer (layer); tmp = gimp_drawable_get_buffer (tmp_layer); gegl_buffer_copy (buffer, NULL, tmp, NULL); g_object_unref (tmp); g_object_unref (buffer); if (gimp_drawable_is_indexed (layer)) gimp_image_convert_rgb (tmp_image); return_vals = gimp_run_procedure ("plug-in-threshold-alpha", &n_return_vals, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE, GIMP_PDB_IMAGE, tmp_image, GIMP_PDB_DRAWABLE, tmp_layer, GIMP_PDB_INT32, ICO_ALPHA_THRESHOLD, GIMP_PDB_END); gimp_destroy_params (return_vals, n_return_vals); pixbuf = gimp_drawable_get_thumbnail (tmp_layer, MIN (w, 128), MIN (h, 128), GIMP_PIXBUF_SMALL_CHECKS); gimp_image_delete (tmp_image); } else { pixbuf = gimp_drawable_get_thumbnail (layer, MIN (w, 128), MIN (h, 128), GIMP_PIXBUF_SMALL_CHECKS); } gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf); g_object_unref (pixbuf); }
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; INIT_I18N (); run_mode = param[0].data.d_int32; /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); gimp_tile_cache_ntiles (2 * drawable->ntile_cols); *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: /* Possibly retrieve data */ gimp_get_data (OILIFY_PROC, &ovals); /* First acquire information with a dialog */ if (! oilify_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Interpret the arguments per the name used to invoke us */ if (! strcmp (name, OILIFY_PROC)) { if (nparams != 5) { status = GIMP_PDB_CALLING_ERROR; } else { ovals.mask_size = (gdouble) param[3].data.d_int32; ovals.mode = param[4].data.d_int32; } } else if (! strcmp (name, OILIFY_ENHANCED_PROC)) { if (nparams < 5 || nparams > 8) { status = GIMP_PDB_CALLING_ERROR; } else { ovals.mode = param[3].data.d_int32; ovals.mask_size = (gdouble) param[4].data.d_int32; if (nparams >= 6) ovals.mask_size_map = param[5].data.d_int32; if (nparams >= 7) ovals.exponent = (gdouble) param[6].data.d_int32; if (nparams == 8) ovals.exponent_map = param[7].data.d_int32; ovals.use_mask_size_map = ovals.mask_size_map >= 0; ovals.use_exponent_map = ovals.exponent_map >= 0; if (ovals.mask_size < 1.0 || ovals.exponent < 1.0 || (ovals.mode != MODE_INTEN && ovals.mode != MODE_RGB) || (ovals.mode == MODE_INTEN && ! gimp_drawable_is_rgb (drawable->drawable_id))) { status = GIMP_PDB_CALLING_ERROR; } } } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (OILIFY_PROC, &ovals); break; default: break; } /* Make sure that the drawable is gray or RGB color */ if ((status == GIMP_PDB_SUCCESS) && (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id))) { gimp_progress_init (_("Oil painting")); oilify (drawable, NULL); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (OILIFY_PROC, &ovals, sizeof (OilifyVals)); } else { /* gimp_message ("oilify: cannot operate on indexed color images"); */ status = GIMP_PDB_EXECUTION_ERROR; } values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static void ico_image_get_reduced_buf (guint32 layer, gint bpp, gint *num_colors, guchar **cmap_out, guchar **buf_out) { gint32 tmp_image; gint32 tmp_layer; gint w, h; guchar *buf; guchar *cmap = NULL; GeglBuffer *buffer = gimp_drawable_get_buffer (layer); const Babl *format; w = gegl_buffer_get_width (buffer); h = gegl_buffer_get_height (buffer); switch (gimp_drawable_type (layer)) { case GIMP_RGB_IMAGE: format = babl_format ("R'G'B' u8"); break; case GIMP_RGBA_IMAGE: format = babl_format ("R'G'B'A u8"); break; case GIMP_GRAY_IMAGE: format = babl_format ("Y' u8"); break; case GIMP_GRAYA_IMAGE: format = babl_format ("Y'A u8"); break; case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE: format = gegl_buffer_get_format (buffer); default: g_return_if_reached (); } *num_colors = 0; buf = g_new (guchar, w * h * 4); if (bpp <= 8 || bpp == 24 || babl_format_get_bytes_per_pixel (format) != 4) { gint32 image = gimp_item_get_image (layer); GeglBuffer *tmp; tmp_image = gimp_image_new (w, h, gimp_image_base_type (image)); gimp_image_undo_disable (tmp_image); if (gimp_drawable_is_indexed (layer)) { guchar *cmap; gint num_colors; cmap = gimp_image_get_colormap (image, &num_colors); gimp_image_set_colormap (tmp_image, cmap, num_colors); g_free (cmap); } tmp_layer = gimp_layer_new (tmp_image, "tmp", w, h, gimp_drawable_type (layer), 100, GIMP_NORMAL_MODE); gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0); tmp = gimp_drawable_get_buffer (tmp_layer); gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, w, h), 1.0, format, buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); gegl_buffer_copy (buffer, NULL, GEGL_ABYSS_NONE, tmp, NULL); g_object_unref (tmp); if (! gimp_drawable_is_rgb (tmp_layer)) gimp_image_convert_rgb (tmp_image); if (bpp <= 8) { gimp_image_convert_indexed (tmp_image, GIMP_FS_DITHER, GIMP_MAKE_PALETTE, 1 << bpp, TRUE, FALSE, "dummy"); cmap = gimp_image_get_colormap (tmp_image, num_colors); if (*num_colors == (1 << bpp) && ! ico_cmap_contains_black (cmap, *num_colors)) { /* Windows icons with color maps need the color black. * We need to eliminate one more color to make room for black. */ if (gimp_drawable_is_indexed (layer)) { g_free (cmap); cmap = gimp_image_get_colormap (image, num_colors); gimp_image_set_colormap (tmp_image, cmap, *num_colors); } else if (gimp_drawable_is_gray (layer)) { gimp_image_convert_grayscale (tmp_image); } else { gimp_image_convert_rgb (tmp_image); } tmp = gimp_drawable_get_buffer (tmp_layer); gegl_buffer_set (tmp, GEGL_RECTANGLE (0, 0, w, h), 0, format, buf, GEGL_AUTO_ROWSTRIDE); g_object_unref (tmp); if (! gimp_drawable_is_rgb (layer)) gimp_image_convert_rgb (tmp_image); gimp_image_convert_indexed (tmp_image, GIMP_FS_DITHER, GIMP_MAKE_PALETTE, (1<<bpp) - 1, TRUE, FALSE, "dummy"); g_free (cmap); cmap = gimp_image_get_colormap (tmp_image, num_colors); } gimp_image_convert_rgb (tmp_image); } else if (bpp == 24) { GimpParam *return_vals; gint n_return_vals; return_vals = gimp_run_procedure ("plug-in-threshold-alpha", &n_return_vals, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE, GIMP_PDB_IMAGE, tmp_image, GIMP_PDB_DRAWABLE, tmp_layer, GIMP_PDB_INT32, ICO_ALPHA_THRESHOLD, GIMP_PDB_END); gimp_destroy_params (return_vals, n_return_vals); } gimp_layer_add_alpha (tmp_layer); tmp = gimp_drawable_get_buffer (tmp_layer); gegl_buffer_get (tmp, GEGL_RECTANGLE (0, 0, w, h), 1.0, NULL, buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); g_object_unref (tmp); gimp_image_delete (tmp_image); } else { gegl_buffer_get (buffer, GEGL_RECTANGLE (0, 0, w, h), 1.0, format, buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); } g_object_unref (buffer); *cmap_out = cmap; *buf_out = buf; }
static void ico_dialog_update_icon_preview (GtkWidget *dialog, gint32 layer, gint bpp) { GtkWidget *preview = ico_dialog_get_layer_preview (dialog, layer); GdkPixbuf *pixbuf; gint w = gimp_drawable_width (layer); gint h = gimp_drawable_height (layer); if (! preview) return; if (bpp <= 8) { GimpDrawable *drawable; GimpDrawable *tmp; GimpPixelRgn src_pixel_rgn, dst_pixel_rgn; gint32 image; gint32 tmp_image; gint32 tmp_layer; guchar *buffer; guchar *cmap; gint num_colors; image = gimp_item_get_image (layer); tmp_image = gimp_image_new (w, h, gimp_image_base_type (image)); gimp_image_undo_disable (tmp_image); if (gimp_drawable_is_indexed (layer)) { cmap = gimp_image_get_colormap (image, &num_colors); gimp_image_set_colormap (tmp_image, cmap, num_colors); g_free (cmap); } tmp_layer = gimp_layer_new (tmp_image, "temporary", w, h, gimp_drawable_type (layer), 100, GIMP_NORMAL_MODE); gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0); drawable = gimp_drawable_get (layer); tmp = gimp_drawable_get (tmp_layer); gimp_pixel_rgn_init (&src_pixel_rgn, drawable, 0, 0, w, h, FALSE, FALSE); gimp_pixel_rgn_init (&dst_pixel_rgn, tmp, 0, 0, w, h, TRUE, FALSE); buffer = g_malloc (w * h * 4); gimp_pixel_rgn_get_rect (&src_pixel_rgn, buffer, 0, 0, w, h); gimp_pixel_rgn_set_rect (&dst_pixel_rgn, buffer, 0, 0, w, h); gimp_drawable_detach (tmp); gimp_drawable_detach (drawable); if (gimp_drawable_is_indexed (layer)) gimp_image_convert_rgb (tmp_image); gimp_image_convert_indexed (tmp_image, GIMP_FS_DITHER, GIMP_MAKE_PALETTE, 1 <<bpp, TRUE, FALSE, "dummy"); cmap = gimp_image_get_colormap (tmp_image, &num_colors); if ( num_colors == (1 << bpp) && !ico_cmap_contains_black (cmap, num_colors)) { /* Windows icons with color maps need the color black. * We need to eliminate one more color to make room for black. */ if (gimp_drawable_is_indexed (layer)) { g_free (cmap); cmap = gimp_image_get_colormap (image, &num_colors); gimp_image_set_colormap (tmp_image, cmap, num_colors); } else if (gimp_drawable_is_gray (layer)) { gimp_image_convert_grayscale (tmp_image); } else { gimp_image_convert_rgb (tmp_image); } tmp = gimp_drawable_get (tmp_layer); gimp_pixel_rgn_init (&dst_pixel_rgn, tmp, 0, 0, w, h, TRUE, FALSE); gimp_pixel_rgn_set_rect (&dst_pixel_rgn, buffer, 0, 0, w, h); gimp_drawable_detach (tmp); if (!gimp_drawable_is_rgb (layer)) gimp_image_convert_rgb (tmp_image); gimp_image_convert_indexed (tmp_image, GIMP_FS_DITHER, GIMP_MAKE_PALETTE, (1<<bpp) - 1, TRUE, FALSE, "dummy"); } g_free (cmap); g_free (buffer); pixbuf = gimp_drawable_get_thumbnail (tmp_layer, MIN (w, 128), MIN (h, 128), GIMP_PIXBUF_SMALL_CHECKS); gimp_image_delete (tmp_image); } else if (bpp == 24) { GimpDrawable *drawable; GimpDrawable *tmp; GimpPixelRgn src_pixel_rgn, dst_pixel_rgn; gint32 image; gint32 tmp_image; gint32 tmp_layer; guchar *buffer; GimpParam *return_vals; gint n_return_vals; image = gimp_item_get_image (layer); tmp_image = gimp_image_new (w, h, gimp_image_base_type (image)); gimp_image_undo_disable (tmp_image); if (gimp_drawable_is_indexed (layer)) { guchar *cmap; gint num_colors; cmap = gimp_image_get_colormap (image, &num_colors); gimp_image_set_colormap (tmp_image, cmap, num_colors); g_free (cmap); } tmp_layer = gimp_layer_new (tmp_image, "temporary", w, h, gimp_drawable_type (layer), 100, GIMP_NORMAL_MODE); gimp_image_insert_layer (tmp_image, tmp_layer, -1, 0); drawable = gimp_drawable_get (layer); tmp = gimp_drawable_get (tmp_layer); gimp_pixel_rgn_init (&src_pixel_rgn, drawable, 0, 0, w, h, FALSE, FALSE); gimp_pixel_rgn_init (&dst_pixel_rgn, tmp, 0, 0, w, h, TRUE, FALSE); buffer = g_malloc (w * h * 4); gimp_pixel_rgn_get_rect (&src_pixel_rgn, buffer, 0, 0, w, h); gimp_pixel_rgn_set_rect (&dst_pixel_rgn, buffer, 0, 0, w, h); g_free (buffer); gimp_drawable_detach (tmp); gimp_drawable_detach (drawable); if (gimp_drawable_is_indexed (layer)) gimp_image_convert_rgb (tmp_image); return_vals = gimp_run_procedure ("plug-in-threshold-alpha", &n_return_vals, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE, GIMP_PDB_IMAGE, tmp_image, GIMP_PDB_DRAWABLE, tmp_layer, GIMP_PDB_INT32, ICO_ALPHA_THRESHOLD, GIMP_PDB_END); gimp_destroy_params (return_vals, n_return_vals); pixbuf = gimp_drawable_get_thumbnail (tmp_layer, MIN (w, 128), MIN (h, 128), GIMP_PIXBUF_SMALL_CHECKS); gimp_image_delete (tmp_image); } else { pixbuf = gimp_drawable_get_thumbnail (layer, MIN (w, 128), MIN (h, 128), GIMP_PIXBUF_SMALL_CHECKS); } gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf); g_object_unref (pixbuf); }
/* Decompose an image. It returns the number of new (gray) images. * The image IDs for the new images are returned in image_ID_dst. * On failure, -1 is returned. */ static gint32 decompose (gint32 image_ID, gint32 drawable_ID, const gchar *extract_type, gint32 *image_ID_dst, gint32 *nlayers, gint32 *layer_ID_dst) { const gchar *layername; gint j, extract_idx; gint height, width, num_layers; GeglBuffer *src_buffer; GeglBuffer *dst_buffer[MAX_EXTRACT_IMAGES]; GimpPrecision precision; gboolean requirments = FALSE, decomp_has_alpha = FALSE; extract_idx = -1; /* Search extract type */ for (j = 0; j < G_N_ELEMENTS (extract); j++) { if (g_ascii_strcasecmp (extract_type, extract[j].type) == 0) { extract_idx = j; break; } } if (extract_idx < 0) return -1; num_layers = extract[extract_idx].num_images; /* Sanity checks */ src_buffer = gimp_drawable_get_buffer (drawable_ID); precision = gimp_image_get_precision (image_ID); for (j = 0; j < num_layers; j++) { /* FIXME: Not 100% reliable */ decomp_has_alpha |= !g_strcmp0 ("alpha", extract[extract_idx].component[j].babl_name); decomp_has_alpha |= !g_strcmp0 ("A", extract[extract_idx].component[j].babl_name); } requirments |= (gimp_drawable_is_rgb (drawable_ID)); requirments |= (gimp_drawable_is_indexed (drawable_ID)); requirments |= (gimp_drawable_is_gray (drawable_ID) && gimp_drawable_has_alpha (drawable_ID) && (num_layers <= 2) && decomp_has_alpha); requirments &= (!decomp_has_alpha || gimp_drawable_has_alpha (drawable_ID)); if (!requirments) { g_message (_("Image not suitable for this decomposition")); return -1; } width = gegl_buffer_get_width (src_buffer); height = gegl_buffer_get_height (src_buffer); /* Create all new gray images */ for (j = 0; j < num_layers; j++) { gchar *filename; gdouble xres, yres; filename = generate_filename (image_ID, extract_idx, j); gimp_image_get_resolution (image_ID, &xres, &yres); if (decovals.as_layers) { layername = gettext (extract[extract_idx].component[j].channel_name); if (j == 0) image_ID_dst[j] = create_new_image (filename, layername, width, height, GIMP_GRAY, precision, xres, yres, layer_ID_dst + j); else layer_ID_dst[j] = create_new_layer (image_ID_dst[0], j, layername, width, height, GIMP_GRAY); } else { image_ID_dst[j] = create_new_image (filename, NULL, width, height, GIMP_GRAY, precision, xres, yres, layer_ID_dst + j); } g_free (filename); dst_buffer[j] = gimp_drawable_get_buffer (layer_ID_dst[j]); } copy_n_components (src_buffer, dst_buffer, extract[extract_idx]); if (decovals.use_registration) transfer_registration_color (src_buffer, dst_buffer, num_layers); gimp_progress_update (1.0); g_object_unref (src_buffer); for (j = 0; j < num_layers; j++) { g_object_unref (dst_buffer[j]); } *nlayers = num_layers; return (decovals.as_layers ? 1 : num_layers); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; 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); gimp_tile_cache_ntiles (2 * drawable->ntile_cols); switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &bvals); /* First acquire information with a dialog */ if (! sobel_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 6) { status = GIMP_PDB_CALLING_ERROR; } else { bvals.horizontal = (param[4].data.d_int32) ? TRUE : FALSE; bvals.vertical = (param[5].data.d_int32) ? TRUE : FALSE; bvals.keep_sign = (param[6].data.d_int32) ? TRUE : FALSE; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &bvals); break; default: break; } /* 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)) { sobel (drawable, bvals.horizontal, bvals.vertical, bvals.keep_sign, NULL); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &bvals, sizeof (bvals)); } 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."); } gimp_drawable_detach (drawable); values[0].data.d_status = status; }
void filters_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image; GimpDrawable *drawable = NULL; gboolean writable = FALSE; gboolean gray = FALSE; gboolean alpha = FALSE; image = action_data_get_image (data); if (image) { drawable = gimp_image_get_active_drawable (image); if (drawable) { GimpItem *item; alpha = gimp_drawable_has_alpha (drawable); gray = gimp_drawable_is_gray (drawable); if (GIMP_IS_LAYER_MASK (drawable)) item = GIMP_ITEM (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable))); else item = GIMP_ITEM (drawable); writable = ! gimp_item_is_content_locked (item); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) writable = FALSE; } } #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) SET_SENSITIVE ("filters-c2g", writable && !gray); SET_SENSITIVE ("filters-cartoon", writable); SET_SENSITIVE ("filters-color-reduction", writable); SET_SENSITIVE ("filters-color-temperature", writable && !gray); SET_SENSITIVE ("filters-color-to-alpha", writable && !gray && alpha); SET_SENSITIVE ("filters-difference-of-gaussians", writable); SET_SENSITIVE ("filters-dot", writable); SET_SENSITIVE ("filters-gaussian-blur", writable); SET_SENSITIVE ("filters-laplace", writable); SET_SENSITIVE ("filters-mono-mixer", writable && !gray); SET_SENSITIVE ("filters-noise-cie-lch", writable); SET_SENSITIVE ("filters-noise-hsv", writable && !gray); SET_SENSITIVE ("filters-noise-hurl", writable); SET_SENSITIVE ("filters-noise-pick", writable); SET_SENSITIVE ("filters-noise-rgb", writable); SET_SENSITIVE ("filters-noise-slur", writable); SET_SENSITIVE ("filters-lens-distortion", writable); SET_SENSITIVE ("filters-photocopy", writable); SET_SENSITIVE ("filters-pixelize", writable); SET_SENSITIVE ("filters-polar-coordinates", writable); SET_SENSITIVE ("filters-ripple", writable); SET_SENSITIVE ("filters-sobel", writable); SET_SENSITIVE ("filters-softglow", writable); SET_SENSITIVE ("filters-semi-flatten", writable && alpha); SET_SENSITIVE ("filters-threshold-alpha", writable && alpha); SET_SENSITIVE ("filters-unsharp-mask", writable); #undef SET_SENSITIVE }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpDrawable *drawable; gint32 image_ID; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; image_ID = param[1].data.d_int32; INIT_I18N (); /* 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; switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &shvals); /* First acquire information with a dialog */ if (! shift_dialog (image_ID, drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 5) { status = GIMP_PDB_CALLING_ERROR; } else { shvals.shift_amount = param[3].data.d_int32; shvals.orientation = (param[4].data.d_int32) ? HORIZONTAL : VERTICAL; if (shvals.shift_amount < 0 || shvals.shift_amount > 200) status = GIMP_PDB_CALLING_ERROR; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &shvals); 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 (_("Shifting")); /* run the shift effect */ shift (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, &shvals, sizeof (ShiftValues)); } else { /* gimp_message ("shift: cannot operate on indexed color images"); */ status = GIMP_PDB_EXECUTION_ERROR; } } 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) { GimpRunMode run_mode; GimpPDBStatusType status; static GimpParam values[1]; INIT_I18N (); /* * Initialize parameter data... */ status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; *nreturn_vals = 1; *return_vals = values; /* * Get drawable information... */ drawable = gimp_drawable_get (param[2].data.d_drawable); /* * See how we will run */ switch (run_mode) { case GIMP_RUN_INTERACTIVE : /* * Possibly retrieve data... */ gimp_get_data (PLUG_IN_PROC, &despeckle_radius); /* * Get information from the dialog... */ if (gimp_drawable_is_rgb(drawable->drawable_id) || gimp_drawable_is_gray(drawable->drawable_id)) { if (! despeckle_dialog ()) return; } break; case GIMP_RUN_NONINTERACTIVE: /* * Make sure all the arguments are present... */ if (nparams < 4 || nparams > 9) status = GIMP_PDB_CALLING_ERROR; else if (nparams == 4) { despeckle_radius = param[3].data.d_int32; filter_type = FILTER_ADAPTIVE; black_level = 7; white_level = 248; } else if (nparams == 5) { despeckle_radius = param[3].data.d_int32; filter_type = param[4].data.d_int32; black_level = 7; white_level = 248; } else if (nparams == 6) { despeckle_radius = param[3].data.d_int32; filter_type = param[4].data.d_int32; black_level = param[5].data.d_int32; white_level = 248; } else { despeckle_radius = param[3].data.d_int32; filter_type = param[4].data.d_int32; black_level = param[5].data.d_int32; white_level = param[6].data.d_int32; } break; case GIMP_RUN_WITH_LAST_VALS: /* * Possibly retrieve data... */ INIT_I18N(); gimp_get_data (PLUG_IN_PROC, despeckle_vals); break; default: status = GIMP_PDB_CALLING_ERROR; break; } /* * Despeckle the image... */ if (status == GIMP_PDB_SUCCESS) { if (gimp_drawable_is_rgb(drawable->drawable_id) || gimp_drawable_is_gray(drawable->drawable_id)) { /* * Run! */ despeckle (); /* * If run prevmode is interactive, flush displays... */ if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* * Store data... */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, despeckle_vals, sizeof (despeckle_vals)); } else status = GIMP_PDB_EXECUTION_ERROR; } /* * Reset the current run status... */ values[0].data.d_status = status; /* * Detach from the drawable... */ 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]; GimpDrawable *drawable; GimpPDBStatusType status; GimpRunMode run_mode; gdouble xhsiz, yhsiz; GimpRGB background; status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; *nreturn_vals = 1; *return_vals = values; INIT_I18N (); /* Get the active drawable info */ drawable = gimp_drawable_get (param[2].data.d_drawable); img_width = gimp_drawable_width (drawable->drawable_id); img_height = gimp_drawable_height (drawable->drawable_id); img_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); if (! gimp_drawable_mask_intersect (drawable->drawable_id, &sel_x1, &sel_y1, &sel_width, &sel_height)) return; /* Calculate scaling parameters */ sel_x2 = sel_x1 + sel_width; sel_y2 = sel_y1 + sel_height; cen_x = (double) (sel_x1 + sel_x2 - 1) / 2.0; cen_y = (double) (sel_y1 + sel_y2 - 1) / 2.0; xhsiz = (double) (sel_width - 1) / 2.0; yhsiz = (double) (sel_height - 1) / 2.0; if (xhsiz < yhsiz) { scale_x = yhsiz / xhsiz; scale_y = 1.0; } else if (xhsiz > yhsiz) { scale_x = 1.0; scale_y = xhsiz / yhsiz; } else { scale_x = 1.0; scale_y = 1.0; } /* Get background color */ gimp_context_get_background (&background); gimp_rgb_set_alpha (&background, 0.0); gimp_drawable_get_color_uchar (drawable->drawable_id, &background, back_color); /* See how we will run */ switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &pcvals); /* Get information from the dialog */ if (! polarize_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are present */ if (nparams != 8) { status = GIMP_PDB_CALLING_ERROR; } else { pcvals.circle = param[3].data.d_float; pcvals.angle = param[4].data.d_float; pcvals.backwards = param[5].data.d_int32; pcvals.inverse = param[6].data.d_int32; pcvals.polrec = param[7].data.d_int32; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &pcvals); break; default: break; } /* Distort the image */ if ((status == GIMP_PDB_SUCCESS) && (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id))) { /* Set the tile cache size */ gimp_tile_cache_ntiles (2 * (drawable->width + gimp_tile_width() - 1) / gimp_tile_width ()); /* Run! */ polarize (drawable); /* If run mode is interactive, flush displays */ if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &pcvals, sizeof (polarize_vals_t)); } else if (status == GIMP_PDB_SUCCESS) status = GIMP_PDB_EXECUTION_ERROR; 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[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, &svals); /* First acquire information with a dialog */ if (! softglow_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: svals.glow_radius = param[3].data.d_float; svals.brightness = param[4].data.d_float; svals.sharpness = param[5].data.d_float; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &svals); 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 ("Softglow"); softglow (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, &svals, sizeof (SoftglowVals)); } 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[1]; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; INIT_I18N (); /* 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; switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &rvals); /* First acquire information with a dialog */ if (! ripple_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 10) { status = GIMP_PDB_CALLING_ERROR; } else { rvals.period = param[3].data.d_int32; rvals.amplitude = param[4].data.d_int32; rvals.orientation = (param[5].data.d_int32) ? GIMP_ORIENTATION_VERTICAL : GIMP_ORIENTATION_HORIZONTAL; rvals.edges = param[6].data.d_int32; rvals.waveform = param[7].data.d_int32; rvals.antialias = (param[8].data.d_int32) ? TRUE : FALSE; rvals.tile = (param[9].data.d_int32) ? TRUE : FALSE; if (rvals.period < 1) { gimp_message ("Ripple: period must be at least 1.\n"); status = GIMP_PDB_CALLING_ERROR; } if (rvals.edges < SMEAR || rvals.edges > BLANK) status = GIMP_PDB_CALLING_ERROR; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &rvals); 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 (_("Rippling")); /* run the ripple effect */ ripple (drawable, NULL); gimp_progress_update (1.0); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &rvals, sizeof (RippleValues)); } else { /* gimp_message ("ripple: cannot operate on indexed color images"); */ status = GIMP_PDB_EXECUTION_ERROR; } } 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; gint32 drawable_id; GeglBuffer *shadow_buffer; GeglBuffer *buffer; run_mode = param[0].data.d_int32; drawable_id = param[2].data.d_drawable; INIT_I18N (); gegl_init (NULL, NULL); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; /* Get the specified drawable */ shadow_buffer = gimp_drawable_get_shadow_buffer (drawable_id); buffer = gimp_drawable_get_buffer (drawable_id); /* Make sure that the drawable is gray or RGB color */ if (gimp_drawable_is_rgb (drawable_id) || gimp_drawable_is_gray (drawable_id)) { MapMode mode = 0; if ( !strcmp (name, GRADMAP_PROC)) { mode = GRADIENT_MODE; gimp_progress_init (_("Gradient Map")); } else if ( !strcmp (name, PALETTEMAP_PROC)) { mode = PALETTE_MODE; gimp_progress_init (_("Palette Map")); } else { status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { if (mode) map (buffer, shadow_buffer, drawable_id, mode); } } else { status = GIMP_PDB_EXECUTION_ERROR; } g_object_unref (buffer); g_object_unref (shadow_buffer); gimp_drawable_merge_shadow (drawable_id, TRUE); gimp_drawable_update (drawable_id, 0, 0, gimp_drawable_width (drawable_id), gimp_drawable_height (drawable_id)); values[0].data.d_status = status; if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; 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 so that the gaussian blur works well */ gimp_tile_cache_ntiles (2 * (MAX (drawable->ntile_rows, drawable->ntile_cols))); *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, &evals); /* First acquire information with a dialog */ if (! neon_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 5) status = GIMP_PDB_CALLING_ERROR; if (status == GIMP_PDB_SUCCESS) { evals.radius = param[3].data.d_float; evals.amount = param[4].data.d_float; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &evals); break; default: break; } /* make sure the drawable exist and is not indexed */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id)) { gimp_progress_init (_("Neon")); /* run the neon effect */ neon (drawable, evals.radius, evals.amount, NULL); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &evals, sizeof (NeonVals)); } else { g_message (_("Cannot operate on indexed color images.")); status = GIMP_PDB_EXECUTION_ERROR; } 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]; /* Return values */ GimpRunMode run_mode; /* Current run mode */ GimpPDBStatusType status; /* Return status */ GimpDrawable *drawable; /* Current image */ /* * Initialize parameter data... */ 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 drawable information... */ drawable = gimp_drawable_get (param[2].data.d_drawable); gimp_tile_cache_ntiles (2 * drawable->ntile_cols); /* * See how we will run */ switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* * Possibly retrieve data... */ gimp_get_data (PLUG_IN_PROC, &sharpen_params); /* * Get information from the dialog... */ if (!sharpen_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* * Make sure all the arguments are present... */ if (nparams != 4) status = GIMP_PDB_CALLING_ERROR; else sharpen_params.sharpen_percent = param[3].data.d_int32; break; case GIMP_RUN_WITH_LAST_VALS: /* * Possibly retrieve data... */ gimp_get_data (PLUG_IN_PROC, &sharpen_params); break; default: status = GIMP_PDB_CALLING_ERROR; break; } /* * Sharpen the image... */ if (status == GIMP_PDB_SUCCESS) { if ((gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id))) { /* * Run! */ sharpen (drawable); /* * If run mode is interactive, flush displays... */ if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* * Store data... */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &sharpen_params, sizeof (SharpenParams)); } else status = GIMP_PDB_EXECUTION_ERROR; } /* * Reset the current run status... */ values[0].data.d_status = status; /* * Detach from the drawable... */ gimp_drawable_detach (drawable); }
void filters_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image; GimpDrawable *drawable = NULL; gboolean writable = FALSE; gboolean gray = FALSE; gboolean alpha = FALSE; image = action_data_get_image (data); if (image) { drawable = gimp_image_get_active_drawable (image); if (drawable) { GimpItem *item; alpha = gimp_drawable_has_alpha (drawable); gray = gimp_drawable_is_gray (drawable); if (GIMP_IS_LAYER_MASK (drawable)) item = GIMP_ITEM (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable))); else item = GIMP_ITEM (drawable); writable = ! gimp_item_is_content_locked (item); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) writable = FALSE; } } #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) SET_SENSITIVE ("filters-alien-map", writable); SET_SENSITIVE ("filters-antialias", writable); SET_SENSITIVE ("filters-apply-canvas", writable); SET_SENSITIVE ("filters-apply-lens", writable); SET_SENSITIVE ("filters-bump-map", writable); SET_SENSITIVE ("filters-c2g", writable && !gray); SET_SENSITIVE ("filters-cartoon", writable); SET_SENSITIVE ("filters-channel-mixer", writable); SET_SENSITIVE ("filters-checkerboard", writable); SET_SENSITIVE ("filters-color-enhance", writable && !gray); SET_SENSITIVE ("filters-color-exchange", writable); SET_SENSITIVE ("filters-color-reduction", writable); SET_SENSITIVE ("filters-color-rotate", writable); SET_SENSITIVE ("filters-color-temperature", writable && !gray); SET_SENSITIVE ("filters-color-to-alpha", writable && !gray && alpha); SET_SENSITIVE ("filters-convolution-matrix", writable); SET_SENSITIVE ("filters-cubism", writable); SET_SENSITIVE ("filters-deinterlace", writable); SET_SENSITIVE ("filters-desaturate", writable && !gray); SET_SENSITIVE ("filters-difference-of-gaussians", writable); SET_SENSITIVE ("filters-diffraction-patterns", writable); SET_SENSITIVE ("filters-displace", writable); SET_SENSITIVE ("filters-distance-map", writable); SET_SENSITIVE ("filters-dropshadow", writable && alpha); SET_SENSITIVE ("filters-edge", writable); SET_SENSITIVE ("filters-edge-laplace", writable); SET_SENSITIVE ("filters-edge-sobel", writable); SET_SENSITIVE ("filters-emboss", writable); SET_SENSITIVE ("filters-engrave", writable); SET_SENSITIVE ("filters-exposure", writable); SET_SENSITIVE ("filters-fractal-trace", writable); SET_SENSITIVE ("filters-gaussian-blur", writable); SET_SENSITIVE ("filters-gaussian-blur-selective", writable); SET_SENSITIVE ("filters-gegl-graph", writable); SET_SENSITIVE ("filters-grid", writable); SET_SENSITIVE ("filters-high-pass", writable); SET_SENSITIVE ("filters-illusion", writable); SET_SENSITIVE ("filters-kaleidoscope", writable); SET_SENSITIVE ("filters-lens-distortion", writable); SET_SENSITIVE ("filters-lens-flare", writable); SET_SENSITIVE ("filters-maze", writable); SET_SENSITIVE ("filters-mono-mixer", writable && !gray); SET_SENSITIVE ("filters-mosaic", writable); SET_SENSITIVE ("filters-motion-blur-circular", writable); SET_SENSITIVE ("filters-motion-blur-linear", writable); SET_SENSITIVE ("filters-motion-blur-zoom", writable); SET_SENSITIVE ("filters-noise-cell", writable); SET_SENSITIVE ("filters-noise-cie-lch", writable); SET_SENSITIVE ("filters-noise-hsv", writable && !gray); SET_SENSITIVE ("filters-noise-hurl", writable); SET_SENSITIVE ("filters-noise-perlin", writable); SET_SENSITIVE ("filters-noise-pick", writable); SET_SENSITIVE ("filters-noise-reduction", writable); SET_SENSITIVE ("filters-noise-rgb", writable); SET_SENSITIVE ("filters-noise-simplex", writable); SET_SENSITIVE ("filters-noise-slur", writable); SET_SENSITIVE ("filters-noise-solid", writable); SET_SENSITIVE ("filters-noise-spread", writable); SET_SENSITIVE ("filters-oilify", writable); SET_SENSITIVE ("filters-panorama-projection", writable); SET_SENSITIVE ("filters-photocopy", writable); SET_SENSITIVE ("filters-pixelize", writable); SET_SENSITIVE ("filters-plasma", writable); SET_SENSITIVE ("filters-polar-coordinates", writable); SET_SENSITIVE ("filters-posterize", writable); SET_SENSITIVE ("filters-red-eye-removal", writable && !gray); SET_SENSITIVE ("filters-ripple", writable); SET_SENSITIVE ("filters-saturation", writable && !gray); SET_SENSITIVE ("filters-semi-flatten", writable && alpha); SET_SENSITIVE ("filters-sepia", writable && !gray); SET_SENSITIVE ("filters-shift", writable); SET_SENSITIVE ("filters-sinus", writable); SET_SENSITIVE ("filters-softglow", writable); SET_SENSITIVE ("filters-stretch-contrast", writable); SET_SENSITIVE ("filters-stretch-contrast-hsv", writable); SET_SENSITIVE ("filters-supernova", writable); SET_SENSITIVE ("filters-threshold-alpha", writable && alpha); SET_SENSITIVE ("filters-tile-glass", writable); SET_SENSITIVE ("filters-tile-paper", writable); SET_SENSITIVE ("filters-tile-seamless", writable); SET_SENSITIVE ("filters-unsharp-mask", writable); SET_SENSITIVE ("filters-value-propagate", writable); SET_SENSITIVE ("filters-video-degradation", writable); SET_SENSITIVE ("filters-vignette", writable); SET_SENSITIVE ("filters-waves", writable); SET_SENSITIVE ("filters-whirl-pinch", writable); SET_SENSITIVE ("filters-wind", writable); #undef SET_SENSITIVE { GimpProcedure *proc = gimp_filter_history_nth (group->gimp, 0); gint i; if (proc && gimp_procedure_get_sensitive (proc, GIMP_OBJECT (drawable))) { gimp_action_group_set_action_sensitive (group, "filters-repeat", TRUE); gimp_action_group_set_action_sensitive (group, "filters-reshow", TRUE); } else { gimp_action_group_set_action_sensitive (group, "filters-repeat", FALSE); gimp_action_group_set_action_sensitive (group, "filters-reshow", FALSE); } for (i = 0; i < gimp_filter_history_length (group->gimp); i++) { gchar *name = g_strdup_printf ("filter-recent-%02d", i + 1); gboolean sensitive; proc = gimp_filter_history_nth (group->gimp, i); sensitive = gimp_procedure_get_sensitive (proc, GIMP_OBJECT (drawable)); gimp_action_group_set_action_sensitive (group, name, sensitive); g_free (name); } } }
/* do the analyzing */ static void analyze (GimpDrawable *drawable) { GimpPixelRgn srcPR; guchar *src_row, *cmap; gint x, y, numcol; gint x1, y1, x2, y2; guchar r, g, b; gint a; guchar idx; gboolean gray; gboolean has_alpha; gboolean has_sel; guchar *sel; GimpPixelRgn selPR; gint ofsx, ofsy; GimpDrawable *selDrawable; gimp_progress_init (_("Colorcube Analysis")); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); /* * Get the size of the input image (this will/must be the same * as the size of the output image). */ width = drawable->width; height = drawable->height; bpp = drawable->bpp; has_sel = !gimp_selection_is_empty (imageID); gimp_drawable_offsets (drawable->drawable_id, &ofsx, &ofsy); /* initialize the pixel region */ gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, width, height, FALSE, FALSE); cmap = gimp_image_get_colormap (imageID, &numcol); gray = (gimp_drawable_is_gray (drawable->drawable_id) || gimp_item_is_channel (drawable->drawable_id)); has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); selDrawable = gimp_drawable_get (gimp_image_get_selection (imageID)); gimp_pixel_rgn_init (&selPR, selDrawable, 0, 0, width, height, FALSE, FALSE); /* allocate row buffer */ src_row = g_new (guchar, (x2 - x1) * bpp); sel = g_new (guchar, x2 - x1); for (y = y1; y < y2; y++) { gimp_pixel_rgn_get_row (&srcPR, src_row, x1, y, (x2 - x1)); if (has_sel) gimp_pixel_rgn_get_row (&selPR, sel, x1 + ofsx, y + ofsy, (x2 - x1)); for (x = 0; x < x2 - x1; x++) { /* Start with full opacity. */ a = 255; /* * If the image is indexed, fetch RGB values * from colormap. */ if (cmap) { idx = src_row[x * bpp]; r = cmap[idx * 3]; g = cmap[idx * 3 + 1]; b = cmap[idx * 3 + 2]; if (has_alpha) a = src_row[x * bpp + 1]; } else if (gray) { r = g = b = src_row[x * bpp]; if (has_alpha) a = src_row[x * bpp + 1]; } else { r = src_row[x * bpp]; g = src_row[x * bpp + 1]; b = src_row[x * bpp + 2]; if (has_alpha) a = src_row[x * bpp + 3]; } if (has_sel) a *= sel[x]; else a *= 255; if (a != 0) insertcolor (r, g, b, (gdouble) a * (1.0 / (255.0 * 255.0))); } /* tell the user what we're doing */ if ((y % 10) == 0) gimp_progress_update ((gdouble) y / (gdouble) (y2 - y1)); } gimp_progress_update (1.0); /* clean up */ gimp_drawable_detach (selDrawable); g_free (src_row); g_free (sel); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; *nreturn_vals = 1; *return_vals = values; 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); width = gimp_image_width (image_ID); height = gimp_image_height (image_ID); switch (run_mode) { case GIMP_RUN_INTERACTIVE: if (! border_dialog (image_ID, drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: break; case GIMP_RUN_WITH_LAST_VALS: break; default: break; } if ((status == GIMP_PDB_SUCCESS) && (gimp_drawable_is_rgb(drawable->drawable_id) || gimp_drawable_is_gray(drawable->drawable_id))) { /* Run! */ gimp_image_undo_group_start (image_ID); border (image_ID); gimp_image_undo_group_end (image_ID); /* If run mode is interactive, flush displays */ if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ /*if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &rbvals, sizeof (BorderValues));*/ } gimp_drawable_detach (drawable); }
static void run( const gchar * name, gint nparams, const GimpParam * param, gint * nreturn_vals, GimpParam ** return_vals) { static GimpParam values[2]; /* Gimp return values. !!! Allow 2: status and error message. */ TGimpAdapterParameters pluginParameters; TImageSynthParameters engineParameters; GimpDrawable *drawable = NULL; GimpDrawable *corpus_drawable = NULL; GimpDrawable *map_in_drawable= NULL; GimpDrawable *map_out_drawable= NULL; gboolean ok, with_map; /* Local copies of pixmaps (not using gimp regions.) 2-D arrays of Pixel, addressable by Coordinates (Point). c++: static Bitmap<Pixelel> */ Map targetMap; Map corpusMap; Map targetMaskMap; Map corpusMaskMap; int cancelFlag = 0; #ifdef SYNTH_THREADED // This is as early as it can be called. Not sure it needs to be called. See later call to it. // Call it early since calls to gdk, gtk might require this? g_thread_init(NULL); #endif #ifdef DEBUG gimp_message_set_handler(1); // To console instead of GUI start_time = clock(); #endif // internationalization i18n // Note these constants are defined in the build environment. /* Initialize i18n support */ #if defined(G_OS_WIN32) bindtextdomain (GETTEXT_PACKAGE, gimp_locale_directory()); #else bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); #endif #ifdef HAVE_BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); #endif textdomain (GETTEXT_PACKAGE); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; /* Unless everything succeeds. */ drawable = gimp_drawable_get(param[2].data.d_drawable); /* Check image type (could be called non-interactive) */ if (!gimp_drawable_is_rgb(drawable->drawable_id) && !gimp_drawable_is_gray(drawable->drawable_id)) { ERROR_RETURN(_("Incompatible image mode.")); } /* Deal with run mode */ ok = FALSE; switch(param[0].data.d_int32) { case GIMP_RUN_INTERACTIVE : ok = get_last_parameters(&pluginParameters,drawable->drawable_id, RESYNTH_ENGINE_PDB_NAME); gimp_message("Resynthesizer engine should not be called interactively"); /* But keep going with last (or default) parameters, really no harm. */ break; case GIMP_RUN_NONINTERACTIVE : ok = get_parameters_from_list(&pluginParameters, nparams, param); break; case GIMP_RUN_WITH_LAST_VALS : ok = get_last_parameters(&pluginParameters,drawable->drawable_id, RESYNTH_ENGINE_PDB_NAME); break; } if (!ok) { ERROR_RETURN(_("Resynthesizer failed to get parameters.")); } /* Limit neighbours parameter to size allocated. */ if (pluginParameters.neighbours > IMAGE_SYNTH_MAX_NEIGHBORS ) pluginParameters.neighbours = IMAGE_SYNTH_MAX_NEIGHBORS; corpus_drawable = gimp_drawable_get(pluginParameters.corpus_id); /* The target and corpus must have the same base type. In earlier version, they must have the same bpp. But now we don't compare the alphas, so they can differ in presence of alpha. */ if (! equal_basetypes(drawable, corpus_drawable) ) { ERROR_RETURN(_("The input texture and output image must have the same number of color channels.")); } with_map = (pluginParameters.input_map_id != -1 && pluginParameters.output_map_id != -1); /* If only one map is passed, it is ignored quietly. */ map_in_drawable=0; map_out_drawable=0; if (with_map) { map_in_drawable = gimp_drawable_get(pluginParameters.input_map_id); map_out_drawable = gimp_drawable_get(pluginParameters.output_map_id); /* All these can be wrong at the same time. Forego userfriendliness for ease of programming: abort on first error */ if ( ! equal_basetypes(map_in_drawable, map_out_drawable) ) { /* Maps need the same base type. Formerly needed the same bpp. */ ERROR_RETURN(_("The input and output maps must have the same mode")); } if (map_in_drawable->width != corpus_drawable->width || map_in_drawable->height != corpus_drawable->height) { ERROR_RETURN(_("The input map should be the same size as the input texture image")); } if (map_out_drawable->width != drawable->width || map_out_drawable->height != drawable->height) { ERROR_RETURN(_("The output map should be the same size as the output image")); } } /* The engine should not be run interactively so no need to store last values. I.E. the meaning of "last" is "last values set by user interaction". */ #ifdef ANIMATE // Copy local pointer vars to globals targetDrawableCopy = drawable; targetMapCopy = &targetMap; #endif /* Error checks done, initialization work begins. So start progress callbacks. */ progressStart("Initializing..."); /* Set flags for presence of alpha channels. The flag is an optimization. Alternatives: - a function - OR standardize the internal pixmap to ALWAYS have an alpha pixelel initialized to VISIBLE and set from any alpha pixelel. */ gboolean is_alpha_image = gimp_drawable_has_alpha(drawable->drawable_id); gboolean is_alpha_corpus = gimp_drawable_has_alpha(corpus_drawable->drawable_id); // Image adaption requires format indices // WAS prepareImageFormatIndices(drawable, corpus_drawable, with_map, map_in_drawable); TFormatIndices formatIndices; guint map_count = (with_map? count_color_channels(map_in_drawable) : 0 ); prepareImageFormatIndices( &formatIndices, count_color_channels(drawable), map_count, is_alpha_image, is_alpha_corpus, with_map ); #ifdef ADAPT_SIMPLE /* Adapt Gimp to an engine with a simpler interface. */ setDefaultParams(¶meters); ImageBuffer imageBuffer; ImageBuffer maskBuffer; // TODO change to new signature adaptGimpToSimple(drawable, &imageBuffer, &maskBuffer); // From Gimp to simple g_printf("Here3\n"); adaptSimpleAPI(&imageBuffer, &maskBuffer); // From simple to existing engine API #else g_printf("Gimp adaption\n"); /* target/context adaption */ fetch_image_mask_map(drawable, &targetMap, formatIndices.total_bpp, &targetMaskMap, MASK_TOTALLY_SELECTED, map_out_drawable, formatIndices.map_start_bip); #ifdef ANIMATE clear_target_pixels(formatIndices.colorEndBip); // For debugging, blacken so new colors sparkle #endif /* corpus adaption */ fetch_image_mask_map(corpus_drawable, &corpusMap, formatIndices.total_bpp, &corpusMaskMap, MASK_TOTALLY_SELECTED, map_in_drawable, formatIndices.map_start_bip); // TODO These are artifacts of earlier design, not used. free_map(&corpusMaskMap); free_map(&targetMaskMap); adaptParameters(&pluginParameters, &engineParameters); #endif // After possible adaption, check size again g_assert(targetMap.width * targetMap.height); // Image is not empty g_assert(corpusMap.width * corpusMap.height); // Corpus is not empty // Done with adaption: now main image data in canonical pixmaps, etc. // Begin real work progressStart("synthesizing..."); int result = engine( engineParameters, &formatIndices, &targetMap, &corpusMap, progressUpdate, (void *) 0, &cancelFlag ); if (result == IMAGE_SYNTH_ERROR_EMPTY_CORPUS) { ERROR_RETURN(_("The texture source is empty. Does any selection include non-transparent pixels?")); } else if (result == IMAGE_SYNTH_ERROR_EMPTY_TARGET ) { ERROR_RETURN(_("The output layer is empty. Does any selection have visible pixels in the active layer?")); } // Normal post-process adaption follows /* dump_target_points(); */ /* detailed debugging. */ // print_post_stats(); // Update Gimp image from local pixmap // Note this works even for test harness where ADAPT_SIMPLE // but then it does NOT test returning results in buffer. /* We could test antiAdaptImage() here. But antiAdaptImage() has already been tested once on the incoming side. So no compelling need to test it again here. */ post_results_to_gimp(drawable, targetMap); /* Clean up */ // Adapted free_map(&targetMap); free_map(&corpusMap); // GIMP detach_drawables(drawable, corpus_drawable, map_in_drawable, map_out_drawable); gimp_progress_end(); values[0].data.d_status = GIMP_PDB_SUCCESS; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; gint32 image_ID; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GError *error = NULL; 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; if (! gimp_item_is_layer (param[2].data.d_drawable)) { g_set_error (&error, 0, 0, "%s", _("Can operate on layers only " "(but was called on channel or mask).")); status = GIMP_PDB_EXECUTION_ERROR; } if (status == GIMP_PDB_SUCCESS) { /* 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 (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 { 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."); } gimp_drawable_detach (drawable); } if (status != GIMP_PDB_SUCCESS && error) { *nreturn_vals = 2; values[1].type = GIMP_PDB_STRING; values[1].data.d_string = error->message; } 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]; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 image_id; INIT_I18N(); *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 (_("Zealous cropping")); gimp_tile_cache_ntiles (1 + 2 * (drawable->width > drawable->height ? (drawable->width / gimp_tile_width()) : (drawable->height / gimp_tile_height()))); do_zcrop(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; }
void filters_actions_update (GimpActionGroup *group, gpointer data) { GimpImage *image; GimpDrawable *drawable = NULL; gboolean writable = FALSE; gboolean gray = FALSE; gboolean alpha = FALSE; image = action_data_get_image (data); if (image) { drawable = gimp_image_get_active_drawable (image); if (drawable) { GimpItem *item; alpha = gimp_drawable_has_alpha (drawable); gray = gimp_drawable_is_gray (drawable); if (GIMP_IS_LAYER_MASK (drawable)) item = GIMP_ITEM (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable))); else item = GIMP_ITEM (drawable); writable = ! gimp_item_is_content_locked (item); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) writable = FALSE; } } #define SET_SENSITIVE(action,condition) \ gimp_action_group_set_action_sensitive (group, action, (condition) != 0) SET_SENSITIVE ("filters-alien-map", writable); SET_SENSITIVE ("filters-antialias", writable); SET_SENSITIVE ("filters-bump-map", writable); SET_SENSITIVE ("filters-c2g", writable && !gray); SET_SENSITIVE ("filters-cartoon", writable); SET_SENSITIVE ("filters-checkerboard", writable); SET_SENSITIVE ("filters-color-reduction", writable); SET_SENSITIVE ("filters-color-temperature", writable && !gray); SET_SENSITIVE ("filters-color-to-alpha", writable && !gray && alpha); SET_SENSITIVE ("filters-cubism", writable); SET_SENSITIVE ("filters-deinterlace", writable); SET_SENSITIVE ("filters-difference-of-gaussians", writable); SET_SENSITIVE ("filters-dropshadow", writable && alpha); SET_SENSITIVE ("filters-edge-laplace", writable); SET_SENSITIVE ("filters-edge-sobel", writable); SET_SENSITIVE ("filters-emboss", writable); SET_SENSITIVE ("filters-exposure", writable); SET_SENSITIVE ("filters-fractal-trace", writable); SET_SENSITIVE ("filters-gaussian-blur", writable); SET_SENSITIVE ("filters-grid", writable); SET_SENSITIVE ("filters-mono-mixer", writable && !gray); SET_SENSITIVE ("filters-mosaic", writable); SET_SENSITIVE ("filters-motion-blur-circular", writable); SET_SENSITIVE ("filters-motion-blur-linear", writable); SET_SENSITIVE ("filters-motion-blur-zoom", writable); SET_SENSITIVE ("filters-noise-cie-lch", writable); SET_SENSITIVE ("filters-noise-hsv", writable && !gray); SET_SENSITIVE ("filters-noise-hurl", writable); SET_SENSITIVE ("filters-noise-pick", writable); SET_SENSITIVE ("filters-noise-rgb", writable); SET_SENSITIVE ("filters-noise-slur", writable); SET_SENSITIVE ("filters-noise-spread", writable); SET_SENSITIVE ("filters-lens-distortion", writable); SET_SENSITIVE ("filters-photocopy", writable); SET_SENSITIVE ("filters-pixelize", writable); SET_SENSITIVE ("filters-plasma", writable); SET_SENSITIVE ("filters-polar-coordinates", writable); SET_SENSITIVE ("filters-red-eye-removal", writable && !gray); SET_SENSITIVE ("filters-ripple", writable); SET_SENSITIVE ("filters-semi-flatten", writable && alpha); SET_SENSITIVE ("filters-shift", writable); SET_SENSITIVE ("filters-softglow", writable); SET_SENSITIVE ("filters-stretch-contrast", writable); SET_SENSITIVE ("filters-stretch-contrast-hsv", writable); SET_SENSITIVE ("filters-threshold-alpha", writable && alpha); SET_SENSITIVE ("filters-tile-seamless", writable); SET_SENSITIVE ("filters-unsharp-mask", writable); SET_SENSITIVE ("filters-vignette", writable); SET_SENSITIVE ("filters-waves", writable); SET_SENSITIVE ("filters-whirl-pinch", writable); SET_SENSITIVE ("filters-wind", writable); #undef SET_SENSITIVE }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[2]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 drawable_id; run_mode = param[0].data.d_int32; INIT_I18N (); set_default_params (); /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &curl); *nreturn_vals = 2; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; values[1].type = GIMP_PDB_LAYER; values[1].data.d_layer = -1; /* Get the specified drawable */ drawable_id = param[2].data.d_drawable; image_id = param[1].data.d_image; if (gimp_drawable_is_rgb (drawable_id) || gimp_drawable_is_gray (drawable_id)) { switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* First acquire information with a dialog */ if (! dialog ()) 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) { curl.colors = CLAMP (param[3].data.d_int32, 0, CURL_COLORS_LAST); curl.edge = CLAMP (param[4].data.d_int32, CURL_EDGE_FIRST, CURL_EDGE_LAST); curl.orientation = CLAMP (param[5].data.d_int32, 0, CURL_ORIENTATION_LAST); curl.shade = param[6].data.d_int32 ? TRUE : FALSE; } break; case GIMP_RUN_WITH_LAST_VALS: break; default: break; } if (status == GIMP_PDB_SUCCESS) { values[1].data.d_layer = page_curl (drawable_id); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &curl, sizeof (CurlParams)); } } else /* Sorry - no indexed/noalpha images */ status = GIMP_PDB_EXECUTION_ERROR; 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]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpDrawable *drawable; run_mode = param[0].data.d_int32; INIT_I18N (); /* Get the specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); *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: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &evals); /* First acquire information with a dialog */ if (! edge_dialog (drawable)) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are there! */ if (nparams != 5 && nparams != 6) { status = GIMP_PDB_CALLING_ERROR; } if (status == GIMP_PDB_SUCCESS) { evals.amount = param[3].data.d_float; evals.wrapmode = param[4].data.d_int32; evals.edgemode = nparams > 5 ? param[5].data.d_int32 : SOBEL; } break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &evals); break; default: break; } /* make sure the drawable exist and is not indexed */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id)) { gimp_progress_init (_("Edge detection")); /* set the tile cache size */ gimp_tile_cache_ntiles (TILE_CACHE_SIZE); /* run the edge effect */ edge (drawable); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data (PLUG_IN_PROC, &evals, sizeof (EdgeVals)); } else { /* gimp_message ("edge: cannot operate on indexed color images"); */ status = GIMP_PDB_EXECUTION_ERROR; } 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; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; /* assume the best! */ static GimpParam values[1]; INIT_I18N (); /* * Get the specified drawable, do standard initialization. */ if (strcmp (name, PLUG_IN_PROC[0]) == 0) rndm_type = RNDM_HURL; else if (strcmp (name, PLUG_IN_PROC[1]) == 0) rndm_type = RNDM_PICK; else if (strcmp (name, PLUG_IN_PROC[2]) == 0) rndm_type = RNDM_SLUR; run_mode = param[0].data.d_int32; drawable = gimp_drawable_get(param[2].data.d_drawable); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; gr = g_rand_new (); /* * Make sure the drawable type is appropriate. */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id) || gimp_drawable_is_indexed (drawable->drawable_id)) { gimp_tile_cache_ntiles (2 * drawable->ntile_cols); switch (run_mode) { /* * If we're running interactively, pop up the dialog box. */ case GIMP_RUN_INTERACTIVE: gimp_get_data (PLUG_IN_PROC[rndm_type - 1], &pivals); if (! randomize_dialog (drawable)) /* return on Cancel */ return; break; /* * If we're not interactive (probably scripting), we * get the parameters from the param[] array, since * we don't use the dialog box. Make sure they all * parameters have legitimate values. */ case GIMP_RUN_NONINTERACTIVE: if (nparams != 7) { status = GIMP_PDB_CALLING_ERROR; } else { pivals.rndm_pct = (gdouble) param[3].data.d_float; pivals.rndm_rcount = (gdouble) param[4].data.d_float; pivals.randomize = (gboolean) param[5].data.d_int32; pivals.seed = (gint) param[6].data.d_int32; if (pivals.randomize) pivals.seed = g_random_int (); if ((rndm_type != RNDM_PICK && rndm_type != RNDM_SLUR && rndm_type != RNDM_HURL) || (pivals.rndm_pct < 1.0 || pivals.rndm_pct > 100.0) || (pivals.rndm_rcount < 1.0 || pivals.rndm_rcount > 100.0)) { status = GIMP_PDB_CALLING_ERROR; } } break; /* * If we're running with the last set of values, get those values. */ case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC[rndm_type - 1], &pivals); if (pivals.randomize) pivals.seed = g_random_int (); break; /* * Hopefully we never get here! */ default: break; } if (status == GIMP_PDB_SUCCESS) { gimp_progress_init_printf ("%s", gettext (RNDM_NAME[rndm_type - 1])); /* * Initialize the g_rand() function seed */ g_rand_set_seed (gr, pivals.seed); randomize (drawable, NULL); /* * If we ran interactively (even repeating) update the display. */ if (run_mode != GIMP_RUN_NONINTERACTIVE) { gimp_displays_flush (); } /* * If we use the dialog popup, set the data for future use. */ if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_set_data (PLUG_IN_PROC[rndm_type - 1], &pivals, sizeof (RandomizeVals)); } } } else { /* * If we got the wrong drawable type, we need to complain. */ status = GIMP_PDB_EXECUTION_ERROR; } /* * DONE! * Set the status where GIMP can see it, and let go * of the drawable. */ g_rand_free (gr); values[0].data.d_status = status; gimp_drawable_detach(drawable); }