org.openscience.cdk.renderer

Class AbstractRenderer<T extends IChemObject>

java.lang.Object

org.openscience.cdk.renderer.AbstractRenderer<T>

Direct Known Subclasses:

AtomContainerRenderer, ChemModelRenderer, MoleculeSetRenderer, ReactionRenderer, ReactionSetRenderer

public abstract class AbstractRenderer<T extends IChemObject>
extends Object

The base class for all renderers, handling the core aspects of rendering such as the location of the model in 'model space' and the location on the screen to draw the model. It also holds a reference to the list of IGenerator instances that are used to create the diagram. These generators are accessed through the generateDiagram method.

The terminology 'model space' and 'screen space' refer to the coordinate systems for the model and the drawing, respectively. So the 2D points for atoms in the model might be 1 unit apart (roughly representing Ångstrom, perhaps) but the circles in the diagram that represent those atoms might be 10 pixels apart on screen. Therefore screen space will be 10 times model space for this example.

The abstract method calculateScaleForBondLength(double) is needed to determine the scale. For the model example just given, this would return '10.0' for an input of '10.0', as that is the scale for that desired bond length.

Author:

maclean

Constructor Summary

Constructors

Constructor and Description
AbstractRenderer(RendererModel rendererModel)

Method Summary

Methods

Modifier and Type	Method and Description
abstract double	calculateScaleForBondLength(double bondLength) Calculate the scale to convert the model bonds into bonds of the length supplied.
Rectangle	calculateScreenBounds(Rectangle2D modelBounds) Converts a bounding rectangle in 'model space' into the equivalent bounds in 'screen space'.
IRenderingElement	generateDiagram(T object) The main method of the renderer, that uses each of the generators to create a different set of IRenderingElements grouped together into a tree.
javax.vecmath.Point2d	getDrawCenter() Get the position on screen that the diagram will be drawn.
javax.vecmath.Point2d	getModelCenter() Get the center of the model.
RendererModel	getRenderer2DModel() Get the RendererModel used by this renderer, which provides access to the various parameters used to generate and draw the diagram.
void	repaint(IDrawVisitor drawVisitor) Repaint using the cached diagram.
void	setDrawCenter(double modelX, double modelY) Set the point on the screen to draw the diagram.
void	setModelCenter(double modelX, double modelY) Set the position of the center of the model.
void	setZoom(double zoom) Set the zoom, where 1.0 is 100% zoom.
void	setZoomToFit(double drawWidth, double drawHeight, double diagramWidth, double diagramHeight) Calculate and set the zoom factor needed to completely fit the diagram onto the screen bounds.
Rectangle	shift(Rectangle screenBounds, Rectangle diagramBounds) Determine the overlap of the diagram with the screen, and shift (if necessary) the diagram draw center.
void	shiftDrawCenter(double shiftX, double shiftY) Move the draw center by dx and dy.
javax.vecmath.Point2d	toModelCoordinates(double screenX, double screenY) Convert a point in screen space into a point in model space.
javax.vecmath.Point2d	toScreenCoordinates(double modelX, double modelY) Convert a point in model space into a point in screen space.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AbstractRenderer

public AbstractRenderer(RendererModel rendererModel)

Method Detail

generateDiagram

public IRenderingElement generateDiagram(T object)

The main method of the renderer, that uses each of the generators to create a different set of IRenderingElements grouped together into a tree.

Parameters:

object - the object of type T to draw

Returns:

the diagram as a tree of IRenderingElements

calculateScaleForBondLength

public abstract double calculateScaleForBondLength(double bondLength)

Calculate the scale to convert the model bonds into bonds of the length supplied. A standard way to do this is to calculate the average bond length (mean, or median) in model space, and divide the supplied screen distance by this average to give a scale.

Parameters:

bondLength - the desired length on screen

Returns:

a multiplication factor, or 'scale'

calculateScreenBounds

public Rectangle calculateScreenBounds(Rectangle2D modelBounds)

Converts a bounding rectangle in 'model space' into the equivalent bounds in 'screen space'. Used to determine how much space the model will take up on screen given a particular scale, zoom, and margin.

Parameters:

modelBounds - the bounds of the model

Returns:

the bounds of the diagram as drawn on screen

toModelCoordinates

public javax.vecmath.Point2d toModelCoordinates(double screenX,
                                       double screenY)

Convert a point in screen space into a point in model space.

Parameters:

screenX - the screen x-coordinate

screenY - the screen y-coordinate

Returns:

the equivalent point in model space, or (0,0) if there is an error

toScreenCoordinates

public javax.vecmath.Point2d toScreenCoordinates(double modelX,
                                        double modelY)

Convert a point in model space into a point in screen space.

Parameters:

modelX - the model x-coordinate

modelY - the model y-coordinate

Returns:

the equivalent point in screen space

setModelCenter

public void setModelCenter(double modelX,
                  double modelY)

Set the position of the center of the model.

Parameters:

modelX - the x-coordinate of the model center

modelY - the y-coordinate of the model center

setDrawCenter

public void setDrawCenter(double modelX,
                 double modelY)

Set the point on the screen to draw the diagram.

Parameters:

modelX - the x-coordinate of the point to draw at

modelY - the y-coordinate of the point to draw at

setZoom

public void setZoom(double zoom)

Set the zoom, where 1.0 is 100% zoom.

Parameters:

zoom - the zoom as a double value

getRenderer2DModel

public RendererModel getRenderer2DModel()

Get the RendererModel used by this renderer, which provides access to the various parameters used to generate and draw the diagram.

Returns:

a reference to the RendererModel

shiftDrawCenter

public void shiftDrawCenter(double shiftX,
                   double shiftY)

Move the draw center by dx and dy.

Parameters:

shiftX - the x shift

shiftY - the y shift

getDrawCenter

public javax.vecmath.Point2d getDrawCenter()

Get the position on screen that the diagram will be drawn.

Returns:

the draw center

getModelCenter

public javax.vecmath.Point2d getModelCenter()

Get the center of the model.

Returns:

the model center

setZoomToFit

public void setZoomToFit(double drawWidth,
                double drawHeight,
                double diagramWidth,
                double diagramHeight)

Calculate and set the zoom factor needed to completely fit the diagram onto the screen bounds.

Parameters:

drawWidth - the width of the area to draw onto

drawHeight - the height of the area to draw onto

diagramWidth - the width of the diagram

diagramHeight - the height of the diagram

repaint

public void repaint(IDrawVisitor drawVisitor)

Repaint using the cached diagram.

Parameters:

drawVisitor - the wrapper for the graphics object that draws

shift

public Rectangle shift(Rectangle screenBounds,
              Rectangle diagramBounds)

Determine the overlap of the diagram with the screen, and shift (if necessary) the diagram draw center. It returns a rectangle only because that is a convenient class to hold the four parameters calculated, but it is not a rectangle representing an area...

Parameters:

screenBounds - the bounds of the screen

diagramBounds - the bounds of the diagram

Returns:

the shape that the screen should be