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