![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkgc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / tk|
Return to tkgc.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 root 1: /*
2: * tkGC.c --
3: *
4: * This file maintains a database of read-only graphics contexts
5: * for the Tk toolkit, in order to allow GC's to be shared.
6: *
7: * Copyright 1990 Regents of the University of California
8: * Permission to use, copy, modify, and distribute this
9: * software and its documentation for any purpose and without
10: * fee is hereby granted, provided that the above copyright
11: * notice appear in all copies. The University of California
12: * makes no representations about the suitability of this
13: * software for any purpose. It is provided "as is" without
14: * express or implied warranty.
15: */
16:
17: #ifndef lint
18: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkGC.c,v 1.9 92/05/13 08:48:45 ouster Exp $ SPRITE (Berkeley)";
19: #endif /* not lint */
20:
21: #include "tkconfig.h"
22: #include "tk.h"
23:
24: /*
25: * One of the following data structures exists for each GC that is
26: * currently active. The structure is indexed with two hash tables,
27: * one based on font name and one based on XFontStruct address.
28: */
29:
30: typedef struct {
31: GC gc; /* Graphics context. */
32: Display *display; /* Display to which gc belongs. */
33: int refCount; /* Number of active uses of gc. */
34: Tcl_HashEntry *valueHashPtr;/* Entry in valueTable (needed when deleting
35: * this structure). */
36: } TkGC;
37:
38: /*
39: * Hash table to map from a GC's values to a TkGC structure describing
40: * a GC with those values (used by Tk_GetGC).
41: */
42:
43: static Tcl_HashTable valueTable;
44: typedef struct {
45: XGCValues values; /* Desired values for GC. */
46: Screen *screen; /* Screen for which GC is valid. */
47: } ValueKey;
48:
49: /*
50: * Hash table for GC -> TkGC mapping. This table is indexed by the
51: * GC identifier, and is used by Tk_FreeGC.
52: */
53:
54: static Tcl_HashTable idTable;
55:
56: static int initialized = 0; /* 0 means static structures haven't been
57: * initialized yet. */
58:
59: /*
60: * Forward declarations for procedures defined in this file:
61: */
62:
63: static void GCInit _ANSI_ARGS_((void));
64:
65: /*
66: *----------------------------------------------------------------------
67: *
68: * Tk_GetGC --
69: *
70: * Given a desired set of values for a graphics context, find
71: * a read-only graphics context with the desired values.
72: *
73: * Results:
74: * The return value is the X identifer for the desired graphics
75: * context. The caller should never modify this GC, and should
76: * call Tk_FreeGC when the GC is no longer needed.
77: *
78: * Side effects:
79: * The GC is added to an internal database with a reference count.
80: * For each call to this procedure, there should eventually be a call
81: * to Tk_FreeGC, so that the database can be cleaned up when GC's
82: * aren't needed anymore.
83: *
84: *----------------------------------------------------------------------
85: */
86:
87: GC
88: Tk_GetGC(tkwin, valueMask, valuePtr)
89: Tk_Window tkwin; /* Window in which GC will be used. */
90: register unsigned long valueMask;
91: /* 1 bits correspond to values specified
92: * in *valuesPtr; other values are set
93: * from defaults. */
94: register XGCValues *valuePtr;
95: /* Values are specified here for bits set
96: * in valueMask. */
97: {
98: ValueKey key;
99: Tcl_HashEntry *valueHashPtr, *idHashPtr;
100: register TkGC *gcPtr;
101: int new;
102:
103: if (!initialized) {
104: GCInit();
105: }
106:
107: /*
108: * Must zero key at start to clear out pad bytes that may be
109: * part of structure on some systems.
110: */
111:
112: memset((VOID *) &key, 0, sizeof(key));
113:
114: /*
115: * First, check to see if there's already a GC that will work
116: * for this request (exact matches only, sorry).
117: */
118:
119: if (valueMask & GCFunction) {
120: key.values.function = valuePtr->function;
121: } else {
122: key.values.function = GXcopy;
123: }
124: if (valueMask & GCPlaneMask) {
125: key.values.plane_mask = valuePtr->plane_mask;
126: } else {
127: key.values.plane_mask = ~0;
128: }
129: if (valueMask & GCForeground) {
130: key.values.foreground = valuePtr->foreground;
131: } else {
132: key.values.foreground = 0;
133: }
134: if (valueMask & GCBackground) {
135: key.values.background = valuePtr->background;
136: } else {
137: key.values.background = 1;
138: }
139: if (valueMask & GCLineWidth) {
140: key.values.line_width = valuePtr->line_width;
141: } else {
142: key.values.line_width = 0;
143: }
144: if (valueMask & GCLineStyle) {
145: key.values.line_style = valuePtr->line_style;
146: } else {
147: key.values.line_style = LineSolid;
148: }
149: if (valueMask & GCCapStyle) {
150: key.values.cap_style = valuePtr->cap_style;
151: } else {
152: key.values.cap_style = CapButt;
153: }
154: if (valueMask & GCJoinStyle) {
155: key.values.join_style = valuePtr->join_style;
156: } else {
157: key.values.join_style = JoinMiter;
158: }
159: if (valueMask & GCFillStyle) {
160: key.values.fill_style = valuePtr->fill_style;
161: } else {
162: key.values.fill_style = FillSolid;
163: }
164: if (valueMask & GCFillRule) {
165: key.values.fill_rule = valuePtr->fill_rule;
166: } else {
167: key.values.fill_rule = EvenOddRule;
168: }
169: if (valueMask & GCArcMode) {
170: key.values.arc_mode = valuePtr->arc_mode;
171: } else {
172: key.values.arc_mode = ArcPieSlice;
173: }
174: if (valueMask & GCTile) {
175: key.values.tile = valuePtr->tile;
176: } else {
177: key.values.tile = None;
178: }
179: if (valueMask & GCStipple) {
180: key.values.stipple = valuePtr->stipple;
181: } else {
182: key.values.stipple = None;
183: }
184: if (valueMask & GCTileStipXOrigin) {
185: key.values.ts_x_origin = valuePtr->ts_x_origin;
186: } else {
187: key.values.ts_x_origin = 0;
188: }
189: if (valueMask & GCTileStipYOrigin) {
190: key.values.ts_y_origin = valuePtr->ts_y_origin;
191: } else {
192: key.values.ts_y_origin = 0;
193: }
194: if (valueMask & GCFont) {
195: key.values.font = valuePtr->font;
196: } else {
197: key.values.font = None;
198: }
199: if (valueMask & GCSubwindowMode) {
200: key.values.subwindow_mode = valuePtr->subwindow_mode;
201: } else {
202: key.values.subwindow_mode = ClipByChildren;
203: }
204: if (valueMask & GCGraphicsExposures) {
205: key.values.graphics_exposures = valuePtr->graphics_exposures;
206: } else {
207: key.values.graphics_exposures = True;
208: }
209: if (valueMask & GCClipXOrigin) {
210: key.values.clip_x_origin = valuePtr->clip_x_origin;
211: } else {
212: key.values.clip_x_origin = 0;
213: }
214: if (valueMask & GCClipYOrigin) {
215: key.values.clip_y_origin = valuePtr->clip_y_origin;
216: } else {
217: key.values.clip_y_origin = 0;
218: }
219: if (valueMask & GCClipMask) {
220: key.values.clip_mask = valuePtr->clip_mask;
221: } else {
222: key.values.clip_mask = None;
223: }
224: if (valueMask & GCDashOffset) {
225: key.values.dash_offset = valuePtr->dash_offset;
226: } else {
227: key.values.dash_offset = 0;
228: }
229: if (valueMask & GCDashList) {
230: key.values.dashes = valuePtr->dashes;
231: } else {
232: key.values.dashes = 4;
233: }
234: key.screen = Tk_Screen(tkwin);
235: valueHashPtr = Tcl_CreateHashEntry(&valueTable, (char *) &key, &new);
236: if (!new) {
237: gcPtr = (TkGC *) Tcl_GetHashValue(valueHashPtr);
238: gcPtr->refCount++;
239: return gcPtr->gc;
240: }
241:
242: /*
243: * No GC is currently available for this set of values. Allocate a
244: * new GC and add a new structure to the database.
245: */
246:
247: gcPtr = (TkGC *) ckalloc(sizeof(TkGC));
248: #if 0
249: gcPtr->gc = XCreateGC(Tk_Display(tkwin),
250: RootWindowOfScreen(Tk_Screen(tkwin)),
251: valueMask, &key.values);
252: #else
253: gcPtr->gc = XCreateGC(Tk_Display(tkwin),
254: Tk_DefaultPixmap(Tk_Screen(tkwin)),
255: valueMask, &key.values);
256: #endif
257: gcPtr->display = Tk_Display(tkwin);
258: gcPtr->refCount = 1;
259: gcPtr->valueHashPtr = valueHashPtr;
260: idHashPtr = Tcl_CreateHashEntry(&idTable, (char *) gcPtr->gc, &new);
261: if (!new) {
262: panic("GC already registered in Tk_GetGC");
263: }
264: Tcl_SetHashValue(valueHashPtr, gcPtr);
265: Tcl_SetHashValue(idHashPtr, gcPtr);
266: return gcPtr->gc;
267: }
268:
269: /*
270: *----------------------------------------------------------------------
271: *
272: * Tk_FreeGC --
273: *
274: * This procedure is called to release a font allocated by
275: * Tk_GetGC.
276: *
277: * Results:
278: * None.
279: *
280: * Side effects:
281: * The reference count associated with gc is decremented, and
282: * gc is officially deallocated if no-one is using it anymore.
283: *
284: *----------------------------------------------------------------------
285: */
286:
287: void
288: Tk_FreeGC(gc)
289: GC gc; /* Graphics context to be released. */
290: {
291: Tcl_HashEntry *idHashPtr;
292: register TkGC *gcPtr;
293:
294: if (!initialized) {
295: panic("Tk_FreeGC called before Tk_GetGC");
296: }
297:
298: idHashPtr = Tcl_FindHashEntry(&idTable, (char *) gc);
299: if (idHashPtr == NULL) {
300: panic("Tk_FreeGC received unknown gc argument");
301: }
302: gcPtr = (TkGC *) Tcl_GetHashValue(idHashPtr);
303: gcPtr->refCount--;
304: if (gcPtr->refCount == 0) {
305: XFreeGC(gcPtr->display, gcPtr->gc);
306: Tcl_DeleteHashEntry(gcPtr->valueHashPtr);
307: Tcl_DeleteHashEntry(idHashPtr);
308: ckfree((char *) gcPtr);
309: }
310: }
311:
312: /*
313: *----------------------------------------------------------------------
314: *
315: * GCInit --
316: *
317: * Initialize the structures used for GC management.
318: *
319: * Results:
320: * None.
321: *
322: * Side effects:
323: * Read the code.
324: *
325: *----------------------------------------------------------------------
326: */
327:
328: static void
329: GCInit()
330: {
331: initialized = 1;
332: Tcl_InitHashTable(&valueTable, sizeof(ValueKey)/sizeof(int));
333: Tcl_InitHashTable(&idTable, TCL_ONE_WORD_KEYS);
334: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.