Source for org.jfree.chart.ClipPath

   1: /* ===========================================================
   2:  * JFreeChart : a free chart library for the Java(tm) platform
   3:  * ===========================================================
   4:  *
   5:  * (C) Copyright 2000-2007, 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, 2007, 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:  * Changes
  37:  * -------
  38:  * 22-Apr-2003 : Added standard header (DG);
  39:  * 09-May-2003 : Added AxisLocation (DG);
  40:  * 11-Sep-2003 : Implemented Cloneable (NB);
  41:  * 21-Jan-2004 : Update for renamed method in ValueAxis (DG);
  42:  * ------------- JFREECHART 1.0.x ---------------------------------------------
  43:  * 31-Jan-2007 : Deprecated (DG);
  44:  *
  45:  */
  46: 
  47: package org.jfree.chart;
  48: 
  49: import java.awt.BasicStroke;
  50: import java.awt.Composite;
  51: import java.awt.Graphics2D;
  52: import java.awt.Paint;
  53: import java.awt.Stroke;
  54: import java.awt.geom.GeneralPath;
  55: import java.awt.geom.Rectangle2D;
  56: 
  57: import org.jfree.chart.axis.ValueAxis;
  58: import org.jfree.chart.plot.XYPlot;
  59: import org.jfree.chart.renderer.xy.XYBlockRenderer;
  60: import org.jfree.ui.RectangleEdge;
  61: 
  62: /**
  63:  * This class would typically be used with a 
  64:  * {@link org.jfree.chart.plot.ContourPlot}.  It allows the user to define a 
  65:  * <code>GeneralPath</code> curve in plot coordinates.  This curve can then be 
  66:  * used mask off or define regions within the contour plot.  The data must be 
  67:  * sorted.
  68:  * 
  69:  * @deprecated This class is no longer supported (as of version 1.0.4).  If 
  70:  *     you are creating contour plots, please try to use {@link XYPlot} and 
  71:  *     {@link XYBlockRenderer}.
  72:  */
  73: public class ClipPath implements Cloneable {
  74: 
  75:     /** The x values. */
  76:     private double[] xValue = null;
  77:     
  78:     /** The y values. */
  79:     private double[] yValue = null;
  80: 
  81:     /** Controls whether drawing will be clipped (
  82:      * false would still allow the drawing or filling of path */
  83:     private boolean clip = true;
  84: 
  85:     /** Controls whether the path is drawn as an outline. */
  86:     private boolean drawPath = false;
  87: 
  88:     /** Controls whether the path is filled. */
  89:     private boolean fillPath = false;
  90: 
  91:     /** The fill paint. */
  92:     private Paint fillPaint = null;
  93:     
  94:     /** The draw paint. */
  95:     private Paint drawPaint = null;
  96:     
  97:     /** The draw stroke. */
  98:     private Stroke drawStroke = null;
  99:     
 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: }