home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1995 August / NEBULA.bin / SourceCode / AdobeExamples / NX_CtlPoints / ControlPoint.m < prev    next >
Encoding:
Text File  |  1993-01-18  |  5.1 KB  |  230 lines
  1.  
  2. /*
  3.  * (a)  (C) 1990 by Adobe Systems Incorporated. All rights reserved.
  4.  *
  5.  * (b)  If this Sample Code is distributed as part of the Display PostScript
  6.  *    System Software Development Kit from Adobe Systems Incorporated,
  7.  *    then this copy is designated as Development Software and its use is
  8.  *    subject to the terms of the License Agreement attached to such Kit.
  9.  *
  10.  * (c)  If this Sample Code is distributed independently, then the following
  11.  *    terms apply:
  12.  *
  13.  * (d)  This file may be freely copied and redistributed as long as:
  14.  *    1) Parts (a), (d), (e) and (f) continue to be included in the file,
  15.  *    2) If the file has been modified in any way, a notice of such
  16.  *      modification is conspicuously indicated.
  17.  *
  18.  * (e)  PostScript, Display PostScript, and Adobe are registered trademarks of
  19.  *    Adobe Systems Incorporated.
  20.  * 
  21.  * (f) THE INFORMATION BELOW IS FURNISHED AS IS, IS SUBJECT TO
  22.  *    CHANGE WITHOUT NOTICE, AND SHOULD NOT BE CONSTRUED
  23.  *    AS A COMMITMENT BY ADOBE SYSTEMS INCORPORATED.
  24.  *    ADOBE SYSTEMS INCORPORATED ASSUMES NO RESPONSIBILITY
  25.  *    OR LIABILITY FOR ANY ERRORS OR INACCURACIES, MAKES NO
  26.  *    WARRANTY OF ANY KIND (EXPRESS, IMPLIED OR STATUTORY)
  27.  *    WITH RESPECT TO THIS INFORMATION, AND EXPRESSLY
  28.  *    DISCLAIMS ANY AND ALL WARRANTIES OF MERCHANTABILITY, 
  29.  *    FITNESS FOR PARTICULAR PURPOSES AND NONINFRINGEMENT
  30.  *    OF THIRD PARTY RIGHTS.
  31.  */
  32.  
  33. /*
  34. *    ControlPoint.m
  35. *    This file handles the particulars for the control point.
  36.  *
  37.  *    Version:    2.0
  38.  *    Author:    Ken Fromm
  39.  *    History:
  40.  *            03-07-91        Added this comment.
  41. */
  42.  
  43. #import "ControlPoint.h"
  44. #import "ControlView.h"
  45. #import "ControlPointWraps.h"
  46. #import "ControlViewWraps.h"
  47. #import <appkit/View.h>
  48. #import <appkit/nextstd.h>
  49. #import <dpsclient/dpsclient.h>
  50. #import <dpsclient/wraps.h>
  51.  
  52. static char    fontname[ ] = "ControlPointsFont";
  53.  
  54. /* The point arrays below have the number of points in the array as the first entry
  55. * followed by the points. The op arrays have the number of ops in the array
  56. * as the first entry followed by the operators.
  57. */
  58.  
  59. static float    ptsRectfill[] = {8, -2, -2, 0, 4, 4, 0, 0, -4};
  60. static char    opsRectfill[] = {5, dps_rmoveto, dps_rlineto, dps_rlineto, dps_rlineto,
  61.                         dps_closepath};
  62.                          
  63. static float    ptsRectstroke[] = {8, -2, -2, 0, 4, 4, 0, 0, -4};
  64. static char    opsRectstroke[] = {5, dps_rmoveto, dps_rlineto, dps_rlineto, dps_rlineto,
  65.                             dps_closepath};
  66.  
  67. static float    ptsX[] = {8,  -2, -2, 4, 4, 0, -4, -4, 4};
  68. static char    opsX[] = {4, dps_rmoveto, dps_rlineto, dps_rmoveto, dps_rlineto};
  69.  
  70. static float    ptsCross[] = {8, 0, 2, 0, -4, -2, 2, 4, 0};
  71. static char    opsCross[] = {4, dps_rmoveto, dps_rlineto, dps_rmoveto, dps_rlineto};
  72.  
  73. @implementation ControlPoint
  74.  
  75. - setControlView:anObject
  76. {
  77.     controlView = anObject;
  78.  
  79.     PSWDefsContPts ();
  80.     PSWSetDependent();
  81.     PSWDefineFont(fontname);
  82.  
  83.     [self setRectfill:self];
  84.     
  85.     return self;
  86. }
  87.  
  88. /* These four methods set the values for drawing a type of control point. */
  89. - setRectfill:sender
  90. {
  91.     fontchar = 'a';
  92.     basicProc = "BRF";
  93.     basicOp = "fill";
  94.     userPtsArray = ptsRectfill;
  95.     userOpsArray = opsRectfill;
  96.     userOp = "ufill";
  97.     rectOp = "rectfill";
  98.  
  99.     [controlView setButtonTitle:FILL];
  100.     [controlView setButtonEnable:YES];
  101.     [controlView  eraseTimes:self];
  102.     
  103.     return self;
  104. }
  105.  
  106. - setRectstroke:sender
  107. {
  108.     fontchar = 'b';
  109.     basicProc = "BRS";
  110.     basicOp = "stroke";
  111.     userPtsArray = ptsRectstroke;
  112.     userOpsArray = opsRectstroke;
  113.     userOp = "ustroke";
  114.     rectOp = "rectstroke";
  115.     
  116.     [controlView setButtonTitle:STROKE];
  117.     [controlView setButtonEnable:YES];
  118.     [controlView  eraseTimes:self];
  119.  
  120.     return self;
  121. }
  122.  
  123. - setX:sender
  124. {
  125.     fontchar = 'c';
  126.     basicProc = "BX";
  127.     basicOp = "stroke";
  128.     userPtsArray = ptsX;
  129.     userOpsArray = opsX;
  130.     userOp = "ustroke";
  131.     rectOp = "pop";
  132.  
  133.     [controlView setButtonTitle:STROKE];
  134.     [controlView setButtonEnable:NO];
  135.     [controlView  eraseTimes:self];
  136.  
  137.     return self;
  138. }
  139.  
  140. - setCross:sender
  141. {
  142.     fontchar = 'd';
  143.     basicProc = "BC";
  144.     basicOp = "stroke";
  145.     userPtsArray = ptsCross;
  146.     userOpsArray = opsCross;
  147.     userOp = "ustroke";
  148.     rectOp = "pop";
  149.     
  150.     [controlView setButtonTitle:STROKE];
  151.     [controlView setButtonEnable:NO];
  152.     [controlView  eraseTimes:self];
  153.  
  154.     return self;
  155. }
  156.  
  157. /* Sets a flag to use or not use the device space rounding techniques. */
  158. -deviceDependence:(BOOL) independent
  159. {
  160.     if (independent)
  161.         PSWSetIndependent();
  162.     else
  163.         PSWSetDependent();
  164.     
  165.     PSundefinefont(fontname);
  166.     PSWDefineFont(fontname);
  167. }
  168.  
  169. - selectFont:(int) fontsize;
  170. {
  171.     PSselectfont(fontname,  fontsize);
  172.  
  173.     return self;    
  174. }
  175.  
  176. /* These methods return the current values for the type of control point to draw. */
  177. - (char) getChar
  178. {
  179.     return fontchar;
  180. }
  181.  
  182. - (char *) getBasicProc
  183. {
  184.     return basicProc;
  185. }
  186.  
  187. - (char *) getBasicOp
  188. {
  189.     return basicOp;
  190. }
  191.  
  192. - (float *) getUserPtsArray
  193. {
  194.     return userPtsArray;
  195. }
  196.  
  197. - (char *) getUserOpsArray
  198. {
  199.     return userOpsArray;
  200. }
  201.  
  202. - (char *) getUserOp
  203. {
  204.     return userOp;
  205. }
  206.  
  207. - (char *) getRectOp
  208. {
  209.     return rectOp;
  210. }
  211.  
  212. /* Draws the contol point into a bit map. Uses the alpha to allow transparency. */
  213. - drawImage:imageId
  214. {
  215.     [imageId lockFocus];
  216.         PSgsave();
  217.             PSsetalpha(0.0);                /* Transparent */
  218.             PSsetgray(NX_WHITE);    
  219.             PSrectfill(0, 0, FIGURESIZE, FIGURESIZE);
  220.             PSsetalpha(1.0);                /* Opaque */
  221.             PSsetgray(NX_BLACK);
  222.             PSWBasic(FIGURESIZE/2, FIGURESIZE/2, basicProc, basicOp);
  223.         PSgrestore();
  224.     [imageId unlockFocus];
  225.  
  226.     return self;
  227. }
  228.  
  229. @end
  230.