procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-03 09:23:24 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions
gimp/app/core/gimpimage-new.c
Jacob Boerema 6b10cce682 app, libgimpbase: add creation date/time metadata... 
when creating a new image.

We add a new function `gimp_metadata_set_creation_date` to
`libgimpbase/gimpmetadata` to handle setting all relevant
metadata tags.

We add a local function `gimp_image_new_add_creation_metadata` to
add the creation date metadata to relevant functions that create
new images.
We write tags for both the creation date and several modified dates
for IPTC, XMP and Exif metadata. All these use different ways to
express date/time and timezones and I can already see we need to have
another look at other places where we handle modified dates.

This solves the second part of #7287, adding metadata about the
date/time a new image was created.
2025-01-15 16:54:22 -05:00

730 lines
24 KiB
C
Raw Blame History

/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995-1999 Spencer Kimball and Peter Mattis
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <cairo.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <gegl.h>
#include "libgimpbase/gimpbase.h"
#include "libgimpcolor/gimpcolor.h"
#include "libgimpconfig/gimpconfig.h"
#include "core-types.h"
#include "config/gimpcoreconfig.h"
#include "gegl/gimp-babl.h"
#include "gegl/gimp-gegl-utils.h"
#include "gimp.h"
#include "gimpbuffer.h"
#include "gimpchannel.h"
#include "gimpcontext.h"
#include "gimpdrawable-fill.h"
#include "gimpdrawable-filters.h"
#include "gimpdrawablefilter.h"
#include "gimpgrouplayer.h"
#include "gimpimage.h"
#include "gimpimage-color-profile.h"
#include "gimpimage-colormap.h"
#include "gimpimage-metadata.h"
#include "gimpimage-new.h"
#include "gimpimage-undo.h"
#include "gimplayer.h"
#include "gimplayer-new.h"
#include "gimplist.h"
#include "gimptemplate.h"
#include "gimp-intl.h"
GimpTemplate *
gimp_image_new_get_last_template (Gimp *gimp,
GimpImage *image)
{
GimpTemplate *template;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (image == NULL || GIMP_IS_IMAGE (image), NULL);
template = gimp_template_new ("image new values");
if (image)
{
const gchar *comment;
comment = gimp_template_get_comment (gimp->config->default_image);
gimp_config_sync (G_OBJECT (gimp->config->default_image),
G_OBJECT (template), 0);
gimp_template_set_from_image (template, image);
/* Do not pass around the comment from the current active comment. Only
* pass comments stored in actual templates. This can be even considered
* as data leak otherwise (creating 2 images in a row and not realizing
* the second will have the metadata comment from the first). See #11384.
*/
g_object_set (template, "comment", comment, NULL);
}
else
{
gimp_config_sync (G_OBJECT (gimp->image_new_last_template),
G_OBJECT (template), 0);
}
return template;
}
void
gimp_image_new_set_last_template (Gimp *gimp,
GimpTemplate *template)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_TEMPLATE (template));
gimp_config_sync (G_OBJECT (template),
G_OBJECT (gimp->image_new_last_template), 0);
}
void
gimp_image_new_add_creation_metadata (GimpImage *image)
{
GimpMetadata *metadata;
metadata = gimp_image_get_metadata (image);
if (! metadata)
{
g_critical ("Metadata not found. Should not happen!");
}
else
{
GDateTime *datetime;
datetime = g_date_time_new_now_local ();
gimp_metadata_set_creation_date (metadata, datetime);
g_date_time_unref (datetime);
}
}
GimpImage *
gimp_image_new_from_template (Gimp *gimp,
GimpTemplate *template,
GimpContext *context)
{
GimpImage *image;
GimpLayer *layer;
GimpColorProfile *profile;
GimpColorRenderingIntent intent;
gboolean bpc;
gint width, height;
gboolean has_alpha;
const gchar *comment;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_TEMPLATE (template), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
image = gimp_create_image (gimp,
gimp_template_get_width (template),
gimp_template_get_height (template),
gimp_template_get_base_type (template),
gimp_template_get_precision (template),
FALSE);
gimp_context_set_image (context, image);
gimp_image_undo_disable (image);
comment = gimp_template_get_comment (template);
if (comment)
{
GimpParasite *parasite;
parasite = gimp_parasite_new ("gimp-comment",
GIMP_PARASITE_PERSISTENT,
strlen (comment) + 1,
comment);
gimp_image_parasite_attach (image, parasite, FALSE);
gimp_parasite_free (parasite);
}
gimp_image_set_resolution (image,
gimp_template_get_resolution_x (template),
gimp_template_get_resolution_y (template));
gimp_image_set_unit (image, gimp_template_get_resolution_unit (template));
profile = gimp_template_get_color_profile (template);
gimp_image_set_color_profile (image, profile, NULL);
if (profile)
g_object_unref (profile);
profile = gimp_template_get_simulation_profile (template);
gimp_image_set_simulation_profile (image, profile);
if (profile)
g_object_unref (profile);
intent = gimp_template_get_simulation_intent (template);
gimp_image_set_simulation_intent (image, intent);
bpc = gimp_template_get_simulation_bpc (template);
gimp_image_set_simulation_bpc (image, bpc);
width = gimp_image_get_width (image);
height = gimp_image_get_height (image);
if (gimp_template_get_fill_type (template) == GIMP_FILL_TRANSPARENT)
has_alpha = TRUE;
else
has_alpha = FALSE;
layer = gimp_layer_new (image, width, height,
gimp_image_get_layer_format (image, has_alpha),
_("Background"),
GIMP_OPACITY_OPAQUE,
gimp_image_get_default_new_layer_mode (image));
gimp_drawable_fill (GIMP_DRAWABLE (layer),
context, gimp_template_get_fill_type (template));
gimp_image_add_layer (image, layer, NULL, 0, FALSE);
gimp_image_new_add_creation_metadata (image);
gimp_image_undo_enable (image);
gimp_image_clean_all (image);
return image;
}
GimpImage *
gimp_image_new_from_drawable (Gimp *gimp,
GimpDrawable *drawable)
{
GimpItem *item;
GimpImage *image;
GimpImage *new_image;
GimpLayer *new_layer;
GType new_type;
gint off_x, off_y;
GimpImageBaseType type;
gdouble xres;
gdouble yres;
GimpColorProfile *profile;
GimpContainer *filters;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
item = GIMP_ITEM (drawable);
image = gimp_item_get_image (item);
type = gimp_drawable_get_base_type (drawable);
new_image = gimp_create_image (gimp,
gimp_item_get_width (item),
gimp_item_get_height (item),
type,
gimp_drawable_get_precision (drawable),
TRUE);
gimp_image_undo_disable (new_image);
if (type == GIMP_INDEXED)
gimp_image_set_colormap_palette (new_image,
gimp_image_get_colormap_palette (image),
FALSE);
gimp_image_get_resolution (image, &xres, &yres);
gimp_image_set_resolution (new_image, xres, yres);
gimp_image_set_unit (new_image, gimp_image_get_unit (image));
profile = gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (drawable));
gimp_image_set_color_profile (new_image, profile, NULL);
if (GIMP_IS_LAYER (drawable))
new_type = G_TYPE_FROM_INSTANCE (drawable);
else
new_type = GIMP_TYPE_LAYER;
new_layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (drawable),
new_image, new_type));
gimp_object_set_name (GIMP_OBJECT (new_layer),
gimp_object_get_name (drawable));
gimp_item_get_offset (GIMP_ITEM (new_layer), &off_x, &off_y);
gimp_item_translate (GIMP_ITEM (new_layer), -off_x, -off_y, FALSE);
gimp_item_set_visible (GIMP_ITEM (new_layer), TRUE, FALSE);
gimp_layer_set_mode (new_layer,
gimp_image_get_default_new_layer_mode (new_image),
FALSE);
gimp_layer_set_opacity (new_layer, GIMP_OPACITY_OPAQUE, FALSE);
if (gimp_layer_can_lock_alpha (new_layer))
gimp_layer_set_lock_alpha (new_layer, FALSE, FALSE);
filters = gimp_drawable_get_filters (GIMP_DRAWABLE (drawable));
if (gimp_container_get_n_children (filters) > 0)
{
GList *filter_list;
for (filter_list = GIMP_LIST (filters)->queue->tail;
filter_list;
filter_list = g_list_previous (filter_list))
{
if (GIMP_IS_DRAWABLE_FILTER (filter_list->data))
{
GimpDrawableFilter *old_filter = filter_list->data;
GimpDrawableFilter *filter;
filter =
gimp_drawable_filter_duplicate (GIMP_DRAWABLE (new_layer),
old_filter);
if (filter != NULL)
{
gimp_drawable_filter_apply (filter, NULL);
gimp_drawable_filter_commit (filter, TRUE, NULL, FALSE);
gimp_drawable_filter_layer_mask_freeze (filter);
g_object_unref (filter);
}
}
}
}
gimp_image_add_layer (new_image, new_layer, NULL, 0, TRUE);
gimp_image_new_add_creation_metadata (new_image);
gimp_image_undo_enable (new_image);
return new_image;
}
/**
* gimp_image_new_copy_drawables:
* @image: the image where @drawables belong to.
* @drawables: the drawables to copy into @new_image.
* @new_image: the image to insert to.
* @tag_copies: tag copies of @drawable with "gimp-image-copied-layer".
* @copied_drawables:
* @tagged_drawables:
* @parent:
* @new_parent:
*
* This recursive function will create copies of all @drawables
* belonging to the same @image, and will insert them into @new_image
* with the same layer order and hierarchy (adding layer groups when
* needed).
* If a single drawable is selected, it will be copied visible, with
* full opacity and default layer mode. Otherwise, visibility, opacity
* and layer mode will be copied as-is, allowing proper compositing.
*
* The @copied_drawables, @tagged_drawables, @parent and @new_parent arguments
* are only used internally for recursive calls and must be set to NULL for the
* initial call.
*/
static void
gimp_image_new_copy_drawables (GimpImage *image,
GList *drawables,
GimpImage *new_image,
gboolean tag_copies,
GList *copied_drawables,
GList *tagged_drawables,
GimpLayer *parent,
GimpLayer *new_parent)
{
GList *layers;
GList *iter;
gint n_drawables;
gint index;
n_drawables = g_list_length (drawables);
if (parent == NULL)
{
/* Root layers. */
layers = gimp_image_get_layer_iter (image);
copied_drawables = g_list_copy (drawables);
for (iter = copied_drawables; iter; iter = iter->next)
{
/* Tagged drawables are the explicitly copied drawables which have no
* explicitly copied descendant items.
*/
GList *iter2;
for (iter2 = iter; iter2; iter2 = iter2->next)
if (gimp_viewable_is_ancestor (iter->data, iter2->data))
break;
if (iter2 == NULL)
tagged_drawables = g_list_prepend (tagged_drawables, iter->data);
}
/* Add any item parent. */
for (iter = copied_drawables; iter; iter = iter->next)
{
GimpItem *item = iter->data;
while ((item = gimp_item_get_parent (item)))
if (! g_list_find (copied_drawables, item))
copied_drawables = g_list_prepend (copied_drawables, item);
}
}
else
{
GimpContainer *container;
container = gimp_viewable_get_children (GIMP_VIEWABLE (parent));
layers = GIMP_LIST (container)->queue->head;
}
index = 0;
for (iter = layers; iter; iter = iter->next)
{
if (g_list_find (copied_drawables, iter->data))
{
GimpLayer *new_layer;
GimpContainer *filters;
GType new_type;
gboolean is_group;
gboolean is_tagged;
if (GIMP_IS_LAYER (iter->data))
new_type = G_TYPE_FROM_INSTANCE (iter->data);
else
new_type = GIMP_TYPE_LAYER;
is_group = (gimp_viewable_get_children (iter->data) != NULL);
is_tagged = (g_list_find (tagged_drawables, iter->data) != NULL);
if (is_group && ! is_tagged)
new_layer = gimp_group_layer_new (new_image);
else
new_layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (iter->data),
new_image, new_type));
if (tag_copies && is_tagged)
g_object_set_data (G_OBJECT (new_layer),
"gimp-image-copied-layer",
GINT_TO_POINTER (TRUE));
gimp_object_set_name (GIMP_OBJECT (new_layer),
gimp_object_get_name (iter->data));
/* Visibility, mode and opacity mimic the source image if
* multiple items are copied. Otherwise we just set them to
* defaults.
*/
gimp_item_set_visible (GIMP_ITEM (new_layer),
n_drawables > 1 ?
gimp_item_get_visible (iter->data) : TRUE,
FALSE);
gimp_layer_set_mode (new_layer,
n_drawables > 1 && GIMP_IS_LAYER (iter->data) ?
gimp_layer_get_mode (iter->data) :
gimp_image_get_default_new_layer_mode (new_image),
FALSE);
gimp_layer_set_opacity (new_layer,
n_drawables > 1 && GIMP_IS_LAYER (iter->data) ?
gimp_layer_get_opacity (iter->data) : GIMP_OPACITY_OPAQUE, FALSE);
if (gimp_layer_can_lock_alpha (new_layer))
gimp_layer_set_lock_alpha (new_layer, FALSE, FALSE);
filters = gimp_drawable_get_filters (GIMP_DRAWABLE (iter->data));
if (gimp_container_get_n_children (filters) > 0)
{
GList *filter_list;
for (filter_list = GIMP_LIST (filters)->queue->tail; filter_list;
filter_list = g_list_previous (filter_list))
{
if (GIMP_IS_DRAWABLE_FILTER (filter_list->data))
{
GimpDrawableFilter *old_filter = filter_list->data;
GimpDrawableFilter *filter;
filter = gimp_drawable_filter_duplicate (GIMP_DRAWABLE (new_layer), old_filter);
if (filter != NULL)
{
gimp_drawable_filter_apply (filter, NULL);
gimp_drawable_filter_commit (filter, TRUE, NULL, FALSE);
gimp_drawable_filter_layer_mask_freeze (filter);
g_object_unref (filter);
}
}
}
}
gimp_image_add_layer (new_image, new_layer, new_parent, index++, TRUE);
/* If a group, loop through children. */
if (is_group && ! is_tagged)
gimp_image_new_copy_drawables (image, drawables, new_image, tag_copies,
copied_drawables, tagged_drawables,
iter->data, new_layer);
}
}
if (parent == NULL)
{
g_list_free (copied_drawables);
g_list_free (tagged_drawables);
}
}
GimpImage *
gimp_image_new_from_drawables (Gimp *gimp,
GList *drawables,
gboolean copy_selection,
gboolean tag_copies)
{
GimpImage *image = NULL;
GimpImage *new_image;
GList *iter;
GimpImageBaseType type;
GimpPrecision precision;
gdouble xres;
gdouble yres;
GimpColorProfile *profile = NULL;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (drawables != NULL, NULL);
for (iter = drawables; iter; iter = iter->next)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (iter->data), NULL);
if (iter == drawables)
image = gimp_item_get_image (iter->data);
else
/* We only accept list of drawables for a same origin image. */
g_return_val_if_fail (gimp_item_get_image (iter->data) == image, NULL);
}
type = gimp_drawable_get_base_type (drawables->data);
precision = gimp_drawable_get_precision (drawables->data);
profile = gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (drawables->data));
new_image = gimp_create_image (gimp,
gimp_image_get_width (image),
gimp_image_get_height (image),
type, precision,
TRUE);
gimp_image_undo_disable (new_image);
if (type == GIMP_INDEXED)
gimp_image_set_colormap_palette (new_image,
gimp_image_get_colormap_palette (image),
FALSE);
gimp_image_get_resolution (image, &xres, &yres);
gimp_image_set_resolution (new_image, xres, yres);
gimp_image_set_unit (new_image, gimp_image_get_unit (image));
if (profile)
gimp_image_set_color_profile (new_image, profile, NULL);
if (copy_selection)
{
GimpChannel *selection;
selection = gimp_image_get_mask (image);
if (! gimp_channel_is_empty (selection))
{
GimpChannel *new_selection;
GeglBuffer *buffer;
new_selection = gimp_image_get_mask (new_image);
buffer = gimp_gegl_buffer_dup (gimp_drawable_get_buffer (GIMP_DRAWABLE (selection)));
gimp_drawable_set_buffer (GIMP_DRAWABLE (new_selection),
FALSE, NULL, buffer);
g_object_unref (buffer);
}
}
gimp_image_new_copy_drawables (image, drawables, new_image, tag_copies, NULL, NULL, NULL, NULL);
gimp_image_new_add_creation_metadata (new_image);
gimp_image_undo_enable (new_image);
return new_image;
}
GimpImage *
gimp_image_new_from_component (Gimp *gimp,
GimpImage *image,
GimpChannelType component)
{
GimpImage *new_image;
GimpChannel *channel;
GimpLayer *layer;
const gchar *desc;
gdouble xres;
gdouble yres;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
new_image = gimp_create_image (gimp,
gimp_image_get_width (image),
gimp_image_get_height (image),
GIMP_GRAY,
gimp_image_get_precision (image),
TRUE);
gimp_image_undo_disable (new_image);
gimp_image_get_resolution (image, &xres, &yres);
gimp_image_set_resolution (new_image, xres, yres);
gimp_image_set_unit (new_image, gimp_image_get_unit (image));
channel = gimp_channel_new_from_component (image, component, NULL, NULL);
layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (channel),
new_image, GIMP_TYPE_LAYER));
g_object_unref (channel);
gimp_enum_get_value (GIMP_TYPE_CHANNEL_TYPE, component,
NULL, NULL, &desc, NULL);
gimp_object_take_name (GIMP_OBJECT (layer),
g_strdup_printf (_("%s Channel Copy"), desc));
gimp_image_add_layer (new_image, layer, NULL, 0, TRUE);
gimp_image_new_add_creation_metadata (new_image);
gimp_image_undo_enable (new_image);
return new_image;
}
GimpImage *
gimp_image_new_from_buffer (Gimp *gimp,
GimpBuffer *buffer)
{
GimpImage *image;
GimpLayer *layer;
const Babl *format;
gboolean has_alpha;
gdouble res_x;
gdouble res_y;
GimpColorProfile *profile;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL);
format = gimp_buffer_get_format (buffer);
has_alpha = babl_format_has_alpha (format);
image = gimp_create_image (gimp,
gimp_buffer_get_width (buffer),
gimp_buffer_get_height (buffer),
gimp_babl_format_get_base_type (format),
gimp_babl_format_get_precision (format),
TRUE);
gimp_image_undo_disable (image);
if (gimp_buffer_get_resolution (buffer, &res_x, &res_y))
{
gimp_image_set_resolution (image, res_x, res_y);
gimp_image_set_unit (image, gimp_buffer_get_unit (buffer));
}
profile = gimp_buffer_get_color_profile (buffer);
gimp_image_set_color_profile (image, profile, NULL);
layer = gimp_layer_new_from_buffer (buffer, image,
gimp_image_get_layer_format (image,
has_alpha),
_("Pasted Layer"),
GIMP_OPACITY_OPAQUE,
gimp_image_get_default_new_layer_mode (image));
gimp_image_add_layer (image, layer, NULL, 0, TRUE);
gimp_image_new_add_creation_metadata (image);
gimp_image_undo_enable (image);
return image;
}
GimpImage *
gimp_image_new_from_pixbuf (Gimp *gimp,
GdkPixbuf *pixbuf,
const gchar *layer_name)
{
GimpImage *new_image;
GimpLayer *layer;
GimpImageBaseType base_type;
gboolean has_alpha = FALSE;
guint8 *icc_data;
gsize icc_len;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
switch (gdk_pixbuf_get_n_channels (pixbuf))
{
case 2: has_alpha = TRUE;
case 1: base_type = GIMP_GRAY;
break;
case 4: has_alpha = TRUE;
case 3: base_type = GIMP_RGB;
break;
default:
g_return_val_if_reached (NULL);
}
new_image = gimp_create_image (gimp,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
base_type,
GIMP_PRECISION_U8_NON_LINEAR,
FALSE);
gimp_image_undo_disable (new_image);
icc_data = gimp_pixbuf_get_icc_profile (pixbuf, &icc_len);
if (icc_data)
{
gimp_image_set_icc_profile (new_image, icc_data, icc_len,
GIMP_ICC_PROFILE_PARASITE_NAME,
NULL);
g_free (icc_data);
}
layer = gimp_layer_new_from_pixbuf (pixbuf, new_image,
gimp_image_get_layer_format (new_image,
has_alpha),
layer_name,
GIMP_OPACITY_OPAQUE,
gimp_image_get_default_new_layer_mode (new_image));
gimp_image_add_layer (new_image, layer, NULL, 0, TRUE);
gimp_image_new_add_creation_metadata (new_image);
gimp_image_undo_enable (new_image);
return new_image;
}
Reference in a new issue View git blame Copy permalink