home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / gnu / gs-2.6.1.4-src.lha / src / amiga / gs-2.6.1.4 / gxstroke.c < prev    next >
C/C++ Source or Header  |  1994-01-27  |  26KB  |  761 lines
  1. /* Copyright (C) 1989, 1992, 1993 Aladdin Enterprises.  All rights reserved.
  2.  
  3. This file is part of Ghostscript.
  4.  
  5. Ghostscript is distributed in the hope that it will be useful, but
  6. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  7. to anyone 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.  Refer
  9. to the Ghostscript General Public License for full details.
  10.  
  11. Everyone is granted permission to copy, modify and redistribute
  12. Ghostscript, but only under the conditions described in the Ghostscript
  13. General Public License.  A copy of this license is supposed to have been
  14. given to you along with Ghostscript so you can know your rights and
  15. responsibilities.  It should be in a file named COPYING.  Among other
  16. things, the copyright notice and this notice must be preserved on all
  17. copies.  */
  18.  
  19. /* gxstroke.c */
  20. /* Path stroking procedures for Ghostscript library */
  21. #include "math_.h"
  22. #include "gx.h"
  23. #include "gpcheck.h"
  24. #include "gserrors.h"
  25. #include "gxfixed.h"
  26. #include "gxarith.h"
  27. #include "gxmatrix.h"
  28. #include "gscoord.h"
  29. #include "gzstate.h"
  30. #include "gzdevice.h"
  31. #include "gzcolor.h"            /* requires gxdevice.h */
  32. #include "gzline.h"
  33. #include "gzpath.h"
  34.  
  35. /* Define the filling adjustment that actually produces no adjustment. */
  36. #define fill_no_adjust ((fixed)1)
  37.  
  38. /*
  39.  * Structure for a partial line (passed to the drawing routine).
  40.  * Two of these are required to do joins right.
  41.  * Each endpoint includes the two ends of the cap as well,
  42.  * and the deltas for square and round cap computation.
  43.  *
  44.  * The deltas (co, cdelta, ce) are in clockwise order in device space
  45.  * around the endpoint p: they are one-half the line width (suitably
  46.  * transformed) at 90 degrees counter-clockwise, straight ahead,
  47.  * and 90 degrees clockwise from the oriented line o->e,
  48.  * where "90 degrees" is measured in *user* coordinates.
  49.  * Note that the values at o are the negatives of the values at e.
  50.  *
  51.  * Initially, only o.p, e.p, e.cdelta, width, and thin are set.
  52.  * compute_caps fills in the rest.
  53.  */
  54. typedef gs_fixed_point _ss *p_ptr;
  55. typedef struct endpoint_s {
  56.     gs_fixed_point p;        /* the end of the line */
  57.     gs_fixed_point co, ce;        /* ends of the cap, p +/- width */
  58.     gs_fixed_point cdelta;        /* +/- cap length */
  59. } endpoint;
  60. typedef endpoint _ss *ep_ptr;
  61. typedef struct partial_line_s {
  62.     endpoint o;            /* starting coordinate */
  63.     endpoint e;            /* ending coordinate */
  64.     gs_fixed_point width;        /* one-half line width, see above */
  65.     int thin;            /* true if minimum-width line */
  66. } partial_line;
  67. typedef partial_line _ss *pl_ptr;
  68.  
  69. /* Procedures that stroke a partial_line (the first pl_ptr argument). */
  70. /* If both partial_lines are non-null, the procedure creates */
  71. /* an appropriate join; otherwise, the procedure creates an */
  72. /* end cap.  If the first int is 0, the procedure also starts with */
  73. /* an appropriate cap. */
  74. private int near stroke_add(P5(gx_path *, int, pl_ptr, pl_ptr, gs_state *));
  75. private int near stroke_fill(P5(gx_path *, int, pl_ptr, pl_ptr, gs_state *));
  76.  
  77. /* Other forward declarations */
  78. private int near stroke(P4(const gx_path *, gx_path *,
  79.   int near (*)(P5(gx_path *, int, pl_ptr, pl_ptr, gs_state *)),
  80.   gs_state *));
  81. private void near adjust_stroke(P2(pl_ptr, gs_state *));
  82. private int near expand_dashes(P3(const subpath *, gx_path *, gs_state *));
  83. private void near compute_caps(P1(pl_ptr));
  84. private int near add_capped(P4(gx_path *, gs_line_cap,
  85.   int (*)(P3(gx_path *, fixed, fixed)),
  86.   ep_ptr));
  87.  
  88. /* Stroke a path for drawing or saving */
  89. int
  90. gx_stroke_fill(const gx_path *ppath, gs_state *pgs)
  91. {    return stroke(ppath, (gx_path *)0, stroke_fill, pgs);
  92. }
  93. int
  94. gx_stroke_add(const gx_path *ppath, gx_path *to_path, gs_state *pgs)
  95. {    int code = stroke(ppath, to_path, stroke_add, pgs);
  96.     if ( code < 0 ) return code;
  97.     if ( !ppath->subpath_open && ppath->position_valid )
  98.         code = gx_path_add_point(to_path, ppath->position.x,
  99.                      ppath->position.y);
  100.     return code;
  101. }
  102.  
  103. /* Fill a partial stroked path. */
  104. /* Free variables: code, to_path, ppath, stroke_path_body, pgs, exit (label). */
  105. #define fill_stroke_path()\
  106. if(to_path==&stroke_path_body && !gx_path_is_void_inline(&stroke_path_body))\
  107. { code = gx_fill_path(to_path, pgs->dev_color, pgs, gx_rule_winding_number,\
  108.     fill_no_adjust);\
  109.   gx_path_release(to_path);\
  110.   if ( code < 0 ) goto exit;\
  111.   gx_path_init(to_path, ppath->memory_procs);\
  112. }
  113.  
  114. /* Stroke a path.  Call line_proc (stroke_add or stroke_fill) */
  115. /* for each line segment. */
  116. private int near
  117. stroke(const gx_path *ppath, gx_path *to_path,
  118.   int near (*line_proc)(P5(gx_path *, int, pl_ptr, pl_ptr, gs_state *)),
  119.   gs_state *pgs)
  120. {    const subpath *psub;
  121.     const subpath *save_psub = 0;
  122.     int code = 0;
  123.     const line_params *lp = pgs->line_params;
  124.     int dash_count = lp->dash.pattern_size;
  125.     gx_path fpath, dpath;
  126.     gx_path stroke_path_body;
  127.     float xx = pgs->ctm.xx, xy = pgs->ctm.xy;
  128.     float yx = pgs->ctm.yx, yy = pgs->ctm.yy;
  129.     int skewed = !is_fzero2(xy, yx);
  130.     int uniform = (skewed ? 0 : xx == yy ? 1 : xx == -yy ? -1 : 0);
  131.     /*
  132.      * We are dealing with a reflected coordinate system
  133.      * if (1,0) is counter-clockwise from (0,1).
  134.      * See the note in stroke_add for the algorithm.
  135.      */    
  136.     int reflected =
  137.       (uniform ? uniform > 0 :
  138.        skewed ? xy * yx < xx * yy :
  139.        (xx < 0) == (yy < 0));
  140.     float line_width = lp->width;    /* this is *half* the line width! */
  141.     int always_thin;
  142.     double line_width_and_scale, line_width_scale_xx;
  143. #ifdef DEBUG
  144. if ( gs_debug['o'] )
  145.    {    int count = lp->dash.pattern_size;
  146.     int i;
  147.     dprintf3("[o]half_width=%f, cap=%d, join=%d,\n",
  148.          lp->width, (int)lp->cap, (int)lp->join);
  149.     dprintf2("   miter_limit=%f, miter_check=%f,\n",
  150.          lp->miter_limit, lp->miter_check);
  151.     dprintf1("   dash pattern=%d", count);
  152.     for ( i = 0; i < count; i++ )
  153.         dprintf1(",%f", lp->dash.pattern[i]);
  154.     dprintf4(",\n   offset=%f, init(ink_on=%d, index=%d, dist_left=%f)\n",
  155.          lp->dash.offset, lp->dash.init_ink_on, lp->dash.init_index,
  156.          lp->dash.init_dist_left);
  157.    }
  158. #endif
  159.     if ( line_width < 0 ) line_width = -line_width;
  160.     if ( is_fzero(line_width) )
  161.         always_thin = 1;
  162.     else if ( !skewed )
  163.        {    float xxa = xx, yya = yy;
  164.         if ( xxa < 0 ) xxa = -xxa;
  165.         if ( yya < 0 ) yya = -yya;
  166.         always_thin = (max(xxa, yya) * line_width < 0.5);
  167.        }
  168.     else
  169.        {    /* The check is more complicated, but it's worth it. */
  170.         float xsq = xx * xx + xy * xy;
  171.         float ysq = yx * yx + yy * yy;
  172.         float cross = xx * yx + xy * yy;
  173.         if ( cross < 0 ) cross = 0;
  174.         always_thin =
  175.           ((max(xsq, ysq) + cross) * line_width * line_width < 0.5);
  176.        }
  177.     line_width_and_scale = line_width * (double)int2fixed(1);
  178.     if ( !always_thin && uniform )
  179.     {    /* Precompute a value we'll need later. */
  180.         line_width_scale_xx = line_width_and_scale * xx;
  181.         if ( line_width_scale_xx < 0 )
  182.           line_width_scale_xx = -line_width_scale_xx;
  183.     }
  184.     if_debug5('o', "[o]ctm=(%g,%g,%g,%g) thin=%d\n",
  185.           xx, xy, yx, yy, always_thin);
  186.     /* Start by flattening the path.  We should do this on-the-fly.... */
  187.     if ( !ppath->curve_count )    /* don't need to flatten */
  188.        {    psub = ppath->first_subpath;
  189.         if ( !psub ) return 0;
  190.        }
  191.     else
  192.        {    if ( (code = gx_path_flatten(ppath, &fpath, pgs->flatness, (int)pgs->in_cachedevice)) < 0 )
  193.            return code;
  194.         psub = fpath.first_subpath;
  195.        }
  196.     if ( dash_count )
  197.         gx_path_init(&dpath, ppath->memory_procs);
  198.     if ( to_path == 0 )
  199.     {    /* We might try to defer this if it's expensive.... */
  200.         to_path = &stroke_path_body;
  201.         gx_path_init(to_path, ppath->memory_procs);
  202.     }
  203.     for ( ; ; )
  204.      { const line_segment *pline;
  205.        fixed x, y;
  206.        partial_line pl, pl_prev, pl_first;
  207.        int first = 0;
  208.        int index = 0;
  209.        if ( !psub )
  210.         {    /* Might just be the end of a dash expansion. */
  211.         if ( save_psub )
  212.            {    gx_path_release(&dpath);
  213.             psub = (const subpath *)save_psub->last->next;
  214.             if ( !psub ) break;
  215.             gx_path_init(&dpath, ppath->memory_procs);
  216.             save_psub = 0;
  217.            }
  218.         else        /* all done */
  219.             break;
  220.         }
  221.        if ( dash_count && !save_psub )
  222.         {    code = expand_dashes(psub, &dpath, pgs);
  223.         if ( code < 0 ) goto exit;
  224.         save_psub = (subpath *)psub;
  225.         psub = dpath.first_subpath;
  226.         continue;        /* psub might be null */
  227.         }
  228.        pline = (const line_segment *)(psub->n