static void gimp_group_layer_undo_constructed (GObject *object) { GimpGroupLayerUndo *group_layer_undo = GIMP_GROUP_LAYER_UNDO (object); GimpGroupLayer *group; G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_GROUP_LAYER (GIMP_ITEM_UNDO (object)->item)); group = GIMP_GROUP_LAYER (GIMP_ITEM_UNDO (object)->item); switch (GIMP_UNDO (object)->undo_type) { case GIMP_UNDO_GROUP_LAYER_SUSPEND: case GIMP_UNDO_GROUP_LAYER_RESUME: break; case GIMP_UNDO_GROUP_LAYER_CONVERT: group_layer_undo->prev_type = gimp_drawable_get_base_type (GIMP_DRAWABLE (group)); group_layer_undo->prev_precision = gimp_drawable_get_precision (GIMP_DRAWABLE (group)); break; default: g_assert_not_reached (); } }
void bfm_onionskin_rm (GDisplay *disp) { if (!bfm_check (disp) || !disp->bfm->onionskin_b) return; if(disp->bfm->cfm) { /*cfm_onionskin_rm (disp->bfm->cfm);*/ } else if(disp->bfm->sfm && disp->bfm->onionskin_b) { disp->bfm->sfm->old_offset_x = GIMP_DRAWABLE (disp->bfm->bg->active_layer)->offset_x; disp->bfm->sfm->old_offset_y = GIMP_DRAWABLE (disp->bfm->bg->active_layer)->offset_y; disp->bfm->sfm->old_ex = disp->bfm->sfm->ex; disp->bfm->sfm->old_ey = disp->bfm->sfm->ey; disp->bfm->sfm->old_opacity = disp->bfm->fg->active_layer->opacity; disp->bfm->fg->active_layer->opacity = 1; gimage_remove_layer (disp->bfm->fg, (disp->bfm->bg->active_layer)); GIMP_DRAWABLE (disp->bfm->bg->active_layer)->offset_x = 0; GIMP_DRAWABLE (disp->bfm->bg->active_layer)->offset_y = 0; GIMP_DRAWABLE(disp->bfm->bg->active_layer)->gimage_ID = disp->bfm->bg->ID; disp->bfm->onionskin_b = 0; sfm_onionskin_rm (disp); } }
void gimp_channel_combine_buffer (GimpChannel *mask, GeglBuffer *add_on_buffer, GimpChannelOps op, gint off_x, gint off_y) { GeglBuffer *buffer; gint x, y, w, h; g_return_if_fail (GIMP_IS_CHANNEL (mask)); g_return_if_fail (GEGL_IS_BUFFER (add_on_buffer)); buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)); if (! gimp_gegl_mask_combine_buffer (buffer, add_on_buffer, op, off_x, off_y)) return; gimp_rectangle_intersect (off_x, off_y, gegl_buffer_get_width (add_on_buffer), gegl_buffer_get_height (add_on_buffer), 0, 0, gimp_item_get_width (GIMP_ITEM (mask)), gimp_item_get_height (GIMP_ITEM (mask)), &x, &y, &w, &h); mask->bounds_known = FALSE; gimp_drawable_update (GIMP_DRAWABLE (mask), x, y, w, h); }
void gimp_channel_combine_mask (GimpChannel *mask, GimpChannel *add_on, GimpChannelOps op, gint off_x, gint off_y) { PixelRegion srcPR, destPR; gint x, y, w, h; g_return_if_fail (GIMP_IS_CHANNEL (mask)); g_return_if_fail (GIMP_IS_CHANNEL (add_on)); if (! gimp_rectangle_intersect (off_x, off_y, gimp_item_get_width (GIMP_ITEM (add_on)), gimp_item_get_height (GIMP_ITEM (add_on)), 0, 0, gimp_item_get_width (GIMP_ITEM (mask)), gimp_item_get_height (GIMP_ITEM (mask)), &x, &y, &w, &h)) return; pixel_region_init (&srcPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (add_on)), x - off_x, y - off_y, w, h, FALSE); pixel_region_init (&destPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (mask)), x, y, w, h, TRUE); switch (op) { case GIMP_CHANNEL_OP_ADD: case GIMP_CHANNEL_OP_REPLACE: pixel_regions_process_parallel ((PixelProcessorFunc) gimp_channel_combine_sub_region_add, NULL, 2, &srcPR, &destPR); break; case GIMP_CHANNEL_OP_SUBTRACT: pixel_regions_process_parallel ((PixelProcessorFunc) gimp_channel_combine_sub_region_sub, NULL, 2, &srcPR, &destPR); break; case GIMP_CHANNEL_OP_INTERSECT: pixel_regions_process_parallel ((PixelProcessorFunc) gimp_channel_combine_sub_region_intersect, NULL, 2, &srcPR, &destPR); break; default: g_warning ("%s: unknown operation type", G_STRFUNC); break; } mask->bounds_known = FALSE; gimp_drawable_update (GIMP_DRAWABLE (mask), x, y, w, h); }
static void gimp_group_layer_undo_pop (GimpUndo *undo, GimpUndoMode undo_mode, GimpUndoAccumulator *accum) { GimpGroupLayerUndo *group_layer_undo = GIMP_GROUP_LAYER_UNDO (undo); GimpGroupLayer *group; group = GIMP_GROUP_LAYER (GIMP_ITEM_UNDO (undo)->item); GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum); switch (undo->undo_type) { case GIMP_UNDO_GROUP_LAYER_SUSPEND: case GIMP_UNDO_GROUP_LAYER_RESUME: if ((undo_mode == GIMP_UNDO_MODE_UNDO && undo->undo_type == GIMP_UNDO_GROUP_LAYER_SUSPEND) || (undo_mode == GIMP_UNDO_MODE_REDO && undo->undo_type == GIMP_UNDO_GROUP_LAYER_RESUME)) { /* resume group layer auto-resizing */ gimp_group_layer_resume_resize (group, FALSE); } else { /* suspend group layer auto-resizing */ gimp_group_layer_suspend_resize (group, FALSE); } break; case GIMP_UNDO_GROUP_LAYER_CONVERT: { GimpImageBaseType type; GimpPrecision precision; type = gimp_drawable_get_base_type (GIMP_DRAWABLE (group)); precision = gimp_drawable_get_precision (GIMP_DRAWABLE (group)); gimp_drawable_convert_type (GIMP_DRAWABLE (group), gimp_item_get_image (GIMP_ITEM (group)), group_layer_undo->prev_type, group_layer_undo->prev_precision, 0, 0, FALSE, FALSE, NULL); group_layer_undo->prev_type = type; group_layer_undo->prev_precision = precision; } break; default: g_assert_not_reached (); } }
static CombinationMode gimp_image_merge_layers_get_operation (GimpLayer *dest, GimpLayer *src) { GimpImageType type = gimp_drawable_type (GIMP_DRAWABLE (dest)); gint bytes = gimp_drawable_bytes (GIMP_DRAWABLE (src)); return gimp_image_get_combination_mode (type, bytes); }
void floating_sel_to_layer (GimpLayer *layer) { GimpItem *item; GimpImage *image; g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); item = GIMP_ITEM (layer); if (! (image = gimp_item_get_image (item))) return; /* Check if the floating layer belongs to a channel... */ if (GIMP_IS_CHANNEL (layer->fs.drawable)) { gimp_message (image->gimp, NULL, GIMP_MESSAGE_WARNING, _("Cannot create a new layer from the floating selection " "because it belongs to a layer mask or channel.")); return; } gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_TO_LAYER, _("Floating Selection to Layer")); /* restore the contents of the drawable */ floating_sel_restore (layer, item->offset_x, item->offset_y, item->width, item->height); gimp_image_undo_push_fs_to_layer (image, NULL, layer); /* clear the selection */ gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (layer)); /* Set pointers */ layer->fs.drawable = NULL; image->floating_sel = NULL; gimp_item_set_visible (GIMP_ITEM (layer), TRUE, TRUE); gimp_layer_set_lock_alpha (layer, FALSE, TRUE); gimp_image_undo_group_end (image); gimp_object_name_changed (GIMP_OBJECT (layer)); gimp_drawable_update (GIMP_DRAWABLE (layer), 0, 0, GIMP_ITEM (layer)->width, GIMP_ITEM (layer)->height); gimp_image_floating_selection_changed (image); }
void gimp_channel_combine_rect (GimpChannel *mask, GimpChannelOps op, gint x, gint y, gint w, gint h) { GeglBuffer *buffer; g_return_if_fail (GIMP_IS_CHANNEL (mask)); buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)); if (! gimp_gegl_mask_combine_rect (buffer, op, x, y, w, h)) return; gimp_rectangle_intersect (x, y, w, h, 0, 0, gimp_item_get_width (GIMP_ITEM (mask)), gimp_item_get_height (GIMP_ITEM (mask)), &x, &y, &w, &h); /* Determine new boundary */ if (mask->bounds_known && (op == GIMP_CHANNEL_OP_ADD) && ! mask->empty) { if (x < mask->x1) mask->x1 = x; if (y < mask->y1) mask->y1 = y; if ((x + w) > mask->x2) mask->x2 = (x + w); if ((y + h) > mask->y2) mask->y2 = (y + h); } else if (op == GIMP_CHANNEL_OP_REPLACE || mask->empty) { mask->empty = FALSE; mask->x1 = x; mask->y1 = y; mask->x2 = x + w; mask->y2 = y + h; } else { mask->bounds_known = FALSE; } mask->x1 = CLAMP (mask->x1, 0, gimp_item_get_width (GIMP_ITEM (mask))); mask->y1 = CLAMP (mask->y1, 0, gimp_item_get_height (GIMP_ITEM (mask))); mask->x2 = CLAMP (mask->x2, 0, gimp_item_get_width (GIMP_ITEM (mask))); mask->y2 = CLAMP (mask->y2, 0, gimp_item_get_height (GIMP_ITEM (mask))); gimp_drawable_update (GIMP_DRAWABLE (mask), x, y, w, h); }
static void gimp_text_layer_render_layout (GimpTextLayer *layer, GimpTextLayout *layout) { GimpDrawable *drawable = GIMP_DRAWABLE (layer); GimpItem *item = GIMP_ITEM (layer); GeglBuffer *buffer; cairo_t *cr; cairo_surface_t *surface; gint width; gint height; g_return_if_fail (gimp_drawable_has_alpha (drawable)); width = gimp_item_get_width (item); height = gimp_item_get_height (item); surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height); cr = cairo_create (surface); gimp_text_layout_render (layout, cr, layer->text->base_dir, FALSE); cairo_destroy (cr); cairo_surface_flush (surface); buffer = gimp_cairo_surface_create_buffer (surface); gegl_buffer_copy (buffer, NULL, gimp_drawable_get_buffer (drawable), NULL); g_object_unref (buffer); cairo_surface_destroy (surface); gimp_drawable_update (drawable, 0, 0, width, height); }
static void gimp_drawable_mod_undo_pop (GimpUndo *undo, GimpUndoMode undo_mode, GimpUndoAccumulator *accum) { GimpDrawableModUndo *drawable_mod_undo = GIMP_DRAWABLE_MOD_UNDO (undo); GimpDrawable *drawable = GIMP_DRAWABLE (GIMP_ITEM_UNDO (undo)->item); GeglBuffer *buffer; gint offset_x; gint offset_y; GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum); buffer = drawable_mod_undo->buffer; offset_x = drawable_mod_undo->offset_x; offset_y = drawable_mod_undo->offset_y; drawable_mod_undo->buffer = g_object_ref (gimp_drawable_get_buffer (drawable)); gimp_item_get_offset (GIMP_ITEM (drawable), &drawable_mod_undo->offset_x, &drawable_mod_undo->offset_y); gimp_drawable_set_buffer_full (drawable, FALSE, NULL, buffer, offset_x, offset_y); g_object_unref (buffer); }
void drawable_lock_position_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpDrawable *drawable; gboolean locked; return_if_no_drawable (image, drawable, data); locked = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)); if (GIMP_IS_LAYER_MASK (drawable)) drawable = GIMP_DRAWABLE (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable))); if (locked != gimp_item_get_lock_position (GIMP_ITEM (drawable))) { GimpUndo *undo; gboolean push_undo = TRUE; undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO, GIMP_UNDO_ITEM_LOCK_POSITION); if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (drawable)) push_undo = FALSE; gimp_item_set_lock_position (GIMP_ITEM (drawable), locked, push_undo); gimp_image_flush (image); } }
void gimp_layer_mask_set_show (GimpLayerMask *layer_mask, gboolean show, gboolean push_undo) { g_return_if_fail (GIMP_IS_LAYER_MASK (layer_mask)); if (layer_mask->show_mask != show) { GimpImage *image = GIMP_ITEM (layer_mask)->image; if (push_undo) gimp_image_undo_push_layer_mask_show (image, _("Show Layer Mask"), layer_mask); layer_mask->show_mask = show ? TRUE : FALSE; if (layer_mask->layer) { GimpDrawable *drawable = GIMP_DRAWABLE (layer_mask->layer); gimp_drawable_update (drawable, 0, 0, gimp_item_width (GIMP_ITEM (drawable)), gimp_item_height (GIMP_ITEM (drawable))); } g_signal_emit (layer_mask, layer_mask_signals[SHOW_CHANGED], 0); } }
void gimp_layer_mask_set_apply (GimpLayerMask *layer_mask, gboolean apply, gboolean push_undo) { g_return_if_fail (GIMP_IS_LAYER_MASK (layer_mask)); if (layer_mask->apply_mask != apply) { GimpImage *image = GIMP_ITEM (layer_mask)->image; if (push_undo) gimp_image_undo_push_layer_mask_apply (image, _("Apply Layer Mask"), layer_mask); layer_mask->apply_mask = apply ? TRUE : FALSE; if (layer_mask->layer) { GimpDrawable *drawable = GIMP_DRAWABLE (layer_mask->layer); gimp_drawable_update (drawable, 0, 0, gimp_item_width (GIMP_ITEM (drawable)), gimp_item_height (GIMP_ITEM (drawable))); } g_signal_emit (layer_mask, layer_mask_signals[APPLY_CHANGED], 0); } }
GimpLayerMask * gimp_layer_mask_new (GimpImage *image, gint width, gint height, const gchar *name, const GimpRGB *color) { GimpLayerMask *layer_mask; layer_mask = g_object_new (GIMP_TYPE_LAYER_MASK, NULL); gimp_drawable_configure (GIMP_DRAWABLE (layer_mask), image, 0, 0, width, height, GIMP_GRAY_IMAGE, name); /* set the layer_mask color and opacity */ GIMP_CHANNEL (layer_mask)->color = *color; GIMP_CHANNEL (layer_mask)->show_masked = TRUE; /* selection mask variables */ GIMP_CHANNEL (layer_mask)->x2 = width; GIMP_CHANNEL (layer_mask)->y2 = height; return layer_mask; }
static void gimp_drawable_tree_view_new_dropped (GimpItemTreeView *view, gint x, gint y, const GimpRGB *color, GimpPattern *pattern) { GimpItem *item; gimp_image_undo_group_start (gimp_item_tree_view_get_image (view), GIMP_UNDO_GROUP_EDIT_PASTE, _("New Layer")); item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->new_item (gimp_item_tree_view_get_image (view)); if (item) { gimp_edit_fill_full (gimp_item_get_image (item), GIMP_DRAWABLE (item), color, pattern, GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE, pattern ? C_("undo-type", "Drop pattern to layer") : C_("undo-type", "Drop color to layer")); } gimp_image_undo_group_end (gimp_item_tree_view_get_image (view)); gimp_image_flush (gimp_item_tree_view_get_image (view)); }
/** @return fg drawable if `disp' has bfm, NULL else */ CanvasDrawable* bfm_get_fg_drawable (GDisplay *disp) { if (!bfm_check (disp)) return NULL; return GIMP_DRAWABLE (disp->bfm->fg->active_layer); } /* relies on fg!=NULL */
static GValueArray * selection_layer_alpha_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; GimpLayer *layer; layer = gimp_value_get_layer (&args->values[0], gimp); if (success) { GimpImage *image = gimp_item_get_image (GIMP_ITEM (layer)); gimp_channel_select_alpha (gimp_image_get_mask (image), GIMP_DRAWABLE (layer), GIMP_CHANNEL_OP_REPLACE, FALSE, 0.0, 0.0); } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
static void gimp_mask_undo_constructed (GObject *object) { GimpMaskUndo *mask_undo = GIMP_MASK_UNDO (object); GimpChannel *channel; GimpDrawable *drawable; gint x1, y1, x2, y2; if (G_OBJECT_CLASS (parent_class)->constructed) G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_CHANNEL (GIMP_ITEM_UNDO (object)->item)); channel = GIMP_CHANNEL (GIMP_ITEM_UNDO (object)->item); drawable = GIMP_DRAWABLE (channel); if (gimp_channel_bounds (channel, &x1, &y1, &x2, &y2)) { mask_undo->buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, x2 - x1, y2 - y1), gimp_drawable_get_format (drawable)); gegl_buffer_copy (gimp_drawable_get_buffer (drawable), GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1), mask_undo->buffer, GEGL_RECTANGLE (0, 0, 0, 0)); mask_undo->x = x1; mask_undo->y = y1; } mask_undo->format = gimp_drawable_get_format (drawable); }
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); }
static void gimp_image_duplicate_mask (GimpImage *image, GimpImage *new_image) { GimpDrawable *mask; GimpDrawable *new_mask; mask = GIMP_DRAWABLE (gimp_image_get_mask (image)); new_mask = GIMP_DRAWABLE (gimp_image_get_mask (new_image)); gegl_buffer_copy (gimp_drawable_get_buffer (mask), NULL, gimp_drawable_get_buffer (new_mask), NULL); GIMP_CHANNEL (new_mask)->bounds_known = FALSE; GIMP_CHANNEL (new_mask)->boundary_known = FALSE; }
static void gimp_layer_new_convert_buffer (GimpLayer *layer, GeglBuffer *src_buffer, GimpColorProfile *src_profile, GError **error) { GimpDrawable *drawable = GIMP_DRAWABLE (layer); GimpImage *image = gimp_item_get_image (GIMP_ITEM (layer)); GimpColorConfig *config = image->gimp->config->color_management; GeglBuffer *dest_buffer = gimp_drawable_get_buffer (drawable); GimpColorProfile *dest_profile; dest_profile = gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (layer)); if (! src_profile || ! dest_profile || /* FIXME: this is the wrong check, need something like file import * conversion config */ config->mode == GIMP_COLOR_MANAGEMENT_OFF) { gegl_buffer_copy (src_buffer, NULL, GEGL_ABYSS_NONE, dest_buffer, NULL); return; } gimp_gegl_convert_color_profile (src_buffer, NULL, src_profile, dest_buffer, NULL, dest_profile, GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL, TRUE, NULL); }
void gimp_channel_combine_ellipse_rect (GimpChannel *mask, GimpChannelOps op, gint x, gint y, gint w, gint h, gdouble rx, gdouble ry, gboolean antialias) { GimpChannelCombineData data; g_return_if_fail (GIMP_IS_CHANNEL (mask)); if (gimp_channel_combine_start (mask, op, GEGL_RECTANGLE (x, y, w, h), TRUE, FALSE, &data)) { GeglBuffer *buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)); gimp_gegl_mask_combine_ellipse_rect (buffer, op, x, y, w, h, rx, ry, antialias); } gimp_channel_combine_end (mask, &data); }
void gimp_channel_combine_buffer (GimpChannel *mask, GeglBuffer *add_on_buffer, GimpChannelOps op, gint off_x, gint off_y) { GimpChannelCombineData data; g_return_if_fail (GIMP_IS_CHANNEL (mask)); g_return_if_fail (GEGL_IS_BUFFER (add_on_buffer)); if (gimp_channel_combine_start (mask, op, GEGL_RECTANGLE ( off_x, off_y, gegl_buffer_get_width (add_on_buffer), gegl_buffer_get_height (add_on_buffer)), FALSE, FALSE, &data)) { GeglBuffer *buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)); gimp_gegl_mask_combine_buffer (buffer, add_on_buffer, op, off_x, off_y); } gimp_channel_combine_end (mask, &data); }
static void gimp_foreground_select_tool_stroke (GimpChannel *mask, FgSelectStroke *stroke) { GimpScanConvert *scan_convert = gimp_scan_convert_new (); if (stroke->num_points == 1) { GimpVector2 points[2]; points[0] = points[1] = stroke->points[0]; points[1].x += 0.01; points[1].y += 0.01; gimp_scan_convert_add_polyline (scan_convert, 2, points, FALSE); } else { gimp_scan_convert_add_polyline (scan_convert, stroke->num_points, stroke->points, FALSE); } gimp_scan_convert_stroke (scan_convert, stroke->width, GIMP_JOIN_ROUND, GIMP_CAP_ROUND, 10.0, 0.0, NULL); gimp_scan_convert_compose_value (scan_convert, gimp_drawable_get_tiles (GIMP_DRAWABLE (mask)), 0, 0, stroke->background ? 0 : 255); gimp_scan_convert_free (scan_convert); }
static GdkSegment * gimp_region_select_tool_calculate (GimpRegionSelectTool *region_sel, GimpDisplay *display, gint *num_segs) { GimpTool *tool = GIMP_TOOL (region_sel); GimpRegionSelectOptions *options = GIMP_REGION_SELECT_TOOL_GET_OPTIONS (tool); GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (display->shell); GimpDrawable *drawable; GdkSegment *segs; BoundSeg *bsegs; PixelRegion maskPR; drawable = gimp_image_get_active_drawable (display->image); gimp_display_shell_set_override_cursor (shell, GDK_WATCH); if (region_sel->region_mask) g_object_unref (region_sel->region_mask); region_sel->region_mask = GIMP_REGION_SELECT_TOOL_GET_CLASS (region_sel)->get_mask (region_sel, display); if (! region_sel->region_mask) { gimp_display_shell_unset_override_cursor (shell); *num_segs = 0; return NULL; } /* calculate and allocate a new segment array which represents the * boundary of the contiguous region */ pixel_region_init (&maskPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (region_sel->region_mask)), 0, 0, gimp_item_width (GIMP_ITEM (region_sel->region_mask)), gimp_item_height (GIMP_ITEM (region_sel->region_mask)), FALSE); bsegs = boundary_find (&maskPR, BOUNDARY_WITHIN_BOUNDS, 0, 0, gimp_item_width (GIMP_ITEM (region_sel->region_mask)), gimp_item_height (GIMP_ITEM (region_sel->region_mask)), BOUNDARY_HALF_WAY, num_segs); segs = g_new (GdkSegment, *num_segs); gimp_display_shell_transform_segments (shell, bsegs, segs, *num_segs, ! options->sample_merged); g_free (bsegs); gimp_display_shell_unset_override_cursor (shell); return segs; }
/** * gimp_projection_initialize: * @proj: A #GimpProjection. * @x: * @y: * @w: * @h: * * This function determines whether a visible layer with combine mode * Normal provides complete coverage over the specified area. If not, * the projection is initialized to transparent black. */ static void gimp_projection_initialize (GimpProjection *proj, gint x, gint y, gint w, gint h) { GList *list; gint proj_off_x; gint proj_off_y; gboolean coverage = FALSE; gimp_projectable_get_offset (proj->projectable, &proj_off_x, &proj_off_y); for (list = gimp_projectable_get_layers (proj->projectable); list; list = g_list_next (list)) { GimpLayer *layer = list->data; GimpDrawable *drawable = GIMP_DRAWABLE (layer); GimpItem *item = GIMP_ITEM (layer); gint off_x, off_y; gimp_item_get_offset (item, &off_x, &off_y); /* subtract the projectable's offsets because the list of * update areas is in tile-pyramid coordinates, but our * external API is always in terms of image coordinates. */ off_x -= proj_off_x; off_y -= proj_off_y; if (gimp_item_get_visible (item) && ! gimp_drawable_has_alpha (drawable) && ! gimp_layer_get_mask (layer) && gimp_layer_get_mode (layer) == GIMP_NORMAL_MODE && gimp_layer_get_opacity (layer) == GIMP_OPACITY_OPAQUE && off_x <= x && off_y <= y && (off_x + gimp_item_get_width (item)) >= (x + w) && (off_y + gimp_item_get_height (item)) >= (y + h)) { coverage = TRUE; break; } } if (! coverage) { PixelRegion region; pixel_region_init (®ion, gimp_pickable_get_tiles (GIMP_PICKABLE (proj)), x, y, w, h, TRUE); clear_region (®ion); } }
/** @return bg drawable if `disp' has bfm, NULL else */ CanvasDrawable* bfm_get_bg_drawable (GDisplay *disp) { if (!bfm_check (disp)) return NULL; if (!disp->bfm->bg) return NULL; return GIMP_DRAWABLE (disp->bfm->bg->active_layer); }
void floating_sel_anchor (GimpLayer *layer) { GimpImage *image; GimpDrawable *drawable; GimpFilter *filter = NULL; gint off_x, off_y; gint dr_off_x, dr_off_y; g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); /* Don't let gimp_image_remove_layer free the layer while we still need it */ g_object_ref (layer); image = gimp_item_get_image (GIMP_ITEM (layer)); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_ANCHOR, C_("undo-type", "Anchor Floating Selection")); drawable = gimp_layer_get_floating_sel_drawable (layer); gimp_item_get_offset (GIMP_ITEM (layer), &off_x, &off_y); gimp_item_get_offset (GIMP_ITEM (drawable), &dr_off_x, &dr_off_y); if (gimp_item_get_visible (GIMP_ITEM (layer)) && gimp_rectangle_intersect (off_x, off_y, gimp_item_get_width (GIMP_ITEM (layer)), gimp_item_get_height (GIMP_ITEM (layer)), dr_off_x, dr_off_y, gimp_item_get_width (GIMP_ITEM (drawable)), gimp_item_get_height (GIMP_ITEM (drawable)), NULL, NULL, NULL, NULL)) { filter = gimp_drawable_get_floating_sel_filter (drawable); g_object_ref (filter); } /* first remove the filter, then merge it, or we will get warnings * about already connected nodes */ gimp_image_remove_layer (image, layer, TRUE, NULL); if (filter) { gimp_drawable_merge_filter (drawable, filter, NULL, NULL); g_object_unref (filter); } gimp_image_undo_group_end (image); /* invalidate the boundaries */ gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (gimp_image_get_mask (image))); g_object_unref (layer); }
static void gimp_display_shell_drop_drawable (GtkWidget *widget, gint x, gint y, GimpViewable *viewable, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image = gimp_display_get_image (shell->display); GType new_type; GimpItem *new_item; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! image) { image = gimp_image_new_from_drawable (shell->display->gimp, GIMP_DRAWABLE (viewable)); gimp_create_display (shell->display->gimp, image, GIMP_UNIT_PIXEL, 1.0, G_OBJECT (gtk_widget_get_screen (widget)), gimp_widget_get_monitor (widget)); g_object_unref (image); return; } if (GIMP_IS_LAYER (viewable)) new_type = G_TYPE_FROM_INSTANCE (viewable); else new_type = GIMP_TYPE_LAYER; new_item = gimp_item_convert (GIMP_ITEM (viewable), image, new_type); if (new_item) { GimpLayer *new_layer = GIMP_LAYER (new_item); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, _("Drop New Layer")); gimp_display_shell_dnd_position_item (shell, image, new_item); gimp_item_set_visible (new_item, TRUE, FALSE); gimp_item_set_linked (new_item, FALSE, FALSE); gimp_image_add_layer (image, new_layer, GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE); gimp_image_undo_group_end (image); gimp_display_shell_dnd_flush (shell, image); } }
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; }