]> cvs.zerfleddert.de Git - micropolis/blob - src/tk/tkpixmap.c
Import Micropolis from http://www.donhopkins.com/home/micropolis/
[micropolis] / src / tk / tkpixmap.c
1 /*
2 * tkPixmap.c --
3 *
4 * This file maintains a database of read-only pixmaps for the Tk
5 * toolkit. This allows pixmaps to be shared between widgets and
6 * also avoids interactions with the X server.
7 *
8 * Copyright 1992 by Sven Delmas
9 *
10 * This source is based upon the file tkBitmap.c from:
11 *
12 * Copyright 1990-1992 Regents of the University of California
13 * Permission to use, copy, modify, and distribute this
14 * software and its documentation for any purpose and without
15 * fee is hereby granted, provided that the above copyright
16 * notice appear in all copies. The University of California
17 * makes no representations about the suitability of this
18 * software for any purpose. It is provided "as is" without
19 * express or implied warranty.
20 * file: /user6/ouster/wish/RCS/tkBitmap.c,v 1.16
21 * 92/08/24 09:45:43 ouster Exp $ SPRITE (Berkeley);
22 */
23
24 #if defined(USE_XPM3)
25
26 #ifndef lint
27 static char *AtFSid = "$Header: tkPixmap.c[1.1] Mon Sep 28 14:12:35 1992 garfield@cs.tu-berlin.de frozen $";
28 #endif /* not lint */
29
30 #include "tkconfig.h"
31 #include "tk.h"
32
33 /*
34 * The includes below are for pre-defined bitmaps.
35 */
36
37 #include "bitmaps/gray50"
38 #include "bitmaps/gray25"
39
40 /*
41 * Include the xpm 3 defines for color pixmaps
42 */
43 //#include "xpmtk.h"
44 #include <xpm.h>
45
46 /*
47 * One of the following data structures exists for each bitmap that is
48 * currently in use. Each structure is indexed with both "idTable" and
49 * "nameTable".
50 */
51
52 typedef struct {
53 Pixmap bitmap; /* X identifier for bitmap. None means this
54 * bitmap was created by Tk_DefinePixmap
55 * and it isn't currently in use. */
56 unsigned int width, height; /* Dimensions of bitmap. */
57 Display *display; /* Display for which bitmap is valid. */
58 int refCount; /* Number of active uses of bitmap. */
59 Tcl_HashEntry *hashPtr; /* Entry in nameTable for this structure
60 * (needed when deleting). */
61 } TkBitmap;
62
63 /*
64 * Hash table to map from a textual description of a bitmap to the
65 * TkBitmap record for the bitmap, and key structure used in that
66 * hash table:
67 */
68
69 static Tcl_HashTable nameTable;
70 typedef struct {
71 Tk_Uid name; /* Textual name for desired bitmap. */
72 Screen *screen; /* Screen for which bitmap will be used. */
73 } NameKey;
74
75 /*
76 * Hash table that maps from bitmap identifiers to the TkBitmap structure
77 * for the pixmap. This table is indexed by Bitmap ids, and is used by
78 * Tk_FreePixmap.
79 */
80
81 static Tcl_HashTable idTable;
82
83 /*
84 * For each call to Tk_DefinePixmap one of the following structures is
85 * created to hold information about the pixmap.
86 */
87
88 typedef struct {
89 char *source; /* Bits for bitmap. */
90 Pixmap pixmap; /* Pre-defined pixmap */
91 unsigned int width, height; /* Dimensions of bitmap. */
92 } PredefBitmap;
93
94 /*
95 * Hash table create by Tk_DefinePixmap to map from a name to a
96 * collection of in-core data about a bitmap. The table is
97 * indexed by the address of the data for the bitmap, and the entries
98 * contain pointers to PredefBitmap structures.
99 */
100
101 static Tcl_HashTable predefTable;
102
103 /*
104 * Hash table used by Tk_GetPixmapFromData to map from a collection
105 * of in-core data about a bitmap to a Tk_Uid giving an automatically-
106 * generated name for the bitmap:
107 */
108
109 static Tcl_HashTable dataTable;
110 typedef struct {
111 char *source; /* Bitmap bits. */
112 unsigned int width, height; /* Dimensions of bitmap. */
113 } DataKey;
114
115 static int initialized = 0; /* 0 means static structures haven't been
116 * initialized yet. */
117
118 /*
119 * Forward declarations for procedures defined in this file:
120 */
121
122 static void PixmapInit _ANSI_ARGS_((Tk_Window tkwin));
123 \f
124 /*
125 *----------------------------------------------------------------------
126 *
127 * Tk_GetPixmap --
128 *
129 * Given a string describing a bitmap or pixmap, locate (or create
130 * if necessary) a pixmap that fits the description.
131 *
132 * Results:
133 * The return value is the X identifer for the desired pixmap,
134 * unless string couldn't be parsed correctly. In this case,
135 * None is returned and an error message is left in
136 * interp->result. The caller should never modify the pixmap
137 * that is returned, and should eventually call Tk_FreePixmap
138 * when the pixmap is no longer needed.
139 *
140 * Side effects:
141 * The pixmap is added to an internal database with a reference count.
142 * For each call to this procedure, there should eventually be a call
143 * to Tk_FreePixmap, so that the database can be cleaned up when pixmaps
144 * aren't needed anymore.
145 *
146 *----------------------------------------------------------------------
147 */
148 Pixmap
149 Tk_GetPixmap(interp, tkwin, string)
150 Tcl_Interp *interp; /* Interpreter to use for error reporting. */
151 Tk_Window tkwin; /* Window in which pixmap will be used. */
152 Tk_Uid string; /* Description of pixmap. See manual entry
153 * for details on legal syntax. */
154 {
155 NameKey key;
156 Tcl_HashEntry *nameHashPtr, *idHashPtr, *predefHashPtr;
157 register TkBitmap *bitmapPtr;
158 PredefBitmap *predefPtr;
159 int new;
160 Pixmap bitmap;
161 Pixmap bitmap_shape;
162 unsigned int width, height;
163 int dummy2;
164 XpmAttributes xpm_attributes;
165 Display *dpy = Tk_Display(tkwin);
166
167 if (!initialized) {
168 PixmapInit(tkwin);
169 }
170
171 key.name = string;
172 key.screen = Tk_Screen(tkwin);
173 nameHashPtr = Tcl_CreateHashEntry(&nameTable, (char *) &key, &new);
174 if (!new) {
175 bitmapPtr = (TkBitmap *) Tcl_GetHashValue(nameHashPtr);
176 bitmapPtr->refCount++;
177 return bitmapPtr->bitmap;
178 }
179
180 /*
181 * No suitable bitmap exists. Create a new bitmap from the
182 * information contained in the string. If the string starts
183 * with "@" then the rest of the string is a file name containing
184 * the bitmap. Otherwise the string must refer to a bitmap
185 * defined by a call to Tk_DefinePixmap.
186 */
187
188 if (*string == '@') {
189 string = Tcl_TildeSubst(interp, string + 1);
190 if (string == NULL) {
191 goto error;
192 }
193
194 if (XReadBitmapFile(dpy, RootWindowOfScreen(Tk_Screen(tkwin)),
195 string, &width, &height, &bitmap_shape, &dummy2, &dummy2)
196 != BitmapSuccess)
197 {
198 xpm_attributes.visual = Tk_DefaultVisual(Tk_Screen(tkwin));
199 xpm_attributes.colormap = Tk_DefaultColormap(Tk_Screen(tkwin));
200 xpm_attributes.depth = Tk_DefaultDepth(Tk_Screen(tkwin));
201 xpm_attributes.valuemask = XpmVisual | XpmColormap | XpmDepth;
202
203 if (XpmReadFileToPixmap(dpy, RootWindowOfScreen(Tk_Screen(tkwin)),
204 string, &bitmap, &bitmap_shape,
205 &xpm_attributes) != BitmapSuccess) {
206 Tcl_AppendResult(interp, "error reading bitmap file \"",
207 string, "\"", (char *) NULL);
208 goto error;
209 } {
210 width = xpm_attributes.width;
211 height = xpm_attributes.height;
212 XpmFreeAttributes(&xpm_attributes);
213 }
214 } else {
215 bitmap = XCreatePixmap(dpy, RootWindowOfScreen(Tk_Screen(tkwin)),
216 width, height,
217 Tk_DefaultDepth(Tk_Screen(tkwin)));
218 XCopyPlane(dpy, bitmap_shape, bitmap,
219 Tk_DefaultGC(Tk_Screen(tkwin)),
220 0, 0, width, height, 0, 0, 1);
221 }
222 } else {
223 /* first try for a display-specific version */
224 predefHashPtr = Tcl_FindHashEntry(&predefTable, (char *) &key);
225 if (predefHashPtr == NULL) {
226 /* try for a non-display specific version */
227 key.screen = (Screen*) NULL;
228 predefHashPtr = Tcl_FindHashEntry(&predefTable, (char *) &key);
229 if (predefHashPtr == NULL) {
230 /* give up */
231 Tcl_AppendResult(interp, "pixmap \"", string,
232 "\" not defined", (char *) NULL);
233 goto error;
234 }
235 }
236 predefPtr = (PredefBitmap *) Tcl_GetHashValue(predefHashPtr);
237 width = predefPtr->width;
238 height = predefPtr->height;
239 if (predefPtr->source != NULL) {
240 bitmap_shape =
241 XCreateBitmapFromData(dpy, Tk_DefaultRootWindow(dpy),
242 predefPtr->source, width, height);
243 bitmap = XCreatePixmap(dpy, RootWindowOfScreen(Tk_Screen(tkwin)),
244 width, height,
245 Tk_DefaultDepth(Tk_Screen(tkwin)));
246 XCopyPlane(dpy, bitmap_shape, bitmap,
247 Tk_DefaultGC(Tk_Screen(tkwin)),
248 0, 0, width, height, 0, 0, 1);
249 } else {
250 if (predefPtr->pixmap != None) {
251 bitmap = predefPtr->pixmap;
252 } else {
253 bitmap =
254 XCreatePixmap(dpy, RootWindowOfScreen(Tk_Screen(tkwin)),
255 width, height,
256 Tk_DefaultDepth(Tk_Screen(tkwin)));
257 }
258 }
259 }
260
261 /*
262 * Add information about this bitmap to our database.
263 */
264
265 bitmapPtr = (TkBitmap *) ckalloc(sizeof(TkBitmap));
266 bitmapPtr->bitmap = bitmap;
267 bitmapPtr->width = width;
268 bitmapPtr->height = height;
269 bitmapPtr->display = dpy;
270 bitmapPtr->refCount = 1;
271 bitmapPtr->hashPtr = nameHashPtr;
272 idHashPtr = Tcl_CreateHashEntry(&idTable, (char *) bitmapPtr->bitmap,
273 &new);
274 if (!new) {
275 /* deh patched to support multiple displays */
276 /* panic("pixmap already registered in Tk_GetPixmap"); */
277 bitmapPtr->refCount = 1000;
278 }
279 Tcl_SetHashValue(nameHashPtr, bitmapPtr);
280 Tcl_SetHashValue(idHashPtr, bitmapPtr);
281 return bitmapPtr->bitmap;
282
283 error:
284 Tcl_DeleteHashEntry(nameHashPtr);
285 return None;
286 }
287 \f
288 /*
289 *----------------------------------------------------------------------
290 *
291 * Tk_DefinePixmap --
292 *
293 * This procedure associates a textual name with a binary pixmap
294 * description, so that the name may be used to refer to the
295 * pixmap in future calls to Tk_GetPixmap. The pixmap can
296 * be pre-created by the user, or can be created later
297 * by Tk_GetPixmap(). Since pixmaps are display-specific,
298 * a user supplied pixmap will be associated with tkwin's display.
299 * If pixmap is given as None, then a new pixmap will be created
300 * by Tk_GetPixmap for each unique display.
301 *
302 * Results:
303 * A standard Tcl result. If an error occurs then TCL_ERROR is
304 * returned and a message is left in interp->result.
305 *
306 * Side effects:
307 * "Name" is entered into the pixmap table and may be used from
308 * here on to refer to the given pixmap.
309 *
310 *----------------------------------------------------------------------
311 */
312
313 int
314 Tk_DefinePixmap(interp, name, tkwin, pixmap, source, width, height)
315 Tcl_Interp *interp; /* Interpreter to use for error reporting. */
316 Tk_Uid name; /* Name to use for bitmap. Must not already
317 * be defined as a bitmap. */
318 Tk_Window tkwin; /* any window on screen where pixmap lives */
319 Pixmap pixmap; /* pixmap to associate with name,
320 * or None to create a new pixmap */
321 char *source; /* Address of bits for bitmap. */
322 unsigned int width; /* Width of bitmap. */
323 unsigned int height; /* Height of bitmap. */
324 {
325 int new;
326 Tcl_HashEntry *predefHashPtr;
327 PredefBitmap *predefPtr;
328 NameKey key;
329
330 if (!initialized) {
331 PixmapInit(tkwin);
332 }
333
334 key.name = name;
335 key.screen = (pixmap != None) ? Tk_Screen(tkwin) : (Screen *)NULL;
336 predefHashPtr = Tcl_CreateHashEntry(&predefTable, (char *) &key, &new);
337 if (!new) {
338 Tcl_AppendResult(interp, "bitmap \"", name,
339 "\" is already defined", (char *) NULL);
340 return TCL_ERROR;
341 }
342 predefPtr = (PredefBitmap *) malloc(sizeof(PredefBitmap));
343 predefPtr->source = source;
344 predefPtr->pixmap = pixmap;
345 predefPtr->width = width;
346 predefPtr->height = height;
347 Tcl_SetHashValue(predefHashPtr, predefPtr);
348 return TCL_OK;
349 }
350 \f
351 /*
352 *--------------------------------------------------------------
353 *
354 * Tk_NameOfPixmap --
355 *
356 * Given a pixmap, return a textual string identifying the
357 * pixmap.
358 *
359 * Results:
360 * The return value is the string name associated with pixmap.
361 *
362 * Side effects:
363 * None.
364 *
365 *--------------------------------------------------------------
366 */
367
368 Tk_Uid
369 Tk_NameOfPixmap(bitmap)
370 Pixmap bitmap; /* Bitmap whose name is wanted. */
371 {
372 Tcl_HashEntry *idHashPtr;
373 TkBitmap *bitmapPtr;
374
375 if (!initialized) {
376 unknown:
377 panic("Tk_NameOfPixmap received unknown pixmap argument");
378 }
379
380 idHashPtr = Tcl_FindHashEntry(&idTable, (char *) bitmap);
381 if (idHashPtr == NULL) {
382 goto unknown;
383 }
384 bitmapPtr = (TkBitmap *) Tcl_GetHashValue(idHashPtr);
385 if (bitmapPtr->hashPtr == NULL) {
386 /* the bitmap has been un-defined */
387 return Tk_GetUid("UndefinedBitmap");
388 }
389 return ((NameKey *) bitmapPtr->hashPtr->key.words)->name;
390 }
391 \f
392 /*
393 *--------------------------------------------------------------
394 *
395 * Tk_SizeOfPixmap --
396 *
397 * Given a pixmap managed by this module, returns the width
398 * and height of the pixmap..
399 *
400 * Results:
401 * The words at *widthPtr and *heightPtr are filled in with
402 * the dimenstions of pixmap.
403 *
404 * Side effects:
405 * If pixmap isn't managed by this module then the procedure
406 * panics..
407 *
408 *--------------------------------------------------------------
409 */
410
411 void
412 Tk_SizeOfPixmap(bitmap, widthPtr, heightPtr)
413 Pixmap bitmap; /* Bitmap whose size is wanted. */
414 unsigned int *widthPtr; /* Store bitmap width here. */
415 unsigned int *heightPtr; /* Store bitmap height here. */
416 {
417 Tcl_HashEntry *idHashPtr;
418 TkBitmap *bitmapPtr;
419
420 if (!initialized) {
421 unknownBitmap:
422 panic("Tk_SizeOfPixmap received unknown pixmap argument");
423 }
424
425 idHashPtr = Tcl_FindHashEntry(&idTable, (char *) bitmap);
426 if (idHashPtr == NULL) {
427 goto unknownBitmap;
428 }
429 bitmapPtr = (TkBitmap *) Tcl_GetHashValue(idHashPtr);
430 *widthPtr = bitmapPtr->width;
431 *heightPtr = bitmapPtr->height;
432 }
433 \f
434 /*
435 *----------------------------------------------------------------------
436 *
437 * Tk_FreePixmap --
438 *
439 * This procedure is called to release a pixmap allocated by
440 * Tk_GetPixmap.
441 *
442 * Results:
443 * None.
444 *
445 * Side effects:
446 * The reference count associated with bitmap is decremented, and
447 * it is officially deallocated if no-one is using it anymore.
448 *
449 *----------------------------------------------------------------------
450 */
451
452 void
453 Tk_FreePixmap(bitmap)
454 Pixmap bitmap; /* Bitmap to be released. */
455 {
456 Tcl_HashEntry *idHashPtr;
457 register TkBitmap *bitmapPtr;
458
459 if (!initialized) {
460 panic("Tk_FreePixmap called before Tk_GetPixmap");
461 }
462
463 idHashPtr = Tcl_FindHashEntry(&idTable, (char *) bitmap);
464 if (idHashPtr == NULL) {
465 panic("Tk_FreePixmap received unknown pixmap argument");
466 }
467 bitmapPtr = (TkBitmap *) Tcl_GetHashValue(idHashPtr);
468 bitmapPtr->refCount--;
469 if (bitmapPtr->refCount == 0) {
470 XFreePixmap(bitmapPtr->display, bitmapPtr->bitmap);
471 Tcl_DeleteHashEntry(idHashPtr);
472 if (bitmapPtr->hashPtr != NULL) {
473 /* If hashPtr is NULL, the bitmap has been undefined,
474 * and already removed from the name table */
475 Tcl_DeleteHashEntry(bitmapPtr->hashPtr);
476 }
477 ckfree((char *) bitmapPtr);
478 }
479 }
480 \f
481 /*
482 *----------------------------------------------------------------------
483 *
484 * Tk_GetPixmapFromData --
485 *
486 * Given a description of the bits for a pixmap, make a pixmap that
487 * has the given properties.
488 *
489 * Results:
490 * The return value is the X identifer for the desired pixmap,
491 * unless it couldn't be created properly. In this case, None is
492 * returned and an error message is left in interp->result. The
493 * caller should never modify the bitmap that is returned, and
494 * should eventually call Tk_FreePixmap when the pixmap is no
495 * longer needed.
496 *
497 * Side effects:
498 * The pixmap is added to an internal database with a reference count.
499 * For each call to this procedure, there should eventually be a call
500 * to Tk_FreePixmap, so that the database can be cleaned up when pixmaps
501 * aren't needed anymore.
502 *
503 *----------------------------------------------------------------------
504 */
505
506 /* ARGSUSED */
507 Pixmap
508 Tk_GetPixmapFromData(interp, tkwin, source, width, height)
509 Tcl_Interp *interp; /* Interpreter to use for error reporting. */
510 Tk_Window tkwin; /* Window in which bitmap will be used. */
511 char *source; /* Bitmap data for bitmap shape. */
512 unsigned int width, height; /* Dimensions of bitmap. */
513 {
514 DataKey key;
515 Tcl_HashEntry *dataHashPtr;
516 Tk_Uid name = NULL; /* Initialization need only to prevent
517 * compiler warning. */
518 int new;
519 static autoNumber = 0;
520 char string[20];
521
522 if (!initialized) {
523 PixmapInit(tkwin);
524 }
525
526 key.source = source;
527 key.width = width;
528 key.height = height;
529 dataHashPtr = Tcl_CreateHashEntry(&dataTable, (char *) &key, &new);
530 if (!new) {
531 name = (Tk_Uid) Tcl_GetHashValue(dataHashPtr);
532 } else {
533 autoNumber++;
534 sprintf(string, "_tk%d", autoNumber);
535 name = Tk_GetUid(string);
536 Tcl_SetHashValue(dataHashPtr, name);
537 if (Tk_DefinePixmap(interp, name, tkwin, None, source, width,
538 height) != TCL_OK) {
539 Tcl_DeleteHashEntry(dataHashPtr);
540 return TCL_ERROR;
541 }
542 }
543 return Tk_GetPixmap(interp, tkwin, name);
544 }
545 \f
546 /*
547 *----------------------------------------------------------------------
548 *
549 * PixmapInit --
550 *
551 * Initialize the structures used for pixmap management.
552 *
553 * Results:
554 * None.
555 *
556 * Side effects:
557 * Read the code.
558 *
559 *----------------------------------------------------------------------
560 */
561
562 static void
563 PixmapInit(tkwin)
564 Tk_Window tkwin; /* any window on screen where pixmap lives */
565 {
566 Tcl_Interp *dummy;
567
568 dummy = Tcl_CreateInterp();
569 initialized = 1;
570 Tcl_InitHashTable(&nameTable, sizeof(NameKey)/sizeof(int));
571 Tcl_InitHashTable(&dataTable, sizeof(DataKey)/sizeof(int));
572 Tcl_InitHashTable(&predefTable, sizeof(NameKey)/sizeof(int));
573 Tcl_InitHashTable(&idTable, TCL_ONE_WORD_KEYS);
574
575 Tk_DefinePixmap(dummy, Tk_GetUid("gray50"), tkwin, None,
576 (char *)gray50_bits, gray50_width, gray50_height);
577 Tk_DefinePixmap(dummy, Tk_GetUid("gray25"), tkwin, None,
578 (char *)gray25_bits, gray25_width, gray25_height);
579 Tcl_DeleteInterp(dummy);
580 }
581 \f
582 /*
583 *----------------------------------------------------------------------
584 *
585 * Tk_UndefinePixmap --
586 *
587 * This procedure removes any association "name" with
588 * a bitmap or pixmap. This can be used to undefine
589 * names defined by either Tk_DefinePixmap or Tk_DefinePixmap.
590 * If tkwin is NULL, only display-independent pixmaps will
591 * be removed, otherwise both display-independent and
592 * the pixmap associated with tkwin will be undefined.
593 *
594 * Results:
595 * A standard Tcl result. If an error occurs then TCL_ERROR is
596 * returned and a message is left in interp->result.
597 *
598 * Side effects:
599 * "Name" is removed from the predef table.
600 *
601 *----------------------------------------------------------------------
602 */
603
604 int
605 Tk_UndefinePixmap(interp, name, tkwin)
606 Tcl_Interp *interp; /* Interpreter to use for error reporting. */
607 Tk_Uid name; /* Name of bitmap/pixmap to undefine */
608 Tk_Window tkwin; /* any window on screen where pixmap lives */
609 {
610 NameKey key;
611 Tcl_HashEntry *predefHashPtr, *nameHashPtr;
612 TkBitmap *bitmapPtr;
613 int cnt = 0;
614
615 if (!initialized) {
616 PixmapInit(tkwin);
617 }
618
619 key.name = name;
620 key.screen = (Screen *) NULL;
621 predefHashPtr = Tcl_FindHashEntry(&predefTable, (char*)&key);
622 if (predefHashPtr != NULL) {
623 ++cnt;
624 Tcl_DeleteHashEntry(predefHashPtr);
625 }
626
627 key.screen = Tk_Screen(tkwin);
628 predefHashPtr = Tcl_FindHashEntry(&predefTable, (char*)&key);
629 if (predefHashPtr != NULL) {
630 ++cnt;
631 Tcl_DeleteHashEntry(predefHashPtr);
632 }
633 if (cnt == 0) {
634 Tcl_AppendResult(interp, "pixmap \"", name,
635 "\" doesn't exist", (char *) NULL);
636 return TCL_ERROR;
637 }
638
639 /*
640 * Remove it from the name table if it is there (it might not
641 * have been created yet, it which case we wont find it). We
642 * delete it from the name table and mark the hashPtr as NULL
643 * so that we know it has been deleted. The pixmap still exists,
644 * and well later be freed and removed from idTable by Tk_FreeBitmap().
645 */
646 nameHashPtr = Tcl_FindHashEntry(&nameTable, (char *) &key);
647 if (nameHashPtr != NULL) {
648 bitmapPtr = (TkBitmap *) Tcl_GetHashValue(nameHashPtr);
649 /* assert(nameHashPtr == bitmapPtr->hashPtr); */
650 /* assert(bitmapPtr->refCount > 0); */
651 bitmapPtr->hashPtr = (Tcl_HashEntry*) NULL;
652 Tcl_DeleteHashEntry(nameHashPtr);
653 }
654 return TCL_OK;
655 }
656
657 #endif
Impressum, Datenschutz