/[dtapublic]/projs/trunk/shared_source/c_tk_base_7_5_w_mods/xgc.c
ViewVC logotype

Annotation of /projs/trunk/shared_source/c_tk_base_7_5_w_mods/xgc.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 69 - (hide annotations) (download)
Sat Nov 5 10:54:17 2016 UTC (8 years, 1 month ago) by dashley
File MIME type: text/plain
File size: 12784 byte(s)
License and property (keyword) changes.
1 dashley 69 /* $Header$ */
2 dashley 25
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 dashley 69 /* End of xgc.c */

Properties

Name Value
svn:keywords Header

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25