|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
ObjectComponent
Container
JComponent
ZoomPane
public abstract class ZoomPane
Base class for widget with a zoomable content. User can perform zooms using keyboard, menu or mouse. Subclasses must provide the content to be paint with the following methods, which need to be overridden:
getArea(), which must return a bounding box for the content to paint. This
area can be expressed in arbitrary units. For example, an object wanting to display a
geographic map with a content ranging from 10° to 15°E and 40° to 45°N should override
this method as follows:
public Rectangle2D getArea() {
return new Rectangle2D.Double(10, 40, 15-10, 45-40);
}paintComponent(Graphics2D), which must paint the widget content. Implementations
must invoke graphics.transform( somewhere in their code in order to
perform the zoom. Note that, by default, the zoom is initialized in such a way
that the y axis points upwards, like the convention in geometry. This is opposed to
the default Java2D axis orientation, where the y axis points downwards. The Java2D
convention is appropriate for text rendering - consequently implementations wanting to paint
text should use the default transform (the one provided by zoom)Graphics2D) for that
purpose. Example:
protected void paintComponent(final Graphics2D graphics) {
graphics.clip(getZoomableBounds(null));
final AffineTransform textTr = graphics.getTransform();
graphics.transform(zoom);
// Paint the widget here, using logical coordinates.
// The coordinate system is the same as getArea()'s one.
graphics.setTransform(textTr);
// Paint any text here, in pixel coordinates.
}reset(), which sets up the initial zoom. Overriding this method
is optional since the default implementation is appropriate in many cases. This default
implementation setups the initial zoom in such a way that the following relation
approximately hold: Logical coordinates provided by getPreferredArea(),
after an affine transform described by zoom, match pixel coordinates provided
by getZoomableBounds(Rectangle).
getArea(). The user can specify a
different preferred area with setPreferredArea(Rectangle2D). The user can also
reduce zoomable bounds by inserting an empty border around the widget, e.g.:
setBorder(BorderFactory.createEmptyBorder(top, left, bottom, right));
Zoom actions
Whatever action is performed by the user, all zoom commands are translated as calls to
transform(AffineTransform). Derived classes can redefine this method if they want
to take particular actions during zooms, for example, modifying the minimum and maximum of
a graph's axes. The table below shows the keyboard presses assigned to each zoom:
|
|
|
In this table, the last column gives the Strings that identify the different actions
which manage the zooms. For example, to zoom in, we must write
getActionMap().get("ZoomIn").
Scroll pane
JScrollPane objects are not suitable for adding scrollbars to a
ZoomPane object. Instead, use createScrollPane(). Once again, all
movements performed by the user through the scrollbars will be translated by calls to
transform(AffineTransform).
|
To try this component in your browser, see the demonstration applet. |
| display/geotk-widgets-swing (download) | View source code for this class |
| Nested Class Summary |
|---|
| Nested classes/interfaces inherited from class JComponent |
|---|
JComponent.AccessibleJComponent |
| Nested classes/interfaces inherited from class Container |
|---|
Container.AccessibleAWTContainer |
| Nested classes/interfaces inherited from class Component |
|---|
Component.AccessibleAWTComponent, Component.BaselineResizeBehavior, Component.BltBufferStrategy, Component.FlipBufferStrategy |
| Field Summary | |
|---|---|
static int |
DEFAULT_ZOOM
Constant indicating default zoom close to the maximum permitted zoom. |
static int |
RESET
Constant indicating the resetting of scale, rotation and translation to a default value which makes the whole graphic appear in a window. |
static int |
ROTATE
Constant indicating a rotation. |
static int |
SCALE_X
Constant indicating the scale changes on the x axis. |
static int |
SCALE_Y
Constant indicating the scale changes on the y axis. |
static int |
TRANSLATE_X
Constant indicating the translations on the x axis. |
static int |
TRANSLATE_Y
Constant indicating the translations on the y axis. |
static int |
UNIFORM_SCALE
Constant indicating the scale changes on the x and y axes, with the added condition that these changes must be uniform. |
protected AffineTransform |
zoom
Affine transform containing zoom factors, translations and rotations. |
| Fields inherited from class JComponent |
|---|
accessibleContext, listenerList, TOOL_TIP_TEXT_KEY, ui, UNDEFINED_CONDITION, WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, WHEN_FOCUSED, WHEN_IN_FOCUSED_WINDOW |
| Fields inherited from class Component |
|---|
BOTTOM_ALIGNMENT, CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT, TOP_ALIGNMENT |
| Fields inherited from interface ImageObserver |
|---|
ABORT, ALLBITS, ERROR, FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, WIDTH |
| Constructor Summary | |
|---|---|
ZoomPane(int allowedActions)
Constructs a ZoomPane. |
|
| Method Summary | |
|---|---|
void |
addMouseListener(MouseListener listener)
Adds an object to the list of objects interested in being notified about mouse events. |
void |
addZoomChangeListener(ZoomChangeListener listener)
Adds an object to the list of objects interested in being notified about zoom changes. |
void |
buildNavigationMenu(JMenu menu)
Adds navigation options to the specified menu. |
void |
correctApparentPixelPosition(Point2D point)
Corrects a pixel's coordinates for removing the effect of the magnifying glass. |
JComponent |
createScrollPane()
Returns an object which displays this ZoomPane with the scrollbars. |
protected void |
fireZoomChanged(AffineTransform change)
Signals that a zoom change has taken place. |
abstract Rectangle2D |
getArea()
Returns a bounding box that contains the logical coordinates of all data that may be displayed in this ZoomPane. |
protected Dimension |
getDefaultSize()
Returns the default size for this component. |
Insets |
getInsets()
Returns the Insets of this component. |
Paint |
getMagnifierBorder()
Returns the color of the magnifying glass's border. |
Paint |
getMagnifierGlass()
Returns the color with which to tint magnifying glass. |
protected JPopupMenu |
getMagnifierMenu(MouseEvent event)
Method called automatically when the user clicks on the right mouse button inside the magnifying glass. |
protected Shape |
getMouseSelectionShape(Point2D point)
Returns the geometric shape to be used to delimitate an area. |
protected JPopupMenu |
getPopupMenu(MouseEvent event)
Method called automatically when the user clicks on the right mouse button. |
Rectangle2D |
getPreferredArea()
Returns the logical coordinates of the region that we want to see displayed the first time that ZoomPane appears on the screen. |
protected Dimension2D |
getPreferredPixelSize()
Returns the preferred pixel size for a close zoom. |
double |
getScaleFactor()
Returns the current zoom scale factor. |
AffineTransform |
getTransform()
Returns a clone of the current zoom transform. |
Rectangle2D |
getVisibleArea()
Returns the logical coordinates of the region visible on the screen. |
protected Rectangle |
getZoomableBounds(Rectangle bounds)
Returns the bounding box (in pixel coordinates) of the zoomable area. |
boolean |
hasPreferredArea()
Indicates whether the logical coordinates of a region have been defined. |
boolean |
isMagnifierEnabled()
Indicates whether or not the magnifying glass is allowed to be displayed on this component. |
boolean |
isMagnifierVisible()
Indicates whether or not the magnifying glass is visible. |
boolean |
isPaintingWhileAdjusting()
Indicates whether or not this ZoomPane object should be repainted when the user
moves the scrollbar slider. |
protected void |
mouseSelectionPerformed(Shape area)
Method called automatically after the user selects an area with the mouse. |
protected void |
paintComponent(Graphics graphics)
Paints this component. |
protected abstract void |
paintComponent(Graphics2D graphics)
Paints this component. |
protected void |
paintMagnifier(Graphics2D graphics)
Paints the magnifying glass. |
protected void |
printComponent(Graphics graphics)
Prints this component. |
protected void |
printComponent(Graphics2D graphics)
Prints this component. |
void |
removeZoomChangeListener(ZoomChangeListener listener)
Removes an object from the list of objects interested in being notified about zoom changes. |
void |
repaint(long tm,
int x,
int y,
int width,
int height)
Declares that a part of this pane needs to be repainted. |
void |
reset()
Reinitializes the zoom affine transform in order to cancel any zoom, rotation or translation. |
protected void |
reset(Rectangle zoomableBounds,
boolean yAxisUpward)
Reinitializes the affine transform zoom in order to cancel any zoom, rotation or
translation. |
void |
scrollRectToVisible(Rectangle rect)
Modifies the position in pixels of the visible part of ZoomPane. |
void |
setMagnifierBorder(Paint color)
Sets the color of the magnifying glass's border. |
void |
setMagnifierEnabled(boolean enabled)
Specifies whether or not the magnifying glass is allowed to be displayed on this component. |
void |
setMagnifierGlass(Paint color)
Sets the color with which to tint magnifying glass. |
void |
setMagnifierVisible(boolean visible)
Displays or hides the magnifying glass. |
void |
setPaintingWhileAdjusting(boolean flag)
Defines whether or not this ZoomPane object should repaint the map when the user
moves the scrollbar slider. |
void |
setPreferredArea(Rectangle2D area)
Specifies the logical coordinates of the region that we want to see displayed the first time that ZoomPane appears on the screen. |
protected void |
setResetPolicy(boolean fill)
Sets the policy for the zoom when the content is initially drawn or when the user resets the zoom. |
void |
setTransform(AffineTransform tr)
Sets the zoom transform to the given value. |
void |
setVisibleArea(Rectangle2D logicalBounds)
Defines the limits of the visible part, in logical coordinates. |
void |
tieModels(BoundedRangeModel x,
BoundedRangeModel y)
Synchronises the position and the range of the models x and y with the position of the zoom. |
void |
transform(AffineTransform change)
Changes the zoom by applying an affine transform. |
void |
transformPixels(AffineTransform change)
Changes the zoom by applying an affine transform. |
void |
untieModels(BoundedRangeModel x,
BoundedRangeModel y)
Cancels the synchronization between the specified x and y models and the zoom of this ZoomPane object. |
void |
updateUI()
Informs ZoomPane that the GUI has changed. |
| Methods inherited from class Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Field Detail |
|---|
public static final int SCALE_X
public static final int SCALE_Y
public static final int UNIFORM_SCALE
SCALE_X
and SCALE_Y. The inverse, however, (SCALE_X|SCALE_Y)
doesn't imply UNIFORM_SCALE.
public static final int TRANSLATE_X
public static final int TRANSLATE_Y
public static final int ROTATE
public static final int RESET
reset().
public static final int DEFAULT_ZOOM
Note: this flag will only have any effect if at least one of the
SCALE_X and SCALE_Y flags is not also specified.
protected final AffineTransform zoom
Graphics2D.transform(zoom).
| Constructor Detail |
|---|
public ZoomPane(int allowedActions)
throws IllegalArgumentException
ZoomPane.
allowedActions - Allowed zoom actions. It can be a bitwise combination of the following constants:
SCALE_X, SCALE_Y, UNIFORM_SCALE, TRANSLATE_X,
TRANSLATE_Y, ROTATE, RESET and DEFAULT_ZOOM.
IllegalArgumentException - If type is invalid.| Method Detail |
|---|
public void reset()
getPreferredArea() logical coordinates appears in the
panel.
Note:reset()is the only method ofZoomPanewhich doesn't have to pass through thetransform(AffineTransform)method to modify the zoom. This exception is necessary to avoid falling into an infinite loop.
protected void reset(Rectangle zoomableBounds,
boolean yAxisUpward)
zoom in order to cancel any zoom, rotation or
translation. The argument yAxisUpward indicates whether the y axis should
point upwards. The value false lets it point downwards. This method is offered
for convenience sake for derived classes which want to redefine reset().
zoomableBounds - Coordinates, in pixels, of the screen space in which to draw.
This argument will usually be
getZoomableBounds(null).yAxisUpward - true if the y axis should point upwards rather than
downwards.protected void setResetPolicy(boolean fill)
true means that the panel should initially be completely filled, even if
the content partially falls outside the panel's bounds. Value false means that the
full content should appear in the panel, even if some space is not used. Default value is
false.
fill - true if the panel should be initially completely filled.public abstract Rectangle2D getArea()
ZoomPane. For example, if this ZoomPane is to display a geographic map,
then this method should return the map's bounds in degrees of latitude and longitude (if the
underlying CRS is geographic), in metres
(if the underlying CRS is projected) or
some other geodetic units. This bounding box is completely independent of any current zoom
setting and will change only if the content changes.
ZoomPane. If this bounding box is unknown, then this method
can return null (but this is not recommended).public final boolean hasPreferredArea()
true if setPreferredArea(java.awt.geom.Rectangle2D) has been called with a non null argument.
true if a preferred area has been set.public final Rectangle2D getPreferredArea()
ZoomPane appears on the screen. This region will also be displayed each time
the method reset() is called. The default implementation goes as follows:
setPreferredArea(java.awt.geom.Rectangle2D), this region will be returned.getArea() will be returned.
null if these coordinates are unknown.public final void setPreferredArea(Rectangle2D area)
ZoomPane appears on the screen. This region will also be displayed the first
time that the reset() method is called.
area - The logical coordinates of the region to be initially displayed,public final Rectangle2D getVisibleArea()
public void setVisibleArea(Rectangle2D logicalBounds)
throws IllegalArgumentException
zoom contains
a rotation, this rotation will not be modified.
logicalBounds - Logical coordinates of the region to be displayed.
IllegalArgumentException - if source is empty.protected Rectangle getZoomableBounds(Rectangle bounds)
JComponent.getBounds(Rectangle), except that the zoomable area may be smaller than the whole
widget area. For example, a chart needs to keep some space for axes around the zoomable area.
Another difference is that pixel coordinates are relative to the widget, i.e. the (0,0)
coordinate lies on the ZoomPane upper left corner, no matter what its location on
screen.
ZoomPane invokes getZoomableBounds when it needs to set up an initial
zoom value. Subclasses should also set the clip area to this bounding box in their
paintComponent(Graphics2D) method before setting the graphics transform.
For example:
graphics.clip(getZoomableBounds(null)); graphics.transform(zoom);
bounds - An optional pre-allocated rectangle, or null to create a new one. This
argument is useful if the caller wants to avoid allocating a new object on the heap.
ZoomPane widget.protected Dimension getDefaultSize()
JComponent.getPreferredSize() if no preferred size has been explicitly set with
JComponent.setPreferredSize(java.awt.Dimension).
protected Dimension2D getPreferredPixelSize()
getArea().
public double getScaleFactor()
getArea() are
expressed in metres). Scale factors for X and Y axes can be computed separately using the
following equations:
X scale = ![]() |
Y scale = ![]() |
This method combines scale along both axes, which is correct if this ZoomPane has
been constructed with the UNIFORM_SCALE type.
zoom affine transform.public AffineTransform getTransform()
zoom transform.
public void setTransform(AffineTransform tr)
zoom transform to the given value. The default implementation computes an
affine transform which is the change needed for going from the current zoom
to the given transform, then calls transform(AffineTransform) with that change.
This is done that way for giving listeners a chance to track the changes.
tr - The new transform.public void transform(AffineTransform change)
change
transform must express a change in logical units, for example, a translation in metres.
This method is conceptually similar to the following code:
zoom.concatenate(change); fireZoomChanged(change); repaint(getZoomableBounds(null));
change - The zoom change, as an affine transform in logical coordinates. If
change is the identity transform, then this method does nothing and
listeners are not notified.public void transformPixels(AffineTransform change)
change transform
must express a change in pixel units, for example, a scrolling of 6 pixels toward right. This
method is conceptually similar to the following code:
zoom.preConcatenate(change); // Converts the change from pixel to logical units AffineTransform logical = zoom.createInverse(); logical.concatenate(change); logical.concatenate(zoom); fireZoomChanged(logical); repaint(getZoomableBounds(null));
change - The zoom change, as an affine transform in pixel coordinates. If
change is the identity transform, then this method does nothing
and listeners are not notified.public void addZoomChangeListener(ZoomChangeListener listener)
listener - The change listener to add.public void removeZoomChangeListener(ZoomChangeListener listener)
listener - The change listener to remove.public void addMouseListener(MouseListener listener)
addMouseListener in class Componentlistener - The mouse listener to add.protected void fireZoomChanged(AffineTransform change)
addZoomChangeListener(ZoomChangeListener) method will be notified
of the change as soon as possible.
If oldZoom and newZoom are the affine transforms of the old and new zoom
respectively, the change is computed in such a way that the following relation is respected
within rounding errors:
Note: This method may modify the givennewZoom = oldZoom.concatenate(change)
change transform to
combine several consecutive calls of fireZoomChanged in a single transformation.
change - Affine transform which represents the change in the zoom.
The value of this argument may be changed by this method call.protected void mouseSelectionPerformed(Shape area)
area. Derived classes can redefine this method
in order to carry out another action.
area - Area selected by the user, in logical coordinates.protected Shape getMouseSelectionShape(Point2D point)
Ellipse2D
vs Rectangle2D) and any of its parameters not related to its position (e.g. arc
size in a RoundRectangle2D).
The returned shape will generally be an instance of RectangularShape, but can also
be an instance of Line2D. Any other class risks throwing a
ClassCastException at execution.
The default implementation always returns a Rectangle2D object.
point - Logical coordinates of the mouse at the moment the button is pressed. This
information can be used by subclasses that wish to consider the mouse position
before choosing a geometric shape.
RectangularShape or Line2D, or null
to indicate that we do not want to select with the mouse.public boolean isMagnifierEnabled()
true if the magniying glass is allowed to be displayed.public void setMagnifierEnabled(boolean enabled)
false will hide the magnifying glass, delete the
choice "Display magnifying glass" from the contextual menu and lead to all calls to
setMagnifierVisible(true) being ignored.
enabled - true if the magniying glass is allowed to be displayed.public boolean isMagnifierVisible()
setMagnifierVisible(boolean) to make it appear.
true if the magniying glass is currently visible.public void setMagnifierVisible(boolean visible)
true, the magnifying glass will appear at the
centre of the window.
visible - true for making the magniying glass visible.public Paint getMagnifierGlass()
public void setMagnifierGlass(Paint color)
color - The new color of the magnifying glass interior.public Paint getMagnifierBorder()
public void setMagnifierBorder(Paint color)
color - The new color of the magnifying glass border.public void correctApparentPixelPosition(Point2D point)
point is outside the magnifying glass,
then this method do nothing.point in such a way that it contains the position that the same pixel
would have in the absence of magnifying glass.
correctApparentPixelPosition in interface DeformableViewerpoint - In input, a pixel's coordinate as it appears on the screen. In output, the
coordinate that the same pixel would have if the magnifying glass wasn't presents.public void buildNavigationMenu(JMenu menu)
menu - The menu in which to add navigation options.protected JPopupMenu getPopupMenu(MouseEvent event)
event - Mouse event. This object contains the mouse coordinates
in geographic coordinates (as well as pixel coordinates).
null to avoid displaying the menu.protected JPopupMenu getMagnifierMenu(MouseEvent event)
event - Mouse event containing amongst others, the mouse position.
null to avoid displaying the menu.public JComponent createScrollPane()
ZoomPane with the scrollbars.
ZoomPane together with scrollbars.
public void tieModels(BoundedRangeModel x,
BoundedRangeModel y)
x - Model of the horizontal scrollbar or null if there isn't one.y - Model of the vertical scrollbar or null if there isn't one.
public void untieModels(BoundedRangeModel x,
BoundedRangeModel y)
ZoomPane object. The ChangeListener and
ZoomChangeListener objects that were created are deleted.
x - Model of the horizontal scrollbar or null if there isn't one.y - Model of the vertical scrollbar or null if there isn't one.public void scrollRectToVisible(Rectangle rect)
ZoomPane. viewSize
is the size ZoomPane would be (in pixels) if its visible surface covered the whole
of the getArea() region with the current zoom (Note: viewSize can be obtained
by JComponent.getPreferredSize() if JComponent.setPreferredSize(java.awt.Dimension) hasn't been called with a non-null
value). Therefore, by definition, the region getArea() converted into pixel space would
give the rectangle bounds = Rectangle(0, 0, viewSize.width, viewSize.height).
This scrollRectToVisible method allows us to define the sub-region of bounds
which must appear in the ZoomPane window.
scrollRectToVisible in class JComponentrect - The region to be made visible.public boolean isPaintingWhileAdjusting()
ZoomPane object should be repainted when the user
moves the scrollbar slider. The scrollbars (or other models) involved are those which have
been synchronised with this ZoomPane object through the tieModels(javax.swing.BoundedRangeModel, javax.swing.BoundedRangeModel) method.
The default value is false, which means that ZoomPane will wait until the
user releases the slider before repainting.
true if the zoom pane is painted while the user is scrolling.public void setPaintingWhileAdjusting(boolean flag)
ZoomPane object should repaint the map when the user
moves the scrollbar slider. A fast computer is recommended if this flag is to be set to
true.
flag - true if the zoom pane should be painted while the user is scrolling.
public void repaint(long tm,
int x,
int y,
int width,
int height)
repaint in class JComponentprotected void paintMagnifier(Graphics2D graphics)
paintComponent(Graphics2D) if a magnifying glass is visible.
graphics - The graphics where to paint the magnifying glass.protected abstract void paintComponent(Graphics2D graphics)
ZoomPane content. For most implementations, the first line in this method
will be graphics.transform(zoom).
graphics - The graphics where to paint this component.protected void printComponent(Graphics2D graphics)
paintComponent(Graphics2D).
graphics - The graphics where to print this component.protected final void paintComponent(Graphics graphics)
paintComponent(Graphics2D) instead.
paintComponent in class JComponentgraphics - The graphics where to paint this component.protected final void printComponent(Graphics graphics)
printComponent(Graphics2D) instead.
printComponent in class JComponentgraphics - The graphics where to print this component.public final Insets getInsets()
JComponent.getInsets(Insets).
getInsets in class JComponentpublic void updateUI()
ZoomPane that the GUI has changed.
The user doesn't have to call this method directly.
updateUI in class JComponent
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||