home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 (1993) / nebula.bin / SourceCode / MiniExamples / PerformanceTuning / VisibleView-01 / VisibleOne.m < prev    next >
Encoding:
Text File  |  1991-10-18  |  10.1 KB  |  528 lines
  1. //
  2. //    A Visible View
  3. //    Randy Nelson—Copyright NeXT 1990
  4. //    Not for release or reuse
  5. //
  6.  
  7. #import "VisibleOne.h"
  8. #import <appkit/View.h>
  9. #import <appkit/publicWraps.h>
  10. #import <dpsclient/wraps.h>
  11. #import <appkit/graphics.h>
  12. #import <appkit/Application.h>
  13. #import <appkit/Font.h>
  14. #import <appkit/Form.h>
  15. #import <appkit/Control.h>
  16. #import <appkit/Button.h>
  17. #import <appkit/Bitmap.h>
  18. #import <appkit/nextstd.h>
  19. #import <libc.h>
  20. #import "SubViewFramer.h"
  21. #import "Appender.h"
  22. #import    "Timing.h"
  23.  
  24. @implementation VisibleOne
  25.  
  26. #define TIMING_DEBUG        1
  27.  
  28.  
  29. //factory method—sets clipping off
  30. + newFrame:(NXRect *)f
  31. {
  32.     self = [super newFrame:f];
  33.     [self setClipping:NO];
  34.     return self;
  35. }
  36.  
  37. //outlet initializers
  38. - setAppender:anObject
  39. {
  40.     appender = anObject;
  41.     return self;
  42. }
  43.  
  44. - setTransparencyIndicator:anObject
  45. {
  46.     transparencyIndicator = anObject;
  47.     return self;
  48. }
  49.  
  50. - setCompositeIndicator:anObject
  51. {
  52.     compositeIndicator = anObject;
  53.     return self;
  54. }
  55.  
  56. - setDrawGridIndicator:anObject
  57. {
  58.     drawGridIndicator = anObject;
  59.     return self;
  60. }
  61.  
  62. - setFrameX:anObject
  63. {
  64.     frameX = anObject;
  65.     return self;
  66. }
  67.  
  68. - setFrameY:anObject
  69. {
  70.     frameY = anObject;
  71.     return self;
  72. }
  73.  
  74. - setFrameWidth:anObject
  75. {
  76.     frameWidth = anObject;
  77.     return self;
  78. }
  79.  
  80. - setFrameHeight:anObject
  81. {
  82.     frameHeight = anObject;
  83.     return self;
  84. }
  85.  
  86. - setScaleX:anObject
  87. {
  88.     scaleX = anObject;
  89.     return self;
  90. }
  91.  
  92. - setTranslateY:anObject
  93. {
  94.     translateY = anObject;
  95.     return self;
  96. }
  97.  
  98. - setVitalMatrix:anObject
  99. {
  100.     vitalMatrix = anObject;
  101.     return self;
  102. }
  103.  
  104. - setTranslateX:anObject
  105. {
  106.     translateX = anObject;
  107.     return self;
  108. }
  109.  
  110. - setScaleY:anObject
  111. {
  112.     scaleY = anObject;
  113.     return self;
  114. }
  115.  
  116. //translate
  117. - setSelfOrigin:sender
  118. {
  119.     [self setDrawOrigin:[translateX intValue] :[translateY intValue]];
  120.     [window display];
  121.     return self;
  122. }
  123.  
  124. //scale
  125. - setSelfScale:sender
  126. {
  127.     [self scale:[scaleX floatValue] :[scaleY floatValue]];
  128.     [window display];
  129.  
  130.     //reset the interface values
  131.     [scaleX setIntValue:1];
  132.     [scaleY setIntValue:1];
  133.     
  134.     return self;
  135. }
  136.  
  137. //rotate
  138. - setSelfRotation:sender
  139. {
  140.     [self setDrawRotation:[sender intValue]];
  141.     [window display];
  142.     return self;
  143. }
  144.  
  145. //move frame
  146. - frameMove:sender
  147. {
  148.     [self moveTo:[frameX floatValue] :[frameY floatValue]];
  149.     [window display];
  150.     [self setTrackingRect];
  151.     return self;
  152. }
  153.  
  154. //rotate frame
  155. - frameRotate:sender
  156. {
  157.     [self rotateTo:[sender intValue]];
  158.     [window display];
  159.     /*if ([self frameAngle] == 0){
  160.         [self setTrackingRect];
  161.     }
  162.     else{
  163.         [window discardTrackingRect:23];
  164.     }
  165.     */
  166.     return self;
  167. }
  168.  
  169. //resize frame
  170. - frameChangeSize:sender
  171. {
  172.     [self sizeTo:[frameWidth intValue] :[frameHeight intValue]];
  173.     [window display];
  174.     [self setTrackingRect];
  175.     return self;
  176. }
  177.  
  178. //sent by the preferences buttons to force a redraw, reflecting their new state
  179. - newDisplayState:sender
  180. {
  181.     [window display];
  182.     return self;
  183. }
  184.  
  185. //delegate method of app
  186. - appDidInit:sender
  187. {
  188.     NXRect aRect = {0.0, 0.0, 0.0, 0.0};
  189.     sprintf(buffer, "Received appDidInit:\n");    
  190.     [appender appendToText:buffer];
  191.     
  192.     //gets the bitmap for compositing
  193.     myPic = [Bitmap findBitmapFor:"nextLogo"];
  194.     
  195.     //sets up the subViewFramer as our superview
  196.     newSuperView = [SubViewFramer newFrame:&aRect];
  197.     [window setContentView:newSuperView];
  198.     [newSuperView addSubview:self];
  199.     [newSuperView display];
  200.         
  201.     [self setTrackingRect];
  202.     [window makeKeyAndOrderFront:self];
  203.     return self;
  204. }
  205.  
  206. //allows us to become first responder
  207. - (BOOL)acceptsFirstResponder
  208. {
  209.     sprintf(buffer, "Received acceptsFirstResponder -- returning YES\n");    
  210.     [appender appendToText:buffer];
  211.     return YES;
  212. }
  213.  
  214. //allows us to use the mouse click that activates the window
  215. - (BOOL)acceptsFirstMouse
  216. {
  217.     sprintf(buffer, "Received acceptsFirstMouse -- returning YES\n");    
  218.     [appender appendToText:buffer];
  219.     return YES;
  220. }
  221.  
  222. //draws the view and then calls the superview for framing
  223. - drawSelf:(NXRect *)r :(int)c
  224. {
  225.     NXPoint zero = {0.0, 0.0};
  226.  
  227.     [self updateVitals];
  228.     if([compositeIndicator state]){
  229.         [myPic composite:NX_COPY toPoint:&zero];
  230.     }
  231.     if([drawGridIndicator state]){
  232.         PSselectfont("Times-Italic", 24.0);
  233.         PSsetgray(NX_WHITE);
  234.         [self drawGrid];
  235.     }
  236.     //draws the views basic contents
  237.     [self drawSomePS];
  238.     
  239.     //displays the bounds rect
  240.     PSsetgray(NX_BLACK);
  241.     sprintf(buffer, "bounds.origin.x %.1f,.y %.1f", bounds.origin.x, bounds.origin.y);
  242.     PSmoveto(bounds.origin.x, (bounds.origin.y - 18));
  243.     PSselectfont("Times-Italic", 24.0);
  244.     PSshow(buffer);
  245.     NXFrameRect(&bounds);
  246.     
  247.     //calls the subViewFramer, our superview
  248.     [newSuperView frameMe:self];
  249.     
  250.     return self;
  251. }
  252.  
  253. //indicates the mouse down with a beep
  254. - mouseDown:(NXEvent *)e
  255. {
  256.     sprintf(buffer, "Received mouseDown: -- window coordinates %.f, %.f\n", e->location.x, e->location.y);    
  257.     [appender appendToText:buffer];
  258.     NXBeep();
  259.     return self;
  260. }
  261.  
  262. //indicates at the location of the mouse at mouse up using instance drawing
  263. - mouseUp:(NXEvent *)e
  264. {
  265.     
  266.     NXPoint mousePoint = e->location;
  267.  
  268.     sprintf(buffer, "Received mouseUp: -- window coordinates %.f, %.f\n", e->location.x, e->location.y);
  269.     [appender appendToText:buffer];
  270.     [self convertPointFromSuperview:&mousePoint];
  271.     [self lockFocus];
  272.     PSselectfont("Times-Italic", 24.0);
  273.     PSsetgray(NX_DKGRAY);
  274.     PSnewinstance();
  275.     PSsetinstance(YES);
  276.     PSmoveto(mousePoint.x, mousePoint.y);
  277.     PSsetgray(0.0);
  278.     PSrectfill(mousePoint.x-2.0, mousePoint.y-2.0, 4.0, 4.0);
  279.     PSmoveto(mousePoint.x+4.0, mousePoint.y+4.0);
  280.     sprintf(buffer, "%.f, %.f", mousePoint.x, mousePoint.y);
  281.     PSshow(buffer);
  282.     PSsetinstance(NO);
  283.     [self unlockFocus];
  284.     return self;
  285. }
  286.  
  287. //tracks the mouse entering the view
  288. - mouseEntered:(NXEvent *)e
  289. {
  290.     sprintf(buffer, "Received mouseEntered: -- window coordinates %.f, %.f\n", e->location.x, e->location.y);
  291.     [appender appendToText:buffer];
  292.     return self;
  293. }
  294.  
  295. //tracks the mouse leaving the view
  296. - mouseExited:(NXEvent *)e
  297. {
  298.     sprintf(buffer, "Received mouseExited: -- window coordinates %.f, %.f\n", e->location.x, e->location.y);
  299.     [appender appendToText:buffer];
  300.     return self;
  301. }
  302.  
  303. //gets keyUps
  304. - keyUp:(NXEvent *)e
  305. {
  306.     sprintf(buffer, "Received keyUp:\n");
  307.     [appender appendToText:buffer];
  308.     return self;
  309. }
  310.  
  311. //gets keyDowns
  312. - keyDown:(NXEvent *)e
  313. {
  314.     sprintf(buffer, "Received keyDown: -- char '%c'\n", e->data.key.charCode);
  315.     [appender appendToText:buffer];
  316.     return self;
  317. }
  318.  
  319. //checks to see if the mouse down was in this view
  320. - hitTest:(NXPoint *)aPt
  321. {
  322.     char *localBuffer;
  323.     
  324.     NX_MALLOC(localBuffer, char, 100);
  325.     
  326.     sprintf(localBuffer, "Received hitTest:");
  327.     [appender appendToText:localBuffer];
  328.     if ([super hitTest:aPt]){
  329.         sprintf(localBuffer, " -- YES inside this view\n");
  330.         [appender appendToText:localBuffer];
  331.         return self;
  332.     }
  333.     sprintf(localBuffer, " -- NO not inside this view\n");     
  334.     [appender appendToText:localBuffer];
  335.     return  nil;
  336. }
  337.  
  338. //updates the statistics matrix
  339. - updateVitals
  340. {
  341.     [[[[[[[[[[vitalMatrix setFloatValue:bounds.origin.x at:0]
  342.         setFloatValue:bounds.origin.y at:1]
  343.             setFloatValue:bounds.size.width at:2]
  344.                 setFloatValue:bounds.size.height at:3]
  345.                     setFloatValue:[self boundsAngle] at:4]
  346.                         setFloatValue:frame.origin.x at:5]
  347.                             setFloatValue:frame.origin.y at:6]
  348.                                 setFloatValue:frame.size.width at:7]
  349.                                     setFloatValue:frame.size.height at:8]
  350.                                         setFloatValue:[self frameAngle] at:9];
  351.     return self;
  352. }
  353.  
  354. //for communication with the transparent superview
  355. - (BOOL)wantsTransparency
  356. {
  357.     return ([transparencyIndicator state]);
  358. }
  359.  
  360. - setTrackingRect
  361. {
  362.     NXRect aRect;
  363.     
  364.     //registers the tracking rect
  365.     aRect = frame;
  366.     [superview convertRect:&aRect toView:nil];
  367.     sprintf(buffer, "Sending setTrackingRect:... to window\n");    
  368.     [appender appendToText:buffer];
  369.     [window setTrackingRect:&aRect inside:NO owner:self tag:23 left:NO right:NO];
  370.     return self;
  371. }
  372.  
  373. - drawGrid
  374. {
  375. #ifdef TIMING_DEBUG
  376.     id t4 = [Timing newWithTag:4];
  377.     [t4 reset];
  378.     [t4 enter:PSTIME];
  379. #endif
  380.     
  381.     PSrectstroke(0.0, 0.0, 100.0, 100.0); 
  382.     PSrectstroke(100.0, 100.0, 100.0, 100.0); 
  383.     PSrectstroke(0.0, 0.0, 200.0, 200.0); 
  384.     PSmoveto (0.0, 0.0 ); 
  385.     PSshow("0.0 0.0");
  386.     PSmoveto(100.0, 100.0 );
  387.     PSshow ("100.0, 100.0"); 
  388.     PSmoveto (200.0, 200.0); 
  389.     PSshow("200.0, 200.0");
  390.     PSrectstroke(0.0, 0.0, -100.0, -100.0);
  391.     PSrectstroke(-100.0, -100.0, -100.0, -100.0 ); 
  392.     PSrectstroke (0.0, 0.0, -200.0, -200.0); 
  393.     PSmoveto(-100.0, -100.0 ); 
  394.     PSshow("-100.0, -100.0");
  395.     PSmoveto(-200.0, -200.0 ); 
  396.     PSshow("-200.0, -200.0");
  397.     PSrectstroke(0.0, 0.0, -100.0, 100.0); 
  398.     PSrectstroke(-100.0, 100.0, -100.0, 100.0);
  399.     PSrectstroke( 0.0, 0.0, -200.0, 200.0);
  400.     PSmoveto(-100.0 , 100.0 ); 
  401.     PSshow("-100.0, 100.0");
  402.     PSmoveto(-200.0, 200.0); 
  403.     PSshow("-200.0, 200.0");
  404.     PSrectstroke( 0.0, 0.0, 100.0, -100.0 );
  405.     PSrectstroke(100.0, -100.0, 100.0, -100.0);
  406.     PSrectstroke( 0.0, 0.0, 200.0, -200.0 );
  407.     PSmoveto (100.0, -100.0 );
  408.     PSshow("100.0, -100.0");
  409.     PSmoveto( 200.0, -200.0); 
  410.     PSshow("200.0, -200.0");
  411.     
  412.     
  413. #ifdef TIMING_DEBUG
  414.     [t4 leave];
  415.     [t4 summary:self];
  416. #endif
  417.  
  418.     return self;
  419. }
  420.  
  421. //defs
  422. - tripath
  423. {
  424.     PSmoveto(0.0, 0.0);
  425.     PSlineto(100.0, 0.0);
  426.     PSlineto(50.0, 100.0);
  427.     PSclosepath();
  428.     return self;
  429. } 
  430.  
  431. - cirpath
  432. {
  433.     PSmoveto(100.0, 50.0);
  434.     PSarc(50.0, 50.0, 50.0, 0.0, 360.0);
  435.     return self;
  436. }
  437.  
  438. - recstroke
  439. {
  440.     PSrectstroke(0.0, 0.0, 100.0, 100.0);
  441.     return self;
  442. } 
  443.  
  444. - recfill
  445. {
  446.     PSrectfill(0.0, 0.0, 100.0, 100.0);
  447.     return self;
  448. }
  449.  
  450. - rec
  451. {
  452.     PSsetgray(.333);
  453.     [self recfill];
  454.     PSsetgray(0.0);
  455.     [self recstroke];
  456.     return self;
  457. }
  458.  
  459. - cir
  460. {
  461.     PSsetgray(.5);
  462.     [self cirpath];
  463.     PSfill();
  464.     PSsetgray(0.0);
  465.     [self cirpath];
  466.     PSstroke();
  467.     return self;
  468. }
  469.  
  470. - tri
  471. {
  472.     PSsetgray(.666);
  473.     [self tripath];
  474.     PSfill();
  475.     PSsetgray(0.0);
  476.     [self tripath];
  477.     PSstroke();
  478.     return self;
  479. }
  480.  
  481. - mass
  482. {
  483.     [self rec];
  484.     [self cir];
  485.     [self tri];
  486.     return self;
  487. }
  488.  
  489. //body
  490. - drawSomePS
  491. {    
  492.     PSgsave();
  493.     PStranslate(200.0, 50.0); 
  494.     PSrotate(30.0);
  495.     [self mass];
  496.     PSgrestore();
  497.     
  498.     PSgsave();
  499.     PStranslate(150.0, 50.0);
  500.     PSrotate(45.0);
  501.     [self rec];
  502.     PSgrestore();
  503.     
  504.     PSgsave();
  505.     PStranslate(50.0, 150.0);
  506.     [self tri];
  507.     PSgrestore();
  508.     
  509.     PSgsave();
  510.     PStranslate(100.0, 100.0);
  511.     [self cir];
  512.     PSgrestore();
  513.     
  514.     PSgsave();
  515.     PStranslate(25.0, 25.0);
  516.     [self mass];
  517.     PSgrestore();
  518.     
  519.     PSgsave();
  520.     PStranslate(125.0, 275.0);
  521.     PSrotate(-60.0);
  522.     [self mass];
  523.     PSgrestore();
  524.  
  525.     return self;
  526. }
  527. @end
  528.