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 gimp_posterize_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpPosterizeTool *posterize_tool = GIMP_POSTERIZE_TOOL (tool); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable; drawable = gimp_image_get_active_drawable (image); if (! drawable) return FALSE; if (gimp_drawable_is_indexed (drawable)) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Posterize does not operate on indexed layers.")); return FALSE; } gimp_config_reset (GIMP_CONFIG (posterize_tool->config)); if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error)) { return FALSE; } gtk_adjustment_set_value (posterize_tool->levels_data, posterize_tool->config->levels); gimp_image_map_tool_preview (GIMP_IMAGE_MAP_TOOL (posterize_tool)); return TRUE; }
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; int final_drawable = gimp_image_merge_visible_layers(out->image_id, GIMP_CLIP_TO_IMAGE); // "file_jpeg_save" doesn't support indexed images if (gimp_drawable_is_indexed(final_drawable)) { 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, final_drawable, 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_perspective_clone_start (GimpPaintCore *paint_core, GimpDrawable *drawable, GimpPaintOptions *paint_options, GimpCoords *coords, GError **error) { GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core); if (! GIMP_PAINT_CORE_CLASS (parent_class)->start (paint_core, drawable, paint_options, coords, error)) { return FALSE; } if (! source_core->set_source && gimp_drawable_is_indexed (drawable)) { g_set_error (error, 0, 0, _("Perspective Clone does not operate on indexed layers.")); return FALSE; } return TRUE; }
/* 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 n_params, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint32 drawable_id; gint32 image_id; INIT_I18N (); gegl_init (NULL, NULL); *nreturn_vals = 1; *return_vals = values; run_mode = param[0].data.d_int32; if (run_mode == GIMP_RUN_NONINTERACTIVE) { if (n_params != 3) { status = GIMP_PDB_CALLING_ERROR; } } if (status == GIMP_PDB_SUCCESS) { /* Get the specified drawable */ image_id = param[1].data.d_int32; drawable_id = param[2].data.d_int32; /* Make sure that the drawable is gray or RGB or indexed */ if (gimp_drawable_is_rgb (drawable_id) || gimp_drawable_is_gray (drawable_id) || gimp_drawable_is_indexed (drawable_id)) { gimp_progress_init (_("Zealous cropping")); do_zcrop (drawable_id, image_id); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); } else { status = GIMP_PDB_EXECUTION_ERROR; } } values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; gegl_exit (); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[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 webx_indexed_target_changed (WebxIndexedTarget *indexed) { gtk_widget_set_sensitive (GTK_WIDGET (indexed->remove_unused_w), TRUE); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->reuse_pal_w))) { if (!gimp_drawable_is_indexed (global_drawable_ID)) { /* no user palette */ gtk_widget_set_sensitive (indexed->reuse_pal_w, FALSE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (indexed->make_pal_w), TRUE); } else { gtk_widget_set_sensitive (indexed->reuse_pal_w, TRUE); gtk_widget_set_sensitive (indexed->remove_unused_w, FALSE); indexed->palette_type = GIMP_REUSE_PALETTE; } } if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->make_pal_w))) { indexed->palette_type = GIMP_MAKE_PALETTE; gtk_widget_set_sensitive (indexed->num_colors_w, TRUE); gtk_widget_set_sensitive (indexed->remove_unused_w, FALSE); } else { gtk_widget_set_sensitive (indexed->num_colors_w, FALSE); } if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->web_pal_w))) { indexed->palette_type = GIMP_WEB_PALETTE; } if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->bw_pal_w))) { indexed->palette_type = GIMP_MONO_PALETTE; } gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (indexed->dither_type_w), &indexed->dither_type); indexed->num_colors = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (indexed->num_colors_w)); indexed->remove_unused = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->remove_unused_w)); indexed->alpha_dither = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->alpha_dither_w)); webx_target_changed (WEBX_TARGET (indexed)); }
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; }
/* ---------------------------- * p_selectionConstraintFunc * ---------------------------- * */ static gint p_selectionConstraintFunc (gint32 image_id, gint32 drawable_id, gpointer data) { if (image_id < 0) return FALSE; /* dont accept layers from indexed images */ if (gimp_drawable_is_indexed (drawable_id)) return FALSE; return TRUE; } /* end p_selectionConstraintFunc */
void gimp_drawable_curves_spline (GimpDrawable *drawable, GimpProgress *progress, gint32 channel, const guint8 *points, gint n_points) { GimpCurvesConfig *config; GimpCurve *curve; gint i; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (! gimp_drawable_is_indexed (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (channel >= GIMP_HISTOGRAM_VALUE && channel <= GIMP_HISTOGRAM_ALPHA); if (channel == GIMP_HISTOGRAM_ALPHA) g_return_if_fail (gimp_drawable_has_alpha (drawable)); if (gimp_drawable_is_gray (drawable)) g_return_if_fail (channel == GIMP_HISTOGRAM_VALUE || channel == GIMP_HISTOGRAM_ALPHA); config = g_object_new (GIMP_TYPE_CURVES_CONFIG, NULL); curve = config->curve[channel]; gimp_data_freeze (GIMP_DATA (curve)); /* FIXME: create a curves object with the right number of points */ /* unset the last point */ gimp_curve_set_point (curve, curve->n_points - 1, -1, -1); n_points = MIN (n_points / 2, curve->n_points); for (i = 0; i < n_points; i++) gimp_curve_set_point (curve, i, (gdouble) points[i * 2] / 255.0, (gdouble) points[i * 2 + 1] / 255.0); gimp_data_thaw (GIMP_DATA (curve)); gimp_drawable_curves (drawable, progress, config); g_object_unref (config); }
void gimp_drawable_brightness_contrast (GimpDrawable *drawable, GimpProgress *progress, gint brightness, gint contrast) { GimpBrightnessContrastConfig *config; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (! gimp_drawable_is_indexed (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); config = g_object_new (GIMP_TYPE_BRIGHTNESS_CONTRAST_CONFIG, "brightness", brightness / 127.0, "contrast", contrast / 127.0, NULL); if (gimp_use_gegl (gimp_item_get_image (GIMP_ITEM (drawable))->gimp)) { GeglNode *node; node = g_object_new (GEGL_TYPE_NODE, "operation", "gimp:brightness-contrast", "config", config, NULL); gimp_drawable_apply_operation (drawable, progress, C_("undo-type", "Brightness-Contrast") , node, TRUE); g_object_unref (node); } else { GimpLut *lut; lut = brightness_contrast_lut_new (config->brightness / 2.0, config->contrast, gimp_drawable_bytes (drawable)); gimp_drawable_process_lut (drawable, progress, C_("undo-type", "Brightness-Contrast"), lut); gimp_lut_free (lut); } g_object_unref (config); }
static gboolean gimp_blend_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpBlendOptions *options = GIMP_BLEND_TOOL_GET_OPTIONS (tool); if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error)) { return FALSE; } if (gimp_drawable_is_indexed (drawable)) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Blend does not operate on indexed layers.")); return FALSE; } if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Cannot modify the pixels of layer groups.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer's pixels are locked.")); return FALSE; } if (! gimp_context_get_gradient (GIMP_CONTEXT (options))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("No gradient available for use with this tool.")); return FALSE; } return TRUE; }
void gimp_drawable_curves_explicit (GimpDrawable *drawable, GimpProgress *progress, gint32 channel, const guint8 *points, gint n_points) { GimpCurvesConfig *config; GimpCurve *curve; gint i; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (! gimp_drawable_is_indexed (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (channel >= GIMP_HISTOGRAM_VALUE && channel <= GIMP_HISTOGRAM_ALPHA); if (channel == GIMP_HISTOGRAM_ALPHA) g_return_if_fail (gimp_drawable_has_alpha (drawable)); if (gimp_drawable_is_gray (drawable)) g_return_if_fail (channel == GIMP_HISTOGRAM_VALUE || channel == GIMP_HISTOGRAM_ALPHA); config = g_object_new (GIMP_TYPE_CURVES_CONFIG, NULL); curve = config->curve[channel]; gimp_data_freeze (GIMP_DATA (curve)); gimp_curve_set_curve_type (curve, GIMP_CURVE_FREE); for (i = 0; i < 256; i++) gimp_curve_set_curve (curve, (gdouble) i / 255.0, (gdouble) points[i] / 255.0); gimp_data_thaw (GIMP_DATA (curve)); gimp_drawable_curves (drawable, progress, config); g_object_unref (config); }
void gimp_drawable_posterize (GimpDrawable *drawable, GimpProgress *progress, gint levels) { GimpPosterizeConfig *config; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (! gimp_drawable_is_indexed (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); config = g_object_new (GIMP_TYPE_POSTERIZE_CONFIG, "levels", levels, NULL); if (gimp_use_gegl (gimp_item_get_image (GIMP_ITEM (drawable))->gimp)) { GeglNode *node; node = g_object_new (GEGL_TYPE_NODE, "operation", "gimp:posterize", NULL); gegl_node_set (node, "config", config, NULL); gimp_drawable_apply_operation (drawable, progress, _("Posterize"), node, TRUE); g_object_unref (node); } else { GimpLut *lut; lut = posterize_lut_new (config->levels, gimp_drawable_bytes (drawable)); gimp_drawable_process_lut (drawable, progress, _("Posterize"), lut); gimp_lut_free (lut); } g_object_unref (config); }
SioxState * gimp_drawable_foreground_extract_siox_init (GimpDrawable *drawable, gint x, gint y, gint width, gint height) { GeglBuffer *buffer; const guchar *colormap = NULL; gboolean intersect; gint offset_x; gint offset_y; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); if (gimp_drawable_is_indexed (drawable)) colormap = gimp_drawable_get_colormap (drawable); gimp_item_get_offset (GIMP_ITEM (drawable), &offset_x, &offset_y); intersect = gimp_rectangle_intersect (offset_x, offset_y, gimp_item_get_width (GIMP_ITEM (drawable)), gimp_item_get_height (GIMP_ITEM (drawable)), x, y, width, height, &x, &y, &width, &height); /* FIXME: * Clear the mask outside the rectangle that we are working on? */ if (! intersect) return NULL; buffer = gimp_drawable_get_buffer (drawable); return siox_init (gimp_gegl_buffer_get_tiles (buffer), colormap, offset_x, offset_y, x, y, width, height); }
static void gimp_blend_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE; if (gimp_drawable_is_indexed (drawable) || gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) || gimp_item_is_content_locked (GIMP_ITEM (drawable))) { modifier = GIMP_CURSOR_MODIFIER_BAD; } gimp_tool_control_set_cursor_modifier (tool->control, modifier); GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); }
static void check_drawables (void) { if (mapvals.bump_mapped) { if (mapvals.bumpmap_id != -1 && gimp_item_get_image (mapvals.bumpmap_id) == -1) { mapvals.bump_mapped = FALSE; mapvals.bumpmap_id = -1; } if (gimp_drawable_is_indexed (mapvals.bumpmap_id) || (gimp_drawable_width (mapvals.drawable_id) != gimp_drawable_width (mapvals.bumpmap_id)) || (gimp_drawable_height (mapvals.drawable_id) != gimp_drawable_height (mapvals.bumpmap_id))) { mapvals.bump_mapped = FALSE; mapvals.bumpmap_id = -1; } } if (mapvals.env_mapped) { if (mapvals.envmap_id != -1 && gimp_item_get_image (mapvals.envmap_id) == -1) { mapvals.env_mapped = FALSE; mapvals.envmap_id = -1; } if (gimp_drawable_is_gray (mapvals.envmap_id) || gimp_drawable_has_alpha (mapvals.envmap_id)) { mapvals.env_mapped = FALSE; mapvals.envmap_id = -1; } } }
static gboolean gimp_levels_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpLevelsTool *l_tool = GIMP_LEVELS_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_indexed (drawable)) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Levels does not operate on indexed layers.")); return FALSE; } gimp_config_reset (GIMP_CONFIG (l_tool->config)); if (l_tool->active_picker) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l_tool->active_picker), FALSE); if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error)) { return FALSE; } gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (l_tool->channel_menu), levels_menu_sensitivity, drawable, NULL); gimp_drawable_calculate_histogram (drawable, l_tool->histogram); gimp_histogram_view_set_histogram (GIMP_HISTOGRAM_VIEW (l_tool->histogram_view), l_tool->histogram); return TRUE; }
void gimp_channel_select_by_index (GimpChannel *channel, GimpDrawable *drawable, gint index, GimpChannelOps op, gboolean feather, gdouble feather_radius_x, gdouble feather_radius_y) { GeglBuffer *add_on; gint add_on_x = 0; gint add_on_y = 0; g_return_if_fail (GIMP_IS_CHANNEL (channel)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_drawable_is_indexed (drawable)); add_on = gegl_buffer_new (GEGL_RECTANGLE (0, 0, gimp_item_get_width (GIMP_ITEM (drawable)), gimp_item_get_height (GIMP_ITEM (drawable))), babl_format ("Y float")); gimp_gegl_index_to_mask (gimp_drawable_get_buffer (drawable), NULL, gimp_drawable_get_format_without_alpha (drawable), add_on, NULL, index); gimp_item_get_offset (GIMP_ITEM (drawable), &add_on_x, &add_on_y); gimp_channel_select_buffer (channel, C_("undo-type", "Select by Indexed Color"), add_on, add_on_x, add_on_y, op, feather, feather_radius_x, feather_radius_y); g_object_unref (add_on); }
static gboolean gimp_curves_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpCurvesTool *c_tool = GIMP_CURVES_TOOL (tool); GimpDrawable *drawable = gimp_image_get_active_drawable (display->image); GimpHistogram *histogram; if (! drawable) return FALSE; if (gimp_drawable_is_indexed (drawable)) { g_set_error (error, 0, 0, _("Curves does not operate on indexed layers.")); return FALSE; } gimp_config_reset (GIMP_CONFIG (c_tool->config)); GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error); /* always pick colors */ gimp_color_tool_enable (GIMP_COLOR_TOOL (tool), GIMP_COLOR_TOOL_GET_OPTIONS (tool)); gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (c_tool->channel_menu), curves_menu_sensitivity, drawable, NULL); histogram = gimp_histogram_new (); gimp_drawable_calculate_histogram (drawable, histogram); gimp_histogram_view_set_background (GIMP_HISTOGRAM_VIEW (c_tool->graph), histogram); gimp_histogram_unref (histogram); return TRUE; }
static gboolean gimp_brightness_contrast_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpBrightnessContrastTool *bc_tool = GIMP_BRIGHTNESS_CONTRAST_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_indexed (drawable)) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Brightness-Contrast does not operate " "on indexed layers.")); return FALSE; } gimp_config_reset (GIMP_CONFIG (bc_tool->config)); return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error); }
static gboolean gimp_gegl_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpGeglTool *g_tool = GIMP_GEGL_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_indexed (drawable)) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("GEGL operations do not operate on indexed layers.")); return FALSE; } if (g_tool->config) gimp_config_reset (GIMP_CONFIG (g_tool->config)); return GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error); }
static gboolean apply_color(color_settings settings, image_output out) { gboolean success = TRUE; int default_drawable = out->drawable_ids[0]; if (settings->brightness != 0 || settings->contrast != 0) { // brightness or contrast have been modified, apply the manipulation if (!gimp_drawable_is_rgb(default_drawable)) { gimp_image_convert_rgb(out->image_id); } int i; for (i = 0; i < out->drawable_count; i++) { success = gimp_brightness_contrast( out->drawable_ids[i], settings->brightness, settings->contrast ); } } if (settings->grayscale && !gimp_drawable_is_gray(default_drawable)) { // do grayscale conversion success = gimp_image_convert_grayscale(out->image_id); } if (settings->levels_auto) { // do levels correction int i; for (i = 0; i < out->drawable_count; i++) { success = gimp_levels_stretch(out->drawable_ids[i]); } } if (settings->curve_file != NULL && !gimp_drawable_is_indexed(default_drawable)) { // apply curve if (!colorcurve_init) { // read from the curve file only the first time success = parse_curve_file( settings->curve_file, &colorcurve_num_points_v, &colorcurve_ctr_points_v, &colorcurve_num_points_r, &colorcurve_ctr_points_r, &colorcurve_num_points_g, &colorcurve_ctr_points_g, &colorcurve_num_points_b, &colorcurve_ctr_points_b, &colorcurve_num_points_a, &colorcurve_ctr_points_a ); colorcurve_init = TRUE; } else success = TRUE; if (success) { int i; for (i = 0; i < out->drawable_count; i++) { if (colorcurve_num_points_v >= 4 && colorcurve_num_points_v <= 34) { success = gimp_curves_spline(out->drawable_ids[i], GIMP_HISTOGRAM_VALUE, colorcurve_num_points_v, colorcurve_ctr_points_v); } if (colorcurve_num_points_r >= 4 && colorcurve_num_points_r <= 34) { success = gimp_curves_spline(out->drawable_ids[i], GIMP_HISTOGRAM_RED, colorcurve_num_points_r, colorcurve_ctr_points_r); } if (colorcurve_num_points_g >= 4 && colorcurve_num_points_g <= 34) { success = gimp_curves_spline(out->drawable_ids[i], GIMP_HISTOGRAM_GREEN, colorcurve_num_points_g, colorcurve_ctr_points_g); } if (colorcurve_num_points_b >= 4 && colorcurve_num_points_b <= 34) { success = gimp_curves_spline(out->drawable_ids[i], GIMP_HISTOGRAM_BLUE, colorcurve_num_points_b, colorcurve_ctr_points_b); } if (colorcurve_num_points_a >= 4 && colorcurve_num_points_a <= 34) { success = gimp_curves_spline(out->drawable_ids[i], GIMP_HISTOGRAM_ALPHA, colorcurve_num_points_a, colorcurve_ctr_points_a); } } } } return success; }
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); }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; gint32 image_ID; GimpRunMode run_mode; gint pwidth; gint pheight; GimpPDBStatusType status = GIMP_PDB_SUCCESS; gint sel_width; gint sel_height; 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 specified drawable */ drawable = gimp_drawable_get (param[2].data.d_drawable); image_ID = param[1].data.d_image; gimp_drawable_mask_bounds (drawable->drawable_id, &sel_x1, &sel_y1, &sel_x2, &sel_y2); sel_width = sel_x2 - sel_x1; sel_height = sel_y2 - sel_y1; /* Calculate preview size */ if (sel_width > sel_height) { pwidth = MIN (sel_width, PREVIEW_SIZE); pheight = sel_height * pwidth / sel_width; } else { pheight = MIN (sel_height, PREVIEW_SIZE); pwidth = sel_width * pheight / sel_height; } preview_width = MAX (pwidth, 2); preview_height = MAX (pheight, 2); /* See how we will run */ switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data ("plug_in_fractalexplorer", &wvals); /* Get information from the dialog */ if (!explorer_dialog ()) return; break; case GIMP_RUN_NONINTERACTIVE: /* Make sure all the arguments are present */ if (nparams != 22) { status = GIMP_PDB_CALLING_ERROR; } else { wvals.fractaltype = param[3].data.d_int8; wvals.xmin = param[4].data.d_float; wvals.xmax = param[5].data.d_float; wvals.ymin = param[6].data.d_float; wvals.ymax = param[7].data.d_float; wvals.iter = param[8].data.d_float; wvals.cx = param[9].data.d_float; wvals.cy = param[10].data.d_float; wvals.colormode = param[11].data.d_int8; wvals.redstretch = param[12].data.d_float; wvals.greenstretch = param[13].data.d_float; wvals.bluestretch = param[14].data.d_float; wvals.redmode = param[15].data.d_int8; wvals.greenmode = param[16].data.d_int8; wvals.bluemode = param[17].data.d_int8; wvals.redinvert = param[18].data.d_int8; wvals.greeninvert = param[19].data.d_int8; wvals.blueinvert = param[20].data.d_int8; wvals.ncolors = CLAMP (param[21].data.d_int32, 2, MAXNCOLORS); } make_color_map(); break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data ("plug_in_fractalexplorer", &wvals); make_color_map (); break; default: break; } xmin = wvals.xmin; xmax = wvals.xmax; ymin = wvals.ymin; ymax = wvals.ymax; cx = wvals.cx; cy = wvals.cy; if (status == GIMP_PDB_SUCCESS) { /* Make sure that the drawable is not indexed */ if (! gimp_drawable_is_indexed (drawable->drawable_id)) { gimp_progress_init (_("Rendering fractal")); /* Set the tile cache size */ gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width() + 1)); /* Run! */ explorer (drawable); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush (); /* Store data */ if (run_mode == GIMP_RUN_INTERACTIVE) gimp_set_data ("plug_in_fractalexplorer", &wvals, sizeof (explorer_vals_t)); } else { status = GIMP_PDB_EXECUTION_ERROR; } } values[0].data.d_status = status; gimp_drawable_detach (drawable); }
static gboolean webx_pipeline_check_update (WebxPipeline *pipeline) { gint *layers; gint num_layers; gint i; g_return_val_if_fail (WEBX_IS_PIPELINE (pipeline), FALSE); if (pipeline->rgb_image != -1) { gimp_image_delete (pipeline->rgb_image); pipeline->rgb_image = -1; } if (pipeline->indexed_image != -1) { gimp_image_delete (pipeline->indexed_image); pipeline->indexed_image = -1; } if (pipeline->background) { g_object_unref (pipeline->background); pipeline->background = NULL; } pipeline->rgb_image = gimp_image_duplicate (pipeline->user_image); gimp_image_undo_disable (pipeline->rgb_image); pipeline->rgb_layer = gimp_image_merge_visible_layers (pipeline->rgb_image, GIMP_CLIP_TO_IMAGE); /* make sure there is only one layer, where all visible layers were merged */ layers = gimp_image_get_layers (pipeline->rgb_image, &num_layers); for (i = 0; i < num_layers; i++) { if (layers[i] != pipeline->rgb_layer) gimp_image_remove_layer (pipeline->rgb_image, layers[i]); } g_free (layers); /* we don't want layer to be smaller than image */ gimp_layer_resize_to_image_size (pipeline->rgb_layer); gimp_image_scale (pipeline->rgb_image, pipeline->resize_width, pipeline->resize_height); webx_pipeline_create_background (pipeline); pipeline->crop_offsx *= pipeline->crop_scale_x; pipeline->crop_offsy *= pipeline->crop_scale_y; pipeline->crop_width *= pipeline->crop_scale_x; pipeline->crop_height *= pipeline->crop_scale_y; pipeline->crop_scale_x = 1.0; pipeline->crop_scale_y = 1.0; webx_pipeline_crop_clip (pipeline); if (pipeline->crop_width != pipeline->resize_width || pipeline->crop_height != pipeline->resize_height ) { gimp_image_crop (pipeline->rgb_image, pipeline->crop_width, pipeline->crop_height, pipeline->crop_offsx, pipeline->crop_offsy); } if (gimp_drawable_is_indexed (pipeline->rgb_layer)) { pipeline->indexed_image = gimp_image_duplicate (pipeline->rgb_image); gimp_image_undo_disable (pipeline->indexed_image); pipeline->indexed_layer = gimp_image_merge_visible_layers (pipeline->indexed_image, GIMP_CLIP_TO_IMAGE); } else { pipeline->indexed_image = -1; pipeline->indexed_layer = -1; } if ( ! gimp_drawable_is_rgb (pipeline->rgb_layer)) gimp_image_convert_rgb (pipeline->rgb_image); return TRUE; }
static GimpLayer * gimp_image_merge_layers (GimpImage *image, GimpContainer *container, GSList *merge_list, GimpContext *context, GimpMergeType merge_type) { GList *list; GSList *reverse_list = NULL; GSList *layers; GimpLayer *merge_layer; GimpLayer *layer; GimpLayer *bottom_layer; GimpParasiteList *parasites; gint count; gint x1, y1, x2, y2; gint off_x, off_y; gint position; gchar *name; GimpLayer *parent; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); layer = NULL; x1 = y1 = 0; x2 = y2 = 0; bottom_layer = NULL; parent = gimp_layer_get_parent (merge_list->data); /* Get the layer extents */ count = 0; while (merge_list) { layer = merge_list->data; gimp_item_get_offset (GIMP_ITEM (layer), &off_x, &off_y); switch (merge_type) { case GIMP_EXPAND_AS_NECESSARY: case GIMP_CLIP_TO_IMAGE: if (! count) { x1 = off_x; y1 = off_y; x2 = off_x + gimp_item_get_width (GIMP_ITEM (layer)); y2 = off_y + gimp_item_get_height (GIMP_ITEM (layer)); } else { if (off_x < x1) x1 = off_x; if (off_y < y1) y1 = off_y; if ((off_x + gimp_item_get_width (GIMP_ITEM (layer))) > x2) x2 = (off_x + gimp_item_get_width (GIMP_ITEM (layer))); if ((off_y + gimp_item_get_height (GIMP_ITEM (layer))) > y2) y2 = (off_y + gimp_item_get_height (GIMP_ITEM (layer))); } if (merge_type == GIMP_CLIP_TO_IMAGE) { x1 = CLAMP (x1, 0, gimp_image_get_width (image)); y1 = CLAMP (y1, 0, gimp_image_get_height (image)); x2 = CLAMP (x2, 0, gimp_image_get_width (image)); y2 = CLAMP (y2, 0, gimp_image_get_height (image)); } break; case GIMP_CLIP_TO_BOTTOM_LAYER: if (merge_list->next == NULL) { x1 = off_x; y1 = off_y; x2 = off_x + gimp_item_get_width (GIMP_ITEM (layer)); y2 = off_y + gimp_item_get_height (GIMP_ITEM (layer)); } break; case GIMP_FLATTEN_IMAGE: if (merge_list->next == NULL) { x1 = 0; y1 = 0; x2 = gimp_image_get_width (image); y2 = gimp_image_get_height (image); } break; } count ++; reverse_list = g_slist_prepend (reverse_list, layer); merge_list = g_slist_next (merge_list); } if ((x2 - x1) == 0 || (y2 - y1) == 0) return NULL; /* Start a merge undo group. */ name = g_strdup (gimp_object_get_name (layer)); if (merge_type == GIMP_FLATTEN_IMAGE || (gimp_drawable_is_indexed (GIMP_DRAWABLE (layer)) && ! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))) { GeglColor *color; GimpRGB bg; merge_layer = gimp_layer_new (image, (x2 - x1), (y2 - y1), gimp_image_get_layer_format (image, FALSE), gimp_object_get_name (layer), GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE); if (! merge_layer) { g_warning ("%s: could not allocate merge layer.", G_STRFUNC); return NULL; } gimp_item_set_offset (GIMP_ITEM (merge_layer), x1, y1); /* get the background for compositing */ gimp_context_get_background (context, &bg); color = gimp_gegl_color_new (&bg); gegl_buffer_set_color (gimp_drawable_get_buffer (GIMP_DRAWABLE (merge_layer)), GEGL_RECTANGLE(0,0,x2-x1,y2-y1), color); g_object_unref (color); position = 0; } else { /* The final merged layer inherits the name of the bottom most layer * and the resulting layer has an alpha channel whether or not the * original did. Opacity is set to 100% and the MODE is set to normal. */ merge_layer = gimp_layer_new (image, (x2 - x1), (y2 - y1), gimp_drawable_get_format_with_alpha (GIMP_DRAWABLE (layer)), "merged layer", GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE); if (!merge_layer) { g_warning ("%s: could not allocate merge layer", G_STRFUNC); return NULL; } gimp_item_set_offset (GIMP_ITEM (merge_layer), x1, y1); /* clear the layer */ gegl_buffer_clear (gimp_drawable_get_buffer (GIMP_DRAWABLE (merge_layer)), NULL); /* Find the index in the layer list of the bottom layer--we need this * in order to add the final, merged layer to the layer list correctly */ layer = reverse_list->data; position = gimp_container_get_n_children (container) - gimp_container_get_child_index (container, GIMP_OBJECT (layer)); } bottom_layer = layer; /* Copy the tattoo and parasites of the bottom layer to the new layer */ gimp_item_set_tattoo (GIMP_ITEM (merge_layer), gimp_item_get_tattoo (GIMP_ITEM (bottom_layer))); parasites = gimp_item_get_parasites (GIMP_ITEM (bottom_layer)); parasites = gimp_parasite_list_copy (parasites); gimp_item_set_parasites (GIMP_ITEM (merge_layer), parasites); g_object_unref (parasites); for (layers = reverse_list; layers; layers = g_slist_next (layers)) { GeglBuffer *merge_buffer; GeglBuffer *layer_buffer; GimpApplicator *applicator; GimpLayerModeEffects mode; layer = layers->data; gimp_item_get_offset (GIMP_ITEM (layer), &off_x, &off_y); /* DISSOLVE_MODE is special since it is the only mode that does not * work on the projection with the lower layer, but only locally on * the layers alpha channel. */ mode = gimp_layer_get_mode (layer); if (layer == bottom_layer && mode != GIMP_DISSOLVE_MODE) mode = GIMP_NORMAL_MODE; merge_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (merge_layer)); layer_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)); applicator = gimp_applicator_new (NULL, gimp_drawable_get_linear (GIMP_DRAWABLE (layer)), FALSE, FALSE); if (gimp_layer_get_mask (layer) && gimp_layer_get_apply_mask (layer)) { GeglBuffer *mask_buffer; mask_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (layer->mask)); gimp_applicator_set_mask_buffer (applicator, mask_buffer); gimp_applicator_set_mask_offset (applicator, - (x1 - off_x), - (y1 - off_y)); } gimp_applicator_set_src_buffer (applicator, merge_buffer); gimp_applicator_set_dest_buffer (applicator, merge_buffer); gimp_applicator_set_apply_buffer (applicator, layer_buffer); gimp_applicator_set_apply_offset (applicator, - (x1 - off_x), - (y1 - off_y)); gimp_applicator_set_mode (applicator, gimp_layer_get_opacity (layer), mode); gimp_applicator_blit (applicator, GEGL_RECTANGLE (0, 0, gegl_buffer_get_width (merge_buffer), gegl_buffer_get_height (merge_buffer))); g_object_unref (applicator); gimp_image_remove_layer (image, layer, TRUE, NULL); } g_slist_free (reverse_list); gimp_object_take_name (GIMP_OBJECT (merge_layer), name); gimp_item_set_visible (GIMP_ITEM (merge_layer), TRUE, FALSE); /* if the type is flatten, remove all the remaining layers */ if (merge_type == GIMP_FLATTEN_IMAGE) { list = gimp_image_get_layer_iter (image); while (list) { layer = list->data; list = g_list_next (list); gimp_image_remove_layer (image, layer, TRUE, NULL); } gimp_image_add_layer (image, merge_layer, parent, position, TRUE); } else { /* Add the layer to the image */ gimp_image_add_layer (image, merge_layer, parent, gimp_container_get_n_children (container) - position + 1, TRUE); } gimp_drawable_update (GIMP_DRAWABLE (merge_layer), 0, 0, gimp_item_get_width (GIMP_ITEM (merge_layer)), gimp_item_get_height (GIMP_ITEM (merge_layer))); return merge_layer; }
void gimp_projection_construct (GimpProjection *proj, gint x, gint y, gint w, gint h) { g_return_if_fail (GIMP_IS_PROJECTION (proj)); #if 0 GList *layers = gimp_projectable_get_layers (proj->projectable); if (layers && ! layers->next) /* a single layer */ { GimpLayer *layer = layers->data; GimpDrawable *drawable = GIMP_DRAWABLE (layer); GimpItem *item = GIMP_ITEM (layer); gint width, height; gint off_x, off_y; gimp_projectable_get_offset (proj->projectable, &proj_off_x, &proj_off_y); gimp_projectable_get_size (proj->projectable, &width, &height); gimp_item_get_offset (item, &off_x, &off_y); if (gimp_drawable_has_alpha (drawable) && gimp_item_get_visible (item) && gimp_item_get_width (item) == width && gimp_item_get_height (item) == height && ! gimp_drawable_is_indexed (layer) && gimp_layer_get_opacity (layer) == GIMP_OPACITY_OPAQUE && off_x == 0 && off_y == 0 && proj_offset_x == 0 && proj_offset_y == 0) { PixelRegion srcPR, destPR; g_printerr ("cow-projection!"); pixel_region_init (&srcPR, gimp_drawable_get_tiles (layer), x, y, w,h, FALSE); pixel_region_init (&destPR, gimp_pickable_get_tiles (GIMP_PICKABLE (proj)), x, y, w,h, TRUE); copy_region (&srcPR, &destPR); proj->construct_flag = TRUE; gimp_projection_construct_legacy (proj, FALSE, x, y, w, h); return; } } #endif /* First, determine if the projection image needs to be * initialized--this is the case when there are no visible * layers that cover the entire canvas--either because layers * are offset or only a floating selection is visible */ gimp_projection_initialize (proj, x, y, w, h); /* call functions which process the list of layers and * the list of channels */ if (proj->use_gegl) { gimp_projection_construct_gegl (proj, x, y, w, h); } else { proj->construct_flag = FALSE; gimp_projection_construct_legacy (proj, TRUE, x, y, w, h); } }
static void gimp_convolve_motion (GimpPaintCore *paint_core, GimpDrawable *drawable, GimpPaintOptions *paint_options) { GimpConvolve *convolve = GIMP_CONVOLVE (paint_core); GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_core); GimpConvolveOptions *options = GIMP_CONVOLVE_OPTIONS (paint_options); GimpContext *context = GIMP_CONTEXT (paint_options); GimpImage *image; TempBuf *area; PixelRegion srcPR; PixelRegion destPR; PixelRegion tempPR; guchar *buffer; gdouble opacity; gdouble rate; gint bytes; image = gimp_item_get_image (GIMP_ITEM (drawable)); if (gimp_drawable_is_indexed (drawable)) return; opacity = gimp_paint_options_get_fade (paint_options, image, paint_core->pixel_dist); if (opacity == 0.0) return; area = gimp_paint_core_get_paint_area (paint_core, drawable, paint_options); if (! area) return; rate = options->rate; rate *= gimp_paint_options_get_dynamic_rate (paint_options, &paint_core->cur_coords); gimp_convolve_calculate_matrix (convolve, options->type, brush_core->brush->mask->width / 2, brush_core->brush->mask->height / 2, rate); /* configure the source pixel region */ pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable), area->x, area->y, area->width, area->height, FALSE); if (gimp_drawable_has_alpha (drawable)) { bytes = srcPR.bytes; buffer = g_malloc (area->height * bytes * area->width); pixel_region_init_data (&tempPR, buffer, bytes, bytes * area->width, 0, 0, area->width, area->height); copy_region (&srcPR, &tempPR); } else { /* note: this particular approach needlessly convolves the totally- opaque alpha channel. A faster approach would be to keep tempPR the same number of bytes as srcPR, and extend the paint_core_replace_canvas API to handle non-alpha images. */ bytes = srcPR.bytes + 1; buffer = g_malloc (area->height * bytes * area->width); pixel_region_init_data (&tempPR, buffer, bytes, bytes * area->width, 0, 0, area->width, area->height); add_alpha_region (&srcPR, &tempPR); } /* Convolve the region */ pixel_region_init_data (&tempPR, buffer, bytes, bytes * area->width, 0, 0, area->width, area->height); pixel_region_init_temp_buf (&destPR, area, 0, 0, area->width, area->height); convolve_region (&tempPR, &destPR, convolve->matrix, 3, convolve->matrix_divisor, GIMP_NORMAL_CONVOL, TRUE); g_free (buffer); gimp_brush_core_replace_canvas (brush_core, drawable, MIN (opacity, GIMP_OPACITY_OPAQUE), gimp_context_get_opacity (context), gimp_paint_options_get_brush_mode (paint_options), 1.0, GIMP_PAINT_INCREMENTAL); }