X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gdk%2Fgdkpixbuf-render.c;h=a702e2e7ca8d889f10f418a016738017be258b04;hb=397951cc856fff61332f6c4d108e5acb2cc9f8a9;hp=7b86f6e516f14b3292ec82355bad1fbc421782a7;hpb=0bee26c7bac6928f05f6d928407e03f5bddbddff;p=~andy%2Fgtk diff --git a/gdk/gdkpixbuf-render.c b/gdk/gdkpixbuf-render.c index 7b86f6e51..a702e2e7c 100644 --- a/gdk/gdkpixbuf-render.c +++ b/gdk/gdkpixbuf-render.c @@ -20,10 +20,13 @@ * Boston, MA 02111-1307, USA. */ -#include +#include "config.h" #include #include "gdk-pixbuf-private.h" #include "gdkpixbuf.h" +#include "gdkscreen.h" +#include "gdkinternals.h" +#include "gdkalias.h" @@ -35,8 +38,8 @@ * @src_y: source Y coordinate. * @dest_x: Destination X coordinate. * @dest_y: Destination Y coordinate. - * @width: Width of region to threshold. - * @height: Height of region to threshold. + * @width: Width of region to threshold, or -1 to use pixbuf width + * @height: Height of region to threshold, or -1 to use pixbuf height * @alpha_threshold: Opacity values below this will be painted as zero; all * other values will be painted as one. * @@ -60,11 +63,16 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, int start, start_status; int status; - g_return_if_fail (pixbuf != NULL); + g_return_if_fail (GDK_IS_PIXBUF (pixbuf)); g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB); g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4); g_return_if_fail (pixbuf->bits_per_sample == 8); + if (width == -1) + width = pixbuf->width; + if (height == -1) + height = pixbuf->height; + g_return_if_fail (bitmap != NULL); g_return_if_fail (width >= 0 && height >= 0); g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); @@ -75,14 +83,13 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, if (width == 0 || height == 0) return; - gc = gdk_gc_new (bitmap); + gc = _gdk_drawable_get_scratch_gc (bitmap, FALSE); if (!pixbuf->has_alpha) { color.pixel = (alpha_threshold == 255) ? 0 : 1; gdk_gc_set_foreground (gc, &color); gdk_draw_rectangle (bitmap, gc, TRUE, dest_x, dest_y, width, height); - gdk_gc_unref (gc); return; } @@ -124,8 +131,6 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, start + dest_x, y + dest_y, x - 1 + dest_x, y + dest_y); } - - gdk_gc_unref (gc); } @@ -139,8 +144,8 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, * @src_y: Source Y coordinate within pixbuf. * @dest_x: Destination X coordinate within drawable. * @dest_y: Destination Y coordinate within drawable. - * @width: Width of region to render, in pixels. - * @height: Height of region to render, in pixels. + * @width: Width of region to render, in pixels, or -1 to use pixbuf width + * @height: Height of region to render, in pixels, or -1 to use pixbuf height * @dither: Dithering mode for GdkRGB. * @x_dither: X offset for dither. * @y_dither: Y offset for dither. @@ -157,6 +162,8 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, * base position change, as in scrolling. The dither matrix has to be shifted * for consistent visual results. If you do not have any of these cases, the * dither offsets can be both zero. + * + * Deprecated: 2.4: This function is obsolete. Use gdk_draw_pixbuf() instead. **/ void gdk_pixbuf_render_to_drawable (GdkPixbuf *pixbuf, @@ -168,51 +175,9 @@ gdk_pixbuf_render_to_drawable (GdkPixbuf *pixbuf, GdkRgbDither dither, int x_dither, int y_dither) { - int rowstride; - guchar *buf; - - g_return_if_fail (pixbuf != NULL); - g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB); - g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4); - g_return_if_fail (pixbuf->bits_per_sample == 8); - - g_return_if_fail (drawable != NULL); - g_return_if_fail (gc != NULL); - - g_return_if_fail (width >= 0 && height >= 0); - g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); - g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); - - if (width == 0 || height == 0) - return; - - /* This will have to be modified once we support other image types. - */ - - if (pixbuf->n_channels == 4) - { - buf = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * 4; - rowstride = pixbuf->rowstride; - - gdk_draw_rgb_32_image_dithalign (drawable, gc, - dest_x, dest_y, - width, height, - dither, - buf, rowstride, - x_dither, y_dither); - } - else /* n_channels == 3 */ - { - buf = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * 3; - rowstride = pixbuf->rowstride; - - gdk_draw_rgb_image_dithalign (drawable, gc, - dest_x, dest_y, - width, height, - dither, - buf, rowstride, - x_dither, y_dither); - } + gdk_draw_pixbuf (drawable, gc, pixbuf, + src_x, src_y, dest_x, dest_y, width, height, + dither, x_dither, y_dither); } @@ -225,32 +190,23 @@ gdk_pixbuf_render_to_drawable (GdkPixbuf *pixbuf, * @src_y: Source Y coordinates within pixbuf. * @dest_x: Destination X coordinate within drawable. * @dest_y: Destination Y coordinate within drawable. - * @width: Width of region to render, in pixels. - * @height: Height of region to render, in pixels. - * @alpha_mode: If the image does not have opacity information, this is ignored. - * Otherwise, specifies how to handle transparency when rendering. - * @alpha_threshold: If the image does have opacity information and @alpha_mode - * is GDK_PIXBUF_ALPHA_BILEVEL, specifies the threshold value for opacity - * values. + * @width: Width of region to render, in pixels, or -1 to use pixbuf width. + * @height: Height of region to render, in pixels, or -1 to use pixbuf height. + * @alpha_mode: Ignored. Present for backwards compatibility. + * @alpha_threshold: Ignored. Present for backwards compatibility * @dither: Dithering mode for GdkRGB. * @x_dither: X offset for dither. * @y_dither: Y offset for dither. * - * Renders a rectangular portion of a pixbuf to a drawable. This is done using - * GdkRGB, so the specified drawable must have the GdkRGB visual and colormap. + * Renders a rectangular portion of a pixbuf to a drawable. The destination + * drawable must have a colormap. All windows have a colormap, however, pixmaps + * only have colormap by default if they were created with a non-%NULL window argument. + * Otherwise a colormap must be set on them with gdk_drawable_set_colormap. * - * When used with #GDK_PIXBUF_ALPHA_BILEVEL, this function has to create a bitmap - * out of the thresholded alpha channel of the image and, it has to set this - * bitmap as the clipping mask for the GC used for drawing. This can be a - * significant performance penalty depending on the size and the complexity of - * the alpha channel of the image. If performance is crucial, consider handling - * the alpha channel yourself (possibly by caching it in your application) and - * using gdk_pixbuf_render_to_drawable() or GdkRGB directly instead. + * On older X servers, rendering pixbufs with an alpha channel involves round trips + * to the X server, and may be somewhat slow. * - * The #GDK_PIXBUF_ALPHA_FULL mode involves round trips to the X - * server, and may also be somewhat slow in its current implementation - * (though in the future it could be made significantly faster, in - * principle). + * Deprecated: 2.4: This function is obsolete. Use gdk_draw_pixbuf() instead. **/ void gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, @@ -263,177 +219,33 @@ gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, GdkRgbDither dither, int x_dither, int y_dither) { - GdkBitmap *bitmap = NULL; - GdkGC *gc; - GdkPixbuf *composited = NULL; - gint dwidth, dheight; - GdkRegion *clip; - GdkRegion *drect; - GdkRectangle tmp_rect; - - g_return_if_fail (pixbuf != NULL); - g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB); - g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4); - g_return_if_fail (pixbuf->bits_per_sample == 8); - - g_return_if_fail (drawable != NULL); - g_return_if_fail (width >= 0 && height >= 0); - g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); - g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); - - /* Clip to the drawable; this is required for get_from_drawable() so - * can't be done implicitly - */ - - if (dest_x < 0) - { - src_x -= dest_x; - width += dest_x; - dest_x = 0; - } - - if (dest_y < 0) - { - src_y -= dest_y; - height += dest_y; - dest_y = 0; - } - - gdk_drawable_get_size (drawable, &dwidth, &dheight); - - if ((dest_x + width) > dwidth) - width = dwidth - dest_x; - - if ((dest_y + height) > dheight) - height = dheight - dest_y; - - if (width <= 0 || height <= 0) - return; - - /* Clip to the clip region; this avoids getting more - * image data from the server than we need to. - */ - - tmp_rect.x = dest_x; - tmp_rect.y = dest_y; - tmp_rect.width = width; - tmp_rect.height = height; - - drect = gdk_region_rectangle (&tmp_rect); - clip = gdk_drawable_get_clip_region (drawable); - - gdk_region_intersect (drect, clip); - - gdk_region_get_clipbox (drect, &tmp_rect); - - gdk_region_destroy (drect); - gdk_region_destroy (clip); - - if (tmp_rect.width == 0 || - tmp_rect.height == 0) - return; - - /* Actually draw */ - - gc = gdk_gc_new (drawable); - - if (pixbuf->has_alpha) - { - if (alpha_mode == GDK_PIXBUF_ALPHA_FULL) - { - GdkPixbuf *sub = NULL; - - composited = gdk_pixbuf_get_from_drawable (NULL, - drawable, - NULL, - dest_x, dest_y, - 0, 0, - width, height); - - if (composited) - { - if (src_x != 0 || src_y != 0) - { - sub = gdk_pixbuf_new_subpixbuf (pixbuf, src_x, src_y, - width, height); - } - - gdk_pixbuf_composite (sub ? sub : pixbuf, - composited, - 0, 0, - width, height, - 0, 0, - 1.0, 1.0, - GDK_INTERP_BILINEAR, - 255); - - if (sub) - g_object_unref (G_OBJECT (sub)); - } - else - alpha_mode = GDK_PIXBUF_ALPHA_BILEVEL; /* fall back */ - } - - if (alpha_mode == GDK_PIXBUF_ALPHA_BILEVEL) - { - bitmap = gdk_pixmap_new (NULL, width, height, 1); - gdk_pixbuf_render_threshold_alpha (pixbuf, bitmap, - src_x, src_y, - 0, 0, - width, height, - alpha_threshold); - - gdk_gc_set_clip_mask (gc, bitmap); - gdk_gc_set_clip_origin (gc, dest_x, dest_y); - } - } - - if (composited) - { - gdk_pixbuf_render_to_drawable (composited, - drawable, gc, - 0, 0, - dest_x, dest_y, - width, height, - dither, - x_dither, y_dither); - } - else - { - gdk_pixbuf_render_to_drawable (pixbuf, - drawable, gc, - src_x, src_y, - dest_x, dest_y, - width, height, - dither, - x_dither, y_dither); - } - - if (bitmap) - gdk_bitmap_unref (bitmap); - - if (composited) - g_object_unref (G_OBJECT (composited)); - - gdk_gc_unref (gc); + gdk_draw_pixbuf (drawable, NULL, pixbuf, + src_x, src_y, dest_x, dest_y, width, height, + dither, x_dither, y_dither); } /** * gdk_pixbuf_render_pixmap_and_mask: * @pixbuf: A pixbuf. - * @pixmap_return: Return value for the created pixmap. - * @mask_return: Return value for the created mask. + * @pixmap_return: Location to store a pointer to the created pixmap, + * or %NULL if the pixmap is not needed. + * @mask_return: Location to store a pointer to the created mask, + * or %NULL if the mask is not needed. * @alpha_threshold: Threshold value for opacity values. * * Creates a pixmap and a mask bitmap which are returned in the @pixmap_return * and @mask_return arguments, respectively, and renders a pixbuf and its - * corresponding tresholded alpha mask to them. This is merely a convenience + * corresponding thresholded alpha mask to them. This is merely a convenience * function; applications that need to render pixbufs with dither offsets or to - * given drawables should use gdk_pixbuf_render_to_drawable_alpha() or - * gdk_pixbuf_render_to_drawable(), and gdk_pixbuf_render_threshold_alpha(). + * given drawables should use gdk_draw_pixbuf() and gdk_pixbuf_render_threshold_alpha(). + * + * The pixmap that is created is created for the colormap returned + * by gdk_rgb_get_colormap(). You normally will want to instead use + * the actual colormap for a widget, and use + * gdk_pixbuf_render_pixmap_and_mask_for_colormap(). * * If the pixbuf does not have an alpha channel, then *@mask_return will be set - * to NULL. + * to %NULL. **/ void gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf, @@ -441,34 +253,95 @@ gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf, GdkBitmap **mask_return, int alpha_threshold) { - g_return_if_fail (pixbuf != NULL); + gdk_pixbuf_render_pixmap_and_mask_for_colormap (pixbuf, + gdk_rgb_get_colormap (), + pixmap_return, mask_return, + alpha_threshold); +} + +/** + * gdk_pixbuf_render_pixmap_and_mask_for_colormap: + * @pixbuf: A pixbuf. + * @colormap: A #GdkColormap + * @pixmap_return: Location to store a pointer to the created pixmap, + * or %NULL if the pixmap is not needed. + * @mask_return: Location to store a pointer to the created mask, + * or %NULL if the mask is not needed. + * @alpha_threshold: Threshold value for opacity values. + * + * Creates a pixmap and a mask bitmap which are returned in the @pixmap_return + * and @mask_return arguments, respectively, and renders a pixbuf and its + * corresponding tresholded alpha mask to them. This is merely a convenience + * function; applications that need to render pixbufs with dither offsets or to + * given drawables should use gdk_draw_pixbuf(), and gdk_pixbuf_render_threshold_alpha(). + * + * The pixmap that is created uses the #GdkColormap specified by @colormap. + * This colormap must match the colormap of the window where the pixmap + * will eventually be used or an error will result. + * + * If the pixbuf does not have an alpha channel, then *@mask_return will be set + * to %NULL. + **/ +void +gdk_pixbuf_render_pixmap_and_mask_for_colormap (GdkPixbuf *pixbuf, + GdkColormap *colormap, + GdkPixmap **pixmap_return, + GdkBitmap **mask_return, + int alpha_threshold) +{ + GdkScreen *screen; + + g_return_if_fail (GDK_IS_PIXBUF (pixbuf)); + g_return_if_fail (GDK_IS_COLORMAP (colormap)); + + screen = gdk_colormap_get_screen (colormap); if (pixmap_return) { GdkGC *gc; - - *pixmap_return = gdk_pixmap_new (NULL, pixbuf->width, pixbuf->height, - gdk_rgb_get_visual ()->depth); - gc = gdk_gc_new (*pixmap_return); - gdk_pixbuf_render_to_drawable (pixbuf, *pixmap_return, gc, - 0, 0, 0, 0, - pixbuf->width, pixbuf->height, - GDK_RGB_DITHER_NORMAL, - 0, 0); - gdk_gc_unref (gc); + *pixmap_return = gdk_pixmap_new (gdk_screen_get_root_window (screen), + gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), + gdk_colormap_get_visual (colormap)->depth); + + gdk_drawable_set_colormap (GDK_DRAWABLE (*pixmap_return), colormap); + gc = _gdk_drawable_get_scratch_gc (*pixmap_return, FALSE); + + /* If the pixbuf has an alpha channel, using gdk_pixbuf_draw would give + * random pixel values in the area that are within the mask, but semi- + * transparent. So we treat the pixbuf like a pixbuf without alpha channel; + * see bug #487865. + */ + if (gdk_pixbuf_get_has_alpha (pixbuf)) + gdk_draw_rgb_32_image (*pixmap_return, gc, + 0, 0, + gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), + GDK_RGB_DITHER_NORMAL, + gdk_pixbuf_get_pixels (pixbuf), gdk_pixbuf_get_rowstride (pixbuf)); + else + gdk_draw_pixbuf (*pixmap_return, gc, pixbuf, + 0, 0, 0, 0, + gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), + GDK_RGB_DITHER_NORMAL, + 0, 0); } if (mask_return) { - if (pixbuf->has_alpha) + if (gdk_pixbuf_get_has_alpha (pixbuf)) { - *mask_return = gdk_pixmap_new (NULL, pixbuf->width, pixbuf->height, 1); + *mask_return = gdk_pixmap_new (gdk_screen_get_root_window (screen), + gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), 1); + gdk_pixbuf_render_threshold_alpha (pixbuf, *mask_return, 0, 0, 0, 0, - pixbuf->width, pixbuf->height, + gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), alpha_threshold); } else *mask_return = NULL; } } + +#define __GDK_PIXBUF_RENDER_C__ +#include "gdkaliasdef.c" +