static void
jpeg_load_resolution (gint32 image_ID,
struct jpeg_decompress_struct *cinfo)
{
if (cinfo->saw_JFIF_marker && cinfo->X_density != 0 && cinfo->Y_density != 0)
{
gdouble xresolution = cinfo->X_density;
gdouble yresolution = cinfo->Y_density;
gdouble asymmetry = 1.0;
switch (cinfo->density_unit)
{
case 0: /* unknown -> set the aspect ratio but use the default
* image resolution
*/
asymmetry = xresolution / yresolution;
gimp_image_get_resolution (image_ID, &xresolution, &yresolution);
xresolution *= asymmetry;
break;
case 1: /* dots per inch */
break;
case 2: /* dots per cm */
xresolution *= 2.54;
yresolution *= 2.54;
gimp_image_set_unit (image_ID, GIMP_UNIT_MM);
break;
default:
g_message ("Unknown density unit %d, assuming dots per inch.",
cinfo->density_unit);
break;
}
gimp_image_set_resolution (image_ID, xresolution, yresolution);
}
}
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);
}
/* ----------------------------
* gap_frame_fetch_dup_image
* ----------------------------
* returns merged or selected layer_id
* (that is the only visible layer in temporary created scratch image)
* the caller is resonsible to delete the scratch image when processing is done.
* this can be done by calling gap_frame_fetch_delete_list_of_duplicated_images()
*/
gint32
gap_frame_fetch_dup_image(gint32 ffetch_user_id
,const char *filename /* full filename of the image (already contains framenr) */
,gint32 stackpos /* 0 pick layer on top of stack, -1 merge visible layers */
,gboolean addToCache /* enable caching */
)
{
gint32 resulting_layer;
gint32 image_id;
gint32 dup_image_id;
resulting_layer = -1;
dup_image_id = -1;
image_id = p_load_cache_image(filename, ffetch_user_id, addToCache);
if (image_id < 0)
{
return(-1);
}
if (stackpos < 0)
{
dup_image_id = gimp_image_duplicate(image_id);
gap_frame_fetch_remove_parasite(dup_image_id);
resulting_layer = gap_image_merge_visible_layers(dup_image_id, GIMP_CLIP_TO_IMAGE);
}
else
{
gint l_nlayers;
gint32 *l_layers_list;
l_layers_list = gimp_image_get_layers(image_id, &l_nlayers);
if(l_layers_list != NULL)
{
if (stackpos < l_nlayers)
{
gint32 src_layer_id;
gdouble l_xresoulution, l_yresoulution;
gint32 l_unit;
src_layer_id = l_layers_list[stackpos];
dup_image_id = gimp_image_new (gimp_image_width(image_id)
, gimp_image_height(image_id)
, gimp_image_base_type(image_id)
);
gimp_image_get_resolution(image_id, &l_xresoulution, &l_yresoulution);
gimp_image_set_resolution(dup_image_id, l_xresoulution, l_yresoulution);
l_unit = gimp_image_get_unit(image_id);
gimp_image_set_unit(dup_image_id, l_unit);
resulting_layer = gap_layer_copy_to_image (dup_image_id, src_layer_id);
}
g_free (l_layers_list);
}
}
p_add_image_to_list_of_duplicated_images(dup_image_id, ffetch_user_id);
if (addToCache != TRUE)
{
GimpParasite *l_parasite;
l_parasite = gimp_image_parasite_find(image_id, GAP_IMAGE_CACHE_PARASITE);
if(l_parasite)
{
gimp_parasite_free(l_parasite);
}
else
{
/* the original image is not cached
* (delete it because the caller gets the preprocessed duplicate)
*/
gap_image_delete_immediate(image_id);
}
}
return(resulting_layer);
} /* end gap_frame_fetch_dup_image */
