001 /* ===========================================================
002 * JFreeChart : a free chart library for the Java(tm) platform
003 * ===========================================================
004 *
005 * (C) Copyright 2000-2008, by Object Refinery Limited and Contributors.
006 *
007 * Project Info: http://www.jfree.org/jfreechart/index.html
008 *
009 * This library is free software; you can redistribute it and/or modify it
010 * under the terms of the GNU Lesser General Public License as published by
011 * the Free Software Foundation; either version 2.1 of the License, or
012 * (at your option) any later version.
013 *
014 * This library is distributed in the hope that it will be useful, but
015 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017 * License for more details.
018 *
019 * You should have received a copy of the GNU Lesser General Public
020 * License along with this library; if not, write to the Free Software
021 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
022 * USA.
023 *
024 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
025 * in the United States and other countries.]
026 *
027 * -------------
028 * ClipPath.java
029 * -------------
030 * (C) Copyright 2003-2008, by David M. O'Donnell and Contributors.
031 *
032 * Original Author: David M. O'Donnell;
033 * Contributor(s): David Gilbert (for Object Refinery Limited);
034 * Nicolas Brodu;
035 *
036 * Changes
037 * -------
038 * 22-Apr-2003 : Added standard header (DG);
039 * 09-May-2003 : Added AxisLocation (DG);
040 * 11-Sep-2003 : Implemented Cloneable (NB);
041 * 21-Jan-2004 : Update for renamed method in ValueAxis (DG);
042 * ------------- JFREECHART 1.0.x ---------------------------------------------
043 * 31-Jan-2007 : Deprecated (DG);
044 *
045 */
046
047 package org.jfree.chart;
048
049 import java.awt.BasicStroke;
050 import java.awt.Composite;
051 import java.awt.Graphics2D;
052 import java.awt.Paint;
053 import java.awt.Stroke;
054 import java.awt.geom.GeneralPath;
055 import java.awt.geom.Rectangle2D;
056
057 import org.jfree.chart.axis.ValueAxis;
058 import org.jfree.chart.plot.XYPlot;
059 import org.jfree.chart.renderer.xy.XYBlockRenderer;
060 import org.jfree.ui.RectangleEdge;
061
062 /**
063 * This class would typically be used with a
064 * {@link org.jfree.chart.plot.ContourPlot}. It allows the user to define a
065 * <code>GeneralPath</code> curve in plot coordinates. This curve can then be
066 * used mask off or define regions within the contour plot. The data must be
067 * sorted.
068 *
069 * @deprecated This class is no longer supported (as of version 1.0.4). If
070 * you are creating contour plots, please try to use {@link XYPlot} and
071 * {@link XYBlockRenderer}.
072 */
073 public class ClipPath implements Cloneable {
074
075 /** The x values. */
076 private double[] xValue = null;
077
078 /** The y values. */
079 private double[] yValue = null;
080
081 /** Controls whether drawing will be clipped (
082 * false would still allow the drawing or filling of path */
083 private boolean clip = true;
084
085 /** Controls whether the path is drawn as an outline. */
086 private boolean drawPath = false;
087
088 /** Controls whether the path is filled. */
089 private boolean fillPath = false;
090
091 /** The fill paint. */
092 private Paint fillPaint = null;
093
094 /** The draw paint. */
095 private Paint drawPaint = null;
096
097 /** The draw stroke. */
098 private Stroke drawStroke = null;
099
100 /** The composite. */
101 private Composite composite = null;
102
103 /**
104 * Constructor for ClipPath.
105 */
106 public ClipPath() {
107 super();
108 }
109
110 /**
111 * Constructor for ClipPath.
112 * Default values are assumed for the fillPath and drawPath options as
113 * false and true respectively. The fillPaint is set to Color.GRAY, the
114 * drawColor is Color.BLUE, the stroke is BasicStroke(1)
115 * and the composite is AlphaComposite.Src.
116 *
117 * @param xValue x coordinates of curved to be created
118 * @param yValue y coordinates of curved to be created
119 */
120 public ClipPath(double[] xValue, double[] yValue) {
121 this(xValue, yValue, true, false, true);
122 }
123
124
125 /**
126 * Constructor for ClipPath.
127 * The fillPaint is set to Color.GRAY, the drawColor is Color.BLUE, the
128 * stroke is BasicStroke(1) and the composite is AlphaComposite.Src.
129 *
130 * @param xValue x coordinates of curved to be created
131 * @param yValue y coordinates of curved to be created
132 * @param clip clip?
133 * @param fillPath whether the path is to filled
134 * @param drawPath whether the path is to drawn as an outline
135 */
136 public ClipPath(double[] xValue, double[] yValue,
137 boolean clip, boolean fillPath, boolean drawPath) {
138 this.xValue = xValue;
139 this.yValue = yValue;
140
141 this.clip = clip;
142 this.fillPath = fillPath;
143 this.drawPath = drawPath;
144
145 this.fillPaint = java.awt.Color.gray;
146 this.drawPaint = java.awt.Color.blue;
147 this.drawStroke = new BasicStroke(1);
148 this.composite = java.awt.AlphaComposite.Src;
149 }
150
151 /**
152 * Constructor for ClipPath.
153 *
154 * @param xValue x coordinates of curved to be created
155 * @param yValue y coordinates of curved to be created
156 * @param fillPath whether the path is to filled
157 * @param drawPath whether the path is to drawn as an outline
158 * @param fillPaint the fill paint
159 * @param drawPaint the outline stroke color
160 * @param drawStroke the stroke style
161 * @param composite the composite rule
162 */
163 public ClipPath(double[] xValue, double[] yValue, boolean fillPath,
164 boolean drawPath, Paint fillPaint, Paint drawPaint,
165 Stroke drawStroke, Composite composite) {
166
167 this.xValue = xValue;
168 this.yValue = yValue;
169
170 this.fillPath = fillPath;
171 this.drawPath = drawPath;
172
173 this.fillPaint = fillPaint;
174 this.drawPaint = drawPaint;
175 this.drawStroke = drawStroke;
176 this.composite = composite;
177
178 }
179
180 /**
181 * Draws the clip path.
182 *
183 * @param g2 current graphics2D.
184 * @param dataArea the dataArea that the plot is being draw in.
185 * @param horizontalAxis the horizontal axis.
186 * @param verticalAxis the vertical axis.
187 *
188 * @return The GeneralPath defining the outline
189 */
190 public GeneralPath draw(Graphics2D g2,
191 Rectangle2D dataArea,
192 ValueAxis horizontalAxis, ValueAxis verticalAxis) {
193
194 GeneralPath generalPath = generateClipPath(
195 dataArea, horizontalAxis, verticalAxis
196 );
197 if (this.fillPath || this.drawPath) {
198 Composite saveComposite = g2.getComposite();
199 Paint savePaint = g2.getPaint();
200 Stroke saveStroke = g2.getStroke();
201
202 if (this.fillPaint != null) {
203 g2.setPaint(this.fillPaint);
204 }
205 if (this.composite != null) {
206 g2.setComposite(this.composite);
207 }
208 if (this.fillPath) {
209 g2.fill(generalPath);
210 }
211
212 if (this.drawStroke != null) {
213 g2.setStroke(this.drawStroke);
214 }
215 if (this.drawPath) {
216 g2.draw(generalPath);
217 }
218 g2.setPaint(savePaint);
219 g2.setComposite(saveComposite);
220 g2.setStroke(saveStroke);
221 }
222 return generalPath;
223
224 }
225
226 /**
227 * Generates the clip path.
228 *
229 * @param dataArea the dataArea that the plot is being draw in.
230 * @param horizontalAxis the horizontal axis.
231 * @param verticalAxis the vertical axis.
232 *
233 * @return The GeneralPath defining the outline
234 */
235 public GeneralPath generateClipPath(Rectangle2D dataArea,
236 ValueAxis horizontalAxis,
237 ValueAxis verticalAxis) {
238
239 GeneralPath generalPath = new GeneralPath();
240 double transX = horizontalAxis.valueToJava2D(
241 this.xValue[0], dataArea, RectangleEdge.BOTTOM
242 );
243 double transY = verticalAxis.valueToJava2D(
244 this.yValue[0], dataArea, RectangleEdge.LEFT
245 );
246 generalPath.moveTo((float) transX, (float) transY);
247 for (int k = 0; k < this.yValue.length; k++) {
248 transX = horizontalAxis.valueToJava2D(
249 this.xValue[k], dataArea, RectangleEdge.BOTTOM
250 );
251 transY = verticalAxis.valueToJava2D(
252 this.yValue[k], dataArea, RectangleEdge.LEFT
253 );
254 generalPath.lineTo((float) transX, (float) transY);
255 }
256 generalPath.closePath();
257
258 return generalPath;
259
260 }
261
262 /**
263 * Returns the composite.
264 *
265 * @return Composite
266 */
267 public Composite getComposite() {
268 return this.composite;
269 }
270
271 /**
272 * Returns the drawPaint.
273 *
274 * @return Paint
275 */
276 public Paint getDrawPaint() {
277 return this.drawPaint;
278 }
279
280 /**
281 * Returns the drawPath.
282 *
283 * @return boolean
284 */
285 public boolean isDrawPath() {
286 return this.drawPath;
287 }
288
289 /**
290 * Returns the drawStroke.
291 *
292 * @return Stroke
293 */
294 public Stroke getDrawStroke() {
295 return this.drawStroke;
296 }
297
298 /**
299 * Returns the fillPaint.
300 *
301 * @return Paint
302 */
303 public Paint getFillPaint() {
304 return this.fillPaint;
305 }
306
307 /**
308 * Returns the fillPath.
309 *
310 * @return boolean
311 */
312 public boolean isFillPath() {
313 return this.fillPath;
314 }
315
316 /**
317 * Returns the xValue.
318 *
319 * @return double[]
320 */
321 public double[] getXValue() {
322 return this.xValue;
323 }
324
325 /**
326 * Returns the yValue.
327 *
328 * @return double[]
329 */
330 public double[] getYValue() {
331 return this.yValue;
332 }
333
334 /**
335 * Sets the composite.
336 *
337 * @param composite The composite to set
338 */
339 public void setComposite(Composite composite) {
340 this.composite = composite;
341 }
342
343 /**
344 * Sets the drawPaint.
345 *
346 * @param drawPaint The drawPaint to set
347 */
348 public void setDrawPaint(Paint drawPaint) {
349 this.drawPaint = drawPaint;
350 }
351
352 /**
353 * Sets the drawPath.
354 *
355 * @param drawPath The drawPath to set
356 */
357 public void setDrawPath(boolean drawPath) {
358 this.drawPath = drawPath;
359 }
360
361 /**
362 * Sets the drawStroke.
363 *
364 * @param drawStroke The drawStroke to set
365 */
366 public void setDrawStroke(Stroke drawStroke) {
367 this.drawStroke = drawStroke;
368 }
369
370 /**
371 * Sets the fillPaint.
372 *
373 * @param fillPaint The fillPaint to set
374 */
375 public void setFillPaint(Paint fillPaint) {
376 this.fillPaint = fillPaint;
377 }
378
379 /**
380 * Sets the fillPath.
381 *
382 * @param fillPath The fillPath to set
383 */
384 public void setFillPath(boolean fillPath) {
385 this.fillPath = fillPath;
386 }
387
388 /**
389 * Sets the xValue.
390 *
391 * @param xValue The xValue to set
392 */
393 public void setXValue(double[] xValue) {
394 this.xValue = xValue;
395 }
396
397 /**
398 * Sets the yValue.
399 *
400 * @param yValue The yValue to set
401 */
402 public void setYValue(double[] yValue) {
403 this.yValue = yValue;
404 }
405
406 /**
407 * Returns the clip.
408 *
409 * @return boolean
410 */
411 public boolean isClip() {
412 return this.clip;
413 }
414
415 /**
416 * Sets the clip.
417 *
418 * @param clip The clip to set
419 */
420 public void setClip(boolean clip) {
421 this.clip = clip;
422 }
423
424 /**
425 * Returns a clone of the object (a deeper clone than default to avoid bugs
426 * when setting values in cloned object).
427 *
428 * @return The clone.
429 *
430 * @throws CloneNotSupportedException if cloning is not supported.
431 */
432 public Object clone() throws CloneNotSupportedException {
433 ClipPath clone = (ClipPath) super.clone();
434 clone.xValue = (double[]) this.xValue.clone();
435 clone.yValue = (double[]) this.yValue.clone();
436 return clone;
437 }
438
439 }