View Javadoc
1   /*
2    * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.  Oracle designates this
8    * particular file as subject to the "Classpath" exception as provided
9    * by Oracle in the LICENSE file that accompanied this code.
10   *
11   * This code is distributed in the hope that it will be useful, but WITHOUT
12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14   * version 2 for more details (a copy is included in the LICENSE file that
15   * accompanied this code).
16   *
17   * You should have received a copy of the GNU General Public License version
18   * 2 along with this work; if not, write to the Free Software Foundation,
19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20   *
21   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22   * or visit www.oracle.com if you need additional information or have any
23   * questions.
24   */
25  
26  package sun.java2d.pipe;
27  
28  import java.awt.Shape;
29  import java.awt.BasicStroke;
30  import java.awt.geom.Line2D;
31  import java.awt.geom.Rectangle2D;
32  import java.awt.geom.AffineTransform;
33  import sun.java2d.SunGraphics2D;
34  import sun.awt.SunHints;
35  
36  /**
37   * This class converts calls to the basic pixel rendering methods
38   * into calls to the methods on a ParallelogramPipe.
39   * Most calls are transformed into calls to the fill(Shape) method
40   * by the parent PixelToShapeConverter class, but some calls are
41   * transformed into calls to fill/drawParallelogram().
42   */
43  public class PixelToParallelogramConverter extends PixelToShapeConverter
44      implements ShapeDrawPipe
45  {
46      ParallelogramPipe outrenderer;
47      double minPenSize;
48      double normPosition;
49      double normRoundingBias;
50      boolean adjustfill;
51  
52      /**
53       * @param shapepipe pipeline to forward shape calls to
54       * @param pgrampipe pipeline to forward parallelogram calls to
55       *                  (and drawLine calls if possible)
56       * @param minPenSize minimum pen size for dropout control
57       * @param normPosition sub-pixel location to normalize endpoints
58       *                     for STROKE_NORMALIZE cases
59       * @param adjustFill boolean to control whethere normalization
60       *                   constants are also applied to fill operations
61       *                   (normally true for non-AA, false for AA)
62       */
63      public PixelToParallelogramConverter(ShapeDrawPipe shapepipe,
64                                           ParallelogramPipe pgrampipe,
65                                           double minPenSize,
66                                           double normPosition,
67                                           boolean adjustfill)
68      {
69          super(shapepipe);
70          outrenderer = pgrampipe;
71          this.minPenSize = minPenSize;
72          this.normPosition = normPosition;
73          this.normRoundingBias = 0.5 - normPosition;
74          this.adjustfill = adjustfill;
75      }
76  
77      public void drawLine(SunGraphics2D sg2d,
78                           int x1, int y1, int x2, int y2)
79      {
80          if (!drawGeneralLine(sg2d, x1, y1, x2, y2)) {
81              super.drawLine(sg2d, x1, y1, x2, y2);
82          }
83      }
84  
85      public void drawRect(SunGraphics2D sg2d,
86                           int x, int y, int w, int h)
87      {
88          if (w >= 0 && h >= 0) {
89              if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM) {
90                  BasicStroke bs = ((BasicStroke) sg2d.stroke);
91                  if (w > 0 && h > 0) {
92                      if (bs.getLineJoin() == BasicStroke.JOIN_MITER &&
93                          bs.getDashArray() == null)
94                      {
95                          double lw = bs.getLineWidth();
96                          drawRectangle(sg2d, x, y, w, h, lw);
97                          return;
98                      }
99                  } else {
100                     // Note: This calls the integer version which
101                     // will verify that the local drawLine optimizations
102                     // work and call super.drawLine(), if not.
103                     drawLine(sg2d, x, y, x+w, y+h);
104                     return;
105                 }
106             }
107             super.drawRect(sg2d, x, y, w, h);
108         }
109     }
110 
111     public void fillRect(SunGraphics2D sg2d,
112                          int x, int y, int w, int h)
113     {
114         if (w > 0 && h > 0) {
115             fillRectangle(sg2d, x, y, w, h);
116         }
117     }
118 
119     public void draw(SunGraphics2D sg2d, Shape s) {
120         if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM) {
121             BasicStroke bs = ((BasicStroke) sg2d.stroke);
122             if (s instanceof Rectangle2D) {
123                 if (bs.getLineJoin() == BasicStroke.JOIN_MITER &&
124                     bs.getDashArray() == null)
125                 {
126                     Rectangle2D r2d = (Rectangle2D) s;
127                     double w = r2d.getWidth();
128                     double h = r2d.getHeight();
129                     double x = r2d.getX();
130                     double y = r2d.getY();
131                     if (w >= 0 && h >= 0) {
132                         double lw = bs.getLineWidth();
133                         drawRectangle(sg2d, x, y, w, h, lw);
134                     }
135                     return;
136                 }
137             } else if (s instanceof Line2D) {
138                 Line2D l2d = (Line2D) s;
139                 if (drawGeneralLine(sg2d,
140                                     l2d.getX1(), l2d.getY1(),
141                                     l2d.getX2(), l2d.getY2()))
142                 {
143                     return;
144                 }
145             }
146         }
147 
148         outpipe.draw(sg2d, s);
149     }
150 
151     public void fill(SunGraphics2D sg2d, Shape s) {
152         if (s instanceof Rectangle2D) {
153             Rectangle2D r2d = (Rectangle2D) s;
154             double w = r2d.getWidth();
155             double h = r2d.getHeight();
156             if (w > 0 && h > 0) {
157                 double x = r2d.getX();
158                 double y = r2d.getY();
159                 fillRectangle(sg2d, x, y, w, h);
160             }
161             return;
162         }
163 
164         outpipe.fill(sg2d, s);
165     }
166 
167     static double len(double x, double y) {
168         return ((x == 0) ? Math.abs(y)
169                 : ((y == 0) ? Math.abs(x)
170                    : Math.sqrt(x * x + y * y)));
171     }
172 
173     double normalize(double v) {
174         return Math.floor(v + normRoundingBias) + normPosition;
175     }
176 
177     public boolean drawGeneralLine(SunGraphics2D sg2d,
178                                    double ux1, double uy1,
179                                    double ux2, double uy2)
180     {
181         if (sg2d.strokeState == SunGraphics2D.STROKE_CUSTOM ||
182             sg2d.strokeState == SunGraphics2D.STROKE_THINDASHED)
183         {
184             return false;
185         }
186         BasicStroke bs = (BasicStroke) sg2d.stroke;
187         int cap = bs.getEndCap();
188         if (cap == BasicStroke.CAP_ROUND || bs.getDashArray() != null) {
189             // TODO: we could construct the GeneralPath directly
190             // for CAP_ROUND and save a lot of processing in that case...
191             // And again, we would need to deal with dropout control...
192             return false;
193         }
194         double lw = bs.getLineWidth();
195         // Save the original dx, dy in case we need it to transform
196         // the linewidth as a perpendicular vector below
197         double dx = ux2 - ux1;
198         double dy = uy2 - uy1;
199         double x1, y1, x2, y2;
200         switch (sg2d.transformState) {
201         case SunGraphics2D.TRANSFORM_GENERIC:
202         case SunGraphics2D.TRANSFORM_TRANSLATESCALE:
203             {
204                 double coords[] = {ux1, uy1, ux2, uy2};
205                 sg2d.transform.transform(coords, 0, coords, 0, 2);
206                 x1 = coords[0];
207                 y1 = coords[1];
208                 x2 = coords[2];
209                 y2 = coords[3];
210             }
211             break;
212         case SunGraphics2D.TRANSFORM_ANY_TRANSLATE:
213         case SunGraphics2D.TRANSFORM_INT_TRANSLATE:
214             {
215                 double tx = sg2d.transform.getTranslateX();
216                 double ty = sg2d.transform.getTranslateY();
217                 x1 = ux1 + tx;
218                 y1 = uy1 + ty;
219                 x2 = ux2 + tx;
220                 y2 = uy2 + ty;
221             }
222             break;
223         case SunGraphics2D.TRANSFORM_ISIDENT:
224             x1 = ux1;
225             y1 = uy1;
226             x2 = ux2;
227             y2 = uy2;
228             break;
229         default:
230             throw new InternalError("unknown TRANSFORM state...");
231         }
232         if (sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE) {
233             if (sg2d.strokeState == SunGraphics2D.STROKE_THIN &&
234                 outrenderer instanceof PixelDrawPipe)
235             {
236                 // PixelDrawPipes will add sg2d.transXY so we need to factor
237                 // that out...
238                 int ix1 = (int) Math.floor(x1 - sg2d.transX);
239                 int iy1 = (int) Math.floor(y1 - sg2d.transY);
240                 int ix2 = (int) Math.floor(x2 - sg2d.transX);
241                 int iy2 = (int) Math.floor(y2 - sg2d.transY);
242                 ((PixelDrawPipe)outrenderer).drawLine(sg2d, ix1, iy1, ix2, iy2);
243                 return true;
244             }
245             x1 = normalize(x1);
246             y1 = normalize(y1);
247             x2 = normalize(x2);
248             y2 = normalize(y2);
249         }
250         if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
251             // Transform the linewidth...
252             // calculate the scaling factor for a unit vector
253             // perpendicular to the original user space line.
254             double len = len(dx, dy);
255             if (len == 0) {
256                 dx = len = 1;
257                 // dy = 0; already
258             }
259             // delta transform the transposed (90 degree rotated) unit vector
260             double unitvector[] = {dy/len, -dx/len};
261             sg2d.transform.deltaTransform(unitvector, 0, unitvector, 0, 1);
262             lw *= len(unitvector[0], unitvector[1]);
263         }
264         lw = Math.max(lw, minPenSize);
265         dx = x2 - x1;
266         dy = y2 - y1;
267         double len = len(dx, dy);
268         double udx, udy;
269         if (len == 0) {
270             if (cap == BasicStroke.CAP_BUTT) {
271                 return true;
272             }
273             udx = lw;
274             udy = 0;
275         } else {
276             udx = lw * dx / len;
277             udy = lw * dy / len;
278         }
279         double px = x1 + udy / 2.0;
280         double py = y1 - udx / 2.0;
281         if (cap == BasicStroke.CAP_SQUARE) {
282             px -= udx / 2.0;
283             py -= udy / 2.0;
284             dx += udx;
285             dy += udy;
286         }
287         outrenderer.fillParallelogram(sg2d, ux1, uy1, ux2, uy2,
288                                       px, py, -udy, udx, dx, dy);
289         return true;
290     }
291 
292     public void fillRectangle(SunGraphics2D sg2d,
293                               double rx, double ry,
294                               double rw, double rh)
295     {
296         double px, py;
297         double dx1, dy1, dx2, dy2;
298         AffineTransform txform = sg2d.transform;
299         dx1 = txform.getScaleX();
300         dy1 = txform.getShearY();
301         dx2 = txform.getShearX();
302         dy2 = txform.getScaleY();
303         px = rx * dx1 + ry * dx2 + txform.getTranslateX();
304         py = rx * dy1 + ry * dy2 + txform.getTranslateY();
305         dx1 *= rw;
306         dy1 *= rw;
307         dx2 *= rh;
308         dy2 *= rh;
309         if (adjustfill &&
310             sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM &&
311             sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE)
312         {
313             double newx = normalize(px);
314             double newy = normalize(py);
315             dx1 = normalize(px + dx1) - newx;
316             dy1 = normalize(py + dy1) - newy;
317             dx2 = normalize(px + dx2) - newx;
318             dy2 = normalize(py + dy2) - newy;
319             px = newx;
320             py = newy;
321         }
322         outrenderer.fillParallelogram(sg2d, rx, ry, rx+rw, ry+rh,
323                                       px, py, dx1, dy1, dx2, dy2);
324     }
325 
326     public void drawRectangle(SunGraphics2D sg2d,
327                               double rx, double ry,
328                               double rw, double rh,
329                               double lw)
330     {
331         double px, py;
332         double dx1, dy1, dx2, dy2;
333         double lw1, lw2;
334         AffineTransform txform = sg2d.transform;
335         dx1 = txform.getScaleX();
336         dy1 = txform.getShearY();
337         dx2 = txform.getShearX();
338         dy2 = txform.getScaleY();
339         px = rx * dx1 + ry * dx2 + txform.getTranslateX();
340         py = rx * dy1 + ry * dy2 + txform.getTranslateY();
341         // lw along dx1,dy1 scale by transformed length of dx2,dy2 vectors
342         // and vice versa
343         lw1 = len(dx1, dy1) * lw;
344         lw2 = len(dx2, dy2) * lw;
345         dx1 *= rw;
346         dy1 *= rw;
347         dx2 *= rh;
348         dy2 *= rh;
349         if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM &&
350             sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE)
351         {
352             double newx = normalize(px);
353             double newy = normalize(py);
354             dx1 = normalize(px + dx1) - newx;
355             dy1 = normalize(py + dy1) - newy;
356             dx2 = normalize(px + dx2) - newx;
357             dy2 = normalize(py + dy2) - newy;
358             px = newx;
359             py = newy;
360         }
361         lw1 = Math.max(lw1, minPenSize);
362         lw2 = Math.max(lw2, minPenSize);
363         double len1 = len(dx1, dy1);
364         double len2 = len(dx2, dy2);
365         if (lw1 >= len1 || lw2 >= len2) {
366             // The line widths are large enough to consume the
367             // entire hole in the middle of the parallelogram
368             // so we can just fill the outer parallelogram.
369             fillOuterParallelogram(sg2d,
370                                    rx, ry, rx+rw, ry+rh,
371                                    px, py, dx1, dy1, dx2, dy2,
372                                    len1, len2, lw1, lw2);
373         } else {
374             outrenderer.drawParallelogram(sg2d,
375                                           rx, ry, rx+rw, ry+rh,
376                                           px, py, dx1, dy1, dx2, dy2,
377                                           lw1 / len1, lw2 / len2);
378         }
379     }
380 
381     /**
382      * This utility function handles the case where a drawRectangle
383      * operation discovered that the interior hole in the rectangle
384      * or parallelogram has been completely filled in by the stroke
385      * width.  It calculates the outer parallelogram of the stroke
386      * and issues a single fillParallelogram request to fill it.
387      */
388     public void fillOuterParallelogram(SunGraphics2D sg2d,
389                                        double ux1, double uy1,
390                                        double ux2, double uy2,
391                                        double px, double py,
392                                        double dx1, double dy1,
393                                        double dx2, double dy2,
394                                        double len1, double len2,
395                                        double lw1, double lw2)
396     {
397         double udx1 = dx1 / len1;
398         double udy1 = dy1 / len1;
399         double udx2 = dx2 / len2;
400         double udy2 = dy2 / len2;
401         if (len1 == 0) {
402             // len1 is 0, replace udxy1 with perpendicular of udxy2
403             if (len2 == 0) {
404                 // both are 0, use a unit Y vector for udxy2
405                 udx2 = 0;
406                 udy2 = 1;
407             }
408             udx1 = udy2;
409             udy1 = -udx2;
410         } else if (len2 == 0) {
411             // len2 is 0, replace udxy2 with perpendicular of udxy1
412             udx2 = udy1;
413             udy2 = -udx1;
414         }
415         udx1 *= lw1;
416         udy1 *= lw1;
417         udx2 *= lw2;
418         udy2 *= lw2;
419         px -= (udx1 + udx2) / 2;
420         py -= (udy1 + udy2) / 2;
421         dx1 += udx1;
422         dy1 += udy1;
423         dx2 += udx2;
424         dy2 += udy2;
425 
426         outrenderer.fillParallelogram(sg2d, ux1, uy1, ux2, uy2,
427                                       px, py, dx1, dy1, dx2, dy2);
428     }
429 }