public HighLowRenderer() 
{
            
        super();
        this.drawOpenTicks = true;
        this.drawCloseTicks = true;
        this.tickLength = 2.0;
}

The default constructor.

 public Object clone() throws CloneNotSupportedException 
{
        return super.clone();
}

Returns a clone of the renderer.

 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) 
{
        double x = dataset.getXValue(series, item);
        if (!domainAxis.getRange().contains(x)) {
            return;    // the x value is not within the axis range
        }
        double xx = domainAxis.valueToJava2D(x, dataArea,
                plot.getDomainAxisEdge());
        // setup for collecting optional entity info...
        Shape entityArea = null;
        EntityCollection entities = null;
        if (info != null) {
            entities = info.getOwner().getEntityCollection();
        }
        PlotOrientation orientation = plot.getOrientation();
        RectangleEdge location = plot.getRangeAxisEdge();
        Paint itemPaint = getItemPaint(series, item);
        Stroke itemStroke = getItemStroke(series, item);
        g2.setPaint(itemPaint);
        g2.setStroke(itemStroke);
        if (dataset instanceof OHLCDataset) {
            OHLCDataset hld = (OHLCDataset) dataset;
            double yHigh = hld.getHighValue(series, item);
            double yLow = hld.getLowValue(series, item);
            if (!Double.isNaN(yHigh) && !Double.isNaN(yLow)) {
                double yyHigh = rangeAxis.valueToJava2D(yHigh, dataArea,
                        location);
                double yyLow = rangeAxis.valueToJava2D(yLow, dataArea,
                        location);
                if (orientation == PlotOrientation.HORIZONTAL) {
                    g2.draw(new Line2D.Double(yyLow, xx, yyHigh, xx));
                    entityArea = new Rectangle2D.Double(Math.min(yyLow, yyHigh),
                            xx - 1.0, Math.abs(yyHigh - yyLow), 2.0);
                }
                else if (orientation == PlotOrientation.VERTICAL) {
                    g2.draw(new Line2D.Double(xx, yyLow, xx, yyHigh));
                    entityArea = new Rectangle2D.Double(xx - 1.0,
                            Math.min(yyLow, yyHigh), 2.0,
                            Math.abs(yyHigh - yyLow));
                }
            }
            double delta = getTickLength();
            if (domainAxis.isInverted()) {
                delta = -delta;
            }
            if (getDrawOpenTicks()) {
                double yOpen = hld.getOpenValue(series, item);
                if (!Double.isNaN(yOpen)) {
                    double yyOpen = rangeAxis.valueToJava2D(yOpen, dataArea,
                            location);
                    if (this.openTickPaint != null) {
                        g2.setPaint(this.openTickPaint);
                    }
                    else {
                        g2.setPaint(itemPaint);
                    }
                    if (orientation == PlotOrientation.HORIZONTAL) {
                        g2.draw(new Line2D.Double(yyOpen, xx + delta, yyOpen,
                                xx));
                    }
                    else if (orientation == PlotOrientation.VERTICAL) {
                        g2.draw(new Line2D.Double(xx - delta, yyOpen, xx,
                                yyOpen));
                    }
                }
            }
            if (getDrawCloseTicks()) {
                double yClose = hld.getCloseValue(series, item);
                if (!Double.isNaN(yClose)) {
                    double yyClose = rangeAxis.valueToJava2D(
                        yClose, dataArea, location);
                    if (this.closeTickPaint != null) {
                        g2.setPaint(this.closeTickPaint);
                    }
                    else {
                        g2.setPaint(itemPaint);
                    }
                    if (orientation == PlotOrientation.HORIZONTAL) {
                        g2.draw(new Line2D.Double(yyClose, xx, yyClose,
                                xx - delta));
                    }
                    else if (orientation == PlotOrientation.VERTICAL) {
                        g2.draw(new Line2D.Double(xx, yyClose, xx + delta,
                                yyClose));
                    }
                }
            }
        }
        else {
            // not a HighLowDataset, so just draw a line connecting this point
            // with the previous point...
            if (item  > 0) {
                double x0 = dataset.getXValue(series, item - 1);
                double y0 = dataset.getYValue(series, item - 1);
                double y = dataset.getYValue(series, item);
                if (Double.isNaN(x0) || Double.isNaN(y0) || Double.isNaN(y)) {
                    return;
                }
                double xx0 = domainAxis.valueToJava2D(x0, dataArea,
                        plot.getDomainAxisEdge());
                double yy0 = rangeAxis.valueToJava2D(y0, dataArea, location);
                double yy = rangeAxis.valueToJava2D(y, dataArea, location);
                if (orientation == PlotOrientation.HORIZONTAL) {
                    g2.draw(new Line2D.Double(yy0, xx0, yy, xx));
                }
                else if (orientation == PlotOrientation.VERTICAL) {
                    g2.draw(new Line2D.Double(xx0, yy0, xx, yy));
                }
            }
        }
        // add an entity for the item...
        if (entities != null) {
            String tip = null;
            XYToolTipGenerator generator = getToolTipGenerator(series, item);
            if (generator != null) {
                tip = generator.generateToolTip(dataset, series, item);
            }
            String url = null;
            if (getURLGenerator() != null) {
                url = getURLGenerator().generateURL(dataset, series, item);
            }
            XYItemEntity entity = new XYItemEntity(entityArea, dataset,
                    series, item, tip, url);
            entities.add(entity);
        }
}

Draws the visual representation of a single data item.

 public boolean equals(Object obj) 
{
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof HighLowRenderer)) {
            return false;
        }
        HighLowRenderer that = (HighLowRenderer) obj;
        if (this.drawOpenTicks != that.drawOpenTicks) {
            return false;
        }
        if (this.drawCloseTicks != that.drawCloseTicks) {
            return false;
        }
        if (!PaintUtilities.equal(this.openTickPaint, that.openTickPaint)) {
            return false;
        }
        if (!PaintUtilities.equal(this.closeTickPaint, that.closeTickPaint)) {
            return false;
        }
        if (this.tickLength != that.tickLength) {
            return false;
        }
        if (!super.equals(obj)) {
            return false;
        }
        return true;
}

Tests this renderer for equality with an arbitrary object.

 public Range findRangeBounds(XYDataset dataset) 
{
        if (dataset != null) {
            return DatasetUtilities.findRangeBounds(dataset, true);
        }
        else {
            return null;
        }
}

Returns the range of values the renderer requires to display all the items from the specified dataset.

 public Paint getCloseTickPaint() 
{
        return this.closeTickPaint;
}

Returns the paint used to draw the ticks for the close values.

 public boolean getDrawCloseTicks() 
{
        return this.drawCloseTicks;
}

Returns the flag that controls whether close ticks are drawn.

 public boolean getDrawOpenTicks() 
{
        return this.drawOpenTicks;
}

Returns the flag that controls whether open ticks are drawn.

 public Paint getOpenTickPaint() 
{
        return this.openTickPaint;
}

Returns the paint used to draw the ticks for the open values.

 public double getTickLength() 
{
        return this.tickLength;
}

Returns the tick length (in Java2D units).

 public  void setCloseTickPaint(Paint paint) 
{
        this.closeTickPaint = paint;
        fireChangeEvent();
}

Sets the paint used to draw the ticks for the close values and sends a RendererChangeEvent to all registered listeners. If you set this to null (the default), the series paint is used instead.

 public  void setDrawCloseTicks(boolean draw) 
{
        this.drawCloseTicks = draw;
        fireChangeEvent();
}

Sets the flag that controls whether close ticks are drawn, and sends a RendererChangeEvent to all registered listeners.

 public  void setDrawOpenTicks(boolean draw) 
{
        this.drawOpenTicks = draw;
        fireChangeEvent();
}

Sets the flag that controls whether open ticks are drawn, and sends a RendererChangeEvent to all registered listeners.

 public  void setOpenTickPaint(Paint paint) 
{
        this.openTickPaint = paint;
        fireChangeEvent();
}

Sets the paint used to draw the ticks for the open values and sends a RendererChangeEvent to all registered listeners. If you set this to null (the default), the series paint is used instead.

 public  void setTickLength(double length) 
{
        this.tickLength = length;
        fireChangeEvent();
}

Sets the tick length (in Java2D units) and sends a RendererChangeEvent to all registered listeners.