| Frames | No Frames |
1: /* =========================================================== 2: * JFreeChart : a free chart library for the Java(tm) platform 3: * =========================================================== 4: * 5: * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors. 6: * 7: * Project Info: http://www.jfree.org/jfreechart/index.html 8: * 9: * This library is free software; you can redistribute it and/or modify it 10: * under the terms of the GNU Lesser General Public License as published by 11: * the Free Software Foundation; either version 2.1 of the License, or 12: * (at your option) any later version. 13: * 14: * This library is distributed in the hope that it will be useful, but 15: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 16: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 17: * License for more details. 18: * 19: * You should have received a copy of the GNU Lesser General Public 20: * License along with this library; if not, write to the Free Software 21: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 22: * USA. 23: * 24: * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 25: * in the United States and other countries.] 26: * 27: * ------------- 28: * ClipPath.java 29: * ------------- 30: * (C) Copyright 2003, 2004, by David M. O'Donnell and Contributors. 31: * 32: * Original Author: David M. O'Donnell; 33: * Contributor(s): David Gilbert (for Object Refinery Limited); 34: * Nicolas Brodu; 35: * 36: * $Id: ClipPath.java,v 1.2.2.2 2007/01/31 15:56:18 mungady Exp $ 37: * 38: * Changes 39: * ------- 40: * 22-Apr-2003 : Added standard header (DG); 41: * 09-May-2003 : Added AxisLocation (DG); 42: * 11-Sep-2003 : Implemented Cloneable (NB); 43: * 21-Jan-2004 : Update for renamed method in ValueAxis (DG); 44: * ------------- JFREECHART 1.0.x --------------------------------------------- 45: * 31-Jan-2007 : Deprecated (DG); 46: * 47: */ 48: 49: package org.jfree.chart; 50: 51: import java.awt.BasicStroke; 52: import java.awt.Composite; 53: import java.awt.Graphics2D; 54: import java.awt.Paint; 55: import java.awt.Stroke; 56: import java.awt.geom.GeneralPath; 57: import java.awt.geom.Rectangle2D; 58: 59: import org.jfree.chart.axis.ValueAxis; 60: import org.jfree.chart.plot.XYPlot; 61: import org.jfree.chart.renderer.xy.XYBlockRenderer; 62: import org.jfree.ui.RectangleEdge; 63: 64: /** 65: * This class would typically be used with a 66: * {@link org.jfree.chart.plot.ContourPlot}. It allows the user to define a 67: * <code>GeneralPath</code> curve in plot coordinates. This curve can then be 68: * used mask off or define regions within the contour plot. The data must be 69: * sorted. 70: * 71: * @deprecated This class is no longer supported. If you are creating 72: * contour plots, please try to use {@link XYPlot} and 73: * {@link XYBlockRenderer}. 74: */ 75: public class ClipPath implements Cloneable { 76: 77: /** The x values. */ 78: private double[] xValue = null; 79: 80: /** The y values. */ 81: private double[] yValue = null; 82: 83: /** Controls whether drawing will be clipped ( 84: * false would still allow the drawing or filling of path */ 85: private boolean clip = true; 86: 87: /** Controls whether the path is drawn as an outline. */ 88: private boolean drawPath = false; 89: 90: /** Controls whether the path is filled. */ 91: private boolean fillPath = false; 92: 93: /** The fill paint. */ 94: private Paint fillPaint = null; 95: 96: /** The draw paint. */ 97: private Paint drawPaint = null; 98: 99: /** 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: }