static void
gimp_image_undo_constructed (GObject *object)
{
GimpImageUndo *image_undo = GIMP_IMAGE_UNDO (object);
GimpImage *image;
G_OBJECT_CLASS (parent_class)->constructed (object);
image = GIMP_UNDO (object)->image;
switch (GIMP_UNDO (object)->undo_type)
{
case GIMP_UNDO_IMAGE_TYPE:
image_undo->base_type = gimp_image_get_base_type (image);
break;
case GIMP_UNDO_IMAGE_PRECISION:
image_undo->precision = gimp_image_get_precision (image);
break;
case GIMP_UNDO_IMAGE_SIZE:
image_undo->width = gimp_image_get_width (image);
image_undo->height = gimp_image_get_height (image);
break;
case GIMP_UNDO_IMAGE_RESOLUTION:
gimp_image_get_resolution (image,
&image_undo->xresolution,
&image_undo->yresolution);
image_undo->resolution_unit = gimp_image_get_unit (image);
break;
case GIMP_UNDO_IMAGE_GRID:
g_assert (GIMP_IS_GRID (image_undo->grid));
break;
case GIMP_UNDO_IMAGE_COLORMAP:
image_undo->num_colors = gimp_image_get_colormap_size (image);
image_undo->colormap = g_memdup (gimp_image_get_colormap (image),
GIMP_IMAGE_COLORMAP_SIZE);
break;
case GIMP_UNDO_IMAGE_METADATA:
image_undo->metadata =
gimp_metadata_duplicate (gimp_image_get_metadata (image));
break;
case GIMP_UNDO_PARASITE_ATTACH:
case GIMP_UNDO_PARASITE_REMOVE:
g_assert (image_undo->parasite_name != NULL);
image_undo->parasite = gimp_parasite_copy
(gimp_image_parasite_find (image, image_undo->parasite_name));
break;
default:
g_assert_not_reached ();
}
}
static void
gimp_image_duplicate_colormap (GimpImage *image,
GimpImage *new_image)
{
if (gimp_image_get_base_type (new_image) == GIMP_INDEXED)
gimp_image_set_colormap (new_image,
gimp_image_get_colormap (image),
gimp_image_get_colormap_size (image),
FALSE);
}
void
colormap_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpContext *context = action_data_get_context (data);
gboolean indexed = FALSE;
gint num_colors = 0;
GimpRGB fg;
GimpRGB bg;
if (image)
{
indexed = (gimp_image_get_base_type (image) == GIMP_INDEXED);
num_colors = gimp_image_get_colormap_size (image);
}
if (context)
{
gimp_context_get_foreground (context, &fg);
gimp_context_get_background (context, &bg);
}
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, color, FALSE);
SET_SENSITIVE ("colormap-edit-color",
image && indexed && num_colors > 0);
SET_SENSITIVE ("colormap-add-color-from-fg",
image && indexed && num_colors < 256);
SET_SENSITIVE ("colormap-add-color-from-bg",
image && indexed && num_colors < 256);
SET_COLOR ("colormap-add-color-from-fg", context ? &fg : NULL);
SET_COLOR ("colormap-add-color-from-bg", context ? &bg : NULL);
#undef SET_SENSITIVE
#undef SET_COLOR
}
static void
gimp_image_convert_profile_indexed (GimpImage *image,
GimpColorProfile *src_profile,
GimpColorProfile *dest_profile,
GimpColorRenderingIntent intent,
gboolean bpc,
GimpProgress *progress)
{
cmsHPROFILE src_lcms;
cmsHPROFILE dest_lcms;
guchar *cmap;
gint n_colors;
GimpColorTransform transform;
src_lcms = gimp_color_profile_get_lcms_profile (src_profile);
dest_lcms = gimp_color_profile_get_lcms_profile (dest_profile);
n_colors = gimp_image_get_colormap_size (image);
cmap = g_memdup (gimp_image_get_colormap (image), n_colors * 3);
transform = cmsCreateTransform (src_lcms, TYPE_RGB_8,
dest_lcms, TYPE_RGB_8,
intent,
cmsFLAGS_NOOPTIMIZE |
(bpc ? cmsFLAGS_BLACKPOINTCOMPENSATION : 0));
if (transform)
{
cmsDoTransform (transform, cmap, cmap, n_colors);
cmsDeleteTransform (transform);
gimp_image_set_colormap (image, cmap, n_colors, TRUE);
}
else
{
g_warning ("cmsCreateTransform() failed!");
}
g_free (cmap);
}
void
colormap_add_color_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpContext *context;
GimpImage *image;
return_if_no_context (context, data);
return_if_no_image (image, data);
if (gimp_image_get_colormap_size (image) < 256)
{
GimpRGB color;
if (value)
gimp_context_get_background (context, &color);
else
gimp_context_get_foreground (context, &color);
gimp_image_add_colormap_entry (image, &color);
gimp_image_flush (image);
}
}
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 = shell->display->image;
GType new_type;
GimpItem *new_item;
gboolean new_image = FALSE;
GIMP_LOG (DND, NULL);
if (shell->display->gimp->busy)
return;
if (! image)
{
GimpImage *src_image = gimp_item_get_image (GIMP_ITEM (viewable));
GimpDrawable *drawable = GIMP_DRAWABLE (viewable);
GimpImageBaseType type;
gdouble xres;
gdouble yres;
type = GIMP_IMAGE_TYPE_BASE_TYPE (gimp_drawable_type (drawable));
image = gimp_create_image (shell->display->gimp,
gimp_item_width (GIMP_ITEM (viewable)),
gimp_item_height (GIMP_ITEM (viewable)),
type, TRUE);
gimp_image_undo_disable (image);
if (type == GIMP_INDEXED)
gimp_image_set_colormap (image,
gimp_image_get_colormap (src_image),
gimp_image_get_colormap_size (src_image),
FALSE);
gimp_image_get_resolution (src_image, &xres, &yres);
gimp_image_set_resolution (image, xres, yres);
gimp_image_set_unit (image, gimp_image_get_unit (src_image));
gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0);
g_object_unref (image);
new_image = TRUE;
}
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"));
if (! new_image)
gimp_display_shell_dnd_position_item (shell, 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, -1);
gimp_image_undo_group_end (image);
gimp_display_shell_dnd_flush (shell, image);
}
if (new_image)
gimp_image_undo_enable (image);
}
GimpImage *
gimp_image_duplicate (GimpImage *image)
{
GimpImage *new_image;
GimpLayer *floating_layer;
GList *list;
GimpLayer *active_layer = NULL;
GimpChannel *active_channel = NULL;
GimpVectors *active_vectors = NULL;
GimpDrawable *new_floating_sel_drawable = NULL;
GimpDrawable *floating_sel_drawable = NULL;
gchar *filename;
gint count;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
gimp_set_busy_until_idle (image->gimp);
/* Create a new image */
new_image = gimp_create_image (image->gimp,
image->width, image->height,
image->base_type,
FALSE);
gimp_image_undo_disable (new_image);
/* Store the folder to be used by the save dialog */
filename = gimp_image_get_filename (image);
if (filename)
{
g_object_set_data_full (G_OBJECT (new_image), "gimp-image-dirname",
g_path_get_dirname (filename),
(GDestroyNotify) g_free);
g_free (filename);
}
/* Copy the colormap if necessary */
if (new_image->base_type == GIMP_INDEXED)
gimp_image_set_colormap (new_image,
gimp_image_get_colormap (image),
gimp_image_get_colormap_size (image),
FALSE);
/* Copy resolution information */
new_image->xresolution = image->xresolution;
new_image->yresolution = image->yresolution;
new_image->resolution_unit = image->resolution_unit;
/* Copy floating layer */
floating_layer = gimp_image_floating_sel (image);
if (floating_layer)
{
floating_sel_relax (floating_layer, FALSE);
floating_sel_drawable = floating_layer->fs.drawable;
floating_layer = NULL;
}
/* Copy the layers */
for (list = GIMP_LIST (image->layers)->list, count = 0;
list;
list = g_list_next (list))
{
GimpLayer *layer = list->data;
GimpLayer *new_layer;
new_layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (layer),
new_image,
G_TYPE_FROM_INSTANCE (layer),
FALSE));
/* Make sure the copied layer doesn't say: "<old layer> copy" */
gimp_object_set_name (GIMP_OBJECT (new_layer),
gimp_object_get_name (GIMP_OBJECT (layer)));
/* Make sure that if the layer has a layer mask,
* its name isn't screwed up
*/
if (new_layer->mask)
gimp_object_set_name (GIMP_OBJECT (new_layer->mask),
gimp_object_get_name (GIMP_OBJECT (layer->mask)));
if (gimp_image_get_active_layer (image) == layer)
active_layer = new_layer;
if (image->floating_sel == layer)
floating_layer = new_layer;
if (floating_sel_drawable == GIMP_DRAWABLE (layer))
new_floating_sel_drawable = GIMP_DRAWABLE (new_layer);
if (floating_layer != new_layer)
gimp_image_add_layer (new_image, new_layer, count++);
}
/* Copy the channels */
for (list = GIMP_LIST (image->channels)->list, count = 0;
list;
list = g_list_next (list))
{
GimpChannel *channel = list->data;
GimpChannel *new_channel;
new_channel =
GIMP_CHANNEL (gimp_item_convert (GIMP_ITEM (channel),
new_image,
G_TYPE_FROM_INSTANCE (channel),
FALSE));
/* Make sure the copied channel doesn't say: "<old channel> copy" */
gimp_object_set_name (GIMP_OBJECT (new_channel),
gimp_object_get_name (GIMP_OBJECT (channel)));
if (gimp_image_get_active_channel (image) == channel)
active_channel = (new_channel);
if (floating_sel_drawable == GIMP_DRAWABLE (channel))
new_floating_sel_drawable = GIMP_DRAWABLE (new_channel);
gimp_image_add_channel (new_image, new_channel, count++);
}
/* Copy any vectors */
for (list = GIMP_LIST (image->vectors)->list, count = 0;
list;
list = g_list_next (list))
{
GimpVectors *vectors = list->data;
GimpVectors *new_vectors;
new_vectors =
GIMP_VECTORS (gimp_item_convert (GIMP_ITEM (vectors),
new_image,
G_TYPE_FROM_INSTANCE (vectors),
FALSE));
/* Make sure the copied vectors doesn't say: "<old vectors> copy" */
gimp_object_set_name (GIMP_OBJECT (new_vectors),
gimp_object_get_name (GIMP_OBJECT (vectors)));
if (gimp_image_get_active_vectors (image) == vectors)
active_vectors = new_vectors;
gimp_image_add_vectors (new_image, new_vectors, count++);
}
/* Copy the selection mask */
{
TileManager *src_tiles;
TileManager *dest_tiles;
PixelRegion srcPR, destPR;
src_tiles =
gimp_drawable_get_tiles (GIMP_DRAWABLE (image->selection_mask));
dest_tiles =
gimp_drawable_get_tiles (GIMP_DRAWABLE (new_image->selection_mask));
pixel_region_init (&srcPR, src_tiles,
0, 0, image->width, image->height, FALSE);
pixel_region_init (&destPR, dest_tiles,
0, 0, image->width, image->height, TRUE);
copy_region (&srcPR, &destPR);
new_image->selection_mask->bounds_known = FALSE;
new_image->selection_mask->boundary_known = FALSE;
}
if (floating_layer)
floating_sel_attach (floating_layer, new_floating_sel_drawable);
/* Set active layer, active channel, active vectors */
if (active_layer)
gimp_image_set_active_layer (new_image, active_layer);
if (active_channel)
gimp_image_set_active_channel (new_image, active_channel);
if (active_vectors)
gimp_image_set_active_vectors (new_image, active_vectors);
/* Copy state of all color channels */
for (count = 0; count < MAX_CHANNELS; count++)
{
new_image->visible[count] = image->visible[count];
new_image->active[count] = image->active[count];
}
/* Copy any guides */
for (list = image->guides; list; list = g_list_next (list))
{
GimpGuide *guide = list->data;
gint position = gimp_guide_get_position (guide);
switch (gimp_guide_get_orientation (guide))
{
case GIMP_ORIENTATION_HORIZONTAL:
gimp_image_add_hguide (new_image, position, FALSE);
break;
case GIMP_ORIENTATION_VERTICAL:
gimp_image_add_vguide (new_image, position, FALSE);
break;
default:
g_error ("Unknown guide orientation.\n");
}
}
/* Copy any sample points */
for (list = image->sample_points; list; list = g_list_next (list))
{
GimpSamplePoint *sample_point = list->data;
gimp_image_add_sample_point_at_pos (new_image,
sample_point->x,
sample_point->y,
FALSE);
}
/* Copy the grid */
if (image->grid)
gimp_image_set_grid (new_image, image->grid, FALSE);
/* Copy the quick mask info */
new_image->quick_mask_state = image->quick_mask_state;
new_image->quick_mask_inverted = image->quick_mask_inverted;
new_image->quick_mask_color = image->quick_mask_color;
/* Copy parasites */
if (image->parasites)
{
g_object_unref (new_image->parasites);
new_image->parasites = gimp_parasite_list_copy (image->parasites);
}
gimp_image_undo_enable (new_image);
return new_image;
}
static void
gimp_image_prop_view_update (GimpImagePropView *view)
{
GimpImage *image = view->image;
GimpImageBaseType type;
GimpPrecision precision;
GimpUnit unit;
gdouble unit_factor;
gint unit_digits;
const gchar *desc;
gchar format_buf[32];
gchar buf[256];
gdouble xres;
gdouble yres;
gimp_image_get_resolution (image, &xres, &yres);
/* pixel size */
g_snprintf (buf, sizeof (buf), ngettext ("%d × %d pixel",
"%d × %d pixels",
gimp_image_get_height (image)),
gimp_image_get_width (image),
gimp_image_get_height (image));
gtk_label_set_text (GTK_LABEL (view->pixel_size_label), buf);
/* print size */
unit = gimp_get_default_unit ();
unit_digits = gimp_unit_get_digits (unit);
g_snprintf (format_buf, sizeof (format_buf), "%%.%df × %%.%df %s",
unit_digits + 1, unit_digits + 1,
gimp_unit_get_plural (unit));
g_snprintf (buf, sizeof (buf), format_buf,
gimp_pixels_to_units (gimp_image_get_width (image), unit, xres),
gimp_pixels_to_units (gimp_image_get_height (image), unit, yres));
gtk_label_set_text (GTK_LABEL (view->print_size_label), buf);
/* resolution */
unit = gimp_image_get_unit (image);
unit_factor = gimp_unit_get_factor (unit);
g_snprintf (format_buf, sizeof (format_buf), _("pixels/%s"),
gimp_unit_get_abbreviation (unit));
g_snprintf (buf, sizeof (buf), _("%g × %g %s"),
xres / unit_factor,
yres / unit_factor,
unit == GIMP_UNIT_INCH ? _("ppi") : format_buf);
gtk_label_set_text (GTK_LABEL (view->resolution_label), buf);
/* color type */
type = gimp_image_get_base_type (image);
gimp_enum_get_value (GIMP_TYPE_IMAGE_BASE_TYPE, type,
NULL, NULL, &desc, NULL);
switch (type)
{
case GIMP_RGB:
case GIMP_GRAY:
g_snprintf (buf, sizeof (buf), "%s", desc);
break;
case GIMP_INDEXED:
g_snprintf (buf, sizeof (buf),
"%s (%d %s)", desc, gimp_image_get_colormap_size (image),
_("colors"));
break;
}
gtk_label_set_text (GTK_LABEL (view->colorspace_label), buf);
/* precision */
precision = gimp_image_get_precision (image);
gimp_enum_get_value (GIMP_TYPE_PRECISION, precision,
NULL, NULL, &desc, NULL);
gtk_label_set_text (GTK_LABEL (view->precision_label), desc);
/* size in memory */
gimp_image_prop_view_label_set_memsize (view->memsize_label,
GIMP_OBJECT (image));
/* undo / redo */
gimp_image_prop_view_label_set_undo (view->undo_label,
gimp_image_get_undo_stack (image));
gimp_image_prop_view_label_set_undo (view->redo_label,
gimp_image_get_redo_stack (image));
/* number of layers */
g_snprintf (buf, sizeof (buf), "%d",
gimp_image_get_width (image) *
gimp_image_get_height (image));
gtk_label_set_text (GTK_LABEL (view->pixels_label), buf);
/* number of layers */
g_snprintf (buf, sizeof (buf), "%d",
gimp_image_get_n_layers (image));
gtk_label_set_text (GTK_LABEL (view->layers_label), buf);
/* number of channels */
g_snprintf (buf, sizeof (buf), "%d",
gimp_image_get_n_channels (image));
gtk_label_set_text (GTK_LABEL (view->channels_label), buf);
/* number of vectors */
g_snprintf (buf, sizeof (buf), "%d",
gimp_image_get_n_vectors (image));
gtk_label_set_text (GTK_LABEL (view->vectors_label), buf);
}
