shared_source/c_tk_base_7_5_w_mods/xgc.c

/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/xgc.c,v 1.1.1.1 2001/06/13 05:15:43 dtashley Exp $ */

/* 
 * xgc.c --
 *
 *      This file contains generic routines for manipulating X graphics
 *      contexts. 
 *
 * Copyright (c) 1995-1996 Sun Microsystems, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: xgc.c,v 1.1.1.1 2001/06/13 05:15:43 dtashley Exp $
 */

#include "tkInt.h"

#ifdef MAC_TCL
#       include <Xlib.h>
#       include <X.h>
#       define Cursor XCursor
#       define Region XRegion
#else
#       include "Xlib.h"
#endif


/*
 *----------------------------------------------------------------------
 *
 * XCreateGC --
 *
 *      Allocate a new GC, and initialize the specified fields.
 *
 * Results:
 *      Returns a newly allocated GC. 
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

GC
XCreateGC(display, d, mask, values)
    Display* display;
    Drawable d;
    unsigned long mask;
    XGCValues* values;
{
    GC gp;

/*
 * In order to have room for a dash list, MAX_DASH_LIST_SIZE extra chars are
 * defined, which is invisible from the outside. The list is assumed to end
 * with a 0-char, so this must be set explicitely during initialization.
 */

#define MAX_DASH_LIST_SIZE 10

    gp = (XGCValues *)ckalloc(sizeof(XGCValues) + MAX_DASH_LIST_SIZE);
    if (!gp) {
        return None;
    }

    gp->function =      (mask & GCFunction)     ?values->function       :GXcopy;
    gp->plane_mask =    (mask & GCPlaneMask)    ?values->plane_mask     :~0;
    gp->foreground =    (mask & GCForeground)   ?values->foreground     :0;
    gp->background =    (mask & GCBackground)   ?values->background     :0xffffff;
    gp->line_width =    (mask & GCLineWidth)    ?values->line_width     :0;     
    gp->line_style =    (mask & GCLineStyle)    ?values->line_style     :LineSolid;
    gp->cap_style =     (mask & GCCapStyle)     ?values->cap_style      :0;
    gp->join_style =    (mask & GCJoinStyle)    ?values->join_style     :0;
    gp->fill_style =    (mask & GCFillStyle)    ?values->fill_style     :FillSolid;
    gp->fill_rule =     (mask & GCFillRule)     ?values->fill_rule      :WindingRule;
    gp->arc_mode =      (mask & GCArcMode)      ?values->arc_mode       :ArcPieSlice;
    gp->tile =          (mask & GCTile)         ?values->tile           :None;
    gp->stipple =       (mask & GCStipple)      ?values->stipple        :None;
    gp->ts_x_origin =   (mask & GCTileStipXOrigin)      ?values->ts_x_origin:0;
    gp->ts_y_origin =   (mask & GCTileStipYOrigin)      ?values->ts_y_origin:0;
    gp->font =          (mask & GCFont)         ?values->font           :None;
    gp->subwindow_mode = (mask & GCSubwindowMode)?values->subwindow_mode:ClipByChildren;
    gp->graphics_exposures = (mask & GCGraphicsExposures)?values->graphics_exposures:True;
    gp->clip_x_origin = (mask & GCClipXOrigin)  ?values->clip_x_origin  :0;
    gp->clip_y_origin = (mask & GCClipYOrigin)  ?values->clip_y_origin  :0;
    gp->dash_offset =   (mask & GCDashOffset)   ?values->dash_offset    :0;
    gp->dashes =        (mask & GCDashList)     ?values->dashes         :4;
    (&(gp->dashes))[1] =        0;

    if (mask & GCClipMask) {
        gp->clip_mask = (Pixmap)ckalloc(sizeof(TkpClipMask));
        ((TkpClipMask*)gp->clip_mask)->type = TKP_CLIP_PIXMAP;
        ((TkpClipMask*)gp->clip_mask)->value.pixmap = values->clip_mask;
    } else {
        gp->clip_mask = None;
    }

    return gp;
}

/*
 *----------------------------------------------------------------------
 *
 * XChangeGC --
 *
 *      Changes the GC components specified by valuemask for the
 *      specified GC.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Updates the specified GC.
 *
 *----------------------------------------------------------------------
 */

void
XChangeGC(d, gc, mask, values)
    Display * d;
    GC gc;
    unsigned long mask;
    XGCValues *values;
{
    if (mask & GCFunction) { gc->function = values->function; }
    if (mask & GCPlaneMask) { gc->plane_mask = values->plane_mask; }
    if (mask & GCForeground) { gc->foreground = values->foreground; }
    if (mask & GCBackground) { gc->background = values->background; }
    if (mask & GCLineWidth) { gc->line_width = values->line_width; }    
    if (mask & GCLineStyle) { gc->line_style = values->line_style; }
    if (mask & GCCapStyle) { gc->cap_style = values->cap_style; }
    if (mask & GCJoinStyle) { gc->join_style = values->join_style; }
    if (mask & GCFillStyle) { gc->fill_style = values->fill_style; }
    if (mask & GCFillRule) { gc->fill_rule = values->fill_rule; }
    if (mask & GCArcMode) { gc->arc_mode = values->arc_mode; }
    if (mask & GCTile) { gc->tile = values->tile; }
    if (mask & GCStipple) { gc->stipple = values->stipple; }
    if (mask & GCTileStipXOrigin) { gc->ts_x_origin = values->ts_x_origin; }
    if (mask & GCTileStipYOrigin) { gc->ts_y_origin = values->ts_y_origin; }
    if (mask & GCFont) { gc->font = values->font; }
    if (mask & GCSubwindowMode) { gc->subwindow_mode = values->subwindow_mode; }
    if (mask & GCGraphicsExposures) { gc->graphics_exposures = values->graphics_exposures; }
    if (mask & GCClipXOrigin) { gc->clip_x_origin = values->clip_x_origin; }
    if (mask & GCClipYOrigin) { gc->clip_y_origin = values->clip_y_origin; }
    if (mask & GCClipMask) { XSetClipMask(d, gc, values->clip_mask); }
    if (mask & GCDashOffset) { gc->dash_offset = values->dash_offset; }
    if (mask & GCDashList) { gc->dashes = values->dashes; (&(gc->dashes))[1] = 0;}
}

/*
 *----------------------------------------------------------------------
 *
 * XFreeGC --
 *
 *      Deallocates the specified graphics context.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void XFreeGC(d, gc)
    Display * d;
    GC gc;
{
    if (gc != None) {
        if (gc->clip_mask != None) {
            ckfree((char*) gc->clip_mask);
        }
        ckfree((char *) gc);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * XSetForeground, etc. --
 *
 *      The following functions are simply accessor functions for
 *      the GC slots.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Each function sets some slot in the GC.
 *
 *----------------------------------------------------------------------
 */

void 
XSetForeground(display, gc, foreground)
    Display *display;
    GC gc;
    unsigned long foreground;
{
    gc->foreground = foreground;
}

void 
XSetBackground(display, gc, background)
    Display *display;
    GC gc;
    unsigned long background;
{
    gc->background = background;
}

void
XSetDashes(display, gc, dash_offset, dash_list, n)
    Display* display;
    GC gc;
    int dash_offset;
    _Xconst char* dash_list;
    int n;
{
    char *p = &(gc->dashes);

#ifdef TkWinDeleteBrush
    TkWinDeleteBrush(gc->fgBrush);
    TkWinDeletePen(gc->fgPen);
    TkWinDeleteBrush(gc->bgBrush);
    TkWinDeletePen(gc->fgExtPen);
#endif
    gc->dash_offset = dash_offset;
    if (n > MAX_DASH_LIST_SIZE) n = MAX_DASH_LIST_SIZE;
    while (n-- > 0) {
        *p++ = *dash_list++;
    }
    *p = 0;
}

void
XSetFunction(display, gc, function)
    Display *display;
    GC gc;
    int function;
{
    gc->function = function;
}

void
XSetFillRule(display, gc, fill_rule)
    Display *display;
    GC gc;
    int fill_rule;
{
    gc->fill_rule = fill_rule;
}

void
XSetFillStyle(display, gc, fill_style)
    Display *display;
    GC gc;
    int fill_style;
{
    gc->fill_style = fill_style;
}

void
XSetTSOrigin(display, gc, x, y)
    Display *display;
    GC gc;
    int x, y;
{
    gc->ts_x_origin = x;
    gc->ts_y_origin = y;
}

void
XSetFont(display, gc, font)
    Display *display;
    GC gc;
    Font font;
{
    gc->font = font;
}

void
XSetArcMode(display, gc, arc_mode)
    Display *display;
    GC gc;
    int arc_mode;
{
    gc->arc_mode = arc_mode;
}

void
XSetStipple(display, gc, stipple)
    Display *display;
    GC gc;
    Pixmap stipple;
{
    gc->stipple = stipple;
}

void
XSetLineAttributes(display, gc, line_width, line_style, cap_style,
        join_style)
    Display *display;
    GC gc;
    unsigned int line_width;
    int line_style;
    int cap_style;
    int join_style;
{
    gc->line_width = line_width;
    gc->line_style = line_style;
    gc->cap_style = cap_style;
    gc->join_style = join_style;
}

void
XSetClipOrigin(display, gc, clip_x_origin, clip_y_origin)
    Display* display;
    GC gc;
    int clip_x_origin;
    int clip_y_origin;
{
    gc->clip_x_origin = clip_x_origin;
    gc->clip_y_origin = clip_y_origin;
}

/*
 *----------------------------------------------------------------------
 *
 * TkSetRegion, XSetClipMask --
 *
 *      Sets the clipping region/pixmap for a GC.
 *
 *      Note that unlike the Xlib equivalent, it is not safe to delete
 *      the region after setting it into the GC.  The only use of
 *      TkSetRegion is currently in ImgPhotoDisplay, which uses the GC
 *      immediately.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Allocates or dealloates a TkpClipMask.
 *
 *----------------------------------------------------------------------
 */

void
TkSetRegion(display, gc, r)
    Display* display;
    GC gc;
    TkRegion r;
{
    if (r == None) {
        if (gc->clip_mask) {
            ckfree((char*) gc->clip_mask);
            gc->clip_mask = None;
        }
        return;
    }

    if (gc->clip_mask == None) {
        gc->clip_mask = (Pixmap)ckalloc(sizeof(TkpClipMask));
    }
    ((TkpClipMask*)gc->clip_mask)->type = TKP_CLIP_REGION;
    ((TkpClipMask*)gc->clip_mask)->value.region = r;
}

void
XSetClipMask(display, gc, pixmap)
    Display* display;
    GC gc;
    Pixmap pixmap;
{
    if (pixmap == None) {
        if (gc->clip_mask) {
            ckfree((char*) gc->clip_mask);
            gc->clip_mask = None;
        }
        return;
    }

    if (gc->clip_mask == None) {
        gc->clip_mask = (Pixmap)ckalloc(sizeof(TkpClipMask));
    }
    ((TkpClipMask*)gc->clip_mask)->type = TKP_CLIP_PIXMAP;
    ((TkpClipMask*)gc->clip_mask)->value.pixmap = pixmap;
}

/*
 * Some additional dummy functions (hopefully implemented soon).
 */

Cursor
XCreateFontCursor(display, shape)
    Display* display;
    unsigned int shape;
{
    return (Cursor) 0;
}

void
XDrawImageString(display, d, gc, x, y, string, length)
    Display* display;
    Drawable d;
    GC gc;
    int x;
    int y;
    _Xconst char* string;
    int length;
{
}

void
XDrawPoint(display, d, gc, x, y)
    Display* display;
    Drawable d;
    GC gc;
    int x;
    int y;
{
    XDrawLine(display, d, gc, x, y, x, y);
}

void
XDrawPoints(display, d, gc, points, npoints, mode)
    Display* display;
    Drawable d;
    GC gc;
    XPoint* points;
    int npoints;
    int mode;
{
    int i;

    for (i=0; i<npoints; i++) {
        XDrawPoint(display, d, gc, points[i].x, points[i].y);
    }
}

#ifndef MAC_TCL
void
XDrawSegments(display, d, gc, segments, nsegments)
    Display* display;
    Drawable d;
    GC gc;
    XSegment* segments;
    int nsegments;
{
}
#endif

char *
XFetchBuffer(display, nbytes_return, buffer)
    Display* display;
    int* nbytes_return;
    int buffer;
{
    return (char *) 0;
}

Status XFetchName(display, w, window_name_return)
    Display* display;
    Window w;
    char** window_name_return;
{
    return (Status) 0;
}

Atom *XListProperties(display, w, num_prop_return)
    Display* display;
    Window w;
    int* num_prop_return;
{
    return (Atom *) 0;
}

void
XMapRaised(display, w)
    Display* display;
    Window w;
{
}

void
XPutImage(display, d, gc, image, src_x, src_y, dest_x, dest_y, width, height)
    Display* display;
    Drawable d;
    GC gc;
    XImage* image;
    int src_x;
    int src_y;
    int dest_x;
    int dest_y;
    unsigned int width;
    unsigned int height;
{
}

void XQueryTextExtents(display, font_ID, string, nchars, direction_return,
        font_ascent_return, font_descent_return, overall_return)
    Display* display;
    XID font_ID;
    _Xconst char* string;
    int nchars;
    int* direction_return;
    int* font_ascent_return;
    int* font_descent_return;
    XCharStruct* overall_return;
{
}

void
XReparentWindow(display, w, parent, x, y)
    Display* display;
    Window w;
    Window parent;
    int x;
    int y;
{
}

void
XRotateBuffers(display, rotate)
    Display* display;
    int rotate;
{
}

void
XStoreBuffer(display, bytes, nbytes, buffer)
    Display* display;
    _Xconst char* bytes;
    int nbytes;
    int buffer;
{
}

void
XUndefineCursor(display, w)
    Display* display;
    Window w;
{
}


/* $History: xgc.c $
 * 
 * *****************  Version 1  *****************
 * User: Dtashley     Date: 1/02/01    Time: 3:21a
 * Created in $/IjuScripter, IjuConsole/Source/Tk Base
 * Initial check-in.
 */

/* End of XGC.C */
1	dashley	25	/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/xgc.c,v 1.1.1.1 2001/06/13 05:15:43 dtashley Exp $ */
2
3			/*
4			* xgc.c --
5			*
6			* This file contains generic routines for manipulating X graphics
7			* contexts.
8			*
9			* Copyright (c) 1995-1996 Sun Microsystems, Inc.
10			*
11			* See the file "license.terms" for information on usage and redistribution
12			* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13			*
14			* RCS: @(#) $Id: xgc.c,v 1.1.1.1 2001/06/13 05:15:43 dtashley Exp $
15			*/
16
17			#include "tkInt.h"
18
19			#ifdef MAC_TCL
20			# include <Xlib.h>
21			# include <X.h>
22			# define Cursor XCursor
23			# define Region XRegion
24			#else
25			# include "Xlib.h"
26			#endif
27
28
29			/*
30			*----------------------------------------------------------------------
31			*
32			* XCreateGC --
33			*
34			* Allocate a new GC, and initialize the specified fields.
35			*
36			* Results:
37			* Returns a newly allocated GC.
38			*
39			* Side effects:
40			* None.
41			*
42			*----------------------------------------------------------------------
43			*/
44
45			GC
46			XCreateGC(display, d, mask, values)
47			Display* display;
48			Drawable d;
49			unsigned long mask;
50			XGCValues* values;
51			{
52			GC gp;
53
54			/*
55			* In order to have room for a dash list, MAX_DASH_LIST_SIZE extra chars are
56			* defined, which is invisible from the outside. The list is assumed to end
57			* with a 0-char, so this must be set explicitely during initialization.
58			*/
59
60			#define MAX_DASH_LIST_SIZE 10
61
62			gp = (XGCValues *)ckalloc(sizeof(XGCValues) + MAX_DASH_LIST_SIZE);
63			if (!gp) {
64			return None;
65			}
66
67			gp->function = (mask & GCFunction) ?values->function :GXcopy;
68			gp->plane_mask = (mask & GCPlaneMask) ?values->plane_mask :~0;
69			gp->foreground = (mask & GCForeground) ?values->foreground :0;
70			gp->background = (mask & GCBackground) ?values->background :0xffffff;
71			gp->line_width = (mask & GCLineWidth) ?values->line_width :0;
72			gp->line_style = (mask & GCLineStyle) ?values->line_style :LineSolid;
73			gp->cap_style = (mask & GCCapStyle) ?values->cap_style :0;
74			gp->join_style = (mask & GCJoinStyle) ?values->join_style :0;
75			gp->fill_style = (mask & GCFillStyle) ?values->fill_style :FillSolid;
76			gp->fill_rule = (mask & GCFillRule) ?values->fill_rule :WindingRule;
77			gp->arc_mode = (mask & GCArcMode) ?values->arc_mode :ArcPieSlice;
78			gp->tile = (mask & GCTile) ?values->tile :None;
79			gp->stipple = (mask & GCStipple) ?values->stipple :None;
80			gp->ts_x_origin = (mask & GCTileStipXOrigin) ?values->ts_x_origin:0;
81			gp->ts_y_origin = (mask & GCTileStipYOrigin) ?values->ts_y_origin:0;
82			gp->font = (mask & GCFont) ?values->font :None;
83			gp->subwindow_mode = (mask & GCSubwindowMode)?values->subwindow_mode:ClipByChildren;
84			gp->graphics_exposures = (mask & GCGraphicsExposures)?values->graphics_exposures:True;
85			gp->clip_x_origin = (mask & GCClipXOrigin) ?values->clip_x_origin :0;
86			gp->clip_y_origin = (mask & GCClipYOrigin) ?values->clip_y_origin :0;
87			gp->dash_offset = (mask & GCDashOffset) ?values->dash_offset :0;
88			gp->dashes = (mask & GCDashList) ?values->dashes :4;
89			(&(gp->dashes))[1] = 0;
90
91			if (mask & GCClipMask) {
92			gp->clip_mask = (Pixmap)ckalloc(sizeof(TkpClipMask));
93			((TkpClipMask*)gp->clip_mask)->type = TKP_CLIP_PIXMAP;
94			((TkpClipMask*)gp->clip_mask)->value.pixmap = values->clip_mask;
95			} else {
96			gp->clip_mask = None;
97			}
98
99			return gp;
100			}
101
102			/*
103			*----------------------------------------------------------------------
104			*
105			* XChangeGC --
106			*
107			* Changes the GC components specified by valuemask for the
108			* specified GC.
109			*
110			* Results:
111			* None.
112			*
113			* Side effects:
114			* Updates the specified GC.
115			*
116			*----------------------------------------------------------------------
117			*/
118
119			void
120			XChangeGC(d, gc, mask, values)
121			Display * d;
122			GC gc;
123			unsigned long mask;
124			XGCValues *values;
125			{
126			if (mask & GCFunction) { gc->function = values->function; }
127			if (mask & GCPlaneMask) { gc->plane_mask = values->plane_mask; }
128			if (mask & GCForeground) { gc->foreground = values->foreground; }
129			if (mask & GCBackground) { gc->background = values->background; }
130			if (mask & GCLineWidth) { gc->line_width = values->line_width; }
131			if (mask & GCLineStyle) { gc->line_style = values->line_style; }
132			if (mask & GCCapStyle) { gc->cap_style = values->cap_style; }
133			if (mask & GCJoinStyle) { gc->join_style = values->join_style; }
134			if (mask & GCFillStyle) { gc->fill_style = values->fill_style; }
135			if (mask & GCFillRule) { gc->fill_rule = values->fill_rule; }
136			if (mask & GCArcMode) { gc->arc_mode = values->arc_mode; }
137			if (mask & GCTile) { gc->tile = values->tile; }
138			if (mask & GCStipple) { gc->stipple = values->stipple; }
139			if (mask & GCTileStipXOrigin) { gc->ts_x_origin = values->ts_x_origin; }
140			if (mask & GCTileStipYOrigin) { gc->ts_y_origin = values->ts_y_origin; }
141			if (mask & GCFont) { gc->font = values->font; }
142			if (mask & GCSubwindowMode) { gc->subwindow_mode = values->subwindow_mode; }
143			if (mask & GCGraphicsExposures) { gc->graphics_exposures = values->graphics_exposures; }
144			if (mask & GCClipXOrigin) { gc->clip_x_origin = values->clip_x_origin; }
145			if (mask & GCClipYOrigin) { gc->clip_y_origin = values->clip_y_origin; }
146			if (mask & GCClipMask) { XSetClipMask(d, gc, values->clip_mask); }
147			if (mask & GCDashOffset) { gc->dash_offset = values->dash_offset; }
148			if (mask & GCDashList) { gc->dashes = values->dashes; (&(gc->dashes))[1] = 0;}
149			}
150
151			/*
152			*----------------------------------------------------------------------
153			*
154			* XFreeGC --
155			*
156			* Deallocates the specified graphics context.
157			*
158			* Results:
159			* None.
160			*
161			* Side effects:
162			* None.
163			*
164			*----------------------------------------------------------------------
165			*/
166
167			void XFreeGC(d, gc)
168			Display * d;
169			GC gc;
170			{
171			if (gc != None) {
172			if (gc->clip_mask != None) {
173			ckfree((char*) gc->clip_mask);
174			}
175			ckfree((char *) gc);
176			}
177			}
178
179			/*
180			*----------------------------------------------------------------------
181			*
182			* XSetForeground, etc. --
183			*
184			* The following functions are simply accessor functions for
185			* the GC slots.
186			*
187			* Results:
188			* None.
189			*
190			* Side effects:
191			* Each function sets some slot in the GC.
192			*
193			*----------------------------------------------------------------------
194			*/
195
196			void
197			XSetForeground(display, gc, foreground)
198			Display *display;
199			GC gc;
200			unsigned long foreground;
201			{
202			gc->foreground = foreground;
203			}
204
205			void
206			XSetBackground(display, gc, background)
207			Display *display;
208			GC gc;
209			unsigned long background;
210			{
211			gc->background = background;
212			}
213
214			void
215			XSetDashes(display, gc, dash_offset, dash_list, n)
216			Display* display;
217			GC gc;
218			int dash_offset;
219			_Xconst char* dash_list;
220			int n;
221			{
222			char *p = &(gc->dashes);
223
224			#ifdef TkWinDeleteBrush
225			TkWinDeleteBrush(gc->fgBrush);
226			TkWinDeletePen(gc->fgPen);
227			TkWinDeleteBrush(gc->bgBrush);
228			TkWinDeletePen(gc->fgExtPen);
229			#endif
230			gc->dash_offset = dash_offset;
231			if (n > MAX_DASH_LIST_SIZE) n = MAX_DASH_LIST_SIZE;
232			while (n-- > 0) {
233			p++ = dash_list++;
234			}
235			*p = 0;
236			}
237
238			void
239			XSetFunction(display, gc, function)
240			Display *display;
241			GC gc;
242			int function;
243			{
244			gc->function = function;
245			}
246
247			void
248			XSetFillRule(display, gc, fill_rule)
249			Display *display;
250			GC gc;
251			int fill_rule;
252			{
253			gc->fill_rule = fill_rule;
254			}
255
256			void
257			XSetFillStyle(display, gc, fill_style)
258			Display *display;
259			GC gc;
260			int fill_style;
261			{
262			gc->fill_style = fill_style;
263			}
264
265			void
266			XSetTSOrigin(display, gc, x, y)
267			Display *display;
268			GC gc;
269			int x, y;
270			{
271			gc->ts_x_origin = x;
272			gc->ts_y_origin = y;
273			}
274
275			void
276			XSetFont(display, gc, font)
277			Display *display;
278			GC gc;
279			Font font;
280			{
281			gc->font = font;
282			}
283
284			void
285			XSetArcMode(display, gc, arc_mode)
286			Display *display;
287			GC gc;
288			int arc_mode;
289			{
290			gc->arc_mode = arc_mode;
291			}
292
293			void
294			XSetStipple(display, gc, stipple)
295			Display *display;
296			GC gc;
297			Pixmap stipple;
298			{
299			gc->stipple = stipple;
300			}
301
302			void
303			XSetLineAttributes(display, gc, line_width, line_style, cap_style,
304			join_style)
305			Display *display;
306			GC gc;
307			unsigned int line_width;
308			int line_style;
309			int cap_style;
310			int join_style;
311			{
312			gc->line_width = line_width;
313			gc->line_style = line_style;
314			gc->cap_style = cap_style;
315			gc->join_style = join_style;
316			}
317
318			void
319			XSetClipOrigin(display, gc, clip_x_origin, clip_y_origin)
320			Display* display;
321			GC gc;
322			int clip_x_origin;
323			int clip_y_origin;
324			{
325			gc->clip_x_origin = clip_x_origin;
326			gc->clip_y_origin = clip_y_origin;
327			}
328
329			/*
330			*----------------------------------------------------------------------
331			*
332			* TkSetRegion, XSetClipMask --
333			*
334			* Sets the clipping region/pixmap for a GC.
335			*
336			* Note that unlike the Xlib equivalent, it is not safe to delete
337			* the region after setting it into the GC. The only use of
338			* TkSetRegion is currently in ImgPhotoDisplay, which uses the GC
339			* immediately.
340			*
341			* Results:
342			* None.
343			*
344			* Side effects:
345			* Allocates or dealloates a TkpClipMask.
346			*
347			*----------------------------------------------------------------------
348			*/
349
350			void
351			TkSetRegion(display, gc, r)
352			Display* display;
353			GC gc;
354			TkRegion r;
355			{
356			if (r == None) {
357			if (gc->clip_mask) {
358			ckfree((char*) gc->clip_mask);
359			gc->clip_mask = None;
360			}
361			return;
362			}
363
364			if (gc->clip_mask == None) {
365			gc->clip_mask = (Pixmap)ckalloc(sizeof(TkpClipMask));
366			}
367			((TkpClipMask*)gc->clip_mask)->type = TKP_CLIP_REGION;
368			((TkpClipMask*)gc->clip_mask)->value.region = r;
369			}
370
371			void
372			XSetClipMask(display, gc, pixmap)
373			Display* display;
374			GC gc;
375			Pixmap pixmap;
376			{
377			if (pixmap == None) {
378			if (gc->clip_mask) {
379			ckfree((char*) gc->clip_mask);
380			gc->clip_mask = None;
381			}
382			return;
383			}
384
385			if (gc->clip_mask == None) {
386			gc->clip_mask = (Pixmap)ckalloc(sizeof(TkpClipMask));
387			}
388			((TkpClipMask*)gc->clip_mask)->type = TKP_CLIP_PIXMAP;
389			((TkpClipMask*)gc->clip_mask)->value.pixmap = pixmap;
390			}
391
392			/*
393			* Some additional dummy functions (hopefully implemented soon).
394			*/
395
396			Cursor
397			XCreateFontCursor(display, shape)
398			Display* display;
399			unsigned int shape;
400			{
401			return (Cursor) 0;
402			}
403
404			void
405			XDrawImageString(display, d, gc, x, y, string, length)
406			Display* display;
407			Drawable d;
408			GC gc;
409			int x;
410			int y;
411			_Xconst char* string;
412			int length;
413			{
414			}
415
416			void
417			XDrawPoint(display, d, gc, x, y)
418			Display* display;
419			Drawable d;
420			GC gc;
421			int x;
422			int y;
423			{
424			XDrawLine(display, d, gc, x, y, x, y);
425			}
426
427			void
428			XDrawPoints(display, d, gc, points, npoints, mode)
429			Display* display;
430			Drawable d;
431			GC gc;
432			XPoint* points;
433			int npoints;
434			int mode;
435			{
436			int i;
437
438			for (i=0; i<npoints; i++) {
439			XDrawPoint(display, d, gc, points[i].x, points[i].y);
440			}
441			}
442
443			#ifndef MAC_TCL
444			void
445			XDrawSegments(display, d, gc, segments, nsegments)
446			Display* display;
447			Drawable d;
448			GC gc;
449			XSegment* segments;
450			int nsegments;
451			{
452			}
453			#endif
454
455			char *
456			XFetchBuffer(display, nbytes_return, buffer)
457			Display* display;
458			int* nbytes_return;
459			int buffer;
460			{
461			return (char *) 0;
462			}
463
464			Status XFetchName(display, w, window_name_return)
465			Display* display;
466			Window w;
467			char** window_name_return;
468			{
469			return (Status) 0;
470			}
471
472			Atom *XListProperties(display, w, num_prop_return)
473			Display* display;
474			Window w;
475			int* num_prop_return;
476			{
477			return (Atom *) 0;
478			}
479
480			void
481			XMapRaised(display, w)
482			Display* display;
483			Window w;
484			{
485			}
486
487			void
488			XPutImage(display, d, gc, image, src_x, src_y, dest_x, dest_y, width, height)
489			Display* display;
490			Drawable d;
491			GC gc;
492			XImage* image;
493			int src_x;
494			int src_y;
495			int dest_x;
496			int dest_y;
497			unsigned int width;
498			unsigned int height;
499			{
500			}
501
502			void XQueryTextExtents(display, font_ID, string, nchars, direction_return,
503			font_ascent_return, font_descent_return, overall_return)
504			Display* display;
505			XID font_ID;
506			_Xconst char* string;
507			int nchars;
508			int* direction_return;
509			int* font_ascent_return;
510			int* font_descent_return;
511			XCharStruct* overall_return;
512			{
513			}
514
515			void
516			XReparentWindow(display, w, parent, x, y)
517			Display* display;
518			Window w;
519			Window parent;
520			int x;
521			int y;
522			{
523			}
524
525			void
526			XRotateBuffers(display, rotate)
527			Display* display;
528			int rotate;
529			{
530			}
531
532			void
533			XStoreBuffer(display, bytes, nbytes, buffer)
534			Display* display;
535			_Xconst char* bytes;
536			int nbytes;
537			int buffer;
538			{
539			}
540
541			void
542			XUndefineCursor(display, w)
543			Display* display;
544			Window w;
545			{
546			}
547
548
549			/* $History: xgc.c $
550			*
551			* *************** Version 1 ***************
552			* User: Dtashley Date: 1/02/01 Time: 3:21a
553			* Created in $/IjuScripter, IjuConsole/Source/Tk Base
554			* Initial check-in.
555			*/
556
557			/* End of XGC.C */