Example usage for java.awt Graphics2D setColor

List of usage examples for java.awt Graphics2D setColor

  1. HOME
  2. Java
  3. java
  4. java.awt.*
  5. Graphics2D
  6. setColor

Introduction

In this page you can find the example usage for java.awt Graphics2D setColor.

Prototype

public abstract void setColor(Color c);

Source Link

Document

Sets this graphics context's current color to the specified color.

Usage

From source file:com.igormaznitsa.mindmap.swing.panel.MindMapPanel.java

private void drawDestinationElement(final Graphics2D g, final MindMapPanelConfig cfg) {
    if (this.destinationElement != null && this.draggedElement != null) {
        g.setColor(new Color((cfg.getSelectLineColor().getRGB() & 0xFFFFFF) | 0x80000000, true));
        g.setStroke(new BasicStroke(this.config.safeScaleFloatValue(3.0f, 0.1f)));

        final Rectangle2D rectToDraw = new Rectangle2D.Double();
        rectToDraw.setRect(this.destinationElement.getBounds());
        final double selectLineGap = cfg.getSelectLineGap() * 3.0d * cfg.getScale();
        rectToDraw.setRect(rectToDraw.getX() - selectLineGap, rectToDraw.getY() - selectLineGap,
                rectToDraw.getWidth() + selectLineGap * 2, rectToDraw.getHeight() + selectLineGap * 2);

        final int position = calcDropPosition(this.destinationElement, this.draggedElement.getPosition());

        boolean draw = !this.draggedElement.isPositionInside()
                && !this.destinationElement.getModel().hasAncestor(this.draggedElement.getElement().getModel());

        switch (this.draggedElement.getModifier()) {
        case NONE: {
            switch (position) {
            case DRAG_POSITION_TOP: {
                rectToDraw.setRect(rectToDraw.getX(), rectToDraw.getY(), rectToDraw.getWidth(),
                        rectToDraw.getHeight() / 2);
            }/*from  ww  w.  java 2  s  .  c  o  m*/
                break;
            case DRAG_POSITION_BOTTOM: {
                rectToDraw.setRect(rectToDraw.getX(), rectToDraw.getY() + rectToDraw.getHeight() / 2,
                        rectToDraw.getWidth(), rectToDraw.getHeight() / 2);
            }
                break;
            case DRAG_POSITION_LEFT: {
                rectToDraw.setRect(rectToDraw.getX(), rectToDraw.getY(), rectToDraw.getWidth() / 2,
                        rectToDraw.getHeight());
            }
                break;
            case DRAG_POSITION_RIGHT: {
                rectToDraw.setRect(rectToDraw.getX() + rectToDraw.getWidth() / 2, rectToDraw.getY(),
                        rectToDraw.getWidth() / 2, rectToDraw.getHeight());
            }
                break;
            default:
                draw = false;
                break;
            }
        }
            break;
        case MAKE_JUMP: {
        }
            break;
        default:
            throw new Error("Unexpected state " + this.draggedElement.getModifier());
        }

        if (draw) {
            g.fill(rectToDraw);
        }
    }
}

From source file:coolmap.canvas.datarenderer.renderer.impl.NumberToColor.java

@Override
public void renderCellLD(Double v, VNode rowNode, VNode columnNode, Graphics2D g2D, int anchorX, int anchorY,
        int cellWidth, int cellHeight) {
    //        renderCellSD(v, rowNode, columnNode, g2D, anchorX, anchorY, cellWidth, cellHeight);
    if (v == null || v.isNaN()) {
        //System.out.println(v);
        _markNull(v, rowNode, columnNode, g2D, anchorX, anchorY, cellWidth, cellHeight);
    } else {//from  www . j av a 2s .  c  om
        try {
            int index = (int) ((v - _minValue) / (_maxValue - _minValue) * _gradientColors.length);
            if (index >= _gradientColors.length) {
                index = _gradientColors.length - 1;
            }
            if (index < 0) {
                index = 0;
            }
            Color c = _gradientColors[index];
            //System.out.println(c);
            g2D.setColor(c);
            //                System.out.println((int) cellWidth + " " + ((int) cellHeight)) ;
            g2D.fillRect((int) anchorX, (int) anchorY, (int) cellWidth, (int) cellHeight);
        } catch (Exception e) {

        }
    }

}

From source file:coolmap.canvas.datarenderer.renderer.impl.NumberToColor.java

@Override
public void renderCellSD(Double v, VNode rowNode, VNode columnNode, Graphics2D g2D, int anchorX, int anchorY,
        int cellWidth, int cellHeight) {
    if (v == null || v.isNaN()) {
        //System.out.println(v);
        _markNull(v, rowNode, columnNode, g2D, anchorX, anchorY, cellWidth, cellHeight);
    } else {//from w w  w. j av a  2s.c  o  m
        try {
            int index = (int) ((v - _minValue) / (_maxValue - _minValue) * _gradientColors.length);
            if (index >= _gradientColors.length) {
                index = _gradientColors.length - 1;
            }
            if (index < 0) {
                index = 0;
            }
            Color c = _gradientColors[index];
            //System.out.println(c);
            g2D.setColor(c);
            //                System.out.println((int) cellWidth + " " + ((int) cellHeight)) ;
            g2D.fillRect((int) anchorX, (int) anchorY, (int) cellWidth, (int) cellHeight);
            //                System.out.println("WH:" + cellWidth + " " + cellHeight);

            if (drawSubMap.isSelected()) {
                //paint the sub heatmap block

                //                    System.out.println("draw submap");
                if (rowNode == null || columnNode == null
                        || rowNode.isSingleNode() && columnNode.isSingleNode()) {
                    return;
                } else {

                    //need to determine the number of cMatrices
                    CoolMapObject object = getCoolMapObject();
                    List<CMatrix> matrices = object.getBaseCMatrices();
                    Double value;

                    //row and column indices
                    Integer[] rowIndices;
                    Integer[] colIndices;

                    //whether they are group node or node
                    if (rowNode.isGroupNode()) {
                        rowIndices = rowNode.getBaseIndicesFromCOntology(
                                (CMatrix) object.getBaseCMatrices().get(0), COntology.ROW);
                    } else {
                        rowIndices = new Integer[] { ((CMatrix) object.getBaseCMatrices().get(0))
                                .getIndexOfRowName(rowNode.getName()) };
                    }
                    if (columnNode.isGroupNode()) {
                        colIndices = columnNode.getBaseIndicesFromCOntology(
                                (CMatrix) object.getBaseCMatrices().get(0), COntology.COLUMN);
                    } else {
                        colIndices = new Integer[] { ((CMatrix) object.getBaseCMatrices().get(0))
                                .getIndexOfColName(columnNode.getName()) };
                    }

                    //then determine the width
                    int subMatrixWidth = Math.round(cellWidth * 1.0f / matrices.size());

                    int subAnchorX = anchorX;

                    int subCellHeight = Math.round(cellHeight * 1.0f / rowIndices.length);
                    int subCellWidth = Math.round(subMatrixWidth * 1.0f / colIndices.length);

                    //                        System.out.println("CW:" + cellWidth + " " + colIndices.length + " " + subCellWidth);
                    //                        System.out.println("CH:" + cellHeight + " " + rowIndices.length + " " + subCellHeight);
                    if (subCellHeight < 1) {
                        subCellHeight = 1;
                    }
                    if (subCellWidth < 1) {
                        subCellWidth = 1;
                    }

                    for (CMatrix matrix : matrices) {

                        int rowIndex = 0;
                        for (Integer i : rowIndices) {
                            if (i == null || i < 0) {
                                continue;
                            }
                            int columnIndex = 0;
                            for (Integer j : colIndices) {
                                if (j == null || j < 0) {
                                    continue;
                                }
                                try {

                                    value = (Double) matrix.getValue(i, j);
                                    index = (int) ((value - _minValue) / (_maxValue - _minValue)
                                            * _gradientColors.length);
                                    if (index >= _gradientColors.length) {
                                        index = _gradientColors.length - 1;
                                    }
                                    if (index < 0) {
                                        index = 0;
                                    }
                                    c = _gradientColors[index];

                                    g2D.setColor(c);

                                    int subCellX = Math
                                            .round(subMatrixWidth * 1.0f * columnIndex / colIndices.length)
                                            + subAnchorX;
                                    int subCellY = Math.round(cellHeight * 1.0f * rowIndex / rowIndices.length)
                                            + anchorY;

                                    //                                        System.out.println("WTF:" + columnIndex + " " + rowIndex + "----" + subCellX + " " + subCellY + " " + subCellWidth + " " + subCellHeight);
                                    g2D.fillRect(subCellX, subCellY, subCellWidth, subCellHeight);

                                } catch (Exception e) {
                                    //draw it here
                                    e.printStackTrace();
                                }

                                columnIndex++;
                            } //end of column loop

                            rowIndex++;
                        } //end of row loop

                        subAnchorX += subMatrixWidth;
                    } //end of matrix loop

                    g2D.setStroke(UI.stroke1);
                    g2D.setColor(Color.BLACK);
                    g2D.drawRect(anchorX, anchorY, cellWidth, cellHeight);
                }
            }

        } catch (Exception e) {
            //                System.out.println("Null pointer exception:" + v + "," + _minValue + "," + _maxValue + "," + _gradientColors + " " + getName() + "" + this);
            //e.printStackTrace();
        }
    }
}

From source file:com.pronoiahealth.olhie.server.services.BookCoverImageService.java

/**
 * Create the front cover//from  w w  w .  j a va2 s. co m
 * 
 * @param coverId
 * @param logoBytes
 * @param authorStr
 * @param titleStr
 * @param textColor
 *            - ex. #FFFFFF
 * @param width
 * @param height
 * @param type
 *            - ex. BufferedImage.TYPE_INT_ARGB
 * @param imgFormat
 *            - ex. ImageFormat.IMAGE_FORMAT_PNG
 * @return
 * @throws Exception
 */
public byte[] createFrontCover(String coverId, byte[] logoBytes, String authorStr, String titleStr,
        String spineColor, String authorTextColor, String titleTextColor, int width, int height, int type,
        ImageFormat imgFormat, int maxColors) throws Exception {

    Graphics2D g = null;

    try {
        // Front cover first
        // Read in base cover image
        BufferedImage coverImg = Imaging.getBufferedImage(coverMap.get(coverId));

        // Resize cover image to the basic 300 X 400 for front cover
        BufferedImage frontCoverImg = resize(coverImg, 300, 400, type);
        g = (Graphics2D) frontCoverImg.getGraphics();

        // Draw logo if present
        if (logoBytes != null && logoBytes.length > 0) {
            // Resize logo to 200x100
            BufferedImage logoImg = Imaging.getBufferedImage(logoBytes);
            BufferedImage outLogo = null;
            int logoHeight = logoImg.getHeight();
            int logoWidth = logoImg.getWidth();

            if (logoHeight > 100 || logoWidth > 200) {
                outLogo = this.resize(logoImg, logoWidth > 200 ? 200 : logoWidth,
                        logoHeight > 100 ? 100 : logoHeight, type);
            } else {
                outLogo = logoImg;
            }

            // Add to coverImg
            g.drawImage(outLogo, 32, 25, null);
        }

        // Add spine if present
        if (spineColor != null && spineColor.length() > 0) {
            g.setColor(Color.decode(spineColor));
            g.fillRect(0, 0, 2, frontCoverImg.getHeight());
        }

        // Add author if present
        if (authorStr != null && authorStr.length() > 0) {
            // Add author text to image
            BufferedImage authorTextImg = createText(40, 220, authorStr, authorTextColor, false, authorFontMap,
                    type);
            g.drawImage(authorTextImg, 30, 215, null);
        }

        // Add title if present
        if (titleStr != null && titleStr.length() > 0) {
            BufferedImage titleTextImg = createText(100, 220, titleStr, titleTextColor, false, titleFontMap,
                    type);
            g.drawImage(titleTextImg, 30, 240, null);
        }

        // If the requested size is not 300X400 convert the image
        BufferedImage outImg = null;
        if (width != 300 || height != 400) {
            outImg = resize(frontCoverImg, width, height, type);
        } else {
            outImg = frontCoverImg;
        }

        // Do we want a PNG with a fixed number of colors
        if (maxColors >= 2 && imgFormat == ImageFormat.IMAGE_FORMAT_PNG) {
            outImg = ImageUtils.reduce32(outImg, maxColors);
        }

        // Return bytes
        Map<String, Object> params = new HashMap<String, Object>();
        byte[] outBytes = Imaging.writeImageToBytes(outImg, imgFormat, params);
        return outBytes;
    } finally {
        if (g != null) {
            g.dispose();
        }
    }
}

From source file:coolmap.canvas.datarenderer.renderer.impl.NumberToColor.java

@Override
public void renderCellHD(Double v, VNode rowNode, VNode columnNode, Graphics2D g2D, int anchorX, int anchorY,
        int cellWidth, int cellHeight) {
    if (v == null || v.isNaN()) {
        //System.out.println(v);
        _markNull(v, rowNode, columnNode, g2D, anchorX, anchorY, cellWidth, cellHeight);
    } else {/*from  ww w  .  ja  v  a 2s .  co m*/
        try {
            int index = (int) ((v - _minValue) / (_maxValue - _minValue) * _gradientColors.length);
            if (index >= _gradientColors.length) {
                index = _gradientColors.length - 1;
            }
            if (index < 0) {
                index = 0;
            }
            Color c = _gradientColors[index];
            //System.out.println(c);
            g2D.setColor(c);
            //                System.out.println((int) cellWidth + " " + ((int) cellHeight)) ;
            g2D.fillRoundRect((int) anchorX + 1, (int) anchorY + 1, (int) cellWidth - 2, (int) cellHeight - 2,
                    4, 4);

            if (drawSubMap.isSelected()) {
                //paint the sub heatmap block

                //                    System.out.println("draw submap");
                if (rowNode == null || columnNode == null
                        || rowNode.isSingleNode() && columnNode.isSingleNode()) {
                    return;
                } else {

                    g2D.setStroke(UI.strokeDash1_5);
                    //need to determine the number of cMatrices
                    CoolMapObject object = getCoolMapObject();
                    List<CMatrix> matrices = object.getBaseCMatrices();
                    Double value;

                    //row and column indices
                    Integer[] rowIndices;
                    Integer[] colIndices;

                    //whether they are group node or node
                    if (rowNode.isGroupNode()) {
                        rowIndices = rowNode.getBaseIndicesFromCOntology(
                                (CMatrix) object.getBaseCMatrices().get(0), COntology.ROW);
                    } else {
                        rowIndices = new Integer[] { ((CMatrix) object.getBaseCMatrices().get(0))
                                .getIndexOfRowName(rowNode.getName()) };
                    }
                    if (columnNode.isGroupNode()) {
                        colIndices = columnNode.getBaseIndicesFromCOntology(
                                (CMatrix) object.getBaseCMatrices().get(0), COntology.COLUMN);
                    } else {
                        colIndices = new Integer[] { ((CMatrix) object.getBaseCMatrices().get(0))
                                .getIndexOfColName(columnNode.getName()) };
                    }

                    //then determine the width
                    int subMatrixWidth = Math.round(cellWidth * 1.0f / matrices.size());

                    int subAnchorX = anchorX;

                    int subCellHeight = Math.round(cellHeight * 1.0f / rowIndices.length);
                    int subCellWidth = Math.round(subMatrixWidth * 1.0f / colIndices.length);

                    //                        System.out.println("CW:" + cellWidth + " " + colIndices.length + " " + subCellWidth);
                    //                        System.out.println("CH:" + cellHeight + " " + rowIndices.length + " " + subCellHeight);
                    if (subCellHeight < 1) {
                        subCellHeight = 1;
                    }
                    if (subCellWidth < 1) {
                        subCellWidth = 1;
                    }

                    int matrixIndex = 0;
                    for (CMatrix matrix : matrices) {

                        int rowIndex = 0;
                        for (Integer i : rowIndices) {
                            if (i == null || i < 0) {
                                continue;
                            }
                            int columnIndex = 0;
                            for (Integer j : colIndices) {
                                if (j == null || j < 0) {
                                    continue;
                                }
                                try {

                                    value = (Double) matrix.getValue(i, j);
                                    index = (int) ((value - _minValue) / (_maxValue - _minValue)
                                            * _gradientColors.length);
                                    if (index >= _gradientColors.length) {
                                        index = _gradientColors.length - 1;
                                    }
                                    if (index < 0) {
                                        index = 0;
                                    }
                                    c = _gradientColors[index];

                                    g2D.setColor(c);

                                    int subCellX = Math
                                            .round(subMatrixWidth * 1.0f * columnIndex / colIndices.length)
                                            + subAnchorX;
                                    int subCellY = Math.round(cellHeight * 1.0f * rowIndex / rowIndices.length)
                                            + anchorY;

                                    //                                        System.out.println("WTF:" + columnIndex + " " + rowIndex + "----" + subCellX + " " + subCellY + " " + subCellWidth + " " + subCellHeight);
                                    g2D.fillRect(subCellX, subCellY, subCellWidth, subCellHeight);

                                } catch (Exception e) {
                                    //draw it here
                                    e.printStackTrace();
                                }

                                columnIndex++;
                            } //end of column loop

                            rowIndex++;
                        } //end of row loop

                        g2D.setColor(UI.colorBlack1);
                        g2D.drawRect(subAnchorX, anchorY, subMatrixWidth, cellHeight);

                        //
                        //                            subAnchorX += subMatrixWidth;
                        matrixIndex++;
                        subAnchorX = anchorX + Math.round(cellWidth * 1.0f * matrixIndex / matrices.size());
                    } //end of matrix loop

                    g2D.setStroke(UI.stroke2);
                    g2D.setColor(Color.BLACK);
                    g2D.drawRect(anchorX, anchorY, cellWidth, cellHeight);
                }
            }

        } catch (Exception e) {
            //                System.out.println("Null pointer exception:" + v + "," + _minValue + "," + _maxValue + "," + _gradientColors + " " + getName() + "" + this);
            //e.printStackTrace();

        }
    }
}

From source file:forge.view.arcane.util.OutlinedLabel.java

/** {@inheritDoc} */
@Override//from  w  ww .  jav  a 2  s .c o m
public final void paint(final Graphics g) {
    if (getText().length() == 0) {
        return;
    }

    Dimension size = getSize();
    //
    //        if( size.width < 50 ) {
    //            g.setColor(Color.cyan);
    //            g.drawRect(0, 0, size.width-1, size.height-1);
    //        }

    Graphics2D g2d = (Graphics2D) g;

    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

    int textX = outlineSize, textY = 0;
    int wrapWidth = Math.max(0, wrap ? size.width - outlineSize * 2 : Integer.MAX_VALUE);

    final String text = getText();
    AttributedString attributedString = new AttributedString(text);
    if (!StringUtils.isEmpty(text)) {
        attributedString.addAttribute(TextAttribute.FONT, getFont());
    }
    AttributedCharacterIterator charIterator = attributedString.getIterator();
    FontRenderContext fontContext = g2d.getFontRenderContext();

    LineBreakMeasurer measurer = new LineBreakMeasurer(charIterator,
            BreakIterator.getWordInstance(Locale.ENGLISH), fontContext);
    int lineCount = 0;
    while (measurer.getPosition() < charIterator.getEndIndex()) {
        measurer.nextLayout(wrapWidth);
        lineCount++;
        if (lineCount > 2) {
            break;
        }
    }
    charIterator.first();
    // Use char wrap if word wrap would cause more than two lines of text.
    if (lineCount > 2) {
        measurer = new LineBreakMeasurer(charIterator, BreakIterator.getCharacterInstance(Locale.ENGLISH),
                fontContext);
    } else {
        measurer.setPosition(0);
    }
    while (measurer.getPosition() < charIterator.getEndIndex()) {
        TextLayout textLayout = measurer.nextLayout(wrapWidth);
        float ascent = textLayout.getAscent();
        textY += ascent; // Move down to baseline.

        g2d.setColor(outlineColor);
        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8f));

        textLayout.draw(g2d, textX + outlineSize, textY - outlineSize);
        textLayout.draw(g2d, textX + outlineSize, textY + outlineSize);
        textLayout.draw(g2d, textX - outlineSize, textY - outlineSize);
        textLayout.draw(g2d, textX - outlineSize, textY + outlineSize);

        g2d.setColor(getForeground());
        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f));
        textLayout.draw(g2d, textX, textY);

        // Move down to top of next line.
        textY += textLayout.getDescent() + textLayout.getLeading();
    }
}

From source file:ucar.unidata.idv.control.chart.TimeSeriesChart.java

/**
 * Draw the sunrise/sunset curves//w  ww  . j  a v  a  2s.  c  o  m
 *
 * @param g2  the graphics area
 * @param plot   the plot
 * @param dataArea  the date range
 */
private void drawSunriseSunset(Graphics2D g2, XYPlot plot, Rectangle2D dataArea) {
    if (sunriseLocation == null) {
        return;
    }
    DateAxis domainAxis = (DateAxis) plot.getDomainAxis();
    Date startDate = ((DateAxis) domainAxis).getMinimumDate();
    Date endDate = ((DateAxis) domainAxis).getMaximumDate();
    if ((sunriseDates == null) || !Misc.equals(startDate, lastStartDate)
            || !Misc.equals(endDate, lastEndDate)) {
        lastStartDate = startDate;
        lastEndDate = endDate;
        sunriseDates = IdvTimeline.makeSunriseDates(sunriseLocation, startDate, endDate);
    }
    int top = (int) (dataArea.getY());
    int bottom = (int) (dataArea.getY() + dataArea.getHeight());
    int height = bottom - top;
    g2.setColor(Color.yellow);
    Shape originalClip = g2.getClip();
    g2.clip(dataArea);
    for (int i = 0; i < sunriseDates.size(); i += 2) {
        Date d1 = (Date) sunriseDates.get(i + 1);
        Date d2 = (Date) sunriseDates.get(i);
        int x1 = (int) domainAxis.valueToJava2D(d1.getTime(), dataArea, RectangleEdge.BOTTOM);
        int x2 = (int) domainAxis.valueToJava2D(d2.getTime(), dataArea, RectangleEdge.BOTTOM);
        g2.fillRect(x1, top, (x2 - x1), height);
    }
    g2.setClip(originalClip);
}

From source file:peakml.util.jfreechart.FastSpectrumPlot.java

@Override
public void draw(Graphics2D g2, Rectangle2D area, Point2D anchor, PlotState parentState,
        PlotRenderingInfo info) {/*ww w.  ja  v a2  s.  co  m*/
    // add the plot area to the info (used amongst other by the axis for zooming)
    if (info != null)
        info.setPlotArea(area);

    // add the insets (if any)
    RectangleInsets insets = getInsets();
    insets.trim(area);

    // draw the axis and add the dataArea to the info (used amongst other by the axis for zooming)
    AxisSpace space = new AxisSpace();
    space = xaxis.reserveSpace(g2, this, area, RectangleEdge.BOTTOM, space);
    space = yaxis.reserveSpace(g2, this, area, RectangleEdge.LEFT, space);

    Rectangle2D dataArea = space.shrink(area, null);
    if (info != null)
        info.setDataArea(dataArea);

    // flood fill the whole area with the background color
    drawBackground(g2, dataArea);

    // draw the axis
    xaxis.draw(g2, dataArea.getMaxY(), area, dataArea, RectangleEdge.BOTTOM, info);
    yaxis.draw(g2, dataArea.getMinX(), area, dataArea, RectangleEdge.LEFT, info);

    // sanity check
    if (dataseries.size() == 0)
        return;

    // clip the draw area
    Shape originalclip = g2.getClip();
    g2.clip(dataArea);

    // draw all the values
    for (Data data : dataseries) {
        int xpos = (int) xaxis.valueToJava2D(data.mass, dataArea, RectangleEdge.BOTTOM);
        int ypos = (int) yaxis.valueToJava2D(data.intensity, dataArea, RectangleEdge.LEFT);
        g2.drawLine(xpos, (int) yaxis.valueToJava2D(0, dataArea, RectangleEdge.LEFT), xpos, ypos);

        // draw the label
        if (data.description != null && data.description.length() != 0) {
            g2.setColor(Color.RED);
            g2.drawLine(xpos + 2, ypos - 2, xpos + 15, ypos - 15);
            g2.setColor(Color.BLACK);
            g2.drawString(data.description, xpos + 17, ypos - 17);
        }
    }

    // reset
    g2.setClip(originalclip);
}

From source file:org.eurocarbdb.application.glycoworkbench.plugin.reporting.AnnotationReportCanvas.java

protected void paintAnnotations(Graphics2D g2d) {

    DecimalFormat mz_df = new DecimalFormat("0.0");

    // set font/* w w w  .  j av a 2  s  . c o m*/
    Font old_font = g2d.getFont();
    Font new_font = new Font(theOptions.ANNOTATION_MZ_FONT, Font.PLAIN, theOptions.ANNOTATION_MZ_SIZE);

    // compute bboxes
    PositionManager pman = new PositionManager();
    BBoxManager bbman = new BBoxManager();
    computeRectangles(pman, bbman);

    // compute connections
    computeConnections();

    // paint connections
    for (AnnotationObject a : theDocument.getAnnotations()) {
        boolean selected = !is_printing && selections.contains(a);

        // paint arrow        
        Polygon connection = connections.get(a);
        if (connection != null) {
            g2d.setColor(theOptions.CONNECTION_LINES_COLOR);
            g2d.setStroke((selected) ? new BasicStroke((float) (1. + theOptions.ANNOTATION_LINE_WIDTH))
                    : new BasicStroke((float) theOptions.ANNOTATION_LINE_WIDTH));
            g2d.draw(connection);
            g2d.setStroke(new BasicStroke(1));
        }

        // paint control point       
        if (selected) {
            g2d.setColor(Color.black);
            Point2D cp = connections_cp.get(a);
            if (cp != null) {
                int s = (int) (2 + theOptions.ANNOTATION_LINE_WIDTH);
                g2d.fill(new Rectangle((int) cp.getX() - s, (int) cp.getY() - s, 2 * s, 2 * s));
            }
        }
    }

    // paint glycans
    for (AnnotationObject a : theDocument.getAnnotations()) {
        boolean highlighted = a.isHighlighted();
        boolean selected = !is_printing && selections.contains(a);

        // set scale
        theGlycanRenderer.getGraphicOptions().setScale(theOptions.SCALE_GLYCANS * theDocument.getScale(a));

        // paint highlighted region
        if (highlighted) {
            Rectangle c_bbox = rectangles_complete.get(a);

            g2d.setColor(theOptions.HIGHLIGHTED_COLOR);
            g2d.setXORMode(Color.white);
            g2d.fill(c_bbox);
            g2d.setPaintMode();

            g2d.setColor(Color.black);
            g2d.draw(c_bbox);
        }

        // paint glycan
        for (Glycan s : a.getStructures())
            theGlycanRenderer.paint(g2d, s, null, null, false, false, pman, bbman);

        // paint MZ text
        g2d.setFont(new_font);
        g2d.setColor(theOptions.MASS_TEXT_COLOR);
        String mz_text = mz_df.format(a.getPeakPoint().getX());
        Rectangle mz_bbox = rectangles_text.get(a);
        g2d.drawString(mz_text, mz_bbox.x, mz_bbox.y + mz_bbox.height);

        // paint selection        
        if (selected) {
            // paint rectangle
            Rectangle c_bbox = rectangles_complete.get(a);

            g2d.setStroke(new BasicStroke(highlighted ? 2 : 1));
            g2d.setColor(Color.black);

            g2d.draw(c_bbox);

            g2d.setStroke(new BasicStroke(1));

            // paint resize points        
            Polygon p1 = new Polygon();
            int cx1 = right(c_bbox);
            int cy1 = top(c_bbox);
            p1.addPoint(cx1, cy1);
            p1.addPoint(cx1 - 2 * theOptions.ANNOTATION_MARGIN / 3, cy1);
            p1.addPoint(cx1, cy1 + 2 * theOptions.ANNOTATION_MARGIN / 3);
            g2d.fill(p1);

            Polygon p2 = new Polygon();
            int cx2 = left(c_bbox);
            int cy2 = top(c_bbox);
            p2.addPoint(cx2, cy2);
            p2.addPoint(cx2 + 2 * theOptions.ANNOTATION_MARGIN / 3, cy2);
            p2.addPoint(cx2, cy2 + 2 * theOptions.ANNOTATION_MARGIN / 3);
            g2d.fill(p2);
        }
    }

    g2d.setFont(old_font);
}

From source file:org.gumtree.vis.awt.time.TimePlotPanel.java

@Override
protected void drawToolTipFollower(Graphics2D g2, int x, int y) {
    Rectangle2D dataArea = getScreenDataArea();
    if (((int) dataArea.getMinX() <= x) && (x <= (int) dataArea.getMaxX()) && ((int) dataArea.getMinY() <= y)
            && (y <= (int) dataArea.getMaxY())) {
        Date date = new Date((long) getChartX());
        String text = "";
        SimpleDateFormat format = new SimpleDateFormat("EEE d MMM HH:mm:ss");
        StringBuffer buffer = new StringBuffer();
        format.format(date, buffer, new FieldPosition(0));
        text = buffer.toString();//from w  w w.  j  a v  a2s .co m
        text = "(" + text + String.format(", %.2f)", getChartY());
        int xLoc = x + 10;
        int yLoc = y + 20;
        double width = text.length() * 5.5;
        double height = 15;
        if (xLoc + width > dataArea.getMaxX()) {
            xLoc = (int) (x - width);
        }
        if (yLoc + height > dataArea.getMaxY()) {
            yLoc = (int) (y - height);
        }

        Rectangle2D toolTipArea = new Rectangle2D.Double(xLoc, yLoc, width, height);

        g2.setColor(Color.white);
        g2.fill(toolTipArea);
        g2.setColor(Color.black);
        g2.drawString(text, xLoc + 3, yLoc + 11);
    }
}