gdkdrawable-x11.c

linux下电话本所依赖的一些图形库

		  XRenderPictFormat *format,
		  XRenderPictFormat *mask_format,
		  guchar            *src_rgb,
		  gint               src_rowstride,
		  gint               dest_x,
		  gint               dest_y,
		  gint               width,
		  gint               height)
{
  GdkScreen *screen = GDK_DRAWABLE_IMPL_X11 (drawable)->screen;
  Display *xdisplay = GDK_SCREEN_XDISPLAY (screen);
  GdkImage *image;
  GdkPixmap *pix;
  GdkGC *pix_gc;
  Picture pict;
  Picture dest_pict;
  Picture mask = None;
  gint x0, y0;

  pix = gdk_pixmap_new (gdk_screen_get_root_window (screen), width, height, 32);
						  
  pict = XRenderCreatePicture (xdisplay, 
			       GDK_PIXMAP_XID (pix),
			       format, 0, NULL);
  if (mask_format)
    mask = XRenderCreatePicture (xdisplay, 
				 GDK_PIXMAP_XID (pix),
				 mask_format, 0, NULL);

  dest_pict = gdk_x11_drawable_get_picture (drawable);  
  
  pix_gc = _gdk_drawable_get_scratch_gc (pix, FALSE);

  for (y0 = 0; y0 < height; y0 += GDK_SCRATCH_IMAGE_HEIGHT)
    {
      gint height1 = MIN (height - y0, GDK_SCRATCH_IMAGE_HEIGHT);
      for (x0 = 0; x0 < width; x0 += GDK_SCRATCH_IMAGE_WIDTH)
	{
	  gint xs0, ys0;
	  
	  gint width1 = MIN (width - x0, GDK_SCRATCH_IMAGE_WIDTH);
	  
	  image = _gdk_image_get_scratch (screen, width1, height1, 32, &xs0, &ys0);
	  
	  _gdk_x11_convert_to_format (src_rgb + y0 * src_rowstride + 4 * x0, src_rowstride,
                                      (guchar *)image->mem + ys0 * image->bpl + xs0 * image->bpp, image->bpl,
                                      format_type, image->byte_order, 
                                      width1, height1);

	  gdk_draw_image (pix, pix_gc,
			  image, xs0, ys0, x0, y0, width1, height1);
	}
    }
  
  XRenderComposite (xdisplay, PictOpOver, pict, mask, dest_pict, 
		    0, 0, 0, 0, dest_x, dest_y, width, height);

  XRenderFreePicture (xdisplay, pict);
  if (mask)
    XRenderFreePicture (xdisplay, mask);
  
  g_object_unref (pix);
}

typedef struct _ShmPixmapInfo ShmPixmapInfo;

struct _ShmPixmapInfo
{
  GdkImage *image;
  Pixmap    pix;
  Picture   pict;
  Picture   mask;
};

/* Returns FALSE if we can't get a shm pixmap */
static gboolean
get_shm_pixmap_for_image (Display           *xdisplay,
			  GdkImage          *image,
			  XRenderPictFormat *format,
			  XRenderPictFormat *mask_format,
			  Pixmap            *pix,
			  Picture           *pict,
			  Picture           *mask)
{
  ShmPixmapInfo *info;
  
  if (image->type != GDK_IMAGE_SHARED)
    return FALSE;
  
  info = g_object_get_data (G_OBJECT (image), "gdk-x11-shm-pixmap");
  if (!info)
    {
      *pix = _gdk_x11_image_get_shm_pixmap (image);
      
      if (!*pix)
	return FALSE;
      
      info = g_new (ShmPixmapInfo, 1);
      info->pix = *pix;
      
      info->pict = XRenderCreatePicture (xdisplay, info->pix,
					 format, 0, NULL);
      if (mask_format)
	info->mask = XRenderCreatePicture (xdisplay, info->pix,
					   mask_format, 0, NULL);
      else
	info->mask = None;

      g_object_set_data (G_OBJECT (image), "gdk-x11-shm-pixmap", info);
    }

  *pix = info->pix;
  *pict = info->pict;
  *mask = info->mask;

  return TRUE;
}

#ifdef USE_SHM
/* Returns FALSE if drawing with ShmPixmaps is not possible */
static gboolean
draw_with_pixmaps (GdkDrawable       *drawable,
		   GdkGC             *gc,
		   GdkX11FormatType   format_type,
		   XRenderPictFormat *format,
		   XRenderPictFormat *mask_format,
		   guchar            *src_rgb,
		   gint               src_rowstride,
		   gint               dest_x,
		   gint               dest_y,
		   gint               width,
		   gint               height)
{
  Display *xdisplay = GDK_SCREEN_XDISPLAY (GDK_DRAWABLE_IMPL_X11 (drawable)->screen);
  GdkImage *image;
  Pixmap pix;
  Picture pict;
  Picture dest_pict;
  Picture mask = None;
  gint x0, y0;

  dest_pict = gdk_x11_drawable_get_picture (drawable);
  
  for (y0 = 0; y0 < height; y0 += GDK_SCRATCH_IMAGE_HEIGHT)
    {
      gint height1 = MIN (height - y0, GDK_SCRATCH_IMAGE_HEIGHT);
      for (x0 = 0; x0 < width; x0 += GDK_SCRATCH_IMAGE_WIDTH)
	{
	  gint xs0, ys0;
	  
	  gint width1 = MIN (width - x0, GDK_SCRATCH_IMAGE_WIDTH);
	  
	  image = _gdk_image_get_scratch (GDK_DRAWABLE_IMPL_X11 (drawable)->screen,
					  width1, height1, 32, &xs0, &ys0);
	  if (!get_shm_pixmap_for_image (xdisplay, image, format, mask_format, &pix, &pict, &mask))
	    return FALSE;

	  _gdk_x11_convert_to_format (src_rgb + y0 * src_rowstride + 4 * x0, src_rowstride,
                                      (guchar *)image->mem + ys0 * image->bpl + xs0 * image->bpp, image->bpl,
                                      format_type, image->byte_order, 
                                      width1, height1);

	  XRenderComposite (xdisplay, PictOpOver, pict, mask, dest_pict, 
			    xs0, ys0, xs0, ys0, x0 + dest_x, y0 + dest_y,
			    width1, height1);
	}
    }

  return TRUE;
}
#endif

static void
gdk_x11_draw_pixbuf (GdkDrawable     *drawable,
		     GdkGC           *gc,
		     GdkPixbuf       *pixbuf,
		     gint             src_x,
		     gint             src_y,
		     gint             dest_x,
		     gint             dest_y,
		     gint             width,
		     gint             height,
		     GdkRgbDither     dither,
		     gint             x_dither,
		     gint             y_dither)
{
  GdkX11FormatType format_type;
  XRenderPictFormat *format, *mask_format;
  gint rowstride;
#ifdef USE_SHM  
  gboolean use_pixmaps = TRUE;
#endif /* USE_SHM */
    
  format_type = select_format (gdk_drawable_get_display (drawable),
			       &format, &mask_format);

  if (format_type == GDK_X11_FORMAT_NONE ||
      !gdk_pixbuf_get_has_alpha (pixbuf) ||
      gdk_drawable_get_depth (drawable) == 1 ||
      (dither == GDK_RGB_DITHER_MAX && gdk_drawable_get_depth (drawable) != 24) ||
      gdk_x11_drawable_get_picture (drawable) == None)
    {
      GdkDrawable *wrapper = GDK_DRAWABLE_IMPL_X11 (drawable)->wrapper;
      GDK_DRAWABLE_CLASS (parent_class)->draw_pixbuf (wrapper, gc, pixbuf,
						      src_x, src_y, dest_x, dest_y,
						      width, height,
						      dither, x_dither, y_dither);
      return;
    }

  gdk_x11_drawable_update_xft_clip (drawable, gc);

  rowstride = gdk_pixbuf_get_rowstride (pixbuf);

#ifdef USE_SHM
  if (use_pixmaps)
    {
      if (!draw_with_pixmaps (drawable, gc,
			      format_type, format, mask_format,
			      gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * 4,
			      rowstride,
			      dest_x, dest_y, width, height))
	use_pixmaps = FALSE;
    }

  if (!use_pixmaps)
#endif /* USE_SHM */
    draw_with_images (drawable, gc,
		      format_type, format, mask_format,
		      gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * 4,
		      rowstride,
		      dest_x, dest_y, width, height);
}

static void
gdk_x11_draw_trapezoids (GdkDrawable  *drawable,
			 GdkGC	      *gc,
			 GdkTrapezoid *trapezoids,
			 gint          n_trapezoids)
{
  GdkScreen *screen = GDK_DRAWABLE_IMPL_X11 (drawable)->screen;
  GdkDisplay *display = gdk_screen_get_display (screen);
  XTrapezoid *xtrapezoids;
  gint i;

  if (!_gdk_x11_have_render_with_trapezoids (display))
    {
      GdkDrawable *wrapper = GDK_DRAWABLE_IMPL_X11 (drawable)->wrapper;
      GDK_DRAWABLE_CLASS (parent_class)->draw_trapezoids (wrapper, gc,
							  trapezoids, n_trapezoids);
      return;
    }

  xtrapezoids = g_new (XTrapezoid, n_trapezoids);

  for (i = 0; i < n_trapezoids; i++)
    {
      xtrapezoids[i].top = XDoubleToFixed (trapezoids[i].y1);
      xtrapezoids[i].bottom = XDoubleToFixed (trapezoids[i].y2);
      xtrapezoids[i].left.p1.x = XDoubleToFixed (trapezoids[i].x11);
      xtrapezoids[i].left.p1.y = XDoubleToFixed (trapezoids[i].y1);
      xtrapezoids[i].left.p2.x = XDoubleToFixed (trapezoids[i].x12);
      xtrapezoids[i].left.p2.y = XDoubleToFixed (trapezoids[i].y2);
      xtrapezoids[i].right.p1.x = XDoubleToFixed (trapezoids[i].x21);
      xtrapezoids[i].right.p1.y = XDoubleToFixed (trapezoids[i].y1);
      xtrapezoids[i].right.p2.x = XDoubleToFixed (trapezoids[i].x22);
      xtrapezoids[i].right.p2.y = XDoubleToFixed (trapezoids[i].y2);
    }

  _gdk_x11_drawable_draw_xtrapezoids (drawable, gc,
				      xtrapezoids, n_trapezoids);
  
  g_free (xtrapezoids);
}

/**
 * gdk_draw_rectangle_alpha_libgtk_only:
 * @drawable: The #GdkDrawable to draw on
 * @x: the x coordinate of the left edge of the rectangle.
 * @y: the y coordinate of the top edge of the rectangle.
 * @width: the width of the rectangle.
 * @height: the height of the rectangle.
 * @color: The color
 * @alpha: The alpha value.
 * 
 * Tries to draw a filled alpha blended rectangle using the window
 * system's native routines. This is not public API and must not be
 * used by applications.
 * 
 * Return value: TRUE if the rectangle could be drawn, FALSE
 * otherwise.
 **/
gboolean
gdk_draw_rectangle_alpha_libgtk_only (GdkDrawable  *drawable,
				      gint          x,
				      gint          y,
				      gint          width,
				      gint          height,
				      GdkColor     *color,
				      guint16       alpha)
{
  Display *xdisplay;
  XRenderColor render_color;
  Picture pict;
  int x_offset, y_offset;
  GdkDrawable *real_drawable, *impl;

  g_return_val_if_fail (color != NULL, FALSE);
  
  if (!GDK_IS_WINDOW (drawable))
    return FALSE;
  
  if (!_gdk_x11_have_render (gdk_drawable_get_display (drawable)))
    return FALSE;

  gdk_window_get_internal_paint_info (GDK_WINDOW (drawable),
				      &real_drawable,
				      &x_offset, &y_offset);

  impl = ((GdkWindowObject *)real_drawable)->impl;  
      
  pict = gdk_x11_drawable_get_picture (impl);

  if (pict == None)
    return FALSE;
  
  xdisplay = GDK_DISPLAY_XDISPLAY (gdk_drawable_get_display (drawable));

  render_color.alpha = alpha;
  render_color.red = (guint32)color->red * render_color.alpha / 0xffff;
  render_color.green = (guint32)color->green * render_color.alpha / 0xffff;
  render_color.blue = (guint32)color->blue * render_color.alpha / 0xffff;

  XRenderFillRectangle (xdisplay,
			PictOpOver, pict, &render_color,
			x - x_offset, y - y_offset,
			width, height);
  return TRUE;
}

void
_gdk_x11_drawable_draw_xtrapezoids (GdkDrawable      *drawable,
				    GdkGC            *gc,
				    XTrapezoid       *xtrapezoids,
				    int               n_trapezoids)
{
  GdkScreen *screen = GDK_DRAWABLE_IMPL_X11 (drawable)->screen;
  GdkDisplay *display = gdk_screen_get_display (screen);
  GdkDisplayX11 *x11display = GDK_DISPLAY_X11 (display);
   
  XftDraw *draw;

  if (!_gdk_x11_have_render_with_trapezoids (display))
    {
      /* This is the case of drawing the borders of the unknown glyph box
       * without render on the display, we need to feed it back to
       * fallback code. Not efficient, but doesn't matter.
       */
      GdkTrapezoid *trapezoids = g_new (GdkTrapezoid, n_trapezoids);
      int i;

      for (i = 0; i < n_trapezoids; i++)
	{
	  trapezoids[i].y1 = XFixedToDouble (xtrapezoids[i].top);
	  trapezoids[i].y2 = XFixedToDouble (xtrapezoids[i].bottom);
	  trapezoids[i].x11 = XFixedToDouble (xtrapezoids[i].left.p1.x);
	  trapezoids[i].x12 = XFixedToDouble (xtrapezoids[i].left.p2.x);
	  trapezoids[i].x21 = XFixedToDouble (xtrapezoids[i].right.p1.x);
	  trapezoids[i].x22 = XFixedToDouble (xtrapezoids[i].right.p2.x);
	}

      gdk_x11_draw_trapezoids (drawable, gc, trapezoids, n_trapezoids);
      g_free (trapezoids);

      return;
    }

  gdk_x11_drawable_update_xft_clip (drawable, gc);
  draw = gdk_x11_drawable_get_xft_draw (drawable);

  if (!x11display->mask_format)
    x11display->mask_format = XRenderFindStandardFormat (x11display->xdisplay,
							 PictStandardA8);

  XRenderCompositeTrapezoids (x11display->xdisplay, PictOpOver,
			      _gdk_x11_gc_get_fg_picture (gc),
			      XftDrawPicture (draw),
			      x11display->mask_format,
			      - gc->ts_x_origin, - gc->ts_y_origin,
			      xtrapezoids, n_trapezoids);
}

void
_gdk_x11_drawable_draw_xft_glyphs (GdkDrawable      *drawable,
				   GdkGC            *gc,
				   XftFont          *xft_font,
				   XftGlyphSpec     *glyphs,
				   gint              n_glyphs)
{
  GdkScreen *screen = GDK_DRAWABLE_IMPL_X11 (drawable)->screen;
  GdkDisplay *display = gdk_screen_get_display (screen);
  GdkDisplayX11 *x11display = GDK_DISPLAY_X11 (display);
  XftDraw *draw;
   
  gdk_x11_drawable_update_xft_clip (drawable, gc);
  draw = gdk_x11_drawable_get_xft_draw (drawable);

  if (_gdk_x11_have_render (display))
    {
      XftGlyphSpecRender (x11display->xdisplay, PictOpOver,
			  _gdk_x11_gc_get_fg_picture (gc),
			  xft_font,
			  XftDrawPicture (draw),
			  - gc->ts_x_origin, - gc->ts_y_origin,
			  glyphs, n_glyphs);
    }
  else
    {
      XftColor color;
      
      _gdk_gc_x11_get_fg_xft_color (gc, &color);
      XftDrawGlyphSpec (draw, &color, xft_font, glyphs, n_glyphs);
    }
}

#define __GDK_DRAWABLE_X11_C__
#include "gdkaliasdef.c"