GeglBuffer * gimp_buffer_get_buffer (const GimpBuffer *buffer) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL); return buffer->buffer; }
GimpUnit gimp_buffer_get_unit (GimpBuffer *buffer) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), GIMP_UNIT_PIXEL); return buffer->unit; }
const Babl * gimp_buffer_get_format (const GimpBuffer *buffer) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL); return gegl_buffer_get_format (buffer->buffer); }
GimpColorProfile * gimp_buffer_get_color_profile (const GimpBuffer *buffer) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL); return buffer->color_profile; }
gint gimp_buffer_get_bytes (const GimpBuffer *buffer) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), 0); return tile_manager_bpp (buffer->tiles); }
TileManager * gimp_buffer_get_tiles (const GimpBuffer *buffer) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL); return buffer->tiles; }
gint gimp_buffer_get_height (const GimpBuffer *buffer) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), 0); return gegl_buffer_get_height (buffer->buffer); }
gint gimp_buffer_get_width (GimpBuffer *buffer) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), 0); return gegl_buffer_get_width (buffer->buffer); }
void gimp_buffer_set_unit (GimpBuffer *buffer, GimpUnit unit) { g_return_if_fail (GIMP_IS_BUFFER (buffer)); g_return_if_fail (unit > GIMP_UNIT_PIXEL); buffer->unit = unit; }
GimpImage * gimp_edit_paste_as_new_image (Gimp *gimp, GimpObject *paste) { GimpImage *image = NULL; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (paste) || GIMP_IS_BUFFER (paste), NULL); if (GIMP_IS_IMAGE (paste)) { image = gimp_image_duplicate (GIMP_IMAGE (paste)); } else if (GIMP_IS_BUFFER (paste)) { image = gimp_image_new_from_buffer (gimp, GIMP_BUFFER (paste)); } return image; }
const guint8 * gimp_buffer_get_icc_profile (const GimpBuffer *buffer, gsize *length) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL); if (length) *length = buffer->icc_profile_len; return buffer->icc_profile; }
void gimp_buffer_set_resolution (GimpBuffer *buffer, gdouble resolution_x, gdouble resolution_y) { g_return_if_fail (GIMP_IS_BUFFER (buffer)); g_return_if_fail (resolution_x >= 0.0 && resolution_x <= GIMP_MAX_RESOLUTION); g_return_if_fail (resolution_y >= 0.0 && resolution_y <= GIMP_MAX_RESOLUTION); buffer->resolution_x = resolution_x; buffer->resolution_y = resolution_y; }
GimpImageType gimp_buffer_get_image_type (const GimpBuffer *buffer) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), 0); switch (tile_manager_bpp (buffer->tiles)) { case 1: return GIMP_GRAY_IMAGE; case 2: return GIMP_GRAYA_IMAGE; case 3: return GIMP_RGB_IMAGE; case 4: return GIMP_RGBA_IMAGE; } return 0; }
void gimp_buffer_set_color_profile (GimpBuffer *buffer, GimpColorProfile *profile) { g_return_if_fail (GIMP_IS_BUFFER (buffer)); g_return_if_fail (profile == NULL || GIMP_IS_COLOR_PROFILE (profile)); if (profile != buffer->color_profile) { g_clear_object (&buffer->color_profile); if (profile) buffer->color_profile = g_object_ref (profile); } }
/** * gimp_layer_new_from_buffer: * @buffer: The buffer to make the new layer from. * @dest_image: The image the new layer will be added to. * @format: The #Babl format of the new layer. * @name: The new layer's name. * @opacity: The new layer's opacity. * @mode: The new layer's mode. * * Copies %buffer to a layer taking into consideration the * possibility of transforming the contents to meet the requirements * of the target image type * * Return value: The new layer. **/ GimpLayer * gimp_layer_new_from_buffer (GimpBuffer *buffer, GimpImage *dest_image, const Babl *format, const gchar *name, gdouble opacity, GimpLayerModeEffects mode) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), NULL); g_return_val_if_fail (format != NULL, NULL); return gimp_layer_new_from_gegl_buffer (gimp_buffer_get_buffer (buffer), dest_image, format, name, opacity, mode, gimp_buffer_get_color_profile (buffer)); }
gboolean gimp_buffer_get_resolution (GimpBuffer *buffer, gdouble *resolution_x, gdouble *resolution_y) { g_return_val_if_fail (GIMP_IS_BUFFER (buffer), FALSE); if (buffer->resolution_x > 0.0 && buffer->resolution_y > 0.0) { if (resolution_x) *resolution_x = buffer->resolution_x; if (resolution_y) *resolution_y = buffer->resolution_y; return TRUE; } return FALSE; }
void gimp_set_global_buffer (Gimp *gimp, GimpBuffer *buffer) { g_return_if_fail (GIMP_IS_GIMP (gimp)); g_return_if_fail (buffer == NULL || GIMP_IS_BUFFER (buffer)); if (buffer == gimp->global_buffer) return; if (gimp->global_buffer) g_object_unref (gimp->global_buffer); gimp->global_buffer = buffer; if (gimp->global_buffer) g_object_ref (gimp->global_buffer); g_signal_emit (gimp, gimp_signals[BUFFER_CHANGED], 0); }
/** * gimp_clipboard_set_buffer: * @gimp: pointer to #Gimp * @buffer: a #GimpBuffer, or %NULL. * * Offers the buffer in %GDK_SELECTION_CLIPBOARD. **/ void gimp_clipboard_set_buffer (Gimp *gimp, GimpBuffer *buffer) { GimpClipboard *gimp_clip; GtkClipboard *clipboard; g_return_if_fail (GIMP_IS_GIMP (gimp)); g_return_if_fail (buffer == NULL || GIMP_IS_BUFFER (buffer)); clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (), GDK_SELECTION_CLIPBOARD); if (! clipboard) return; gimp_clip = gimp_clipboard_get (gimp); gimp_clipboard_clear (gimp_clip); if (buffer) { gimp_clip->buffer = g_object_ref (buffer); gtk_clipboard_set_with_owner (clipboard, gimp_clip->target_entries, gimp_clip->n_target_entries, (GtkClipboardGetFunc) gimp_clipboard_send_buffer, (GtkClipboardClearFunc) NULL, G_OBJECT (gimp)); /* mark the first entry (image/png) as suitable for storing */ gtk_clipboard_set_can_store (clipboard, gimp_clip->target_entries, 1); } else if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (gimp)) { gtk_clipboard_clear (clipboard); } }
void gimp_buffer_set_icc_profile (GimpBuffer *buffer, const guint8 *data, gsize length) { g_return_if_fail (GIMP_IS_BUFFER (buffer)); g_return_if_fail (data == NULL || length != 0); if (data != buffer->icc_profile) { if (buffer->icc_profile) { g_free (buffer->icc_profile); buffer->icc_profile = NULL; buffer->icc_profile_len = 0; } if (data) { buffer->icc_profile = g_memdup (data, length); buffer->icc_profile_len = length; } } }
GimpLayer * gimp_edit_paste (GimpImage *image, GimpDrawable *drawable, GimpObject *paste, GimpPasteType paste_type, gint viewport_x, gint viewport_y, gint viewport_width, gint viewport_height) { GimpLayer *layer = NULL; const Babl *floating_format; gint offset_x; gint offset_y; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (drawable == NULL || gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (paste) || GIMP_IS_BUFFER (paste), NULL); /* change paste type to NEW_LAYER for cases where we can't attach a * floating selection */ if (! drawable || gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) || gimp_item_is_content_locked (GIMP_ITEM (drawable))) { paste_type = GIMP_PASTE_TYPE_NEW_LAYER; } /* floating pastes always have the pasted-to drawable's format with * alpha; if drawable == NULL, user is pasting into an empty image */ if (drawable) floating_format = gimp_drawable_get_format_with_alpha (drawable); else floating_format = gimp_image_get_layer_format (image, TRUE); if (GIMP_IS_IMAGE (paste)) { GType layer_type; layer = gimp_image_get_layer_iter (GIMP_IMAGE (paste))->data; switch (paste_type) { case GIMP_PASTE_TYPE_FLOATING: case GIMP_PASTE_TYPE_FLOATING_INTO: /* when pasting as floating selection, force creation of a * plain layer, so gimp_item_convert() will collapse a * group layer */ layer_type = GIMP_TYPE_LAYER; break; case GIMP_PASTE_TYPE_NEW_LAYER: layer_type = G_TYPE_FROM_INSTANCE (layer); break; default: g_return_val_if_reached (NULL); } layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (layer), image, layer_type)); switch (paste_type) { case GIMP_PASTE_TYPE_FLOATING: case GIMP_PASTE_TYPE_FLOATING_INTO: /* when pasting as floating selection, get rid of the layer mask, * and make sure the layer has the right format */ if (gimp_layer_get_mask (layer)) gimp_layer_apply_mask (layer, GIMP_MASK_DISCARD, FALSE); if (gimp_drawable_get_format (GIMP_DRAWABLE (layer)) != floating_format) { gimp_drawable_convert_type (GIMP_DRAWABLE (layer), image, gimp_drawable_get_base_type (drawable), gimp_drawable_get_precision (drawable), TRUE, NULL, GEGL_DITHER_NONE, GEGL_DITHER_NONE, FALSE, NULL); } break; default: break; } } else if (GIMP_IS_BUFFER (paste)) { layer = gimp_layer_new_from_buffer (GIMP_BUFFER (paste), image, floating_format, _("Pasted Layer"), GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE); } if (! layer) return NULL; gimp_edit_get_paste_offset (image, drawable, GIMP_OBJECT (layer), viewport_x, viewport_y, viewport_width, viewport_height, &offset_x, &offset_y); gimp_item_set_offset (GIMP_ITEM (layer), offset_x, offset_y); gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, C_("undo-type", "Paste")); switch (paste_type) { case GIMP_PASTE_TYPE_FLOATING: /* if there is a selection mask clear it - this might not * always be desired, but in general, it seems like the correct * behavior */ if (! gimp_channel_is_empty (gimp_image_get_mask (image))) gimp_channel_clear (gimp_image_get_mask (image), NULL, TRUE); /* fall thru */ case GIMP_PASTE_TYPE_FLOATING_INTO: floating_sel_attach (layer, drawable); break; case GIMP_PASTE_TYPE_NEW_LAYER: { GimpLayer *parent = NULL; gint position = 0; /* always add on top of the passed layer, where we would * attach a floating selection */ if (GIMP_IS_LAYER (drawable)) { parent = gimp_layer_get_parent (GIMP_LAYER (drawable)); position = gimp_item_get_index (GIMP_ITEM (drawable)); } gimp_image_add_layer (image, layer, parent, position, TRUE); } break; } gimp_image_undo_group_end (image); return layer; }
GimpLayer * gimp_edit_paste (GimpImage *image, GimpDrawable *drawable, GimpBuffer *paste, gboolean paste_into, gint viewport_x, gint viewport_y, gint viewport_width, gint viewport_height) { GimpLayer *layer; const Babl *format; gint image_width; gint image_height; gint width; gint height; gint offset_x; gint offset_y; gboolean clamp_to_image = TRUE; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (drawable == NULL || gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); g_return_val_if_fail (GIMP_IS_BUFFER (paste), NULL); /* Make a new layer: if drawable == NULL, * user is pasting into an empty image. */ if (drawable) format = gimp_drawable_get_format_with_alpha (drawable); else format = gimp_image_get_layer_format (image, TRUE); layer = gimp_layer_new_from_buffer (paste, image, format, _("Pasted Layer"), GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE); if (! layer) return NULL; image_width = gimp_image_get_width (image); image_height = gimp_image_get_height (image); width = gimp_item_get_width (GIMP_ITEM (layer)); height = gimp_item_get_height (GIMP_ITEM (layer)); if (viewport_width == image_width && viewport_height == image_height) { /* if the whole image is visible, act as if there was no viewport */ viewport_x = 0; viewport_y = 0; viewport_width = 0; viewport_height = 0; } if (drawable) { /* if pasting to a drawable */ gint off_x, off_y; gint x1, y1, x2, y2; gint paste_x, paste_y; gint paste_width, paste_height; gboolean have_mask; gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); have_mask = gimp_item_mask_bounds (GIMP_ITEM (drawable), &x1, &y1, &x2, &y2); if (! have_mask && /* if we have no mask */ viewport_width > 0 && /* and we have a viewport */ viewport_height > 0 && (width < (x2 - x1) || /* and the paste is smaller than the target */ height < (y2 - y1)) && /* and the viewport intersects with the target */ gimp_rectangle_intersect (viewport_x, viewport_y, viewport_width, viewport_height, off_x, off_y, x2 - x1, y2 - y1, &paste_x, &paste_y, &paste_width, &paste_height)) { /* center on the viewport */ offset_x = paste_x + (paste_width - width) / 2; offset_y = paste_y + (paste_height- height) / 2; } else { /* otherwise center on the target */ offset_x = off_x + ((x1 + x2) - width) / 2; offset_y = off_y + ((y1 + y2) - height) / 2; /* and keep it that way */ clamp_to_image = FALSE; } } else if (viewport_width > 0 && /* if we have a viewport */ viewport_height > 0 && (width < image_width || /* and the paste is */ height < image_height)) /* smaller than the image */ { /* center on the viewport */ offset_x = viewport_x + (viewport_width - width) / 2; offset_y = viewport_y + (viewport_height - height) / 2; } else { /* otherwise center on the image */ offset_x = (image_width - width) / 2; offset_y = (image_height - height) / 2; /* and keep it that way */ clamp_to_image = FALSE; } if (clamp_to_image) { /* Ensure that the pasted layer is always within the image, if it * fits and aligned at top left if it doesn't. (See bug #142944). */ offset_x = MIN (offset_x, image_width - width); offset_y = MIN (offset_y, image_height - height); offset_x = MAX (offset_x, 0); offset_y = MAX (offset_y, 0); } gimp_item_set_offset (GIMP_ITEM (layer), offset_x, offset_y); /* Start a group undo */ gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, C_("undo-type", "Paste")); /* If there is a selection mask clear it-- * this might not always be desired, but in general, * it seems like the correct behavior. */ if (! gimp_channel_is_empty (gimp_image_get_mask (image)) && ! paste_into) gimp_channel_clear (gimp_image_get_mask (image), NULL, TRUE); /* if there's a drawable, add a new floating selection */ if (drawable) floating_sel_attach (layer, drawable); else gimp_image_add_layer (image, layer, NULL, 0, TRUE); /* end the group undo */ gimp_image_undo_group_end (image); return layer; }