Java Code Examples for java.awt.Stroke

/**
 * Utility method for drawing a line perpendicular to the range axis (used
 * for crosshairs).
 *
 * @param g2  the graphics device.
 * @param dataArea  the area defined by the axes.
 * @param value  the data value.
 * @param stroke  the line stroke (<code>null</code> not permitted).
 * @param paint  the line paint (<code>null</code> not permitted).
 */
protected void drawRangeLine(Graphics2D g2, Rectangle2D dataArea,
        double value, Stroke stroke, Paint paint) {

    double java2D = getRangeAxis().valueToJava2D(value, dataArea, 
            getRangeAxisEdge());
    Line2D line = null;
    if (this.orientation == PlotOrientation.HORIZONTAL) {
        line = new Line2D.Double(java2D, dataArea.getMinY(), java2D, 
                dataArea.getMaxY());
    }
    else if (this.orientation == PlotOrientation.VERTICAL) {
        line = new Line2D.Double(dataArea.getMinX(), java2D, 
                dataArea.getMaxX(), java2D);
    }
    g2.setStroke(stroke);
    g2.setPaint(paint);
    g2.draw(line);

}
 

@Override
protected void paintComponent(Graphics g) {
  super.paintComponent(g);
  Graphics2D g2 = (Graphics2D) g;
  Stroke stroke = g2.getStroke();
  //shift the image for pressed buttons
  if (!getModel().isPressed()) {
    g2.translate(-1, -1);
  }
  g2.setStroke(new BasicStroke(2));
  g.setColor(Color.BLACK);
  if (getModel().isRollover()) {
    g.setColor(Color.MAGENTA);
  }
  int delta = 6;
  g.drawLine(delta, delta, getWidth() - delta - 1, getHeight() - delta - 1);
  g.drawLine(getWidth() - delta - 1, delta, delta, getHeight() - delta - 1);
  //leave the graphics unchanged
  if (!getModel().isPressed()) {
    g.translate(1, 1);
  }
  g2.setStroke(stroke);
}
 

/**
 * Creates a new crosshair value with the specified value and line style.
 *
 * @param value  the value.
 * @param paint  the line paint (<code>null</code> not permitted).
 * @param stroke  the line stroke (<code>null</code> not permitted).
 */
public Crosshair(double value, Paint paint, Stroke stroke) {
    ParamChecks.nullNotPermitted(paint, "paint");
    ParamChecks.nullNotPermitted(stroke, "stroke");
    this.visible = true;
    this.value = value;
    this.paint = paint;
    this.stroke = stroke;
    this.labelVisible = false;
    this.labelGenerator = new StandardCrosshairLabelGenerator();
    this.labelAnchor = RectangleAnchor.BOTTOM_LEFT;
    this.labelXOffset = 3.0;
    this.labelYOffset = 3.0;
    this.labelFont = new Font("Tahoma", Font.PLAIN, 12);
    this.labelPaint = Color.black;
    this.labelBackgroundPaint = new Color(0, 0, 255, 63);
    this.labelOutlineVisible = true;
    this.labelOutlinePaint = Color.black;
    this.labelOutlineStroke = new BasicStroke(0.5f);
    this.pcs = new PropertyChangeSupport(this);
}
 

/**
 * Sets the stroke that will be used to draw shapes.
 * 
 * @param s  the stroke ({@code null} not permitted).
 * 
 * @see #getStroke() 
 */
@Override
public void setStroke(Stroke s) {
    nullNotPermitted(s, "s");
    this.stroke = s;
    if (stroke instanceof BasicStroke) {
        BasicStroke bs = (BasicStroke) s;
        double lineWidth = bs.getLineWidth();
        if (lineWidth == 0.0) {
            lineWidth = this.zeroStrokeWidth;
        }
        this.gc.setLineWidth(lineWidth);
        this.gc.setLineCap(awtToJavaFXLineCap(bs.getEndCap()));
        this.gc.setLineJoin(awtToJavaFXLineJoin(bs.getLineJoin()));
        this.gc.setMiterLimit(bs.getMiterLimit());
    }
}
 

@Override
protected void paintWidget() {
    super.paintWidget();
    Graphics2D g = this.getGraphics();
    Stroke old = g.getStroke();
    g.setColor(Color.BLUE);
    Rectangle r = new Rectangle(this.getPreferredBounds());
    r.width--;
    r.height--;
    if (this.getBounds().width > 0 && this.getBounds().height > 0) {
        g.setStroke(new BasicStroke(2));
        g.drawRect(r.x, r.y, r.width, r.height);
    }

    Color titleColor = Color.BLACK;
    g.setColor(titleColor);
    g.setFont(titleFont);

    String s = "B" + blockNode.getName();
    Rectangle2D r1 = g.getFontMetrics().getStringBounds(s, g);
    g.drawString(s, r.x + 5, r.y + (int) r1.getHeight());
    g.setStroke(old);
}
 

/**
 * Tests this map for equality with an arbitrary object.
 *
 * @param obj  the object (<code>null</code> permitted).
 *
 * @return A boolean.
 */
@Override
public boolean equals(Object obj) {
    if (obj == this) {
        return true;
    }
    if (!(obj instanceof StrokeMap)) {
        return false;
    }
    StrokeMap that = (StrokeMap) obj;
    if (this.store.size() != that.store.size()) {
        return false;
    }
    Set keys = this.store.keySet();
    Iterator iterator = keys.iterator();
    while (iterator.hasNext()) {
        Comparable key = (Comparable) iterator.next();
        Stroke s1 = getStroke(key);
        Stroke s2 = that.getStroke(key);
        if (!ObjectUtilities.equal(s1, s2)) {
            return false;
        }
    }
    return true;
}
 

void drawUnderline(Graphics2D g2d,
                   float thickness,
                   float x1,
                   float x2,
                   float y) {

    Stroke saveStroke = g2d.getStroke();
    g2d.setStroke(stroke);

    Line2D.Float drawLine = new Line2D.Float(x1, y, x2, y);
    g2d.draw(drawLine);

    drawLine.y1 += DEFAULT_THICKNESS;
    drawLine.y2 += DEFAULT_THICKNESS;
    drawLine.x1 += DEFAULT_THICKNESS;

    g2d.draw(drawLine);

    g2d.setStroke(saveStroke);
}
 

@Override
public void paint(Graphics2D g) {

    g.setColor(function.getBackground());
    final Rectangle2D rect = movingArea.getBounds(getBounds());

    RoundRectangle2D.Double rec = new RoundRectangle2D.Double(rect.getX(),
            rect.getY(), rect.getWidth(), rect.getHeight(),
            movingArea.getIDoubleOrdinate(4),
            movingArea.getIDoubleOrdinate(4));

    g.fill(rec);
    g.setFont(function.getFont());
    paintText(g);

    paintBorder(g);

    final Stroke tmp = g.getStroke();
    g.draw(rec);
    g.setStroke(tmp);
    paintTringle(g);

}
 

/**
 * Draws a grid line against the domain axis.
 * <P>
 * Note that this default implementation assumes that the horizontal axis
 * is the domain axis. If this is not the case, you will need to override
 * this method.
 *
 * @param g2  the graphics device.
 * @param plot  the plot.
 * @param dataArea  the area for plotting data (not yet adjusted for any
 *                  3D effect).
 * @param value  the Java2D value at which the grid line should be drawn.
 * @param paint  the paint (<code>null</code> not permitted).
 * @param stroke  the stroke (<code>null</code> not permitted).
 *
 * @see #drawRangeGridline(Graphics2D, CategoryPlot, ValueAxis,
 *     Rectangle2D, double)
 *
 * @since 1.2.0
 */
public void drawDomainLine(Graphics2D g2, CategoryPlot plot,
        Rectangle2D dataArea, double value, Paint paint, Stroke stroke) {

    if (paint == null) {
        throw new IllegalArgumentException("Null 'paint' argument.");
    }
    if (stroke == null) {
        throw new IllegalArgumentException("Null 'stroke' argument.");
    }
    Line2D line = null;
    PlotOrientation orientation = plot.getOrientation();

    if (orientation == PlotOrientation.HORIZONTAL) {
        line = new Line2D.Double(dataArea.getMinX(), value,
                dataArea.getMaxX(), value);
    }
    else if (orientation == PlotOrientation.VERTICAL) {
        line = new Line2D.Double(value, dataArea.getMinY(), value,
                dataArea.getMaxY());
    }

    g2.setPaint(paint);
    g2.setStroke(stroke);
    g2.draw(line);

}
 

/**
 * Constructs a new marker.
 *
 * @param paint  the paint (<code>null</code> not permitted).
 * @param stroke  the stroke (<code>null</code> not permitted).
 * @param outlinePaint  the outline paint (<code>null</code> permitted).
 * @param outlineStroke  the outline stroke (<code>null</code> permitted).
 * @param alpha  the alpha transparency (must be in the range 0.0f to 
 *     1.0f).
 *     
 * @throws IllegalArgumentException if <code>paint</code> or 
 *     <code>stroke</code> is <code>null</code>, or <code>alpha</code> is 
 *     not in the specified range.
 */
protected Marker(Paint paint, Stroke stroke, 
                 Paint outlinePaint, Stroke outlineStroke, 
                 float alpha) {

    if (paint == null) {
        throw new IllegalArgumentException("Null 'paint' argument.");
    }
    if (stroke == null) {
        throw new IllegalArgumentException("Null 'stroke' argument.");
    }
    if (alpha < 0.0f || alpha > 1.0f)
        throw new IllegalArgumentException(
                "The 'alpha' value must be in the range 0.0f to 1.0f");
    
    this.paint = paint;
    this.stroke = stroke;
    this.outlinePaint = outlinePaint;
    this.outlineStroke = outlineStroke;
    this.alpha = alpha;
    
    this.labelFont = new Font("SansSerif", Font.PLAIN, 9);
    this.labelPaint = Color.black;
    this.labelAnchor = RectangleAnchor.TOP_LEFT;
    this.labelOffset = new RectangleInsets(3.0, 3.0, 3.0, 3.0);
    this.labelOffsetType = LengthAdjustmentType.CONTRACT;
    this.labelTextAnchor = TextAnchor.CENTER;
    
    this.listenerList = new EventListenerList();
}
 

/**
 * Provides serialization support.
 *
 * @param stream  the output stream.
 *
 * @throws IOException  if there is an I/O error.
 */
private void writeObject(ObjectOutputStream stream) throws IOException {
    stream.defaultWriteObject();
    stream.writeInt(this.store.size());
    Set keys = this.store.keySet();
    Iterator iterator = keys.iterator();
    while (iterator.hasNext()) {
        Comparable key = (Comparable) iterator.next();
        stream.writeObject(key);
        Stroke stroke = getStroke(key);
        SerialUtilities.writeStroke(stroke, stream);
    }
}
 

/**
 * Creates a new instance.
 *
 * @param periodClass  the subclass of {@link RegularTimePeriod} to use
 *                     (<code>null</code> not permitted).
 * @param dateFormat  the date format (<code>null</code> not permitted).
 * @param padding  controls the space around the band (<code>null</code>
 *                 not permitted).
 * @param labelFont  the label font (<code>null</code> not permitted).
 * @param labelPaint  the label paint (<code>null</code> not permitted).
 * @param drawDividers  a flag that controls whether dividers are drawn.
 * @param dividerStroke  the stroke used to draw the dividers
 *                       (<code>null</code> not permitted).
 * @param dividerPaint  the paint used to draw the dividers
 *                      (<code>null</code> not permitted).
 */
public PeriodAxisLabelInfo(Class periodClass, DateFormat dateFormat,
                           RectangleInsets padding,
                           Font labelFont, Paint labelPaint,
                           boolean drawDividers, Stroke dividerStroke,
                           Paint dividerPaint) {
    if (periodClass == null) {
        throw new IllegalArgumentException("Null 'periodClass' argument.");
    }
    if (dateFormat == null) {
        throw new IllegalArgumentException("Null 'dateFormat' argument.");
    }
    if (padding == null) {
        throw new IllegalArgumentException("Null 'padding' argument.");
    }
    if (labelFont == null) {
        throw new IllegalArgumentException("Null 'labelFont' argument.");
    }
    if (labelPaint == null) {
        throw new IllegalArgumentException("Null 'labelPaint' argument.");
    }
    if (dividerStroke == null) {
        throw new IllegalArgumentException(
                "Null 'dividerStroke' argument.");
    }
    if (dividerPaint == null) {
        throw new IllegalArgumentException("Null 'dividerPaint' argument.");
    }
    this.periodClass = periodClass;
    this.dateFormat = dateFormat;
    this.padding = padding;
    this.labelFont = labelFont;
    this.labelPaint = labelPaint;
    this.drawDividers = drawDividers;
    this.dividerStroke = dividerStroke;
    this.dividerPaint = dividerPaint;
}
 

/**
 * Draws a grid line against the range axis.
 *
 * @param g2  the graphics device.
 * @param plot  the plot.
 * @param axis  the value axis.
 * @param dataArea  the area for plotting data (not yet adjusted for any 
 *                  3D effect).
 * @param value  the value at which the grid line should be drawn.
 *
 */
public void drawRangeGridline(Graphics2D g2,
                              CategoryPlot plot,
                              ValueAxis axis,
                              Rectangle2D dataArea,
                              double value) {

    Range range = axis.getRange();
    if (!range.contains(value)) {
        return;
    }

    PlotOrientation orientation = plot.getOrientation();
    double v = axis.valueToJava2D(value, dataArea, plot.getRangeAxisEdge());
    Line2D line = null;
    if (orientation == PlotOrientation.HORIZONTAL) {
        line = new Line2D.Double(v, dataArea.getMinY(), v, 
                dataArea.getMaxY());
    }
    else if (orientation == PlotOrientation.VERTICAL) {
        line = new Line2D.Double(dataArea.getMinX(), v, 
                dataArea.getMaxX(), v);
    }

    Paint paint = plot.getRangeGridlinePaint();
    if (paint == null) {
        paint = CategoryPlot.DEFAULT_GRIDLINE_PAINT;
    }
    g2.setPaint(paint);

    Stroke stroke = plot.getRangeGridlineStroke();
    if (stroke == null) {
        stroke = CategoryPlot.DEFAULT_GRIDLINE_STROKE;
    }
    g2.setStroke(stroke);

    g2.draw(line);

}
 

/**
 * Creates a new supplier.
 *
 * @param paintSequence  the fill paint sequence.
 * @param outlinePaintSequence  the outline paint sequence.
 * @param strokeSequence  the stroke sequence.
 * @param outlineStrokeSequence  the outline stroke sequence.
 * @param shapeSequence  the shape sequence.
 */
public DefaultDrawingSupplier(Paint[] paintSequence,
                              Paint[] outlinePaintSequence,
                              Stroke[] strokeSequence,
                              Stroke[] outlineStrokeSequence,
                              Shape[] shapeSequence) {

    this.paintSequence = paintSequence;
    this.fillPaintSequence = DEFAULT_FILL_PAINT_SEQUENCE;
    this.outlinePaintSequence = outlinePaintSequence;
    this.strokeSequence = strokeSequence;
    this.outlineStrokeSequence = outlineStrokeSequence;
    this.shapeSequence = shapeSequence;

}
 

/**
 * Draws a horizontal line across the chart to represent a 'range marker'.
 *
 * @param g2  the graphics device.
 * @param plot  the plot.
 * @param rangeAxis  the range axis.
 * @param marker  the marker line.
 * @param dataArea  the axis data area.
 */
public void drawRangeMarker(Graphics2D g2,
                            ContourPlot plot,
                            ValueAxis rangeAxis,
                            Marker marker,
                            Rectangle2D dataArea) {

    if (marker instanceof ValueMarker) {
        ValueMarker vm = (ValueMarker) marker;
        double value = vm.getValue();
        Range range = rangeAxis.getRange();
        if (!range.contains(value)) {
            return;
        }

        double y = rangeAxis.valueToJava2D(value, dataArea,
                RectangleEdge.LEFT);
        Line2D line = new Line2D.Double(dataArea.getMinX(), y,
                dataArea.getMaxX(), y);
        Paint paint = marker.getOutlinePaint();
        Stroke stroke = marker.getOutlineStroke();
        g2.setPaint(paint != null ? paint : Plot.DEFAULT_OUTLINE_PAINT);
        g2.setStroke(stroke != null ? stroke : Plot.DEFAULT_OUTLINE_STROKE);
        g2.draw(line);
    }

}
 

public void paint(Graphics2D g2, Rectangle rect) {
    Paint oldPaint = g2.getPaint();
    
    Arc2D arc = new Arc2D.Double(rect.x - radius + 0.5f, rect.y + rect.height - radius *2 +0.5f,
            radius*2, radius*2, -90, 90, Arc2D.OPEN);
    GeneralPath gp = new GeneralPath(arc);
    arc = new Arc2D.Double(rect.x+radius+0.5f, rect.y+0.5f,
            radius*4, radius*4, 180, -90, Arc2D.OPEN);
    gp.append(arc,true);
    arc = new Arc2D.Double(rect.x + rect.width - radius*6 +1f, rect.y+0.5f,
            radius*4, radius*4, 90, -90, Arc2D.OPEN);
    gp.append(arc,true);
    arc = new Arc2D.Double(rect.x + rect.width - radius*2 +1f, rect.y + rect.height - radius*2 +0.5f,
            radius*2, radius*2, 180, 90, Arc2D.OPEN);
    gp.append(arc,true);
    if (tabbedPane.selectedTab==tab) {
        g2.setPaint(SELECTED_TAB_COLOR);
        g2.fill(gp);
    } else {
        g2.setPaint(TAB_COLOR);
        g2.fill(gp);
        gp.closePath();
    }
    g2.setPaint(TAB_BORDER_COLOR);
    if (tab.getState().isFocused()) {
        Stroke s = g2.getStroke ();
        g2.setStroke (new BasicStroke(1.5f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, BasicStroke.JOIN_MITER, new float[] {2,2}, 0));
        g2.drawRect (rect.x+radius*3, rect.y+radius*2,rect.width-radius*6,rect.height-radius*4);
        g2.setStroke (s);
    }
    g2.draw(gp);
    
    g2.setPaint(oldPaint);
}
 

/**
 * Utility method for drawing a crosshair on the chart (if required).
 *
 * @param g2  The graphics device.
 * @param dataArea  The data area.
 * @param value  The coordinate, where to draw the line.
 * @param stroke  The stroke to use.
 * @param paint  The paint to use.
 */
protected void drawHorizontalLine(Graphics2D g2, Rectangle2D dataArea,
                                  double value, Stroke stroke,
                                  Paint paint) {

    double yy = getRangeAxis().valueToJava2D(value, dataArea,
            RectangleEdge.LEFT);
    Line2D line = new Line2D.Double(dataArea.getMinX(), yy,
            dataArea.getMaxX(), yy);
    g2.setStroke(stroke);
    g2.setPaint(paint);
    g2.draw(line);

}
 

/**
 * Creates a new border with the specified color.
 *
 * @param paint  the color ({@code null} not permitted).
 * @param stroke  the border stroke ({@code null} not permitted).
 * @param insets  the insets ({@code null} not permitted).
 */
public LineBorder(Paint paint, Stroke stroke, RectangleInsets insets) {
    ParamChecks.nullNotPermitted(paint, "paint");
    ParamChecks.nullNotPermitted(stroke, "stroke");
    ParamChecks.nullNotPermitted(insets, "insets");
    this.paint = paint;
    this.stroke = stroke;
    this.insets = insets;
}
 

/**
 * Creates a new supplier.
 *
 * @param paintSequence  the paint sequence.
 * @param fillPaintSequence  the fill paint sequence.
 * @param outlinePaintSequence  the outline paint sequence.
 * @param strokeSequence  the stroke sequence.
 * @param outlineStrokeSequence  the outline stroke sequence.
 * @param shapeSequence  the shape sequence.
 *
 * @since 1.0.6
 */
public DefaultDrawingSupplier(Paint[] paintSequence,
        Paint[] fillPaintSequence, Paint[] outlinePaintSequence,
        Stroke[] strokeSequence, Stroke[] outlineStrokeSequence,
        Shape[] shapeSequence) {

    this.paintSequence = paintSequence;
    this.fillPaintSequence = fillPaintSequence;
    this.outlinePaintSequence = outlinePaintSequence;
    this.strokeSequence = strokeSequence;
    this.outlineStrokeSequence = outlineStrokeSequence;
    this.shapeSequence = shapeSequence;
}
 

private Stroke getStroke(float thickness) {

            float lineThickness = getLineThickness(thickness);
            BasicStroke stroke = cachedStroke;
            if (stroke == null ||
                    stroke.getLineWidth() != lineThickness) {

                stroke = createStroke(lineThickness);
                cachedStroke = stroke;
            }

            return stroke;
        }
 

private void drawValueIndicator(Graphics2D g2d) {
    Diagram.RectTransform transform = diagram.getTransform();
    Point2D a = transform.transformB2A(dragPoint, null);
    double x = a.getX();
    if (x < selectedGraph.getXMin()) {
        x = selectedGraph.getXMin();
    }
    if (x > selectedGraph.getXMax()) {
        x = selectedGraph.getXMax();
    }
    final Stroke oldStroke = g2d.getStroke();
    final Color oldColor = g2d.getColor();

    double y = getY(selectedGraph, x);
    Point2D b = transform.transformA2B(new Point2D.Double(x, y), null);

    g2d.setStroke(new BasicStroke(1.0f));
    g2d.setColor(diagram.getForegroundColor());
    Ellipse2D.Double marker = new Ellipse2D.Double(b.getX() - 4.0, b.getY() - 4.0, 8.0, 8.0);
    g2d.draw(marker);

    g2d.setStroke(new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0, new float[]{6, 6}, 12));
    g2d.setColor(diagram.getForegroundColor());
    final Rectangle graphArea = diagram.getGraphArea();
    g2d.draw(new Line2D.Double(b.getX(), graphArea.y + graphArea.height, b.getX(), b.getY()));
    g2d.draw(new Line2D.Double(graphArea.x, b.getY(), b.getX(), b.getY()));

    DecimalFormat decimalFormat = new DecimalFormat("0.#####E0");
    String text = selectedGraph.getYName() + ": x = " + decimalFormat.format(x) + ", y = " + decimalFormat.format(y);

    g2d.setStroke(oldStroke);
    g2d.setColor(oldColor);

    drawTextBox(g2d, text, graphArea.x + 6, graphArea.y + 6 + 16, new Color(255, 255, 255, 128));
}
 

/**
 * Draws the gridlines for the plot.
 *
 * @param g2  the graphics device.
 * @param dataArea  the area inside the axes.
 * 
 * @see #drawRangeGridlines(Graphics2D, Rectangle2D, List)
 */
protected void drawDomainGridlines(Graphics2D g2, Rectangle2D dataArea) {

    // draw the domain grid lines, if any...
    if (isDomainGridlinesVisible()) {
        CategoryAnchor anchor = getDomainGridlinePosition();
        RectangleEdge domainAxisEdge = getDomainAxisEdge();
        Stroke gridStroke = getDomainGridlineStroke();
        Paint gridPaint = getDomainGridlinePaint();
        if ((gridStroke != null) && (gridPaint != null)) {
            // iterate over the categories
            CategoryDataset data = getDataset();
            if (data != null) {
                CategoryAxis axis = getDomainAxis();
                if (axis != null) {
                    int columnCount = data.getColumnCount();
                    for (int c = 0; c < columnCount; c++) {
                        double xx = axis.getCategoryJava2DCoordinate(
                                anchor, c, columnCount, dataArea, 
                                domainAxisEdge);
                        CategoryItemRenderer renderer1 = getRenderer();
                        if (renderer1 != null) {
                            renderer1.drawDomainGridline(g2, this, 
                                    dataArea, xx);
                        }
                    }
                }
            }
        }
    }
}
 

private void drawTextAndEmbellishments(Label label,
                                       Graphics2D g2d,
                                       float x,
                                       float y) {

    label.handleDraw(g2d, x, y);

    if (!strikethrough && stdUnderline == null && imUnderline == null) {
        return;
    }

    float x1 = x;
    float x2 = x1 + (float)label.getLogicalBounds().getWidth();

    CoreMetrics cm = label.getCoreMetrics();
    if (strikethrough) {
        Stroke savedStroke = g2d.getStroke();
        g2d.setStroke(new BasicStroke(cm.strikethroughThickness,
                                      BasicStroke.CAP_BUTT,
                                      BasicStroke.JOIN_MITER));
        float strikeY = y + cm.strikethroughOffset;
        g2d.draw(new Line2D.Float(x1, strikeY, x2, strikeY));
        g2d.setStroke(savedStroke);
    }

    float ulOffset = cm.underlineOffset;
    float ulThickness = cm.underlineThickness;

    if (stdUnderline != null) {
        stdUnderline.drawUnderline(g2d, ulThickness, x1, x2, y + ulOffset);
    }

    if (imUnderline != null) {
        imUnderline.drawUnderline(g2d, ulThickness, x1, x2, y + ulOffset);
    }
}
 

/**
 * Draws a grid line against the domain axis.
 * <P>
 * Note that this default implementation assumes that the horizontal axis 
 * is the domain axis. If this is not the case, you will need to override 
 * this method.
 *
 * @param g2  the graphics device.
 * @param plot  the plot.
 * @param dataArea  the area for plotting data (not yet adjusted for any 
 *                  3D effect).
 * @param value  the Java2D value at which the grid line should be drawn.
 */
public void drawDomainGridline(Graphics2D g2,
                               CategoryPlot plot,
                               Rectangle2D dataArea,
                               double value) {

    Line2D line = null;
    PlotOrientation orientation = plot.getOrientation();

    if (orientation == PlotOrientation.HORIZONTAL) {
        line = new Line2D.Double(dataArea.getMinX(), value, 
                dataArea.getMaxX(), value);
    }
    else if (orientation == PlotOrientation.VERTICAL) {
        line = new Line2D.Double(value, dataArea.getMinY(), value, 
                dataArea.getMaxY());
    }

    Paint paint = plot.getDomainGridlinePaint();
    if (paint == null) {
        paint = CategoryPlot.DEFAULT_GRIDLINE_PAINT;
    }
    g2.setPaint(paint);

    Stroke stroke = plot.getDomainGridlineStroke();
    if (stroke == null) {
        stroke = CategoryPlot.DEFAULT_GRIDLINE_STROKE;
    }
    g2.setStroke(stroke);

    g2.draw(line);

}
 

/**
 * Confirm that the equals method can distinguish all the required fields.
 */
@Test
public void testEquals() {
    PeriodAxisLabelInfo info1 = new PeriodAxisLabelInfo(Day.class,
            new SimpleDateFormat("d"));
    PeriodAxisLabelInfo info2 = new PeriodAxisLabelInfo(Day.class,
            new SimpleDateFormat("d"));
    assertTrue(info1.equals(info2));
    assertTrue(info2.equals(info1));

    Class c1 = Day.class;
    Class c2 = Month.class;
    DateFormat df1 = new SimpleDateFormat("d");
    DateFormat df2 = new SimpleDateFormat("MMM");
    RectangleInsets sp1 = new RectangleInsets(1, 1, 1, 1);
    RectangleInsets sp2 = new RectangleInsets(2, 2, 2, 2);
    Font lf1 = new Font("SansSerif", Font.PLAIN, 10);
    Font lf2 = new Font("SansSerif", Font.BOLD, 9);
    Paint lp1 = Color.black;
    Paint lp2 = Color.blue;
    boolean b1 = true;
    boolean b2 = false;
    Stroke s1 = new BasicStroke(0.5f);
    Stroke s2 = new BasicStroke(0.25f);
    Paint dp1 = Color.red;
    Paint dp2 = Color.green;

    info1 = new PeriodAxisLabelInfo(c2, df1, sp1, lf1, lp1, b1, s1, dp1);
    info2 = new PeriodAxisLabelInfo(c1, df1, sp1, lf1, lp1, b1, s1, dp1);
    assertFalse(info1.equals(info2));
    info2 = new PeriodAxisLabelInfo(c2, df1, sp1, lf1, lp1, b1, s1, dp1);
    assertTrue(info1.equals(info2));

    info1 = new PeriodAxisLabelInfo(c2, df2, sp1, lf1, lp1, b1, s1, dp1);
    assertFalse(info1.equals(info2));
    info2 = new PeriodAxisLabelInfo(c2, df2, sp1, lf1, lp1, b1, s1, dp1);
    assertTrue(info1.equals(info2));

    info1 = new PeriodAxisLabelInfo(c2, df2, sp2, lf1, lp1, b1, s1, dp1);
    assertFalse(info1.equals(info2));
    info2 = new PeriodAxisLabelInfo(c2, df2, sp2, lf1, lp1, b1, s1, dp1);
    assertTrue(info1.equals(info2));

    info1 = new PeriodAxisLabelInfo(c2, df2, sp2, lf2, lp1, b1, s1, dp1);
    assertFalse(info1.equals(info2));
    info2 = new PeriodAxisLabelInfo(c2, df2, sp2, lf2, lp1, b1, s1, dp1);
    assertTrue(info1.equals(info2));

    info1 = new PeriodAxisLabelInfo(c2, df2, sp2, lf2, lp2, b1, s1, dp1);
    assertFalse(info1.equals(info2));
    info2 = new PeriodAxisLabelInfo(c2, df2, sp2, lf2, lp2, b1, s1, dp1);
    assertTrue(info1.equals(info2));

    info1 = new PeriodAxisLabelInfo(c2, df2, sp2, lf2, lp2, b2, s1, dp1);
    assertFalse(info1.equals(info2));
    info2 = new PeriodAxisLabelInfo(c2, df2, sp2, lf2, lp2, b2, s1, dp1);
    assertTrue(info1.equals(info2));

    info1 = new PeriodAxisLabelInfo(c2, df2, sp2, lf2, lp2, b2, s2, dp1);
    assertFalse(info1.equals(info2));
    info2 = new PeriodAxisLabelInfo(c2, df2, sp2, lf2, lp2, b2, s2, dp1);
    assertTrue(info1.equals(info2));

    info1 = new PeriodAxisLabelInfo(c2, df2, sp2, lf2, lp2, b2, s2, dp2);
    assertFalse(info1.equals(info2));
    info2 = new PeriodAxisLabelInfo(c2, df2, sp2, lf2, lp2, b2, s2, dp2);
    assertTrue(info1.equals(info2));

}
 

/**
 * Creates and returns a theme called "Darkness". In this theme, the charts have a black
 * background and white lines and labels
 *
 * @return The "Darkness" theme.
 */
public static EStandardChartTheme createDarknessTheme() {
  EStandardChartTheme theme = new EStandardChartTheme(THEME.DARKNESS, "Darkness");
  // Fonts
  theme.setExtraLargeFont(new Font("Arial", Font.BOLD, 20));
  theme.setLargeFont(new Font("Arial", Font.BOLD, 11));
  theme.setRegularFont(new Font("Arial", Font.PLAIN, 11));
  theme.setSmallFont(new Font("Arial", Font.PLAIN, 11));
  //
  theme.setTitlePaint(Color.white);
  theme.setSubtitlePaint(Color.white);
  theme.setLegendBackgroundPaint(Color.black);
  theme.setLegendItemPaint(Color.white);
  theme.setChartBackgroundPaint(Color.black);
  theme.setPlotBackgroundPaint(Color.black);
  theme.setPlotOutlinePaint(Color.yellow);
  theme.setBaselinePaint(Color.white);
  theme.setCrosshairPaint(Color.red);
  theme.setLabelLinkPaint(Color.lightGray);
  theme.setTickLabelPaint(Color.white);
  theme.setAxisLabelPaint(Color.white);
  theme.setShadowPaint(Color.darkGray);
  theme.setItemLabelPaint(Color.white);
  theme.setDrawingSupplier(new DefaultDrawingSupplier(
      new Paint[] {Color.WHITE, Color.decode("0xFFFF00"), Color.decode("0x0036CC"),
          Color.decode("0xFF0000"), Color.decode("0xFFFF7F"), Color.decode("0x6681CC"),
          Color.decode("0xFF7F7F"), Color.decode("0xFFFFBF"), Color.decode("0x99A6CC"),
          Color.decode("0xFFBFBF"), Color.decode("0xA9A938"), Color.decode("0x2D4587")},
      new Paint[] {Color.decode("0xFFFF00"), Color.decode("0x0036CC")},
      new Stroke[] {new BasicStroke(2.0f)}, new Stroke[] {new BasicStroke(0.5f)},
      DefaultDrawingSupplier.DEFAULT_SHAPE_SEQUENCE));
  theme.setErrorIndicatorPaint(Color.lightGray);
  theme.setGridBandPaint(new Color(255, 255, 255, 20));
  theme.setGridBandAlternatePaint(new Color(255, 255, 255, 40));

  // axis
  Color transp = new Color(255, 255, 255, 200);
  theme.setRangeGridlinePaint(transp);
  theme.setDomainGridlinePaint(transp);

  theme.setAxisLinePaint(Color.white);

  theme.setMasterFontColor(Color.WHITE);
  // axis offset
  theme.setAxisOffset(new RectangleInsets(0, 0, 0, 0));
  return theme;
}
 

/**
 * Confirm that the equals method can distinguish all the required fields.
 */
@Test
public void testEquals() {
    CategoryPointerAnnotation a1 = new CategoryPointerAnnotation("Label",
            "Key 1", 20.0, Math.PI);
    CategoryPointerAnnotation a2 = new CategoryPointerAnnotation("Label",
            "Key 1", 20.0, Math.PI);
    assertTrue(a1.equals(a2));

    a1 = new CategoryPointerAnnotation("Label2", "Key 1", 20.0, Math.PI);
    assertFalse(a1.equals(a2));
    a2 = new CategoryPointerAnnotation("Label2", "Key 1", 20.0, Math.PI);
    assertTrue(a1.equals(a2));

    a1.setCategory("Key 2");
    assertFalse(a1.equals(a2));
    a2.setCategory("Key 2");
    assertTrue(a1.equals(a2));

    a1.setValue(22.0);
    assertFalse(a1.equals(a2));
    a2.setValue(22.0);
    assertTrue(a1.equals(a2));

    //private double angle;
    a1.setAngle(Math.PI / 4.0);
    assertFalse(a1.equals(a2));
    a2.setAngle(Math.PI / 4.0);
    assertTrue(a1.equals(a2));

    //private double tipRadius;
    a1.setTipRadius(20.0);
    assertFalse(a1.equals(a2));
    a2.setTipRadius(20.0);
    assertTrue(a1.equals(a2));

    //private double baseRadius;
    a1.setBaseRadius(5.0);
    assertFalse(a1.equals(a2));
    a2.setBaseRadius(5.0);
    assertTrue(a1.equals(a2));

    //private double arrowLength;
    a1.setArrowLength(33.0);
    assertFalse(a1.equals(a2));
    a2.setArrowLength(33.0);
    assertTrue(a1.equals(a2));

    //private double arrowWidth;
    a1.setArrowWidth(9.0);
    assertFalse(a1.equals(a2));
    a2.setArrowWidth(9.0);
    assertTrue(a1.equals(a2));

    //private Stroke arrowStroke;
    Stroke stroke = new BasicStroke(1.5f);
    a1.setArrowStroke(stroke);
    assertFalse(a1.equals(a2));
    a2.setArrowStroke(stroke);
    assertTrue(a1.equals(a2));

    //private Paint arrowPaint;
    a1.setArrowPaint(Color.blue);
    assertFalse(a1.equals(a2));
    a2.setArrowPaint(Color.blue);
    assertTrue(a1.equals(a2));

    //private double labelOffset;
    a1.setLabelOffset(10.0);
    assertFalse(a1.equals(a2));
    a2.setLabelOffset(10.0);
    assertTrue(a1.equals(a2));
}
 

/**
 * Confirm that the equals() method can distinguish all the required fields.
 */
@Test
public void testEquals() {
    PeriodAxis a1 = new PeriodAxis("Test");
    PeriodAxis a2 = new PeriodAxis("Test");
    assertTrue(a1.equals(a2));
    assertTrue(a2.equals(a1));

    a1.setFirst(new Year(2000));
    assertFalse(a1.equals(a2));
    a2.setFirst(new Year(2000));
    assertTrue(a1.equals(a2));

    a1.setLast(new Year(2004));
    assertFalse(a1.equals(a2));
    a2.setLast(new Year(2004));
    assertTrue(a1.equals(a2));

    a1.setTimeZone(TimeZone.getTimeZone("Pacific/Auckland"));
    assertFalse(a1.equals(a2));
    a2.setTimeZone(TimeZone.getTimeZone("Pacific/Auckland"));
    assertTrue(a1.equals(a2));

    a1.setAutoRangeTimePeriodClass(Quarter.class);
    assertFalse(a1.equals(a2));
    a2.setAutoRangeTimePeriodClass(Quarter.class);
    assertTrue(a1.equals(a2));

    PeriodAxisLabelInfo info[] = new PeriodAxisLabelInfo[1];
    info[0] = new PeriodAxisLabelInfo(Month.class,
            new SimpleDateFormat("MMM"));

    a1.setLabelInfo(info);
    assertFalse(a1.equals(a2));
    a2.setLabelInfo(info);
    assertTrue(a1.equals(a2));

    a1.setMajorTickTimePeriodClass(Minute.class);
    assertFalse(a1.equals(a2));
    a2.setMajorTickTimePeriodClass(Minute.class);
    assertTrue(a1.equals(a2));

    a1.setMinorTickMarksVisible(!a1.isMinorTickMarksVisible());
    assertFalse(a1.equals(a2));
    a2.setMinorTickMarksVisible(a1.isMinorTickMarksVisible());
    assertTrue(a1.equals(a2));

    a1.setMinorTickTimePeriodClass(Minute.class);
    assertFalse(a1.equals(a2));
    a2.setMinorTickTimePeriodClass(Minute.class);
    assertTrue(a1.equals(a2));

    Stroke s = new BasicStroke(1.23f);
    a1.setMinorTickMarkStroke(s);
    assertFalse(a1.equals(a2));
    a2.setMinorTickMarkStroke(s);
    assertTrue(a1.equals(a2));

    a1.setMinorTickMarkPaint(Color.blue);
    assertFalse(a1.equals(a2));
    a2.setMinorTickMarkPaint(Color.blue);
    assertTrue(a1.equals(a2));
}
 

/**
 * Sets the stroke for this graphics context.  For now, this implementation
 * only recognises the {@link BasicStroke} class.
 *
 * @param stroke  the stroke (<code>null</code> not permitted).
 *
 * @see #getStroke()
 */
public void setStroke(Stroke stroke) {
    if (stroke instanceof BasicStroke) {
        BasicStroke bs = (BasicStroke) stroke;
        // linewidth
        this.gc.setLineWidth((int) bs.getLineWidth());

        // line join
        switch (bs.getLineJoin()) {
            case BasicStroke.JOIN_BEVEL :
                this.gc.setLineJoin(SWT.JOIN_BEVEL);
                break;
            case BasicStroke.JOIN_MITER :
                this.gc.setLineJoin(SWT.JOIN_MITER);
                break;
            case BasicStroke.JOIN_ROUND :
                this.gc.setLineJoin(SWT.JOIN_ROUND);
                break;
        }

        // line cap
        switch (bs.getEndCap()) {
            case BasicStroke.CAP_BUTT :
                this.gc.setLineCap(SWT.CAP_FLAT);
                break;
            case BasicStroke.CAP_ROUND :
                this.gc.setLineCap(SWT.CAP_ROUND);
                break;
            case BasicStroke.CAP_SQUARE :
                this.gc.setLineCap(SWT.CAP_SQUARE);
                break;
        }

        // set the line style to solid by default
        this.gc.setLineStyle(SWT.LINE_SOLID);

        // apply dash style if any
        float[] dashes = bs.getDashArray();
        if (dashes != null) {
            int[] swtDashes = new int[dashes.length];
            for (int i = 0; i < swtDashes.length; i++) {
                swtDashes[i] = (int) dashes[i];
            }
            this.gc.setLineDash(swtDashes);
        }
    }
    else {
        throw new RuntimeException(
                "Can only handle 'Basic Stroke' at present.");
    }
}
 

public static byte[] getBackgroundImage(VisionVO vision, int width, int height) throws Exception {
	byte[] data = null;
	List<PerspectiveVO> perspectivesList = perspectiveService.findForListByVisionOid(vision.getOid());
	
	BufferedImage bi = new BufferedImage(getWidth(width), getHeight(height), BufferedImage.TYPE_INT_RGB);
	Graphics2D g2 = bi.createGraphics();	
	Font font = new Font("", Font.BOLD, 16);
	g2.setFont(font);		
	g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);		
	
	int fontLeft = 3;
	int fontAddY = ONE_HEIGHT; // 150
	int fontNowY = 80;
	int lineAddY = 60;
	
	// 填滿 grid 圖片的底
	BufferedImage bg = ImageIO.read( StrategyMapUtils.class.getClassLoader().getResource(SRC_IMG) );
	for (int y=0; y<height; y+=bg.getHeight()) {
		for (int x=0; x<width; x+=bg.getWidth()) {
			g2.drawImage(bg, x, y, null);
		}
	}
	
	Stroke dashed = new BasicStroke(2, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0, new float[]{9}, 0);
	
	for (int i=0; perspectivesList != null && i < perspectivesList.size(); i++) {
		
		PerspectiveVO perspective = perspectivesList.get(i);
		
		if (fontNowY > bi.getHeight()) {
			logger.warn("Perspective item over heigh, no paint it : " + perspective.getName());
			continue;
		}
		if (fontLeft > bi.getWidth()) {
			logger.warn("Perspective item over width, no paint it : " + perspective.getName());
			continue;				
		}
		
		g2.setPaint( new Color(64, 64, 64) );
		g2.drawString(perspective.getName(), fontLeft, fontNowY);
		
		g2.setStroke(dashed);
		g2.drawLine(0, fontNowY+lineAddY, width, fontNowY+lineAddY);
		
		fontNowY = fontNowY + fontAddY;
	}
	ByteArrayOutputStream baos = null;
	try {
		baos = new ByteArrayOutputStream();
		ImageIO.write(bi, "PNG", baos);
		data = baos.toByteArray();
		baos.flush();
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		baos = null;
	}
	return data;
}