Java Code Examples for java.awt.Graphics2D#create()

public void paintGraph(Graphics graphics, int pixWidth, int pixHeight) {
	Graphics2D g = (Graphics2D) graphics;
	Graphics2D scaled = (Graphics2D) g.create();

	scaled.translate(0, pixHeight + 1 + this.updatePanelHeight + 50);
	// prepare data
	prepareData();

	scaled.scale(1, -1);
	g.setColor(Color.black);
	drawPoints(scaled, pixWidth, pixHeight);

	scaled.dispose();

	// x-axis label
	String xAxisLabel = "sorted k-distances";
	Rectangle2D stringBounds = SCALED_LABEL_FONT.getStringBounds(xAxisLabel, g.getFontRenderContext());
	g.drawString(xAxisLabel, MARGIN + (float) (pixWidth / 2.0d - stringBounds.getWidth() / 2.0d), MARGIN
			+ (float) (pixHeight - 2.0d * stringBounds.getHeight()) + 3);

	// y-axis label
	String yAxisLabel = "k-distance value";
	stringBounds = LABEL_FONT.getStringBounds(yAxisLabel, g.getFontRenderContext());
	g.drawString(yAxisLabel, MARGIN, (int) (MARGIN + stringBounds.getHeight() + 6));
}
 

public void paint(Graphics g) {
    Graphics2D g2d = (Graphics2D)g;
    // prevent the clipping from applying to the lines
    Graphics2D another = (Graphics2D)g2d.create();

    g2d.scale(get(zoom), get(zoom));
    g2d.clipRect(get(cropLeft) + 10, get(cropTop) + 10, getWidth() / get(zoom) - get(cropLeft) - get(cropRight) - 20,
            getHeight() / get(zoom) - get(cropTop) - get(cropBottom) - 20);
    BufferedImage img = wiz.getImage();
    g2d.drawImage(img, 10, 10, null);

    another.scale(get(zoom), get(zoom));
    another.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f));
    another.drawLine(0, get(top) + 10, getWidth() / get(zoom), get(top) + 10);
    another.drawLine(0, getHeight() / get(zoom) - get(bottom) - 10, getWidth() / get(zoom), getHeight() / get(zoom) - get(bottom) - 10);
    another.drawLine(get(left) + 10, 0, get(left) + 10, getHeight() / get(zoom));
    another.drawLine(getWidth() / get(zoom) - get(right) - 10, 0, getWidth() / get(zoom) - get(right) - 10, getHeight() / get(zoom));
    another.dispose();
}
 

/**
 * Draws the background annoations.
 */
private void draw(final ExecutionUnit process, final Graphics2D g2, final ProcessRendererModel rendererModel,
		final boolean printing) {
	if (!visualizer.isActive()) {
		return;
	}

	// background annotations
	WorkflowAnnotations annotations = rendererModel.getProcessAnnotations(process);
	if (annotations != null) {
		for (WorkflowAnnotation anno : annotations.getAnnotationsDrawOrder()) {
			// selected is drawn by highlight decorator
			if (anno.equals(model.getSelected())) {
				continue;
			}

			// paint the annotation itself
			Graphics2D g2P = (Graphics2D) g2.create();
			drawer.drawAnnotation(anno, g2P, printing);
			g2P.dispose();
		}
	}
}
 

@Override
public void render(JasperReportsContext jasperReportsContext, Graphics2D grx, Rectangle2D rectangle) throws JRException
{
	ensureSvg(jasperReportsContext);

	AffineTransform transform = ViewBox.getPreserveAspectRatioTransform(
			new float[]{0, 0, (float) documentSize.getWidth(), (float) documentSize.getHeight()},
			SVGPreserveAspectRatio.SVG_PRESERVEASPECTRATIO_NONE, true,
			(float) rectangle.getWidth(), (float) rectangle.getHeight());
	Graphics2D graphics = (Graphics2D) grx.create();
	try
	{
		graphics.translate(rectangle.getX(), rectangle.getY());
		graphics.transform(transform);

		// CompositeGraphicsNode not thread safe
		synchronized (rootNode)
		{
			rootNode.paint(graphics);
		}
	}
	finally
	{
		graphics.dispose();
	}
}
 

@Override
public void render(Graphics2D g, ScreenTransform transform) {
    if (start == null || end == null) {
        return;
    }
    Graphics2D graphics = (Graphics2D)g.create();
    graphics.setColor(colour);
    double x1 = start.getX();
    double x2 = end.getX();
    double y1 = start.getY();
    double y2 = end.getY();
    if (useWorldCoords) {
        x1 = transform.xToScreen(x1);
        x2 = transform.xToScreen(x2);
        /*
        double temp = transform.yToScreen(y2);
        y2 = transform.yToScreen(y1);
        y1 = temp;
        */
        y1 = transform.yToScreen(y1);
        y2 = transform.yToScreen(y2);
    }
    graphics.drawLine((int)x1, (int)y1, (int)x2, (int)y2);
}
 

protected void paintBackground(Graphics2D g, GeneralPath bodyOutline) {
	Paint background = getBackground();
	if (background != null) {

		if (isShadowActive()) {
			Graphics2D g2 = (Graphics2D) g.create();
			double dy = 0;
			Stroke stroke = getStroke();
			if (stroke != null) {
				dy = (ShapeBounds.getBounds(
						stroke.createStrokedShape(bodyOutline)).getHeight() - ShapeBounds
						.getBounds(bodyOutline).getHeight()) / 2;
			}
			g2.translate(0, dy);
			g2.setColor(getBackgroundShadowColor());
			g2.translate(0, 1);
			g2.fill(bodyOutline);
			g2.translate(0, 1);
			g2.fill(bodyOutline);
			g2.dispose();
		}

		g.setPaint(background);
		g.fill(bodyOutline);
	}
}
 

private void paintForegroundEnabledAndVertical(Graphics2D g, int width, int height) {
    Graphics2D g2 = (Graphics2D) g.create();
    g2.translate(0, height);
    g2.rotate(Math.toRadians(-90));

    paintForegroundEnabled(g2, height, width);
}
 

@Override
protected void drawDrawing(Graphics2D gr) {
  if (getDrawing() == null) {
    return;
  }

  Graphics2D g2d = (Graphics2D) gr.create();
  AffineTransform tx = g2d.getTransform();
  tx.translate(getDrawingToViewTransform().getTranslateX(),
               getDrawingToViewTransform().getTranslateY());
  tx.scale(getScaleFactor(), getScaleFactor());
  g2d.setTransform(tx);

  if (blocksVisible) {
    drawBlocks(g2d);
  }

  drawDriveOrderElements(g2d);

  getDrawing().setFontRenderContext(g2d.getFontRenderContext());
  try {
    getDrawing().draw(g2d);
  }
  catch (ConcurrentModificationException e) {
    LOG.warn("Exception from JHotDraw caught while calling DefaultDrawing.draw(), continuing.");
    // TODO What to do when it is catched?
  }

  g2d.dispose();
}
 

static void clear(Graphics2D  g, int type, int w, int h) {
    Graphics2D gg = (Graphics2D) g.create();
    if (type > OPAQUE) {
        gg.setColor(new Color(0, 0, 0, 0));
        gg.setComposite(AlphaComposite.Src);
    } else {
        gg.setColor(new Color(0xAD, 0xD8, 0xE6));
    }
    gg.fillRect(0, 0, w, h);
}
 

/**
 * Shadow non valid drop targets while dragging annotations around.
 *
 * @param g
 *            the graphics context to draw upon
 * @param anno
 *            the current annotation to draw
 * @param printing
 *            if we are currently printing
 */
private void shadowOperatorsWhileDragging(final Graphics2D g, final WorkflowAnnotation anno, final boolean printing) {
	if (printing) {
		// never draw them for printing
		return;
	}

	AnnotationDragHelper dragged = model.getDragged();
	// only shadow if we are actually dragging and the operator annotation is unsnapped
	if (!dragged.isUnsnapped() || !dragged.isDragInProgress()) {
		return;
	}
	Graphics2D g2 = (Graphics2D) g.create();

	// shadow operators which are not a valid drop target
	for (Operator op : anno.getProcess().getOperators()) {
		if (anno instanceof OperatorAnnotation) {
			if (op.equals(((OperatorAnnotation) anno).getAttachedTo())) {
				continue;
			}
		}
		WorkflowAnnotations annotations = rendererModel.getOperatorAnnotations(op);
		if (annotations != null && !annotations.isEmpty()) {
			overshadowRect(rendererModel.getOperatorRect(op), g2);
		}
	}

	g2.dispose();
}
 

/**
 * Draws indicator in case the annotation text overflows on the y axis.
 *
 * @param g
 *            the graphics context to draw upon
 * @param loc
 *            the location of the annotation
 * @param printing
 *            if we are currently printing
 */
private void drawOverflowIndicator(final Graphics2D g, final Rectangle2D loc, final boolean printing) {
	if (printing) {
		// never draw them for printing
		return;
	}
	Graphics2D g2 = (Graphics2D) g.create();

	int size = 20;
	int xOffset = 10;
	int yOffset = 10;
	int stepSize = size / 4;
	int dotSize = 3;
	int x = (int) loc.getMaxX() - size - xOffset;
	int y = (int) loc.getMaxY() - size - yOffset;
	GradientPaint gp = new GradientPaint(x, y, Color.WHITE, x, y + size * 1.5f, Color.LIGHT_GRAY);
	g2.setPaint(gp);
	g2.fillRect(x, y, size, size);

	g2.setColor(Color.BLACK);
	g2.drawRect(x, y, size, size);

	g2.fillOval(x + stepSize, y + stepSize * 2, dotSize, dotSize);
	g2.fillOval(x + stepSize * 2, y + stepSize * 2, dotSize, dotSize);
	g2.fillOval(x + stepSize * 3, y + stepSize * 2, dotSize, dotSize);

	g2.dispose();
}
 

static void clear(Graphics2D  g, int type, int w, int h) {
    Graphics2D gg = (Graphics2D) g.create();
    if (type > OPAQUE) {
        gg.setColor(new Color(0, 0, 0, 0));
        gg.setComposite(AlphaComposite.Src);
    } else {
        gg.setColor(new Color(0xAD, 0xD8, 0xE6));
    }
    gg.fillRect(0, 0, w, h);
}
 

/**
 * Draws operator backgrounds and then calls all registered {@link ProcessDrawDecorator}s for
 * the annotations render phase.
 *
 * @param process
 * 		the process to draw the operator backgrounds for
 * @param g2
 * 		the graphics context to draw upon
 * @param printing
 * 		if {@code true} we are printing instead of drawing to the screen
 */
public void drawOperatorBackgrounds(final ExecutionUnit process, final Graphics2D g2, final boolean printing) {
	Graphics2D gBG = (Graphics2D) g2.create();
	// draw background of operators
	for (Operator op : process.getOperators()) {
		Rectangle2D frame = model.getOperatorRect(op);
		if (frame == null) {
			continue;
		}

		// only draw background if operator is visisble
		Rectangle2D opBounds = new Rectangle2D.Double(frame.getX() - 10, frame.getY(), frame.getWidth() + 20,
				frame.getHeight());
		if (g2.getClipBounds() != null && !g2.getClipBounds().intersects(opBounds)) {
			continue;
		}

		renderOperatorBackground(op, gBG);
	}

	// draw connections background for all operators
	for (Operator operator : process.getOperators()) {
		renderConnectionsBackground(operator.getInputPorts(), operator.getOutputPorts(), gBG);
	}

	// draw connections background for process
	renderConnectionsBackground(process.getInnerSinks(), process.getInnerSources(), gBG);
	gBG.dispose();

	// let decorators draw
	drawPhaseDecorators(process, g2, RenderPhase.OPERATOR_BACKGROUND, printing);
}
 

public void paint(BoxContainerPanel bcp, Graphics2D g) {
	for (Handle handle : handles) {
		Graphics2D g2 = (Graphics2D) g.create();
		g2.setComposite(AlphaComposite.getInstance(
				AlphaComposite.SRC_OVER,
				bcp.getUI().getHandleOpacity(bcp, handle)));
		handle.paint(bcp, g2);
		g2.dispose();
	}
}
 

@Override
protected void paintWidget() {
    Graphics2D g = this.getGraphics();

    if (xPoints.length == 0 || Math.abs(xPoints[0] - xPoints[xPoints.length - 1]) > 2000) {
        return;
    }

    //g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
    //g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
    //g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);

    DiagramScene ds = (DiagramScene) this.getScene();
    boolean shouldHide = false;//ds.getShouldHide(this);

    Composite oldComposite = null;
    if (shouldHide) {
        Color c = new Color(255 - (255 - color.getRed()) / WHITE_FACTOR, 255 - (255 - color.getGreen()) / WHITE_FACTOR, 255 - (255 - color.getBlue()) / WHITE_FACTOR);
        g.setPaint(c);
    } else {
        g.setPaint(color);
    }

    if (split) {
        for (int i = 1; i < controlPoints.size(); i++) {
            Point prev = controlPoints.get(i - 1);
            Point cur = controlPoints.get(i);
            if (cur == null || prev == null) {
                continue;
            }

            g.drawLine(prev.x, prev.y, cur.x, cur.y);
        }
    } else {
        g.drawPolyline(xPoints, yPoints, pointCount);
    }

    /*for(int i=0; i<xPoints.length; i++) {
    int x = xPoints[i];
    int y = yPoints[i];
    g.fillOval(x - 2, y - 2, 4, 4);
    }*/

    if (xPoints.length >= 2) {
        Graphics2D g2 = (Graphics2D) g.create();
        int xOff = xPoints[xPoints.length - 2] - xPoints[xPoints.length - 1];
        int yOff = yPoints[yPoints.length - 2] - yPoints[yPoints.length - 1];
        if (xOff == 0 && yOff == 0 && yPoints.length >= 3) {
            xOff = xPoints[xPoints.length - 3] - xPoints[xPoints.length - 1];
            yOff = yPoints[yPoints.length - 3] - yPoints[yPoints.length - 1];
        }
        g2.translate(xPoints[xPoints.length - 1], yPoints[yPoints.length - 1]);
        g2.rotate(Math.atan2(yOff, xOff));

        g2.scale(0.55, 0.80);
        AnchorShape.TRIANGLE_FILLED.paint(g2, false);
    }
}
 

private void calcFontMetrics( Graphics2D g2d, int w, int h ) {
    FontMetrics fm;
    Graphics2D g2 = (Graphics2D)g2d.create();

    /// ABP
    if ( g2Transform != NONE && textToUse != FILE_TEXT ) {
        g2.setFont( g2.getFont().deriveFont( getAffineTransform( g2Transform )) );
        fm = g2.getFontMetrics();
    }
    else {
        fm = g2.getFontMetrics();
    }

    maxAscent = fm.getMaxAscent();
    maxDescent = fm.getMaxDescent();
    if (maxAscent == 0) maxAscent = 10;
    if (maxDescent == 0) maxDescent = 5;
    if ( textToUse == RANGE_TEXT || textToUse == ALL_GLYPHS ) {
        /// Give slight extra room for each character
        maxAscent += 3;
        maxDescent += 3;
        gridWidth = fm.getMaxAdvance() + 6;
        gridHeight = maxAscent + maxDescent;
        if ( force16Cols )
          numCharAcross = 16;
        else
          numCharAcross = ( w - 10 ) / gridWidth;
        numCharDown = ( h - 10 ) / gridHeight;

        canvasInset_X = ( w - numCharAcross * gridWidth ) / 2;
        canvasInset_Y = ( h - numCharDown * gridHeight ) / 2;
        if ( numCharDown == 0 || numCharAcross == 0 )
          throw new CannotDrawException( isPrinting ? CANT_FIT_PRINT : CANT_FIT_DRAW );

        if ( !isPrinting )
          resetScrollbar( verticalBar.getValue() * numCharAcross );
    }
    else {
        maxDescent += fm.getLeading();
        canvasInset_X = 5;
        canvasInset_Y = 5;
        /// gridWidth and numCharAcross will not be used in this mode...
        gridHeight = maxAscent + maxDescent;
        numCharDown = ( h - canvasInset_Y * 2 ) / gridHeight;

        if ( numCharDown == 0 )
          throw new CannotDrawException( isPrinting ? CANT_FIT_PRINT : CANT_FIT_DRAW );
        /// If this is text loaded from file, prepares the LineBreak'ed
        /// text layout at this point
        if ( textToUse == FILE_TEXT ) {
            if ( !isPrinting )
              f2dt.fireChangeStatus( "LineBreaking Text... Please Wait", false );
            lineBreakTLs = new Vector();
            for ( int i = 0; i < fileText.length; i++ ) {
                AttributedString as =
                  new AttributedString( fileText[i], g2.getFont().getAttributes() );

                LineBreakMeasurer lbm =
                  new LineBreakMeasurer( as.getIterator(), g2.getFontRenderContext() );

                while ( lbm.getPosition() < fileText[i].length() )
                  lineBreakTLs.add( lbm.nextLayout( (float) w ));

            }
        }
        if ( !isPrinting )
          resetScrollbar( verticalBar.getValue() );
    }
}
 

private void calcFontMetrics( Graphics2D g2d, int w, int h ) {
    FontMetrics fm;
    Graphics2D g2 = (Graphics2D)g2d.create();

    /// ABP
    if ( g2Transform != NONE && textToUse != FILE_TEXT ) {
        g2.setFont( g2.getFont().deriveFont( getAffineTransform( g2Transform )) );
        fm = g2.getFontMetrics();
    }
    else {
        fm = g2.getFontMetrics();
    }

    maxAscent = fm.getMaxAscent();
    maxDescent = fm.getMaxDescent();
    if (maxAscent == 0) maxAscent = 10;
    if (maxDescent == 0) maxDescent = 5;
    if ( textToUse == RANGE_TEXT || textToUse == ALL_GLYPHS ) {
        /// Give slight extra room for each character
        maxAscent += 3;
        maxDescent += 3;
        gridWidth = fm.getMaxAdvance() + 6;
        gridHeight = maxAscent + maxDescent;
        if ( force16Cols )
          numCharAcross = 16;
        else
          numCharAcross = ( w - 10 ) / gridWidth;
        numCharDown = ( h - 10 ) / gridHeight;

        canvasInset_X = ( w - numCharAcross * gridWidth ) / 2;
        canvasInset_Y = ( h - numCharDown * gridHeight ) / 2;
        if ( numCharDown == 0 || numCharAcross == 0 )
          throw new CannotDrawException( isPrinting ? CANT_FIT_PRINT : CANT_FIT_DRAW );

        if ( !isPrinting )
          resetScrollbar( verticalBar.getValue() * numCharAcross );
    }
    else {
        maxDescent += fm.getLeading();
        canvasInset_X = 5;
        canvasInset_Y = 5;
        /// gridWidth and numCharAcross will not be used in this mode...
        gridHeight = maxAscent + maxDescent;
        numCharDown = ( h - canvasInset_Y * 2 ) / gridHeight;

        if ( numCharDown == 0 )
          throw new CannotDrawException( isPrinting ? CANT_FIT_PRINT : CANT_FIT_DRAW );
        /// If this is text loaded from file, prepares the LineBreak'ed
        /// text layout at this point
        if ( textToUse == FILE_TEXT ) {
            if ( !isPrinting )
              f2dt.fireChangeStatus( "LineBreaking Text... Please Wait", false );
            lineBreakTLs = new Vector();
            for ( int i = 0; i < fileText.length; i++ ) {
                AttributedString as =
                  new AttributedString( fileText[i], g2.getFont().getAttributes() );

                LineBreakMeasurer lbm =
                  new LineBreakMeasurer( as.getIterator(), g2.getFontRenderContext() );

                while ( lbm.getPosition() < fileText[i].length() )
                  lineBreakTLs.add( lbm.nextLayout( (float) w ));

            }
        }
        if ( !isPrinting )
          resetScrollbar( verticalBar.getValue() );
    }
}
 

protected void paintPage(Graphics2D grx)
{
	if (pageError)
	{
		paintPageError(grx);
		return;
	}
	
	try
	{
		if (exporter == null)
		{
			exporter = getGraphics2DExporter();
		}
		else
		{
			exporter.reset();
		}

		exporter.setExporterInput(new SimpleExporterInput(viewerContext.getJasperPrint()));

		SimpleGraphics2DReportConfiguration configuration = new SimpleGraphics2DReportConfiguration();
		configuration.setPageIndex(viewerContext.getPageIndex());
		configuration.setZoomRatio(realZoom);
		configuration.setOffsetX(1); //lblPage border
		configuration.setOffsetY(1);
		exporter.setConfiguration(configuration);

		SimpleGraphics2DExporterOutput output = new SimpleGraphics2DExporterOutput();
		Graphics2D g = (Graphics2D)grx.create();
		output.setGraphics2D(g);
		exporter.setExporterOutput(output);

		try
		{
			exporter.exportReport();
		}
		finally
		{
			g.dispose();
		}
	}
	catch(Exception e)
	{
		if (log.isErrorEnabled())
		{
			log.error("Page paint error.", e);
		}

		pageError = true;
		
		paintPageError(grx);
		SwingUtilities.invokeLater(new Runnable()
		{
			@Override
			public void run()
			{
				JOptionPane.showMessageDialog(JRViewerPanel.this, viewerContext.getBundleString("error.displaying"));
			}
		});
	}

}
 

/**
 * Prepares this Graphics2D to paint this BlockLetter at the given (x,y)
 * coordinate.
 * 
 * @param g
 *            the Graphics2D to paint to
 * @param x
 *            the x-coordinate to paint to
 * @param y
 *            the y-coordinate to paint to
 * @return a cloned Graphics2D to paint to. When complete you should dispose
 *         this Graphics2D.
 */
protected Graphics2D prep(Graphics2D g, float x, float y) {
	Graphics2D g2 = (Graphics2D) g.create();
	g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
			RenderingHints.VALUE_ANTIALIAS_ON);
	g2.translate(x, y);

	float dx = (float) (depth * Math.cos(angle));
	float dy = (float) (depth * Math.sin(angle));
	g2.translate(-dx, -dy);
	return g2;
}
 

/**
 * Draws the process(es) foreground based on the {@link ProcessRendererModel} data and then
 * calls all registered {@link ProcessDrawDecorator}s for the foreground render phase.
 *
 * @param process
 * 		the process to draw the foreground for
 * @param g2
 * 		the graphics context to draw upon
 * @param printing
 * 		if {@code true} we are printing instead of drawing to the screen
 */
public void drawForeground(final ExecutionUnit process, final Graphics2D g2, final boolean printing) {
	Graphics2D gBG = (Graphics2D) g2.create();
	renderForeground(process, gBG, printing);
	gBG.dispose();
}