![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkoption.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 tkoption.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 ! root 1: /* ! 2: * tkOption.c -- ! 3: * ! 4: * This module contains procedures to manage the option ! 5: * database, which allows various strings to be associated ! 6: * with windows either by name or by class or both. ! 7: * ! 8: * Copyright 1990 Regents of the University of California. ! 9: * Permission to use, copy, modify, and distribute this ! 10: * software and its documentation for any purpose and without ! 11: * fee is hereby granted, provided that the above copyright ! 12: * notice appear in all copies. The University of California ! 13: * makes no representations about the suitability of this ! 14: * software for any purpose. It is provided "as is" without ! 15: * express or implied warranty. ! 16: */ ! 17: ! 18: #ifndef lint ! 19: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkOption.c,v 1.25 92/03/16 08:46:14 ouster Exp $ SPRITE (Berkeley)"; ! 20: #endif ! 21: ! 22: #include "tkconfig.h" ! 23: #include "tkint.h" ! 24: ! 25: /* ! 26: * The option database is stored as one tree for each main window. ! 27: * Each name or class field in an option is associated with a node or ! 28: * leaf of the tree. For example, the options "x.y.z" and "x.y*a" ! 29: * each correspond to three nodes in the tree; they share the nodes ! 30: * "x" and "x.y", but have different leaf nodes. One of the following ! 31: * structures exists for each node or leaf in the option tree. It is ! 32: * actually stored as part of the parent node, and describes a particular ! 33: * child of the parent. ! 34: */ ! 35: ! 36: typedef struct Element { ! 37: Tk_Uid nameUid; /* Name or class from one element of ! 38: * an option spec. */ ! 39: union { ! 40: struct ElArray *arrayPtr; /* If this is an intermediate node, ! 41: * a pointer to a structure describing ! 42: * the remaining elements of all ! 43: * options whose prefixes are the ! 44: * same up through this element. */ ! 45: Tk_Uid valueUid; /* For leaf nodes, this is the string ! 46: * value of the option. */ ! 47: } child; ! 48: int priority; /* Used to select among matching ! 49: * options. Includes both the ! 50: * priority level and a serial #. ! 51: * Greater value means higher ! 52: * priority. Irrelevant except in ! 53: * leaf nodes. */ ! 54: int flags; /* OR-ed combination of bits. See ! 55: * below for values. */ ! 56: } Element; ! 57: ! 58: /* ! 59: * Flags in NodeElement structures: ! 60: * ! 61: * CLASS - Non-zero means this element refers to a class, ! 62: * Zero means this element refers to a name. ! 63: * NODE - Zero means this is a leaf element (the child ! 64: * field is a value, not a pointer to another node). ! 65: * One means this is a node element. ! 66: * WILDCARD - Non-zero means this there was a star in the ! 67: * original specification just before this element. ! 68: * Zero means there was a dot. ! 69: */ ! 70: ! 71: #define TYPE_MASK 0x7 ! 72: ! 73: #define CLASS 0x1 ! 74: #define NODE 0x2 ! 75: #define WILDCARD 0x4 ! 76: ! 77: #define EXACT_LEAF_NAME 0x0 ! 78: #define EXACT_LEAF_CLASS 0x1 ! 79: #define EXACT_NODE_NAME 0x2 ! 80: #define EXACT_NODE_CLASS 0x3 ! 81: #define WILDCARD_LEAF_NAME 0x4 ! 82: #define WILDCARD_LEAF_CLASS 0x5 ! 83: #define WILDCARD_NODE_NAME 0x6 ! 84: #define WILDCARD_NODE_CLASS 0x7 ! 85: ! 86: /* ! 87: * The following structure is used to manage a dynamic array of ! 88: * Elements. These structures are used for two purposes: to store ! 89: * the contents of a node in the option tree, and for the option ! 90: * stacks described below. ! 91: */ ! 92: ! 93: typedef struct ElArray { ! 94: int arraySize; /* Number of elements actually ! 95: * allocated in the "els" array. */ ! 96: int numUsed; /* Number of elements currently in ! 97: * use out of els. */ ! 98: Element *nextToUse; /* Pointer to &els[numUsed]. */ ! 99: Element els[1]; /* Array of structures describing ! 100: * children of this node. The ! 101: * array will actually contain enough ! 102: * elements for all of the children ! 103: * (and even a few extras, perhaps). ! 104: * This must be the last field in ! 105: * the structure. */ ! 106: } ElArray; ! 107: ! 108: #define EL_ARRAY_SIZE(numEls) ((unsigned) (sizeof(ElArray) \ ! 109: + ((numEls)-1)*sizeof(Element))) ! 110: #define INITIAL_SIZE 5 ! 111: ! 112: /* ! 113: * In addition to the option tree, which is a relatively static structure, ! 114: * there are eight additional structures called "stacks", which are used ! 115: * to speed up queries into the option database. The stack structures ! 116: * are designed for the situation where an individual widget makes repeated ! 117: * requests for its particular options. The requests differ only in ! 118: * their last name/class, so during the first request we extract all ! 119: * the options pertaining to the particular widget and save them in a ! 120: * stack-like cache; subsequent requests for the same widget can search ! 121: * the cache relatively quickly. In fact, the cache is a hierarchical ! 122: * one, storing a list of relevant options for this widget and all of ! 123: * its ancestors up to the application root; hence the name "stack". ! 124: * ! 125: * Each of the eight stacks consists of an array of Elements, ordered in ! 126: * terms of levels in the window hierarchy. All the elements relevant ! 127: * for the top-level widget appear first in the array, followed by all ! 128: * those from the next-level widget on the path to the current widget, ! 129: * etc. down to those for the current widget. ! 130: * ! 131: * Cached information is divided into eight stacks according to the ! 132: * CLASS, NODE, and WILDCARD flags. Leaf and non-leaf information is ! 133: * kept separate to speed up individual probes (non-leaf information is ! 134: * only relevant when building the stacks, but isn't relevant when ! 135: * making probes; similarly, only non-leaf information is relevant ! 136: * when the stacks are being extended to the next widget down in the ! 137: * widget hierarchy). Wildcard elements are handled separately from ! 138: * "exact" elements because once they appear at a particular level in ! 139: * the stack they remain active for all deeper levels; exact elements ! 140: * are only relevant at a particular level. For example, when searching ! 141: * for options relevant in a particular window, the entire wildcard ! 142: * stacks get checked, but only the portions of the exact stacks that ! 143: * pertain to the window's parent. Lastly, name and class stacks are ! 144: * kept separate because different search keys are used when searching ! 145: * them; keeping them separate speeds up the searches. ! 146: */ ! 147: ! 148: #define NUM_STACKS 8 ! 149: static ElArray *stacks[NUM_STACKS]; ! 150: static TkWindow *cachedWindow = NULL; /* Lowest-level window currently ! 151: * loaded in stacks at present. ! 152: * NULL means stacks have never ! 153: * been used, or have been ! 154: * invalidated because of a change ! 155: * to the database. */ ! 156: ! 157: /* ! 158: * One of the following structures is used to keep track of each ! 159: * level in the stacks. ! 160: */ ! 161: ! 162: typedef struct StackLevel { ! 163: TkWindow *winPtr; /* Window corresponding to this stack ! 164: * level. */ ! 165: int bases[NUM_STACKS]; /* For each stack, index of first ! 166: * element on stack corresponding to ! 167: * this level (used to restore "numUsed" ! 168: * fields when popping out of a level. */ ! 169: } StackLevel; ! 170: ! 171: /* ! 172: * Information about all of the stack levels that are currently ! 173: * active. This array grows dynamically to become as large as needed. ! 174: */ ! 175: ! 176: static StackLevel *levels = NULL; ! 177: /* Array describing current stack. */ ! 178: static int numLevels = 0; /* Total space allocated. */ ! 179: static int curLevel = 0; /* Highest level currently in use. */ ! 180: ! 181: /* ! 182: * The variable below is a serial number for all options entered into ! 183: * the database so far. It increments on each addition to the option ! 184: * database. It is used in computing option priorities, so that the ! 185: * most recent entry wins when choosing between options at the same ! 186: * priority level. ! 187: */ ! 188: ! 189: static int serial = 0; ! 190: ! 191: /* ! 192: * Special "no match" Element to use as default for searches. ! 193: */ ! 194: ! 195: static Element defaultMatch; ! 196: ! 197: /* ! 198: * Forward declarations for procedures defined in this file: ! 199: */ ! 200: ! 201: static int AddFromString _ANSI_ARGS_((Tcl_Interp *interp, ! 202: Tk_Window tkwin, char *string, int priority)); ! 203: static void ClearOptionTree _ANSI_ARGS_((ElArray *arrayPtr)); ! 204: static ElArray * ExtendArray _ANSI_ARGS_((ElArray *arrayPtr, ! 205: Element *elPtr)); ! 206: static void ExtendStacks _ANSI_ARGS_((ElArray *arrayPtr, ! 207: int leaf)); ! 208: static int GetDefaultOptions _ANSI_ARGS_((Tcl_Interp *interp, ! 209: TkWindow *winPtr)); ! 210: static ElArray * NewArray _ANSI_ARGS_((int numEls)); ! 211: static void OptionInit _ANSI_ARGS_((TkMainInfo *mainPtr)); ! 212: static int ParsePriority _ANSI_ARGS_((Tcl_Interp *interp, ! 213: char *string)); ! 214: static int ReadOptionFile _ANSI_ARGS_((Tcl_Interp *interp, ! 215: Tk_Window tkwin, char *fileName, int priority)); ! 216: static void SetupStacks _ANSI_ARGS_((TkWindow *winPtr, int leaf)); ! 217: ! 218: /* ! 219: *-------------------------------------------------------------- ! 220: * ! 221: * Tk_AddOption -- ! 222: * ! 223: * Add a new option to the option database. ! 224: * ! 225: * Results: ! 226: * None. ! 227: * ! 228: * Side effects: ! 229: * Information is added to the option database. ! 230: * ! 231: *-------------------------------------------------------------- ! 232: */ ! 233: ! 234: void ! 235: Tk_AddOption(tkwin, name, value, priority) ! 236: Tk_Window tkwin; /* Window token; option will be associated ! 237: * with main window for this window. */ ! 238: char *name; /* Multi-element name of option. */ ! 239: char *value; /* String value for option. */ ! 240: int priority; /* Overall priority level to use for ! 241: * this option, such as TK_USER_DEFAULT_PRIO ! 242: * or TK_INTERACTIVE_PRIO. Must be between ! 243: * 0 and TK_MAX_PRIO. */ ! 244: { ! 245: TkWindow *winPtr = ((TkWindow *) tkwin)->mainPtr->winPtr; ! 246: register ElArray **arrayPtrPtr; ! 247: register Element *elPtr; ! 248: Element newEl; ! 249: register char *p; ! 250: char *field; ! 251: int count, firstField, length; ! 252: #define TMP_SIZE 100 ! 253: char tmp[TMP_SIZE+1]; ! 254: ! 255: if (winPtr->mainPtr->optionRootPtr == NULL) { ! 256: OptionInit(winPtr->mainPtr); ! 257: } ! 258: cachedWindow = NULL; /* Invalidate the cache. */ ! 259: ! 260: /* ! 261: * Compute the priority for the new element, including both the ! 262: * overall level and the serial number (to disambiguate with the ! 263: * level). ! 264: */ ! 265: ! 266: if (priority < 0) { ! 267: priority = 0; ! 268: } else if (priority > TK_MAX_PRIO) { ! 269: priority = TK_MAX_PRIO; ! 270: } ! 271: newEl.priority = (priority << 24) + serial; ! 272: serial++; ! 273: ! 274: /* ! 275: * Parse the option one field at a time. ! 276: */ ! 277: ! 278: arrayPtrPtr = &(((TkWindow *) tkwin)->mainPtr->optionRootPtr); ! 279: p = name; ! 280: for (firstField = 1; ; firstField = 0) { ! 281: ! 282: /* ! 283: * Scan the next field from the name and convert it to a Tk_Uid. ! 284: * Must copy the field before calling Tk_Uid, so that a terminating ! 285: * NULL may be added without modifying the source string. ! 286: */ ! 287: ! 288: if (*p == '*') { ! 289: newEl.flags = WILDCARD; ! 290: p++; ! 291: } else { ! 292: newEl.flags = 0; ! 293: } ! 294: field = p; ! 295: while ((*p != 0) && (*p != '.') && (*p != '*')) { ! 296: p++; ! 297: } ! 298: length = p - field; ! 299: if (length > TMP_SIZE) { ! 300: length = TMP_SIZE; ! 301: } ! 302: strncpy(tmp, field, length); ! 303: tmp[length] = 0; ! 304: newEl.nameUid = Tk_GetUid(tmp); ! 305: if (isupper(*field)) { ! 306: newEl.flags |= CLASS; ! 307: } ! 308: ! 309: if (*p != 0) { ! 310: ! 311: /* ! 312: * New element will be a node. If this option can't possibly ! 313: * apply to this main window, then just skip it. Otherwise, ! 314: * add it to the parent, if it isn't already there, and descend ! 315: * into it. ! 316: */ ! 317: ! 318: newEl.flags |= NODE; ! 319: if (firstField && !(newEl.flags & WILDCARD) ! 320: && (newEl.nameUid != winPtr->nameUid) ! 321: && (newEl.nameUid != winPtr->classUid)) { ! 322: return; ! 323: } ! 324: for (elPtr = (*arrayPtrPtr)->els, count = (*arrayPtrPtr)->numUsed; ! 325: ; elPtr++, count--) { ! 326: if (count == 0) { ! 327: newEl.child.arrayPtr = NewArray(5); ! 328: *arrayPtrPtr = ExtendArray(*arrayPtrPtr, &newEl); ! 329: arrayPtrPtr = &((*arrayPtrPtr)->nextToUse[-1].child.arrayPtr); ! 330: break; ! 331: } ! 332: if ((elPtr->nameUid == newEl.nameUid) ! 333: && (elPtr->flags == newEl.flags)) { ! 334: arrayPtrPtr = &(elPtr->child.arrayPtr); ! 335: break; ! 336: } ! 337: } ! 338: if (*p == '.') { ! 339: p++; ! 340: } ! 341: } else { ! 342: ! 343: /* ! 344: * New element is a leaf. Add it to the parent, if it isn't ! 345: * already there. If it exists already, keep whichever value ! 346: * has highest priority. ! 347: */ ! 348: ! 349: newEl.child.valueUid = Tk_GetUid(value); ! 350: for (elPtr = (*arrayPtrPtr)->els, count = (*arrayPtrPtr)->numUsed; ! 351: ; elPtr++, count--) { ! 352: if (count == 0) { ! 353: *arrayPtrPtr = ExtendArray(*arrayPtrPtr, &newEl); ! 354: return; ! 355: } ! 356: if ((elPtr->nameUid == newEl.nameUid) ! 357: && (elPtr->flags == newEl.flags)) { ! 358: if (elPtr->priority < newEl.priority) { ! 359: elPtr->priority = newEl.priority; ! 360: elPtr->child.valueUid = newEl.child.valueUid; ! 361: } ! 362: return; ! 363: } ! 364: } ! 365: } ! 366: } ! 367: } ! 368: ! 369: /* ! 370: *-------------------------------------------------------------- ! 371: * ! 372: * Tk_GetOption -- ! 373: * ! 374: * Retrieve an option from the option database. ! 375: * ! 376: * Results: ! 377: * The return value is the value specified in the option ! 378: * database for the given name and class on the given ! 379: * window. If there is nothing specified in the database ! 380: * for that option, then NULL is returned. ! 381: * ! 382: * Side effects: ! 383: * The internal caches used to speed up option mapping ! 384: * may be modified, if this tkwin is different from the ! 385: * last tkwin used for option retrieval. ! 386: * ! 387: *-------------------------------------------------------------- ! 388: */ ! 389: ! 390: Tk_Uid ! 391: Tk_GetOption(tkwin, name, className) ! 392: Tk_Window tkwin; /* Token for window that option is ! 393: * associated with. */ ! 394: char *name; /* Name of option. */ ! 395: char *className; /* Class of option. NULL means there ! 396: * is no class for this option: just ! 397: * check for name. */ ! 398: { ! 399: Tk_Uid nameId, classId; ! 400: register Element *elPtr, *bestPtr; ! 401: register int count; ! 402: ! 403: /* ! 404: * Note: no need to call OptionInit here: it will be done by ! 405: * the SetupStacks call below (squeeze out those nanoseconds). ! 406: */ ! 407: ! 408: if (tkwin != (Tk_Window) cachedWindow) { ! 409: SetupStacks((TkWindow *) tkwin, 1); ! 410: } ! 411: ! 412: nameId = Tk_GetUid(name); ! 413: bestPtr = &defaultMatch; ! 414: for (elPtr = stacks[EXACT_LEAF_NAME]->els, ! 415: count = stacks[EXACT_LEAF_NAME]->numUsed; count > 0; ! 416: elPtr++, count--) { ! 417: if ((elPtr->nameUid == nameId) ! 418: && (elPtr->priority > bestPtr->priority)) { ! 419: bestPtr = elPtr; ! 420: } ! 421: } ! 422: for (elPtr = stacks[WILDCARD_LEAF_NAME]->els, ! 423: count = stacks[WILDCARD_LEAF_NAME]->numUsed; count > 0; ! 424: elPtr++, count--) { ! 425: if ((elPtr->nameUid == nameId) ! 426: && (elPtr->priority > bestPtr->priority)) { ! 427: bestPtr = elPtr; ! 428: } ! 429: } ! 430: if (className != NULL) { ! 431: classId = Tk_GetUid(className); ! 432: for (elPtr = stacks[EXACT_LEAF_CLASS]->els, ! 433: count = stacks[EXACT_LEAF_CLASS]->numUsed; count > 0; ! 434: elPtr++, count--) { ! 435: if ((elPtr->nameUid == classId) ! 436: && (elPtr->priority > bestPtr->priority)) { ! 437: bestPtr = elPtr; ! 438: } ! 439: } ! 440: for (elPtr = stacks[WILDCARD_LEAF_CLASS]->els, ! 441: count = stacks[WILDCARD_LEAF_CLASS]->numUsed; count > 0; ! 442: elPtr++, count--) { ! 443: if ((elPtr->nameUid == classId) ! 444: && (elPtr->priority > bestPtr->priority)) { ! 445: bestPtr = elPtr; ! 446: } ! 447: } ! 448: } ! 449: return bestPtr->child.valueUid; ! 450: } ! 451: ! 452: /* ! 453: *-------------------------------------------------------------- ! 454: * ! 455: * Tk_OptionCmd -- ! 456: * ! 457: * This procedure is invoked to process the "option" Tcl command. ! 458: * See the user documentation for details on what it does. ! 459: * ! 460: * Results: ! 461: * A standard Tcl result. ! 462: * ! 463: * Side effects: ! 464: * See the user documentation. ! 465: * ! 466: *-------------------------------------------------------------- ! 467: */ ! 468: ! 469: int ! 470: Tk_OptionCmd(clientData, interp, argc, argv) ! 471: ClientData clientData; /* Main window associated with ! 472: * interpreter. */ ! 473: Tcl_Interp *interp; /* Current interpreter. */ ! 474: int argc; /* Number of arguments. */ ! 475: char **argv; /* Argument strings. */ ! 476: { ! 477: Tk_Window tkwin = (Tk_Window) clientData; ! 478: int length; ! 479: char c; ! 480: ! 481: if (argc < 2) { ! 482: Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], ! 483: " cmd arg ?arg ...?\"", (char *) NULL); ! 484: return TCL_ERROR; ! 485: } ! 486: c = argv[1][0]; ! 487: length = strlen(argv[1]); ! 488: if ((c == 'a') && (strncmp(argv[1], "add", length) == 0)) { ! 489: int priority; ! 490: ! 491: if ((argc != 4) && (argc != 5)) { ! 492: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 493: argv[0], " add pattern value ?priority?\"", (char *) NULL); ! 494: return TCL_ERROR; ! 495: } ! 496: if (argc == 4) { ! 497: priority = TK_INTERACTIVE_PRIO; ! 498: } else { ! 499: priority = ParsePriority(interp, argv[4]); ! 500: if (priority < 0) { ! 501: return TCL_ERROR; ! 502: } ! 503: } ! 504: Tk_AddOption(tkwin, argv[2], argv[3], priority); ! 505: return TCL_OK; ! 506: } else if ((c == 'c') && (strncmp(argv[1], "clear", length) == 0)) { ! 507: TkMainInfo *mainPtr; ! 508: ! 509: if (argc != 2) { ! 510: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 511: argv[0], " clear\"", (char *) NULL); ! 512: return TCL_ERROR; ! 513: } ! 514: mainPtr = ((TkWindow *) tkwin)->mainPtr; ! 515: if (mainPtr->optionRootPtr != NULL) { ! 516: ClearOptionTree(mainPtr->optionRootPtr); ! 517: mainPtr->optionRootPtr = NULL; ! 518: } ! 519: cachedWindow = NULL; ! 520: return TCL_OK; ! 521: } else if ((c == 'g') && (strncmp(argv[1], "get", length) == 0)) { ! 522: Tk_Window window; ! 523: Tk_Uid value; ! 524: ! 525: if (argc != 5) { ! 526: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 527: argv[0], " get window name class\"", (char *) NULL); ! 528: return TCL_ERROR; ! 529: } ! 530: window = Tk_NameToWindow(interp, argv[2], tkwin); ! 531: if (window == NULL) { ! 532: return TCL_ERROR; ! 533: } ! 534: value = Tk_GetOption(window, argv[3], argv[4]); ! 535: if (value != NULL) { ! 536: interp->result = value; ! 537: } ! 538: return TCL_OK; ! 539: } else if ((c == 'r') && (strncmp(argv[1], "readfile", length) == 0)) { ! 540: int priority; ! 541: ! 542: if ((argc != 3) && (argc != 4)) { ! 543: Tcl_AppendResult(interp, "wrong # args: should be \"", ! 544: argv[0], " readfile fileName ?priority?\"", ! 545: (char *) NULL); ! 546: return TCL_ERROR; ! 547: } ! 548: if (argc == 4) { ! 549: priority = ParsePriority(interp, argv[3]); ! 550: if (priority < 0) { ! 551: return TCL_ERROR; ! 552: } ! 553: } else { ! 554: priority = TK_INTERACTIVE_PRIO; ! 555: } ! 556: return ReadOptionFile(interp, tkwin, argv[2], priority); ! 557: } else { ! 558: Tcl_AppendResult(interp, "bad option \"", argv[1], ! 559: "\": must be add, clear, get, or readfile", (char *) NULL); ! 560: return TCL_ERROR; ! 561: } ! 562: } ! 563: ! 564: /* ! 565: *-------------------------------------------------------------- ! 566: * ! 567: * TkOptionDeadWindow -- ! 568: * ! 569: * This procedure is called whenever a window is deleted. ! 570: * It cleans up any option-related stuff associated with ! 571: * the window. ! 572: * ! 573: * Results: ! 574: * None. ! 575: * ! 576: * Side effects: ! 577: * Option-related resources are freed. See code below ! 578: * for details. ! 579: * ! 580: *-------------------------------------------------------------- ! 581: */ ! 582: ! 583: void ! 584: TkOptionDeadWindow(winPtr) ! 585: register TkWindow *winPtr; /* Window to be cleaned up. */ ! 586: { ! 587: /* ! 588: * If this window is in the option stacks, then clear the stacks. ! 589: */ ! 590: ! 591: if (winPtr->optionLevel != -1) { ! 592: int i; ! 593: ! 594: for (i = 1; i <= curLevel; i++) { ! 595: levels[curLevel].winPtr->optionLevel = -1; ! 596: } ! 597: curLevel = 0; ! 598: cachedWindow = NULL; ! 599: } ! 600: ! 601: /* ! 602: * If this window was a main window, then delete its option ! 603: * database. ! 604: */ ! 605: ! 606: if ((winPtr->mainPtr->winPtr == winPtr) ! 607: && (winPtr->mainPtr->optionRootPtr != NULL)) { ! 608: ClearOptionTree(winPtr->mainPtr->optionRootPtr); ! 609: winPtr->mainPtr->optionRootPtr = NULL; ! 610: } ! 611: } ! 612: ! 613: /* ! 614: *---------------------------------------------------------------------- ! 615: * ! 616: * ParsePriority -- ! 617: * ! 618: * Parse a string priority value. ! 619: * ! 620: * Results: ! 621: * The return value is the integer priority level corresponding ! 622: * to string, or -1 if string doesn't point to a valid priority level. ! 623: * In this case, an error message is left in interp->result. ! 624: * ! 625: * Side effects: ! 626: * None. ! 627: * ! 628: *---------------------------------------------------------------------- ! 629: */ ! 630: ! 631: static int ! 632: ParsePriority(interp, string) ! 633: Tcl_Interp *interp; /* Interpreter to use for error reporting. */ ! 634: char *string; /* Describes a priority level, either ! 635: * symbolically or numerically. */ ! 636: { ! 637: char c; ! 638: int length, priority; ! 639: ! 640: c = string[0]; ! 641: length = strlen(string); ! 642: if ((c == 'w') ! 643: && (strncmp(string, "widgetDefault", length) == 0)) { ! 644: return TK_WIDGET_DEFAULT_PRIO; ! 645: } else if ((c == 's') ! 646: && (strncmp(string, "startupFile", length) == 0)) { ! 647: return TK_STARTUP_FILE_PRIO; ! 648: } else if ((c == 'u') ! 649: && (strncmp(string, "userDefault", length) == 0)) { ! 650: return TK_USER_DEFAULT_PRIO; ! 651: } else if ((c == 'i') ! 652: && (strncmp(string, "interactive", length) == 0)) { ! 653: return TK_INTERACTIVE_PRIO; ! 654: } else { ! 655: char *end; ! 656: ! 657: priority = strtoul(string, &end, 0); ! 658: if ((end == string) || (*end != 0) || (priority < 0) ! 659: || (priority > 100)) { ! 660: Tcl_AppendResult(interp, "bad priority level \"", string, ! 661: "\": must be widgetDefault, startupFile, userDefault, ", ! 662: "interactive, or a number between 0 and 100", ! 663: (char *) NULL); ! 664: return -1; ! 665: } ! 666: } ! 667: return priority; ! 668: } ! 669: ! 670: /* ! 671: *---------------------------------------------------------------------- ! 672: * ! 673: * AddFromString -- ! 674: * ! 675: * Given a string containing lines in the standard format for ! 676: * X resources (see other documentation for details on what this ! 677: * is), parse the resource specifications and enter them as options ! 678: * for tkwin's main window. ! 679: * ! 680: * Results: ! 681: * The return value is a standard Tcl return code. In the case of ! 682: * an error in parsing string, TCL_ERROR will be returned and an ! 683: * error message will be left in interp->result. The memory at ! 684: * string is totally trashed by this procedure. If you care about ! 685: * its contents, make a copy before calling here. ! 686: * ! 687: * Side effects: ! 688: * None. ! 689: * ! 690: *---------------------------------------------------------------------- ! 691: */ ! 692: ! 693: static int ! 694: AddFromString(interp, tkwin, string, priority) ! 695: Tcl_Interp *interp; /* Interpreter to use for reporting results. */ ! 696: Tk_Window tkwin; /* Token for window: options are entered ! 697: * for this window's main window. */ ! 698: char *string; /* String containing option specifiers. */ ! 699: int priority; /* Priority level to use for options in ! 700: * this string, such as TK_USER_DEFAULT_PRIO ! 701: * or TK_INTERACTIVE_PRIO. Must be between ! 702: * 0 and TK_MAX_PRIO. */ ! 703: { ! 704: register char *src, *dst; ! 705: char *name, *value; ! 706: int lineNum; ! 707: ! 708: src = string; ! 709: lineNum = 1; ! 710: while (1) { ! 711: ! 712: /* ! 713: * Skip leading white space and empty lines and comment lines, and ! 714: * check for the end of the spec. ! 715: */ ! 716: ! 717: while ((*src == ' ') || (*src == '\t')) { ! 718: src++; ! 719: } ! 720: if ((*src == '#') || (*src == '!')) { ! 721: do { ! 722: src++; ! 723: if ((src[0] == '\\') && (src[1] == '\n')) { ! 724: src += 2; ! 725: lineNum++; ! 726: } ! 727: } while ((*src != '\n') && (*src != 0)); ! 728: } ! 729: if (*src == '\n') { ! 730: src++; ! 731: lineNum++; ! 732: continue; ! 733: } ! 734: if (*src == '\0') { ! 735: break; ! 736: } ! 737: ! 738: /* ! 739: * Parse off the option name, collapsing out backslash-newline ! 740: * sequences of course. ! 741: */ ! 742: ! 743: dst = name = src; ! 744: while (*src != ':') { ! 745: if ((*src == '\0') || (*src == '\n')) { ! 746: sprintf(interp->result, "missing colon on line %d", ! 747: lineNum); ! 748: return TCL_ERROR; ! 749: } ! 750: if ((src[0] == '\\') && (src[1] == '\n')) { ! 751: src += 2; ! 752: lineNum++; ! 753: } else { ! 754: *dst = *src; ! 755: dst++; ! 756: src++; ! 757: } ! 758: } ! 759: ! 760: /* ! 761: * Eliminate trailing white space on the name, and null-terminate ! 762: * it. ! 763: */ ! 764: ! 765: while ((dst != name) && ((dst[-1] == ' ') || (dst[-1] == '\t'))) { ! 766: dst--; ! 767: } ! 768: *dst = '\0'; ! 769: ! 770: /* ! 771: * Skip white space between the name and the value. ! 772: */ ! 773: ! 774: src++; ! 775: while ((*src == ' ') || (*src == '\t')) { ! 776: src++; ! 777: } ! 778: if (*src == '\0') { ! 779: sprintf(interp->result, "missing value on line %d", lineNum); ! 780: return TCL_ERROR; ! 781: } ! 782: ! 783: /* ! 784: * Parse off the value, squeezing out backslash-newline sequences ! 785: * along the way. ! 786: */ ! 787: ! 788: dst = value = src; ! 789: while (*src != '\n') { ! 790: if (*src == '\0') { ! 791: sprintf(interp->result, "missing newline on line %d", ! 792: lineNum); ! 793: return TCL_ERROR; ! 794: } ! 795: if ((src[0] == '\\') && (src[1] == '\n')) { ! 796: src += 2; ! 797: lineNum++; ! 798: } else { ! 799: *dst = *src; ! 800: dst++; ! 801: src++; ! 802: } ! 803: } ! 804: *dst = 0; ! 805: ! 806: /* ! 807: * Enter the option into the database. ! 808: */ ! 809: ! 810: Tk_AddOption(tkwin, name, value, priority); ! 811: src++; ! 812: lineNum++; ! 813: } ! 814: return TCL_OK; ! 815: } ! 816: ! 817: /* ! 818: *---------------------------------------------------------------------- ! 819: * ! 820: * ReadOptionFile -- ! 821: * ! 822: * Read a file of options ("resources" in the old X terminology) ! 823: * and load them into the option database. ! 824: * ! 825: * Results: ! 826: * The return value is a standard Tcl return code. In the case of ! 827: * an error in parsing string, TCL_ERROR will be returned and an ! 828: * error message will be left in interp->result. ! 829: * ! 830: * Side effects: ! 831: * None. ! 832: * ! 833: *---------------------------------------------------------------------- ! 834: */ ! 835: ! 836: static int ! 837: ReadOptionFile(interp, tkwin, fileName, priority) ! 838: Tcl_Interp *interp; /* Interpreter to use for reporting results. */ ! 839: Tk_Window tkwin; /* Token for window: options are entered ! 840: * for this window's main window. */ ! 841: char *fileName; /* Name of file containing options. */ ! 842: int priority; /* Priority level to use for options in ! 843: * this file, such as TK_USER_DEFAULT_PRIO ! 844: * or TK_INTERACTIVE_PRIO. Must be between ! 845: * 0 and TK_MAX_PRIO. */ ! 846: { ! 847: char *realName, *buffer; ! 848: int fileId, result; ! 849: struct stat statBuf; ! 850: ! 851: realName = Tcl_TildeSubst(interp, fileName); ! 852: if (fileName == NULL) { ! 853: return TCL_ERROR; ! 854: } ! 855: #ifdef MSDOS ! 856: fileId = open(realName, O_RDONLY | O_BINARY, 0); ! 857: #else ! 858: fileId = open(realName, O_RDONLY, 0); ! 859: #endif ! 860: if (fileId < 0) { ! 861: Tcl_AppendResult(interp, "couldn't read file \"", fileName, "\"", ! 862: (char *) NULL); ! 863: return TCL_ERROR; ! 864: } ! 865: if (fstat(fileId, &statBuf) == -1) { ! 866: Tcl_AppendResult(interp, "couldn't stat file \"", fileName, "\"", ! 867: (char *) NULL); ! 868: close(fileId); ! 869: return TCL_ERROR; ! 870: } ! 871: buffer = (char *) ckalloc((unsigned) statBuf.st_size+1); ! 872: #ifdef MSDOS ! 873: if (read(fileId, buffer, (int) statBuf.st_size) < 0) { ! 874: #else ! 875: if (read(fileId, buffer, (int) statBuf.st_size) != statBuf.st_size) { ! 876: #endif ! 877: Tcl_AppendResult(interp, "error reading file \"", fileName, "\"", ! 878: (char *) NULL); ! 879: close(fileId); ! 880: return TCL_ERROR; ! 881: } ! 882: close(fileId); ! 883: buffer[statBuf.st_size] = 0; ! 884: result = AddFromString(interp, tkwin, buffer, priority); ! 885: ckfree(buffer); ! 886: return result; ! 887: } ! 888: ! 889: /* ! 890: *-------------------------------------------------------------- ! 891: * ! 892: * NewArray -- ! 893: * ! 894: * Create a new ElArray structure of a given size. ! 895: * ! 896: * Results: ! 897: * The return value is a pointer to a properly initialized ! 898: * element array with "numEls" space. The array is marked ! 899: * as having no active elements. ! 900: * ! 901: * Side effects: ! 902: * Memory is allocated. ! 903: * ! 904: *-------------------------------------------------------------- ! 905: */ ! 906: ! 907: static ElArray * ! 908: NewArray(numEls) ! 909: int numEls; /* How many elements of space to allocate. */ ! 910: { ! 911: register ElArray *arrayPtr; ! 912: ! 913: arrayPtr = (ElArray *) ckalloc(EL_ARRAY_SIZE(numEls)); ! 914: arrayPtr->arraySize = numEls; ! 915: arrayPtr->numUsed = 0; ! 916: arrayPtr->nextToUse = arrayPtr->els; ! 917: return arrayPtr; ! 918: } ! 919: ! 920: /* ! 921: *-------------------------------------------------------------- ! 922: * ! 923: * ExtendArray -- ! 924: * ! 925: * Add a new element to an array, extending the array if ! 926: * necessary. ! 927: * ! 928: * Results: ! 929: * The return value is a pointer to the new array, which ! 930: * will be different from arrayPtr if the array got expanded. ! 931: * ! 932: * Side effects: ! 933: * Memory may be allocated or freed. ! 934: * ! 935: *-------------------------------------------------------------- ! 936: */ ! 937: ! 938: static ElArray * ! 939: ExtendArray(arrayPtr, elPtr) ! 940: register ElArray *arrayPtr; /* Array to be extended. */ ! 941: register Element *elPtr; /* Element to be copied into array. */ ! 942: { ! 943: /* ! 944: * If the current array has filled up, make it bigger. ! 945: */ ! 946: ! 947: if (arrayPtr->numUsed >= arrayPtr->arraySize) { ! 948: register ElArray *newPtr; ! 949: ! 950: newPtr = (ElArray *) ckalloc(EL_ARRAY_SIZE(2*arrayPtr->arraySize)); ! 951: newPtr->arraySize = 2*arrayPtr->arraySize; ! 952: newPtr->numUsed = arrayPtr->numUsed; ! 953: newPtr->nextToUse = &newPtr->els[newPtr->numUsed]; ! 954: memcpy((VOID *) newPtr->els, (VOID *) arrayPtr->els, ! 955: (arrayPtr->arraySize*sizeof(Element))); ! 956: ckfree((char *) arrayPtr); ! 957: arrayPtr = newPtr; ! 958: } ! 959: ! 960: *arrayPtr->nextToUse = *elPtr; ! 961: arrayPtr->nextToUse++; ! 962: arrayPtr->numUsed++; ! 963: return arrayPtr; ! 964: } ! 965: ! 966: /* ! 967: *-------------------------------------------------------------- ! 968: * ! 969: * SetupStacks -- ! 970: * ! 971: * Arrange the stacks so that they cache all the option ! 972: * information for a particular window. ! 973: * ! 974: * Results: ! 975: * None. ! 976: * ! 977: * Side effects: ! 978: * The stacks are modified to hold information for tkwin ! 979: * and all its ancestors in the window hierarchy. ! 980: * ! 981: *-------------------------------------------------------------- ! 982: */ ! 983: ! 984: static void ! 985: SetupStacks(winPtr, leaf) ! 986: TkWindow *winPtr; /* Window for which information is to ! 987: * be cached. */ ! 988: int leaf; /* Non-zero means this is the leaf ! 989: * window being probed. Zero means this ! 990: * is an ancestor of the desired leaf. */ ! 991: { ! 992: int level, i, *iPtr; ! 993: register StackLevel *levelPtr; ! 994: register ElArray *arrayPtr; ! 995: ! 996: /* ! 997: * The following array defines the order in which the current ! 998: * stacks are searched to find matching entries to add to the ! 999: * stacks. Given the current priority-based scheme, the order ! 1000: * below is no longer relevant; all that matters is that an ! 1001: * element is on the list *somewhere*. The ordering is a relic ! 1002: * of the old days when priorities were determined differently. ! 1003: */ ! 1004: ! 1005: static int searchOrder[] = {WILDCARD_NODE_CLASS, WILDCARD_NODE_NAME, ! 1006: EXACT_NODE_CLASS, EXACT_NODE_NAME, -1}; ! 1007: ! 1008: if (winPtr->mainPtr->optionRootPtr == NULL) { ! 1009: OptionInit(winPtr->mainPtr); ! 1010: } ! 1011: ! 1012: /* ! 1013: * Step 1: make sure that options are cached for this window's ! 1014: * parent. ! 1015: */ ! 1016: ! 1017: if (winPtr->parentPtr != NULL) { ! 1018: level = winPtr->parentPtr->optionLevel; ! 1019: if ((level == -1) || (cachedWindow == NULL)) { ! 1020: SetupStacks(winPtr->parentPtr, 0); ! 1021: level = winPtr->parentPtr->optionLevel; ! 1022: } ! 1023: level++; ! 1024: } else { ! 1025: level = 1; ! 1026: } ! 1027: ! 1028: /* ! 1029: * Step 2: pop extra unneeded information off the stacks and ! 1030: * mark those windows as no longer having cached information. ! 1031: */ ! 1032: ! 1033: if (curLevel >= level) { ! 1034: while (curLevel >= level) { ! 1035: levels[curLevel].winPtr->optionLevel = -1; ! 1036: curLevel--; ! 1037: } ! 1038: levelPtr = &levels[level]; ! 1039: for (i = 0; i < NUM_STACKS; i++) { ! 1040: arrayPtr = stacks[i]; ! 1041: arrayPtr->numUsed = levelPtr->bases[i]; ! 1042: arrayPtr->nextToUse = &arrayPtr->els[arrayPtr->numUsed]; ! 1043: } ! 1044: } ! 1045: curLevel = winPtr->optionLevel = level; ! 1046: ! 1047: /* ! 1048: * Step 3: if the root database information isn't loaded or ! 1049: * isn't valid, initialize level 0 of the stack from the ! 1050: * database root (this only happens if winPtr is a main window). ! 1051: */ ! 1052: ! 1053: if ((curLevel == 1) ! 1054: && ((cachedWindow == NULL) ! 1055: || (cachedWindow->mainPtr != winPtr->mainPtr))) { ! 1056: for (i = 0; i < NUM_STACKS; i++) { ! 1057: arrayPtr = stacks[i]; ! 1058: arrayPtr->numUsed = 0; ! 1059: arrayPtr->nextToUse = arrayPtr->els; ! 1060: } ! 1061: ExtendStacks(winPtr->mainPtr->optionRootPtr, 0); ! 1062: } ! 1063: ! 1064: /* ! 1065: * Step 4: create a new stack level; grow the level array if ! 1066: * we've run out of levels. Clear the stacks for EXACT_LEAF_NAME ! 1067: * and EXACT_LEAF_CLASS (anything that was there is of no use ! 1068: * any more). ! 1069: */ ! 1070: ! 1071: if (curLevel >= numLevels) { ! 1072: StackLevel *newLevels; ! 1073: ! 1074: newLevels = (StackLevel *) ckalloc((unsigned) ! 1075: (numLevels*2*sizeof(StackLevel))); ! 1076: memcpy((VOID *) newLevels, (VOID *) levels, ! 1077: (numLevels*sizeof(StackLevel))); ! 1078: ckfree((char *) levels); ! 1079: numLevels *= 2; ! 1080: levels = newLevels; ! 1081: } ! 1082: levelPtr = &levels[curLevel]; ! 1083: levelPtr->winPtr = winPtr; ! 1084: arrayPtr = stacks[EXACT_LEAF_NAME]; ! 1085: arrayPtr->numUsed = 0; ! 1086: arrayPtr->nextToUse = arrayPtr->els; ! 1087: arrayPtr = stacks[EXACT_LEAF_CLASS]; ! 1088: arrayPtr->numUsed = 0; ! 1089: arrayPtr->nextToUse = arrayPtr->els; ! 1090: levelPtr->bases[EXACT_LEAF_NAME] = stacks[EXACT_LEAF_NAME]->numUsed; ! 1091: levelPtr->bases[EXACT_LEAF_CLASS] = stacks[EXACT_LEAF_CLASS]->numUsed; ! 1092: levelPtr->bases[EXACT_NODE_NAME] = stacks[EXACT_NODE_NAME]->numUsed; ! 1093: levelPtr->bases[EXACT_NODE_CLASS] = stacks[EXACT_NODE_CLASS]->numUsed; ! 1094: levelPtr->bases[WILDCARD_LEAF_NAME] = stacks[WILDCARD_LEAF_NAME]->numUsed; ! 1095: levelPtr->bases[WILDCARD_LEAF_CLASS] = stacks[WILDCARD_LEAF_CLASS]->numUsed; ! 1096: levelPtr->bases[WILDCARD_NODE_NAME] = stacks[WILDCARD_NODE_NAME]->numUsed; ! 1097: levelPtr->bases[WILDCARD_NODE_CLASS] = stacks[WILDCARD_NODE_CLASS]->numUsed; ! 1098: ! 1099: ! 1100: /* ! 1101: * Step 5: scan the current stack level looking for matches to this ! 1102: * window's name or class; where found, add new information to the ! 1103: * stacks. ! 1104: */ ! 1105: ! 1106: for (iPtr = searchOrder; *iPtr != -1; iPtr++) { ! 1107: register Element *elPtr; ! 1108: int count; ! 1109: Tk_Uid id; ! 1110: ! 1111: i = *iPtr; ! 1112: if (i & CLASS) { ! 1113: id = winPtr->classUid; ! 1114: } else { ! 1115: id = winPtr->nameUid; ! 1116: } ! 1117: elPtr = stacks[i]->els; ! 1118: count = levelPtr->bases[i]; ! 1119: ! 1120: /* ! 1121: * For wildcard stacks, check all entries; for non-wildcard ! 1122: * stacks, only check things that matched in the parent. ! 1123: */ ! 1124: ! 1125: if (!(i & WILDCARD)) { ! 1126: elPtr += levelPtr[-1].bases[i]; ! 1127: count -= levelPtr[-1].bases[i]; ! 1128: } ! 1129: for ( ; count > 0; elPtr++, count--) { ! 1130: if (elPtr->nameUid != id) { ! 1131: continue; ! 1132: } ! 1133: ExtendStacks(elPtr->child.arrayPtr, leaf); ! 1134: } ! 1135: } ! 1136: cachedWindow = winPtr; ! 1137: } ! 1138: ! 1139: /* ! 1140: *-------------------------------------------------------------- ! 1141: * ! 1142: * ExtendStacks -- ! 1143: * ! 1144: * Given an element array, copy all the elements from the ! 1145: * array onto the system stacks (except for irrelevant leaf ! 1146: * elements). ! 1147: * ! 1148: * Results: ! 1149: * None. ! 1150: * ! 1151: * Side effects: ! 1152: * The option stacks are extended. ! 1153: * ! 1154: *-------------------------------------------------------------- ! 1155: */ ! 1156: ! 1157: static void ! 1158: ExtendStacks(arrayPtr, leaf) ! 1159: ElArray *arrayPtr; /* Array of elements to copy onto stacks. */ ! 1160: int leaf; /* If zero, then don't copy exact leaf ! 1161: * elements. */ ! 1162: { ! 1163: register int count; ! 1164: register Element *elPtr; ! 1165: ! 1166: for (elPtr = arrayPtr->els, count = arrayPtr->numUsed; ! 1167: count > 0; elPtr++, count--) { ! 1168: if (!(elPtr->flags & (NODE|WILDCARD)) && !leaf) { ! 1169: continue; ! 1170: } ! 1171: stacks[elPtr->flags] = ExtendArray(stacks[elPtr->flags], elPtr); ! 1172: } ! 1173: } ! 1174: ! 1175: /* ! 1176: *-------------------------------------------------------------- ! 1177: * ! 1178: * OptionInit -- ! 1179: * ! 1180: * Initialize data structures for option handling. ! 1181: * ! 1182: * Results: ! 1183: * None. ! 1184: * ! 1185: * Side effects: ! 1186: * Option-related data structures get initialized. ! 1187: * ! 1188: *-------------------------------------------------------------- ! 1189: */ ! 1190: ! 1191: static void ! 1192: OptionInit(mainPtr) ! 1193: register TkMainInfo *mainPtr; /* Top-level information about ! 1194: * window that isn't initialized ! 1195: * yet. */ ! 1196: { ! 1197: int i; ! 1198: Tcl_Interp *interp; ! 1199: ! 1200: /* ! 1201: * First, once-only initialization. ! 1202: */ ! 1203: ! 1204: if (numLevels == 0) { ! 1205: ! 1206: numLevels = 5; ! 1207: levels = (StackLevel *) ckalloc((unsigned) (5*sizeof(StackLevel))); ! 1208: for (i = 0; i < NUM_STACKS; i++) { ! 1209: stacks[i] = NewArray(10); ! 1210: levels[0].bases[i] = 0; ! 1211: } ! 1212: ! 1213: defaultMatch.nameUid = NULL; ! 1214: defaultMatch.child.valueUid = NULL; ! 1215: defaultMatch.priority = -1; ! 1216: defaultMatch.flags = 0; ! 1217: } ! 1218: ! 1219: /* ! 1220: * Then, per-main-window initialization. Create and delete dummy ! 1221: * interpreter for message logging. ! 1222: */ ! 1223: ! 1224: mainPtr->optionRootPtr = NewArray(20); ! 1225: interp = Tcl_CreateInterp(); ! 1226: (void) GetDefaultOptions(interp, mainPtr->winPtr); ! 1227: Tcl_DeleteInterp(interp); ! 1228: } ! 1229: ! 1230: /* ! 1231: *-------------------------------------------------------------- ! 1232: * ! 1233: * ClearOptionTree -- ! 1234: * ! 1235: * This procedure is called to erase everything in a ! 1236: * hierarchical option database. ! 1237: * ! 1238: * Results: ! 1239: * None. ! 1240: * ! 1241: * Side effects: ! 1242: * All the options associated with arrayPtr are deleted, ! 1243: * along with all option subtrees. The space pointed to ! 1244: * by arrayPtr is freed. ! 1245: * ! 1246: *-------------------------------------------------------------- ! 1247: */ ! 1248: ! 1249: static void ! 1250: ClearOptionTree(arrayPtr) ! 1251: ElArray *arrayPtr; /* Array of options; delete everything ! 1252: * referred to recursively by this. */ ! 1253: { ! 1254: register Element *elPtr; ! 1255: int count; ! 1256: ! 1257: for (count = arrayPtr->numUsed, elPtr = arrayPtr->els; count > 0; ! 1258: count--, elPtr++) { ! 1259: if (elPtr->flags & NODE) { ! 1260: ClearOptionTree(elPtr->child.arrayPtr); ! 1261: } ! 1262: } ! 1263: ckfree((char *) arrayPtr); ! 1264: } ! 1265: ! 1266: /* ! 1267: *-------------------------------------------------------------- ! 1268: * ! 1269: * GetDefaultOptions -- ! 1270: * ! 1271: * This procedure is invoked to load the default set of options ! 1272: * for a window. ! 1273: * ! 1274: * Results: ! 1275: * None. ! 1276: * ! 1277: * Side effects: ! 1278: * Options are added to those for winPtr's main window. If ! 1279: * there exists a RESOURCE_MANAGER proprety for winPtr's ! 1280: * display, that is used. Otherwise, the .Xdefaults file in ! 1281: * the user's home directory is used. ! 1282: * ! 1283: *-------------------------------------------------------------- ! 1284: */ ! 1285: ! 1286: static int ! 1287: GetDefaultOptions(interp, winPtr) ! 1288: Tcl_Interp *interp; /* Interpreter to use for error reporting. */ ! 1289: TkWindow *winPtr; /* Fetch option defaults for main window ! 1290: * associated with this. */ ! 1291: { ! 1292: char *regProp, *home, *fileName; ! 1293: int result, actualFormat; ! 1294: unsigned long numItems, bytesAfter; ! 1295: Atom actualType; ! 1296: ! 1297: /* ! 1298: * Try the RESOURCE_MANAGER property on the root window first. ! 1299: */ ! 1300: ! 1301: regProp = NULL; ! 1302: result = XGetWindowProperty(winPtr->display, ! 1303: Tk_DefaultRootWindow(winPtr->display), ! 1304: XA_RESOURCE_MANAGER, 0, 100000, ! 1305: False, XA_STRING, &actualType, &actualFormat, ! 1306: &numItems, &bytesAfter, (unsigned char **) ®Prop); ! 1307: ! 1308: if ((result == Success) && (actualType == XA_STRING) ! 1309: && (actualFormat == 8)) { ! 1310: result = AddFromString(interp, (Tk_Window) winPtr, regProp, ! 1311: TK_USER_DEFAULT_PRIO); ! 1312: XFree(regProp); ! 1313: return result; ! 1314: } ! 1315: ! 1316: /* ! 1317: * No luck there. Try a .Xdefaults file in the user's home ! 1318: * directory. ! 1319: */ ! 1320: ! 1321: if (regProp != NULL) { ! 1322: XFree(regProp); ! 1323: } ! 1324: home = getenv("HOME"); ! 1325: if (home == NULL) { ! 1326: sprintf(interp->result, ! 1327: "no RESOURCE_MANAGER property and no HOME envariable"); ! 1328: return TCL_ERROR; ! 1329: } ! 1330: fileName = (char *) ckalloc((unsigned) (strlen(home) + 20)); ! 1331: sprintf(fileName, "%s/.Xdefaults", home); ! 1332: result = ReadOptionFile(interp, (Tk_Window) winPtr, fileName, ! 1333: TK_USER_DEFAULT_PRIO); ! 1334: ckfree(fileName); ! 1335: return result; ! 1336: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.