gdkgc-win32.c

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

  if (mask & GDK_GC_EXPOSURES)
    {
      win32_gc->graphics_exposures = values->graphics_exposures;
      win32_gc->values_mask |= GDK_GC_EXPOSURES;
      GDK_NOTE (GC, (g_print ("%sexp=%d", s, win32_gc->graphics_exposures),
		     s = ","));
    }

  if (mask & GDK_GC_LINE_WIDTH)
    {
      win32_gc->pen_width = values->line_width;
      win32_gc->values_mask |= GDK_GC_LINE_WIDTH;
      GDK_NOTE (GC, (g_print ("%spw=%d", s, win32_gc->pen_width),
		     s = ","));
    }

  if (mask & GDK_GC_LINE_STYLE)
    {
      win32_gc->line_style = values->line_style;
      win32_gc->values_mask |= GDK_GC_LINE_STYLE;
    }

  if (mask & GDK_GC_CAP_STYLE)
    {
      win32_gc->cap_style = values->cap_style;
      win32_gc->values_mask |= GDK_GC_CAP_STYLE;
    }

  if (mask & GDK_GC_JOIN_STYLE)
    {
      win32_gc->join_style = values->join_style;
      win32_gc->values_mask |= GDK_GC_JOIN_STYLE;
    }

  if (mask & (GDK_GC_LINE_WIDTH|GDK_GC_LINE_STYLE|GDK_GC_CAP_STYLE|GDK_GC_JOIN_STYLE))
    {
      fixup_pen (win32_gc);
      GDK_NOTE (GC, (g_print ("%sps|=PS_STYLE_%s|PS_ENDCAP_%s|PS_JOIN_%s", s,
			      _gdk_win32_psstyle_to_string (win32_gc->pen_style),
			      _gdk_win32_psendcap_to_string (win32_gc->pen_style),
			      _gdk_win32_psjoin_to_string (win32_gc->pen_style)),
		     s = ","));
    }

  GDK_NOTE (GC, g_print ("} mask=(%s)", _gdk_win32_gcvalues_mask_to_string (win32_gc->values_mask)));
}

GdkGC*
_gdk_win32_gc_new (GdkDrawable	  *drawable,
		   GdkGCValues	  *values,
		   GdkGCValuesMask mask)
{
  GdkGC *gc;
  GdkGCWin32 *win32_gc;

  /* NOTICE that the drawable here has to be the impl drawable,
   * not the publically-visible drawables.
   */
  g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_WIN32 (drawable), NULL);

  gc = g_object_new (_gdk_gc_win32_get_type (), NULL);
  win32_gc = GDK_GC_WIN32 (gc);

  win32_gc->hcliprgn = NULL;

  /* Use the same default values as X11 does, even if they don't make
   * sense per se. But apps always set fg and bg anyway.
   */
  win32_gc->foreground = 0;
  win32_gc->background = 1;
  win32_gc->font = NULL;
  win32_gc->rop2 = R2_COPYPEN;
  win32_gc->fill_style = GDK_SOLID;
  win32_gc->tile = NULL;
  win32_gc->stipple = NULL;
  win32_gc->subwindow_mode = GDK_CLIP_BY_CHILDREN;
  win32_gc->graphics_exposures = TRUE;
  win32_gc->pen_width = 0;
  /* Don't get confused by the PS_ENDCAP_ROUND. For narrow GDI pens
   * (width == 1), PS_GEOMETRIC|PS_ENDCAP_ROUND works like X11's
   * CapButt.
   */
  win32_gc->pen_style = PS_GEOMETRIC|PS_ENDCAP_ROUND|PS_JOIN_MITER;
  win32_gc->line_style = GDK_LINE_SOLID;
  win32_gc->cap_style = GDK_CAP_BUTT;
  win32_gc->join_style = GDK_JOIN_MITER;
  win32_gc->pen_dashes = NULL;
  win32_gc->pen_num_dashes = 0;
  win32_gc->pen_dash_offset = 0;
  win32_gc->pen_hbrbg = NULL;

  win32_gc->values_mask = GDK_GC_FUNCTION | GDK_GC_FILL;

  GDK_NOTE (GC, g_print ("_gdk_win32_gc_new: %p: ", win32_gc));
  gdk_win32_gc_values_to_win32values (values, mask, win32_gc);
  GDK_NOTE (GC, g_print ("\n"));

  win32_gc->hdc = NULL;
  win32_gc->hwnd = NULL;

  return gc;
}

static void
gdk_win32_gc_get_values (GdkGC       *gc,
			 GdkGCValues *values)
{
  GdkGCWin32 *win32_gc = GDK_GC_WIN32 (gc);

  values->foreground.pixel = win32_gc->foreground;
  values->background.pixel = win32_gc->background;
  values->font = win32_gc->font;

  switch (win32_gc->rop2)
    {
    case R2_COPYPEN:
      values->function = GDK_COPY; break;
    case R2_NOT:
      values->function = GDK_INVERT; break;
    case R2_XORPEN:
      values->function = GDK_XOR; break;
    case R2_BLACK:
      values->function = GDK_CLEAR; break;
    case R2_MASKPEN:
      values->function = GDK_AND; break;
    case R2_MASKPENNOT:
      values->function = GDK_AND_REVERSE; break;
    case R2_MASKNOTPEN:
      values->function = GDK_AND_INVERT; break;
    case R2_NOP:
      values->function = GDK_NOOP; break;
    case R2_MERGEPEN:
      values->function = GDK_OR; break;
    case R2_NOTXORPEN:
      values->function = GDK_EQUIV; break;
    case R2_MERGEPENNOT:
      values->function = GDK_OR_REVERSE; break;
    case R2_NOTCOPYPEN:
      values->function = GDK_COPY_INVERT; break;
    case R2_MERGENOTPEN:
      values->function = GDK_OR_INVERT; break;
    case R2_NOTMASKPEN:
      values->function = GDK_NAND; break;
    case R2_NOTMERGEPEN:
      values->function = GDK_NOR; break;
    case R2_WHITE:
      values->function = GDK_SET; break;
    }

  values->fill = win32_gc->fill_style;

  values->tile = win32_gc->tile;
  values->stipple = win32_gc->stipple;

  /* Also the X11 backend always returns a NULL clip_mask */
  values->clip_mask = NULL;

  values->subwindow_mode = win32_gc->subwindow_mode;
  values->ts_x_origin = win32_gc->parent_instance.ts_x_origin;
  values->ts_y_origin = win32_gc->parent_instance.ts_y_origin;
  values->clip_x_origin = win32_gc->parent_instance.clip_x_origin;
  values->clip_y_origin = win32_gc->parent_instance.clip_y_origin;
  values->graphics_exposures = win32_gc->graphics_exposures;
  values->line_width = win32_gc->pen_width;
  
  values->line_style = win32_gc->line_style;
  values->cap_style = win32_gc->cap_style;
  values->join_style = win32_gc->join_style;
}

static void
gdk_win32_gc_set_values (GdkGC           *gc,
			 GdkGCValues     *values,
			 GdkGCValuesMask  mask)
{
  g_return_if_fail (GDK_IS_GC (gc));

  GDK_NOTE (GC, g_print ("gdk_win32_gc_set_values: %p: ", GDK_GC_WIN32 (gc)));
  gdk_win32_gc_values_to_win32values (values, mask, GDK_GC_WIN32 (gc));
  GDK_NOTE (GC, g_print ("\n"));
}

static void
gdk_win32_gc_set_dashes (GdkGC *gc,
			 gint	dash_offset,
			 gint8  dash_list[],
			 gint   n)
{
  GdkGCWin32 *win32_gc;
  int i;

  g_return_if_fail (GDK_IS_GC (gc));
  g_return_if_fail (dash_list != NULL);

  win32_gc = GDK_GC_WIN32 (gc);

  win32_gc->pen_num_dashes = n;
  g_free (win32_gc->pen_dashes);
  win32_gc->pen_dashes = g_new (DWORD, n);
  for (i = 0; i < n; i++)
    win32_gc->pen_dashes[i] = dash_list[i];
  win32_gc->pen_dash_offset = dash_offset;
  fixup_pen (win32_gc);
}

void
gdk_gc_set_clip_rectangle (GdkGC	*gc,
			   GdkRectangle *rectangle)
{
  GdkGCWin32 *win32_gc;

  g_return_if_fail (GDK_IS_GC (gc));

  win32_gc = GDK_GC_WIN32 (gc);

  if (win32_gc->hcliprgn)
    DeleteObject (win32_gc->hcliprgn);

  if (rectangle)
    {
      GDK_NOTE (GC, g_print ("gdk_gc_set_clip_rectangle: %p: %s\n",
			     win32_gc,
			     _gdk_win32_gdkrectangle_to_string (rectangle)));
      win32_gc->hcliprgn = CreateRectRgn (rectangle->x, rectangle->y,
					  rectangle->x + rectangle->width,
					  rectangle->y + rectangle->height);
      win32_gc->values_mask |= GDK_GC_CLIP_MASK;
    }
  else
    {
      GDK_NOTE (GC, g_print ("gdk_gc_set_clip_rectangle: NULL\n"));

      win32_gc->hcliprgn = NULL;
      win32_gc->values_mask &= ~GDK_GC_CLIP_MASK;
    }

  gc->clip_x_origin = 0;
  gc->clip_y_origin = 0;
  
  win32_gc->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
} 

void
gdk_gc_set_clip_region (GdkGC	  *gc,
			GdkRegion *region)
{
  GdkGCWin32 *win32_gc;

  g_return_if_fail (GDK_IS_GC (gc));

  win32_gc = GDK_GC_WIN32 (gc);

  if (win32_gc->hcliprgn)
    DeleteObject (win32_gc->hcliprgn);

  if (region)
    {
      GDK_NOTE (GC, g_print ("gdk_gc_set_clip_region: %p: %s\n",
			     win32_gc,
			     _gdk_win32_gdkregion_to_string (region)));

      win32_gc->hcliprgn = _gdk_win32_gdkregion_to_hrgn (region, 0, 0);
      win32_gc->values_mask |= GDK_GC_CLIP_MASK;
    }
  else
    {
      GDK_NOTE (GC, g_print ("gdk_gc_set_clip_region: NULL\n"));

      win32_gc->hcliprgn = NULL;
      win32_gc->values_mask &= ~GDK_GC_CLIP_MASK;
    }

  gc->clip_x_origin = 0;
  gc->clip_y_origin = 0;
  
  win32_gc->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
}

void
gdk_gc_copy (GdkGC *dst_gc,
	     GdkGC *src_gc)
{
  GdkGCWin32 *dst_win32_gc;
  GdkGCWin32 *src_win32_gc;

  g_return_if_fail (GDK_IS_GC_WIN32 (dst_gc));
  g_return_if_fail (GDK_IS_GC_WIN32 (src_gc));
  
  dst_win32_gc = GDK_GC_WIN32 (dst_gc);
  src_win32_gc = GDK_GC_WIN32 (src_gc);

  GDK_NOTE (GC, g_print ("gdk_gc_copy: %p := %p\n", dst_win32_gc, src_win32_gc));

  if (dst_gc->colormap)
    g_object_unref (dst_gc->colormap);

  if (dst_win32_gc->hcliprgn != NULL)
    DeleteObject (dst_win32_gc->hcliprgn);

  if (dst_win32_gc->font != NULL)
    gdk_font_unref (dst_win32_gc->font);

  if (dst_win32_gc->tile != NULL)
    g_object_unref (dst_win32_gc->tile);

  if (dst_win32_gc->stipple != NULL)
    g_object_unref (dst_win32_gc->stipple);

  if (dst_win32_gc->pen_dashes)
    g_free (dst_win32_gc->pen_dashes);
  
  dst_gc->clip_x_origin = src_gc->clip_x_origin;
  dst_gc->clip_y_origin = src_gc->clip_y_origin;
  dst_gc->ts_x_origin = src_gc->ts_x_origin;
  dst_gc->ts_y_origin = src_gc->ts_y_origin;
  dst_gc->colormap = src_gc->colormap;
  if (dst_gc->colormap)
    g_object_ref (dst_gc->colormap);

  dst_win32_gc->hcliprgn = src_win32_gc->hcliprgn;
  if (dst_win32_gc->hcliprgn)
    {
      /* create a new region, to copy to */
      dst_win32_gc->hcliprgn = CreateRectRgn (0,0,1,1);
      /* overwrite from source */
      CombineRgn (dst_win32_gc->hcliprgn, src_win32_gc->hcliprgn,
		  NULL, RGN_COPY);
    }

  dst_win32_gc->values_mask = src_win32_gc->values_mask; 
  dst_win32_gc->foreground = src_win32_gc->foreground;
  dst_win32_gc->background = src_win32_gc->background;
  dst_win32_gc->font = src_win32_gc->font;
  if (dst_win32_gc->font != NULL)
    gdk_font_ref (dst_win32_gc->font);

  dst_win32_gc->rop2 = src_win32_gc->rop2;
  dst_win32_gc->fill_style = src_win32_gc->fill_style;
  dst_win32_gc->tile = src_win32_gc->tile;
  if (dst_win32_gc->tile != NULL)
    g_object_ref (dst_win32_gc->tile);

  dst_win32_gc->stipple = src_win32_gc->stipple;
  if (dst_win32_gc->stipple != NULL)
    g_object_ref (dst_win32_gc->stipple);

  dst_win32_gc->subwindow_mode = src_win32_gc->subwindow_mode;
  dst_win32_gc->graphics_exposures = src_win32_gc->graphics_exposures;
  dst_win32_gc->pen_width = src_win32_gc->pen_width;
  dst_win32_gc->pen_style = src_win32_gc->pen_style;
  dst_win32_gc->line_style = src_win32_gc->line_style;
  dst_win32_gc->cap_style = src_win32_gc->cap_style;
  dst_win32_gc->join_style = src_win32_gc->join_style;
  if (src_win32_gc->pen_dashes)
    dst_win32_gc->pen_dashes = g_memdup (src_win32_gc->pen_dashes, 
                                         sizeof (DWORD) * src_win32_gc->pen_num_dashes);
  else
    dst_win32_gc->pen_dashes = NULL;
  dst_win32_gc->pen_num_dashes = src_win32_gc->pen_num_dashes;
  dst_win32_gc->pen_dash_offset = src_win32_gc->pen_dash_offset;


  dst_win32_gc->hdc = NULL;
  dst_win32_gc->saved_dc = FALSE;
  dst_win32_gc->hwnd = NULL;
  dst_win32_gc->holdpal = NULL;
  dst_win32_gc->pen_hbrbg = NULL;
}

GdkScreen *  
gdk_gc_get_screen (GdkGC *gc)
{
  g_return_val_if_fail (GDK_IS_GC_WIN32 (gc), NULL);
  
  return _gdk_screen;
}

static guint bitmask[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };

COLORREF
_gdk_win32_colormap_color (GdkColormap *colormap,
                           gulong       pixel)
{
  const GdkVisual *visual;
  GdkColormapPrivateWin32 *colormap_private;
  guchar r, g, b;

  if (colormap == NULL)
    return DIBINDEX (pixel & 1);

  colormap_private = GDK_WIN32_COLORMAP_DATA (colormap);

  g_assert (colormap_private != NULL);

  visual = colormap->visual;
  switch (visual->type)
    {
    case GDK_VISUAL_GRAYSCALE:
    case GDK_VISUAL_PSEUDO_COLOR:
    case GDK_VISUAL_STATIC_COLOR:
      return PALETTEINDEX (pixel);

    case GDK_VISUAL_TRUE_COLOR:
      r = (pixel & visual->red_mask) >> visual->red_shift;
      r = (r * 255) / bitmask[visual->red_prec];
      g = (pixel & visual->green_mask) >> visual->green_shift;
      g = (g * 255) / bitmask[visual->green_prec];
      b = (pixel & visual->blue_mask) >> visual->blue_shift;
      b = (b * 255) / bitmask[visual->blue_prec];
      return RGB (r, g, b);

    default:
      g_assert_not_reached ();
      return 0;
    }
}

gboolean
predraw (GdkGC       *gc,
	 GdkColormap *colormap)
{
  GdkGCWin32 *win32_gc = (GdkGCWin32 *) gc;
  GdkColormapPrivateWin32 *colormap_private;
  gint k;
  gboolean ok = TRUE;

  if (colormap &&
      (colormap->visual->type == GDK_VISUAL_PSEUDO_COLOR ||
       colormap->visual->type == GDK_VISUAL_STATIC_COLOR))
    {
      colormap_private = GDK_WIN32_COLORMAP_DATA (colormap);

      g_assert (colormap_private != NULL);

      if (!(win32_gc->holdpal = SelectPalette (win32_gc->hdc, colormap_private->hpal, FALSE)))
	WIN32_GDI_FAILED ("SelectPalette"), ok = FALSE;
      else if ((k = RealizePalette (win32_gc->hdc)) == GDI_ERROR)
	WIN32_GDI_FAILED ("RealizePalette"), ok = FALSE;
      else if (k > 0)
	GDK_NOTE (COLORMAP, g_print ("predraw: realized %p: %d colors\n",
				     colormap_private->hpal, k));
    }

  return ok;
}