-/*
- * Creates an GdkPixBuf from a Drawable
+/* GdkPixbuf library - convert X drawable information to RGB
*
- * Author:
- * Cody Russell <bratsche@dfw.net>
+ * Copyright (C) 1999 Michael Zucchi
+ *
+ * Authors: Michael Zucchi <zucchi@zedzone.mmc.com.au>
+ * Cody Russell <bratsche@dfw.net>
+ * Federico Mena-Quintero <federico@gimp.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gdkpixbuf.h"
+
+#include "gdkcolor.h"
+#include "gdkwindow.h"
+#include "gdkinternals.h"
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+/**
+ * SECTION:pixbufs
+ * @Short_description: Functions for obtaining pixbufs
+ * @Title: Pixbufs
+ *
+ * Pixbufs are client-side images. For details on how to create
+ * and manipulate pixbufs, see the #GdkPixbuf API documentation.
+ *
+ * The functions described here allow to obtain pixbufs from
+ * #GdkWindows and cairo surfaces.
+ */
+
+
+/**
+ * gdk_pixbuf_get_from_window:
+ * @window: Source window
+ * @src_x: Source X coordinate within @window
+ * @src_y: Source Y coordinate within @window
+ * @width: Width in pixels of region to get
+ * @height: Height in pixels of region to get
+ *
+ * Transfers image data from a #GdkWindow and converts it to an RGB(A)
+ * representation inside a #GdkPixbuf. In other words, copies
+ * image data from a server-side drawable to a client-side RGB(A) buffer.
+ * This allows you to efficiently read individual pixels on the client side.
+ *
+ * This function will create an RGB pixbuf with 8 bits per channel with
+ * the same size specified by the @width and @height arguments. The pixbuf
+ * will contain an alpha channel if the @window contains one.
+ *
+ * If the window is off the screen, then there is no image data in the
+ * obscured/offscreen regions to be placed in the pixbuf. The contents of
+ * portions of the pixbuf corresponding to the offscreen region are undefined.
+ *
+ * If the window you're obtaining data from is partially obscured by
+ * other windows, then the contents of the pixbuf areas corresponding
+ * to the obscured regions are undefined.
+ *
+ * If the window is not mapped (typically because it's iconified/minimized
+ * or not on the current workspace), then %NULL will be returned.
+ *
+ * If memory can't be allocated for the return value, %NULL will be returned
+ * instead.
+ *
+ * (In short, there are several ways this function can fail, and if it fails
+ * it returns %NULL; so check the return value.)
+ *
+ * Return value: (transfer full): A newly-created pixbuf with a reference
+ * count of 1, or %NULL on error
*/
-#include <config.h>
-#include <stdio.h>
-#include <string.h>
-#include <glib.h>
-#include <gmodule.h>
-#include "gdk-pixbuf.h"
-#include "gdk-pixbuf-drawable.h"
-
-/* private function */
-
-static GdkPixBuf *
-gdk_pixbuf_from_drawable_core (GdkWindow *window,
- gint x, gint y,
- gint width, gint height,
- gint with_alpha)
+GdkPixbuf *
+gdk_pixbuf_get_from_window (GdkWindow *src,
+ gint src_x,
+ gint src_y,
+ gint width,
+ gint height)
+{
+ cairo_surface_t *surface;
+ GdkPixbuf *dest;
+
+ g_return_val_if_fail (GDK_IS_WINDOW (src), NULL);
+ g_return_val_if_fail (gdk_window_is_viewable (src), NULL);
+
+ surface = _gdk_window_ref_cairo_surface (src);
+ dest = gdk_pixbuf_get_from_surface (surface,
+ src_x, src_y,
+ width, height);
+ cairo_surface_destroy (surface);
+
+ return dest;
+}
+
+static cairo_format_t
+gdk_cairo_format_for_content (cairo_content_t content)
+{
+ switch (content)
+ {
+ case CAIRO_CONTENT_COLOR:
+ return CAIRO_FORMAT_RGB24;
+ case CAIRO_CONTENT_ALPHA:
+ return CAIRO_FORMAT_A8;
+ case CAIRO_CONTENT_COLOR_ALPHA:
+ default:
+ return CAIRO_FORMAT_ARGB32;
+ }
+}
+
+static cairo_surface_t *
+gdk_cairo_surface_coerce_to_image (cairo_surface_t *surface,
+ cairo_content_t content,
+ int src_x,
+ int src_y,
+ int width,
+ int height)
{
- GdkImage *image;
- ArtPixBuf *art_pixbuf;
- GdkColormap *colormap;
- art_u8 *buff;
- art_u8 *pixels;
- gulong pixel;
- gint rowstride;
- art_u8 r, g, b;
- gint xx, yy;
- gint fatness;
- gint screen_width, screen_height;
- gint window_width, window_height, window_x, window_y;
-
- g_return_val_if_fail (window != NULL, NULL);
-
- screen_width = gdk_screen_width();
- screen_height = gdk_screen_height();
- gdk_window_get_geometry(window, NULL, NULL,
- &window_width, &window_height, NULL);
- gdk_window_get_origin(window, &window_x, &window_y);
-
- if(window_x < 0)
- {
- x = ABS(window_x);
- width = window_width - x;
- }
- else
- {
- width = CLAMP(window_x + window_width, window_x,
- screen_width) - window_x;
- }
-
- if(window_y < 0)
- {
- y = ABS(window_y);
- height = window_height - y;
- }
- else
- {
- height = CLAMP(window_y + window_height, window_y,
- screen_height) - window_y;
- }
-
- image = gdk_image_get (window, x, y, width, height);
- colormap = gdk_rgb_get_cmap ();
-
- fatness = with_alpha ? 4 : 3;
- rowstride = width * fatness;
-
- buff = art_alloc (rowstride * height);
- pixels = buff;
-
- switch (image->depth)
- {
- case 0:
- case 1:
- case 2:
- case 3:
- case 4:
- case 5:
- case 6:
- case 7:
- case 8:
- for (yy = 0; yy < height; yy++)
- {
- for (xx = 0; xx < width; xx++)
- {
- pixel = gdk_image_get_pixel (image, xx, yy);
- pixels[0] = colormap->colors[pixel].red;
- pixels[1] = colormap->colors[pixel].green;
- pixels[2] = colormap->colors[pixel].blue;
- if (with_alpha)
- pixels[3] = 0;
- pixels += fatness;
-
- }
- }
- break;
-
- case 16:
- case 15:
- for (yy = 0; yy < height; yy++)
- {
- for (xx = 0; xx < width; xx++)
- {
- pixel = gdk_image_get_pixel (image, xx, yy);
- r = (pixel >> 8) & 0xf8;
- g = (pixel >> 3) & 0xfc;
- b = (pixel << 3) & 0xf8;
- pixels[0] = r;
- pixels[1] = g;
- pixels[2] = b;
- if (with_alpha)
- pixels[3] = 0; /* GdkImages don't have alpha =) */
- pixels += fatness;
- }
- }
- break;
-
- case 24:
- case 32:
- for (yy = 0; yy < height; yy++)
- {
- for (xx = 0; xx < width; xx++)
- {
- pixel = gdk_image_get_pixel (image, xx, yy);
- r = (pixel >> 16) & 0xff;
- g = (pixel >> 8) & 0xff;
- b = pixel & 0xff;
- pixels[0] = r;
- pixels[1] = g;
- pixels[2] = b;
- if (with_alpha)
- pixels[3] = 0; /* GdkImages don't have alpha.. */
- pixels += fatness;
- }
- }
- break;
-
- default:
- g_error ("art_pixbuf_from_drawable_core (): Unknown depth.");
- }
-
- art_pixbuf = with_alpha ? art_pixbuf_new_rgba (buff, width, height, rowstride) :
- art_pixbuf_new_rgb (buff, width, height, rowstride);
-
- return gdk_pixbuf_new(art_pixbuf, NULL);
+ cairo_surface_t *copy;
+ cairo_t *cr;
+
+ copy = cairo_image_surface_create (gdk_cairo_format_for_content (content),
+ width,
+ height);
+
+ cr = cairo_create (copy);
+ cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+ cairo_set_source_surface (cr, surface, -src_x, -src_y);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+
+ return copy;
}
-/* Public functions */
+static void
+convert_alpha (guchar *dest_data,
+ int dest_stride,
+ guchar *src_data,
+ int src_stride,
+ int src_x,
+ int src_y,
+ int width,
+ int height)
+{
+ int x, y;
+
+ src_data += src_stride * src_y + src_x * 4;
+
+ for (y = 0; y < height; y++) {
+ guint32 *src = (guint32 *) src_data;
+
+ for (x = 0; x < width; x++) {
+ guint alpha = src[x] >> 24;
+
+ if (alpha == 0)
+ {
+ dest_data[x * 4 + 0] = 0;
+ dest_data[x * 4 + 1] = 0;
+ dest_data[x * 4 + 2] = 0;
+ }
+ else
+ {
+ dest_data[x * 4 + 0] = (((src[x] & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
+ dest_data[x * 4 + 1] = (((src[x] & 0x00ff00) >> 8) * 255 + alpha / 2) / alpha;
+ dest_data[x * 4 + 2] = (((src[x] & 0x0000ff) >> 0) * 255 + alpha / 2) / alpha;
+ }
+ dest_data[x * 4 + 3] = alpha;
+ }
+
+ src_data += src_stride;
+ dest_data += dest_stride;
+ }
+}
-GdkPixBuf *
-gdk_pixbuf_rgb_from_drawable (GdkWindow *window,
- gint x, gint y,
- gint width, gint height)
+static void
+convert_no_alpha (guchar *dest_data,
+ int dest_stride,
+ guchar *src_data,
+ int src_stride,
+ int src_x,
+ int src_y,
+ int width,
+ int height)
{
- return gdk_pixbuf_from_drawable_core (window, x, y, width, height, 0);
+ int x, y;
+
+ src_data += src_stride * src_y + src_x * 4;
+
+ for (y = 0; y < height; y++) {
+ guint32 *src = (guint32 *) src_data;
+
+ for (x = 0; x < width; x++) {
+ dest_data[x * 3 + 0] = src[x] >> 16;
+ dest_data[x * 3 + 1] = src[x] >> 8;
+ dest_data[x * 3 + 2] = src[x];
+ }
+
+ src_data += src_stride;
+ dest_data += dest_stride;
+ }
}
-
-GdkPixBuf *
-gdk_pixbuf_rgba_from_drawable (GdkWindow *window,
- gint x, gint y,
- gint width, gint height)
+
+/**
+ * gdk_pixbuf_get_from_surface:
+ * @surface: surface to copy from
+ * @src_x: Source X coordinate within @surface
+ * @src_y: Source Y coordinate within @surface
+ * @width: Width in pixels of region to get
+ * @height: Height in pixels of region to get
+ *
+ * Transfers image data from a #cairo_surface_t and converts it to an RGB(A)
+ * representation inside a #GdkPixbuf. This allows you to efficiently read
+ * individual pixels from cairo surfaces. For #GdkWindows, use
+ * gdk_pixbuf_get_from_window() instead.
+ *
+ * This function will create an RGB pixbuf with 8 bits per channel.
+ * The pixbuf will contain an alpha channel if the @surface contains one.
+ *
+ * Return value: (transfer full): A newly-created pixbuf with a reference
+ * count of 1, or %NULL on error
+ */
+GdkPixbuf *
+gdk_pixbuf_get_from_surface (cairo_surface_t *surface,
+ gint src_x,
+ gint src_y,
+ gint width,
+ gint height)
{
- return gdk_pixbuf_from_drawable_core (window, x, y, width, height, 1);
+ cairo_content_t content;
+ GdkPixbuf *dest;
+
+ /* General sanity checks */
+ g_return_val_if_fail (surface != NULL, NULL);
+ g_return_val_if_fail (width > 0 && height > 0, NULL);
+
+ content = cairo_surface_get_content (surface) | CAIRO_CONTENT_COLOR;
+ dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
+ !!(content & CAIRO_CONTENT_ALPHA),
+ 8,
+ width, height);
+
+ surface = gdk_cairo_surface_coerce_to_image (surface, content,
+ src_x, src_y,
+ width, height);
+ cairo_surface_flush (surface);
+ if (cairo_surface_status (surface) || dest == NULL)
+ {
+ cairo_surface_destroy (surface);
+ return NULL;
+ }
+
+ if (gdk_pixbuf_get_has_alpha (dest))
+ convert_alpha (gdk_pixbuf_get_pixels (dest),
+ gdk_pixbuf_get_rowstride (dest),
+ cairo_image_surface_get_data (surface),
+ cairo_image_surface_get_stride (surface),
+ 0, 0,
+ width, height);
+ else
+ convert_no_alpha (gdk_pixbuf_get_pixels (dest),
+ gdk_pixbuf_get_rowstride (dest),
+ cairo_image_surface_get_data (surface),
+ cairo_image_surface_get_stride (surface),
+ 0, 0,
+ width, height);
+
+ cairo_surface_destroy (surface);
+ return dest;
}
projects / ~andy / gtk / blobdiff