All Downloads are FREE. Search and download functionalities are using the official Maven repository.

jcckit.GraphicsPlotCanvas Maven / Gradle / Ivy

Go to download

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

There is a newer version: 8059
Show 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 ValueTypeMandatoryDescription
background = default background color of the wrapped * AWT componentColornoBackground color of the wrapped AWT component.
foreground = default foreground color of the wrapped * AWT componentColornoForeground color of the wrapped AWT component.
doubleBuffering = truebooleannoIf 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; } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy