home *** CD-ROM | disk | FTP | other *** search
/ Practical Programming in Tcl & Tk (4th Edition) / TCLBOOK4.BIN / mac / extensions / blt / blt2_4z_patch1.txt < prev    next >
Text File  |  2003-04-01  |  19KB  |  617 lines
  1. This patch fixes the following problems with BLT 2.4z
  2.  
  3.   1) BLT won't load into more than one interpreter.
  4.  
  5.   2) Hiding an element 
  6.      
  7.         .graph element configure "e0" -hide yes
  8.  
  9.     also hides the legend entry.
  10.  
  11. Apply this patch from the top of the blt2.4z source tree (i.e.
  12. the directory that contains "blt2.4z").
  13.  
  14.   --gah
  15.  
  16. diff -cr blt2.4z-old/src/bltGrAxis.c blt2.4z/src/bltGrAxis.c
  17. *** blt2.4z-old/src/bltGrAxis.c    2002-09-18 17:30:51.000000000 -0500
  18. --- blt2.4z/src/bltGrAxis.c    2002-12-02 22:39:26.000000000 -0600
  19. ***************
  20. *** 1424,1482 ****
  21.       double majorStep, minorStep;
  22.       int nMajor, nMinor;
  23.   
  24. !     min = (min != 0.0) ? log10(FABS(min)) : 0.0;
  25. !     max = (max != 0.0) ? log10(FABS(max)) : 1.0;
  26. ! 
  27. !     tickMin = floor(min);
  28. !     tickMax = ceil(max);
  29. !     range = tickMax - tickMin;
  30. ! 
  31. !     if (range > 10) {
  32. !     /* There are too many decades to display a major tick at every
  33. !      * decade.  Instead, treat the axis as a linear scale.  */
  34. !     range = NiceNum(range, 0);
  35. !     majorStep = NiceNum(range / DEF_NUM_TICKS, 1);
  36. !     tickMin = UFLOOR(tickMin, majorStep);
  37. !     tickMax = UCEIL(tickMax, majorStep);
  38. !     nMajor = (int)((tickMax - tickMin) / majorStep) + 1;
  39. !     minorStep = EXP10(floor(log10(majorStep)));
  40. !     if (minorStep == majorStep) {
  41. !         nMinor = 4, minorStep = 0.2;
  42.       } else {
  43. !         nMinor = Round(majorStep / minorStep) - 1;
  44. !     }
  45. !     } else {
  46. !     if (tickMin == tickMax) {
  47. !         tickMax++;
  48. !     }
  49. !     majorStep = 1.0;
  50. !     nMajor = (int)(tickMax - tickMin + 1); /* FIXME: Check this. */
  51. ! 
  52. !     minorStep = 0.0;    /* This is a special hack to pass
  53.                    * information to the GenerateTicks
  54.                    * routine. An interval of 0.0 tells
  55.                    *    1) this is a minor sweep and 
  56.                    *    2) the axis is log scale.  
  57.                    */
  58. !     nMinor = 10;
  59. !     }
  60. !     if ((axisPtr->looseMin == TICK_RANGE_TIGHT) ||
  61. !     ((axisPtr->looseMin == TICK_RANGE_LOOSE) && 
  62. !      (DEFINED(axisPtr->reqMin)))) {
  63. !     tickMin = min;
  64. !     nMajor++;
  65. !     }
  66. !     if ((axisPtr->looseMax == TICK_RANGE_TIGHT) ||
  67. !     ((axisPtr->looseMax == TICK_RANGE_LOOSE) &&
  68. !      (DEFINED(axisPtr->reqMax)))) {
  69. !     tickMax = max;
  70.       }
  71.       axisPtr->majorSweep.step = majorStep;
  72.       axisPtr->majorSweep.initial = floor(tickMin);
  73.       axisPtr->majorSweep.nSteps = nMajor;
  74.       axisPtr->minorSweep.initial = axisPtr->minorSweep.step = minorStep;
  75.       axisPtr->minorSweep.nSteps = nMinor;
  76. - 
  77.       SetAxisRange(&axisPtr->axisRange, tickMin, tickMax);
  78.   }
  79.   
  80. --- 1424,1485 ----
  81.       double majorStep, minorStep;
  82.       int nMajor, nMinor;
  83.   
  84. !     nMajor = nMinor = 0;
  85. !     majorStep = minorStep = 0.0;
  86. !     if (min < max) {
  87. !     min = (min != 0.0) ? log10(FABS(min)) : 0.0;
  88. !     max = (max != 0.0) ? log10(FABS(max)) : 1.0;
  89. !     
  90. !     tickMin = floor(min);
  91. !     tickMax = ceil(max);
  92. !     range = tickMax - tickMin;
  93. !     
  94. !     if (range > 10) {
  95. !         /* There are too many decades to display a major tick at every
  96. !          * decade.  Instead, treat the axis as a linear scale.  */
  97. !         range = NiceNum(range, 0);
  98. !         majorStep = NiceNum(range / DEF_NUM_TICKS, 1);
  99. !         tickMin = UFLOOR(tickMin, majorStep);
  100. !         tickMax = UCEIL(tickMax, majorStep);
  101. !         nMajor = (int)((tickMax - tickMin) / majorStep) + 1;
  102. !         minorStep = EXP10(floor(log10(majorStep)));
  103. !         if (minorStep == majorStep) {
  104. !         nMinor = 4, minorStep = 0.2;
  105. !         } else {
  106. !         nMinor = Round(majorStep / minorStep) - 1;
  107. !         }
  108.       } else {
  109. !         if (tickMin == tickMax) {
  110. !         tickMax++;
  111. !         }
  112. !         majorStep = 1.0;
  113. !         nMajor = (int)(tickMax - tickMin + 1); /* FIXME: Check this. */
  114. !         
  115. !         minorStep = 0.0;    /* This is a special hack to pass
  116.                    * information to the GenerateTicks
  117.                    * routine. An interval of 0.0 tells
  118.                    *    1) this is a minor sweep and 
  119.                    *    2) the axis is log scale.  
  120.                    */
  121. !         nMinor = 10;
  122. !     }
  123. !     if ((axisPtr->looseMin == TICK_RANGE_TIGHT) ||
  124. !         ((axisPtr->looseMin == TICK_RANGE_LOOSE) && 
  125. !          (DEFINED(axisPtr->reqMin)))) {
  126. !         tickMin = min;
  127. !         nMajor++;
  128. !     }
  129. !     if ((axisPtr->looseMax == TICK_RANGE_TIGHT) ||
  130. !         ((axisPtr->looseMax == TICK_RANGE_LOOSE) &&
  131. !          (DEFINED(axisPtr->reqMax)))) {
  132. !         tickMax = max;
  133. !     }
  134.       }
  135.       axisPtr->majorSweep.step = majorStep;
  136.       axisPtr->majorSweep.initial = floor(tickMin);
  137.       axisPtr->majorSweep.nSteps = nMajor;
  138.       axisPtr->minorSweep.initial = axisPtr->minorSweep.step = minorStep;
  139.       axisPtr->minorSweep.nSteps = nMinor;
  140.       SetAxisRange(&axisPtr->axisRange, tickMin, tickMax);
  141.   }
  142.   
  143. ***************
  144. *** 1551,1581 ****
  145.       double axisMin, axisMax;
  146.       int nTicks;
  147.   
  148. !     range = max - min;
  149. ! 
  150. !     /* Calculate the major tick stepping. */
  151. !     if (axisPtr->reqStep > 0.0) {
  152. !     /* An interval was designated by the user.  Keep scaling it
  153. !      * until it fits comfortably within the current range of the
  154. !      * axis.  */
  155. !     step = axisPtr->reqStep;
  156. !     while ((2 * step) >= range) {
  157. !         step *= 0.5;
  158.       }
  159. !     } else {
  160. !     range = NiceNum(range, 0);
  161. !     step = NiceNum(range / DEF_NUM_TICKS, 1);
  162.       }
  163. - 
  164. -     /* Find the outer tick values. Add 0.0 to prevent getting -0.0. */
  165. -     axisMin = tickMin = floor(min / step) * step + 0.0;
  166. -     axisMax = tickMax = ceil(max / step) * step + 0.0;
  167. - 
  168. -     nTicks = Round((tickMax - tickMin) / step) + 1;
  169.       axisPtr->majorSweep.step = step;
  170.       axisPtr->majorSweep.initial = tickMin;
  171.       axisPtr->majorSweep.nSteps = nTicks;
  172. ! 
  173.       /*
  174.        * The limits of the axis are either the range of the data
  175.        * ("tight") or at the next outer tick interval ("loose").  The
  176. --- 1554,1588 ----
  177.       double axisMin, axisMax;
  178.       int nTicks;
  179.   
  180. !     nTicks = 0;
  181. !     tickMin = tickMax = 0.0;
  182. !     if (min < max) {
  183. !     range = max - min;
  184. !     
  185. !     /* Calculate the major tick stepping. */
  186. !     if (axisPtr->reqStep > 0.0) {
  187. !         /* An interval was designated by the user.  Keep scaling it
  188. !          * until it fits comfortably within the current range of the
  189. !          * axis.  */
  190. !         step = axisPtr->reqStep;
  191. !         while ((2 * step) >= range) {
  192. !         step *= 0.5;
  193. !         }
  194. !     } else {
  195. !         range = NiceNum(range, 0);
  196. !         step = NiceNum(range / DEF_NUM_TICKS, 1);
  197.       }
  198. !     
  199. !     /* Find the outer tick values. Add 0.0 to prevent getting -0.0. */
  200. !     axisMin = tickMin = floor(min / step) * step + 0.0;
  201. !     axisMax = tickMax = ceil(max / step) * step + 0.0;
  202. !     
  203. !     nTicks = Round((tickMax - tickMin) / step) + 1;
  204.       }
  205.       axisPtr->majorSweep.step = step;
  206.       axisPtr->majorSweep.initial = tickMin;
  207.       axisPtr->majorSweep.nSteps = nTicks;
  208. !     
  209.       /*
  210.        * The limits of the axis are either the range of the data
  211.        * ("tight") or at the next outer tick interval ("loose").  The
  212. ***************
  213. *** 1596,1604 ****
  214.       axisMax = max;
  215.       }
  216.       SetAxisRange(&axisPtr->axisRange, axisMin, axisMax);
  217. ! 
  218.       /* Now calculate the minor tick step and number. */
  219. ! 
  220.       if ((axisPtr->reqNumMinorTicks > 0) && 
  221.       ((axisPtr->flags & AXIS_CONFIG_MAJOR) == 0)) {
  222.       nTicks = axisPtr->reqNumMinorTicks - 1;
  223. --- 1603,1611 ----
  224.       axisMax = max;
  225.       }
  226.       SetAxisRange(&axisPtr->axisRange, axisMin, axisMax);
  227. !     
  228.       /* Now calculate the minor tick step and number. */
  229. !     
  230.       if ((axisPtr->reqNumMinorTicks > 0) && 
  231.       ((axisPtr->flags & AXIS_CONFIG_MAJOR) == 0)) {
  232.       nTicks = axisPtr->reqNumMinorTicks - 1;
  233. ***************
  234. *** 1614,1620 ****
  235.       axisPtr->minorSweep.nSteps = nTicks;
  236.   }
  237.   
  238. - 
  239.   static void
  240.   SweepTicks(axisPtr)
  241.       Axis *axisPtr;
  242. --- 1621,1626 ----
  243. ***************
  244. *** 1684,1692 ****
  245.       for (linkPtr = Blt_ChainFirstLink(graphPtr->elements.displayList);
  246.       linkPtr != NULL; linkPtr = Blt_ChainNextLink(linkPtr)) {
  247.       elemPtr = Blt_ChainGetValue(linkPtr);
  248. !     (*elemPtr->procsPtr->extentsProc) (elemPtr, &exts);
  249. !     GetDataLimits(elemPtr->axes.x, exts.left, exts.right);
  250. !     GetDataLimits(elemPtr->axes.y, exts.top, exts.bottom);
  251.       }
  252.       /*
  253.        * Step 3:  Now that we know the range of data values for each axis,
  254. --- 1690,1700 ----
  255.       for (linkPtr = Blt_ChainFirstLink(graphPtr->elements.displayList);
  256.       linkPtr != NULL; linkPtr = Blt_ChainNextLink(linkPtr)) {
  257.       elemPtr = Blt_ChainGetValue(linkPtr);
  258. !     if (!elemPtr->hidden) {
  259. !         (*elemPtr->procsPtr->extentsProc) (elemPtr, &exts);
  260. !         GetDataLimits(elemPtr->axes.x, exts.left, exts.right);
  261. !         GetDataLimits(elemPtr->axes.y, exts.top, exts.bottom);
  262. !     }
  263.       }
  264.       /*
  265.        * Step 3:  Now that we know the range of data values for each axis,
  266. diff -cr blt2.4z-old/src/bltGrElem.c blt2.4z/src/bltGrElem.c
  267. *** blt2.4z-old/src/bltGrElem.c    2002-09-18 17:30:51.000000000 -0500
  268. --- blt2.4z/src/bltGrElem.c    2002-12-02 22:42:31.000000000 -0600
  269. ***************
  270. *** 1215,1223 ****
  271.   {
  272.       int nNames;            /* Number of names found in Tcl name list */
  273.       char **nameArr;        /* Broken out array of element names */
  274. -     Blt_HashSearch cursor;
  275.       register int i;
  276. -     register Blt_HashEntry *hPtr;
  277.       Element *elemPtr;        /* Element information record */
  278.   
  279.       if (Tcl_SplitList(graphPtr->interp, newList, &nNames, &nameArr) != TCL_OK) {
  280. --- 1215,1221 ----
  281. ***************
  282. *** 1227,1243 ****
  283.       }
  284.       /* Clear the display list and mark all elements as hidden.  */
  285.       Blt_ChainReset(graphPtr->elements.displayList);
  286. -     for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.table, &cursor);
  287. -     hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
  288. -     elemPtr = (Element *)Blt_GetHashValue(hPtr);
  289. -     elemPtr->hidden = TRUE;
  290. -     }
  291.   
  292.       /* Rebuild the display list, checking that each name it exists
  293.        * (currently ignoring invalid element names).  */
  294.       for (i = 0; i < nNames; i++) {
  295.       if (NameToElement(graphPtr, nameArr[i], &elemPtr) == TCL_OK) {
  296. -         elemPtr->hidden = FALSE;
  297.           Blt_ChainAppend(graphPtr->elements.displayList, elemPtr);
  298.       }
  299.       }
  300. --- 1225,1235 ----
  301. ***************
  302. *** 1399,1406 ****
  303.           /* Comment the PostScript to indicate the start of the element */
  304.           Blt_FormatToPostScript(psToken, "\n%% Element \"%s\"\n\n", 
  305.           elemPtr->name);
  306. !         (*elemPtr->procsPtr->printNormalProc) (graphPtr, psToken, 
  307. !         elemPtr);
  308.       }
  309.       }
  310.   }
  311. --- 1391,1397 ----
  312.           /* Comment the PostScript to indicate the start of the element */
  313.           Blt_FormatToPostScript(psToken, "\n%% Element \"%s\"\n\n", 
  314.           elemPtr->name);
  315. !         (*elemPtr->procsPtr->printNormalProc) (graphPtr, psToken, elemPtr);
  316.       }
  317.       }
  318.   }
  319. ***************
  320. *** 1426,1433 ****
  321.       if ((!elemPtr->hidden) && (elemPtr->flags & ELEM_ACTIVE)) {
  322.           Blt_FormatToPostScript(psToken, "\n%% Active Element \"%s\"\n\n",
  323.           elemPtr->name);
  324. !         (*elemPtr->procsPtr->printActiveProc) (graphPtr, psToken, 
  325. !                            elemPtr);
  326.       }
  327.       }
  328.   }
  329. --- 1417,1423 ----
  330.       if ((!elemPtr->hidden) && (elemPtr->flags & ELEM_ACTIVE)) {
  331.           Blt_FormatToPostScript(psToken, "\n%% Active Element \"%s\"\n\n",
  332.           elemPtr->name);
  333. !         (*elemPtr->procsPtr->printActiveProc) (graphPtr, psToken, elemPtr);
  334.       }
  335.       }
  336.   }
  337. ***************
  338. *** 1671,1676 ****
  339. --- 1661,1667 ----
  340.       ClosestSearch search;
  341.       int i, x, y;
  342.       int flags = TCL_LEAVE_ERR_MSG;
  343. +     int found;
  344.   
  345.       if (graphPtr->flags & RESET_AXES) {
  346.       Blt_ResetAxes(graphPtr);
  347. ***************
  348. *** 1715,1727 ****
  349.       search.dist = (double)(search.halo + 1);
  350.   
  351.       if (i < argc) {
  352.       for ( /* empty */ ; i < argc; i++) {
  353.           if (NameToElement(graphPtr, argv[i], &elemPtr) != TCL_OK) {
  354.           return TCL_ERROR;    /* Can't find named element */
  355.           }
  356. !         if (elemPtr->hidden) {
  357.           Tcl_AppendResult(interp, "element \"", argv[i], "\" is hidden",
  358. !             (char *)NULL);
  359.           return TCL_ERROR;    /* Element isn't visible */
  360.           }
  361.           /* Check if the X or Y vectors have notifications pending */
  362. --- 1706,1728 ----
  363.       search.dist = (double)(search.halo + 1);
  364.   
  365.       if (i < argc) {
  366. +     Blt_ChainLink *linkPtr;
  367. + 
  368.       for ( /* empty */ ; i < argc; i++) {
  369.           if (NameToElement(graphPtr, argv[i], &elemPtr) != TCL_OK) {
  370.           return TCL_ERROR;    /* Can't find named element */
  371.           }
  372. !         found = FALSE;
  373. !         for (linkPtr = Blt_ChainFirstLink(graphPtr->elements.displayList);
  374. !          linkPtr == NULL; linkPtr = Blt_ChainNextLink(linkPtr)) {
  375. !         if (elemPtr == Blt_ChainGetValue(linkPtr)) {
  376. !             found = TRUE;
  377. !             break;
  378. !         }
  379. !         }
  380. !         if ((!found) || (elemPtr->hidden)) {
  381.           Tcl_AppendResult(interp, "element \"", argv[i], "\" is hidden",
  382. !             (char *)NULL);
  383.           return TCL_ERROR;    /* Element isn't visible */
  384.           }
  385.           /* Check if the X or Y vectors have notifications pending */
  386. ***************
  387. *** 1744,1759 ****
  388.       for (linkPtr = Blt_ChainLastLink(graphPtr->elements.displayList);
  389.           linkPtr != NULL; linkPtr = Blt_ChainPrevLink(linkPtr)) {
  390.           elemPtr = Blt_ChainGetValue(linkPtr);
  391. - 
  392.           /* Check if the X or Y vectors have notifications pending */
  393. !         if ((elemPtr->flags & MAP_ITEM) ||
  394.           (Blt_VectorNotifyPending(elemPtr->x.clientId)) ||
  395.           (Blt_VectorNotifyPending(elemPtr->y.clientId))) {
  396.           continue;
  397.           }
  398. !         if (!elemPtr->hidden) {
  399. !         (*elemPtr->procsPtr->closestProc) (graphPtr, elemPtr, &search);
  400. !         }
  401.       }
  402.   
  403.       }
  404. --- 1745,1758 ----
  405.       for (linkPtr = Blt_ChainLastLink(graphPtr->elements.displayList);
  406.           linkPtr != NULL; linkPtr = Blt_ChainPrevLink(linkPtr)) {
  407.           elemPtr = Blt_ChainGetValue(linkPtr);
  408.           /* Check if the X or Y vectors have notifications pending */
  409. !         if ((elemPtr->hidden) || 
  410. !         (elemPtr->flags & MAP_ITEM) ||
  411.           (Blt_VectorNotifyPending(elemPtr->x.clientId)) ||
  412.           (Blt_VectorNotifyPending(elemPtr->y.clientId))) {
  413.           continue;
  414.           }
  415. !         (*elemPtr->procsPtr->closestProc)(graphPtr, elemPtr, &search);
  416.       }
  417.   
  418.       }
  419. ***************
  420. *** 1859,1888 ****
  421.           return TCL_ERROR;    /* Failed to configure element */
  422.       }
  423.       if (Blt_ConfigModified(elemPtr->specsPtr, "-hide", (char *)NULL)) {
  424. -         Blt_ChainLink *linkPtr;
  425. - 
  426. -         for (linkPtr = Blt_ChainFirstLink(graphPtr->elements.displayList);
  427. -         linkPtr != NULL; linkPtr = Blt_ChainNextLink(linkPtr)) {
  428. -         if (elemPtr == Blt_ChainGetValue(linkPtr)) {
  429. -             break;
  430. -         }
  431. -         }
  432. -         if ((elemPtr->hidden) != (linkPtr == NULL)) {
  433. - 
  434. -         /* The element's "hidden" variable is out of sync with
  435. -          * the display list. [That's what you get for having
  436. -          * two ways to do the same thing.]  This affects what
  437. -          * elements are considered for axis ranges and
  438. -          * displayed in the legend. Update the display list by
  439. -          * either by adding or removing the element.  */
  440. - 
  441. -         if (linkPtr == NULL) {
  442. -             Blt_ChainPrepend(graphPtr->elements.displayList, elemPtr);
  443. -         } else {
  444. -             Blt_ChainDeleteLink(graphPtr->elements.displayList, 
  445. -                     linkPtr);
  446. -         }
  447. -         }
  448.           graphPtr->flags |= RESET_AXES;
  449.           elemPtr->flags |= MAP_ITEM;
  450.       }
  451. --- 1858,1863 ----
  452. diff -cr blt2.4z-old/src/bltInit.c blt2.4z/src/bltInit.c
  453. *** blt2.4z-old/src/bltInit.c    2002-09-10 00:12:33.000000000 -0500
  454. --- blt2.4z/src/bltInit.c    2002-12-02 22:25:33.000000000 -0600
  455. ***************
  456. *** 38,54 ****
  457.   #endif
  458.   #endif
  459.   
  460.   double bltNaN;
  461.   #if (TCL_MAJOR_VERSION > 7)
  462.   Tcl_Obj *bltEmptyStringObjPtr;
  463.   #endif
  464.   
  465.   static Tcl_MathProc MinMathProc, MaxMathProc;
  466. - static int tclLoaded = FALSE;
  467. - #ifndef TCL_ONLY
  468. - static int tkLoaded = FALSE;
  469. - #endif
  470. - 
  471.   static char libPath[1024] =
  472.   {
  473.       BLT_LIBRARY
  474. --- 38,53 ----
  475.   #endif
  476.   #endif
  477.   
  478. + #define BLT_THREAD_KEY        "BLT Initialized"
  479. + #define BLT_TCL_CMDS        (1<<0)
  480. + #define BLT_TK_CMDS        (1<<1)
  481. + 
  482.   double bltNaN;
  483.   #if (TCL_MAJOR_VERSION > 7)
  484.   Tcl_Obj *bltEmptyStringObjPtr;
  485.   #endif
  486.   
  487.   static Tcl_MathProc MinMathProc, MaxMathProc;
  488.   static char libPath[1024] =
  489.   {
  490.       BLT_LIBRARY
  491. ***************
  492. *** 404,410 ****
  493.   Blt_Init(interp)
  494.       Tcl_Interp *interp;        /* Interpreter to add extra commands */
  495.   {
  496. !     if (!tclLoaded) {
  497.       register Tcl_AppInitProc **p;
  498.       Tcl_Namespace *nsPtr;
  499.       Tcl_ValueType args[2];
  500. --- 403,412 ----
  501.   Blt_Init(interp)
  502.       Tcl_Interp *interp;        /* Interpreter to add extra commands */
  503.   {
  504. !     int flags;
  505. ! 
  506. !     flags = (int)Tcl_GetAssocData(interp, BLT_THREAD_KEY, NULL);
  507. !     if ((flags & BLT_TCL_CMDS) == 0) {
  508.       register Tcl_AppInitProc **p;
  509.       Tcl_Namespace *nsPtr;
  510.       Tcl_ValueType args[2];
  511. ***************
  512. *** 451,460 ****
  513.       if (Tcl_PkgProvide(interp, "BLT", BLT_VERSION) != TCL_OK) {
  514.           return TCL_ERROR;
  515.       }
  516. !     tclLoaded = TRUE;
  517.       }
  518.   #ifndef TCL_ONLY
  519. !     if (!tkLoaded) {
  520.       register Tcl_AppInitProc **p;
  521.       Tcl_Namespace *nsPtr;
  522.   
  523. --- 453,463 ----
  524.       if (Tcl_PkgProvide(interp, "BLT", BLT_VERSION) != TCL_OK) {
  525.           return TCL_ERROR;
  526.       }
  527. !     Tcl_SetAssocData(interp, BLT_THREAD_KEY, NULL, 
  528. !         (ClientData)(flags | BLT_TCL_CMDS));
  529.       }
  530.   #ifndef TCL_ONLY
  531. !     if ((flags & BLT_TK_CMDS) == 0) {
  532.       register Tcl_AppInitProc **p;
  533.       Tcl_Namespace *nsPtr;
  534.   
  535. ***************
  536. *** 486,492 ****
  537.           }
  538.       }
  539.       Blt_InitEpsCanvasItem(interp);
  540. !     tkLoaded = TRUE;
  541.       }
  542.   #endif
  543.       return TCL_OK;
  544. --- 489,496 ----
  545.           }
  546.       }
  547.       Blt_InitEpsCanvasItem(interp);
  548. !     Tcl_SetAssocData(interp, BLT_THREAD_KEY, NULL, 
  549. !         (ClientData)(flags | BLT_TK_CMDS));
  550.       }
  551.   #endif
  552.       return TCL_OK;
  553. ***************
  554. *** 499,505 ****
  555.   Blt_Init(interp)
  556.       Tcl_Interp *interp;        /* Interpreter to add extra commands */
  557.   {
  558. !     if (!tclLoaded) {
  559.       register Tcl_AppInitProc **p;
  560.       Tcl_ValueType args[2];
  561.   
  562. --- 503,512 ----
  563.   Blt_Init(interp)
  564.       Tcl_Interp *interp;        /* Interpreter to add extra commands */
  565.   {
  566. !     int flags;
  567. ! 
  568. !     flags = (int)Tcl_GetAssocData(interp, BLT_THREAD_KEY, NULL);
  569. !     if ((flags & BLT_TCL_CMDS) == 0) {
  570.       register Tcl_AppInitProc **p;
  571.       Tcl_ValueType args[2];
  572.   
  573. ***************
  574. *** 537,546 ****
  575.       if (Tcl_PkgProvide(interp, "BLT", BLT_VERSION) != TCL_OK) {
  576.           return TCL_ERROR;
  577.       }
  578. !     tclLoaded = TRUE;
  579.       }
  580.   #ifndef TCL_ONLY
  581. !     if (!tkLoaded) {
  582.       register Tcl_AppInitProc **p;
  583.   
  584.   #if (TCL_VERSION_NUMBER >= _VERSION(8,1,0)) 
  585. --- 544,554 ----
  586.       if (Tcl_PkgProvide(interp, "BLT", BLT_VERSION) != TCL_OK) {
  587.           return TCL_ERROR;
  588.       }
  589. !     Tcl_SetAssocData(interp, BLT_THREAD_KEY, NULL, 
  590. !         (ClientData)(flags | BLT_TCL_CMDS));
  591.       }
  592.   #ifndef TCL_ONLY
  593. !     if ((flags & BLT_TK_CMDS) == 0) {
  594.       register Tcl_AppInitProc **p;
  595.   
  596.   #if (TCL_VERSION_NUMBER >= _VERSION(8,1,0)) 
  597. ***************
  598. *** 560,566 ****
  599.           }
  600.       }
  601.       Blt_InitEpsCanvasItem(interp);
  602. !     tkLoaded = TRUE;
  603.       }
  604.   #endif
  605.       return TCL_OK;
  606. --- 568,575 ----
  607.           }
  608.       }
  609.       Blt_InitEpsCanvasItem(interp);
  610. !     Tcl_SetAssocData(interp, BLT_THREAD_KEY, NULL, 
  611. !         (ClientData)(flags | BLT_TK_CMDS));
  612.       }
  613.   #endif
  614.       return TCL_OK;
  615.  
  616.  
  617.