LinearGradientPaintContext


1   /*
2    * @(#)LinearGradientPaintContext.java  1.2 06/04/24
3    *
4    * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
5    * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6    */
7   
8   package java.awt;
9   
10  import java.awt.MultipleGradientPaint.CycleMethod  ;
11  import java.awt.MultipleGradientPaint.ColorSpaceType  ;
12  import java.awt.geom.AffineTransform  ;
13  import java.awt.geom.Point2D  ;
14  import java.awt.geom.Rectangle2D  ;
15  import java.awt.image.ColorModel  ;
16  
17  /**
18   * Provides the actual implementation for the LinearGradientPaint.
19   * This is where the pixel processing is done.
20   * 
21   * @see java.awt.LinearGradientPaint
22   * @see java.awt.PaintContext
23   * @see java.awt.Paint
24   * @author Nicholas Talian, Vincent Hardy, Jim Graham, Jerry Evans
25   */
26  final class LinearGradientPaintContext extends MultipleGradientPaintContext   {
27      
28      /**
29       * The following invariants are used to process the gradient value from 
30       * a device space coordinate, (X, Y):
31       *     g(X, Y) = dgdX*X + dgdY*Y + gc
32       */
33      private float dgdX, dgdY, gc;    
34             
35      /** 
36       * Constructor for LinearGradientPaintContext.
37       *
38       * @param paint the {@code LinearGradientPaint} from which this context
39       *              is created
40       * @param cm {@code ColorModel} that receives
41       *           the <code>Paint</code> data. This is used only as a hint.
42       * @param deviceBounds the device space bounding box of the 
43       *                     graphics primitive being rendered
44       * @param userBounds the user space bounding box of the 
45       *                   graphics primitive being rendered
46       * @param t the {@code AffineTransform} from user
47       *          space into device space (gradientTransform should be 
48       *          concatenated with this)
49       * @param hints the hints that the context object uses to choose
50       *              between rendering alternatives
51       * @param dStart gradient start point, in user space
52       * @param dEnd gradient end point, in user space
53       * @param fractions the fractions specifying the gradient distribution
54       * @param colors the gradient colors
55       * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
56       * @param colorSpace which colorspace to use for interpolation, 
57       *                   either SRGB or LINEAR_RGB
58       */
59      LinearGradientPaintContext(LinearGradientPaint   paint,
60                                 ColorModel   cm,
61                                 Rectangle   deviceBounds,
62                                 Rectangle2D   userBounds,
63                                 AffineTransform   t,
64                                 RenderingHints   hints,
65                                 Point2D   start,
66                                 Point2D   end,
67                                 float[] fractions,
68                                 Color  [] colors, 
69                                 CycleMethod cycleMethod,
70                                 ColorSpaceType colorSpace)
71      {        
72          super(paint, cm, deviceBounds, userBounds, t, hints, fractions,
73                colors, cycleMethod, colorSpace);
74  
75          // A given point in the raster should take on the same color as its
76          // projection onto the gradient vector.
77          // Thus, we want the projection of the current position vector
78          // onto the gradient vector, then normalized with respect to the
79          // length of the gradient vector, giving a value which can be mapped
80          // into the range 0-1.
81          //    projection =
82          //        currentVector dot gradientVector / length(gradientVector)
83          //    normalized = projection / length(gradientVector)
84  
85          float startx = (float)start.getX();
86          float starty = (float)start.getY();
87          float endx = (float)end.getX();
88          float endy = (float)end.getY();
89  
90          float dx = endx - startx;  // change in x from start to end
91          float dy = endy - starty;  // change in y from start to end
92          float dSq = dx*dx + dy*dy; // total distance squared
93          
94          // avoid repeated calculations by doing these divides once
95          float constX = dx/dSq;
96          float constY = dy/dSq;
97  
98          // incremental change along gradient for +x
99          dgdX = a00*constX + a10*constY;
100         // incremental change along gradient for +y
101         dgdY = a01*constX + a11*constY;
102 
103         // constant, incorporates the translation components from the matrix
104         gc = (a02-startx)*constX + (a12-starty)*constY;
105     }
106 
107     /**
108      * Return a Raster containing the colors generated for the graphics
109      * operation.  This is where the area is filled with colors distributed
110      * linearly.
111      *
112      * @param x,y,w,h the area in device space for which colors are
113      * generated.
114      */
115     protected void fillRaster(int[] pixels, int off, int adjust, 
116                               int x, int y, int w, int h)
117     {
118         // current value for row gradients
119         float g = 0;
120         
121         // used to end iteration on rows
122         int rowLimit = off + w;
123         
124         // constant which can be pulled out of the inner loop
125         float initConst = (dgdX*x) + gc;
126         
127         for (int i = 0; i < h; i++) { // for every row
128 
129             // initialize current value to be start
130             g = initConst + dgdY*(y+i);
131             
132             while (off < rowLimit) { // for every pixel in this row
133                 // get the color
134                 pixels[off++] = indexIntoGradientsArrays(g);
135 
136                 // incremental change in g
137                 g += dgdX;
138             }
139 
140             // change in off from row to row
141             off += adjust;
142 
143             //rowlimit is width + offset
144             rowLimit = off + w;
145         }
146     }
147 }
148
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Free Books Free Magazines
Popular Tags