GimpUndo * gimp_image_undo_push_layer_remove (GimpImage *image, const gchar *undo_desc, GimpLayer *layer, GimpLayer *prev_parent, gint prev_position, GimpLayer *prev_layer) { g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)), NULL); g_return_val_if_fail (prev_parent == NULL || GIMP_IS_LAYER (prev_parent), NULL); g_return_val_if_fail (prev_layer == NULL || GIMP_IS_LAYER (prev_layer), NULL); return gimp_image_undo_push (image, GIMP_TYPE_LAYER_UNDO, GIMP_UNDO_LAYER_REMOVE, undo_desc, GIMP_DIRTY_IMAGE_STRUCTURE, "item", layer, "prev-parent", prev_parent, "prev-position", prev_position, "prev-layer", prev_layer, NULL); }
static void gimp_layer_mask_prop_undo_constructed (GObject *object) { GimpLayerMaskPropUndo *layer_mask_prop_undo; GimpLayer *layer; layer_mask_prop_undo = GIMP_LAYER_MASK_PROP_UNDO (object); G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item)); layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item); switch (GIMP_UNDO (object)->undo_type) { case GIMP_UNDO_LAYER_MASK_APPLY: layer_mask_prop_undo->apply = gimp_layer_get_apply_mask (layer); break; case GIMP_UNDO_LAYER_MASK_SHOW: layer_mask_prop_undo->show = gimp_layer_get_show_mask (layer); break; default: g_assert_not_reached (); } }
static void gimp_layer_prop_undo_constructed (GObject *object) { GimpLayerPropUndo *layer_prop_undo = GIMP_LAYER_PROP_UNDO (object); GimpLayer *layer; G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item)); layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item); switch (GIMP_UNDO (object)->undo_type) { case GIMP_UNDO_LAYER_MODE: layer_prop_undo->mode = gimp_layer_get_mode (layer); break; case GIMP_UNDO_LAYER_OPACITY: layer_prop_undo->opacity = gimp_layer_get_opacity (layer); break; case GIMP_UNDO_LAYER_LOCK_ALPHA: layer_prop_undo->lock_alpha = gimp_layer_get_lock_alpha (layer); break; default: g_assert_not_reached (); } }
void floating_sel_remove (GimpLayer *layer) { GimpImage *image; g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); image = gimp_item_get_image (GIMP_ITEM (layer->fs.drawable)); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_REMOVE, _("Remove Floating Selection")); /* store the affected area from the drawable in the backing store */ floating_sel_relax (layer, TRUE); /* Invalidate the preview of the obscured drawable. We do this here * because it will not be done until the floating selection is removed, * at which point the obscured drawable's preview will not be declared * invalid. */ gimp_viewable_invalidate_preview (GIMP_VIEWABLE (layer)); /* remove the layer from the image */ gimp_image_remove_layer (image, layer); gimp_image_undo_group_end (image); }
void floating_sel_activate_drawable (GimpLayer *layer) { GimpImage *image; GimpDrawable *drawable; g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); image = gimp_item_get_image (GIMP_ITEM (layer)); drawable = gimp_layer_get_floating_sel_drawable (layer); /* set the underlying drawable to active */ if (GIMP_IS_LAYER_MASK (drawable)) { GimpLayerMask *mask = GIMP_LAYER_MASK (drawable); gimp_image_set_active_layer (image, gimp_layer_mask_get_layer (mask)); } else if (GIMP_IS_CHANNEL (drawable)) { gimp_image_set_active_channel (image, GIMP_CHANNEL (drawable)); } else { gimp_image_set_active_layer (image, GIMP_LAYER (drawable)); } }
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); } }
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); }
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; }
static void gimp_layer_mask_undo_constructed (GObject *object) { GimpLayerMaskUndo *layer_mask_undo = GIMP_LAYER_MASK_UNDO (object); G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item)); g_assert (GIMP_IS_LAYER_MASK (layer_mask_undo->layer_mask)); }
GimpUndo * gimp_image_undo_push_layer_add (GimpImage *image, const gchar *undo_desc, GimpLayer *layer, GimpLayer *prev_layer) { g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (! gimp_item_is_attached (GIMP_ITEM (layer)), NULL); g_return_val_if_fail (prev_layer == NULL || GIMP_IS_LAYER (prev_layer), NULL); return gimp_image_undo_push (image, GIMP_TYPE_LAYER_UNDO, GIMP_UNDO_LAYER_ADD, undo_desc, GIMP_DIRTY_IMAGE_STRUCTURE, "item", layer, "prev-layer", prev_layer, NULL); }
static gboolean gimp_layer_mask_is_attached (const GimpItem *item) { GimpLayerMask *mask = GIMP_LAYER_MASK (item); GimpLayer *layer = gimp_layer_mask_get_layer (mask); return (GIMP_IS_IMAGE (gimp_item_get_image (item)) && GIMP_IS_LAYER (layer) && gimp_layer_get_mask (layer) == mask && gimp_item_is_attached (GIMP_ITEM (layer))); }
void floating_sel_invalidate (GimpLayer *layer) { g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); /* Invalidate the attached-to drawable's preview */ gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimp_layer_get_floating_sel_drawable (layer))); /* Invalidate the boundary */ layer->fs.boundary_known = FALSE; }
gboolean gimp_text_layer_xcf_load_hack (GimpLayer **layer) { const gchar *name; GimpText *text = NULL; const GimpParasite *parasite; g_return_val_if_fail (layer != NULL, FALSE); g_return_val_if_fail (GIMP_IS_LAYER (*layer), FALSE); name = gimp_text_parasite_name (); parasite = gimp_item_parasite_find (GIMP_ITEM (*layer), name); if (parasite) { GError *error = NULL; text = gimp_text_from_parasite (parasite, &error); if (error) { gimp_message (gimp_item_get_image (GIMP_ITEM (*layer))->gimp, NULL, GIMP_MESSAGE_ERROR, _("Problems parsing the text parasite for layer '%s':\n" "%s\n\n" "Some text properties may be wrong. " "Unless you want to edit the text layer, " "you don't need to worry about this."), gimp_object_get_name (*layer), error->message); g_clear_error (&error); } } else { name = gimp_text_gdyntext_parasite_name (); parasite = gimp_item_parasite_find (GIMP_ITEM (*layer), name); if (parasite) text = gimp_text_from_gdyntext_parasite (parasite); } if (text) { *layer = gimp_text_layer_from_layer (*layer, text); /* let the text layer knows what parasite was used to create it */ GIMP_TEXT_LAYER (*layer)->text_parasite = name; } return (text != NULL); }
gboolean floating_sel_to_layer (GimpLayer *layer, GError **error) { GimpItem *item; GimpImage *image; g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE); g_return_val_if_fail (gimp_layer_is_floating_sel (layer), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); item = GIMP_ITEM (layer); image = gimp_item_get_image (item); /* Check if the floating layer belongs to a channel */ if (GIMP_IS_CHANNEL (gimp_layer_get_floating_sel_drawable (layer))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Cannot create a new layer from the floating " "selection because it belongs to a layer mask " "or channel.")); return FALSE; } gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_TO_LAYER, C_("undo-type", "Floating Selection to Layer")); gimp_image_undo_push_fs_to_layer (image, NULL, layer); gimp_drawable_detach_floating_sel (gimp_layer_get_floating_sel_drawable (layer)); gimp_layer_set_floating_sel_drawable (layer, NULL); gimp_item_set_visible (item, TRUE, TRUE); gimp_layer_set_lock_alpha (layer, FALSE, TRUE); gimp_image_undo_group_end (image); /* When the floating selection is converted to/from a normal layer * it does something resembling a name change, so emit the * "name-changed" signal */ gimp_object_name_changed (GIMP_OBJECT (layer)); gimp_drawable_update (GIMP_DRAWABLE (layer), 0, 0, gimp_item_get_width (item), gimp_item_get_height (item)); return TRUE; }
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 floating_sel_anchor (GimpLayer *layer) { GimpImage *image; GimpDrawable *drawable; g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); image = gimp_item_get_image (GIMP_ITEM (layer)); if (! gimp_layer_is_floating_sel (layer)) { gimp_message (image->gimp, NULL, GIMP_MESSAGE_WARNING, _("Cannot anchor this layer because " "it is not a floating selection.")); return; } /* Start a floating selection anchoring undo */ gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_ANCHOR, _("Anchor Floating Selection")); /* Invalidate the previews of the layer that will be composited * with the floating section. */ gimp_viewable_invalidate_preview (GIMP_VIEWABLE (layer->fs.drawable)); /* Relax the floating selection */ floating_sel_relax (layer, TRUE); /* Composite the floating selection contents */ floating_sel_composite (layer, GIMP_ITEM (layer)->offset_x, GIMP_ITEM (layer)->offset_y, GIMP_ITEM (layer)->width, GIMP_ITEM (layer)->height, TRUE); drawable = layer->fs.drawable; /* remove the floating selection */ gimp_image_remove_layer (image, layer); /* end the group undo */ gimp_image_undo_group_end (image); /* invalidate the boundaries */ gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (gimp_image_get_mask (image))); }
GimpUndo * gimp_image_undo_push_layer_mask_show (GimpImage *image, const gchar *undo_desc, GimpLayer *layer) { g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)), NULL); return gimp_image_undo_push (image, GIMP_TYPE_LAYER_MASK_PROP_UNDO, GIMP_UNDO_LAYER_MASK_SHOW, undo_desc, GIMP_DIRTY_ITEM_META, "item", layer, NULL); }
void floating_sel_restore (GimpLayer *layer, gint x, gint y, gint w, gint h) { PixelRegion srcPR, destPR; gint offx, offy; gint x1, y1, x2, y2; g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); /* What this function does is "uncover" the specified area in the * drawable that this floating selection obscures. We do this so * that either the floating selection can be removed or it can be * translated */ /* Find the minimum area we need to uncover -- in image space */ gimp_item_offsets (GIMP_ITEM (layer->fs.drawable), &offx, &offy); x1 = MAX (GIMP_ITEM (layer)->offset_x, offx); y1 = MAX (GIMP_ITEM (layer)->offset_y, offy); x2 = MIN (GIMP_ITEM (layer)->offset_x + GIMP_ITEM (layer)->width, offx + gimp_item_width (GIMP_ITEM (layer->fs.drawable))); y2 = MIN (GIMP_ITEM(layer)->offset_y + GIMP_ITEM (layer)->height, offy + gimp_item_height (GIMP_ITEM (layer->fs.drawable))); x1 = CLAMP (x, x1, x2); y1 = CLAMP (y, y1, y2); x2 = CLAMP (x + w, x1, x2); y2 = CLAMP (y + h, y1, y2); if ((x2 - x1) > 0 && (y2 - y1) > 0) { /* Copy the area from the backing store to the drawable */ pixel_region_init (&srcPR, layer->fs.backing_store, (x1 - GIMP_ITEM (layer)->offset_x), (y1 - GIMP_ITEM (layer)->offset_y), (x2 - x1), (y2 - y1), FALSE); pixel_region_init (&destPR, gimp_drawable_get_tiles (layer->fs.drawable), (x1 - offx), (y1 - offy), (x2 - x1), (y2 - y1), TRUE); copy_region (&srcPR, &destPR); } }
GimpUndo * gimp_image_undo_push_fs_to_layer (GimpImage *image, const gchar *undo_desc, GimpLayer *floating_layer) { GimpUndo *undo; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_LAYER (floating_layer), NULL); undo = gimp_image_undo_push (image, GIMP_TYPE_FLOATING_SEL_UNDO, GIMP_UNDO_FS_TO_LAYER, undo_desc, GIMP_DIRTY_IMAGE_STRUCTURE, "item", floating_layer, NULL); return undo; }
GimpUndo * gimp_image_undo_push_layer_mask_add (GimpImage *image, const gchar *undo_desc, GimpLayer *layer, GimpLayerMask *mask) { g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)), NULL); g_return_val_if_fail (GIMP_IS_LAYER_MASK (mask), NULL); g_return_val_if_fail (! gimp_item_is_attached (GIMP_ITEM (mask)), NULL); return gimp_image_undo_push (image, GIMP_TYPE_LAYER_MASK_UNDO, GIMP_UNDO_LAYER_MASK_ADD, undo_desc, GIMP_DIRTY_IMAGE_STRUCTURE, "item", layer, "layer-mask", mask, NULL); }
void floating_sel_attach (GimpLayer *layer, GimpDrawable *drawable) { GimpImage *image; GimpLayer *floating_sel; g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable))); g_return_if_fail (drawable != GIMP_DRAWABLE (layer)); g_return_if_fail (gimp_item_get_image (GIMP_ITEM (layer)) == gimp_item_get_image (GIMP_ITEM (drawable))); image = gimp_item_get_image (GIMP_ITEM (drawable)); floating_sel = gimp_image_floating_sel (image); /* If there is already a floating selection, anchor it */ if (floating_sel) { floating_sel_anchor (floating_sel); /* if we were pasting to the old floating selection, paste now * to the drawable */ if (drawable == (GimpDrawable *) floating_sel) drawable = gimp_image_get_active_drawable (image); } /* set the drawable and allocate a backing store */ gimp_layer_set_lock_alpha (layer, TRUE, FALSE); layer->fs.drawable = drawable; layer->fs.backing_store = tile_manager_new (GIMP_ITEM (layer)->width, GIMP_ITEM (layer)->height, gimp_drawable_bytes (drawable)); /* add the layer to the image */ gimp_image_add_layer (image, layer, 0); /* store the affected area from the drawable in the backing store */ floating_sel_rigor (layer, TRUE); }
static GObject * gimp_layer_prop_undo_constructor (GType type, guint n_params, GObjectConstructParam *params) { GObject *object; GimpLayerPropUndo *layer_prop_undo; GimpImage *image; GimpLayer *layer; object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params); layer_prop_undo = GIMP_LAYER_PROP_UNDO (object); g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item)); image = GIMP_UNDO (object)->image; layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item); switch (GIMP_UNDO (object)->undo_type) { case GIMP_UNDO_LAYER_REPOSITION: layer_prop_undo->position = gimp_image_get_layer_index (image, layer); break; case GIMP_UNDO_LAYER_MODE: layer_prop_undo->mode = gimp_layer_get_mode (layer); break; case GIMP_UNDO_LAYER_OPACITY: layer_prop_undo->opacity = gimp_layer_get_opacity (layer); break; case GIMP_UNDO_LAYER_LOCK_ALPHA: layer_prop_undo->lock_alpha = gimp_layer_get_lock_alpha (layer); break; default: g_assert_not_reached (); } return object; }
void floating_sel_rigor (GimpLayer *layer, gboolean push_undo) { g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); /* store the affected area from the drawable in the backing store */ floating_sel_store (layer, GIMP_ITEM (layer)->offset_x, GIMP_ITEM (layer)->offset_y, GIMP_ITEM (layer)->width, GIMP_ITEM (layer)->height); layer->fs.initial = TRUE; if (push_undo) gimp_image_undo_push_fs_rigor (gimp_item_get_image (GIMP_ITEM (layer)), NULL, layer); }
void floating_sel_relax (GimpLayer *layer, gboolean push_undo) { g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); /* restore the contents of drawable the floating layer is attached to */ if (layer->fs.initial == FALSE) floating_sel_restore (layer, GIMP_ITEM (layer)->offset_x, GIMP_ITEM (layer)->offset_y, GIMP_ITEM (layer)->width, GIMP_ITEM (layer)->height); layer->fs.initial = TRUE; if (push_undo) gimp_image_undo_push_fs_relax (gimp_item_get_image (GIMP_ITEM (layer)), NULL, layer); }
gboolean gimp_pdb_layer_is_text_layer (GimpLayer *layer, GimpPDBItemModify modify, GError **error) { g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); if (! gimp_item_is_text_layer (GIMP_ITEM (layer))) { g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT, _("Layer '%s' (%d) cannot be used because it is not " "a text layer"), gimp_object_get_name (layer), gimp_item_get_ID (GIMP_ITEM (layer))); return FALSE; } return gimp_pdb_item_is_attached (GIMP_ITEM (layer), NULL, modify, error); }
/** * gimp_text_layer_from_layer: * @layer: a #GimpLayer object * @text: a #GimpText object * * Converts a standard #GimpLayer and a #GimpText object into a * #GimpTextLayer. The new text layer takes ownership of the @text and * @layer objects. The @layer object is rendered unusable by this * function. Don't even try to use if afterwards! * * This is a gross hack that is needed in order to load text layers * from XCF files in a backwards-compatible way. Please don't use it * for anything else! * * Return value: a newly allocated #GimpTextLayer object **/ static GimpLayer * gimp_text_layer_from_layer (GimpLayer *layer, GimpText *text) { GimpTextLayer *text_layer; GimpDrawable *drawable; g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (GIMP_IS_TEXT (text), NULL); text_layer = g_object_new (GIMP_TYPE_TEXT_LAYER, "image", gimp_item_get_image (GIMP_ITEM (layer)), NULL); gimp_item_replace_item (GIMP_ITEM (text_layer), GIMP_ITEM (layer)); drawable = GIMP_DRAWABLE (text_layer); gimp_drawable_steal_buffer (drawable, GIMP_DRAWABLE (layer)); gimp_layer_set_opacity (GIMP_LAYER (text_layer), gimp_layer_get_opacity (layer), FALSE); gimp_layer_set_mode (GIMP_LAYER (text_layer), gimp_layer_get_mode (layer), FALSE); gimp_layer_set_blend_space (GIMP_LAYER (text_layer), gimp_layer_get_blend_space (layer), FALSE); gimp_layer_set_composite_space (GIMP_LAYER (text_layer), gimp_layer_get_composite_space (layer), FALSE); gimp_layer_set_composite_mode (GIMP_LAYER (text_layer), gimp_layer_get_composite_mode (layer), FALSE); gimp_layer_set_lock_alpha (GIMP_LAYER (text_layer), gimp_layer_get_lock_alpha (layer), FALSE); gimp_text_layer_set_text (text_layer, text); g_object_unref (text); g_object_unref (layer); return GIMP_LAYER (text_layer); }
static void gimp_floating_sel_undo_constructed (GObject *object) { GimpFloatingSelUndo *floating_sel_undo = GIMP_FLOATING_SEL_UNDO (object); GimpLayer *layer; G_OBJECT_CLASS (parent_class)->constructed (object); g_assert (GIMP_IS_LAYER (GIMP_ITEM_UNDO (object)->item)); layer = GIMP_LAYER (GIMP_ITEM_UNDO (object)->item); switch (GIMP_UNDO (object)->undo_type) { case GIMP_UNDO_FS_TO_LAYER: floating_sel_undo->drawable = gimp_layer_get_floating_sel_drawable (layer); break; default: g_assert_not_reached (); } }
void gimp_layer_mask_set_layer (GimpLayerMask *layer_mask, GimpLayer *layer) { g_return_if_fail (GIMP_IS_LAYER_MASK (layer_mask)); g_return_if_fail (layer == NULL || GIMP_IS_LAYER (layer)); layer_mask->layer = layer; if (layer) { gchar *mask_name; GIMP_ITEM (layer_mask)->offset_x = GIMP_ITEM (layer)->offset_x; GIMP_ITEM (layer_mask)->offset_y = GIMP_ITEM (layer)->offset_y; mask_name = g_strdup_printf (_("%s mask"), gimp_object_get_name (GIMP_OBJECT (layer))); gimp_object_take_name (GIMP_OBJECT (layer_mask), mask_name); } }
void gimp_display_shell_set_layer_style (GimpDisplayShell *shell, cairo_t *cr, GimpLayer *layer) { cairo_pattern_t *pattern; g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell)); g_return_if_fail (cr != NULL); g_return_if_fail (GIMP_IS_LAYER (layer)); cairo_set_line_width (cr, 1.0); cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE); if (gimp_layer_get_mask (layer) && gimp_layer_mask_get_edit (gimp_layer_get_mask (layer))) { pattern = gimp_cairo_stipple_pattern_create (&layer_mask_fg, &layer_mask_bg, 0); } else if (gimp_viewable_get_children (GIMP_VIEWABLE (layer))) { pattern = gimp_cairo_stipple_pattern_create (&layer_group_fg, &layer_group_bg, 0); } else { pattern = gimp_cairo_stipple_pattern_create (&layer_fg, &layer_bg, 0); } cairo_set_source (cr, pattern); cairo_pattern_destroy (pattern); }