home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / SourceCode / MiscKit1.7.1 / MiscKit / Palettes / MiscGaugePalette / MiscGaugeView.subproj / MiscGaugeCell.m < prev    next >
Encoding:
Text File  |  1995-04-14  |  13.8 KB  |  585 lines
  1. /****************************************************************************
  2.   CLASS:                MiscGaugeCell
  3.   
  4.   For more information, see the interface file.
  5.   
  6.   Since most of the code from this class came from the GaugeView class, here
  7.   is the original comments for your reading pleasure:
  8.    
  9.   GaugeView.m, analog gauge view
  10.   Author: Bruce Blumberg, NeXT Developer Support Group.
  11.   Originally written for 0.6 mid 1988, modified for 1.0 by Ali Ozer.
  12.   Redesigned for 2.0 by Julie Zelenski, NeXT Developer Support
  13.  
  14.   Subclass of view to implement a simple round analog gauge. You can set the 
  15.   minimum, maximum value, start angle, angle range, title, font, and more.  
  16.   It is a pretty generic round gauge view, if you ever have need for one.
  17.  
  18.   You may freely copy, distribute and reuse the code in this example.  
  19.   NeXT disclaims any warranty of any kind, expressed or implied, as to 
  20.   its fitness for any particular use.
  21.  
  22.   This object is included in the MiscKit by permission from the author
  23.   and its use is governed by the MiscKit license, found in the file
  24.   "LICENSE.rtf" in the MiscKit distribution.  Please refer to that file
  25.   for a list of all applicable permissions and restrictions.
  26.  ****************************************************************************/
  27.  
  28. #import <appkit/appkit.h>
  29. #import "Gauge.h"                // For the pswraps.
  30. #import "MiscGaugeCell.h"
  31.  
  32. // Used for class versioning. If you happen to change the ivars, then 
  33. // bump the version up and update the read:/write: methods.
  34. #define MISCGAUGECELL_VERSION 0
  35. #define MISCGAUGECELL_NAME "MiscGaugeCell"
  36.  
  37.  
  38. @implementation MiscGaugeCell 
  39.  
  40. + initialize
  41. {
  42.     if (self == [MiscGaugeCell class])
  43.         // Set the class's version for archiving purposes.
  44.         [self setVersion: MISCGAUGECELL_VERSION];
  45.     return self;
  46. }
  47.  
  48.  
  49. - init
  50. {
  51.     if ([super init] == nil)
  52.         return nil;
  53.     
  54.     cache = [ [NXImage alloc] init];   
  55.     radius = 0.0;
  56.     center.x = center.y = 0.0;
  57.     startAngle = angleRange = degreesPerUnit = 0.0;
  58.     tickInterval = 0;
  59.     gaugeColor = NXConvertGrayToColor (NX_DKGRAY);
  60.     textColor = NXConvertGrayToColor (NX_BLACK);
  61. //    backgroundColor = NXConvertGrayToColor (NX_LTGRAY);
  62.     minValue = 0.0; 
  63.     maxValue = 1.0;
  64.     value = 0.0;
  65.     strValue = NULL;
  66.     tickRatio = 0.65;
  67.     handRatio = 0.6;
  68.     degreesPerUnit = angleRange/(maxValue-minValue);
  69.     [self setType: NX_TEXTCELL];    // Need this so I can use [self font].
  70.     [self setTitle: "Gauge"];
  71.     [self setTitlePosition: NX_ATTOP];
  72.     titleFont = [self font]; 
  73.  
  74.     return self;
  75. }
  76.  
  77.  
  78. - free
  79. {
  80.     if (strValue != NULL)
  81.         NX_FREE (strValue);
  82.     if (cache != nil)    
  83.         cache = [cache free];
  84.     return [super free];
  85. }
  86.  
  87.  
  88. - (float)maxValue { return maxValue; }
  89. - (float)minValue { return minValue; }
  90. - (float)floatValue    { return value; }
  91. - (double)doubleValue { return (double)value; }
  92. - (int)intValue { return (int)value; }
  93.  
  94.  
  95. - (const char *)stringValue 
  96. { 
  97.     if (strValue != NULL)
  98.         NX_FREE (strValue);
  99.      
  100.     NX_MALLOC (strValue, char, 20);
  101.     sprintf (strValue, "%f", value);
  102.     return strValue;
  103. }
  104.  
  105.  
  106. - setMaxValue: (float)max
  107. {
  108.     if ([self maxValue] == max)
  109.         return self;
  110.         
  111.     maxValue = max;
  112.     if ([self minValue] >= [self maxValue])
  113.         [self setMinValue: max-1];
  114.     if ([self floatValue] > maxValue)
  115.         [self setFloatValue: maxValue];
  116.  
  117.     degreesPerUnit = angleRange/(maxValue-minValue);
  118.     return self;
  119. }
  120.  
  121.  
  122. - setMinValue: (float)min
  123. {
  124.     if ([self minValue] == min)
  125.         return self;
  126.         
  127.     minValue = min;
  128.     if ([self minValue] >= [self maxValue])
  129.         [self setMaxValue: min+1];
  130.     if ([self floatValue] < minValue)
  131.         [self setFloatValue: minValue]; 
  132.  
  133.     degreesPerUnit = angleRange/(maxValue-minValue);
  134.     return self;
  135. }
  136.  
  137.  
  138. - setFloatValue: (float)val
  139. {
  140.     if (val < [self minValue])
  141.         val = minValue;
  142.     if (val > [self maxValue])
  143.         val = maxValue;
  144.     value = val;
  145.     return self;
  146. }
  147.  
  148.  
  149. - setDoubleValue: (double)val
  150. {
  151.     return [self setFloatValue: (float)val];
  152. }
  153.  
  154.  
  155. - setIntValue: (int)val
  156. {
  157.     return [self setFloatValue: (float)val];
  158. }
  159.  
  160.  
  161. - setStringValue: (const char *)val
  162. {
  163.     if (val == NULL)
  164.         [self setFloatValue: 0.0];
  165.     else
  166.         [self setDoubleValue: atof(val)];
  167.     return self;
  168. }
  169.  
  170.  
  171. //- (NXColor)backgroundColor { return backgroundColor; }
  172. - (NXColor)gaugeColor { return gaugeColor; }
  173. - (NXColor)textColor { return textColor; }
  174.  
  175. /*
  176. - setBackgroundColor: (NXColor)color
  177. {
  178.     if (NXEqualColor (color, backgroundColor) == NO)
  179.         backgroundColor = color;
  180.     return self;
  181. }
  182. */
  183.  
  184. - setGaugeColor: (NXColor)color
  185. {
  186.     if (NXEqualColor (color, gaugeColor) == NO)
  187.         gaugeColor = color;
  188.     return self;
  189. }
  190.  
  191.  
  192. - setTextColor: (NXColor)color
  193. {
  194.     if (NXEqualColor (color, textColor) == NO)
  195.         textColor = color;
  196.     return self;
  197. }
  198.  
  199. /*
  200. - (float)backgroundGray    
  201. {
  202.     float gray;
  203.     NXConvertColorToGray (backgroundColor, &gray);
  204.      return gray; 
  205. }
  206. */
  207.  
  208. - (float)gaugeGray 
  209. { 
  210.     float gray;
  211.     NXConvertColorToGray (gaugeColor, &gray);
  212.      return gray; 
  213. }
  214.  
  215.  
  216. - (float)textGray 
  217. { 
  218.     float gray;
  219.     NXConvertColorToGray (textColor, &gray);
  220.      return gray; 
  221. }
  222.  
  223. /*
  224. - setBackgroundGray: (float)gray
  225. {
  226.     [self setBackgroundColor: NXConvertGrayToColor(gray)];
  227.     return self;
  228. }
  229. */
  230.  
  231. - setGaugeGray: (float)gray
  232. {
  233.     [self setGaugeColor: NXConvertGrayToColor(gray)];
  234.     return self;
  235. }
  236.  
  237.  
  238. - setTextGray: (float)gray
  239. {
  240.     [self setTextColor: NXConvertGrayToColor(gray)];
  241.     return self;
  242. }
  243.  
  244.  
  245. - (float)startAngle { return startAngle; }
  246. - (float)angleRange    { return angleRange; }
  247. - (int)tickInterval { return tickInterval; }
  248. - (float)tickRatio { return tickRatio; }
  249. - (float)handRatio { return handRatio; }
  250.  
  251.  
  252. - setStartAngle:(float)newValue
  253. {
  254.     // Sets start angle for gauge, which is the angle of the arm when at the 
  255.     // minimum value. needRedraw is set to indicate that face image must be 
  256.     // redrawn. 0 degrees is straight right, with increasing numbers going
  257.     // counter clockwise.
  258.     if (newValue < 0.0)
  259.         newValue = 0.0;
  260.     if (newValue > 360.0)
  261.         newValue = 360.0;
  262.     startAngle = newValue;
  263.     return self;
  264. }
  265.  
  266.  
  267. - setAngleRange:(float)newValue
  268. {
  269.     // Sets angle range for gauge, which is the sweep of the arm from minimum
  270.     // value to maximum value.  The value cannot exceed 360 degrees (a full
  271.     // revolution).  Recalculates degreesPerUnit which is used to 
  272.     // determine interval of ticks and labels. needRedraw is set to indicate 
  273.     // that face image must be redrawn.
  274.     if (newValue > 360.0) 
  275.         newValue = 360.0;
  276.     if (newValue < 0.0) 
  277.         newValue = 0.0;
  278.     
  279.     angleRange = newValue;
  280.     degreesPerUnit = angleRange/(maxValue-minValue);
  281.     return self;
  282. }
  283.  
  284.  
  285. - setTickInterval:(int)newValue
  286. {
  287.     // Sets tick interval for gauge, which is number of units between tick
  288.     // marks on gauge face.  needRedraw is set to indicate that 
  289.     // face image must be redrawn.
  290.     if (newValue < 1)
  291.         newValue = 1;
  292.     tickInterval = newValue;
  293.     return self;
  294. }
  295.  
  296.  
  297. - setTickRatio: (float)newRatio
  298. {
  299.     // Make sure new tick ratio is between 0.0 (no ticks) and 1.0.
  300.     if (newRatio < 0.0)
  301.         newRatio = 0.0;
  302.     if (newRatio > 1.0)
  303.         newRatio = 1.0;
  304.     tickRatio = newRatio;
  305.     return self;
  306. }
  307.  
  308.  
  309. - setHandRatio: (float)newRatio
  310. {
  311.     // Make sure new hand ratio is between 0.2 and 0.9.
  312.     if (newRatio < 0.2)
  313.         newRatio = 0.2;
  314.     if (newRatio > 0.9)
  315.         newRatio = 0.9;
  316.     handRatio = newRatio;
  317.     return self;
  318. }
  319.  
  320.  
  321. - titleFont { return titleFont; }
  322. - (const char *)title { return [super stringValue]; }
  323. - (int)titlePosition { return titlePosition; }
  324.  
  325. - setTitleFont: newFont
  326. {
  327.     if ([self titleFont] != newFont)
  328.         titleFont = newFont;
  329.     return self;
  330. }
  331.  
  332.  
  333. - setTitle: (const char *)newTitle
  334. {
  335.     // We are making use of the ivar contents inherited from Cell.
  336.     // Since we overrode stringValue and setStringValue:, we have
  337.     // to use Cell's implementation.
  338.     [super setStringValue: newTitle];
  339.     return self;
  340. }    
  341.     
  342.  
  343. - setTitlePosition: (int)newPos
  344. {
  345.     if (newPos == NX_ATTOP || newPos == NX_ATBOTTOM)
  346.         titlePosition = newPos;
  347.     return self;
  348. }
  349.  
  350.  
  351. - calcCellSize: (NXSize *)size inRect:(NXRect *)rect
  352. {
  353.     // Return the minimum size that the cell will fit in.
  354.     size->width = NX_WIDTH(rect);
  355.     size->height = NX_HEIGHT(rect);
  356.  
  357.     if (size->height < size->width) 
  358.         size->width = size->height;
  359.     else 
  360.         size->height = size->width;
  361.  
  362.     return self;
  363. }
  364.  
  365.  
  366. - drawSelf: (const NXRect *)rect inView: controlView
  367. {
  368.     center.x = NX_WIDTH(rect)/2.0;
  369.     center.y = NX_HEIGHT(rect)/2.0;
  370.     if (NX_WIDTH(rect) > NX_HEIGHT(rect))
  371.         radius = (NX_HEIGHT(rect)/2.0) - 8.0;
  372.     else
  373.         radius = (NX_WIDTH(rect)/2.0) - 8.0;
  374.  
  375.     // Redraws the face in the cached image.        
  376.     [self drawFace: rect];
  377.     // Draws the gauge itself. 
  378.     [self drawInside: rect inView: controlView];
  379.     return self;
  380. }
  381.  
  382.  
  383. - drawInside: (const NXRect *)rect inView: controlView
  384. {
  385.     // Composites the "face" of the gauge, then draws the hand.
  386.     // This method will also work inside a flipped view (like a Matrix).
  387.     NXPoint corner = {0.0, 0.0};
  388.  
  389.     // If view is flipped composite from lower left corner.
  390.     if ([controlView isFlipped])
  391.         corner.y = NX_HEIGHT (rect);
  392.  
  393.     // Composite the gauge face into the view.
  394.     [cache composite: NX_SOVER toPoint: &corner];
  395.     // Draw the hand.
  396.     [self drawHand: rect flipped: [controlView isFlipped] ];    
  397.  
  398.     return self;
  399. }
  400.  
  401.  
  402. - drawHand: (const NXRect *)rect flipped: (BOOL)viewFlipped
  403. {
  404.     // If you want the gauge to have a different look you should only
  405.     // have to override drawFace: and drawHand:. The passed rect
  406.     // is the same rect that is passed to drawInside:.
  407.     float valueAngle;    
  408.  
  409.     valueAngle = startAngle - degreesPerUnit*(value-minValue);
  410.     
  411.     if (viewFlipped == YES)
  412.     {
  413.         PSgsave();
  414.         PSWflipme (NX_HEIGHT(rect));
  415.      }
  416.     
  417.     NXSetColor ([self textColor]);
  418.     PSWdrawHand(center.x,center.y,valueAngle, radius*handRatio);
  419.  
  420.     if (viewFlipped == YES)
  421.         PSgrestore();
  422.     return self;
  423. }
  424.  
  425.     
  426. - drawFace: (const NXRect *)rect 
  427. {    
  428.     // This method draws the gauge face image in an NXImage.  It erases
  429.     // the background, draws the circular border, draws the tick marks and 
  430.     // labels them appropriately. Since we are drawing into an NXImage
  431.     // we don't care whether the view we are compositing into is flipped or 
  432.     // not.
  433.     float angle, angleIncrement;
  434.     int number;
  435.     NXSize string;
  436.     NXPoint pt;
  437.     char numString[10];
  438.     NXSize cacheSize;
  439.     Font *cellsFont = [self font];
  440.     Font *flippedFont;
  441.     float titleY;
  442.     
  443.     cacheSize.width = NX_WIDTH (rect);
  444.     cacheSize.height = NX_HEIGHT (rect);
  445.     [cache setSize: &cacheSize];
  446.     
  447.     if ([cache lockFocus] == NO)
  448.         return self;
  449.  
  450.     // Do the entire rect in our background color.
  451. //    NXSetColor ([self backgroundColor]);
  452.     PSsetalpha (0.0);
  453.     NXRectFill(rect);
  454.     PSsetalpha (1.0);
  455.  
  456.     // Draw the gauge face.
  457.     NXSetColor ([self gaugeColor]);
  458.     PSWdrawBorder(center.x, center.y, radius);
  459.     angleIncrement = angleRange/((maxValue-minValue)/(float)tickInterval); 
  460.     if (tickRatio > 0.0)
  461.     {
  462.         NXSetColor ([self textColor]);
  463.         PSWdrawTicks(center.x, center.y, radius*tickRatio, angleIncrement/2.0, 
  464.                         startAngle, startAngle+angleRange); 
  465.      }
  466.  
  467.     if ([self title] != NULL)
  468.     {
  469.         // Makes sure that the title font if using the NX_IDENTITYMATRIX.     
  470.         flippedFont = [Font newFont: [titleFont name] 
  471.                         size: [titleFont pointSize] matrix: NX_IDENTITYMATRIX];
  472.         [flippedFont set];     
  473.     
  474.         // Spit out the title.
  475.         string.height = [flippedFont pointSize];
  476.         string.width = [flippedFont getWidthOf: [self title] ];
  477.         if ([self titlePosition] == NX_ATTOP)
  478.             titleY = center.y+(NX_HEIGHT(rect)/10.0);
  479.         else
  480.             titleY = center.y-(NX_HEIGHT(rect)/12.0)-string.height;
  481.         
  482.         NXSetColor ([self textColor]);    
  483.         PSWdrawString((NX_WIDTH(rect)-string.width)/2, titleY, 
  484.                         [self title]);
  485.      }
  486.      
  487.     // Make sure the cell's font (for the numbers) is also using
  488.     // the NX_IDENTITYMATRIX.     
  489.     flippedFont = [Font newFont: [cellsFont name] 
  490.                     size: [cellsFont pointSize] matrix: NX_IDENTITYMATRIX];
  491.     [flippedFont set];     
  492.     string.height = [flippedFont pointSize];
  493.     
  494.     // Spit out all the numbers.
  495.     number =  minValue;
  496.     NXSetColor ([self textColor]);
  497.     for(angle=startAngle;angle>=startAngle-angleRange;angle -= angleIncrement){
  498.         sprintf(numString,"%d",number);
  499.         string.width = [cellsFont getWidthOf: numString];
  500.         pt.x = cos(angle/57.3)*(radius-1.0-string.width/2)+ center.x; 
  501.         pt.y = sin(angle/57.3)*(radius-1.0-string.height/2) + center.y ;
  502.         PSWdrawString(pt.x-(string.width/2), pt.y-(string.height/2.5),
  503.             numString);
  504.         number += tickInterval;
  505.     }
  506.     
  507.     [cache unlockFocus]; 
  508.     return self;
  509. }    
  510.  
  511.  
  512. - highlight:(const NXRect *)cellFrame inView:aView lit:(BOOL)flag
  513. {
  514.     // We don't want highlighting to occur.
  515.     return self;
  516. }
  517.  
  518.  
  519. - awake
  520. {
  521.     [super awake];
  522.     cache = [ [NXImage alloc] init];
  523.     strValue = NULL;
  524.     degreesPerUnit = angleRange/(maxValue-minValue);
  525.     return self;
  526. }
  527.  
  528.  
  529. - read: (NXTypedStream *)stream
  530. {
  531.     int version;
  532.     
  533.     [super read: stream];
  534.     version = NXTypedStreamClassVersion (stream, MISCGAUGECELL_NAME);
  535.     switch (version)
  536.     {
  537.         case MISCGAUGECELL_VERSION:
  538.             NXReadTypes (stream, "ffiff", &startAngle, &angleRange, 
  539.                             &tickInterval, &tickRatio, &handRatio);
  540.             NXReadTypes (stream, "fffs", &minValue, &maxValue, &value,
  541.                             &titlePosition);
  542. //            backgroundColor = NXReadColor (stream);
  543.             gaugeColor = NXReadColor (stream);
  544.             textColor = NXReadColor (stream);
  545.             titleFont = NXReadObject (stream);
  546.             break;
  547.             
  548.         default:
  549.             NXLogError ("Could not read typed stream for class %s, version %d", MISCGAUGECELL_NAME, version);
  550.             break;
  551.      }
  552.     return self;
  553. }
  554.  
  555.  
  556. - write: (NXTypedStream *)stream
  557. {
  558.     [super write: stream];
  559.     NXWriteTypes (stream, "ffiff", &startAngle, &angleRange, 
  560.                     &tickInterval, &tickRatio, &handRatio);
  561.     NXWriteTypes (stream, "fffs", &minValue, &maxValue, &value,
  562.                     &titlePosition); 
  563. //    NXWriteColor (stream, backgroundColor);
  564.     NXWriteColor (stream, gaugeColor);
  565.     NXWriteColor (stream, textColor);
  566.     NXWriteObject (stream, titleFont);
  567.     return self;
  568. }
  569.  
  570. @end
  571.  
  572.  
  573. /****************************************************************************
  574.   CHANGES:
  575.    Version 0.3, March 19, 1995
  576.   1. Fixed so it would draw with a transparent background correctly.
  577.    Version 0.4, March 21, 1995
  578.   2. Removed the lastRect and needRedraw ivars since as long as 
  579.      drawSelf:inView: is called only when needed the face needs 
  580.      redrawing (from GaugeView) then drawing will be fairly efficient.
  581.   3. Added drawHand:flipped: so you could easily customize the look
  582.      of the gauge face and hand.
  583.      
  584.  ****************************************************************************/
  585.