LayerManagerpublic class LayerManager extends Object | The LayerManager manages a series of Layers. The LayerManager simplifies
the process of rendering the Layers that have been added to it by
automatically rendering the correct regions of each Layer in the
appropriate order.
The LayerManager maintains an ordered list to which Layers can be appended,
inserted and removed. A Layer's index correlates to its z-order; the layer
at index 0 is closest to the user while a the Layer with the highest index
is furthest away from the user. The indices are always contiguous; that
is, if a Layer is removed, the indices of subsequent Layers will be
adjusted to maintain continuity.
The LayerManager class provides several features that control how the
game's Layers are rendered on the screen.
The view window controls the size of the visible region and its
position relative to the LayerManager's coordinate system. Changing the
position of the view window enables effects such as scrolling or panning
the user's view. For example, to scroll to the right, simply move the view
window's location to the right. The size of the view window controls how
large the user's view will be, and is usually fixed at a size that is
appropriate for the device's screen.
In this example, the view window is set to 85 x 85 pixels and is located at
(52, 11) in the LayerManager's coordinate system. The Layers appear at
their respective positions relative to the LayerManager's origin.
The {@link #paint(Graphics, int, int)} method includes an (x,y) location
that controls where the view window is rendered relative to the screen.
Changing these parameters does not change the contents of the view window,
it simply changes the location where the view window is drawn. Note that
this location is relative to the origin of the Graphics object, and thus
it is subject to the translation attributes of the Graphics object.
For example, if a game uses the top of the screen to display the current
score, the view window may be rendered at (17, 17) to provide enough space
for the score.
|
| Fields Summary |
|---|
| private int | nlayersThe number of layers in this LayerManager.
This value can be null. | | private Layer[] | componentThe Layers in this LayerManager. | | private int | viewXthe view window co-ordinates. | | private int | viewY | | private int | viewWidth | | private int | viewHeight |
| Constructors Summary |
|---|
public LayerManager()Creates a new LayerManager.
setViewWindow(0, 0, Integer.MAX_VALUE, Integer.MAX_VALUE);
|
| Methods Summary |
|---|
| private void | addImpl(Layer layer, int index)add or insert a layer
// Add component to list;
// allocate new array if necessary.
if (nlayers == component.length) {
Layer newcomponents[] = new Layer[nlayers + 4];
System.arraycopy(component, 0, newcomponents, 0, nlayers);
System.arraycopy(component, index, newcomponents,
index + 1, nlayers - index);
component = newcomponents;
} else {
System.arraycopy(component, index, component,
index + 1, nlayers - index);
}
component[index] = layer;
nlayers++;
| | public void | append(Layer l)Appends a Layer to this LayerManager. The Layer is appended to the
list of existing Layers such that it has the highest index (i.e. it
is furthest away from the user). The Layer is first removed
from this LayerManager if it has already been added.
// remove the Layer if it is already present
// will throw NullPointerException if the Layer is null
removeImpl(l);
addImpl(l, nlayers);
| | public Layer | getLayerAt(int index)Gets the Layer with the specified index.
if ((index < 0) || (index >= nlayers)) {
throw new IndexOutOfBoundsException();
}
return component[index];
| | public int | getSize()Gets the number of Layers in this LayerManager.
return nlayers;
| | public void | insert(Layer l, int index)Inserts a new Layer in this LayerManager at the specified index.
The Layer is first removed from this LayerManager if it has already
been added.
/* Check for correct arguments: index in bounds */
if ((index < 0) || (index > nlayers)) {
throw new IndexOutOfBoundsException();
}
// if the Layer is already present
// remove it
// will throw NullPointerException if the Layer is null
removeImpl(l);
// insert it at the specified index
addImpl(l, index);
| | public void | paint(javax.microedition.lcdui.Graphics g, int x, int y)Renders the LayerManager's current view window at the specified
location.
The LayerManager renders each of its layers in order of descending
index, thereby implementing the correct z-order. Layers that are
completely outside of the view window are not rendered.
The coordinates passed to this method determine where the
LayerManager's view window will be rendered relative to the origin
of the Graphics object. For example, a game may use the top of the
screen to display the current score, so to render the game's layers
below that area, the view window might be rendered at (0, 20). The
location is relative to the Graphics object's origin, so translating
the Graphics object will change where the view window is rendered on
the screen.
The clip region of the Graphics object is intersected with a region
having the same dimensions as the view window and located at (x,y).
The LayerManager then translates the graphics object such that the
point (x,y) corresponds to the location of the viewWindow in the
coordinate system of the LayerManager. The Layers are then rendered
in the appropriate order. The translation and clip region of the
Graphics object are restored to their prior values before this method
returns.
Rendering is subject to the clip region and translation of the Graphics
object. Thus, only part of the specified view window may be rendered
if the clip region is not large enough.
For performance reasons, this method may ignore Layers that are
invisible or that would be rendered entirely outside of the Graphics
object's clip region. The attributes of the Graphics object are not
restored to a known state between calls to the Layers' paint methods.
The clip region may extend beyond the bounds of a Layer; it is the
responsibility of the Layer to ensure that rendering operations are
performed within its bounds.
// if g == null g.getClipX will throw NullPointerException;
// save the original clip
int clipX = g.getClipX();
int clipY = g.getClipY();
int clipW = g.getClipWidth();
int clipH = g.getClipHeight();
// translate the LayerManager co-ordinates to Screen co-ordinates
g.translate(x - viewX, y - viewY);
// set the clip to view window
g.clipRect(viewX, viewY, viewWidth, viewHeight);
// draw last to first
for (int i = nlayers; --i >= 0; ) {
Layer comp = component[i];
if (comp.visible) {
// REMINDER: do this if outside Graphics clip region don't paint
// (comp.contains(x - comp.x, y - comp.y)) &&
// paint will happen only in clipped region of view window
comp.paint(g);
}
}
// restore Screen co-ordinates origin and clip
g.translate(-x + viewX, -y + viewY);
g.setClip(clipX, clipY, clipW, clipH);
| | private void | remove(int index)remove a layer at the specified index.
System.arraycopy(component, index + 1,
component, index,
nlayers - index - 1);
component[--nlayers] = null;
| | public void | remove(Layer l)Removes the specified Layer from this LayerManager. This method does
nothing if the specified Layer is not added to the this LayerManager.
removeImpl(l);
| | private void | removeImpl(Layer l)Removes the specified Layer from this LayerManager.
if (l == null) {
throw new NullPointerException();
}
/**
* Search backwards, expect that more recent additions
* are more likely to be removed.
*/
for (int i = nlayers; --i >= 0; ) {
if (component[i] == l) {
remove(i);
}
}
| | public void | setViewWindow(int x, int y, int width, int height)Sets the view window on the LayerManager.
The view window specifies the region that the LayerManager draws when
its {@link #paint} method is called. It allows the developer to
control the size of the visible region, as well as the location of the
view window relative to the LayerManager's coordinate system.
The view window stays in effect until it is modified by another call
to this method. By default, the view window is located at (0,0) in
the LayerManager's coordinate system and its width and height are both
set to Integer.MAX_VALUE.
if (width < 0 || height < 0) {
throw new IllegalArgumentException();
}
viewX = x;
viewY = y;
viewWidth = width;
viewHeight = height;
|
|
