jcckit.GraphicsPlotCanvas Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of plantuml Show documentation

PlantUML is a component that allows to quickly write : * sequence diagram, * use case diagram, * class diagram, * activity diagram, * component diagram, * state diagram * object diagram

The newest version!

/*
 * Copyright 2003-2004, Franz-Josef Elmer, All rights reserved
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details
 * (http://www.gnu.org/copyleft/lesser.html).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcckit;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;

import jcckit.graphic.GraphicalElement;
import jcckit.graphic.Renderer;
import jcckit.plot.Plot;
import jcckit.plot.PlotCanvas;
import jcckit.renderer.Graphics2DRenderer;
import jcckit.renderer.Transformation;
import jcckit.util.ConfigParameters;
import jcckit.util.Factory;

/**
 * Class which handles plotting into a Graphics context based on the
 * {@link jcckit.renderer.GraphicsRenderer}. This class is not a subclass of
 * java.awt.Component. The actual AWT component presenting the plot
 * is an innerclass. Its instance wrapped by GraphicsPlotCanvas can
 * be obtained with {@link #getGraphicsCanvas}.
 * 
 * The plot is painted by using double-buffering and pre-rendered view of the
 * coordinate system. That is, the coordinate system is drawn into an off-screen
 * image. It will be redrawn only if the size of the embedding AWT component is
 * changed.
 * 
 * @author Franz-Josef Elmer
 */
public class GraphicsPlotCanvas extends PlotCanvas {
	/** Key of a configuration parameter. */
	public static final String BACKGROUND_KEY = "background";
	public static final String FOREGROUND_KEY = "foreground";
	public static final String DOUBLE_BUFFERING_KEY = "doubleBuffering";

	/**
	 * Class which does the actual painting. Needs the Component into
	 * which the plot is painted for some resources like size, background color,
	 * etc.
	 * 
	 * @author Franz-Josef Elmer
	 */
	private final BufferedImage img3;

	private final Graphics2D g3;

	private Transformation _transformation;
	private String _renderer = "jcckit.renderer.GraphicsRenderer";

	private GraphicalElement _marker;

	/**
	 * Creates an instance from the specified configuration parameters. 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 *     
	 *     
	 * Key & Default Value Type Mandatory Description
background = default background color of the wrapped
	 * AWT component Color no Background color of the wrapped AWT component.
foreground = default foreground color of the wrapped
	 * AWT component Color no Foreground color of the wrapped AWT component.
doubleBuffering = true boolean no If true the plot will be painted by using 
	 *         double-buffering and pre-rendered view of the coordinate system.
	 *     
	 * In addition the configuration parameters of the
	 * 
	 * constructor of the superclass {@link jcckit.plot.PlotCanvas} apply.
	 */
	public GraphicsPlotCanvas(ConfigParameters config, BufferedImage img3) {
		super(config);
		this.img3 = img3;
		setRenderer("jcckit.renderer.Graphics2DRenderer");

		g3 = img3.createGraphics();
		g3.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

		// _doubleBuffering = config.getBoolean(DOUBLE_BUFFERING_KEY, true);
		background = config.getColor(BACKGROUND_KEY, Color.WHITE);
		foreground = config.getColor(FOREGROUND_KEY, Color.BLACK);
	}

	private final Color background;
	private final Color foreground;

	/**
	 * Paints the plot. If {@link GraphicsPlotCanvas#_doubleBuffering} is set
	 * double-buffering and pre-rendered view of the coordinate system is used.
	 */
	public void paint() {
		Dimension size = new Dimension(img3.getWidth(), img3.getHeight());
		g3.setColor(background);
		g3.fillRect(0, 0, size.width + 1, size.height + 1);

		init(size);

		_transformation.apply(g3);
		Plot plot = getPlot();
		drawCoordinateSystem(size, plot);
		drawPlot(plot);
		if (_marker != null) {
			_marker.renderWith(createRenderer());
		}
	}

	private void drawPlot(Plot plot) {
		prepare();
		Renderer renderer = createRenderer();
		GraphicalElement[] curves = plot.getCurves();
		for (int i = 0; i < curves.length; i++) {
			curves[i].renderWith(renderer);
		}
		GraphicalElement annotation = plot.getAnnotation();
		if (annotation != null) {
			annotation.renderWith(renderer);
		}
		if (plot.isLegendVisible()) {
			plot.getLegend().renderWith(renderer);
		}
	}

	private void init(Dimension size) {
		calculateTransformation(size);
	}

	private void drawCoordinateSystem(Dimension size, Plot plot) {
		g3.setColor(foreground);
		plot.getCoordinateSystem().renderWith(createRenderer());
	}

	/**
	 * Prepare graphics context before drawing the pre-rendered view of the
	 * coordinate system. Does nothing but will be used in subclasses.
	 */
	protected void prepare() {
	}

	/**
	 * Calculate the transformation form device-independent coordinates into
	 * device-dependent coordinates according to the specified canvas size.
	 */
	protected void calculateTransformation(Dimension size) {
		_transformation = new Transformation(size.width, size.height, getPaper(), getHorizontalAnchor(),
				getVerticalAnchor());
	}

	/**
	 * Creates an appropriated {@link Renderer} for the specified
	 * Graphics context.
	 */
	protected Renderer createRenderer() {
		return ((Graphics2DRenderer) Factory.create(_renderer)).init(g3);
		// return ((GraphicsRenderer) Factory.create(_renderer)).init(g, null,
		// _transformation);
	}

	/**
	 * Sets the renderer used to render the plot. The default value is
	 * {@link GraphicsRenderer}.
	 * 
	 * @param className
	 *            Fully qualified name of the renderer class.
	 */
	public void setRenderer(String className) {
		_renderer = className;
	}

	// /**
	// * Maps the cursor position onto a point in device-independent
	// coordinates.
	// *
	// * @param x
	// * X-coordinate of the cursor.
	// * @param y
	// * Y-coordinate of the cursor.
	// */
	// public GraphPoint mapCursorPosition(int x, int y) {
	// return _transformation.transformBack(x, y);
	// }

	/**
	 * Defines a graphical marker which will be drawn on top of the plot. To
	 * remove the marker call this method with argument null.
	 * 
	 * @param marker
	 *            Marker element. Can be null.
	 */
	public void setMarker(GraphicalElement marker) {
		_marker = marker;
	}

}

Key & Default Value	Type	Mandatory	Description
`background =` default background color of the wrapped AWT component*	`Color`	no	Background color of the wrapped AWT component.
`foreground =` default foreground color of the wrapped AWT component*	`Color`	no	Foreground color of the wrapped AWT component.
`doubleBuffering = true`	`boolean`	no	If `true` the plot will be painted by using * double-buffering and pre-rendered view of the coordinate system. *