Examples with Polygon java.awt.Polygon used on opensource projects

Example 86 with Polygon

use of java.awt.Polygon in project Activiti by Activiti.

the class DefaultProcessDiagramCanvas method drawArrowHead.

public void drawArrowHead(Line2D.Double line) {
    int doubleArrowWidth = (int) (2 * ARROW_WIDTH);
    if (doubleArrowWidth == 0) {
        doubleArrowWidth = 2;
    }
    Polygon arrowHead = new Polygon();
    arrowHead.addPoint(0, 0);
    int arrowHeadPoint = (int) (-ARROW_WIDTH);
    if (arrowHeadPoint == 0) {
        arrowHeadPoint = -1;
    }
    arrowHead.addPoint(arrowHeadPoint, -doubleArrowWidth);
    arrowHeadPoint = (int) (ARROW_WIDTH);
    if (arrowHeadPoint == 0) {
        arrowHeadPoint = 1;
    }
    arrowHead.addPoint(arrowHeadPoint, -doubleArrowWidth);
    AffineTransform transformation = new AffineTransform();
    transformation.setToIdentity();
    double angle = Math.atan2(line.y2 - line.y1, line.x2 - line.x1);
    transformation.translate(line.x2, line.y2);
    transformation.rotate((angle - Math.PI / 2d));
    AffineTransform originalTransformation = g.getTransform();
    g.setTransform(transformation);
    g.fill(arrowHead);
    g.setTransform(originalTransformation);
}

Example 87 with Polygon

use of java.awt.Polygon in project vcell by virtualcell.

the class DownArrowIcon method paintIcon.

public void paintIcon(Component c, Graphics g, int x, int y) {
    Graphics g1 = g.create();
    Polygon p = new Polygon();
    p.addPoint(x, y);
    p.addPoint(x + getIconWidth(), y);
    p.addPoint(x + getIconWidth() / 2, y + getIconHeight());
    g1.setColor(c.getForeground());
    g1.fillPolygon(p);
}

Example 88 with Polygon

use of java.awt.Polygon in project SIMVA-SoS by SESoS.

the class PiePlot3D method draw.

/**
 * Draws the plot on a Java 2D graphics device (such as the screen or a
 * printer).  This method is called by the
 * {@link org.jfree.chart.JFreeChart} class, you don't normally need
 * to call it yourself.
 *
 * @param g2  the graphics device.
 * @param plotArea  the area within which the plot should be drawn.
 * @param anchor  the anchor point.
 * @param parentState  the state from the parent plot, if there is one.
 * @param info  collects info about the drawing
 *              (<code>null</code> permitted).
 */
@Override
public void draw(Graphics2D g2, Rectangle2D plotArea, Point2D anchor, PlotState parentState, PlotRenderingInfo info) {
    // adjust for insets...
    RectangleInsets insets = getInsets();
    insets.trim(plotArea);
    Rectangle2D originalPlotArea = (Rectangle2D) plotArea.clone();
    if (info != null) {
        info.setPlotArea(plotArea);
        info.setDataArea(plotArea);
    }
    drawBackground(g2, plotArea);
    Shape savedClip = g2.getClip();
    g2.clip(plotArea);
    Graphics2D savedG2 = g2;
    BufferedImage dataImage = null;
    if (getShadowGenerator() != null) {
        dataImage = new BufferedImage((int) plotArea.getWidth(), (int) plotArea.getHeight(), BufferedImage.TYPE_INT_ARGB);
        g2 = dataImage.createGraphics();
        g2.translate(-plotArea.getX(), -plotArea.getY());
        g2.setRenderingHints(savedG2.getRenderingHints());
        originalPlotArea = (Rectangle2D) plotArea.clone();
    }
    // adjust the plot area by the interior spacing value
    double gapPercent = getInteriorGap();
    double labelPercent = 0.0;
    if (getLabelGenerator() != null) {
        labelPercent = getLabelGap() + getMaximumLabelWidth();
    }
    double gapHorizontal = plotArea.getWidth() * (gapPercent + labelPercent) * 2.0;
    double gapVertical = plotArea.getHeight() * gapPercent * 2.0;
    if (DEBUG_DRAW_INTERIOR) {
        double hGap = plotArea.getWidth() * getInteriorGap();
        double vGap = plotArea.getHeight() * getInteriorGap();
        double igx1 = plotArea.getX() + hGap;
        double igx2 = plotArea.getMaxX() - hGap;
        double igy1 = plotArea.getY() + vGap;
        double igy2 = plotArea.getMaxY() - vGap;
        g2.setPaint(Color.lightGray);
        g2.draw(new Rectangle2D.Double(igx1, igy1, igx2 - igx1, igy2 - igy1));
    }
    double linkX = plotArea.getX() + gapHorizontal / 2;
    double linkY = plotArea.getY() + gapVertical / 2;
    double linkW = plotArea.getWidth() - gapHorizontal;
    double linkH = plotArea.getHeight() - gapVertical;
    // make the link area a square if the pie chart is to be circular...
    if (isCircular()) {
        // is circular?
        double min = Math.min(linkW, linkH) / 2;
        linkX = (linkX + linkX + linkW) / 2 - min;
        linkY = (linkY + linkY + linkH) / 2 - min;
        linkW = 2 * min;
        linkH = 2 * min;
    }
    PiePlotState state = initialise(g2, plotArea, this, null, info);
    // the link area defines the dog leg points for the linking lines to
    // the labels
    Rectangle2D linkAreaXX = new Rectangle2D.Double(linkX, linkY, linkW, linkH * (1 - this.depthFactor));
    state.setLinkArea(linkAreaXX);
    if (DEBUG_DRAW_LINK_AREA) {
        g2.setPaint(Color.blue);
        g2.draw(linkAreaXX);
        g2.setPaint(Color.yellow);
        g2.draw(new Ellipse2D.Double(linkAreaXX.getX(), linkAreaXX.getY(), linkAreaXX.getWidth(), linkAreaXX.getHeight()));
    }
    // the explode area defines the max circle/ellipse for the exploded pie
    // sections.
    // it is defined by shrinking the linkArea by the linkMargin factor.
    double hh = linkW * getLabelLinkMargin();
    double vv = linkH * getLabelLinkMargin();
    Rectangle2D explodeArea = new Rectangle2D.Double(linkX + hh / 2.0, linkY + vv / 2.0, linkW - hh, linkH - vv);
    state.setExplodedPieArea(explodeArea);
    // the pie area defines the circle/ellipse for regular pie sections.
    // it is defined by shrinking the explodeArea by the explodeMargin
    // factor.
    double maximumExplodePercent = getMaximumExplodePercent();
    double percent = maximumExplodePercent / (1.0 + maximumExplodePercent);
    double h1 = explodeArea.getWidth() * percent;
    double v1 = explodeArea.getHeight() * percent;
    Rectangle2D pieArea = new Rectangle2D.Double(explodeArea.getX() + h1 / 2.0, explodeArea.getY() + v1 / 2.0, explodeArea.getWidth() - h1, explodeArea.getHeight() - v1);
    // the link area defines the dog-leg point for the linking lines to
    // the labels
    int depth = (int) (pieArea.getHeight() * this.depthFactor);
    Rectangle2D linkArea = new Rectangle2D.Double(linkX, linkY, linkW, linkH - depth);
    state.setLinkArea(linkArea);
    state.setPieArea(pieArea);
    state.setPieCenterX(pieArea.getCenterX());
    state.setPieCenterY(pieArea.getCenterY() - depth / 2.0);
    state.setPieWRadius(pieArea.getWidth() / 2.0);
    state.setPieHRadius((pieArea.getHeight() - depth) / 2.0);
    // get the data source - return if null;
    PieDataset dataset = getDataset();
    if (DatasetUtilities.isEmptyOrNull(getDataset())) {
        drawNoDataMessage(g2, plotArea);
        g2.setClip(savedClip);
        drawOutline(g2, plotArea);
        return;
    }
    // if too any elements
    if (dataset.getKeys().size() > plotArea.getWidth()) {
        String text = localizationResources.getString("Too_many_elements");
        Font sfont = new Font("dialog", Font.BOLD, 10);
        g2.setFont(sfont);
        FontMetrics fm = g2.getFontMetrics(sfont);
        int stringWidth = fm.stringWidth(text);
        g2.drawString(text, (int) (plotArea.getX() + (plotArea.getWidth() - stringWidth) / 2), (int) (plotArea.getY() + (plotArea.getHeight() / 2)));
        return;
    }
    // effect.
    if (isCircular()) {
        double min = Math.min(plotArea.getWidth(), plotArea.getHeight()) / 2;
        plotArea = new Rectangle2D.Double(plotArea.getCenterX() - min, plotArea.getCenterY() - min, 2 * min, 2 * min);
    }
    // get a list of keys...
    List sectionKeys = dataset.getKeys();
    if (sectionKeys.isEmpty()) {
        return;
    }
    // establish the coordinates of the top left corner of the drawing area
    double arcX = pieArea.getX();
    double arcY = pieArea.getY();
    // g2.clip(clipArea);
    Composite originalComposite = g2.getComposite();
    g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, getForegroundAlpha()));
    double totalValue = DatasetUtilities.calculatePieDatasetTotal(dataset);
    double runningTotal = 0;
    if (depth < 0) {
        // if depth is negative don't draw anything
        return;
    }
    ArrayList arcList = new ArrayList();
    Arc2D.Double arc;
    Paint paint;
    Paint outlinePaint;
    Stroke outlineStroke;
    Iterator iterator = sectionKeys.iterator();
    while (iterator.hasNext()) {
        Comparable currentKey = (Comparable) iterator.next();
        Number dataValue = dataset.getValue(currentKey);
        if (dataValue == null) {
            arcList.add(null);
            continue;
        }
        double value = dataValue.doubleValue();
        if (value <= 0) {
            arcList.add(null);
            continue;
        }
        double startAngle = getStartAngle();
        double direction = getDirection().getFactor();
        double angle1 = startAngle + (direction * (runningTotal * 360)) / totalValue;
        double angle2 = startAngle + (direction * (runningTotal + value) * 360) / totalValue;
        if (Math.abs(angle2 - angle1) > getMinimumArcAngleToDraw()) {
            arcList.add(new Arc2D.Double(arcX, arcY + depth, pieArea.getWidth(), pieArea.getHeight() - depth, angle1, angle2 - angle1, Arc2D.PIE));
        } else {
            arcList.add(null);
        }
        runningTotal += value;
    }
    Shape oldClip = g2.getClip();
    Ellipse2D top = new Ellipse2D.Double(pieArea.getX(), pieArea.getY(), pieArea.getWidth(), pieArea.getHeight() - depth);
    Ellipse2D bottom = new Ellipse2D.Double(pieArea.getX(), pieArea.getY() + depth, pieArea.getWidth(), pieArea.getHeight() - depth);
    Rectangle2D lower = new Rectangle2D.Double(top.getX(), top.getCenterY(), pieArea.getWidth(), bottom.getMaxY() - top.getCenterY());
    Rectangle2D upper = new Rectangle2D.Double(pieArea.getX(), top.getY(), pieArea.getWidth(), bottom.getCenterY() - top.getY());
    Area a = new Area(top);
    a.add(new Area(lower));
    Area b = new Area(bottom);
    b.add(new Area(upper));
    Area pie = new Area(a);
    pie.intersect(b);
    Area front = new Area(pie);
    front.subtract(new Area(top));
    Area back = new Area(pie);
    back.subtract(new Area(bottom));
    // draw the bottom circle
    int[] xs;
    int[] ys;
    int categoryCount = arcList.size();
    for (int categoryIndex = 0; categoryIndex < categoryCount; categoryIndex++) {
        arc = (Arc2D.Double) arcList.get(categoryIndex);
        if (arc == null) {
            continue;
        }
        Comparable key = getSectionKey(categoryIndex);
        paint = lookupSectionPaint(key);
        outlinePaint = lookupSectionOutlinePaint(key);
        outlineStroke = lookupSectionOutlineStroke(key);
        g2.setPaint(paint);
        g2.fill(arc);
        g2.setPaint(outlinePaint);
        g2.setStroke(outlineStroke);
        g2.draw(arc);
        g2.setPaint(paint);
        Point2D p1 = arc.getStartPoint();
        // draw the height
        xs = new int[] { (int) arc.getCenterX(), (int) arc.getCenterX(), (int) p1.getX(), (int) p1.getX() };
        ys = new int[] { (int) arc.getCenterY(), (int) arc.getCenterY() - depth, (int) p1.getY() - depth, (int) p1.getY() };
        Polygon polygon = new Polygon(xs, ys, 4);
        g2.setPaint(java.awt.Color.lightGray);
        g2.fill(polygon);
        g2.setPaint(outlinePaint);
        g2.setStroke(outlineStroke);
        g2.draw(polygon);
        g2.setPaint(paint);
    }
    g2.setPaint(Color.gray);
    g2.fill(back);
    g2.fill(front);
    // cycle through once drawing only the sides at the back...
    int cat = 0;
    iterator = arcList.iterator();
    while (iterator.hasNext()) {
        Arc2D segment = (Arc2D) iterator.next();
        if (segment != null) {
            Comparable key = getSectionKey(cat);
            paint = lookupSectionPaint(key);
            outlinePaint = lookupSectionOutlinePaint(key);
            outlineStroke = lookupSectionOutlineStroke(key);
            drawSide(g2, pieArea, segment, front, back, paint, outlinePaint, outlineStroke, false, true);
        }
        cat++;
    }
    // cycle through again drawing only the sides at the front...
    cat = 0;
    iterator = arcList.iterator();
    while (iterator.hasNext()) {
        Arc2D segment = (Arc2D) iterator.next();
        if (segment != null) {
            Comparable key = getSectionKey(cat);
            paint = lookupSectionPaint(key);
            outlinePaint = lookupSectionOutlinePaint(key);
            outlineStroke = lookupSectionOutlineStroke(key);
            drawSide(g2, pieArea, segment, front, back, paint, outlinePaint, outlineStroke, true, false);
        }
        cat++;
    }
    g2.setClip(oldClip);
    // draw the sections at the top of the pie (and set up tooltips)...
    Arc2D upperArc;
    for (int sectionIndex = 0; sectionIndex < categoryCount; sectionIndex++) {
        arc = (Arc2D.Double) arcList.get(sectionIndex);
        if (arc == null) {
            continue;
        }
        upperArc = new Arc2D.Double(arcX, arcY, pieArea.getWidth(), pieArea.getHeight() - depth, arc.getAngleStart(), arc.getAngleExtent(), Arc2D.PIE);
        Comparable currentKey = (Comparable) sectionKeys.get(sectionIndex);
        paint = lookupSectionPaint(currentKey, true);
        outlinePaint = lookupSectionOutlinePaint(currentKey);
        outlineStroke = lookupSectionOutlineStroke(currentKey);
        g2.setPaint(paint);
        g2.fill(upperArc);
        g2.setStroke(outlineStroke);
        g2.setPaint(outlinePaint);
        g2.draw(upperArc);
        // add a tooltip for the section...
        if (info != null) {
            EntityCollection entities = info.getOwner().getEntityCollection();
            if (entities != null) {
                String tip = null;
                PieToolTipGenerator tipster = getToolTipGenerator();
                if (tipster != null) {
                    // @mgs: using the method's return value was missing
                    tip = tipster.generateToolTip(dataset, currentKey);
                }
                String url = null;
                if (getURLGenerator() != null) {
                    url = getURLGenerator().generateURL(dataset, currentKey, getPieIndex());
                }
                PieSectionEntity entity = new PieSectionEntity(upperArc, dataset, getPieIndex(), sectionIndex, currentKey, tip, url);
                entities.add(entity);
            }
        }
    }
    List keys = dataset.getKeys();
    Rectangle2D adjustedPlotArea = new Rectangle2D.Double(originalPlotArea.getX(), originalPlotArea.getY(), originalPlotArea.getWidth(), originalPlotArea.getHeight() - depth);
    if (getSimpleLabels()) {
        drawSimpleLabels(g2, keys, totalValue, adjustedPlotArea, linkArea, state);
    } else {
        drawLabels(g2, keys, totalValue, adjustedPlotArea, linkArea, state);
    }
    if (getShadowGenerator() != null) {
        BufferedImage shadowImage = getShadowGenerator().createDropShadow(dataImage);
        g2 = savedG2;
        g2.drawImage(shadowImage, (int) plotArea.getX() + getShadowGenerator().calculateOffsetX(), (int) plotArea.getY() + getShadowGenerator().calculateOffsetY(), null);
        g2.drawImage(dataImage, (int) plotArea.getX(), (int) plotArea.getY(), null);
    }
    g2.setClip(savedClip);
    g2.setComposite(originalComposite);
    drawOutline(g2, originalPlotArea);
}

Example 89 with Polygon

use of java.awt.Polygon in project SIMVA-SoS by SESoS.

the class MeterPlot method draw.

/**
 * Draws the plot on a Java 2D graphics device (such as the screen or a
 * printer).
 *
 * @param g2  the graphics device.
 * @param area  the area within which the plot should be drawn.
 * @param anchor  the anchor point (<code>null</code> permitted).
 * @param parentState  the state from the parent plot, if there is one.
 * @param info  collects info about the drawing.
 */
@Override
public void draw(Graphics2D g2, Rectangle2D area, Point2D anchor, PlotState parentState, PlotRenderingInfo info) {
    if (info != null) {
        info.setPlotArea(area);
    }
    // adjust for insets...
    RectangleInsets insets = getInsets();
    insets.trim(area);
    area.setRect(area.getX() + 4, area.getY() + 4, area.getWidth() - 8, area.getHeight() - 8);
    // draw the background
    if (this.drawBorder) {
        drawBackground(g2, area);
    }
    // adjust the plot area by the interior spacing value
    double gapHorizontal = (2 * DEFAULT_BORDER_SIZE);
    double gapVertical = (2 * DEFAULT_BORDER_SIZE);
    double meterX = area.getX() + gapHorizontal / 2;
    double meterY = area.getY() + gapVertical / 2;
    double meterW = area.getWidth() - gapHorizontal;
    double meterH = area.getHeight() - gapVertical + ((this.meterAngle <= 180) && (this.shape != DialShape.CIRCLE) ? area.getHeight() / 1.25 : 0);
    double min = Math.min(meterW, meterH) / 2;
    meterX = (meterX + meterX + meterW) / 2 - min;
    meterY = (meterY + meterY + meterH) / 2 - min;
    meterW = 2 * min;
    meterH = 2 * min;
    Rectangle2D meterArea = new Rectangle2D.Double(meterX, meterY, meterW, meterH);
    Rectangle2D.Double originalArea = new Rectangle2D.Double(meterArea.getX() - 4, meterArea.getY() - 4, meterArea.getWidth() + 8, meterArea.getHeight() + 8);
    double meterMiddleX = meterArea.getCenterX();
    double meterMiddleY = meterArea.getCenterY();
    // plot the data (unless the dataset is null)...
    ValueDataset data = getDataset();
    if (data != null) {
        double dataMin = this.range.getLowerBound();
        double dataMax = this.range.getUpperBound();
        Shape savedClip = g2.getClip();
        g2.clip(originalArea);
        Composite originalComposite = g2.getComposite();
        g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, getForegroundAlpha()));
        if (this.dialBackgroundPaint != null) {
            fillArc(g2, originalArea, dataMin, dataMax, this.dialBackgroundPaint, true);
        }
        drawTicks(g2, meterArea, dataMin, dataMax);
        drawArcForInterval(g2, meterArea, new MeterInterval("", this.range, this.dialOutlinePaint, new BasicStroke(1.0f), null));
        Iterator iterator = this.intervals.iterator();
        while (iterator.hasNext()) {
            MeterInterval interval = (MeterInterval) iterator.next();
            drawArcForInterval(g2, meterArea, interval);
        }
        Number n = data.getValue();
        if (n != null) {
            double value = n.doubleValue();
            drawValueLabel(g2, meterArea);
            if (this.range.contains(value)) {
                g2.setPaint(this.needlePaint);
                g2.setStroke(new BasicStroke(2.0f));
                double radius = (meterArea.getWidth() / 2) + DEFAULT_BORDER_SIZE + 15;
                double valueAngle = valueToAngle(value);
                double valueP1 = meterMiddleX + (radius * Math.cos(Math.PI * (valueAngle / 180)));
                double valueP2 = meterMiddleY - (radius * Math.sin(Math.PI * (valueAngle / 180)));
                Polygon arrow = new Polygon();
                if ((valueAngle > 135 && valueAngle < 225) || (valueAngle < 45 && valueAngle > -45)) {
                    double valueP3 = (meterMiddleY - DEFAULT_CIRCLE_SIZE / 4);
                    double valueP4 = (meterMiddleY + DEFAULT_CIRCLE_SIZE / 4);
                    arrow.addPoint((int) meterMiddleX, (int) valueP3);
                    arrow.addPoint((int) meterMiddleX, (int) valueP4);
                } else {
                    arrow.addPoint((int) (meterMiddleX - DEFAULT_CIRCLE_SIZE / 4), (int) meterMiddleY);
                    arrow.addPoint((int) (meterMiddleX + DEFAULT_CIRCLE_SIZE / 4), (int) meterMiddleY);
                }
                arrow.addPoint((int) valueP1, (int) valueP2);
                g2.fill(arrow);
                Ellipse2D circle = new Ellipse2D.Double(meterMiddleX - DEFAULT_CIRCLE_SIZE / 2, meterMiddleY - DEFAULT_CIRCLE_SIZE / 2, DEFAULT_CIRCLE_SIZE, DEFAULT_CIRCLE_SIZE);
                g2.fill(circle);
            }
        }
        g2.setClip(savedClip);
        g2.setComposite(originalComposite);
    }
    if (this.drawBorder) {
        drawOutline(g2, area);
    }
}

Example 90 with Polygon

use of java.awt.Polygon in project SIMVA-SoS by SESoS.

the class XYStepAreaRenderer method drawItem.

/**
 * Draws the visual representation of a single data item.
 *
 * @param g2  the graphics device.
 * @param state  the renderer state.
 * @param dataArea  the area within which the data is being drawn.
 * @param info  collects information about the drawing.
 * @param plot  the plot (can be used to obtain standard color information
 *              etc).
 * @param domainAxis  the domain axis.
 * @param rangeAxis  the range axis.
 * @param dataset  the dataset.
 * @param series  the series index (zero-based).
 * @param item  the item index (zero-based).
 * @param crosshairState  crosshair information for the plot
 *                        (<code>null</code> permitted).
 * @param pass  the pass index.
 */
@Override
public void drawItem(Graphics2D g2, XYItemRendererState state, Rectangle2D dataArea, PlotRenderingInfo info, XYPlot plot, ValueAxis domainAxis, ValueAxis rangeAxis, XYDataset dataset, int series, int item, CrosshairState crosshairState, int pass) {
    PlotOrientation orientation = plot.getOrientation();
    // Get the item count for the series, so that we can know which is the
    // end of the series.
    int itemCount = dataset.getItemCount(series);
    Paint paint = getItemPaint(series, item);
    Stroke seriesStroke = getItemStroke(series, item);
    g2.setPaint(paint);
    g2.setStroke(seriesStroke);
    // get the data point...
    double x1 = dataset.getXValue(series, item);
    double y1 = dataset.getYValue(series, item);
    double x = x1;
    double y = Double.isNaN(y1) ? getRangeBase() : y1;
    double transX1 = domainAxis.valueToJava2D(x, dataArea, plot.getDomainAxisEdge());
    double transY1 = rangeAxis.valueToJava2D(y, dataArea, plot.getRangeAxisEdge());
    // avoid possible sun.dc.pr.PRException: endPath: bad path
    transY1 = restrictValueToDataArea(transY1, plot, dataArea);
    if (this.pArea == null && !Double.isNaN(y1)) {
        // Create a new Area for the series
        this.pArea = new Polygon();
        // start from Y = rangeBase
        double transY2 = rangeAxis.valueToJava2D(getRangeBase(), dataArea, plot.getRangeAxisEdge());
        // avoid possible sun.dc.pr.PRException: endPath: bad path
        transY2 = restrictValueToDataArea(transY2, plot, dataArea);
        // The first point is (x, this.baseYValue)
        if (orientation == PlotOrientation.VERTICAL) {
            this.pArea.addPoint((int) transX1, (int) transY2);
        } else if (orientation == PlotOrientation.HORIZONTAL) {
            this.pArea.addPoint((int) transY2, (int) transX1);
        }
    }
    double transX0;
    double transY0;
    double x0;
    double y0;
    if (item > 0) {
        // get the previous data point...
        x0 = dataset.getXValue(series, item - 1);
        y0 = Double.isNaN(y1) ? y1 : dataset.getYValue(series, item - 1);
        x = x0;
        y = Double.isNaN(y0) ? getRangeBase() : y0;
        transX0 = domainAxis.valueToJava2D(x, dataArea, plot.getDomainAxisEdge());
        transY0 = rangeAxis.valueToJava2D(y, dataArea, plot.getRangeAxisEdge());
        // avoid possible sun.dc.pr.PRException: endPath: bad path
        transY0 = restrictValueToDataArea(transY0, plot, dataArea);
        if (Double.isNaN(y1)) {
            // NULL value -> insert point on base line
            // instead of 'step point'
            transX1 = transX0;
            transY0 = transY1;
        }
        if (transY0 != transY1) {
            // not just a horizontal bar but need to perform a 'step'.
            double transXs = transX0 + (getStepPoint() * (transX1 - transX0));
            if (orientation == PlotOrientation.VERTICAL) {
                this.pArea.addPoint((int) transXs, (int) transY0);
                this.pArea.addPoint((int) transXs, (int) transY1);
            } else if (orientation == PlotOrientation.HORIZONTAL) {
                this.pArea.addPoint((int) transY0, (int) transXs);
                this.pArea.addPoint((int) transY1, (int) transXs);
            }
        }
    }
    Shape shape = null;
    if (!Double.isNaN(y1)) {
        // Add each point to Area (x, y)
        if (orientation == PlotOrientation.VERTICAL) {
            this.pArea.addPoint((int) transX1, (int) transY1);
        } else if (orientation == PlotOrientation.HORIZONTAL) {
            this.pArea.addPoint((int) transY1, (int) transX1);
        }
        if (getShapesVisible()) {
            shape = getItemShape(series, item);
            if (orientation == PlotOrientation.VERTICAL) {
                shape = ShapeUtilities.createTranslatedShape(shape, transX1, transY1);
            } else if (orientation == PlotOrientation.HORIZONTAL) {
                shape = ShapeUtilities.createTranslatedShape(shape, transY1, transX1);
            }
            if (isShapesFilled()) {
                g2.fill(shape);
            } else {
                g2.draw(shape);
            }
        } else {
            if (orientation == PlotOrientation.VERTICAL) {
                shape = new Rectangle2D.Double(transX1 - 2, transY1 - 2, 4.0, 4.0);
            } else if (orientation == PlotOrientation.HORIZONTAL) {
                shape = new Rectangle2D.Double(transY1 - 2, transX1 - 2, 4.0, 4.0);
            }
        }
    }
    // a single point.
    if (getPlotArea() && item > 0 && this.pArea != null && (item == (itemCount - 1) || Double.isNaN(y1))) {
        double transY2 = rangeAxis.valueToJava2D(getRangeBase(), dataArea, plot.getRangeAxisEdge());
        // avoid possible sun.dc.pr.PRException: endPath: bad path
        transY2 = restrictValueToDataArea(transY2, plot, dataArea);
        if (orientation == PlotOrientation.VERTICAL) {
            // Add the last point (x,0)
            this.pArea.addPoint((int) transX1, (int) transY2);
        } else if (orientation == PlotOrientation.HORIZONTAL) {
            // Add the last point (x,0)
            this.pArea.addPoint((int) transY2, (int) transX1);
        }
        // fill the polygon
        g2.fill(this.pArea);
        // draw an outline around the Area.
        if (isOutline()) {
            g2.setStroke(plot.getOutlineStroke());
            g2.setPaint(plot.getOutlinePaint());
            g2.draw(this.pArea);
        }
        // start new area when needed (see above)
        this.pArea = null;
    }
    // do we need to update the crosshair values?
    if (!Double.isNaN(y1)) {
        int domainAxisIndex = plot.getDomainAxisIndex(domainAxis);
        int rangeAxisIndex = plot.getRangeAxisIndex(rangeAxis);
        updateCrosshairValues(crosshairState, x1, y1, domainAxisIndex, rangeAxisIndex, transX1, transY1, orientation);
    }
    // collect entity and tool tip information...
    EntityCollection entities = state.getEntityCollection();
    if (entities != null) {
        addEntity(entities, shape, dataset, series, item, transX1, transY1);
    }
}