void gimp_paint_core_validate_undo_tiles (GimpPaintCore *core, GimpDrawable *drawable, gint x, gint y, gint w, gint h) { gint i, j; g_return_if_fail (GIMP_IS_PAINT_CORE (core)); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (core->undo_tiles != NULL); for (i = y; i < (y + h); i += (TILE_HEIGHT - (i % TILE_HEIGHT))) { for (j = x; j < (x + w); j += (TILE_WIDTH - (j % TILE_WIDTH))) { Tile *dest_tile = tile_manager_get_tile (core->undo_tiles, j, i, FALSE, FALSE); if (! tile_is_valid (dest_tile)) { Tile *src_tile = tile_manager_get_tile (gimp_drawable_get_tiles (drawable), j, i, TRUE, FALSE); tile_manager_map_tile (core->undo_tiles, j, i, src_tile); tile_release (src_tile, FALSE); } } } }
void gimp_drawable_apply_operation_to_tiles (GimpDrawable *drawable, GimpProgress *progress, const gchar *undo_desc, GeglNode *operation, gboolean linear, TileManager *new_tiles) { GeglRectangle rect; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); g_return_if_fail (undo_desc != NULL); g_return_if_fail (GEGL_IS_NODE (operation)); g_return_if_fail (new_tiles != NULL); rect.x = 0; rect.y = 0; rect.width = tile_manager_width (new_tiles); rect.height = tile_manager_height (new_tiles); gimp_drawable_apply_operation_private (drawable, progress, undo_desc, operation, linear, new_tiles, &rect); if (progress) gimp_progress_end (progress); }
void gimp_edit_clear (GimpImage *image, GimpDrawable *drawable, GimpContext *context) { GimpFillOptions *options; g_return_if_fail (GIMP_IS_IMAGE (image)); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (GIMP_IS_CONTEXT (context)); options = gimp_fill_options_new (context->gimp); if (gimp_drawable_has_alpha (drawable)) gimp_fill_options_set_by_fill_type (options, context, GIMP_FILL_TRANSPARENT, NULL); else gimp_fill_options_set_by_fill_type (options, context, GIMP_FILL_BACKGROUND, NULL); gimp_edit_fill (image, drawable, options, C_("undo-type", "Clear")); g_object_unref (options); }
gboolean gimp_edit_clear (GimpImage *image, GimpDrawable *drawable, GimpContext *context) { GimpRGB background; GimpLayerModeEffects paint_mode; g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE); g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE); gimp_context_get_background (context, &background); if (gimp_drawable_has_alpha (drawable)) paint_mode = GIMP_ERASE_MODE; else paint_mode = GIMP_NORMAL_MODE; return gimp_edit_fill_full (image, drawable, &background, NULL, GIMP_OPACITY_OPAQUE, paint_mode, C_("undo-type", "Clear")); }
void gimp_edit_fill (GimpImage *image, GimpDrawable *drawable, GimpFillOptions *options, const gchar *undo_desc) { GeglBuffer *buffer; gint x, y, width, height; g_return_if_fail (GIMP_IS_IMAGE (image)); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (GIMP_IS_FILL_OPTIONS (options)); if (! gimp_item_mask_intersect (GIMP_ITEM (drawable), &x, &y, &width, &height)) return; /* nothing to do, but the fill succeeded */ buffer = gimp_fill_options_create_buffer (options, drawable, GEGL_RECTANGLE (0, 0, width, height)); if (! undo_desc) undo_desc = gimp_fill_options_get_undo_desc (options); gimp_drawable_apply_buffer (drawable, buffer, GEGL_RECTANGLE (0, 0, width, height), TRUE, undo_desc, gimp_context_get_opacity (GIMP_CONTEXT (options)), gimp_context_get_paint_mode (GIMP_CONTEXT (options)), NULL, x, y); g_object_unref (buffer); gimp_drawable_update (drawable, x, y, width, height); }
GeglBuffer * gimp_paint_core_get_paint_buffer (GimpPaintCore *core, GimpDrawable *drawable, GimpPaintOptions *paint_options, const GimpCoords *coords, gint *paint_buffer_x, gint *paint_buffer_y) { GeglBuffer *paint_buffer; g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), NULL); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), NULL); g_return_val_if_fail (coords != NULL, NULL); g_return_val_if_fail (paint_buffer_x != NULL, NULL); g_return_val_if_fail (paint_buffer_y != NULL, NULL); paint_buffer = GIMP_PAINT_CORE_GET_CLASS (core)->get_paint_buffer (core, drawable, paint_options, coords, paint_buffer_x, paint_buffer_y); core->paint_buffer_x = *paint_buffer_x; core->paint_buffer_y = *paint_buffer_y; return paint_buffer; }
void gimp_drawable_foreground_extract (GimpDrawable *drawable, GimpForegroundExtractMode mode, GimpDrawable *mask, GimpProgress *progress) { SioxState *state; const gdouble sensitivity[3] = { SIOX_DEFAULT_SENSITIVITY_L, SIOX_DEFAULT_SENSITIVITY_A, SIOX_DEFAULT_SENSITIVITY_B }; g_return_if_fail (GIMP_IS_DRAWABLE (mask)); g_return_if_fail (mode == GIMP_FOREGROUND_EXTRACT_SIOX); state = gimp_drawable_foreground_extract_siox_init (drawable, 0, 0, gimp_item_get_width (GIMP_ITEM (mask)), gimp_item_get_height (GIMP_ITEM (mask))); if (state) { gimp_drawable_foreground_extract_siox (mask, state, SIOX_REFINEMENT_RECALCULATE, SIOX_DEFAULT_SMOOTHNESS, sensitivity, FALSE, progress); gimp_drawable_foreground_extract_siox_done (state); } }
GimpTransformResize gimp_drawable_transform_get_effective_clip (GimpDrawable *drawable, GeglBuffer *orig_buffer, GimpTransformResize clip_result) { g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), clip_result); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), clip_result); g_return_val_if_fail (orig_buffer == NULL || GEGL_IS_BUFFER (orig_buffer), clip_result); /* Always clip unfloated buffers since they must keep their size */ if (GIMP_IS_CHANNEL (drawable)) { if (orig_buffer) { if (! babl_format_has_alpha (gegl_buffer_get_format (orig_buffer))) clip_result = GIMP_TRANSFORM_RESIZE_CLIP; } else { GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable)); if (gimp_channel_is_empty (gimp_image_get_mask (image))) clip_result = GIMP_TRANSFORM_RESIZE_CLIP; } } return clip_result; }
GimpCanvasItem * gimp_draw_tool_add_transform_preview (GimpDrawTool *draw_tool, GimpDrawable *drawable, const GimpMatrix3 *transform, gdouble x1, gdouble y1, gdouble x2, gdouble y2, gboolean perspective, gdouble opacity) { GimpCanvasItem *item; g_return_val_if_fail (GIMP_IS_DRAW_TOOL (draw_tool), NULL); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (transform != NULL, NULL); item = gimp_canvas_transform_preview_new (gimp_display_get_shell (draw_tool->display), drawable, transform, x1, y1, x2, y2, perspective, opacity); gimp_draw_tool_add_preview (draw_tool, item); g_object_unref (item); return item; }
gboolean gimp_plug_in_cleanup_remove_shadow (GimpPlugIn *plug_in, GimpDrawable *drawable) { GimpPlugInProcFrame *proc_frame; GimpPlugInCleanupItem *cleanup; g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), FALSE); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); proc_frame = gimp_plug_in_get_proc_frame (plug_in); cleanup = gimp_plug_in_cleanup_item_get (proc_frame, GIMP_ITEM (drawable)); if (! cleanup) return FALSE; if (! cleanup->shadow_buffer) return FALSE; proc_frame->item_cleanups = g_list_remove (proc_frame->item_cleanups, cleanup); gimp_plug_in_cleanup_item_free (cleanup); return TRUE; }
GimpUndo * gimp_image_undo_push_drawable (GimpImage *image, const gchar *undo_desc, GimpDrawable *drawable, GeglBuffer *buffer, gint x, gint y) { GimpItem *item; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL); item = GIMP_ITEM (drawable); g_return_val_if_fail (gimp_item_is_attached (item), NULL); return gimp_image_undo_push (image, GIMP_TYPE_DRAWABLE_UNDO, GIMP_UNDO_DRAWABLE, undo_desc, GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE, "item", item, "buffer", buffer, "x", x, "y", y, NULL); }
/** * gimp_symmetry_set_origin: * @sym: the #GimpSymmetry * @drawable: the #GimpDrawable where painting will happen * @origin: new base coordinates. * * Set the symmetry to new origin coordinates and drawable. **/ void gimp_symmetry_set_origin (GimpSymmetry *sym, GimpDrawable *drawable, GimpCoords *origin) { g_return_if_fail (GIMP_IS_SYMMETRY (sym)); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_get_image (GIMP_ITEM (drawable)) == sym->image); if (drawable != sym->drawable) { if (sym->drawable) g_object_unref (sym->drawable); sym->drawable = g_object_ref (drawable); } if (origin != sym->origin) { g_free (sym->origin); sym->origin = g_memdup (origin, sizeof (GimpCoords)); } g_list_free_full (sym->strokes, g_free); sym->strokes = NULL; GIMP_SYMMETRY_GET_CLASS (sym)->update_strokes (sym, drawable, origin); }
const gchar * gimp_edit_named_copy (GimpImage *image, const gchar *name, GimpDrawable *drawable, GimpContext *context, GError **error) { GimpBuffer *buffer; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (name != NULL, NULL); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); buffer = gimp_edit_extract (image, GIMP_PICKABLE (drawable), context, FALSE, error); if (buffer) { gimp_object_set_name (GIMP_OBJECT (buffer), name); gimp_container_add (image->gimp->named_buffers, GIMP_OBJECT (buffer)); g_object_unref (buffer); return gimp_object_get_name (buffer); } return NULL; }
void gimp_drawable_stroke_boundary (GimpDrawable *drawable, GimpStrokeOptions *options, const GimpBoundSeg *bound_segs, gint n_bound_segs, gint offset_x, gint offset_y, gboolean push_undo) { GimpScanConvert *scan_convert; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (GIMP_IS_STROKE_OPTIONS (options)); g_return_if_fail (bound_segs == NULL || n_bound_segs != 0); g_return_if_fail (gimp_fill_options_get_style (GIMP_FILL_OPTIONS (options)) != GIMP_FILL_STYLE_PATTERN || gimp_context_get_pattern (GIMP_CONTEXT (options)) != NULL); scan_convert = gimp_scan_convert_new_from_boundary (bound_segs, n_bound_segs, offset_x, offset_y); if (scan_convert) { gimp_drawable_stroke_scan_convert (drawable, options, scan_convert, push_undo); gimp_scan_convert_free (scan_convert); } }
const GimpBuffer * gimp_edit_copy (GimpImage *image, GimpDrawable *drawable, GimpContext *context, GError **error) { GimpBuffer *buffer; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); buffer = gimp_edit_extract (image, GIMP_PICKABLE (drawable), context, FALSE, error); if (buffer) { gimp_set_global_buffer (image->gimp, buffer); g_object_unref (buffer); return image->gimp->global_buffer; } return NULL; }
static void gimp_drawable_mod_undo_constructed (GObject *object) { GimpDrawableModUndo *drawable_mod_undo = GIMP_DRAWABLE_MOD_UNDO (object); GimpItem *item; GimpDrawable *drawable; G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_DRAWABLE (GIMP_ITEM_UNDO (object)->item)); item = GIMP_ITEM_UNDO (object)->item; drawable = GIMP_DRAWABLE (item); if (drawable_mod_undo->copy_buffer) { drawable_mod_undo->buffer = gegl_buffer_dup (gimp_drawable_get_buffer (drawable)); } else { drawable_mod_undo->buffer = g_object_ref (gimp_drawable_get_buffer (drawable)); } gimp_item_get_offset (item, &drawable_mod_undo->offset_x, &drawable_mod_undo->offset_y); }
const Babl * gimp_drawable_get_preview_format (GimpDrawable *drawable) { gboolean alpha; gboolean linear; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); alpha = gimp_drawable_has_alpha (drawable); linear = gimp_drawable_get_linear (drawable); switch (gimp_drawable_get_base_type (drawable)) { case GIMP_GRAY: return gimp_babl_format (GIMP_GRAY, gimp_babl_precision (GIMP_COMPONENT_TYPE_U8, linear), alpha); case GIMP_RGB: return gimp_babl_format (GIMP_RGB, gimp_babl_precision (GIMP_COMPONENT_TYPE_U8, linear), alpha); case GIMP_INDEXED: if (alpha) return babl_format ("R'G'B'A u8"); else return babl_format ("R'G'B' u8"); } g_return_val_if_reached (NULL); }
gboolean gimp_plug_in_cleanup_add_shadow (GimpPlugIn *plug_in, GimpDrawable *drawable) { GimpPlugInProcFrame *proc_frame; GimpPlugInCleanupItem *cleanup; g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), FALSE); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); proc_frame = gimp_plug_in_get_proc_frame (plug_in); cleanup = gimp_plug_in_cleanup_item_get (proc_frame, GIMP_ITEM (drawable)); if (! cleanup) { cleanup = gimp_plug_in_cleanup_item_new (GIMP_ITEM (drawable)); proc_frame->item_cleanups = g_list_prepend (proc_frame->item_cleanups, cleanup); } cleanup->shadow_tiles = TRUE; return TRUE; }
gboolean gimp_drawable_bucket_fill (GimpDrawable *drawable, GimpContext *context, GimpBucketFillMode fill_mode, gint paint_mode, gdouble opacity, gboolean do_seed_fill, gboolean fill_transparent, GimpSelectCriterion fill_criterion, gdouble threshold, gboolean sample_merged, gdouble x, gdouble y, GError **error) { GimpRGB color; GimpPattern *pattern = NULL; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE); g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); if (fill_mode == GIMP_FG_BUCKET_FILL) { gimp_context_get_foreground (context, &color); } else if (fill_mode == GIMP_BG_BUCKET_FILL) { gimp_context_get_background (context, &color); } else if (fill_mode == GIMP_PATTERN_BUCKET_FILL) { pattern = gimp_context_get_pattern (context); if (! pattern) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("No patterns available for this operation.")); return FALSE; } } else { g_warning ("%s: invalid fill_mode passed", G_STRFUNC); return FALSE; } gimp_drawable_bucket_fill_full (drawable, fill_mode, paint_mode, opacity, do_seed_fill, fill_transparent, fill_criterion, threshold, sample_merged, x, y, &color, pattern); return TRUE; }
void gimp_drawable_stroke_vectors (GimpDrawable *drawable, GimpStrokeOptions *options, GimpVectors *vectors) { GimpScanConvert *scan_convert; GimpStroke *stroke; gint num_coords = 0; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (GIMP_IS_STROKE_OPTIONS (options)); g_return_if_fail (GIMP_IS_VECTORS (vectors)); scan_convert = gimp_scan_convert_new (); /* For each Stroke in the vector, interpolate it, and add it to the * ScanConvert */ for (stroke = gimp_vectors_stroke_get_next (vectors, NULL); stroke; stroke = gimp_vectors_stroke_get_next (vectors, stroke)) { GArray *coords; gboolean closed; /* Get the interpolated version of this stroke, and add it to our * scanconvert. */ coords = gimp_stroke_interpolate (stroke, 0.2, &closed); if (coords && coords->len) { GimpVector2 *points = g_new0 (GimpVector2, coords->len); gint i; for (i = 0; i < coords->len; i++) { points[i].x = g_array_index (coords, GimpCoords, i).x; points[i].y = g_array_index (coords, GimpCoords, i).y; num_coords++; } gimp_scan_convert_add_polyline (scan_convert, coords->len, points, closed); g_free (points); } if (coords) g_array_free (coords, TRUE); } if (num_coords > 0) gimp_drawable_stroke_scan_convert (drawable, options, scan_convert); gimp_scan_convert_free (scan_convert); }
GimpDrawable * gimp_drawable_transform_paste (GimpDrawable *drawable, GeglBuffer *buffer, GimpColorProfile *buffer_profile, gint offset_x, gint offset_y, gboolean new_layer) { GimpImage *image; GimpLayer *layer = NULL; const gchar *undo_desc = NULL; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL); g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (buffer_profile), NULL); image = gimp_item_get_image (GIMP_ITEM (drawable)); if (GIMP_IS_LAYER (drawable)) undo_desc = C_("undo-type", "Transform Layer"); else if (GIMP_IS_CHANNEL (drawable)) undo_desc = C_("undo-type", "Transform Channel"); else return NULL; gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, undo_desc); if (new_layer) { layer = gimp_layer_new_from_gegl_buffer (buffer, image, gimp_drawable_get_format_with_alpha (drawable), _("Transformation"), GIMP_OPACITY_OPAQUE, gimp_image_get_default_new_layer_mode (image), buffer_profile); gimp_item_set_offset (GIMP_ITEM (layer), offset_x, offset_y); floating_sel_attach (layer, drawable); drawable = GIMP_DRAWABLE (layer); } else { gimp_drawable_set_buffer_full (drawable, TRUE, NULL, buffer, offset_x, offset_y, TRUE); } gimp_image_undo_group_end (image); return drawable; }
gboolean gimp_image_pick_color (GimpImage *image, GimpDrawable *drawable, gint x, gint y, gboolean sample_merged, gboolean sample_average, gdouble average_radius, const Babl **sample_format, gpointer pixel, GimpRGB *color) { GimpPickable *pickable; g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); g_return_val_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (drawable == NULL || gimp_item_get_image (GIMP_ITEM (drawable)) == image, FALSE); if (! sample_merged) { if (! drawable) drawable = gimp_image_get_active_drawable (image); if (! drawable) return FALSE; } if (sample_merged) { pickable = GIMP_PICKABLE (image); } else { gint off_x, off_y; gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); x -= off_x; y -= off_y; pickable = GIMP_PICKABLE (drawable); } /* Do *not* call gimp_pickable_flush() here because it's too expensive * to call it unconditionally each time e.g. the cursor view is updated. * Instead, call gimp_pickable_flush() in the callers if needed. */ if (sample_format) *sample_format = gimp_pickable_get_format (pickable); return gimp_pickable_pick_color (pickable, x, y, sample_average, average_radius, pixel, color); }
static void gimp_drawable_undo_constructed (GObject *object) { GimpDrawableUndo *drawable_undo = GIMP_DRAWABLE_UNDO (object); G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_DRAWABLE (GIMP_ITEM_UNDO (object)->item)); g_assert (drawable_undo->buffer != NULL); }
GimpTempBuf * gimp_drawable_get_sub_preview (GimpDrawable *drawable, gint src_x, gint src_y, gint src_width, gint src_height, gint dest_width, gint dest_height) { GimpItem *item; GimpImage *image; GeglBuffer *buffer; GimpTempBuf *preview; gdouble scale; gint scaled_x; gint scaled_y; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (src_x >= 0, NULL); g_return_val_if_fail (src_y >= 0, NULL); g_return_val_if_fail (src_width > 0, NULL); g_return_val_if_fail (src_height > 0, NULL); g_return_val_if_fail (dest_width > 0, NULL); g_return_val_if_fail (dest_height > 0, NULL); item = GIMP_ITEM (drawable); g_return_val_if_fail ((src_x + src_width) <= gimp_item_get_width (item), NULL); g_return_val_if_fail ((src_y + src_height) <= gimp_item_get_height (item), NULL); image = gimp_item_get_image (item); if (! image->gimp->config->layer_previews) return NULL; buffer = gimp_drawable_get_buffer (drawable); preview = gimp_temp_buf_new (dest_width, dest_height, gimp_drawable_get_preview_format (drawable)); scale = MIN ((gdouble) dest_width / (gdouble) src_width, (gdouble) dest_height / (gdouble) src_height); scaled_x = RINT ((gdouble) src_x * scale); scaled_y = RINT ((gdouble) src_y * scale); gegl_buffer_get (buffer, GEGL_RECTANGLE (scaled_x, scaled_y, dest_width, dest_height), scale, gimp_temp_buf_get_format (preview), gimp_temp_buf_get_data (preview), GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP); return preview; }
void gimp_paint_core_finish (GimpPaintCore *core, GimpDrawable *drawable, gboolean push_undo) { GimpImage *image; g_return_if_fail (GIMP_IS_PAINT_CORE (core)); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); if (core->stroke_buffer) { g_array_free (core->stroke_buffer, TRUE); core->stroke_buffer = NULL; } image = gimp_item_get_image (GIMP_ITEM (drawable)); /* Determine if any part of the image has been altered-- * if nothing has, then just return... */ if ((core->x2 == core->x1) || (core->y2 == core->y1)) { gimp_viewable_preview_thaw (GIMP_VIEWABLE (drawable)); return; } if (push_undo) { gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_PAINT, core->undo_desc); GIMP_PAINT_CORE_GET_CLASS (core)->push_undo (core, image, NULL); gimp_drawable_push_undo (drawable, NULL, core->x1, core->y1, core->x2 - core->x1, core->y2 - core->y1, core->undo_tiles, TRUE); gimp_image_undo_group_end (image); } tile_manager_unref (core->undo_tiles); core->undo_tiles = NULL; if (core->saved_proj_tiles) { tile_manager_unref (core->saved_proj_tiles); core->saved_proj_tiles = NULL; } gimp_viewable_preview_thaw (GIMP_VIEWABLE (drawable)); }
gboolean gimp_edit_fill (GimpImage *image, GimpDrawable *drawable, GimpContext *context, GimpFillType fill_type, gdouble opacity, GimpLayerModeEffects paint_mode, GError **error) { GimpRGB color; GimpPattern *pattern; const gchar *undo_desc = NULL; g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE); g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); if (! gimp_get_fill_params (context, fill_type, &color, &pattern, error)) return FALSE; switch (fill_type) { case GIMP_FILL_FOREGROUND: undo_desc = C_("undo-type", "Fill with Foreground Color"); break; case GIMP_FILL_BACKGROUND: undo_desc = C_("undo-type", "Fill with Background Color"); break; case GIMP_FILL_WHITE: undo_desc = C_("undo-type", "Fill with White"); break; case GIMP_FILL_TRANSPARENT: undo_desc = C_("undo-type", "Fill with Transparency"); break; case GIMP_FILL_PATTERN: undo_desc = C_("undo-type", "Fill with Pattern"); break; } return gimp_edit_fill_full (image, drawable, &color, pattern, opacity, paint_mode, undo_desc); }
GimpObject * gimp_edit_cut (GimpImage *image, GimpDrawable *drawable, GimpContext *context, GError **error) { g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); if (GIMP_IS_LAYER (drawable) && gimp_channel_is_empty (gimp_image_get_mask (image))) { GimpImage *clip_image; clip_image = gimp_image_new_from_drawable (image->gimp, drawable); gimp_container_remove (image->gimp->images, GIMP_OBJECT (clip_image)); gimp_set_clipboard_image (image->gimp, clip_image); g_object_unref (clip_image); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_CUT, C_("undo-type", "Cut Layer")); gimp_image_remove_layer (image, GIMP_LAYER (drawable), TRUE, NULL); gimp_image_undo_group_end (image); return GIMP_OBJECT (gimp_get_clipboard_image (image->gimp)); } else { GimpBuffer *buffer; buffer = gimp_edit_extract (image, GIMP_PICKABLE (drawable), context, TRUE, error); if (buffer) { gimp_set_clipboard_buffer (image->gimp, buffer); g_object_unref (buffer); return GIMP_OBJECT (gimp_get_clipboard_buffer (image->gimp)); } } return NULL; }
void gimp_channel_select_fuzzy (GimpChannel *channel, GimpDrawable *drawable, gboolean sample_merged, gint x, gint y, gfloat threshold, gboolean select_transparent, GimpSelectCriterion select_criterion, gboolean diagonal_neighbors, GimpChannelOps op, gboolean antialias, gboolean feather, gdouble feather_radius_x, gdouble feather_radius_y) { GimpPickable *pickable; 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)); if (sample_merged) pickable = GIMP_PICKABLE (gimp_item_get_image (GIMP_ITEM (drawable))); else pickable = GIMP_PICKABLE (drawable); add_on = gimp_pickable_contiguous_region_by_seed (pickable, antialias, threshold, select_transparent, select_criterion, diagonal_neighbors, x, y); if (! sample_merged) gimp_item_get_offset (GIMP_ITEM (drawable), &add_on_x, &add_on_y); gimp_channel_select_buffer (channel, C_("undo-type", "Fuzzy Select"), add_on, add_on_x, add_on_y, op, feather, feather_radius_x, feather_radius_y); g_object_unref (add_on); }
void gimp_drawable_foreground_extract_siox (GimpDrawable *mask, SioxState *state, SioxRefinementType refinement, gint smoothness, const gdouble sensitivity[3], gboolean multiblob, GimpProgress *progress) { GeglBuffer *buffer; gint x1, y1; gint x2, y2; g_return_if_fail (GIMP_IS_DRAWABLE (mask)); g_return_if_fail (babl_format_get_bytes_per_pixel (gimp_drawable_get_format (mask)) == 1); g_return_if_fail (state != NULL); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); if (progress) gimp_progress_start (progress, _("Foreground Extraction"), FALSE); if (GIMP_IS_CHANNEL (mask)) { gimp_channel_bounds (GIMP_CHANNEL (mask), &x1, &y1, &x2, &y2); } else { x1 = 0; y1 = 0; x2 = gimp_item_get_width (GIMP_ITEM (mask)); y2 = gimp_item_get_height (GIMP_ITEM (mask)); } buffer = gimp_drawable_get_buffer (mask); siox_foreground_extract (state, refinement, gimp_gegl_buffer_get_tiles (buffer), x1, y1, x2, y2, smoothness, sensitivity, multiblob, (SioxProgressFunc) gimp_progress_set_value, progress); if (progress) gimp_progress_end (progress); gimp_drawable_update (mask, x1, y1, x2, y2); }
void gimp_drawable_bucket_fill (GimpDrawable *drawable, GimpFillOptions *options, gboolean fill_transparent, GimpSelectCriterion fill_criterion, gdouble threshold, gboolean sample_merged, gboolean diagonal_neighbors, gdouble seed_x, gdouble seed_y) { GimpImage *image; GeglBuffer *buffer; gdouble mask_x; gdouble mask_y; gint width, height; g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (GIMP_IS_FILL_OPTIONS (options)); image = gimp_item_get_image (GIMP_ITEM (drawable)); gimp_set_busy (image->gimp); buffer = gimp_drawable_get_bucket_fill_buffer (drawable, options, fill_transparent, fill_criterion, threshold, sample_merged, diagonal_neighbors, seed_x, seed_y, NULL, &mask_x, &mask_y, &width, &height); if (buffer) { /* Apply it to the image */ gimp_drawable_apply_buffer (drawable, buffer, GEGL_RECTANGLE (0, 0, width, height), TRUE, C_("undo-type", "Bucket Fill"), gimp_context_get_opacity (GIMP_CONTEXT (options)), gimp_context_get_paint_mode (GIMP_CONTEXT (options)), GIMP_LAYER_COLOR_SPACE_AUTO, GIMP_LAYER_COLOR_SPACE_AUTO, gimp_layer_mode_get_paint_composite_mode ( gimp_context_get_paint_mode (GIMP_CONTEXT (options))), NULL, (gint) mask_x, mask_y); g_object_unref (buffer); gimp_drawable_update (drawable, mask_x, mask_y, width, height); } gimp_unset_busy (image->gimp); }