AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-18 17:30:10 +00:00
Code Issues Projects Releases Wiki Activity
a54f709c98
gtk/gdk/x11/gdkgc-x11.c
Manish Singh a5e9b74814 Make sure we always return a value. Return None in the fallthrough case. 
Thu Dec  2 13:18:34 2004  Manish Singh  <yosh@gimp.org>

        * gdk/x11/gdkgc-x11.c (make_fg_tile_picture): Make sure we always
        return a value. Return None in the fallthrough case.
2004-12-02 21:20:07 +00:00

1305 lines
31 KiB
C
Raw Blame History

/* GDK - The GIMP Drawing Kit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* 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.
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include <config.h>
#include "gdkalias.h"
#include "gdkgc.h"
#include "gdkprivate-x11.h"
#include "gdkregion-generic.h"
#include "gdkx.h"
#include <string.h>
typedef enum {
GDK_GC_DIRTY_CLIP = 1 << 0,
GDK_GC_DIRTY_TS = 1 << 1
} GdkGCDirtyValues;
static void gdk_x11_gc_values_to_xvalues (GdkGCValues *values,
GdkGCValuesMask mask,
XGCValues *xvalues,
unsigned long *xvalues_mask);
static void gdk_x11_gc_get_values (GdkGC *gc,
GdkGCValues *values);
static void gdk_x11_gc_set_values (GdkGC *gc,
GdkGCValues *values,
GdkGCValuesMask values_mask);
static void gdk_x11_gc_set_dashes (GdkGC *gc,
gint dash_offset,
gint8 dash_list[],
gint n);
static void gdk_gc_x11_class_init (GdkGCX11Class *klass);
static void gdk_gc_x11_finalize (GObject *object);
static gpointer parent_class = NULL;
GType
_gdk_gc_x11_get_type (void)
{
static GType object_type = 0;
if (!object_type)
{
static const GTypeInfo object_info =
{
sizeof (GdkGCX11Class),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gdk_gc_x11_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GdkGCX11),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
object_type = g_type_register_static (GDK_TYPE_GC,
"GdkGCX11",
&object_info, 0);
}
return object_type;
}
static void
gdk_gc_x11_class_init (GdkGCX11Class *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GdkGCClass *gc_class = GDK_GC_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gdk_gc_x11_finalize;
gc_class->get_values = gdk_x11_gc_get_values;
gc_class->set_values = gdk_x11_gc_set_values;
gc_class->set_dashes = gdk_x11_gc_set_dashes;
}
static void
gdk_gc_x11_finalize (GObject *object)
{
GdkGCX11 *x11_gc = GDK_GC_X11 (object);
if (x11_gc->clip_region)
gdk_region_destroy (x11_gc->clip_region);
if (x11_gc->fg_picture != None)
XRenderFreePicture (GDK_GC_XDISPLAY (x11_gc), x11_gc->fg_picture);
if (x11_gc->stipple)
g_object_unref (x11_gc->stipple);
if (x11_gc->tile)
g_object_unref (x11_gc->tile);
XFreeGC (GDK_GC_XDISPLAY (x11_gc), GDK_GC_XGC (x11_gc));
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GdkGC *
_gdk_x11_gc_new (GdkDrawable *drawable,
GdkGCValues *values,
GdkGCValuesMask values_mask)
{
GdkGC *gc;
GdkGCX11 *private;
XGCValues xvalues;
unsigned long xvalues_mask;
/* 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_X11 (drawable), NULL);
gc = g_object_new (_gdk_gc_x11_get_type (), NULL);
private = GDK_GC_X11 (gc);
private->dirty_mask = 0;
private->have_clip_mask = FALSE;
private->clip_region = NULL;
private->screen = GDK_DRAWABLE_IMPL_X11 (drawable)->screen;
private->depth = gdk_drawable_get_depth (drawable);
if (values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN))
{
values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
private->dirty_mask |= GDK_GC_DIRTY_CLIP;
}
if (values_mask & (GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN))
{
values_mask &= ~(GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN);
private->dirty_mask |= GDK_GC_DIRTY_TS;
}
if (values_mask & GDK_GC_FOREGROUND)
private->fg_pixel = values->foreground.pixel;
if (values_mask & GDK_GC_BACKGROUND)
private->bg_pixel = values->background.pixel;
if (values_mask & GDK_GC_FILL)
private->fill = values->fill;
if (values_mask & GDK_GC_STIPPLE)
{
private->stipple = values->stipple;
if (private->stipple)
g_object_ref (private->stipple);
}
if (values_mask & GDK_GC_TILE)
{
private->tile = values->tile;
if (private->tile)
g_object_ref (private->tile);
}
if ((values_mask & GDK_GC_CLIP_MASK) && values->clip_mask)
private->have_clip_mask = TRUE;
xvalues.function = GXcopy;
xvalues.fill_style = FillSolid;
xvalues.arc_mode = ArcPieSlice;
xvalues.subwindow_mode = ClipByChildren;
xvalues.graphics_exposures = False;
xvalues_mask = GCFunction | GCFillStyle | GCArcMode | GCSubwindowMode | GCGraphicsExposures;
gdk_x11_gc_values_to_xvalues (values, values_mask, &xvalues, &xvalues_mask);
private->xgc = XCreateGC (GDK_GC_XDISPLAY (gc),
GDK_DRAWABLE_IMPL_X11 (drawable)->xid,
xvalues_mask, &xvalues);
return gc;
}
GC
_gdk_x11_gc_flush (GdkGC *gc)
{
Display *xdisplay = GDK_GC_XDISPLAY (gc);
GdkGCX11 *private = GDK_GC_X11 (gc);
GC xgc = private->xgc;
if (private->dirty_mask & GDK_GC_DIRTY_CLIP)
{
if (!private->clip_region)
XSetClipOrigin (xdisplay, xgc,
gc->clip_x_origin, gc->clip_y_origin);
else
{
XRectangle *rectangles;
gint n_rects;
_gdk_region_get_xrectangles (private->clip_region,
gc->clip_x_origin,
gc->clip_y_origin,
&rectangles,
&n_rects);
XSetClipRectangles (xdisplay, xgc, 0, 0,
rectangles,
n_rects, YXBanded);
g_free (rectangles);
}
}
if (private->dirty_mask & GDK_GC_DIRTY_TS)
{
XSetTSOrigin (xdisplay, xgc,
gc->ts_x_origin, gc->ts_y_origin);
}
private->dirty_mask = 0;
return xgc;
}
static void
gdk_x11_gc_get_values (GdkGC *gc,
GdkGCValues *values)
{
XGCValues xvalues;
if (XGetGCValues (GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc),
GCForeground | GCBackground | GCFont |
GCFunction | GCTile | GCStipple | /* GCClipMask | */
GCSubwindowMode | GCGraphicsExposures |
GCTileStipXOrigin | GCTileStipYOrigin |
GCClipXOrigin | GCClipYOrigin |
GCLineWidth | GCLineStyle | GCCapStyle |
GCFillStyle | GCJoinStyle, &xvalues))
{
values->foreground.pixel = xvalues.foreground;
values->background.pixel = xvalues.background;
values->font = gdk_font_lookup_for_display (GDK_GC_DISPLAY (gc),
xvalues.font);
switch (xvalues.function)
{
case GXcopy:
values->function = GDK_COPY;
break;
case GXinvert:
values->function = GDK_INVERT;
break;
case GXxor:
values->function = GDK_XOR;
break;
case GXclear:
values->function = GDK_CLEAR;
break;
case GXand:
values->function = GDK_AND;
break;
case GXandReverse:
values->function = GDK_AND_REVERSE;
break;
case GXandInverted:
values->function = GDK_AND_INVERT;
break;
case GXnoop:
values->function = GDK_NOOP;
break;
case GXor:
values->function = GDK_OR;
break;
case GXequiv:
values->function = GDK_EQUIV;
break;
case GXorReverse:
values->function = GDK_OR_REVERSE;
break;
case GXcopyInverted:
values->function =GDK_COPY_INVERT;
break;
case GXorInverted:
values->function = GDK_OR_INVERT;
break;
case GXnand:
values->function = GDK_NAND;
break;
case GXset:
values->function = GDK_SET;
break;
case GXnor:
values->function = GDK_NOR;
break;
}
switch (xvalues.fill_style)
{
case FillSolid:
values->fill = GDK_SOLID;
break;
case FillTiled:
values->fill = GDK_TILED;
break;
case FillStippled:
values->fill = GDK_STIPPLED;
break;
case FillOpaqueStippled:
values->fill = GDK_OPAQUE_STIPPLED;
break;
}
values->tile = gdk_pixmap_lookup_for_display (GDK_GC_DISPLAY (gc),
xvalues.tile);
values->stipple = gdk_pixmap_lookup_for_display (GDK_GC_DISPLAY (gc),
xvalues.stipple);
values->clip_mask = NULL;
values->subwindow_mode = xvalues.subwindow_mode;
values->ts_x_origin = xvalues.ts_x_origin;
values->ts_y_origin = xvalues.ts_y_origin;
values->clip_x_origin = xvalues.clip_x_origin;
values->clip_y_origin = xvalues.clip_y_origin;
values->graphics_exposures = xvalues.graphics_exposures;
values->line_width = xvalues.line_width;
switch (xvalues.line_style)
{
case LineSolid:
values->line_style = GDK_LINE_SOLID;
break;
case LineOnOffDash:
values->line_style = GDK_LINE_ON_OFF_DASH;
break;
case LineDoubleDash:
values->line_style = GDK_LINE_DOUBLE_DASH;
break;
}
switch (xvalues.cap_style)
{
case CapNotLast:
values->cap_style = GDK_CAP_NOT_LAST;
break;
case CapButt:
values->cap_style = GDK_CAP_BUTT;
break;
case CapRound:
values->cap_style = GDK_CAP_ROUND;
break;
case CapProjecting:
values->cap_style = GDK_CAP_PROJECTING;
break;
}
switch (xvalues.join_style)
{
case JoinMiter:
values->join_style = GDK_JOIN_MITER;
break;
case JoinRound:
values->join_style = GDK_JOIN_ROUND;
break;
case JoinBevel:
values->join_style = GDK_JOIN_BEVEL;
break;
}
}
else
{
memset (values, 0, sizeof (GdkGCValues));
}
}
static void
clear_fg_picture (GdkGC *gc)
{
GdkGCX11 *x11_gc = GDK_GC_X11 (gc);
if (x11_gc->fg_picture != None)
{
XRenderFreePicture (GDK_GC_XDISPLAY (x11_gc), x11_gc->fg_picture);
x11_gc->fg_picture = None;
}
}
static void
gdk_x11_gc_set_values (GdkGC *gc,
GdkGCValues *values,
GdkGCValuesMask values_mask)
{
GdkGCX11 *x11_gc;
XGCValues xvalues;
unsigned long xvalues_mask = 0;
x11_gc = GDK_GC_X11 (gc);
if (values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN))
{
values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
x11_gc->dirty_mask |= GDK_GC_DIRTY_CLIP;
}
if (values_mask & (GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN))
{
values_mask &= ~(GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN);
x11_gc->dirty_mask |= GDK_GC_DIRTY_TS;
}
if (values_mask & GDK_GC_CLIP_MASK)
{
if (x11_gc->clip_region)
{
gdk_region_destroy (x11_gc->clip_region);
x11_gc->clip_region = NULL;
}
x11_gc->have_clip_mask = values->clip_mask != NULL;
}
if (values_mask & GDK_GC_FOREGROUND)
x11_gc->fg_pixel = values->foreground.pixel;
if (values_mask & GDK_GC_BACKGROUND)
{
if (x11_gc->bg_pixel != values->background.pixel)
{
x11_gc->bg_pixel = values->background.pixel;
if (x11_gc->fill == GDK_OPAQUE_STIPPLED)
clear_fg_picture (gc);
}
}
if (values_mask & GDK_GC_FILL)
{
if (x11_gc->fill != values->fill)
{
clear_fg_picture (gc);
x11_gc->fill = values->fill;
}
}
if (values_mask & GDK_GC_STIPPLE)
{
if (x11_gc->stipple != values->stipple)
{
if (x11_gc->fill == GDK_STIPPLED || x11_gc->fill == GDK_OPAQUE_STIPPLED)
clear_fg_picture (gc);
if (x11_gc->stipple)
g_object_unref (x11_gc->stipple);
x11_gc->stipple = values->stipple;
if (x11_gc->stipple)
g_object_ref (x11_gc->stipple);
}
}
if (values_mask & GDK_GC_TILE)
{
if (x11_gc->tile != values->tile)
{
if (x11_gc->fill == GDK_TILED)
clear_fg_picture (gc);
if (x11_gc->tile)
g_object_unref (x11_gc->tile);
x11_gc->tile = values->tile;
if (x11_gc->tile)
g_object_ref (x11_gc->tile);
}
}
gdk_x11_gc_values_to_xvalues (values, values_mask, &xvalues, &xvalues_mask);
XChangeGC (GDK_GC_XDISPLAY (gc),
GDK_GC_XGC (gc),
xvalues_mask,
&xvalues);
}
static void
gdk_x11_gc_set_dashes (GdkGC *gc,
gint dash_offset,
gint8 dash_list[],
gint n)
{
g_return_if_fail (GDK_IS_GC (gc));
g_return_if_fail (dash_list != NULL);
XSetDashes (GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc),
dash_offset, dash_list, n);
}
static void
gdk_x11_gc_values_to_xvalues (GdkGCValues *values,
GdkGCValuesMask mask,
XGCValues *xvalues,
unsigned long *xvalues_mask)
{
/* Optimization for the common case (gdk_gc_new()) */
if (values == NULL || mask == 0)
return;
if (mask & GDK_GC_FOREGROUND)
{
xvalues->foreground = values->foreground.pixel;
*xvalues_mask |= GCForeground;
}
if (mask & GDK_GC_BACKGROUND)
{
xvalues->background = values->background.pixel;
*xvalues_mask |= GCBackground;
}
if ((mask & GDK_GC_FONT) && (values->font->type == GDK_FONT_FONT))
{
xvalues->font = ((XFontStruct *) (GDK_FONT_XFONT (values->font)))->fid;
*xvalues_mask |= GCFont;
}
if (mask & GDK_GC_FUNCTION)
{
switch (values->function)
{
case GDK_COPY:
xvalues->function = GXcopy;
break;
case GDK_INVERT:
xvalues->function = GXinvert;
break;
case GDK_XOR:
xvalues->function = GXxor;
break;
case GDK_CLEAR:
xvalues->function = GXclear;
break;
case GDK_AND:
xvalues->function = GXand;
break;
case GDK_AND_REVERSE:
xvalues->function = GXandReverse;
break;
case GDK_AND_INVERT:
xvalues->function = GXandInverted;
break;
case GDK_NOOP:
xvalues->function = GXnoop;
break;
case GDK_OR:
xvalues->function = GXor;
break;
case GDK_EQUIV:
xvalues->function = GXequiv;
break;
case GDK_OR_REVERSE:
xvalues->function = GXorReverse;
break;
case GDK_COPY_INVERT:
xvalues->function = GXcopyInverted;
break;
case GDK_OR_INVERT:
xvalues->function = GXorInverted;
break;
case GDK_NAND:
xvalues->function = GXnand;
break;
case GDK_SET:
xvalues->function = GXset;
break;
case GDK_NOR:
xvalues->function = GXnor;
break;
}
*xvalues_mask |= GCFunction;
}
if (mask & GDK_GC_FILL)
{
switch (values->fill)
{
case GDK_SOLID:
xvalues->fill_style = FillSolid;
break;
case GDK_TILED:
xvalues->fill_style = FillTiled;
break;
case GDK_STIPPLED:
xvalues->fill_style = FillStippled;
break;
case GDK_OPAQUE_STIPPLED:
xvalues->fill_style = FillOpaqueStippled;
break;
}
*xvalues_mask |= GCFillStyle;
}
if (mask & GDK_GC_TILE)
{
if (values->tile)
xvalues->tile = GDK_DRAWABLE_XID (values->tile);
else
xvalues->tile = None;
*xvalues_mask |= GCTile;
}
if (mask & GDK_GC_STIPPLE)
{
if (values->stipple)
xvalues->stipple = GDK_DRAWABLE_XID (values->stipple);
else
xvalues->stipple = None;
*xvalues_mask |= GCStipple;
}
if (mask & GDK_GC_CLIP_MASK)
{
if (values->clip_mask)
xvalues->clip_mask = GDK_DRAWABLE_XID (values->clip_mask);
else
xvalues->clip_mask = None;
*xvalues_mask |= GCClipMask;
}
if (mask & GDK_GC_SUBWINDOW)
{
xvalues->subwindow_mode = values->subwindow_mode;
*xvalues_mask |= GCSubwindowMode;
}
if (mask & GDK_GC_TS_X_ORIGIN)
{
xvalues->ts_x_origin = values->ts_x_origin;
*xvalues_mask |= GCTileStipXOrigin;
}
if (mask & GDK_GC_TS_Y_ORIGIN)
{
xvalues->ts_y_origin = values->ts_y_origin;
*xvalues_mask |= GCTileStipYOrigin;
}
if (mask & GDK_GC_CLIP_X_ORIGIN)
{
xvalues->clip_x_origin = values->clip_x_origin;
*xvalues_mask |= GCClipXOrigin;
}
if (mask & GDK_GC_CLIP_Y_ORIGIN)
{
xvalues->clip_y_origin = values->clip_y_origin;
*xvalues_mask |= GCClipYOrigin;
}
if (mask & GDK_GC_EXPOSURES)
{
xvalues->graphics_exposures = values->graphics_exposures;
*xvalues_mask |= GCGraphicsExposures;
}
if (mask & GDK_GC_LINE_WIDTH)
{
xvalues->line_width = values->line_width;
*xvalues_mask |= GCLineWidth;
}
if (mask & GDK_GC_LINE_STYLE)
{
switch (values->line_style)
{
case GDK_LINE_SOLID:
xvalues->line_style = LineSolid;
break;
case GDK_LINE_ON_OFF_DASH:
xvalues->line_style = LineOnOffDash;
break;
case GDK_LINE_DOUBLE_DASH:
xvalues->line_style = LineDoubleDash;
break;
}
*xvalues_mask |= GCLineStyle;
}
if (mask & GDK_GC_CAP_STYLE)
{
switch (values->cap_style)
{
case GDK_CAP_NOT_LAST:
xvalues->cap_style = CapNotLast;
break;
case GDK_CAP_BUTT:
xvalues->cap_style = CapButt;
break;
case GDK_CAP_ROUND:
xvalues->cap_style = CapRound;
break;
case GDK_CAP_PROJECTING:
xvalues->cap_style = CapProjecting;
break;
}
*xvalues_mask |= GCCapStyle;
}
if (mask & GDK_GC_JOIN_STYLE)
{
switch (values->join_style)
{
case GDK_JOIN_MITER:
xvalues->join_style = JoinMiter;
break;
case GDK_JOIN_ROUND:
xvalues->join_style = JoinRound;
break;
case GDK_JOIN_BEVEL:
xvalues->join_style = JoinBevel;
break;
}
*xvalues_mask |= GCJoinStyle;
}
}
/**
* gdk_gc_set_clip_rectangle:
* @gc: a #GdkGC.
* @rectangle: the rectangle to clip to.
*
* Sets the clip mask for a graphics context from a
* rectangle. The clip mask is interpreted relative to the clip
* origin. (See gdk_gc_set_clip_origin()).
**/
void
gdk_gc_set_clip_rectangle (GdkGC *gc,
GdkRectangle *rectangle)
{
GdkGCX11 *x11_gc;
gboolean had_region = FALSE;
g_return_if_fail (GDK_IS_GC (gc));
x11_gc = GDK_GC_X11 (gc);
if (x11_gc->clip_region)
{
had_region = TRUE;
gdk_region_destroy (x11_gc->clip_region);
}
if (rectangle)
x11_gc->clip_region = gdk_region_rectangle (rectangle);
else
x11_gc->clip_region = NULL;
/* Unset immediately, to make sure Xlib doesn't keep the
* XID of an old clip mask cached
*/
if ((had_region && !rectangle) || x11_gc->have_clip_mask)
{
XSetClipMask (GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc), None);
x11_gc->have_clip_mask = FALSE;
}
gc->clip_x_origin = 0;
gc->clip_y_origin = 0;
x11_gc->dirty_mask |= GDK_GC_DIRTY_CLIP;
}
/**
* gdk_gc_set_clip_region:
* @gc: a #GdkGC.
* @region: the #GdkRegion.
*
* Sets the clip mask for a graphics context from a region structure.
* The clip mask is interpreted relative to the clip origin. (See
* gdk_gc_set_clip_origin()).
**/
void
gdk_gc_set_clip_region (GdkGC *gc,
GdkRegion *region)
{
GdkGCX11 *x11_gc;
gboolean had_region = FALSE;
g_return_if_fail (GDK_IS_GC (gc));
x11_gc = GDK_GC_X11 (gc);
if (x11_gc->clip_region)
{
had_region = TRUE;
gdk_region_destroy (x11_gc->clip_region);
}
if (region)
x11_gc->clip_region = gdk_region_copy (region);
else
x11_gc->clip_region = NULL;
/* Unset immediately, to make sure Xlib doesn't keep the
* XID of an old clip mask cached
*/
if ((had_region && !region) || x11_gc->have_clip_mask)
{
XSetClipMask (GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc), None);
x11_gc->have_clip_mask = FALSE;
}
gc->clip_x_origin = 0;
gc->clip_y_origin = 0;
x11_gc->dirty_mask |= GDK_GC_DIRTY_CLIP;
}
/**
* gdk_gc_copy:
* @dst_gc: the destination graphics context.
* @src_gc: the source graphics context.
*
* Copy the set of values from one graphics context
* onto another graphics context.
**/
void
gdk_gc_copy (GdkGC *dst_gc, GdkGC *src_gc)
{
GdkGCX11 *x11_src_gc;
GdkGCX11 *x11_dst_gc;
g_return_if_fail (GDK_IS_GC_X11 (dst_gc));
g_return_if_fail (GDK_IS_GC_X11 (src_gc));
x11_dst_gc = GDK_GC_X11 (dst_gc);
x11_src_gc = GDK_GC_X11 (src_gc);
XCopyGC (GDK_GC_XDISPLAY (src_gc), GDK_GC_XGC (src_gc), ~((~1) << GCLastBit),
GDK_GC_XGC (dst_gc));
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;
if (src_gc->colormap)
g_object_ref (src_gc->colormap);
if (dst_gc->colormap)
g_object_unref (dst_gc->colormap);
dst_gc->colormap = src_gc->colormap;
if (x11_dst_gc->clip_region)
gdk_region_destroy (x11_dst_gc->clip_region);
if (x11_src_gc->clip_region)
x11_dst_gc->clip_region = gdk_region_copy (x11_src_gc->clip_region);
else
x11_dst_gc->clip_region = NULL;
x11_dst_gc->dirty_mask = x11_src_gc->dirty_mask;
x11_dst_gc->fg_pixel = x11_src_gc->fg_pixel;
x11_dst_gc->fill = x11_src_gc->fill;
if (x11_dst_gc->stipple)
g_object_unref (x11_dst_gc->stipple);
x11_dst_gc->stipple = x11_src_gc->stipple;
if (x11_dst_gc->stipple)
g_object_ref (x11_dst_gc->stipple);
if (x11_dst_gc->tile)
g_object_unref (x11_dst_gc->tile);
x11_dst_gc->tile = x11_src_gc->tile;
if (x11_dst_gc->tile)
g_object_ref (x11_dst_gc->tile);
clear_fg_picture (dst_gc);
}
/**
* gdk_gc_get_screen:
* @gc: a #GdkGC.
*
* Gets the #GdkScreen for which @gc was created
*
* Returns: the #GdkScreen for @gc.
*
* Since: 2.2
*/
GdkScreen *
gdk_gc_get_screen (GdkGC *gc)
{
g_return_val_if_fail (GDK_IS_GC_X11 (gc), NULL);
return GDK_GC_X11 (gc)->screen;
}
/**
* gdk_x11_gc_get_xdisplay:
* @gc: a #GdkGC.
*
* Returns the display of a #GdkGC.
*
* Return value: an Xlib <type>Display*</type>.
**/
Display *
gdk_x11_gc_get_xdisplay (GdkGC *gc)
{
g_return_val_if_fail (GDK_IS_GC_X11 (gc), NULL);
return GDK_SCREEN_XDISPLAY (gdk_gc_get_screen (gc));
}
/**
* gdk_x11_gc_get_xgc:
* @gc: a #GdkGC.
*
* Returns the X GC of a #GdkGC.
*
* Return value: an Xlib <type>GC</type>.
**/
GC
gdk_x11_gc_get_xgc (GdkGC *gc)
{
GdkGCX11 *gc_x11;
g_return_val_if_fail (GDK_IS_GC_X11 (gc), NULL);
gc_x11 = GDK_GC_X11 (gc);
if (gc_x11->dirty_mask)
_gdk_x11_gc_flush (gc);
return gc_x11->xgc;
}
/* Various bits of the below are roughly cribbed from XFree86
* lib/Xft/xftdraw.c, Copyright 2000, Keith Packard
*/
static XRenderPictFormat *
foreground_format (GdkGC *gc)
{
XRenderPictFormat pf;
pf.type = PictTypeDirect;
pf.depth = 32;
pf.direct.redMask = 0xff;
pf.direct.greenMask = 0xff;
pf.direct.blueMask = 0xff;
pf.direct.alphaMask = 0xff;
return XRenderFindFormat (GDK_GC_XDISPLAY (gc),
(PictFormatType |
PictFormatDepth |
PictFormatRedMask |
PictFormatGreenMask |
PictFormatBlueMask |
PictFormatAlphaMask),
&pf,
0);
}
static Picture
make_fg_tile_picture (GdkGC *gc)
{
GdkGCX11 *x11_gc = GDK_GC_X11 (gc);
GdkVisual *visual = gdk_drawable_get_visual (x11_gc->tile);
XRenderPictFormat *format = NULL;
if (visual)
{
format = XRenderFindVisualFormat (GDK_GC_XDISPLAY (gc),
GDK_VISUAL_XVISUAL (visual));
}
else if (x11_gc->depth == 1)
{
format = XRenderFindStandardFormat (GDK_GC_XDISPLAY (gc),
PictStandardA1);
}
if (format)
{
XRenderPictureAttributes pa;
pa.repeat = True;
return XRenderCreatePicture (GDK_GC_XDISPLAY (gc),
GDK_PIXMAP_XID (x11_gc->tile),
format,
CPRepeat, &pa);
}
return None;
}
static Picture
make_stipple_picture (GdkGC *gc)
{
GdkGCX11 *x11_gc = GDK_GC_X11 (gc);
XRenderPictFormat *format = NULL;
XRenderPictureAttributes pa;
format = XRenderFindStandardFormat (GDK_GC_XDISPLAY (gc),
PictStandardA1);
pa.repeat = True;
return XRenderCreatePicture (GDK_GC_XDISPLAY (gc),
GDK_PIXMAP_XID (x11_gc->stipple),
format,
CPRepeat, &pa);
}
static Picture
make_color_picture (GdkGC *gc,
XRenderColor *color)
{
GdkGCX11 *x11_gc = GDK_GC_X11 (gc);
XRenderPictureAttributes pa;
XRenderPictFormat *pix_format = foreground_format (gc);
Pixmap pix;
Picture picture;
if (!pix_format)
return None;
pix = XCreatePixmap (GDK_GC_XDISPLAY (gc),
GDK_SCREEN_XROOTWIN (x11_gc->screen),
1, 1, pix_format->depth);
pa.repeat = True;
picture = XRenderCreatePicture (GDK_GC_XDISPLAY (gc),
pix,
pix_format,
CPRepeat, &pa);
XFreePixmap (GDK_GC_XDISPLAY (gc), pix);
XRenderFillRectangle (GDK_GC_XDISPLAY (gc), PictOpSrc,
picture, color,
0, 0, 1, 1);
return picture;
}
static void
get_bg_color (GdkGC *gc,
XRenderColor *render_color)
{
GdkGCX11 *x11_gc = GDK_GC_X11 (gc);
GdkColormap *cmap;
cmap = gdk_gc_get_colormap (gc);
if (cmap)
{
GdkColor color;
gdk_colormap_query_color (cmap, x11_gc->bg_pixel, &color);
render_color->alpha = 0xffff;
render_color->red = color.red;
render_color->green = color.green;
render_color->blue = color.blue;
}
else /* Not worth warning, just use black */
{
render_color->alpha = 0xffff;
render_color->red = 0;
render_color->green = 0;
render_color->blue = 0;
}
}
/**
* _gdk_x11_gc_get_fg_picture:
* @gc: a #GdkGC
*
* Gets a Xrender Picture object suitable for being the source
* drawable for drawing with the foreground the graphics context.
*
* Return value: a Picture, owned by the GC; this cannot be
* used over subsequent modification of the GC.
**/
Picture
_gdk_x11_gc_get_fg_picture (GdkGC *gc)
{
GdkGCX11 *x11_gc;
gboolean new = FALSE;
XftColor xftcolor;
GdkFill fill;
int width, height;
g_return_val_if_fail (GDK_IS_GC_X11 (gc), None);
if (!_gdk_x11_have_render (GDK_GC_DISPLAY (gc)))
return None;
x11_gc = GDK_GC_X11 (gc);
fill = GDK_SOLID;
width = 1;
height = 1;
switch (x11_gc->fill)
{
case GDK_SOLID:
break;
case GDK_TILED:
if (x11_gc->tile)
{
if (!x11_gc->fg_picture)
x11_gc->fg_picture = make_fg_tile_picture (gc);
if (x11_gc->fg_picture != None)
return x11_gc->fg_picture;
}
break;
case GDK_STIPPLED:
case GDK_OPAQUE_STIPPLED:
if (x11_gc->stipple)
{
gdk_drawable_get_size (x11_gc->stipple, &width, &height);
fill = x11_gc->fill;
}
break;
}
if (x11_gc->fg_picture == None)
{
XRenderPictureAttributes pa;
XRenderPictFormat *pix_format = foreground_format (gc);
Pixmap pix;
if (!pix_format)
return None;
pix = XCreatePixmap (GDK_GC_XDISPLAY (gc),
GDK_SCREEN_XROOTWIN (x11_gc->screen),
width, height, pix_format->depth);
pa.repeat = True;
x11_gc->fg_picture = XRenderCreatePicture (GDK_GC_XDISPLAY (gc),
pix,
pix_format,
CPRepeat, &pa);
XFreePixmap (GDK_GC_XDISPLAY (gc), pix);
new = TRUE;
}
_gdk_gc_x11_get_fg_xft_color (gc, &xftcolor);
if (x11_gc->fg_picture_color.alpha != 0xffff ||
x11_gc->fg_picture_color.red != xftcolor.color.red ||
x11_gc->fg_picture_color.green != xftcolor.color.green ||
x11_gc->fg_picture_color.blue != xftcolor.color.blue)
{
x11_gc->fg_picture_color.alpha = 0xffff;
x11_gc->fg_picture_color.red = xftcolor.color.red;
x11_gc->fg_picture_color.green = xftcolor.color.green;
x11_gc->fg_picture_color.blue = xftcolor.color.blue;
new = TRUE;
}
switch (fill)
{
case GDK_SOLID:
XRenderFillRectangle (GDK_GC_XDISPLAY (gc), PictOpSrc,
x11_gc->fg_picture, &x11_gc->fg_picture_color,
0, 0, width, height);
break;
case GDK_STIPPLED:
{
Picture stipple_picture = make_stipple_picture (gc);
XRenderFillRectangle (GDK_GC_XDISPLAY (gc), PictOpSrc,
x11_gc->fg_picture, &x11_gc->fg_picture_color,
0, 0, width, height);
XRenderComposite (GDK_GC_XDISPLAY (gc),
PictOpInReverse,
stipple_picture, None, x11_gc->fg_picture,
0, 0, 0, 0, 0, 0, width, height);
XRenderFreePicture (GDK_GC_XDISPLAY (x11_gc), stipple_picture);
}
break;
case GDK_OPAQUE_STIPPLED:
{
XRenderColor bg_color;
Picture stipple_picture = make_stipple_picture (gc);
Picture fg_picture = make_color_picture (gc, &x11_gc->fg_picture_color);
get_bg_color (gc, &bg_color);
XRenderFillRectangle (GDK_GC_XDISPLAY (gc), PictOpSrc,
x11_gc->fg_picture, &bg_color,
0, 0, width, height);
XRenderComposite (GDK_GC_XDISPLAY (gc),
PictOpOver,
fg_picture, stipple_picture, x11_gc->fg_picture,
0, 0, 0, 0, 0, 0, width, height);
XRenderFreePicture (GDK_GC_XDISPLAY (x11_gc), stipple_picture);
XRenderFreePicture (GDK_GC_XDISPLAY (x11_gc), fg_picture);
}
break;
case GDK_TILED:
g_assert_not_reached (); /* handled above */
break;
}
return x11_gc->fg_picture;
}
/**
* _gdk_gc_x11_get_fg_xft_color:
* @gc: a #GdkGC
* @xftcolor: location to store the color
*
* Gets the foreground color of the GC as a XftColor.
**/
void
_gdk_gc_x11_get_fg_xft_color (GdkGC *gc,
XftColor *xftcolor)
{
GdkGCX11 *x11_gc;
GdkColormap *cmap;
GdkColor color;
g_return_if_fail (GDK_IS_GC_X11 (gc));
x11_gc = GDK_GC_X11 (gc);
cmap = gdk_gc_get_colormap (gc);
xftcolor->pixel = x11_gc->fg_pixel;
if (cmap)
{
gdk_colormap_query_color (cmap, xftcolor->pixel, &color);
xftcolor->color.alpha = 0xffff;
xftcolor->color.red = color.red;
xftcolor->color.green = color.green;
xftcolor->color.blue = color.blue;
}
else if (x11_gc->depth == 1)
{
/* Drawing with Xft on a bitmap is a bit bizzare; it
* takes alpha >= 0x8000 to mean 'set to 1' and
* alpha < 0x8000 to mean 'set to 0'.
*/
if (xftcolor->pixel)
{
xftcolor->color.red = 0xffff;
xftcolor->color.green = 0xffff;
xftcolor->color.blue = 0xffff;
xftcolor->color.alpha = 0xffff;
}
else
{
xftcolor->color.red = 0;
xftcolor->color.green = 0;
xftcolor->color.blue = 0;
xftcolor->color.alpha = 0;
}
}
else
{
g_warning ("Using Xft rendering requires the GC argument to have a\n"
"specified colormap. If the GC was created for a drawable\n"
"with a colormap, the colormap will be set on the GC\n"
"automatically. Otherwise, a colormap must be set on it with"
"gdk_gc_set_colormap");
}
}
void
_gdk_windowing_gc_get_foreground (GdkGC *gc,
GdkColor *color)
{
GdkGCX11 *x11_gc;
GdkColormap *cmap;
g_return_if_fail (GDK_IS_GC_X11 (gc));
x11_gc = GDK_GC_X11 (gc);
color->pixel = x11_gc->fg_pixel;
cmap = gdk_gc_get_colormap (gc);
if (cmap)
gdk_colormap_query_color (cmap, x11_gc->fg_pixel, color);
else
g_warning ("No colormap in _gdk_windowing_gc_get_foreground");
}
Reference in New Issue View Git Blame Copy Permalink