gdkdrawable-fb2.c

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

	}
      else
	{
	  tmp_npoints = npoints;
	  tmp_points = points;
	}

      gdk_fb_draw_lines (drawable, gc, tmp_points, tmp_npoints);
      
      if (free_points)
	g_free (tmp_points);
    }
}

static void
gdk_fb_draw_lines (GdkDrawable    *drawable,
		   GdkGC          *gc,
		   GdkPoint       *points,
		   gint            npoints)
{
  GdkGCFBData *private;

  private = GDK_GC_FBDATA (gc);
  if (private->values.line_width > 0)
    {
      if ((private->values.line_style != GDK_LINE_SOLID) && private->dash_list)
	miWideDash (drawable, gc, 0, npoints, points);
      else 
	miWideLine (drawable, gc, 0, npoints, points);
    }
  else
    {
      if ((private->values.line_style != GDK_LINE_SOLID) && private->dash_list)
	miZeroDashLine (drawable, gc, 0, npoints, points);
      else 
	miZeroLine (drawable, gc, 0, npoints, points);
    }
}

static void
gdk_fb_draw_segments (GdkDrawable    *drawable,
		      GdkGC          *gc,
		      GdkSegment     *segs,
		      gint            nsegs)
{
  GdkPoint pts[2];
  int i;

  for(i = 0; i < nsegs; i++)
    {
      pts[0].x = segs[i].x1;
      pts[0].y = segs[i].y1;
      pts[1].x = segs[i].x2;
      pts[1].y = segs[i].y2;

      gdk_fb_draw_lines (drawable, gc, pts, 2);
    }
}

void
gdk_fb_drawable_clear (GdkDrawable *d)
{
  extern void
    _gdk_windowing_window_clear_area (GdkWindow *window,
				      gint       x,
				      gint       y,
				      gint       width,
				      gint       height);

  _gdk_windowing_window_clear_area (d, 0, 0, GDK_DRAWABLE_IMPL_FBDATA (d)->width, GDK_DRAWABLE_IMPL_FBDATA (d)->height);
}

static void
_gdk_fb_draw_glyphs (GdkDrawable      *drawable,
		     GdkGC	     *gc,
		     PangoFont        *font,
		     gint              x,
		     gint              y,
		     PangoGlyphString *glyphs,
		     GdkRectangle     *bbox)
{
  GdkFBDrawingContext fbdc;
  GdkPixmapFBData pixmap;
  PangoGlyphInfo *gi;
  FT_Face face;
  FT_UInt glyph_index;
  int i, xpos;
  int maxy, miny;
  int topy;

  g_return_if_fail (font);

  gdk_fb_drawing_context_init (&fbdc, drawable, gc, FALSE, TRUE);

  /* Fake its existence as a pixmap */

  ((GTypeInstance *)&pixmap)->g_class = g_type_class_peek (_gdk_pixmap_impl_get_type ());
  pixmap.drawable_data.abs_x = 0;
  pixmap.drawable_data.abs_y = 0;
  pixmap.drawable_data.depth = 78;

  maxy = miny = 0;
  
  gi = glyphs->glyphs;
  for (i = 0, xpos = 0; i < glyphs->num_glyphs; i++, gi++)
    {
      if (gi->glyph)
	{
	  glyph_index = gi->glyph;
	  face = pango_ft2_font_get_face (font);

	  if (face)
	    {
	      /* Draw glyph */
	      FT_Load_Glyph (face, glyph_index, FT_LOAD_DEFAULT);
	      if (face->glyph->format != ft_glyph_format_bitmap)
		FT_Render_Glyph (face->glyph, ft_render_mode_normal);

	      pixmap.drawable_data.mem = face->glyph->bitmap.buffer;
	      pixmap.drawable_data.rowstride = face->glyph->bitmap.pitch;
	      pixmap.drawable_data.width = face->glyph->bitmap.width;
	      pixmap.drawable_data.height = face->glyph->bitmap.rows;

	      topy = y - face->glyph->bitmap_top + 1;
	      miny = MIN (miny, topy);
	      maxy = MAX (maxy, topy + face->glyph->bitmap.rows);
	      gdk_fb_draw_drawable_3 (drawable, gc, (GdkPixmap *)&pixmap,
				      &fbdc,
				      0, 0,
				      x + PANGO_PIXELS (xpos) + face->glyph->bitmap_left,
				      topy,
				      face->glyph->bitmap.width, face->glyph->bitmap.rows);
	    }
	}
      xpos += glyphs->glyphs[i].geometry.width;
    }

  gdk_fb_drawing_context_finalize (&fbdc);

  if (bbox)
    {
      bbox->x = x;
      bbox->y = miny;
      bbox->width = xpos;
      bbox->height = maxy - miny;
    }
}

static void
gdk_fb_draw_glyphs (GdkDrawable      *drawable,
		    GdkGC	     *gc,
		    PangoFont        *font,
		    gint              x,
		    gint              y,
		    PangoGlyphString *glyphs)
{
  _gdk_fb_draw_glyphs (drawable, gc, font, x, y, glyphs, NULL);
}

static void
gdk_fb_draw_image (GdkDrawable *drawable,
		   GdkGC       *gc,
		   GdkImage    *image,
		   gint         xsrc,
		   gint         ysrc,
		   gint         xdest,
		   gint         ydest,
		   gint         width,
		   gint         height)
{
  GdkImagePrivateFB *image_private;
  GdkPixmapFBData fbd;

  g_return_if_fail (drawable != NULL);
  g_return_if_fail (image != NULL);
  g_return_if_fail (gc != NULL);

  image_private = (GdkImagePrivateFB*) image;

  g_return_if_fail (image->type == GDK_IMAGE_NORMAL);

  /* Fake its existence as a pixmap */
  memset (&fbd, 0, sizeof(fbd));

  ((GTypeInstance *)&fbd)->g_class = g_type_class_peek (_gdk_pixmap_impl_get_type ());
  
  fbd.drawable_data.mem = image->mem;
  fbd.drawable_data.rowstride = image->bpl;
  fbd.drawable_data.width = fbd.drawable_data.lim_x = image->width;
  fbd.drawable_data.height = fbd.drawable_data.lim_y = image->height;
  fbd.drawable_data.depth = image->depth;
  fbd.drawable_data.window_type = GDK_DRAWABLE_PIXMAP;
  fbd.drawable_data.colormap = gdk_colormap_get_system ();
  
  gdk_fb_draw_drawable_2 (drawable, gc, (GdkPixmap *)&fbd, xsrc, ysrc, xdest, ydest, width, height, TRUE, TRUE);
}

static gint
gdk_fb_get_depth (GdkDrawable *drawable)
{
  return GDK_DRAWABLE_FBDATA (drawable)->depth;
}

static GdkScreen*
gdk_fb_get_screen (GdkDrawable *drawable)
{
  return gdk_screen_get_default();
}

static GdkVisual*
gdk_fb_get_visual (GdkDrawable    *drawable)
{
  return gdk_visual_get_system();
}

#ifdef ENABLE_SHADOW_FB
static void
gdk_shadow_fb_draw_rectangle (GdkDrawable      *drawable,
			      GdkGC            *gc,
			      gboolean          filled,
			      gint              x,
			      gint              y,
			      gint              width,
			      gint              height)
{
  GdkDrawableFBData *private;

  gdk_fb_draw_rectangle (drawable, gc, filled, x, y, width, height);

  private = GDK_DRAWABLE_FBDATA (drawable);
  if (GDK_IS_WINDOW (private->wrapper))
    {
      gint minx, miny, maxx, maxy;
      gint extra_width;
  
      minx = x + private->abs_x;
      miny = y + private->abs_y;
      maxx = x + width + private->abs_x;
      maxy = y + height + private->abs_y;
      
      if (!filled)
	{
	  extra_width = (GDK_GC_FBDATA (gc)->values.line_width + 1) / 2;
	  
	  minx -= extra_width;
	  miny -= extra_width;
	  maxx += extra_width;
	  maxy += extra_width;
	}
      gdk_shadow_fb_update (minx, miny, maxx, maxy);
    }
}

static void
gdk_shadow_fb_draw_arc (GdkDrawable      *drawable,
			GdkGC            *gc,
			gboolean          filled,
			gint              x,
			gint              y,
			gint              width,
			gint              height,
			gint              angle1,
			gint              angle2)
{
  GdkDrawableFBData *private;
  
  gdk_fb_draw_arc (drawable, gc, filled, x, y, width, height, angle1, angle2);

  private = GDK_DRAWABLE_FBDATA (drawable);
  if (GDK_IS_WINDOW (private->wrapper))
    {
      gint minx, miny, maxx, maxy;
      gint extra_width;
  
      minx = x + private->abs_x;
      miny = y + private->abs_y;
      maxx = x + width + private->abs_x;
      maxy = y + height + private->abs_y;
      
      if (!filled)
	{
	  extra_width = (GDK_GC_FBDATA (gc)->values.line_width + 1) / 2;
	  
	  minx -= extra_width;
	  miny -= extra_width;
	  maxx += extra_width;
	  maxy += extra_width;
	}
      gdk_shadow_fb_update (minx, miny, maxx, maxy);
    }
}

static void
gdk_shadow_fb_draw_polygon (GdkDrawable      *drawable,
			    GdkGC            *gc,
			    gboolean          filled,
			    GdkPoint         *points,
			    gint              npoints)
{
  GdkDrawableFBData *private;

  gdk_fb_draw_polygon (drawable, gc, filled, points, npoints);

  private = GDK_DRAWABLE_FBDATA (drawable);
  if (GDK_IS_WINDOW (private->wrapper))
    {
      gint minx, miny, maxx, maxy;
      gint extra_width;
      int i;
  
      minx = maxx = points[0].x;
      miny = maxy = points[0].y;

      for (i = 1; i < npoints; i++)
	{
	  minx = MIN(minx, points[i].x);
	  maxx = MAX(maxx, points[i].x);
	  miny = MIN(miny, points[i].y);
	  maxy = MAX(maxy, points[i].y);
	}
      
      if (!filled)
	{
	  extra_width = (GDK_GC_FBDATA (gc)->values.line_width + 1) / 2;
	  
	  minx -= extra_width;
	  miny -= extra_width;
	  maxx += extra_width;
	  maxy += extra_width;
	}
      gdk_shadow_fb_update (minx + private->abs_x, miny + private->abs_y,
			    maxx + private->abs_x, maxy + private->abs_y);
    }
}

static void
gdk_shadow_fb_draw_text (GdkDrawable      *drawable,
			 GdkFont          *font,
			 GdkGC            *gc,
			 gint              x,
			 gint              y,
			 const gchar      *text,
			 gint              text_length)
{
  gdk_fb_draw_text (drawable, font, gc, x, y, text, text_length);
}

static void
gdk_shadow_fb_draw_text_wc (GdkDrawable      *drawable,
			    GdkFont          *font,
			    GdkGC            *gc,
			    gint              x,
			    gint              y,
			    const GdkWChar   *text,
			    gint              text_length)
{
  gdk_fb_draw_text_wc (drawable, font, gc, x, y, text, text_length);
}

static void
gdk_shadow_fb_draw_glyphs (GdkDrawable      *drawable,
			   GdkGC            *gc,
			   PangoFont        *font,
			   gint              x,
			   gint              y,
			   PangoGlyphString *glyphs)
{
  GdkDrawableFBData *private;
  GdkRectangle bbox;
  
  _gdk_fb_draw_glyphs (drawable, gc, font, x, y, glyphs, &bbox);
  
  private = GDK_DRAWABLE_FBDATA (drawable);
  if (GDK_IS_WINDOW (private->wrapper))
    gdk_shadow_fb_update (bbox.x + private->abs_x, bbox.y + private->abs_y,
			  bbox.x + private->abs_x + bbox.width, bbox.y + private->abs_y + bbox.height);
}

static void
gdk_shadow_fb_draw_drawable (GdkDrawable      *drawable,
			     GdkGC            *gc,
			     GdkPixmap        *src,
			     gint              xsrc,
			     gint              ysrc,
			     gint              xdest,
			     gint              ydest,
			     gint              width,
			     gint              height)
{
  GdkDrawableFBData *private;
  
  gdk_fb_draw_drawable (drawable, gc, src, xsrc, ysrc, xdest, ydest, width, height);
  
  private = GDK_DRAWABLE_FBDATA (drawable);
  if (GDK_IS_WINDOW (private->wrapper))
    gdk_shadow_fb_update (xdest + private->abs_x, ydest + private->abs_y,
			  xdest + private->abs_x + width, ydest + private->abs_y + height);
}

static void
gdk_shadow_fb_draw_image (GdkDrawable      *drawable,
			  GdkGC            *gc,
			  GdkImage         *image,
			  gint              xsrc,
			  gint              ysrc,
			  gint              xdest,
			  gint              ydest,
			  gint              width,
			  gint              height)
{
  GdkDrawableFBData *private;
  
  gdk_fb_draw_image (drawable, gc, image, xsrc, ysrc, xdest, ydest, width, height);
  
  private = GDK_DRAWABLE_FBDATA (drawable);
  if (GDK_IS_WINDOW (private->wrapper))
    gdk_shadow_fb_update (xdest + private->abs_x, ydest + private->abs_y,
			  xdest + private->abs_x + width, ydest + private->abs_y + height);
}

static void
gdk_shadow_fb_draw_points (GdkDrawable      *drawable,
			   GdkGC            *gc,
			   GdkPoint         *points,
			   gint              npoints)
{
  GdkDrawableFBData *private;

  gdk_fb_draw_points (drawable, gc, points, npoints);

  private = GDK_DRAWABLE_FBDATA (drawable);
  if (GDK_IS_WINDOW (private->wrapper))
    {
      gint minx, miny, maxx, maxy;
      int i;
  
      minx = maxx = points[0].x;
      miny = maxy = points[0].y;

      for (i = 1; i < npoints; i++)
	{
	  minx = MIN(minx, points[i].x);
	  maxx = MAX(maxx, points[i].x);
	  miny = MIN(miny, points[i].y);
	  maxy = MAX(maxy, points[i].y);
	}
      
      gdk_shadow_fb_update (minx + private->abs_x, miny + private->abs_y,
			    maxx + private->abs_x, maxy + private->abs_y);
    }
}

static void
gdk_shadow_fb_draw_segments (GdkDrawable      *drawable,
			     GdkGC            *gc,
			     GdkSegment       *segs,
			     gint              nsegs)
{
  GdkDrawableFBData *private;

  gdk_fb_draw_segments (drawable, gc, segs, nsegs);

  private = GDK_DRAWABLE_FBDATA (drawable);
  if (GDK_IS_WINDOW (private->wrapper))
    {
      gint minx, miny, maxx, maxy;
      gint extra_width;
      int i;
  
      minx = maxx = segs[0].x1;
      miny = maxy = segs[0].y1;

      for (i = 0; i < nsegs; i++)
	{
	  minx = MIN(minx, segs[i].x1);
	  maxx = MAX(maxx, segs[i].x1);
	  minx = MIN(minx, segs[i].x2);
	  maxx = MAX(maxx, segs[i].x2);
	  
	  miny = MIN(miny, segs[i].y1);
	  maxy = MAX(maxy, segs[i].y1);
	  miny = MIN(miny, segs[i].y2);
	  maxy = MAX(maxy, segs[i].y2);

	}
      
      extra_width = (GDK_GC_FBDATA (gc)->values.line_width + 1) / 2;
      
      minx -= extra_width;
      miny -= extra_width;
      maxx += extra_width;
      maxy += extra_width;
      
      gdk_shadow_fb_update (minx + private->abs_x, miny + private->abs_y,
			    maxx + private->abs_x, maxy + private->abs_y);
    }
}

static void
gdk_shadow_fb_draw_lines (GdkDrawable      *drawable,
			  GdkGC            *gc,
			  GdkPoint         *points,
			  gint              npoints)
{
  GdkDrawableFBData *private;

  gdk_fb_draw_lines (drawable, gc, points, npoints);

  private = GDK_DRAWABLE_FBDATA (drawable);
  if (GDK_IS_WINDOW (private->wrapper))
    {
      gint minx, miny, maxx, maxy;
      gint extra_width;
      int i;
  
      minx = maxx = points[0].x;
      miny = maxy = points[0].y;

      for (i = 1; i < npoints; i++)
	{
	  minx = MIN(minx, points[i].x);
	  maxx = MAX(maxx, points[i].x);
	  miny = MIN(miny, points[i].y);
	  maxy = MAX(maxy, points[i].y);
	}
      
      extra_width = (GDK_GC_FBDATA (gc)->values.line_width + 1) / 2;
	  
      minx -= extra_width;
      miny -= extra_width;
      maxx += extra_width;
      maxy += extra_width;
      
      gdk_shadow_fb_update (minx + private->abs_x, miny + private->abs_y,
			    maxx + private->abs_x, maxy + private->abs_y);
    }
}

#endif

gboolean
gdk_draw_rectangle_alpha_libgtk_only (GdkDrawable *drawable,
				      gint         x,
				      gint         y,
				      gint         width,
				      gint         height,
				      GdkColor    *color,
				      guint16      alpha)
{
  return FALSE;
}