home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WWTCLKit / WWButtonVar.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  17.3 KB  |  660 lines
  1.  
  2. #import "WWButtonVar.h"
  3. #import "WWButtonVarCell.h"
  4.  
  5. @implementation WWButtonVar
  6.  
  7. static id myStoredCellClass;
  8.  
  9.  
  10. + initialize 
  11. { 
  12.   [WWButtonVar setVersion:1]; 
  13.  
  14.   if (self == [WWButtonVar class])
  15.   {  myStoredCellClass = [WWButtonVarCell class];
  16.   }
  17.  
  18.   return self; 
  19. }
  20. //
  21. + setCellClass:classID
  22. {
  23.   myStoredCellClass = classID;
  24.   return self;
  25. }
  26. ////////////////////////////////////////////////////////
  27. - initFrame:(const NXRect *)frameRect icon:(const char *)aString tag:(int)anInt target:anObject action:(SEL)aSelector key:(unsigned short)charCode enabled:(BOOL)flag
  28. {
  29.   id  oldCell;
  30.    const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  31.  
  32.  
  33.   [super initFrame:frameRect icon:aString tag:anInt target:anObject action:aSelector key:charCode enabled:flag];
  34.   [self registerForDraggedTypes:dragTypes count:1];
  35.  
  36.   oldCell = [self setCell:[[WWButtonVarCell alloc] init]];
  37.   [oldCell free];
  38.   return self;
  39. }
  40. //
  41. - initFrame:(const NXRect *)frameRect title:(const char *)aString tag:(int)anInt target:anObject action:(SEL)aSelector key:(unsigned short)charCode enabled:(BOOL)flag
  42. {
  43.   id  oldCell;
  44.   const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  45.  
  46.  
  47.   [super initFrame:frameRect title:aString tag:anInt target:anObject action:aSelector key:charCode enabled:flag];
  48.   [self registerForDraggedTypes:dragTypes count:1];
  49.  
  50.   oldCell = [self setCell:[[myStoredCellClass alloc] init]];
  51.   [oldCell free];
  52.   return self;
  53. }
  54. //
  55. - init
  56. {
  57.   id  oldCell;
  58.   const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  59.  
  60.  
  61.   [super init];
  62.   [self registerForDraggedTypes:dragTypes count:1];
  63.  
  64.   oldCell = [self setCell:[[myStoredCellClass alloc] init]];
  65.   [oldCell free];
  66.   return self;
  67. }
  68.  
  69. - awake
  70. {
  71.    const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  72.  
  73.  
  74.    [super awake];
  75.    [self registerForDraggedTypes:dragTypes count:1];
  76.  
  77.    framed = NO;
  78.    cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  79.    
  80.    return self;
  81. }
  82.  
  83.  
  84. // need to be able to see the cell's tclVar...
  85. - setTclVar:(const char *)str { return [[self cell] setTclVar:str]; }
  86. - (const char *)tclVar { return [[self cell] tclVar]; }
  87.  
  88. // need to be able to see the cell's controlString...
  89. - setControlString:(const char *)str { return [[self cell] setControlString:str]; }
  90. - (const char *)controlString { return [[self cell] controlString]; }
  91.  
  92. // need to be able to see the cell's tclExpression...
  93. - setTclExpression:(const char *)str { return [[self cell] setTclExpression:str]; }
  94. - (const char *)tclExpression { return [[self cell] tclExpression]; }
  95.  
  96. // need to be able to see the cell's tclExpression...
  97. - setTclCommand:(const char *)str { return [[self cell] setTclCommand:str]; }
  98. - (const char *)tclCommand { return [[self cell] tclCommand]; }
  99.  
  100. - setInterp:newInterp {  return [[self cell] setInterp:newInterp]; }
  101. - evaluateSelf { return [[self cell] evaluateSelf]; }
  102.  
  103. - sendAction:(SEL)theAction to:theTarget
  104. {
  105.   if ([cell respondsTo:@selector(updateInterp)])
  106.   {  [cell updateInterp];
  107.   }
  108.  
  109.   return [super sendAction:theAction to:theTarget];
  110. }
  111.  
  112.  
  113.  
  114.  
  115. - initFrame:(const NXRect *)frameRect
  116. {
  117.    const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  118.  
  119.  
  120.    [super initFrame:frameRect];
  121.    [self registerForDraggedTypes:dragTypes count:1];
  122.  
  123.    tclVarNameSize = 32;
  124.    tclVarName = (char *)NXZoneCalloc([self zone], tclVarNameSize, sizeof(char));
  125.    tclVarValueSize = 32;
  126.    tclVarValue = (char *)NXZoneCalloc([self zone], tclVarValueSize, sizeof(char));
  127.    tclVarTypeSize = 32;
  128.    tclVarType = (char *)NXZoneCalloc([self zone], tclVarTypeSize, sizeof(char));
  129.    // <null pointer> is around 15 characters, so add (say) 40 bytes to cmdBuf...
  130.    cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  131.    framed = NO;
  132.    restrictDropToSameName = NO;
  133.    restrictDropToSameType = NO;
  134.    actAsSource = YES;
  135.    actAsSink = YES;
  136.    frameColor = NX_COLORBLACK;
  137.    frameWidth = 3.0;
  138.    nameSwitchView = nil;
  139.    valueSwitchView = nil;
  140.    typeSwitchView = nil;
  141.  
  142.    return self;
  143. }
  144.  
  145. - awake
  146. {
  147.    const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  148.  
  149.  
  150.    [super awake];
  151.    [self registerForDraggedTypes:dragTypes count:1];
  152.  
  153.    framed = NO;
  154.    cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  155.    
  156.    return self;
  157. }
  158.  
  159. - free
  160. {
  161.    const char *fileType[] = { "" };
  162.    Pasteboard *pboard = [Pasteboard newName:NXDragPboard];
  163.  
  164.  
  165.    [pboard declareTypes:fileType num:0 owner:nil];
  166.    [self unregisterDraggedTypes];
  167.    image = nil; // don't free the potentially shared image
  168.    if (tclVarName) { free(tclVarName); }
  169.    if (tclVarValue) { free(tclVarValue); }
  170.    if (tclVarType) { free(tclVarType); }
  171.    if (cmdBuf) { NXZoneFree([self zone], cmdBuf); }
  172.  
  173.    return [super free];
  174. }
  175.  
  176. - reinitializeStringsFromZone:(NXZone *)zone
  177. {
  178.   tclVarName = (char *)NXZoneCalloc(zone, tclVarNameSize, sizeof(char));
  179.   tclVarValue = (char *)NXZoneCalloc(zone, tclVarValueSize, sizeof(char));
  180.   tclVarType = (char *)NXZoneCalloc(zone, tclVarTypeSize, sizeof(char));
  181.   cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  182.   return self;
  183. }
  184.  
  185. - copyFromZone:(NXZone *)zone
  186. {
  187.   id newCopy = [super copyFromZone:zone];
  188.  
  189.   [newCopy reinitializeStringsFromZone:zone];
  190.   [newCopy setTclVarName:tclVarName];
  191.   [newCopy setTclVarValue:tclVarValue];
  192.   [newCopy setTclVarType:tclVarType];
  193.  
  194.   return newCopy;
  195. }
  196.  
  197. - drawSelf:(const NXRect *)rects :(int)num
  198. {
  199.   [super drawSelf:rects :num];
  200.   if (framed)
  201.   {  NXSetColor(frameColor);
  202.      NXFrameRectWithWidth(&bounds, (NXCoord)frameWidth);
  203.   }
  204.   return self;
  205. }
  206.  
  207. /*-------------------- methods to be the source of a dragging operation */
  208.  
  209. - mouseDown:(NXEvent *)theEvent
  210. {
  211.    NXPoint  zero = {0.0, 0.0};
  212.    id       thePboard;
  213.    const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  214.    static char *fooBarBaz = "fooBarBaz";
  215.  
  216.     
  217.    if (!image) { return self; }
  218.    if (!actAsSource) { return self; }
  219.  
  220.    // Prevent default window ordering (this is a new appkit feature)
  221.    [NXApp preventWindowOrdering];
  222.  
  223.    //get the Pboard
  224.    thePboard = [Pasteboard newName:NXDragPboard];
  225.    [thePboard declareTypes:dragTypes num:1 owner:nil];
  226.  
  227.    // we're not really going to use this info, we're just sticking something on the board...
  228.    [thePboard writeType:NXAsciiPboardType data:fooBarBaz length:(1 + strlen(fooBarBaz))];
  229.     
  230.    //start the drag
  231.    [self dragImage:image    // visible on screen during drag
  232.                 at:&zero    // offset the mouse point for the drag
  233.             offset:&zero    // offset the inital mouse pt
  234.              event:theEvent    // theEvent structure
  235.         pasteboard:thePboard    // a Pasteboard with data on it
  236.             source:self        // source object
  237.          slideBack:YES];    // if no destination animate back to source
  238.     
  239.     return self;
  240. }
  241.  
  242. - draggedImage:(NXImage *)image beganAt:(NXPoint *)screenPoint  { return self; }
  243.  
  244. - (NXDragOperation)draggingSourceOperationMaskForLocal:(BOOL)flag  { return (NX_DragOperationCopy | NX_DragOperationGeneric); }
  245.  
  246. - draggedImage:(NXImage *)image endedAt:(NXPoint *)screenPoint deposited:(BOOL)flag { return self; }
  247.  
  248. /*-------------------- methods to be the destination of a dragging operation */
  249.  
  250. - (NXDragOperation)draggingEntered:sender
  251. {
  252.    if (!actAsSink)
  253.    {  if (framed)
  254.       {  framed = NO;
  255.      [self display];
  256.       }
  257.       return NX_DragOperationNone;
  258.    }
  259.  
  260.    // check to make sure we are not the source and this operation is a copy
  261.    if (   ([sender draggingSourceOperationMask] & NX_DragOperationCopy) 
  262.        && ([sender draggingSource] != self)
  263.        && ([[sender draggingSource] respondsTo:@selector(tclVarValue)]))
  264.    {  
  265.       // if we're selective, need to check the var's name
  266.       // if it's not the same as ours, we're outta here
  267.       if (restrictDropToSameName)
  268.       {  if (tclVarName && [[sender draggingSource] tclVarName] && strcmp(tclVarName, [[sender draggingSource] tclVarName]))
  269.          {  if (framed)
  270.         {  framed = NO;
  271.            [self display];
  272.          }
  273.             return NX_DragOperationNone;
  274.      }
  275.       }
  276.       if (restrictDropToSameType)
  277.       {  if (tclVarType && [[sender draggingSource] tclVarType] && strcmp(tclVarType, [[sender draggingSource] tclVarType]))
  278.          {  if (framed)
  279.         {  framed = NO;
  280.            [self display];
  281.          }
  282.             return NX_DragOperationNone;
  283.      }
  284.       }
  285.       framed = YES;
  286.       [self display];
  287.       //return the type of operation we want to do, this will dictate
  288.       //the type of cursor will show up when accepting the drag
  289.       return NX_DragOperationCopy;
  290.    }
  291.    if (framed) 
  292.    {  framed = NO;
  293.       [self display];
  294.    }
  295.    return NX_DragOperationNone;
  296. }
  297.  
  298. - (NXDragOperation)draggingUpdated:sender
  299. {
  300.    if (!actAsSink)
  301.    {  if (framed)
  302.       {  framed = NO;
  303.      [self display];
  304.       }
  305.       return NX_DragOperationNone;
  306.    }
  307.  
  308.    // make sure that this is a copy operation, and that this instance
  309.    // of DragView is not the source
  310.    if (   ([sender draggingSourceOperationMask] & NX_DragOperationCopy) 
  311.        && ([sender draggingSource] != self)
  312.        && ([[sender draggingSource] respondsTo:@selector(tclVarValue)]))
  313.     { 
  314.       if (restrictDropToSameName)
  315.       {  if (tclVarName && [[sender draggingSource] tclVarName] && strcmp(tclVarName, [[sender draggingSource] tclVarName]))
  316.          {  if (framed)
  317.         {  framed = NO;
  318.            [self display];
  319.          }
  320.             return NX_DragOperationNone;
  321.      }
  322.       }
  323.       if (restrictDropToSameType)
  324.       {  if (tclVarType && [[sender draggingSource] tclVarType] && strcmp(tclVarType, [[sender draggingSource] tclVarType]))
  325.          {  if (framed)
  326.         {  framed = NO;
  327.            [self display];
  328.          }
  329.             return NX_DragOperationNone;
  330.      }
  331.       }
  332.       framed = YES;
  333.       [self display];
  334.       return NX_DragOperationCopy;
  335.    }
  336.    if (framed) 
  337.    {  framed = NO;
  338.       [self display];
  339.    }
  340.    return NX_DragOperationNone;
  341. }
  342.  
  343. - draggingExited:sender
  344. {
  345.    if (!actAsSink)
  346.    {  if (framed)
  347.       {  framed = NO;
  348.      [self display];
  349.       }
  350.       return NX_DragOperationNone;
  351.    }
  352.  
  353.    if (framed) 
  354.    {  framed = NO;
  355.       [self display];
  356.    }
  357.    return self;
  358. }
  359.  
  360. - (BOOL)prepareForDragOperation:sender  
  361. {  
  362.    if (!actAsSink)
  363.    {  if (framed)
  364.       {  framed = NO;
  365.      [self display];
  366.       }
  367.       return NO;
  368.    }
  369.    return YES; 
  370. }
  371.  
  372. static int notJustBlanks(const char *str)
  373. {
  374.   const char  *ptr;
  375.  
  376.  
  377.   ptr = str;
  378.   if (ptr)
  379.   {  while (*ptr && isspace(*ptr))
  380.      {  ptr++;
  381.      }
  382.      if (*ptr) // if we're not at the end and we stopped, it's not just blanks...
  383.      {  return 1;
  384.      }
  385.   }
  386.   return 0;
  387. }
  388.  
  389.  
  390. - (BOOL)performDragOperation:sender
  391. {
  392.    if (!actAsSink)
  393.    {  if (framed)
  394.       {  framed = NO;
  395.      [self display];
  396.       }
  397.       return NO;
  398.    }
  399.  
  400.    // make sure that what we are getting is from the same application
  401.    // and did not originate from this view.
  402.    if (   [sender isDraggingSourceLocal] 
  403.        && ([sender draggingSource] != self) 
  404.        && ([[sender draggingSource] respondsTo:@selector(tclVarValue)]))
  405.  
  406.    {  // should check to make sure the sender will respond appropriately...
  407.       if (restrictDropToSameName)
  408.       {  if (tclVarName && [[sender draggingSource] tclVarName] && strcmp(tclVarName, [[sender draggingSource] tclVarName]))
  409.          {  if (framed) 
  410.         {  framed = NO;
  411.            [self display];
  412.         }
  413.         return NO;
  414.      }
  415.       }
  416.       if (restrictDropToSameType)
  417.       {  if (tclVarType && [[sender draggingSource] tclVarType] && strcmp(tclVarType, [[sender draggingSource] tclVarType]))
  418.          {  if (framed) 
  419.             {  framed = NO;
  420.            [self display];
  421.         }
  422.         return NO;
  423.      }
  424.       }
  425.       [self setImage:nil];
  426.       [self setImage:[[sender draggingSource] image]];
  427.       [self setTclVarValue:[[sender draggingSource] tclVarValue]];
  428.       if (nameSwitchView)
  429.       {  [nameSwitchView showViewNamed:tclVarName];
  430.       }
  431.       if (typeSwitchView)
  432.       {  [typeSwitchView showViewNamed:tclVarType];
  433.       }
  434.       if (notJustBlanks(tclVarValue))
  435.       {  // cmdBuf is basically "set <tclVarName> <tclVarValue>"
  436.          if (valueSwitchView)
  437.          {  [valueSwitchView showViewNamed:tclVarValue];
  438.          }
  439.          sprintf(cmdBuf, "set %s %s", tclVarName, tclVarValue);
  440.          [interp globalEval:cmdBuf];
  441.       }
  442.       framed = NO;
  443.       [self display];
  444.    }
  445.    if (framed) 
  446.    {  framed = NO;
  447.       [self display];
  448.    }
  449.    return YES;
  450. }
  451.  
  452. - concludeDragOperation:sender {  return self; }
  453.  
  454. /*-------------------- methods to display, and other useful stuff */
  455.  
  456. - (BOOL)acceptsFirstMouse  {  return YES; }
  457.  
  458. - (BOOL)shouldDelayWindowOrderingForEvent:(NXEvent *)theEvent {  return YES; }
  459.  
  460. // set and get stuff
  461.  
  462. - setTclVarValue:(const char *)str 
  463. { 
  464.   int   cnt;
  465.  
  466.  
  467.   if (tclVarValueSize <= 0) 
  468.   {  tclVarValueSize = 32; 
  469.      tclVarValue = (char *)NXZoneCalloc([self zone], tclVarValueSize, sizeof(char));
  470.      cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  471.   }
  472.   cnt = strlen(str);
  473.   while (cnt >= tclVarValueSize)
  474.   {  tclVarValueSize *= 2;
  475.      tclVarValue = (char *)NXZoneRealloc([self zone], tclVarValue, tclVarValueSize);
  476.   }
  477.   cmdBuf = (char *)NXZoneRealloc([self zone], cmdBuf, (40 + tclVarNameSize + tclVarValueSize));
  478.   strcpy(tclVarValue, str); 
  479.   return self; 
  480. }
  481. //
  482. - (const char *)tclVarValue { return tclVarValue; }
  483.  
  484.  
  485. - setTclVarName:(const char *)str 
  486. { 
  487.   int   cnt;
  488.  
  489.  
  490.   if (tclVarNameSize <= 0) 
  491.   {  tclVarNameSize = 32; 
  492.      tclVarName = (char *)NXZoneCalloc([self zone], tclVarNameSize, sizeof(char));
  493.      cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  494.   }
  495.   cnt = strlen(str);
  496.   while (cnt >= tclVarNameSize)
  497.   {  tclVarNameSize *= 2;
  498.      tclVarName = (char *)NXZoneRealloc([self zone], tclVarName, tclVarNameSize);
  499.   }
  500.   cmdBuf = (char *)NXZoneRealloc([self zone], cmdBuf, (40 + tclVarNameSize + tclVarValueSize));
  501.   strcpy(tclVarName, str); 
  502.   return self; 
  503. }
  504. //
  505. - (const char *)tclVarName { return tclVarName; }
  506.  
  507. - setTclVarType:(const char *)str 
  508. { 
  509.   int   cnt;
  510.  
  511.  
  512.   if (tclVarTypeSize <= 0) 
  513.   {  tclVarTypeSize = 32; 
  514.      tclVarType = (char *)NXZoneCalloc([self zone], tclVarTypeSize, sizeof(char));
  515.   }
  516.   cnt = strlen(str);
  517.   while (cnt >= tclVarTypeSize)
  518.   {  tclVarTypeSize *= 2;
  519.      tclVarType = (char *)NXZoneRealloc([self zone], tclVarType, tclVarTypeSize);
  520.   }
  521.   strcpy(tclVarType, str); 
  522.   return self; 
  523. }
  524. //
  525. - (const char *)tclVarType { return tclVarType; }
  526.  
  527.  
  528. - (BOOL)restrictDropToSameName { return restrictDropToSameName; }
  529. - setRestrictDropToSameName:(BOOL)flag {  restrictDropToSameName = flag; return self; }
  530.  
  531. - (BOOL)restrictDropToSameType { return restrictDropToSameType; }
  532. - setRestrictDropToSameType:(BOOL)flag {  restrictDropToSameType = flag; return self; }
  533.  
  534. - (BOOL)actAsSink { return actAsSink; }
  535. - setActAsSink:(BOOL)flag 
  536. {  if (actAsSink && !flag) // we're about to turn it off...
  537.    {  [self unregisterDraggedTypes];
  538.    }
  539.    if (!actAsSink && flag) // we're about to turn it on...
  540.    {  const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  541.       [self registerForDraggedTypes:dragTypes count:1];
  542.    }
  543.    
  544.    actAsSink = flag; 
  545.    return self; 
  546. }
  547.  
  548. - (BOOL)actAsSource { return actAsSource; }
  549. - setActAsSource:(BOOL)flag {  actAsSource = flag; return self; }
  550.  
  551. // IB stuff
  552. - (const char *)getInspectorClassName 
  553. {  
  554.    NXEvent  *event = [NXApp currentEvent];
  555.  
  556.    if (event->flags & NX_ALTERNATEMASK)
  557.    {  return [super getInspectorClassName];
  558.    }
  559.    
  560.    return "WWImageVarViewIBInspector"; 
  561. }
  562.  
  563. - write:(NXTypedStream *)stream 
  564. {
  565.    [super write:stream];
  566.    NXWriteTypes(stream, "***cccfc", &tclVarName, &tclVarValue, &tclVarType, 
  567.         &restrictDropToSameName, &restrictDropToSameType, &actAsSource, &frameWidth, &actAsSink);
  568.    NXWriteColor(stream, frameColor);
  569.    return self;
  570. }
  571. //
  572. - read:(NXTypedStream *)stream 
  573. {
  574.    int version;
  575.  
  576.    [super read:stream];
  577.  
  578.    version = NXTypedStreamClassVersion(stream, "WWImageVarView");
  579.    if (version == 1)
  580.    {  NXReadTypes(stream, "***ccc", 
  581.           &tclVarName, &tclVarValue, &tclVarType, 
  582.           &restrictDropToSameName, &restrictDropToSameType, &actAsSource);
  583.       frameColor = NX_COLORBLACK;
  584.       if (tclVarName)
  585.       {  tclVarNameSize = strlen(tclVarName) + 1;
  586.       }
  587.       else
  588.       {  tclVarNameSize = 0;
  589.       }
  590.       if (tclVarValue)
  591.       {  tclVarValueSize = strlen(tclVarValue) + 1;
  592.       }
  593.       else
  594.       {  tclVarValueSize = 0;
  595.       }
  596.       if (tclVarType)
  597.       {  tclVarTypeSize = strlen(tclVarType) + 1;
  598.       }
  599.       else
  600.       {  tclVarTypeSize = 0;
  601.       }
  602.    }
  603.    if (version == 2)
  604.    {  NXReadTypes(stream, "***cccf", 
  605.           &tclVarName, &tclVarValue, &tclVarType, 
  606.           &restrictDropToSameName, &restrictDropToSameType, &actAsSource, &frameWidth);
  607.       frameColor = NXReadColor(stream);
  608.  
  609.       if (tclVarName)
  610.       {  tclVarNameSize = strlen(tclVarName) + 1;
  611.       }
  612.       else
  613.       {  tclVarNameSize = 0;
  614.       }
  615.       if (tclVarValue)
  616.       {  tclVarValueSize = strlen(tclVarValue) + 1;
  617.       }
  618.       else
  619.       {  tclVarValueSize = 0;
  620.       }
  621.       if (tclVarType)
  622.       {  tclVarTypeSize = strlen(tclVarType) + 1;
  623.       }
  624.       else
  625.       {  tclVarTypeSize = 0;
  626.       }
  627.    }
  628.    if (version == 3)
  629.    {  NXReadTypes(stream, "***cccfc", 
  630.           &tclVarName, &tclVarValue, &tclVarType, 
  631.           &restrictDropToSameName, &restrictDropToSameType, &actAsSource, &frameWidth, &actAsSink);
  632.       frameColor = NXReadColor(stream);
  633.  
  634.       if (tclVarName)
  635.       {  tclVarNameSize = strlen(tclVarName) + 1;
  636.       }
  637.       else
  638.       {  tclVarNameSize = 0;
  639.       }
  640.       if (tclVarValue)
  641.       {  tclVarValueSize = strlen(tclVarValue) + 1;
  642.       }
  643.       else
  644.       {  tclVarValueSize = 0;
  645.       }
  646.       if (tclVarType)
  647.       {  tclVarTypeSize = strlen(tclVarType) + 1;
  648.       }
  649.       else
  650.       {  tclVarTypeSize = 0;
  651.       }
  652.    }
  653.    return self;
  654. }
  655.  
  656.  
  657.  
  658.  
  659. @end
  660.