home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WWTCLKit / WWSliderCell.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  26.2 KB  |  899 lines
  1.  
  2. #import "WWSlider.h"
  3. #import "WWSliderCell.h"
  4. #import "WWTCLInterp.h"
  5. #import <dpsclient/psops.h>
  6.  
  7. #import "avoidStupidWarnings.h"
  8.  
  9. @implementation WWSliderCell
  10.  
  11.  
  12. + initialize { [WWSliderCell setVersion:5]; return self; }
  13. ////////////////////////////////////////////////////////
  14. //
  15. - init
  16. {
  17.   [super init];
  18.   controlStringSize = 32;
  19.   controlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  20.   sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  21.   tclExpressionSize = 32;
  22.   tclExpression = (char *)NXZoneCalloc([self zone], tclExpressionSize, sizeof(char));
  23.   tclVarSize = 32;
  24.   tclVar = (char *)NXZoneCalloc([self zone], tclVarSize, sizeof(char));
  25.   tclCommandSize = 32;
  26.   tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  27.   autoSendP = YES;
  28.   interp = nil;
  29.   usingPrivateImage = NO;
  30.   color = NXConvertGrayToColor(.5);
  31.   tclCommandDirty = YES;
  32.  
  33.   return self;
  34. }
  35. //
  36. - awake
  37. {
  38.   [super awake];
  39.   usingPrivateImage = NO;
  40.   tclCommandDirty = YES;
  41.  
  42.   return self;
  43. }
  44.  
  45. - free
  46. {
  47.   if (controlString) { NXZoneFree([self zone], controlString); }
  48.   if (sprintfControlString) { NXZoneFree([self zone], sprintfControlString); }
  49.   if (tclExpression) { NXZoneFree([self zone], tclExpression); }
  50.   if (tclVar) { NXZoneFree([self zone], tclVar); }
  51.   if (tclCommand) { NXZoneFree([self zone], tclCommand); }
  52.   return [super free];
  53. }
  54.  
  55. //
  56. - awakeFromNib
  57. {
  58.   [minText setFloatValue:[self minValue]];
  59.   [maxText setFloatValue:[self maxValue]];
  60.   [valText setFloatValue:[self floatValue]];
  61.   return self;
  62. }
  63. //
  64. - setMinValue:(double)aDouble
  65. {
  66.    [minText setFloatValue:aDouble];
  67.    return [super setMinValue:aDouble];
  68. }
  69. //
  70. - setMaxValue:(double)aDouble
  71. {
  72.    [maxText setFloatValue:aDouble];
  73.    return [super setMaxValue:aDouble];
  74. }
  75.  
  76. //
  77. - setAutoSendP:(BOOL)newFlag  {  autoSendP = newFlag; return self; }
  78. - (BOOL)autoSendP { return autoSendP; }
  79.  
  80. - setStringValue:(const char *)str
  81. {
  82.   char  *theStr;
  83.  
  84.   [super setStringValue:str];
  85.  
  86.   // why am I doing this?  cause I did it in WWThumbWheel, but I don't
  87.   // remember why...
  88.   // I think maybe that if it's zero, it make the string value NULL, not "0"
  89.   [super setFloatValue:(float)atof(str)];
  90.  
  91.   theStr = (char *)[self stringValue];
  92.   [minText setStringValue:theStr];
  93.   [maxText setStringValue:theStr];
  94.   [valText setStringValue:theStr];
  95.   tclCommandDirty = YES;
  96.   return self;
  97. }
  98.  
  99. - setIntValue:(int)val
  100. {
  101.   int   theVal;
  102.  
  103.  
  104.   [super setIntValue:val];
  105.   theVal = [self intValue];
  106.   [minText setIntValue:theVal];
  107.   [maxText setIntValue:theVal];
  108.   [valText setIntValue:theVal];
  109.   tclCommandDirty = YES;
  110.   return self;
  111. }
  112.  
  113. - setFloatValue:(float)val
  114. {
  115.   float  theVal;
  116.  
  117.  
  118.   [super setFloatValue:val];
  119.   theVal = [self floatValue];
  120.   [minText setFloatValue:theVal];
  121.   [maxText setFloatValue:theVal];
  122.   [valText setFloatValue:theVal];
  123.   tclCommandDirty = YES;
  124.   return self;
  125. }
  126.  
  127. - setDoubleValue:(double)val
  128. {
  129.   double  theVal;
  130.  
  131.  
  132.   [super setDoubleValue:val];
  133.   theVal = [self doubleValue];
  134.   [minText setDoubleValue:theVal];
  135.   [maxText setDoubleValue:theVal];
  136.   [valText setDoubleValue:theVal];
  137.   tclCommandDirty = YES;
  138.   return self;
  139. }
  140.  
  141. - reinitializeControlStringAndTclVarFromZone:(NXZone *)zone
  142. {
  143.   controlString = (char *)NXZoneCalloc(zone, controlStringSize, sizeof(char));
  144.   sprintfControlString = (char *)NXZoneCalloc(zone, controlStringSize, sizeof(char));
  145.   tclExpression = (char *)NXZoneCalloc(zone, tclExpressionSize, sizeof(char));
  146.   tclVar = (char *)NXZoneCalloc(zone, tclVarSize, sizeof(char));
  147.   tclCommand = (char *)NXZoneCalloc(zone, tclCommandSize, sizeof(char));
  148.   return self;
  149. }
  150.  
  151. - copyFromZone:(NXZone *)zone
  152. {
  153.   id newCopy = [super copyFromZone:zone];
  154.  
  155.  
  156.   [newCopy reinitializeControlStringAndTclVarFromZone:zone];
  157.   [newCopy setControlString:controlString];
  158.   [newCopy setTclExpression:tclExpression];
  159.   [newCopy setTclVar:tclVar];
  160.   [newCopy setTclCommand:tclCommand];
  161.   [newCopy setColor:color];
  162.  
  163.   return newCopy;
  164. }
  165.  
  166. - setInterp:newInterp {  interp = newInterp; return self; }
  167. - interp { return interp; }
  168.  
  169. - resizeTclCommandForArgVector:(char *)argOrderVector
  170. {
  171.   BOOL    done = NO;
  172.  
  173.   // there has got to be a better, less pathological way of doing this...
  174.  
  175.   if (!done && !strcmp("d", argOrderVector))
  176.   {  while (tclCommandSize < (controlStringSize + 32))
  177.      {  if (!tclCommandSize)
  178.     {  tclCommandSize = 32;
  179.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  180.         }
  181.         else
  182.         {  tclCommandSize *= 2;
  183.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  184.         }
  185.      }
  186.      done = YES;
  187.   }
  188.   if (!done && (!strcmp("Td", argOrderVector) || !strcmp("dT", argOrderVector)))
  189.   {  while (tclCommandSize < (controlStringSize + (2 * 32)))
  190.      {  if (!tclCommandSize)
  191.     {  tclCommandSize = 32;
  192.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  193.         }
  194.         else
  195.         {  tclCommandSize *= 2;
  196.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  197.         }
  198.      }
  199.      done = YES;
  200.   }
  201.   if (!done && !strcmp("T", argOrderVector))
  202.   {  while (tclCommandSize < (controlStringSize + 32))
  203.      {  if (!tclCommandSize)
  204.     {  tclCommandSize = 32;
  205.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  206.         }
  207.         else
  208.         {  tclCommandSize *= 2;
  209.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  210.         }
  211.      }
  212.      done = YES;
  213.   }
  214.   if (!done && !strcmp("f", argOrderVector))
  215.   {  while (tclCommandSize < (controlStringSize + 32) )
  216.      {  if (!tclCommandSize)
  217.     {  tclCommandSize = 32;
  218.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  219.         }
  220.         else
  221.         {  tclCommandSize *= 2;
  222.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  223.         }
  224.      }
  225.      done = YES;
  226.   }
  227.   if (!done && (!strcmp("Tf", argOrderVector) || !strcmp("fT", argOrderVector)))
  228.   {  while (tclCommandSize < (controlStringSize + (2 * 32)))
  229.      {  if (!tclCommandSize)
  230.     {  tclCommandSize = 32;
  231.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  232.         }
  233.         else
  234.         {  tclCommandSize *= 2;
  235.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  236.         }
  237.      }
  238.      done = YES;
  239.   }
  240.   if (!done && !strcmp("fff", argOrderVector))
  241.   {  while (tclCommandSize  < (controlStringSize + (2 + (3 * 32))))
  242.      {  if (!tclCommandSize)
  243.     {  tclCommandSize = 32;
  244.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  245.         }
  246.         else
  247.         {  tclCommandSize *= 2;
  248.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  249.         }
  250.      }
  251.      done = YES;
  252.   }
  253.  
  254.   if (!done && !strcmp("RGB", argOrderVector))
  255.   {  while (tclCommandSize  < (controlStringSize + (2 + (3 * 32))))
  256.      {  if (!tclCommandSize)
  257.     {  tclCommandSize = 32;
  258.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  259.         }
  260.         else
  261.         {  tclCommandSize *= 2;
  262.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  263.         }
  264.      }
  265.      done = YES;
  266.   }
  267.   if (!done && (!strcmp("RGBf", argOrderVector) || !strcmp("fRGB", argOrderVector) || !strcmp("dRGB", argOrderVector) || !strcmp("RGBd", argOrderVector)))
  268.   {  while (tclCommandSize  < (controlStringSize + (2 + (4 * 32))))
  269.      {  if (!tclCommandSize)
  270.     {  tclCommandSize = 32;
  271.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  272.         }
  273.         else
  274.         {  tclCommandSize *= 2;
  275.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  276.         }
  277.      }
  278.      done = YES;
  279.   }
  280.  
  281.   if (!done && !strcmp("s", argOrderVector))
  282.   {  const char  *str = [self stringValue]; 
  283.      int   strLen = strlen(str);
  284.  
  285.      while (tclCommandSize < (controlStringSize + strLen))
  286.      {  if (!tclCommandSize)
  287.     {  tclCommandSize = 32;
  288.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  289.         }
  290.         else
  291.         {  tclCommandSize *= 2;
  292.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  293.         }
  294.      }
  295.      done = YES;
  296.   }
  297.   if (!done && (!strcmp("sT", argOrderVector) || !strcmp("Ts", argOrderVector)))
  298.   {  const char  *str = [self stringValue]; 
  299.      int   strLen = strlen(str);
  300.  
  301.      while (tclCommandSize < (controlStringSize + (strLen + 32)))
  302.      {  if (!tclCommandSize)
  303.     {  tclCommandSize = 32;
  304.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  305.         }
  306.         else
  307.         {  tclCommandSize *= 2;
  308.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  309.         }
  310.      }
  311.      done = YES;
  312.   }
  313.   // those were the easy ones; now for the permutations...
  314.  
  315.   return self;
  316. }
  317.  
  318.  
  319. - updateTclCommand
  320. {
  321.   char    *controlStringPtr, *sprintfControlStringPtr;
  322.   BOOL    done;
  323.   int     argOrderSize = 32;
  324.   char    *argOrderVector = (char *)NXZoneCalloc([self zone], argOrderSize, sizeof(char));
  325.   int     argOrderOffset = 0;
  326.  
  327.  
  328.   if (!controlString)
  329.   {  return nil;
  330.   }
  331.  
  332.   // we want to grovel over the controlString, 
  333.   // for right now, we really only tend to have the following patterns 
  334.   // in the controlString: 1 %f, 1 %d, 1 %s, %R, %G, %B, 1 %T
  335.   controlStringPtr = controlString;
  336.   sprintfControlStringPtr = sprintfControlString;
  337.   strcpy(sprintfControlString, controlString);
  338.   while (*controlStringPtr)
  339.   {  if (*controlStringPtr == '%')
  340.      {  sprintfControlStringPtr++;  controlStringPtr++;
  341.         if (*controlStringPtr)
  342.         {  switch (*controlStringPtr)
  343.            {  case 'd':    while (argOrderOffset >= argOrderSize)
  344.                         {  argOrderSize *= 2;
  345.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  346.                         }
  347.                         argOrderVector[argOrderOffset++] = 'd';
  348.                         sprintfControlStringPtr++; controlStringPtr++;
  349.             break;
  350.               case 'T':    while (argOrderOffset >= argOrderSize)
  351.                         {  argOrderSize *= 2;
  352.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  353.                         }
  354.                         argOrderVector[argOrderOffset++] = 'T';
  355.                         *sprintfControlStringPtr++ = 'd'; controlStringPtr++;
  356.             break;
  357.               case 'f':    while (argOrderOffset >= argOrderSize)
  358.                         {  argOrderSize *= 2;
  359.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  360.                         }
  361.                         argOrderVector[argOrderOffset++] = 'f';
  362.                         sprintfControlStringPtr++; controlStringPtr++;
  363.             break;
  364.               case 's':    while (argOrderOffset >= argOrderSize)
  365.                         {  argOrderSize *= 2;
  366.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  367.                         }
  368.                         argOrderVector[argOrderOffset++] = 's';
  369.                         sprintfControlStringPtr++; controlStringPtr++;
  370.             break;
  371.               case 'R':    while (argOrderOffset >= argOrderSize)
  372.                         {  argOrderSize *= 2;
  373.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  374.                         }
  375.                         argOrderVector[argOrderOffset++] = 'R';
  376.                         *sprintfControlStringPtr++ = 'f'; controlStringPtr++;
  377.                         break;
  378.               case 'G':    while (argOrderOffset >= argOrderSize)
  379.                         {  argOrderSize *= 2;
  380.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  381.                         }
  382.                         argOrderVector[argOrderOffset++] = 'G';
  383.                         *sprintfControlStringPtr++ = 'f'; controlStringPtr++;
  384.                         break;
  385.               case 'B':    while (argOrderOffset >= argOrderSize)
  386.                         {  argOrderSize *= 2;
  387.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  388.                         }
  389.                         argOrderVector[argOrderOffset++] = 'B'; *sprintfControlStringPtr++ = 'f';
  390.                         controlStringPtr++;
  391.                         break;
  392.               case '%':    sprintfControlStringPtr++; controlStringPtr++;
  393.                         break;
  394.                default:    NXLogError("WWSliderCell: unknown specifier <%c> in controlString.\n", *controlStringPtr);
  395.                         sprintfControlStringPtr++; controlStringPtr++;
  396.             break;
  397.            }
  398.        }
  399.      }
  400.      else
  401.      {  sprintfControlStringPtr++;  controlStringPtr++;
  402.      }
  403.   }
  404.   argOrderVector[argOrderOffset] = 0;
  405.  
  406.   done = NO;
  407.  
  408.   if (!done && !strcmp("d", argOrderVector))
  409.   {  [self resizeTclCommandForArgVector:argOrderVector];
  410.      sprintf(tclCommand, sprintfControlString, [self intValue]);
  411.      done = YES;
  412.   }
  413.   if (!done && !strcmp("f", argOrderVector))
  414.   {  [self resizeTclCommandForArgVector:argOrderVector];
  415.      sprintf(tclCommand, sprintfControlString, [self floatValue]);
  416.      done = YES;
  417.   }
  418.   if (!done && !strcmp("s", argOrderVector))
  419.   {  [self resizeTclCommandForArgVector:argOrderVector];
  420.      sprintf(tclCommand, sprintfControlString, [self stringValue]);
  421.      done = YES;
  422.   }
  423.   if (!done && !strcmp("T", argOrderVector))
  424.   {  [self resizeTclCommandForArgVector:argOrderVector];
  425.      sprintf(tclCommand, sprintfControlString, [self tag]);
  426.      done = YES;
  427.   }
  428.   if (!done && !strcmp("dT", argOrderVector))
  429.   {  [self resizeTclCommandForArgVector:argOrderVector];
  430.      sprintf(tclCommand, sprintfControlString, [self intValue], [self tag]);
  431.      done = YES;
  432.   }
  433.   if (!done && !strcmp("fT", argOrderVector))
  434.   {  [self resizeTclCommandForArgVector:argOrderVector];
  435.      sprintf(tclCommand, sprintfControlString, [self floatValue], [self tag]);
  436.      done = YES;
  437.   }
  438.   if (!done && !strcmp("sT", argOrderVector))
  439.   {  [self resizeTclCommandForArgVector:argOrderVector];
  440.      sprintf(tclCommand, sprintfControlString, [self stringValue], [self tag]);
  441.      done = YES;
  442.   }
  443.   if (!done && !strcmp("Td", argOrderVector))
  444.   {  [self resizeTclCommandForArgVector:argOrderVector];
  445.      sprintf(tclCommand, sprintfControlString, [self tag], [self intValue]);
  446.      done = YES;
  447.   }
  448.   if (!done && !strcmp("Tf", argOrderVector))
  449.   {  [self resizeTclCommandForArgVector:argOrderVector];
  450.      sprintf(tclCommand, sprintfControlString, [self tag], [self floatValue]);
  451.      done = YES;
  452.   }
  453.   if (!done && !strcmp("Ts", argOrderVector))
  454.   {  [self resizeTclCommandForArgVector:argOrderVector];
  455.      sprintf(tclCommand, sprintfControlString, [self tag], [self stringValue]);
  456.      done = YES;
  457.   }
  458.   // for back compatibility
  459.   if (!done && !strcmp("fff", argOrderVector))
  460.   {  [self resizeTclCommandForArgVector:argOrderVector];
  461.      sprintf(tclCommand, sprintfControlString, NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color));
  462.      done = YES;
  463.   }
  464.   if (!done && !strcmp("RGB", argOrderVector))
  465.   {  [self resizeTclCommandForArgVector:argOrderVector];
  466.      sprintf(tclCommand, sprintfControlString, NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color));
  467.      done = YES;
  468.   }
  469.   if (!done && !strcmp("fRGB", argOrderVector))
  470.   {  [self resizeTclCommandForArgVector:argOrderVector];
  471.      sprintf(tclCommand, sprintfControlString, [self floatValue], NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color));
  472.      done = YES;
  473.   }
  474.   if (!done && !strcmp("RGBf", argOrderVector))
  475.   {  [self resizeTclCommandForArgVector:argOrderVector];
  476.      sprintf(tclCommand, sprintfControlString, NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color), [self floatValue]);
  477.      done = YES;
  478.   }
  479.   if (!done && !strcmp("dRGB", argOrderVector))
  480.   {  [self resizeTclCommandForArgVector:argOrderVector];
  481.      sprintf(tclCommand, sprintfControlString, [self intValue], NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color));
  482.      done = YES;
  483.   }
  484.   if (!done && !strcmp("RGBd", argOrderVector))
  485.   {  [self resizeTclCommandForArgVector:argOrderVector];
  486.      sprintf(tclCommand, sprintfControlString, NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color), [self intValue]);
  487.      done = YES;
  488.   }
  489.  
  490.   if (!done)
  491.   {  while (tclCommandSize < controlStringSize)
  492.      {  if (!tclCommandSize)
  493.     {  tclCommandSize = 32;
  494.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  495.         }
  496.         else
  497.         {  tclCommandSize *= 2;
  498.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  499.         }
  500.      }
  501.      strcpy(tclCommand, controlString);
  502.   }
  503.   tclCommandDirty = NO;
  504.  
  505.   NXZoneFree([self zone], argOrderVector);
  506.  
  507.   return self;
  508. }
  509.  
  510.  
  511. - evaluateSelf
  512. {
  513.    int   ret;
  514.    char  *newStringValue;
  515.    id    retID;
  516.  
  517.  
  518.   newStringValue = [interp globalEval:tclExpression :&ret];
  519.   if ((ret == TCL_OK) || (ret == TCL_RETURN))
  520.   {  //if (ret == TCL_RETURN)
  521.      //{  NXLogError("got TCL_RETURN for <%s>\n", newStringValue);
  522.      //}
  523.      [self setStringValue:newStringValue];
  524.      retID = self;
  525.   }
  526.   else
  527.   {  NXLogError("WWSliderCell: error <%s> evaluating tcl expression <%s>\n", 
  528.         newStringValue, tclExpression);
  529.      if (newStringValue) { free(newStringValue); }
  530.      retID = nil;
  531.   }
  532.   return retID;
  533. }
  534.  
  535.  
  536. - updateInterp
  537. {
  538.   if ([interp eval:[self tclCommand]])
  539.   {  return self;
  540.   }
  541.   return nil;
  542. }
  543.  
  544.  
  545. - setControlString:(const char *)str 
  546. { 
  547.   int   cnt;
  548.  
  549.  
  550.   if (!str) { return self; }
  551.   if (controlStringSize <= 0) 
  552.   {  controlStringSize = 32; 
  553.      controlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  554.   }
  555.   cnt = strlen(str);
  556.   while (cnt >= controlStringSize)
  557.   {  controlStringSize *= 2;
  558.      controlString = (char *)NXZoneRealloc([self zone], controlString, controlStringSize);
  559.   }
  560.   if (sprintfControlString)
  561.   {  sprintfControlString = (char *)NXZoneRealloc([self zone], sprintfControlString, controlStringSize);
  562.   }
  563.   else
  564.   {  sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  565.   }
  566.   strcpy(controlString, str); 
  567.   tclCommandDirty = YES;
  568.   return self; 
  569. }
  570. //
  571. - (const char *)controlString { return controlString; }
  572.  
  573. - setTclExpression:(const char *)str 
  574. { 
  575.   int   cnt;
  576.  
  577.  
  578.   if (!str) { return self; }
  579.   if (tclExpressionSize <= 0) 
  580.   {  tclExpressionSize = 32; 
  581.      tclExpression = (char *)NXZoneCalloc([self zone], tclExpressionSize, sizeof(char));
  582.   }
  583.   cnt = strlen(str);
  584.   while (cnt >= tclExpressionSize)
  585.   {  tclExpressionSize *= 2;
  586.      tclExpression = (char *)NXZoneRealloc([self zone], tclExpression, tclExpressionSize);
  587.   }
  588.   strcpy(tclExpression, str); 
  589.   return self; 
  590. }
  591. //
  592. - (const char *)tclExpression { return tclExpression; }
  593.  
  594. - setTclVar:(const char *)str 
  595. { 
  596.   int   cnt;
  597.  
  598.  
  599.   if (!str) { return self; }
  600.   if (tclVarSize <= 0) 
  601.   {  tclVarSize = 32; 
  602.      tclVar = (char *)NXZoneCalloc([self zone], tclVarSize, sizeof(char));
  603.   }
  604.   cnt = strlen(str);
  605.   while (cnt >= tclVarSize)
  606.   {  tclVarSize *= 2;
  607.      tclVar = (char *)NXZoneRealloc([self zone], tclVar, tclVarSize);
  608.   }
  609.   strcpy(tclVar, str); 
  610.   return self; 
  611. }
  612. //
  613. - (const char *)tclVar { return tclVar; }
  614.  
  615. - setTclCommand:(const char *)str 
  616. { 
  617.   int   cnt;
  618.  
  619.  
  620.   if (!str) { return self; }
  621.   if (tclCommandSize <= 0) 
  622.   {  tclCommandSize = 32; 
  623.      tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  624.   }
  625.   cnt = strlen(str);
  626.   while (cnt >= tclCommandSize)
  627.   {  tclCommandSize *= 2;
  628.      tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  629.   }
  630.   strcpy(tclCommand, str); 
  631.   return self; 
  632. }
  633. //
  634. - (const char *)tclCommand 
  635. { 
  636.   if (tclCommandDirty)
  637.   {  [self updateTclCommand];
  638.   }
  639.   return tclCommand; 
  640. }
  641.  
  642. - setMinText:sender {  minText = sender; return self;}
  643. - setMaxText:sender {  maxText = sender; return self;}
  644. - setValText:sender {  valText = sender; return self;}
  645.  
  646.  
  647. #define NOTEQUAL(a,b) (ABS((a)-(b))>0.0001)
  648.  
  649. - drawSelf:(const NXRect *)theFrame inView:view
  650. {
  651.    NXSize   imageSize;
  652.    NXImage  *oldImage;
  653.  
  654.  
  655.    if (usingPrivateImage || colorChanged)
  656.    {  oldImage = [self image];
  657.       if (oldImage)
  658.       { [oldImage getSize:&imageSize];
  659.         if(NOTEQUAL(imageSize.width,NX_WIDTH(theFrame)) || NOTEQUAL(imageSize.height,NX_HEIGHT(theFrame)) || colorChanged)
  660.         {  [self generateImage:theFrame];
  661.         }
  662.       }
  663.       else
  664.       {  [self generateImage:theFrame];
  665.       }
  666.    }
  667.    return [super drawSelf:theFrame inView:view];
  668. }
  669.  
  670.  
  671. - setColor:(NXColor)newColor { color = newColor; colorChanged = YES; tclCommandDirty = YES; return self; }
  672. - (NXColor)color { return color; }
  673.  
  674. - generateImage:(const NXRect *)theFrame
  675. {
  676.   NXImage  *oldImage, *newImage;
  677.  
  678.  
  679.   oldImage = [self image];
  680.   if (oldImage && usingPrivateImage)
  681.   {  [oldImage free];
  682.   }
  683.   newImage = [[NXImage alloc] initSize:&(theFrame->size)];
  684.   usingPrivateImage = YES;
  685.   [newImage lockFocus];
  686.   NXSetColor(color);
  687.   PSrectfill(theFrame->origin.x, theFrame->origin.y, theFrame->size.width, theFrame->size.height);
  688.   [newImage unlockFocus];
  689.   [self setImage:newImage];
  690.   colorChanged = NO;
  691.  
  692.   return self;
  693. }
  694.  
  695. - write:(NXTypedStream *)stream 
  696. {
  697.    [super write:stream];
  698.    NXWriteType(stream, "*", &controlString);
  699.    NXWriteType(stream, "*", &tclVar);
  700.    NXWriteType(stream, "*", &tclExpression);
  701.    NXWriteType(stream, "*", &tclCommand);
  702.    NXWriteType(stream, "c", &autoSendP);
  703.    NXWriteObjectReference(stream, interp);
  704.    NXWriteColor(stream, color);
  705.    return self;
  706. }
  707. //
  708. - read:(NXTypedStream *)stream 
  709. {
  710.    int version;
  711.  
  712.    [super read:stream];
  713.  
  714.    version = NXTypedStreamClassVersion(stream, "WWSliderCell");
  715.    if (version == 1)
  716.    {  NXReadType(stream, "*", &controlString);
  717.       if (controlString) 
  718.       {  controlStringSize = strlen(controlString) + 1;
  719.          sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  720.       }
  721.       else
  722.       {  controlStringSize = 0;
  723.          sprintfControlString = NULL;
  724.       }
  725.       NXReadType(stream, "*", &tclVar);
  726.       if (tclVar) 
  727.       {  tclVarSize = strlen(tclVar) + 1;
  728.       }
  729.       else
  730.       { tclVarSize = 0;
  731.       }
  732.       autoSendP = YES;
  733.       interp = nil;
  734.       color = NX_COLORLTGRAY;
  735.       tclCommandSize = 0;
  736.       tclCommand = NULL;
  737.    }
  738.    if (version == 2)
  739.    {  NXReadType(stream, "*", &controlString);
  740.       if (controlString) 
  741.       {  controlStringSize = strlen(controlString) + 1;
  742.          sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  743.       }
  744.       else
  745.       {  controlStringSize = 0;
  746.          sprintfControlString = NULL;
  747.       }
  748.       NXReadType(stream, "*", &tclVar);
  749.       if (tclVar) 
  750.       {  tclVarSize = strlen(tclVar) + 1;
  751.       }
  752.       else
  753.       { tclVarSize = 0;
  754.       }
  755.       NXReadType(stream, "*", &tclExpression);
  756.       if (tclExpression) 
  757.       {  tclExpressionSize = strlen(tclExpression) + 1;
  758.       }
  759.       else
  760.       {  tclExpressionSize = 0;
  761.       }
  762.       tclCommandSize = 0;
  763.       tclCommand = NULL;
  764.       autoSendP = YES;
  765.       interp = nil;
  766.       color = NX_COLORLTGRAY;
  767.    }
  768.    if (version == 3)
  769.    {  NXReadType(stream, "*", &controlString);
  770.       if (controlString) 
  771.       {  controlStringSize = strlen(controlString) + 1;
  772.          sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  773.       }
  774.       else
  775.       {  controlStringSize = 0;
  776.          sprintfControlString = NULL;
  777.       }
  778.       NXReadType(stream, "*", &tclVar);
  779.       if (tclVar) 
  780.       {  tclVarSize = strlen(tclVar) + 1;
  781.       }
  782.       else
  783.       { tclVarSize = 0;
  784.       }
  785.       NXReadType(stream, "*", &tclExpression);
  786.       if (tclExpression) 
  787.       {  tclExpressionSize = strlen(tclExpression) + 1;
  788.       }
  789.       else
  790.       {  tclExpressionSize = 0;
  791.       }
  792.       NXReadType(stream, "*", &tclCommand);
  793.       if (tclCommand) 
  794.       {  tclCommandSize = strlen(tclCommand) + 1;
  795.       }
  796.       else
  797.       {  tclCommandSize = 0;
  798.       }
  799.       NXReadType(stream, "c", &autoSendP);
  800.       interp = NXReadObject(stream);
  801.       color = NX_COLORLTGRAY;
  802.    }
  803.    if (version == 4)
  804.    {  NXReadType(stream, "*", &controlString);
  805.       if (controlString) 
  806.       {  controlStringSize = strlen(controlString) + 1;
  807.       }
  808.       else
  809.       {  controlStringSize = 0;
  810.          sprintfControlString = NULL;
  811.       }
  812.       NXReadType(stream, "*", &tclVar);
  813.       if (tclVar) 
  814.       {  tclVarSize = strlen(tclVar) + 1;
  815.       }
  816.       else
  817.       { tclVarSize = 0;
  818.       }
  819.       NXReadType(stream, "*", &tclExpression);
  820.       if (tclExpression) 
  821.       {  tclExpressionSize = strlen(tclExpression) + 1;
  822.       }
  823.       else
  824.       {  tclExpressionSize = 0;
  825.       }
  826.       NXReadType(stream, "*", &tclCommand);
  827.       if (tclCommand) 
  828.       {  tclCommandSize = strlen(tclCommand) + 1;
  829.       }
  830.       else
  831.       {  tclCommandSize = 0;
  832.       }
  833.       NXReadType(stream, "c", &autoSendP);
  834.       interp = NXReadObject(stream);
  835.       color = NXReadColor(stream);
  836.       NXReadType(stream, "*", &sprintfControlString);
  837.       if (sprintfControlString) {  free(sprintfControlString); }
  838.       if (controlStringSize)
  839.       {  sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  840.       }
  841.       else
  842.       {  sprintfControlString = NULL;
  843.       }
  844.    }
  845.    if (version == 5)
  846.    {  NXReadType(stream, "*", &controlString);
  847.       if (controlString) 
  848.       {  controlStringSize = strlen(controlString) + 1;
  849.          sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  850.       }
  851.       else
  852.       {  controlStringSize = 0;
  853.          sprintfControlString = NULL;
  854.       }
  855.       NXReadType(stream, "*", &tclVar);
  856.       if (tclVar) 
  857.       {  tclVarSize = strlen(tclVar) + 1;
  858.       }
  859.       else
  860.       { tclVarSize = 0;
  861.       }
  862.       NXReadType(stream, "*", &tclExpression);
  863.       if (tclExpression) 
  864.       {  tclExpressionSize = strlen(tclExpression) + 1;
  865.       }
  866.       else
  867.       {  tclExpressionSize = 0;
  868.       }
  869.       NXReadType(stream, "*", &tclCommand);
  870.       if (tclCommand) 
  871.       {  tclCommandSize = strlen(tclCommand) + 1;
  872.       }
  873.       else
  874.       {  tclCommandSize = 0;
  875.       }
  876.       NXReadType(stream, "c", &autoSendP);
  877.       interp = NXReadObject(stream);
  878.       color = NXReadColor(stream);
  879.    }
  880.    return self;
  881. }
  882.  
  883. // IB stuff
  884. - (const char *)getInspectorClassName 
  885. {  
  886.    NXEvent  *event = [NXApp currentEvent];
  887.  
  888.    if (event->flags & NX_ALTERNATEMASK)
  889.    {  return [super getInspectorClassName];
  890.    }
  891.    
  892.    return "WWSliderCellIBInspector"; 
  893. }
  894.  
  895.  
  896.  
  897.  
  898. @end
  899.