![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkpixmap.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 tkpixmap.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 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 [email protected] 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: ! 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: ! 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: ! 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: ! 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: ! 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: ! 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: ! 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: ! 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
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.