home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume6 / yahp2ps / part05 / penctrl.c < prev   
C/C++ Source or Header  |  1989-02-03  |  12KB  |  568 lines
  1. /*
  2.         HPGL to PostScript converter
  3.    Copyright (C) 1988 (and following) Federico Heinz
  4.  
  5. yahp2ps is distributed in the hope that it will be useful, but WITHOUT ANY
  6. WARRANTY.  No author or distributor accepts responsibility to anyone
  7. for the consequences of using it or for whether it serves any
  8. particular purpose or works at all, unless he says so in writing.
  9. Refer to the Free Software Foundation's General Public License for full details.
  10.  
  11. Everyone is granted permission to copy, modify and redistribute yahp2ps,
  12. but only under the conditions described in the GNU General Public
  13. License.  A copy of this license is supposed to have been given to you
  14. along with yahp2ps so you can know your rights and responsibilities.  It
  15. should be in a file named COPYING.  Among other things, the copyright
  16. notice and this notice must be preserved on all copies.
  17.  
  18. In other words, go ahead and share yahp2ps, but don't try to stop
  19. anyone else from sharing it farther.  Help stamp out software hoarding!
  20.  
  21. yahp2ps is TOTALLY unrelated to GNU or the Free Software Foundation,
  22. it is only released under the same conditions.
  23.  
  24.     For bug reports, wishes, etc. send e-mail to
  25.  
  26.     ...!mcvax!unido!tub!actisb!federico  (from Europe)
  27.     ...!uunet!pyramid!actisb!federico    (from anywhere else)
  28.  
  29.     For Physical mail:
  30.  
  31.     Federico Heinz
  32.     Beusselstr. 21
  33.     1000 Berlin 21
  34.  
  35.     Tel. (+49 30) 396 77 92
  36.  
  37. */
  38.  
  39. /***************************************************************************
  40.  
  41.   Primitive pen control routines. Provides the interface between the
  42.   ideal plotter and the machinery.
  43.  
  44. ****************************************************************************/
  45.  
  46. #include "defs.h"
  47. #include "mchinery.h"
  48. #include "penctrl.h"
  49. #include "circle.h"
  50. #include "tick.h"
  51. #include "io.h"
  52.  
  53.  
  54. /***************************************************************************
  55.  
  56.    Data defining the plotter's status.
  57.  
  58. ***************************************************************************/
  59.  
  60.  
  61.                     /* Current plotting pen's coordinates */
  62. CoordinatePair PenPosition = { Zero, Zero };
  63.  
  64.                                      /* Pn's position in User Space */
  65. static CoordinatePair UserP1, UserP2;
  66.  
  67.                                      /* Pn's coords in Plotter Space */
  68. CoordinatePair PlotterP1, PlotterP2;
  69.  
  70.                      /* P1-P2 distance              */
  71. Number      P1P2Diagonal;
  72.  
  73.                      /* Size of paper in use        */
  74. static int        PaperSize = A4;
  75.  
  76. static Number LineType;            /* Line type used for stroking */
  77. static Number LinePatternLength;   /* Length of a pattern cicle   */
  78. static Number PenHeld = Zero;      /* Pen we're holding           */
  79.  
  80.  
  81.        Boolean UserMode = False;     /* Plotting in User Space?           */
  82. static Boolean Rotated = False;      /* Is the plot rotated 90 degrees?   */
  83.        Boolean PenIsUp = True;       /* Is the plotting pen up?           */
  84. static Boolean LineDrawn = False;    /* Have we drawn a line?          */
  85.  
  86. CoordinatePair FurthestPoint[] = { { MaxXA,  MaxYA },
  87.                                    { MaxXA4, MaxYA4 },
  88.                                    { MaxXB,  MaxYB },
  89.                                    { MaxXA3, MaxXA3 } };
  90.  
  91. CoordinatePair FurthestPointRotated[] =
  92.                                  { { MaxYA,  MaxXA },
  93.                                    { MaxYA4, MaxXA4 },
  94.                                    { MaxYB,  MaxXB },
  95.                                    { MaxXA3, MaxXA3 } };
  96.  
  97. CoordinatePair DefaultP1[] = { {InitialP1XA,  InitialP1YA},
  98.                    {InitialP1XA4, InitialP1YA4},
  99.                    {InitialP1XB,  InitialP1YB},
  100.                    {InitialP1XA3, InitialP1YA3} };
  101.  
  102. CoordinatePair DefaultP2[] = { {InitialP2XA,  InitialP2YA},
  103.                    {InitialP2XA4, InitialP2YA4},
  104.                    {InitialP2XB,  InitialP2YB},
  105.                    {InitialP2XA3, InitialP2YA3} };
  106.  
  107. CoordinatePair DefaultP1Rotated[] =
  108.                              { {InitialP1XAR,  InitialP1YAR},
  109.                    {InitialP1XA4R, InitialP1YA4R},
  110.                    {InitialP1XBR,  InitialP1YBR},
  111.                    {InitialP1XA3R, InitialP1YA3R} };
  112.  
  113. CoordinatePair DefaultP2Rotated[] =
  114.                              { {InitialP2XAR,  InitialP2YAR},
  115.                    {InitialP2XA4R, InitialP2YA4R},
  116.                    {InitialP2XBR,  InitialP2YBR},
  117.                    {InitialP2XA3R, InitialP2YA3R} };
  118.  
  119.  
  120. /**************************************************************************
  121.  
  122.    Paper size.
  123.  
  124. /*************************************************************************/
  125.  
  126.  
  127. void changePaperSize(newPaperSize)
  128.  
  129. int newPaperSize;
  130.  
  131. { PaperSize = newPaperSize; }
  132.  
  133.  
  134.  
  135. /***************************************************************************
  136.  
  137.    Pen changing.
  138.  
  139. ***************************************************************************/
  140.  
  141. /*
  142.  
  143.   Each pen's width and color.
  144.  
  145. */
  146.   
  147. static Number PenWidth[MaxPen/One] = { 2500, 3500, 5000,
  148.                        7500, 10000, 20000 };
  149. static Number PenColor[MaxPen/One] = { Zero, Zero, Zero, Zero, Zero, Zero };
  150.  
  151.  
  152.  
  153. /*
  154.  
  155.   Change the pen sizes.
  156.  
  157. */
  158.  
  159. void getPenSizes(string)
  160.  
  161. char *string;
  162.  
  163. { int i;
  164.  
  165.   i = 0;
  166.   while (*string && (i < (MaxPen/One)))
  167.     if (!ASCIIToNumber(&PenWidth[i++], &string))
  168.       error("Illegal pen width.");
  169. }
  170.  
  171.  
  172.  
  173. /*
  174.  
  175.   Get a new pen
  176.  
  177.  */
  178.  
  179. void changePen(pen)
  180.  
  181. Number pen;
  182.  
  183. { Boolean penWasDown;
  184.   int oldPen;
  185.  
  186.   if (pen == PenHeld)
  187.     return;
  188.   if ((penWasDown = !PenIsUp)) liftPen();
  189.   if ((pen > Zero) && (pen <= MaxPen))
  190.   { oldPen = (PenHeld/One) - 1;
  191.     PenHeld = pen;
  192.     pen = (pen / One ) - 1;
  193.     if (PenWidth[pen] != PenWidth[oldPen])
  194.       setPenWidth(PenWidth[pen]);
  195.     if (PenColor[pen] != PenColor[oldPen])
  196.       setPenColor(PenColor[pen]);
  197.   }
  198.   else if (!pen)
  199.     PenHeld = Zero;
  200.   else
  201.     warning("Pen number out of range.");
  202.   if (penWasDown) lowerPen();
  203. }
  204.  
  205.  
  206.  
  207. /*
  208.  
  209.   Update the pattern to new parameters.
  210.  
  211. */
  212.  
  213. static void updateLinePattern()
  214.  
  215. { Boolean penWasDown;
  216.  
  217.   if ((penWasDown = !PenIsUp)) liftPen();
  218.   setPattern(LineType, mulNum(LinePatternLength, P1P2Diagonal)/100);
  219.   if (penWasDown) lowerPen();
  220. }
  221.  
  222.  
  223.  
  224. /*
  225.  
  226.   Change the line pattern
  227.  
  228.  */
  229.  
  230. void setDash(pattern, patternLength)
  231.  
  232. Number pattern, patternLength;
  233.  
  234. { Boolean penWasDown;
  235.  
  236.   if ((LineType == pattern) &&
  237.       ((patternLength <= 0) ||
  238.        (patternLength >= (128*One)) ||
  239.        (patternLength == LinePatternLength)))
  240.     return;
  241.   if ((patternLength > 0) && (patternLength < (128*One)))
  242.     LinePatternLength = patternLength;
  243.   LineType = pattern;
  244.   updateLinePattern();
  245. }
  246.  
  247.  
  248.  
  249. /**************************************************************************
  250.  
  251.    Clipping rectangle.
  252.  
  253. **************************************************************************/
  254.  
  255. static CoordinatePair Origin = { Zero, Zero };
  256.  
  257.  
  258. /*
  259.  
  260.   Set a new clipping rectangle.
  261.  
  262. */
  263.  
  264. void setWindow(corner1, corner2)
  265.  
  266. CoordinatePair corner1, corner2;
  267.  
  268. { setClip(corner1, corner2); }
  269.  
  270.  
  271.  
  272. /*
  273.  
  274.   Set the clipping rectangle to the whole plotting area.
  275.  
  276. */
  277.  
  278. void resetWindow()
  279.  
  280. { 
  281.   if (Rotated)
  282.     setWindow(Origin, FurthestPointRotated[PaperSize]);
  283.   else
  284.     setWindow(Origin, FurthestPoint[PaperSize]);
  285. }
  286.  
  287.  
  288.  
  289. /**************************************************************************
  290.  
  291.   Scaling of User Space.
  292.  
  293. **************************************************************************/
  294.  
  295.  
  296. /* Parameters for scaling */
  297.  
  298. Number XScaleFactor = One, YScaleFactor = One;
  299. Number XOrigin = Zero, YOrigin = Zero;
  300.  
  301.  
  302.  
  303. /*
  304.  
  305.   Convert from plotter coordinates to user coordinates.
  306.  
  307. */
  308.  
  309. static void plotterToUser(target, plotterPoint)
  310.  
  311. CoordinatePair target, plotterPoint;
  312.  
  313. {
  314.   target[X] = divNum(plotterPoint[X] - XOrigin, XScaleFactor);
  315.   target[Y] = divNum(plotterPoint[Y] - YOrigin, YScaleFactor);
  316. }
  317.  
  318.  
  319.  
  320. /*
  321.  
  322.   Set the scaling parameters to the appropriate values.
  323.  
  324. */
  325.  
  326. void updateScaling()
  327.  
  328. { CoordinatePair plotterPenPosition;
  329.  
  330.   if (UserMode)
  331.   { plotterPenPosition[X] = plotterXCoord(PenPosition[X]);
  332.     plotterPenPosition[Y] = plotterYCoord(PenPosition[Y]);
  333.     XScaleFactor = divNum((PlotterP2[X] - PlotterP1[X]),
  334.                           (UserP2[X] - UserP1[X]));
  335.     XOrigin = PlotterP1[X] - mulNum(XScaleFactor, UserP1[X]);
  336.     YScaleFactor = divNum((PlotterP2[Y] - PlotterP1[Y]),
  337.                           (UserP2[Y] - UserP1[Y]));
  338.     YOrigin = PlotterP1[Y] - mulNum(YScaleFactor, UserP1[Y]);
  339.     plotterToUser(PenPosition, plotterPenPosition);
  340.   }
  341. }
  342.  
  343.  
  344.  
  345. /*
  346.  
  347.   From now on, coordinates won't be scaled any more.
  348.  
  349. */
  350.  
  351. void turnScalingOff()
  352.  
  353. { PenPosition[X] = plotterXCoord(PenPosition[X]);
  354.   PenPosition[Y] = plotterYCoord(PenPosition[Y]);
  355.   UserMode = False;
  356. }
  357.  
  358.  
  359.  
  360. /*
  361.  
  362.   From now on, coordinates will be scaled according to the user's taste.
  363.  
  364. */
  365.  
  366. void turnScalingOn(newUserP1, newUserP2)
  367.  
  368. CoordinatePair newUserP1, newUserP2;
  369.  
  370. { if ((newUserP1[X] == newUserP2[X]) || (newUserP1[Y] == newUserP2[Y]))
  371.     warning("Invalid scale parameters.");
  372.   else
  373.   { UserMode = True;
  374.     UserP1[X] = newUserP1[X];
  375.     UserP1[Y] = newUserP1[Y];
  376.     UserP2[X] = newUserP2[X];
  377.     UserP2[Y] = newUserP2[Y];
  378.     updateScaling();
  379.   }
  380. }
  381.  
  382.  
  383.  
  384. /*
  385.  
  386.   Change the scaling points and update everything needed.
  387.  
  388. */
  389.  
  390. void changeP1P2(newP1, newP2)
  391.  
  392. CoordinatePair newP1, newP2;
  393.  
  394. { Number dummy;
  395.   CoordinatePair delta;
  396.   
  397.   PlotterP1[X] = newP1[X];
  398.   PlotterP1[Y] = newP1[Y];
  399.   PlotterP2[X] = newP2[X];
  400.   PlotterP2[Y] = newP2[Y];
  401.   delta[X] = PlotterP2[X] - PlotterP1[X];
  402.   delta[Y] = PlotterP2[Y] - PlotterP1[Y];
  403.   cartesianToPolar(&P1P2Diagonal, &dummy, delta);
  404.   updateScaling();
  405.   updateTicks();
  406.   updateLinePattern();
  407. }
  408.  
  409.  
  410.  
  411. /*
  412.  
  413.   Rotate the coordinate system.
  414.  
  415. */
  416.  
  417. void rotate()
  418.  
  419. { CoordinatePair plotterPenPosition;
  420.   
  421.   if (!Rotated)
  422.   { plotterPenPosition[Y] = plotterXCoord(PenPosition[X]);
  423.     plotterPenPosition[X] = FurthestPoint[PaperSize][Y] -
  424.                                 plotterYCoord(PenPosition[Y]);
  425.     plotterToUser(PenPosition, plotterPenPosition);
  426.     doRotation();
  427.     correctClip();
  428.     Rotated = True;
  429.   }
  430. }
  431.  
  432.  
  433.  
  434. /*
  435.  
  436.   Return paper to default orientation.
  437.  
  438. */
  439.  
  440. void unRotate()
  441.  
  442. { CoordinatePair plotterPenPosition;
  443.   
  444.   if (Rotated)
  445.   { plotterPenPosition[X] = plotterYCoord(PenPosition[Y]);
  446.     plotterPenPosition[Y] = FurthestPoint[PaperSize][Y] -
  447.                                 plotterXCoord(PenPosition[X]);
  448.     plotterToUser(PenPosition, plotterPenPosition);
  449.     undoRotation();
  450.     correctClip();
  451.     Rotated = False;
  452.   }
  453. }
  454.  
  455.  
  456. /**************************************************************************
  457.  
  458.   Plotter status initialization.
  459.  
  460. **************************************************************************/
  461.  
  462.  
  463.  
  464. /*
  465.  
  466.   Set the scaling points to the default values.
  467.  
  468. */
  469.  
  470. void resetP1P2()
  471.  
  472. { if (Rotated)
  473.     changeP1P2(DefaultP1Rotated[PaperSize], DefaultP2Rotated[PaperSize]);
  474.   else
  475.     changeP1P2(DefaultP1[PaperSize], DefaultP2[PaperSize]);
  476. }
  477.  
  478.  
  479. /*
  480.  
  481.   Set default parameters of this module's stuff.
  482.  
  483. */
  484.  
  485. void penctrlInit()
  486.  
  487. { liftPen();
  488.   resetP1P2();
  489.   unRotate();
  490. }
  491.  
  492.  
  493.  
  494. /**************************************************************************
  495.  
  496.   Moving the pen around.
  497.  
  498. **************************************************************************/
  499.  
  500.  
  501.  
  502. /*
  503.  
  504.   Move the logical pen in it's current state to some place in User Space.
  505.  
  506. */
  507.  
  508. void doLine(targetX, targetY)
  509.  
  510. Number targetX, targetY;
  511.  
  512. { Number absoluteTargetX, absoluteTargetY;
  513.  
  514.   if (!PenIsUp && PenHeld)
  515.   { LineDrawn = True; 
  516.     if (LineType)
  517.       drawLine(plotterXCoord(targetX),
  518.                plotterYCoord(targetY));
  519.     else            /* Linetype 0: just dots at coords */
  520.     { liftPen();
  521.       PenPosition[X] = targetX;
  522.       PenPosition[Y] = targetY;
  523.       lowerPen();
  524.       return;
  525.     }
  526.   }
  527.   PenPosition[X] = targetX;
  528.   PenPosition[Y] = targetY;
  529. }
  530.  
  531.  
  532.  
  533. /*
  534.  
  535.   Lift the plotting pen.
  536.  
  537. */
  538.  
  539. void liftPen()
  540.  
  541. { if (!PenIsUp)
  542.   { if (LineDrawn)
  543.       LineDrawn = False;
  544.     else
  545.       if (PenHeld)
  546.         drawDot();
  547.     stroke();
  548.     PenIsUp = True;
  549.   }
  550. }
  551.  
  552.  
  553.  
  554. /*
  555.  
  556.   Lower the plotting pen. At least a dot is plotted.
  557.  
  558. */
  559.  
  560. void lowerPen()
  561.  
  562. { if (PenIsUp)
  563.   { setCurrentPoint(plotterXCoord(PenPosition[X]),
  564.                     plotterYCoord(PenPosition[Y]));
  565.     PenIsUp = False;
  566.   }
  567. }
  568.