static void
rotate_cb (GtkWidget *w, gint type)
{
GdkPixbuf *new_pb = NULL;
GdkPixbuf *pb = gtk_image_get_pixbuf (GTK_IMAGE (picture));
if (!pb)
{
g_printerr ("picture: can't get pixbuf\n");
return;
}
switch (type)
{
case ROTATE_LEFT:
new_pb = gdk_pixbuf_rotate_simple (pb, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
break;
case ROTATE_RIGHT:
new_pb = gdk_pixbuf_rotate_simple (pb, GDK_PIXBUF_ROTATE_CLOCKWISE);
break;
case ROTATE_FLIP_VERT:
new_pb = gdk_pixbuf_flip (pb, FALSE);
break;
case ROTATE_FLIP_HOR:
new_pb = gdk_pixbuf_flip (pb, TRUE);
break;
}
if (new_pb)
{
gtk_image_set_from_pixbuf (GTK_IMAGE (picture), new_pb);
g_object_unref (pb);
}
}
/*
* Returns a transformed image.
*/
GdkPixbuf *
_gdk_pixbuf_transform (GdkPixbuf *src,
GthTransform transform)
{
GdkPixbuf *temp = NULL, *dest = NULL;
if (src == NULL)
return NULL;
switch (transform) {
case GTH_TRANSFORM_NONE:
dest = src;
g_object_ref (dest);
break;
case GTH_TRANSFORM_FLIP_H:
dest = gdk_pixbuf_flip (src, TRUE);
break;
case GTH_TRANSFORM_ROTATE_180:
dest = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_UPSIDEDOWN);
break;
case GTH_TRANSFORM_FLIP_V:
dest = gdk_pixbuf_flip (src, FALSE);
break;
case GTH_TRANSFORM_TRANSPOSE:
temp = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_CLOCKWISE);
dest = gdk_pixbuf_flip (temp, TRUE);
g_object_unref (temp);
break;
case GTH_TRANSFORM_ROTATE_90:
dest = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_CLOCKWISE);
break;
case GTH_TRANSFORM_TRANSVERSE:
temp = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_CLOCKWISE);
dest = gdk_pixbuf_flip (temp, FALSE);
g_object_unref (temp);
break;
case GTH_TRANSFORM_ROTATE_270:
dest = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
break;
default:
dest = src;
g_object_ref (dest);
break;
}
return dest;
}
/* ----------------------------------------------------
* p_replace_pixbuf_by_flipped_pixbuf
* ----------------------------------------------------
*/
static void
p_replace_pixbuf_by_flipped_pixbuf(GapPView *pv_ptr, gint32 flip_to_perform)
{
GdkPixbuf *flipped_pixbuf;
gboolean horizontal;
if(pv_ptr->pixbuf == NULL)
{
printf("ERROR cant flip pv_ptr->pixbuf becaus it is NULL\n");
return;
}
flipped_pixbuf = NULL;
switch(flip_to_perform)
{
case GAP_STB_FLIP_HOR:
horizontal = TRUE;
flipped_pixbuf = gdk_pixbuf_flip(pv_ptr->pixbuf
,horizontal
);
break;
case GAP_STB_FLIP_VER:
horizontal = FALSE;
flipped_pixbuf = gdk_pixbuf_flip(pv_ptr->pixbuf
,horizontal
);
break;
case GAP_STB_FLIP_BOTH:
flipped_pixbuf = gdk_pixbuf_rotate_simple (pv_ptr->pixbuf
,GDK_PIXBUF_ROTATE_UPSIDEDOWN
);
break;
default:
break;
}
if(flipped_pixbuf)
{
/* free old (refresh) pixbuf if there is one
* and replace by fliped variant
*/
g_object_unref(pv_ptr->pixbuf);
pv_ptr->pixbuf = flipped_pixbuf;
}
} /* end p_replace_pixbuf_by_flipped_pixbuf */
static gboolean
ensure_filmholes (void)
{
if (filmholes_left == NULL) {
filmholes_left = gdk_pixbuf_new_from_resource ("/org/gnome/nautilus/icons/filmholes.png", NULL);
}
if (filmholes_right == NULL &&
filmholes_left != NULL) {
filmholes_right = gdk_pixbuf_flip (filmholes_left, TRUE);
}
return (filmholes_left && filmholes_right);
}
static GdkPixbuf *
add_holes_to_pixbuf_small (GdkPixbuf *pixbuf, int width, int height)
{
GdkPixbuf *holes, *tmp, *target;
char *filename;
int i;
filename = g_build_filename (DATADIR, "xplayer", "filmholes.png", NULL);
holes = gdk_pixbuf_new_from_file (filename, NULL);
g_free (filename);
if (holes == NULL) {
g_object_ref (pixbuf);
return pixbuf;
}
g_assert (gdk_pixbuf_get_has_alpha (pixbuf) == FALSE);
g_assert (gdk_pixbuf_get_has_alpha (holes) != FALSE);
target = g_object_ref (pixbuf);
for (i = 0; i < height; i += gdk_pixbuf_get_height (holes))
{
gdk_pixbuf_composite (holes, target, 0, i,
MIN (width, gdk_pixbuf_get_width (holes)),
MIN (height - i, gdk_pixbuf_get_height (holes)),
0, i, 1, 1, GDK_INTERP_NEAREST, 255);
}
tmp = gdk_pixbuf_flip (holes, FALSE);
g_object_unref (holes);
holes = tmp;
for (i = 0; i < height; i += gdk_pixbuf_get_height (holes))
{
gdk_pixbuf_composite (holes, target,
width - gdk_pixbuf_get_width (holes), i,
MIN (width, gdk_pixbuf_get_width (holes)),
MIN (height - i, gdk_pixbuf_get_height (holes)),
width - gdk_pixbuf_get_width (holes), i,
1, 1, GDK_INTERP_NEAREST, 255);
}
g_object_unref (holes);
return target;
}
/**
* gdk_pixbuf_apply_embedded_orientation:
* @src: A #GdkPixbuf.
*
* Takes an existing pixbuf and checks for the presence of an
* associated "orientation" option, which may be provided by the
* jpeg loader (which reads the exif orientation tag) or the
* tiff loader (which reads the tiff orientation tag, and
* compensates it for the partial transforms performed by
* libtiff). If an orientation option/tag is present, the
* appropriate transform will be performed so that the pixbuf
* is oriented correctly.
*
* Return value: (transfer full): A newly-created pixbuf, or a reference to the
* input pixbuf (with an increased reference count).
*
* Since: 2.12
**/
GdkPixbuf *
gdk_pixbuf_apply_embedded_orientation (GdkPixbuf *src)
{
const gchar *orientation_string;
int transform = 0;
GdkPixbuf *temp;
GdkPixbuf *dest;
g_return_val_if_fail (GDK_IS_PIXBUF (src), NULL);
/* Read the orientation option associated with the pixbuf */
orientation_string = gdk_pixbuf_get_option (src, "orientation");
if (orientation_string) {
/* If an orientation option was found, convert the
orientation string into an integer. */
transform = (int) g_ascii_strtoll (orientation_string, NULL, 10);
}
/* Apply the actual transforms, which involve rotations and flips.
The meaning of orientation values 1-8 and the required transforms
are defined by the TIFF and EXIF (for JPEGs) standards. */
switch (transform) {
case 1:
dest = src;
g_object_ref (dest);
break;
case 2:
dest = gdk_pixbuf_flip (src, TRUE);
break;
case 3:
dest = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_UPSIDEDOWN);
break;
case 4:
dest = gdk_pixbuf_flip (src, FALSE);
break;
case 5:
temp = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_CLOCKWISE);
dest = gdk_pixbuf_flip (temp, TRUE);
g_object_unref (temp);
break;
case 6:
dest = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_CLOCKWISE);
break;
case 7:
temp = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_CLOCKWISE);
dest = gdk_pixbuf_flip (temp, FALSE);
g_object_unref (temp);
break;
case 8:
dest = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
break;
default:
/* if no orientation tag was present */
dest = src;
g_object_ref (dest);
break;
}
return dest;
}
GdkCursor *
gimp_cursor_new (GdkDisplay *display,
GimpHandedness cursor_handedness,
GimpCursorType cursor_type,
GimpToolCursorType tool_cursor,
GimpCursorModifier modifier)
{
GimpCursor *bmcursor = NULL;
GimpCursor *bmmodifier = NULL;
GimpCursor *bmtool = NULL;
GdkCursor *cursor;
GdkPixbuf *pixbuf;
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
g_return_val_if_fail (cursor_type < GIMP_CURSOR_LAST, NULL);
if (cursor_type <= (GimpCursorType) GDK_LAST_CURSOR)
return gdk_cursor_new_for_display (display, (GdkCursorType) cursor_type);
g_return_val_if_fail (cursor_type >= GIMP_CURSOR_NONE, NULL);
/* disallow the small tool cursor with some cursors
*/
if (cursor_type <= GIMP_CURSOR_NONE ||
cursor_type == GIMP_CURSOR_CROSSHAIR ||
cursor_type == GIMP_CURSOR_ZOOM ||
cursor_type == GIMP_CURSOR_COLOR_PICKER ||
cursor_type >= GIMP_CURSOR_LAST)
{
tool_cursor = GIMP_TOOL_CURSOR_NONE;
}
/* don't allow anything with the empty cursor
*/
if (cursor_type == GIMP_CURSOR_NONE)
{
tool_cursor = GIMP_TOOL_CURSOR_NONE;
modifier = GIMP_CURSOR_MODIFIER_NONE;
}
/* some more sanity checks
*/
if (cursor_type == GIMP_CURSOR_MOVE &&
modifier == GIMP_CURSOR_MODIFIER_MOVE)
{
modifier = GIMP_CURSOR_MODIFIER_NONE;
}
/* when cursor is "corner" or "side" sides must be exchanged for
* left-hand-mice-flipping of pixbuf below
*/
if (cursor_handedness == GIMP_HANDEDNESS_LEFT)
{
switch (cursor_type)
{
case GIMP_CURSOR_CORNER_TOP_LEFT:
cursor_type = GIMP_CURSOR_CORNER_TOP_RIGHT; break;
case GIMP_CURSOR_CORNER_TOP_RIGHT:
cursor_type = GIMP_CURSOR_CORNER_TOP_LEFT; break;
case GIMP_CURSOR_CORNER_LEFT:
cursor_type = GIMP_CURSOR_CORNER_RIGHT; break;
case GIMP_CURSOR_CORNER_RIGHT:
cursor_type = GIMP_CURSOR_CORNER_LEFT; break;
case GIMP_CURSOR_CORNER_BOTTOM_LEFT:
cursor_type = GIMP_CURSOR_CORNER_BOTTOM_RIGHT; break;
case GIMP_CURSOR_CORNER_BOTTOM_RIGHT:
cursor_type = GIMP_CURSOR_CORNER_BOTTOM_LEFT; break;
case GIMP_CURSOR_SIDE_TOP_LEFT:
cursor_type = GIMP_CURSOR_SIDE_TOP_RIGHT; break;
case GIMP_CURSOR_SIDE_TOP_RIGHT:
cursor_type = GIMP_CURSOR_SIDE_TOP_LEFT; break;
case GIMP_CURSOR_SIDE_LEFT:
cursor_type = GIMP_CURSOR_SIDE_RIGHT; break;
case GIMP_CURSOR_SIDE_RIGHT:
cursor_type = GIMP_CURSOR_SIDE_LEFT; break;
case GIMP_CURSOR_SIDE_BOTTOM_LEFT:
cursor_type = GIMP_CURSOR_SIDE_BOTTOM_RIGHT; break;
case GIMP_CURSOR_SIDE_BOTTOM_RIGHT:
cursor_type = GIMP_CURSOR_SIDE_BOTTOM_LEFT; break;
default:
break;
}
}
/* prepare the main cursor */
cursor_type -= GIMP_CURSOR_NONE;
bmcursor = &gimp_cursors[cursor_type];
/* prepare the tool cursor */
if (tool_cursor > GIMP_TOOL_CURSOR_NONE &&
tool_cursor < GIMP_TOOL_CURSOR_LAST)
{
bmtool = &gimp_tool_cursors[tool_cursor];
}
/* prepare the cursor modifier */
if (modifier > GIMP_CURSOR_MODIFIER_NONE &&
modifier < GIMP_CURSOR_MODIFIER_LAST)
{
bmmodifier = &gimp_cursor_modifiers[modifier];
}
pixbuf = gdk_pixbuf_copy (get_cursor_pixbuf (bmcursor));
if (bmmodifier || bmtool)
{
gint width = gdk_pixbuf_get_width (pixbuf);
gint height = gdk_pixbuf_get_height (pixbuf);
if (bmmodifier)
gdk_pixbuf_composite (get_cursor_pixbuf (bmmodifier), pixbuf,
0, 0, width, height,
0.0, 0.0, 1.0, 1.0,
GDK_INTERP_NEAREST, 200);
if (bmtool)
gdk_pixbuf_composite (get_cursor_pixbuf (bmtool), pixbuf,
0, 0, width, height,
0.0, 0.0, 1.0, 1.0,
GDK_INTERP_NEAREST, 200);
}
/* flip the cursor if mouse setting is left-handed */
if (cursor_handedness == GIMP_HANDEDNESS_LEFT)
{
GdkPixbuf *flipped = gdk_pixbuf_flip (pixbuf, TRUE);
gint width = gdk_pixbuf_get_width (flipped);
cursor = gdk_cursor_new_from_pixbuf (display, flipped,
(width - 1) - bmcursor->x_hot,
bmcursor->y_hot);
g_object_unref (flipped);
}
else
{
cursor = gdk_cursor_new_from_pixbuf (display, pixbuf,
bmcursor->x_hot,
bmcursor->y_hot);
}
g_object_unref (pixbuf);
return cursor;
}
static GdkPixbuf* reorient_with_exif( producer_pixbuf self, int image_idx, GdkPixbuf *pixbuf )
{
#ifdef USE_EXIF
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( &self->parent );
ExifData *d = exif_data_new_from_file( mlt_properties_get_value( self->filenames, image_idx ) );
ExifEntry *entry;
int exif_orientation = 0;
/* get orientation and rotate image accordingly if necessary */
if (d)
{
if ( ( entry = exif_content_get_entry ( d->ifd[EXIF_IFD_0], EXIF_TAG_ORIENTATION ) ) )
exif_orientation = exif_get_short (entry->data, exif_data_get_byte_order (d));
/* Free the EXIF data */
exif_data_unref(d);
}
// Remember EXIF value, might be useful for someone
mlt_properties_set_int( producer_props, "_exif_orientation" , exif_orientation );
if ( exif_orientation > 1 )
{
GdkPixbuf *processed = NULL;
GdkPixbufRotation matrix = GDK_PIXBUF_ROTATE_NONE;
// Rotate image according to exif data
switch ( exif_orientation ) {
case 2:
processed = gdk_pixbuf_flip ( pixbuf, TRUE );
break;
case 3:
matrix = GDK_PIXBUF_ROTATE_UPSIDEDOWN;
processed = pixbuf;
break;
case 4:
processed = gdk_pixbuf_flip ( pixbuf, FALSE );
break;
case 5:
matrix = GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE;
processed = gdk_pixbuf_flip ( pixbuf, TRUE );
break;
case 6:
matrix = GDK_PIXBUF_ROTATE_CLOCKWISE;
processed = pixbuf;
break;
case 7:
matrix = GDK_PIXBUF_ROTATE_CLOCKWISE;
processed = gdk_pixbuf_flip ( pixbuf, TRUE );
break;
case 8:
matrix = GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE;
processed = pixbuf;
break;
}
if ( processed )
{
pixbuf = gdk_pixbuf_rotate_simple( processed, matrix );
g_object_unref( processed );
}
}
#endif
return pixbuf;
}