1. /* ===========================================================

  2.  * JFreeChart : a free chart library for the Java(tm) platform

  3.  * ===========================================================

  4.  *

  5.  * (C) Copyright 2000-2004, 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 under the terms

  10.  * of the GNU Lesser General Public License as published by the Free Software Foundation;

  11.  * either version 2.1 of the License, or (at your option) any later version.

  12.  *

  13.  * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;

  14.  * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

  15.  * See the GNU Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public License along with this

  18.  * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,

  19.  * Boston, MA 02111-1307, USA.

  20.  *

  21.  * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 

  22.  * in the United States and other countries.]

  23.  *

  24.  * ------------------

  25.  * BarRenderer3D.java

  26.  * ------------------

  27.  * (C) Copyright 2001-2004, by Serge V. Grachov and Contributors.

  28.  *

  29.  * Original Author:  Serge V. Grachov;

  30.  * Contributor(s):   David Gilbert (for Object Refinery Limited);

  31.  *                   Tin Luu;

  32.  *                   Milo Simpson;

  33.  *                   Richard Atkinson;

  34.  *                   Rich Unger;

  35.  *                   Christian W. Zuckschwerdt;

  36.  *

  37.  * $Id: BarRenderer3D.java,v 1.6 2004/11/18 16:37:07 mungady Exp $

  38.  *

  39.  * Changes

  40.  * -------

  41.  * 31-Oct-2001 : First version, contributed by Serge V. Grachov (DG);

  42.  * 15-Nov-2001 : Modified to allow for null data values (DG);

  43.  * 13-Dec-2001 : Added tooltips (DG);

  44.  * 16-Jan-2002 : Added fix for single category or single series datasets, pointed out by

  45.  *               Taoufik Romdhane (DG);

  46.  * 24-May-2002 : Incorporated tooltips into chart entities (DG);

  47.  * 11-Jun-2002 : Added check for (permitted) null info object, bug and fix reported by David

  48.  *               Basten.  Also updated Javadocs. (DG);

  49.  * 19-Jun-2002 : Added code to draw labels on bars (TL);

  50.  * 26-Jun-2002 : Added bar clipping to avoid PRExceptions (DG);

  51.  * 05-Aug-2002 : Small modification to drawCategoryItem method to support URLs for HTML image

  52.  *               maps (RA);

  53.  * 06-Aug-2002 : Value labels now use number formatter, thanks to Milo Simpson (DG);

  54.  * 08-Aug-2002 : Applied fixed in bug id 592218 (DG);

  55.  * 20-Sep-2002 : Added fix for categoryPaint by Rich Unger, and fixed errors reported by

  56.  *               Checkstyle (DG);

  57.  * 24-Oct-2002 : Amendments for changes in CategoryDataset interface and CategoryToolTipGenerator

  58.  *               interface (DG);

  59.  * 05-Nov-2002 : Replaced references to CategoryDataset with TableDataset (DG);

  60.  * 06-Nov-2002 : Moved to the com.jrefinery.chart.renderer package (DG);

  61.  * 28-Jan-2003 : Added an attribute to control the shading of the left and bottom walls in the

  62.  *               plot background (DG);

  63.  * 25-Mar-2003 : Implemented Serializable (DG);

  64.  * 10-Apr-2003 : Removed category paint usage (DG);

  65.  * 13-May-2003 : Renamed VerticalBarRenderer3D --> BarRenderer3D and merged with

  66.  *               HorizontalBarRenderer3D (DG);

  67.  * 30-Jul-2003 : Modified entity constructor (CZ);

  68.  * 19-Aug-2003 : Implemented Cloneable and PublicCloneable (DG);

  69.  * 07-Oct-2003 : Added renderer state (DG);

  70.  * 08-Oct-2003 : Removed clipping (replaced with flag in CategoryPlot to control order in which

  71.  *               the data items are processed) (DG);

  72.  * 20-Oct-2003 : Fixed bug (outline stroke not being used for bar outlines) (DG);

  73.  * 21-Oct-2003 : Bar width moved into CategoryItemRendererState (DG);

  74.  * 24-Nov-2003 : Fixed bug 846324 (item labels not showing) (DG);

  75.  * 27-Nov-2003 : Added code to respect maxBarWidth setting (DG);

  76.  * 02-Feb-2004 : Fixed bug where 'drawBarOutline' flag is not respected (DG);

  77.  * 10-Feb-2004 : Small change to drawItem() method to make cut-and-paste overriding easier (DG);

  78.  * 04-Oct-2004 : Fixed bug with item label positioning when plot alignment is horizontal (DG);

  79.  * 05-Nov-2004 : Modified drawItem() signature (DG);

  80.  * 

  81.  */

  82. 

  83. package org.jfree.chart.renderer.category;

  84. 

  85. import java.awt.AlphaComposite;

  86. import java.awt.Color;

  87. import java.awt.Composite;

  88. import java.awt.Graphics2D;

  89. import java.awt.Image;

  90. import java.awt.Paint;

  91. import java.awt.Stroke;

  92. import java.awt.geom.GeneralPath;

  93. import java.awt.geom.Line2D;

  94. import java.awt.geom.Rectangle2D;

  95. import java.io.IOException;

  96. import java.io.ObjectInputStream;

  97. import java.io.ObjectOutputStream;

  98. import java.io.Serializable;

  99. 

  100. import org.jfree.chart.Effect3D;

  101. import org.jfree.chart.axis.CategoryAxis;

  102. import org.jfree.chart.axis.ValueAxis;

  103. import org.jfree.chart.entity.CategoryItemEntity;

  104. import org.jfree.chart.entity.EntityCollection;

  105. import org.jfree.chart.labels.CategoryLabelGenerator;

  106. import org.jfree.chart.labels.CategoryToolTipGenerator;

  107. import org.jfree.chart.labels.ItemLabelAnchor;

  108. import org.jfree.chart.labels.ItemLabelPosition;

  109. import org.jfree.chart.plot.CategoryPlot;

  110. import org.jfree.chart.plot.Marker;

  111. import org.jfree.chart.plot.Plot;

  112. import org.jfree.chart.plot.PlotOrientation;

  113. import org.jfree.chart.plot.ValueMarker;

  114. import org.jfree.data.Range;

  115. import org.jfree.data.category.CategoryDataset;

  116. import org.jfree.io.SerialUtilities;

  117. import org.jfree.ui.RectangleEdge;

  118. import org.jfree.ui.TextAnchor;

  119. import org.jfree.util.PublicCloneable;

  120. 

  121. /**

  122.  * A renderer for bars with a 3D effect, for use with the {@link org.jfree.chart.plot.CategoryPlot} 

  123.  * class.

  124.  *

  125.  * @author Serge V. Grachov

  126.  */

  127. public class BarRenderer3D extends BarRenderer 

  128.                            implements Effect3D, Cloneable, PublicCloneable, Serializable {

  129. 

  130.     /** The default x-offset for the 3D effect. */

  131.     public static final double DEFAULT_X_OFFSET = 12.0;

  132. 

  133.     /** The default y-offset for the 3D effect. */

  134.     public static final double DEFAULT_Y_OFFSET = 8.0;

  135. 

  136.     /** The default wall paint. */

  137.     public static final Paint DEFAULT_WALL_PAINT = new Color(0xDD, 0xDD, 0xDD);

  138. 

  139.     /** The size of x-offset for the 3D effect. */

  140.     private double xOffset;

  141. 

  142.     /** The size of y-offset for the 3D effect. */

  143.     private double yOffset;

  144. 

  145.     /** The paint used to shade the left and lower 3D wall. */

  146.     private transient Paint wallPaint;

  147. 

  148.     /**

  149.      * Default constructor, creates a renderer with a ten pixel '3D effect'.

  150.      */

  151.     public BarRenderer3D() {

  152.         this(DEFAULT_X_OFFSET, DEFAULT_Y_OFFSET);

  153.     }

  154. 

  155.     /**

  156.      * Constructs a new renderer with the specified '3D effect'.

  157.      *

  158.      * @param xOffset  the x-offset for the 3D effect.

  159.      * @param yOffset  the y-offset for the 3D effect.

  160.      */

  161.     public BarRenderer3D(double xOffset, double yOffset) {

  162. 

  163.         super();

  164.         this.xOffset = xOffset;

  165.         this.yOffset = yOffset;

  166.         this.wallPaint = DEFAULT_WALL_PAINT;

  167.         // set the default item label positions

  168.         ItemLabelPosition p1 = new ItemLabelPosition(

  169.             ItemLabelAnchor.INSIDE12, TextAnchor.TOP_CENTER

  170.         );

  171.         setPositiveItemLabelPosition(p1);

  172.         ItemLabelPosition p2 = new ItemLabelPosition(

  173.             ItemLabelAnchor.INSIDE12, TextAnchor.TOP_CENTER

  174.         );

  175.         setNegativeItemLabelPosition(p2);

  176. 

  177.     }

  178. 

  179.     /**

  180.      * Returns the x-offset for the 3D effect.

  181.      *

  182.      * @return The 3D effect.

  183.      */

  184.     public double getXOffset() {

  185.         return this.xOffset;

  186.     }

  187. 

  188.     /**

  189.      * Returns the y-offset for the 3D effect.

  190.      *

  191.      * @return The 3D effect.

  192.      */

  193.     public double getYOffset() {

  194.         return this.yOffset;

  195.     }

  196. 

  197.     /**

  198.      * Returns the paint used to highlight the left and bottom wall in the plot background.

  199.      *

  200.      * @return The paint.

  201.      */

  202.     public Paint getWallPaint() {

  203.         return this.wallPaint;

  204.     }

  205. 

  206.     /**

  207.      * Sets the paint used to hightlight the left and bottom walls in the plot background.

  208.      *

  209.      * @param paint  the paint.

  210.      */

  211.     public void setWallPaint(Paint paint) {

  212.         this.wallPaint = paint;

  213.     }

  214. 

  215.     /**

  216.      * Draws the background for the plot.

  217.      *

  218.      * @param g2  the graphics device.

  219.      * @param plot  the plot.

  220.      * @param dataArea  the area inside the axes.

  221.      */

  222.     public void drawBackground(Graphics2D g2, CategoryPlot plot, Rectangle2D dataArea) {

  223. 

  224.         float x0 = (float) dataArea.getX();

  225.         float x1 = x0 + (float) Math.abs(this.xOffset);

  226.         float x3 = (float) dataArea.getMaxX();

  227.         float x2 = x3 - (float) Math.abs(this.xOffset);

  228. 

  229.         float y0 = (float) dataArea.getMaxY();

  230.         float y1 = y0 - (float) Math.abs(this.yOffset);

  231.         float y3 = (float) dataArea.getMinY();

  232.         float y2 = y3 + (float) Math.abs(this.yOffset);

  233. 

  234.         GeneralPath clip = new GeneralPath();

  235.         clip.moveTo(x0, y0);

  236.         clip.lineTo(x0, y2);

  237.         clip.lineTo(x1, y3);

  238.         clip.lineTo(x3, y3);

  239.         clip.lineTo(x3, y1);

  240.         clip.lineTo(x2, y0);

  241.         clip.closePath();

  242. 

  243.         // fill background...

  244.         Paint backgroundPaint = plot.getBackgroundPaint();

  245.         if (backgroundPaint != null) {

  246.             g2.setPaint(backgroundPaint);

  247.             g2.fill(clip);

  248.         }

  249. 

  250.         GeneralPath leftWall = new GeneralPath();

  251.         leftWall.moveTo(x0, y0);

  252.         leftWall.lineTo(x0, y2);

  253.         leftWall.lineTo(x1, y3);

  254.         leftWall.lineTo(x1, y1);

  255.         leftWall.closePath();

  256.         g2.setPaint(getWallPaint());

  257.         g2.fill(leftWall);

  258. 

  259.         GeneralPath bottomWall = new GeneralPath();

  260.         bottomWall.moveTo(x0, y0);

  261.         bottomWall.lineTo(x1, y1);

  262.         bottomWall.lineTo(x3, y1);

  263.         bottomWall.lineTo(x2, y0);

  264.         bottomWall.closePath();

  265.         g2.setPaint(getWallPaint());

  266.         g2.fill(bottomWall);

  267. 

  268.         // higlight the background corners...

  269.         g2.setPaint(Color.lightGray);

  270.         Line2D corner = new Line2D.Double(x0, y0, x1, y1);

  271.         g2.draw(corner);

  272.         corner.setLine(x1, y1, x1, y3);

  273.         g2.draw(corner);

  274.         corner.setLine(x1, y1, x3, y1);

  275.         g2.draw(corner);

  276. 

  277.         // draw background image, if there is one...

  278.         Image backgroundImage = plot.getBackgroundImage();

  279.         if (backgroundImage != null) {

  280.             Composite originalComposite = g2.getComposite();

  281.             g2.setComposite(

  282.                 AlphaComposite.getInstance(AlphaComposite.SRC, plot.getBackgroundAlpha())

  283.             );

  284.             g2.drawImage(

  285.                 backgroundImage,

  286.                 (int) x1, (int) y3,

  287.                 (int) (x3 - x1 + 1), (int) (y1 - y3 + 1),

  288.                 null

  289.             );

  290.             g2.setComposite(originalComposite);

  291.         }

  292. 

  293.     }

  294. 

  295.     /**

  296.      * Draws the outline for the plot.

  297.      *

  298.      * @param g2  the graphics device.

  299.      * @param plot  the plot.

  300.      * @param dataArea  the area inside the axes.

  301.      */

  302.     public void drawOutline(Graphics2D g2, CategoryPlot plot, Rectangle2D dataArea) {

  303. 

  304.         float x0 = (float) dataArea.getX();

  305.         float x1 = x0 + (float) Math.abs(this.xOffset);

  306.         float x3 = (float) dataArea.getMaxX();

  307.         float x2 = x3 - (float) Math.abs(this.xOffset);

  308. 

  309.         float y0 = (float) dataArea.getMaxY();

  310.         float y1 = y0 - (float) Math.abs(this.yOffset);

  311.         float y3 = (float) dataArea.getMinY();

  312.         float y2 = y3 + (float) Math.abs(this.yOffset);

  313. 

  314.         GeneralPath clip = new GeneralPath();

  315.         clip.moveTo(x0, y0);

  316.         clip.lineTo(x0, y2);

  317.         clip.lineTo(x1, y3);

  318.         clip.lineTo(x3, y3);

  319.         clip.lineTo(x3, y1);

  320.         clip.lineTo(x2, y0);

  321.         clip.closePath();

  322. 

  323.         // put an outline around the data area...

  324.         Stroke outlineStroke = plot.getOutlineStroke();

  325.         Paint outlinePaint = plot.getOutlinePaint();

  326.         if ((outlineStroke != null) && (outlinePaint != null)) {

  327.             g2.setStroke(outlineStroke);

  328.             g2.setPaint(outlinePaint);

  329.             g2.draw(clip);

  330.         }

  331. 

  332.     }

  333. 

  334.     /**

  335.      * Draws a grid line against the domain axis.

  336.      *

  337.      * @param g2  the graphics device.

  338.      * @param plot  the plot.

  339.      * @param dataArea  the area for plotting data (not yet adjusted for any 3D effect).

  340.      * @param value  the Java2D value at which the grid line should be drawn.

  341.      *

  342.      */

  343.     public void drawDomainGridline(Graphics2D g2,

  344.                                    CategoryPlot plot,

  345.                                    Rectangle2D dataArea,

  346.                                    double value) {

  347. 

  348.         Line2D line1 = null;

  349.         Line2D line2 = null;

  350.         PlotOrientation orientation = plot.getOrientation();

  351.         if (orientation == PlotOrientation.HORIZONTAL) {

  352.             double y0 = value;

  353.             double y1 = value - getYOffset();

  354.             double x0 = dataArea.getMinX();

  355.             double x1 = x0 + getXOffset();

  356.             double x2 = dataArea.getMaxY();

  357.             line1 = new Line2D.Double(x0, y0, x1, y1);

  358.             line2 = new Line2D.Double(x1, y1, x2, y1);

  359.         }

  360.         else if (orientation == PlotOrientation.VERTICAL) {

  361.             double x0 = value;

  362.             double x1 = value + getXOffset();

  363.             double y0 = dataArea.getMaxY();

  364.             double y1 = y0 - getYOffset();

  365.             double y2 = dataArea.getMinY();

  366.             line1 = new Line2D.Double(x0, y0, x1, y1);

  367.             line2 = new Line2D.Double(x1, y1, x1, y2);

  368.         }

  369.         Paint paint = plot.getDomainGridlinePaint();

  370.         Stroke stroke = plot.getDomainGridlineStroke();

  371.         g2.setPaint(paint != null ? paint : Plot.DEFAULT_OUTLINE_PAINT);

  372.         g2.setStroke(stroke != null ? stroke : Plot.DEFAULT_OUTLINE_STROKE);

  373.         g2.draw(line1);

  374.         g2.draw(line2);

  375. 

  376.     }

  377. 

  378.     /**

  379.      * Draws a grid line against the range axis.

  380.      *

  381.      * @param g2  the graphics device.

  382.      * @param plot  the plot.

  383.      * @param axis  the value axis.

  384.      * @param dataArea  the area for plotting data (not yet adjusted for any 3D effect).

  385.      * @param value  the value at which the grid line should be drawn.

  386.      *

  387.      */

  388.     public void drawRangeGridline(Graphics2D g2,

  389.                                   CategoryPlot plot,

  390.                                   ValueAxis axis,

  391.                                   Rectangle2D dataArea,

  392.                                   double value) {

  393. 

  394.         Range range = axis.getRange();

  395. 

  396.         if (!range.contains(value)) {

  397.             return;

  398.         }

  399. 

  400.         Rectangle2D adjusted = new Rectangle2D.Double(

  401.             dataArea.getX(),

  402.             dataArea.getY() + getYOffset(),

  403.             dataArea.getWidth() - getXOffset(),

  404.             dataArea.getHeight() - getYOffset()

  405.         );

  406. 

  407.         Line2D line1 = null;

  408.         Line2D line2 = null;

  409.         PlotOrientation orientation = plot.getOrientation();

  410.         if (orientation == PlotOrientation.HORIZONTAL) {

  411.             double x0 = axis.valueToJava2D(value, adjusted, plot.getRangeAxisEdge());

  412.             double x1 = x0 + getXOffset();

  413.             double y0 = dataArea.getMaxY();

  414.             double y1 = y0 - getYOffset();

  415.             double y2 = dataArea.getMinY();

  416.             line1 = new Line2D.Double(x0, y0, x1, y1);

  417.             line2 = new Line2D.Double(x1, y1, x1, y2);

  418.         }

  419.         else if (orientation == PlotOrientation.VERTICAL) {

  420.             double y0 = axis.valueToJava2D(value, adjusted, plot.getRangeAxisEdge());

  421.             double y1 = y0 - getYOffset();

  422.             double x0 = dataArea.getMinX();

  423.             double x1 = x0 + getXOffset();

  424.             double x2 = dataArea.getMaxX();

  425.             line1 = new Line2D.Double(x0, y0, x1, y1);

  426.             line2 = new Line2D.Double(x1, y1, x2, y1);

  427.         }

  428.         Paint paint = plot.getRangeGridlinePaint();

  429.         Stroke stroke = plot.getRangeGridlineStroke();

  430.         g2.setPaint(paint != null ? paint : Plot.DEFAULT_OUTLINE_PAINT);

  431.         g2.setStroke(stroke != null ? stroke : Plot.DEFAULT_OUTLINE_STROKE);

  432.         g2.draw(line1);

  433.         g2.draw(line2);

  434. 

  435.     }

  436. 

  437.     /**

  438.      * Draws a range marker.

  439.      *

  440.      * @param g2  the graphics device.

  441.      * @param plot  the plot.

  442.      * @param axis  the value axis.

  443.      * @param marker  the marker.

  444.      * @param dataArea  the area for plotting data (not including 3D effect).

  445.      */

  446.     public void drawRangeMarker(Graphics2D g2,

  447.                                 CategoryPlot plot,

  448.                                 ValueAxis axis,

  449.                                 Marker marker,

  450.                                 Rectangle2D dataArea) {

  451. 

  452.         if (marker instanceof ValueMarker) {

  453.             ValueMarker vm = (ValueMarker) marker;

  454.             double value = vm.getValue();

  455.             Range range = axis.getRange();

  456.             if (!range.contains(value)) {

  457.                 return;

  458.             }

  459. 

  460.             Rectangle2D adjusted = new Rectangle2D.Double(

  461.                 dataArea.getX(), dataArea.getY() + getYOffset(),

  462.                 dataArea.getWidth() - getXOffset(), dataArea.getHeight() - getYOffset()

  463.             );

  464. 

  465.             GeneralPath path = null;

  466.             PlotOrientation orientation = plot.getOrientation();

  467.             if (orientation == PlotOrientation.HORIZONTAL) {

  468.                 float x = (float) axis.valueToJava2D(

  469.                     value, adjusted, plot.getRangeAxisEdge()

  470.                 );

  471.                 float y = (float) adjusted.getMaxY();

  472.                 path = new GeneralPath();

  473.                 path.moveTo(x, y);

  474.                 path.lineTo((float) (x + getXOffset()), y - (float) getYOffset());

  475.                 path.lineTo(

  476.                     (float) (x + getXOffset()), (float) (adjusted.getMinY() - getYOffset())

  477.                 );

  478.                 path.lineTo(x, (float) adjusted.getMinY());

  479.                 path.closePath();

  480.             }

  481.             else if (orientation == PlotOrientation.VERTICAL) {

  482.                 float y = (float) axis.valueToJava2D(

  483.                     value, adjusted, plot.getRangeAxisEdge()

  484.                 );

  485.                 float x = (float) dataArea.getX();

  486.                 path = new GeneralPath();

  487.                 path.moveTo(x, y);

  488.                 path.lineTo(x + (float) this.xOffset, y - (float) this.yOffset);

  489.                 path.lineTo((float) (adjusted.getMaxX() + this.xOffset), y - (float) this.yOffset);

  490.                 path.lineTo((float) (adjusted.getMaxX()), y);

  491.                 path.closePath();

  492.             }

  493.             g2.setPaint(marker.getPaint());

  494.             g2.fill(path);

  495.             g2.setPaint(marker.getOutlinePaint());

  496.             g2.draw(path);

  497.         }

  498.         else {

  499.             super.drawRangeMarker(g2, plot, axis, marker, dataArea);

  500.             // TODO: draw the interval marker with a 3D effect

  501.         }

  502.     }

  503. 

  504.     /**

  505.      * Draws a 3D bar to represent one data item.

  506.      *

  507.      * @param g2  the graphics device.

  508.      * @param state  the renderer state.

  509.      * @param dataArea  the area for plotting the data.

  510.      * @param plot  the plot.

  511.      * @param domainAxis  the domain axis.

  512.      * @param rangeAxis  the range axis.

  513.      * @param dataset  the dataset.

  514.      * @param row  the row index (zero-based).

  515.      * @param column  the column index (zero-based).

  516.      * @param pass  the pass index.

  517.      */

  518.     public void drawItem(Graphics2D g2,

  519.                          CategoryItemRendererState state,

  520.                          Rectangle2D dataArea,

  521.                          CategoryPlot plot,

  522.                          CategoryAxis domainAxis,

  523.                          ValueAxis rangeAxis,

  524.                          CategoryDataset dataset,

  525.                          int row,

  526.                          int column,

  527.                          int pass) {

  528.     

  529.         // check the value we are plotting...

  530.         Number dataValue = dataset.getValue(row, column);

  531.         if (dataValue == null) {

  532.             return;

  533.         }

  534.         

  535.         double value = dataValue.doubleValue();

  536.         

  537.         Rectangle2D adjusted = new Rectangle2D.Double(

  538.             dataArea.getX(),

  539.             dataArea.getY() + getYOffset(),

  540.             dataArea.getWidth() - getXOffset(),

  541.             dataArea.getHeight() - getYOffset()

  542.         );

  543. 

  544.         PlotOrientation orientation = plot.getOrientation();

  545.         

  546.         double barW0 = calculateBarW0(plot, orientation, adjusted, domainAxis, state, row, column);

  547.         double[] barL0L1 = calculateBarL0L1(value);

  548.         if (barL0L1 == null) {

  549.             return;  // the bar is not visible

  550.         }

  551. 

  552.         RectangleEdge edge = plot.getRangeAxisEdge();

  553.         double transL0 = rangeAxis.valueToJava2D(barL0L1[0], adjusted, edge);

  554.         double transL1 = rangeAxis.valueToJava2D(barL0L1[1], adjusted, edge);

  555.         double barL0 = Math.min(transL0, transL1);

  556.         double barLength = Math.abs(transL1 - transL0);

  557.         

  558.         // draw the bar...

  559.         Rectangle2D bar = null;

  560.         if (orientation == PlotOrientation.HORIZONTAL) {

  561.             bar = new Rectangle2D.Double(barL0, barW0, barLength, state.getBarWidth());

  562.         }

  563.         else {

  564.             bar = new Rectangle2D.Double(barW0, barL0, state.getBarWidth(), barLength);

  565.         }

  566.         Paint itemPaint = getItemPaint(row, column);

  567.         g2.setPaint(itemPaint);

  568.         g2.fill(bar);

  569. 

  570.         double x0 = bar.getMinX();

  571.         double x1 = x0 + getXOffset();

  572.         double x2 = bar.getMaxX();

  573.         double x3 = x2 + getXOffset();

  574.         

  575.         double y0 = bar.getMinY() - getYOffset();

  576.         double y1 = bar.getMinY();

  577.         double y2 = bar.getMaxY() - getYOffset();

  578.         double y3 = bar.getMaxY();

  579.         

  580.         GeneralPath bar3dRight = null;

  581.         GeneralPath bar3dTop = null;

  582.         if (barLength > 0.0) {

  583.             bar3dRight = new GeneralPath();

  584.             bar3dRight.moveTo((float) x2, (float) y3);

  585.             bar3dRight.lineTo((float) x2, (float) y1);

  586.             bar3dRight.lineTo((float) x3, (float) y0);

  587.             bar3dRight.lineTo((float) x3, (float) y2);

  588.             bar3dRight.closePath();

  589. 

  590.             if (itemPaint instanceof Color) {

  591.                 g2.setPaint(((Color) itemPaint).darker());

  592.             }

  593.             g2.fill(bar3dRight);

  594.         }

  595. 

  596.         bar3dTop = new GeneralPath();

  597.         bar3dTop.moveTo((float) x0, (float) y1);

  598.         bar3dTop.lineTo((float) x1, (float) y0);

  599.         bar3dTop.lineTo((float) x3, (float) y0);

  600.         bar3dTop.lineTo((float) x2, (float) y1);

  601.         bar3dTop.closePath();

  602.         g2.fill(bar3dTop);

  603. 

  604.         if (isDrawBarOutline() && state.getBarWidth() > BAR_OUTLINE_WIDTH_THRESHOLD) {

  605.             g2.setStroke(getItemOutlineStroke(row, column));

  606.             g2.setPaint(getItemOutlinePaint(row, column));

  607.             g2.draw(bar);

  608.             if (bar3dRight != null) {

  609.                 g2.draw(bar3dRight);

  610.             }

  611.             if (bar3dTop != null) {

  612.                 g2.draw(bar3dTop);

  613.             }

  614.         }

  615. 

  616.         CategoryLabelGenerator generator = getLabelGenerator(row, column);

  617.         if (generator != null && isItemLabelVisible(row, column)) {

  618.             drawItemLabel(g2, dataset, row, column, plot, generator, bar, (value < 0.0));

  619.         }        

  620. 

  621.         // collect entity and tool tip information...

  622.         if (state.getInfo() != null) {

  623.             EntityCollection entities = state.getInfo().getOwner().getEntityCollection();

  624.             if (entities != null) {

  625.                 GeneralPath barOutline = new GeneralPath();

  626.                 barOutline.moveTo((float) x0, (float) y3);

  627.                 barOutline.lineTo((float) x0, (float) y1);

  628.                 barOutline.lineTo((float) x1, (float) y0);

  629.                 barOutline.lineTo((float) x3, (float) y0);

  630.                 barOutline.lineTo((float) x3, (float) y2);

  631.                 barOutline.lineTo((float) x2, (float) y3);

  632.                 barOutline.closePath();

  633. 

  634.                 String tip = null;

  635.                 CategoryToolTipGenerator tipster = getToolTipGenerator(row, column);

  636.                 if (tipster != null) {

  637.                     tip = tipster.generateToolTip(dataset, row, column);

  638.                 }

  639.                 String url = null;

  640.                 if (getItemURLGenerator(row, column) != null) {

  641.                     url = getItemURLGenerator(row, column).generateURL(dataset, row, column);

  642.                 }

  643.                 CategoryItemEntity entity = new CategoryItemEntity(

  644.                     barOutline, tip, url, dataset, row, dataset.getColumnKey(column), column

  645.                 );

  646.                 entities.add(entity);

  647.             }

  648.         }

  649. 

  650.     }

  651. 

  652.     /**

  653.      * Provides serialization support.

  654.      *

  655.      * @param stream  the output stream.

  656.      *

  657.      * @throws IOException  if there is an I/O error.

  658.      */

  659.     private void writeObject(ObjectOutputStream stream) throws IOException {

  660.         stream.defaultWriteObject();

  661.         SerialUtilities.writePaint(this.wallPaint, stream);

  662.     }

  663. 

  664.     /**

  665.      * Provides serialization support.

  666.      *

  667.      * @param stream  the input stream.

  668.      *

  669.      * @throws IOException  if there is an I/O error.

  670.      * @throws ClassNotFoundException  if there is a classpath problem.

  671.      */

  672.     private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {

  673.         stream.defaultReadObject();

  674.         this.wallPaint = SerialUtilities.readPaint(stream);

  675.     }

  676. 

  677. }