Mercurial > dive4elements > river

comparison artifacts/src/main/java/org/dive4elements/river/jfree/StyledAreaSeriesCollection.java @ 9182:77eb4553245b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixed: waterlevels could not show a band any more Correctly implemented 'showarea' on area themes now
author gernotbelger
date Tue, 26 Jun 2018 20:19:16 +0200
parents 924cd9943337
children eec4df8165a1
comparison
equal deleted inserted replaced
9181:5dacb6ea75a1 9182:77eb4553245b
15 import java.awt.TexturePaint; 15 import java.awt.TexturePaint;
16 import java.awt.geom.Ellipse2D; 16 import java.awt.geom.Ellipse2D;
17 import java.awt.geom.Rectangle2D; 17 import java.awt.geom.Rectangle2D;
18 import java.awt.image.BufferedImage; 18 import java.awt.image.BufferedImage;
19 19
20 import org.dive4elements.river.themes.ThemeDocument;
20 import org.jfree.data.xy.XYSeriesCollection; 21 import org.jfree.data.xy.XYSeriesCollection;
21
22 import org.dive4elements.river.themes.ThemeDocument;
23 22
24 /** 23 /**
25 * One or more dataseries to draw a polygon (either "open up/downwards", or 24 * One or more dataseries to draw a polygon (either "open up/downwards", or
26 * the area between two curves), a theme-document and further display options. 25 * the area between two curves), a theme-document and further display options.
27 * The theme-document will later "style" the graphical representation. 26 * The theme-document will later "style" the graphical representation.
37 36
38 /** MODE in use. */ 37 /** MODE in use. */
39 private FILL_MODE mode; 38 private FILL_MODE mode;
40 39
41 /** Theme-document with attributes about actual visual representation. */ 40 /** Theme-document with attributes about actual visual representation. */
42 private ThemeDocument theme; 41 private final ThemeDocument theme;
43 42
44 /** 43 /**
45 * @param theme the theme-document. 44 * @param theme the theme-document.
46 */ 45 */
47 public StyledAreaSeriesCollection(ThemeDocument theme) { 46 public StyledAreaSeriesCollection(final ThemeDocument theme) {
48 this.theme = theme; 47 this.theme = theme;
49 this.mode = FILL_MODE.BETWEEN; 48 this.mode = FILL_MODE.BETWEEN;
50 } 49 }
51 50
52 51
53 /** Gets the Fill mode. */ 52 /** Gets the Fill mode. */
54 public FILL_MODE getMode() { 53 public FILL_MODE getMode() {
55 return this.mode; 54 return this.mode;
56 } 55 }
57 56
58 57
59 /** Sets the Fill mode. */ 58 /** Sets the Fill mode. */
60 public void setMode(FILL_MODE fMode) { 59 public void setMode(final FILL_MODE fMode) {
61 this.mode = fMode; 60 this.mode = fMode;
62 } 61 }
63 62
64 63
65 /** 64 /**
67 * whether to draw lines and/or points. 66 * whether to draw lines and/or points.
68 * @param renderer Renderer to apply theme to. 67 * @param renderer Renderer to apply theme to.
69 * @return \param renderer 68 * @return \param renderer
70 */ 69 */
71 public StableXYDifferenceRenderer applyTheme( 70 public StableXYDifferenceRenderer applyTheme(
72 StableXYDifferenceRenderer renderer 71 final StableXYDifferenceRenderer renderer
73 ) { 72 ) {
74 applyFillColor(renderer); 73 applyFillColor(renderer);
75 applyShowShape(renderer); 74 applyShowBorder(renderer);
75 applyShowArea(renderer);
76 applyOutlineColor(renderer); 76 applyOutlineColor(renderer);
77 applyOutlineStyle(renderer); 77 applyOutlineStyle(renderer);
78 applyShowLine(renderer); 78 applyShowLine(renderer);
79 applyShowAreaLabel(renderer); 79 applyShowAreaLabel(renderer);
80 applyPointStyle(renderer); 80 applyPointStyle(renderer);
81 if (mode == FILL_MODE.UNDER) { 81 if (this.mode == FILL_MODE.UNDER) {
82 renderer.setAreaCalculationMode( 82 renderer.setAreaCalculationMode(
83 StableXYDifferenceRenderer.CALCULATE_NEGATIVE_AREA); 83 StableXYDifferenceRenderer.CALCULATE_NEGATIVE_AREA);
84 } 84 }
85 else if (mode == FILL_MODE.ABOVE) { 85 else if (this.mode == FILL_MODE.ABOVE) {
86 renderer.setAreaCalculationMode( 86 renderer.setAreaCalculationMode(
87 StableXYDifferenceRenderer.CALCULATE_POSITIVE_AREA); 87 StableXYDifferenceRenderer.CALCULATE_POSITIVE_AREA);
88 } 88 }
89 else { 89 else {
90 renderer.setAreaCalculationMode( 90 renderer.setAreaCalculationMode(
91 StableXYDifferenceRenderer.CALCULATE_ALL_AREA); 91 StableXYDifferenceRenderer.CALCULATE_ALL_AREA);
92 } 92 }
93 93
94 // Apply text style. 94 // Apply text style.
95 theme.parseComplexTextStyle().apply(renderer); 95 this.theme.parseComplexTextStyle().apply(renderer);
96 return renderer; 96 return renderer;
97 } 97 }
98 98
99 private void applyFillColor(final StableXYDifferenceRenderer renderer) { 99 private void applyFillColor(final StableXYDifferenceRenderer renderer) {
100
101 final boolean showArea = theme.parseShowArea();
102 if( !showArea ) {
103 renderer.setPositivePaint(null);
104 renderer.setNegativePaint(null);
105 return;
106 }
107 100
108 Paint paint = parseFillPaint(); 101 Paint paint = parseFillPaint();
109 102
110 if (paint != null && this.getMode() == FILL_MODE.ABOVE) { 103 if (paint != null && this.getMode() == FILL_MODE.ABOVE) {
111 renderer.setPositivePaint(paint); 104 renderer.setPositivePaint(paint);
112 renderer.setNegativePaint(new Color(0,0,0,0)); 105 renderer.setNegativePaint(new Color(0,0,0,0));
113 } 106 }
114 else if (paint != null && this.getMode() == FILL_MODE.UNDER) { 107 else if (paint != null && this.getMode() == FILL_MODE.UNDER) {
116 renderer.setPositivePaint(new Color(0,0,0,0)); 109 renderer.setPositivePaint(new Color(0,0,0,0));
117 } 110 }
118 else { 111 else {
119 if (paint == null) 112 if (paint == null)
120 paint = new Color(177, 117, 102); 113 paint = new Color(177, 117, 102);
121 114
122 renderer.setPositivePaint(paint); 115 renderer.setPositivePaint(paint);
123 renderer.setNegativePaint(paint); 116 renderer.setNegativePaint(paint);
124 } 117 }
125 } 118 }
126 119
127 private Paint parseFillPaint() { 120 private Paint parseFillPaint() {
128 final Color paint = this.theme.parseAreaBackgroundColor(); 121 final Color paint = this.theme.parseAreaBackgroundColor();
129 final int transparency = theme.parseAreaTransparency(); 122 final int transparency = this.theme.parseAreaTransparency();
130 123
131 final Color alphaPaint = withAlpha(paint, transparency); 124 final Color alphaPaint = withAlpha(paint, transparency);
132 125
133 final AreaFillPattern pattern = this.theme.parseAreaBackgroundPattern(); 126 final AreaFillPattern pattern = this.theme.parseAreaBackgroundPattern();
134 127
135 if( pattern == null || pattern == AreaFillPattern.patternFill ) 128 if( pattern == null || pattern == AreaFillPattern.patternFill )
136 return alphaPaint; 129 return alphaPaint;
137 130
138 final BufferedImage image = pattern.getImage(alphaPaint); 131 final BufferedImage image = pattern.getImage(alphaPaint);
139 132
140 final Rectangle2D anchor = new Rectangle2D.Double(0,0, image.getWidth(), image.getHeight()); 133 final Rectangle2D anchor = new Rectangle2D.Double(0,0, image.getWidth(), image.getHeight());
141 return new TexturePaint(image, anchor); 134 return new TexturePaint(image, anchor);
142 } 135 }
143 136
144 private Color withAlpha(final Color color, final int transparency) { 137 private Color withAlpha(final Color color, final int transparency) {
145 138
146 if (transparency <= 0 || color == null) 139 if (transparency <= 0 || color == null)
147 return color; 140 return color;
148 141
149 return new Color( 142 return new Color(
150 color.getRed(), 143 color.getRed(),
151 color.getGreen(), 144 color.getGreen(),
152 color.getBlue(), 145 color.getBlue(),
153 (int)((100 - transparency) * 2.55f)); 146 (int)((100 - transparency) * 2.55f));
154 } 147 }
155 148
156 private void applyShowShape(StableXYDifferenceRenderer renderer) { 149 private void applyShowBorder(final StableXYDifferenceRenderer renderer) {
157 boolean show = theme.parseAreaShowBorder(); 150 final boolean show = this.theme.parseAreaShowBorder();
158 renderer.setDrawOutline(show); 151 renderer.setDrawOutline(show);
159 } 152 }
160 153
161 154 private void applyShowArea(final StableXYDifferenceRenderer renderer) {
162 private void applyShowLine(StableXYDifferenceRenderer renderer) { 155
156 final boolean showArea = this.theme.parseShowArea();
157 renderer.setDrawArea(showArea);
158 }
159
160 private void applyShowLine(final StableXYDifferenceRenderer renderer) {
163 /* FIXME: strange: this will enable/disable showing the 'point' shapes at each vertex. */ 161 /* FIXME: strange: this will enable/disable showing the 'point' shapes at each vertex. */
164 /* FIXME: this will also now be overridden by the option 'showpoints' */ 162 /* FIXME: this will also now be overridden by the option 'showpoints' */
165 final boolean show = theme.parseShowLine(); 163 final boolean show = this.theme.parseShowLine();
166 renderer.setShapesVisible(show); 164 renderer.setShapesVisible(show);
167 } 165 }
168 166
169 private void applyOutlineColor(StableXYDifferenceRenderer renderer) { 167 private void applyOutlineColor(final StableXYDifferenceRenderer renderer) {
170 Color c = theme.parseLineColorField(); 168 final Color c = this.theme.parseLineColorField();
171 renderer.setOutlinePaint(c); 169 renderer.setOutlinePaint(c);
172 } 170 }
173 171
174 /** Inform renderer whether it should draw a label. */ 172 /** Inform renderer whether it should draw a label. */
175 private void applyShowAreaLabel(StableXYDifferenceRenderer renderer) { 173 private void applyShowAreaLabel(final StableXYDifferenceRenderer renderer) {
176 renderer.setLabelArea(theme.parseShowAreaLabel()); 174 renderer.setLabelArea(this.theme.parseShowAreaLabel());
177 } 175 }
178 176
179 private void applyOutlineStyle(StableXYDifferenceRenderer renderer) { 177 private void applyOutlineStyle(final StableXYDifferenceRenderer renderer) {
180 float[] dashes = theme.parseLineStyle(); 178 final float[] dashes = this.theme.parseLineStyle();
181 int size = theme.parseLineWidth(); 179 final int size = this.theme.parseLineWidth();
182 180
183 Stroke stroke = null; 181 Stroke stroke = null;
184 182
185 if (dashes.length <= 1) { 183 if (dashes.length <= 1) {
186 stroke = new BasicStroke(Integer.valueOf(size)); 184 stroke = new BasicStroke(Integer.valueOf(size));
187 } 185 }
188 else { 186 else {
189 stroke = new BasicStroke(Integer.valueOf(size), 187 stroke = new BasicStroke(Integer.valueOf(size),
190 BasicStroke.CAP_BUTT, 188 BasicStroke.CAP_BUTT,
191 BasicStroke.JOIN_ROUND, 189 BasicStroke.JOIN_ROUND,
192 1.0f, 190 1.0f,
193 dashes, 191 dashes,
194 0.0f); 192 0.0f);
195 } 193 }
196 194
197 renderer.setOutlineStroke(stroke); 195 renderer.setOutlineStroke(stroke);
198 } 196 }
199 197
201 199
202 final boolean showPoints = this.theme.parseShowPoints(); 200 final boolean showPoints = this.theme.parseShowPoints();
203 renderer.setShapesVisible(showPoints); 201 renderer.setShapesVisible(showPoints);
204 202
205 if( showPoints ) 203 if( showPoints )
206 { 204 {
207 final int size = theme.parsePointWidth(); 205 final int size = this.theme.parsePointWidth();
208 final int dim = 2 * size; 206 final int dim = 2 * size;
209 207
210 final Ellipse2D pointShape = new Ellipse2D.Double(-size, -size, dim, dim); 208 final Ellipse2D pointShape = new Ellipse2D.Double(-size, -size, dim, dim);
211 final Color pointColor = theme.parsePointColor(); 209 final Color pointColor = this.theme.parsePointColor();
212 210
213 renderer.setSeriesPaint(0, pointColor); 211 renderer.setSeriesPaint(0, pointColor);
214 renderer.setSeriesPaint(1, pointColor); 212 renderer.setSeriesPaint(1, pointColor);
215 213
216 renderer.setSeriesShape(0, pointShape); 214 renderer.setSeriesShape(0, pointShape);
217 renderer.setSeriesShape(1, pointShape); 215 renderer.setSeriesShape(1, pointShape);
218 } 216 }
219 } 217 }
220 218
221 public boolean shouldCalculateRange() { 219 public boolean shouldCalculateRange() {
222 return theme.parseCalculateRange(); 220 return this.theme.parseCalculateRange();
223 } 221 }
224 } 222 }
225 // vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 : 223 // vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :
http://dive4elements.wald.intevation.org