gdkcairo.c 12.6 KB
Newer Older
Cody Russell's avatar
Cody Russell committed
1
/* GDK - The GIMP Drawing Kit
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 * Copyright (C) 2005 Red Hat, Inc. 
 *
 * 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, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

20
#include "config.h"
21

22
#include "gdkcairo.h"
23

24 25
#include "gdkdrawable.h"
#include "gdkinternals.h"
26

27
#include <math.h>
28

29 30 31 32 33 34 35
/**
 * SECTION:cairo_interaction
 * @Short_description: Functions to support using Cairo
 * @Title: Cairo Interaction
 *
 * <link href="http://cairographics.org">Cairo</link> is a graphics
 * library that supports vector graphics and image compositing that
36
 * can be used with GDK. GTK+ does all of its drawing using Cairo.
37 38
 *
 * GDK does not wrap the Cairo API, instead it allows to create Cairo
39 40 41
 * contexts which can be used to draw on #GdkWindows. Additional
 * functions allow use #GdkRectangles with cairo and to use #GdkColors,
 * #GdkPixbufs and #GdkWindows as sources for drawing operations.
42 43 44
 */


45 46 47 48 49 50
/**
 * gdk_cairo_create:
 * @drawable: a #GdkDrawable
 * 
 * Creates a Cairo context for drawing to @drawable.
 *
51 52 53 54 55 56
 * <note><para>
 * Note that due to double-buffering, Cairo contexts created 
 * in a GTK+ expose event handler cannot be cached and reused 
 * between different expose events. 
 * </para></note>
 *
57 58 59
 * Return value: A newly created Cairo context. Free with
 *  cairo_destroy() when you are done drawing.
 * 
Matthias Clasen's avatar
Matthias Clasen committed
60
 * Since: 2.8
61 62 63 64 65 66 67 68 69 70 71
 **/
cairo_t *
gdk_cairo_create (GdkDrawable *drawable)
{
  cairo_surface_t *surface;
  cairo_t *cr;
    
  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);

  surface = _gdk_drawable_ref_cairo_surface (drawable);
  cr = cairo_create (surface);
72 73 74 75

  if (GDK_DRAWABLE_GET_CLASS (drawable)->set_cairo_clip)
    GDK_DRAWABLE_GET_CLASS (drawable)->set_cairo_clip (drawable, cr);
    
76 77 78 79 80
  cairo_surface_destroy (surface);

  return cr;
}

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
/**
 * gdk_cairo_get_clip_rectangle:
 * @cr: a cairo context
 * @rect: (out) (allow-none): return location for the clip, or %NULL
 *
 * This is a convenience function around cairo_clip_extents(). It rounds
 * the clip extents to integer coordinates and returns a boolean
 * indicating if a clip area exists.
 *
 * Returns: %TRUE if a clip rectangle exists, %FALSE if all of @cr is
 * clipped and all drawing can be skipped.
 **/
gboolean
gdk_cairo_get_clip_rectangle (cairo_t      *cr,
                              GdkRectangle *rect)
{
  double x1, y1, x2, y2;
  gboolean clip_exists;

  cairo_clip_extents (cr, &x1, &y1, &x2, &y2);

  clip_exists = x1 < x2 && y1 < y2;

  if (rect)
    {
      x1 = floor (x1);
      y1 = floor (y1);
      x2 = ceil (x2);
      y2 = ceil (y2);

      rect->x      = CLAMP (x1,      G_MININT, G_MAXINT);
      rect->y      = CLAMP (y1,      G_MININT, G_MAXINT);
      rect->width  = CLAMP (x2 - x1, G_MININT, G_MAXINT);
      rect->height = CLAMP (y2 - y1, G_MININT, G_MAXINT);
    }

  return clip_exists;
}

120 121 122 123 124 125 126 127 128 129
/**
 * gdk_cairo_set_source_color:
 * @cr: a #cairo_t
 * @color: a #GdkColor
 * 
 * Sets the specified #GdkColor as the source color of @cr.
 *
 * Since: 2.8
 **/
void
130 131
gdk_cairo_set_source_color (cairo_t        *cr,
			    const GdkColor *color)
132 133 134 135 136 137 138 139 140 141
{
  g_return_if_fail (cr != NULL);
  g_return_if_fail (color != NULL);
    
  cairo_set_source_rgb (cr,
			color->red / 65535.,
			color->green / 65535.,
			color->blue / 65535.);
}

142 143 144 145 146 147 148 149 150 151 152 153 154 155
void
gdk_cairo_set_source_rgba (cairo_t       *cr,
                           const GdkRGBA *rgba)
{
  g_return_if_fail (cr != NULL);
  g_return_if_fail (rgba != NULL);

  cairo_set_source_rgba (cr,
                         rgba->red,
                         rgba->green,
                         rgba->blue,
                         rgba->alpha);
}

156 157 158 159 160 161
/**
 * gdk_cairo_rectangle:
 * @cr: a #cairo_t
 * @rectangle: a #GdkRectangle
 * 
 * Adds the given rectangle to the current path of @cr.
Matthias Clasen's avatar
Matthias Clasen committed
162 163
 *
 * Since: 2.8
164 165
 **/
void
166 167
gdk_cairo_rectangle (cairo_t            *cr,
		     const GdkRectangle *rectangle)
168 169 170 171 172 173 174 175 176 177 178 179
{
  g_return_if_fail (cr != NULL);
  g_return_if_fail (rectangle != NULL);

  cairo_rectangle (cr,
		   rectangle->x,     rectangle->y,
		   rectangle->width, rectangle->height);
}

/**
 * gdk_cairo_region:
 * @cr: a #cairo_t
180
 * @region: a #cairo_region_t
181 182
 * 
 * Adds the given region to the current path of @cr.
Matthias Clasen's avatar
Matthias Clasen committed
183 184
 *
 * Since: 2.8
185 186
 **/
void
187
gdk_cairo_region (cairo_t         *cr,
188
		  const cairo_region_t *region)
189
{
190
  cairo_rectangle_int_t box;
191 192 193 194 195
  gint n_boxes, i;

  g_return_if_fail (cr != NULL);
  g_return_if_fail (region != NULL);

196
  n_boxes = cairo_region_num_rectangles (region);
197 198

  for (i = 0; i < n_boxes; i++)
199 200 201 202
    {
      cairo_region_get_rectangle (region, i, &box);
      cairo_rectangle (cr, box.x, box.y, box.width, box.height);
    }
203 204 205 206 207 208 209 210 211 212 213 214
}

/**
 * gdk_cairo_set_source_pixbuf:
 * @cr: a #Cairo context
 * @pixbuf: a #GdkPixbuf
 * @pixbuf_x: X coordinate of location to place upper left corner of @pixbuf
 * @pixbuf_y: Y coordinate of location to place upper left corner of @pixbuf
 * 
 * Sets the given pixbuf as the source pattern for the Cairo context.
 * The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned
 * so that the origin of @pixbuf is @pixbuf_x, @pixbuf_y
Matthias Clasen's avatar
Matthias Clasen committed
215 216
 *
 * Since: 2.8
217 218
 **/
void
219 220 221 222
gdk_cairo_set_source_pixbuf (cairo_t         *cr,
			     const GdkPixbuf *pixbuf,
			     double           pixbuf_x,
			     double           pixbuf_y)
223 224 225 226 227 228
{
  gint width = gdk_pixbuf_get_width (pixbuf);
  gint height = gdk_pixbuf_get_height (pixbuf);
  guchar *gdk_pixels = gdk_pixbuf_get_pixels (pixbuf);
  int gdk_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
  int n_channels = gdk_pixbuf_get_n_channels (pixbuf);
229
  int cairo_stride;
230 231 232 233 234 235 236 237 238 239 240
  guchar *cairo_pixels;
  cairo_format_t format;
  cairo_surface_t *surface;
  static const cairo_user_data_key_t key;
  int j;

  if (n_channels == 3)
    format = CAIRO_FORMAT_RGB24;
  else
    format = CAIRO_FORMAT_ARGB32;

241 242
  cairo_stride = cairo_format_stride_for_width (format, width);
  cairo_pixels = g_malloc (height * cairo_stride);
243
  surface = cairo_image_surface_create_for_data ((unsigned char *)cairo_pixels,
244 245 246
                                                 format,
                                                 width, height, cairo_stride);

247 248 249 250 251 252 253 254 255 256 257 258 259 260
  cairo_surface_set_user_data (surface, &key,
			       cairo_pixels, (cairo_destroy_func_t)g_free);

  for (j = height; j; j--)
    {
      guchar *p = gdk_pixels;
      guchar *q = cairo_pixels;

      if (n_channels == 3)
	{
	  guchar *end = p + 3 * width;
	  
	  while (p < end)
	    {
261
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
262 263
	      q[0] = p[2];
	      q[1] = p[1];
264
	      q[2] = p[0];
265
#else	  
266 267 268
	      q[1] = p[0];
	      q[2] = p[1];
	      q[3] = p[2];
269 270 271 272 273 274 275 276 277 278
#endif
	      p += 3;
	      q += 4;
	    }
	}
      else
	{
	  guchar *end = p + 4 * width;
	  guint t1,t2,t3;
	    
279
#define MULT(d,c,a,t) G_STMT_START { t = c * a + 0x7f; d = ((t >> 8) + t) >> 8; } G_STMT_END
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302

	  while (p < end)
	    {
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
	      MULT(q[0], p[2], p[3], t1);
	      MULT(q[1], p[1], p[3], t2);
	      MULT(q[2], p[0], p[3], t3);
	      q[3] = p[3];
#else	  
	      q[0] = p[3];
	      MULT(q[1], p[0], p[3], t1);
	      MULT(q[2], p[1], p[3], t2);
	      MULT(q[3], p[2], p[3], t3);
#endif
	      
	      p += 4;
	      q += 4;
	    }
	  
#undef MULT
	}

      gdk_pixels += gdk_rowstride;
303
      cairo_pixels += cairo_stride;
304 305 306
    }

  cairo_set_source_surface (cr, surface, pixbuf_x, pixbuf_y);
307
  cairo_surface_destroy (surface);
308 309
}

310
/**
311
 * gdk_cairo_set_source_window:
312
 * @cr: a #Cairo context
313 314 315
 * @window: a #GdkWindow
 * @x: X coordinate of location to place upper left corner of @window
 * @y: Y coordinate of location to place upper left corner of @window
Matthias Clasen's avatar
Matthias Clasen committed
316
 *
317
 * Sets the given window as the source pattern for the Cairo context.
318
 * The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned
319 320
 * so that the origin of @window is @x, @y. The window contains all its
 * subwindows when rendering.
Matthias Clasen's avatar
Matthias Clasen committed
321
 *
322 323
 * Note that the contents of @window are undefined outside of the
 * visible part of @window, so use this function with care.
324
 *
Matthias Clasen's avatar
Matthias Clasen committed
325 326
 * Since: 2.24
 */
327
void
328
gdk_cairo_set_source_window (cairo_t   *cr,
Matthias Clasen's avatar
Matthias Clasen committed
329 330 331
                             GdkWindow *window,
                             double     x,
                             double     y)
332 333 334
{
  cairo_surface_t *surface;
  
335 336 337 338 339
  g_return_if_fail (cr != NULL);
  g_return_if_fail (GDK_IS_WINDOW (window));

  surface = _gdk_drawable_ref_cairo_surface (GDK_DRAWABLE (window));
  cairo_set_source_surface (cr, surface, x, y);
340 341
  cairo_surface_destroy (surface);
}
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368

/**
 * _gdk_cairo_surface_extents:
 * @surface: surface to measure
 * @extents: (out): rectangle to put the extents
 *
 * Measures the area covered by @surface and puts it into @extents.
 * Note that this function respects device offsets set on @surface.
 * if @surface is unbounded, the resulting extents will be empty and
 * not be a maximal sized rectangle. This is to avoid careless coding.
 * You must explicitly check the return value of you want to handle
 * that case.
 *
 * Returns: %TRUE if the extents fit in a #GdkRectangle, %FALSE if not.
 **/
gboolean
_gdk_cairo_surface_extents (cairo_surface_t *surface,
                            GdkRectangle *extents)
{
  double x1, x2, y1, y2;
  cairo_t *cr;

  g_return_val_if_fail (surface != NULL, FALSE);
  g_return_val_if_fail (extents != NULL, FALSE);

  cr = cairo_create (surface);
  cairo_clip_extents (cr, &x1, &y1, &x2, &y2);
Xan Lopez's avatar
Xan Lopez committed
369
  cairo_destroy (cr);
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407

  x1 = floor (x1);
  y1 = floor (y1);
  x2 = ceil (x2);
  y2 = ceil (y2);
  x2 -= x1;
  y2 -= y1;
  
  if (x1 < G_MININT || x1 > G_MAXINT ||
      y1 < G_MININT || y1 > G_MAXINT ||
      x2 > G_MAXINT || y2 > G_MAXINT)
    {
      extents->x = extents->y = extents->width = extents->height = 0;
      return FALSE;
    }

  extents->x = x1;
  extents->y = y1;
  extents->width = x2;
  extents->height = y2;

  return TRUE;
}

/* This function originally from Jean-Edouard Lachand-Robert, and
 * available at www.codeguru.com. Simplified for our needs, not sure
 * how much of the original code left any longer. Now handles just
 * one-bit deep bitmaps (in Window parlance, ie those that GDK calls
 * bitmaps (and not pixmaps), with zero pixels being transparent.
 */
/**
 * gdk_cairo_region_create_from_surface:
 * @surface: A surface
 *
 * Creates region that describes covers the area where the given @surface
 * is more than 50% opaque. This function takes into account device
 * offsets that might be set with cairo_surface_set_device_offset().
 *
408 409 410
 * Returns: A #cairo_region_t. This must be freed with cairo_region_destroy()
 *   when you are done.
 */
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
cairo_region_t *
gdk_cairo_region_create_from_surface (cairo_surface_t *surface)
{
  cairo_region_t *region;
  GdkRectangle extents, rect;
  cairo_surface_t *image;
  cairo_t *cr;
  gint x, y, stride;
  guchar *data;

  _gdk_cairo_surface_extents (surface, &extents);

  if (cairo_surface_get_content (surface) == CAIRO_CONTENT_COLOR)
    return cairo_region_create_rectangle (&extents);

  if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_IMAGE ||
      cairo_image_surface_get_format (surface) != CAIRO_FORMAT_A1)
    {
      /* coerce to an A1 image */
      image = cairo_image_surface_create (CAIRO_FORMAT_A1,
                                          extents.width, extents.height);
      cr = cairo_create (image);
433
      cairo_set_source_surface (cr, surface, -extents.x, -extents.y);
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
      cairo_paint (cr);
      cairo_destroy (cr);
    }
  else
    image = cairo_surface_reference (surface);

  data = cairo_image_surface_get_data (image);
  stride = cairo_image_surface_get_stride (image);

  region = cairo_region_create ();

  for (y = 0; y < extents.height; y++)
    {
      for (x = 0; x < extents.width; x++)
	{
	  /* Search for a continuous range of "non transparent pixels"*/
	  gint x0 = x;
	  while (x < extents.width)
	    {
	      if (((data[x / 8] >> (x%8)) & 1) == 0)
		/* This pixel is "transparent"*/
		break;
	      x++;
	    }
	  
	  if (x > x0)
	    {
	      /* Add the pixels (x0, y) to (x, y+1) as a new rectangle
	       * in the region
	       */
              rect.x = x0;
              rect.width = x - x0;
              rect.y = y;
              rect.height = 1;

              cairo_region_union_rectangle (region, &rect);
	    }
	}
      data += stride;
    }

  cairo_surface_destroy (image);
  
  cairo_region_translate (region, extents.x, extents.y);

  return region;
}