org.osmdroid.views.overlay

Class ItemizedOverlay<Item extends OverlayItem>

java.lang.Object

org.osmdroid.views.overlay.Overlay

org.osmdroid.views.overlay.ItemizedOverlay<Item>

Type Parameters:

Item -

All Implemented Interfaces:

Overlay.Snappable, OverlayConstants

Direct Known Subclasses:

ItemizedIconOverlay

public abstract class ItemizedOverlay<Item extends OverlayItem>
extends Overlay
implements Overlay.Snappable

Draws a list of OverlayItem as markers to a map. The item with the lowest index is drawn as last and therefore the 'topmost' marker. It also gets checked for onTap first. This class is generic, because you then you get your custom item-class passed back in onTap().

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	ItemizedOverlay.OnFocusChangeListener

Nested classes/interfaces inherited from class org.osmdroid.views.overlay.Overlay

Overlay.Snappable

Field Summary

Fields

Modifier and Type	Field and Description
protected Drawable	mDefaultMarker
protected boolean	mDrawFocusedItem
protected int	mDrawnItemsLimit
protected float	scaleX
protected float	scaleY

Fields inherited from class org.osmdroid.views.overlay.Overlay

mBounds, SHADOW_X_SKEW, SHADOW_Y_SCALE

Fields inherited from interface org.osmdroid.views.util.constants.OverlayConstants

DEFAULT_ZOOMLEVEL_MINIMAP_DIFFERENCE, NOT_SET

Constructor Summary

Constructors

Constructor and Description
ItemizedOverlay(Context ctx, Drawable pDefaultMarker) Deprecated.
ItemizedOverlay(Drawable pDefaultMarker)

Method Summary

Modifier and Type	Method and Description
protected Drawable	boundToHotspot(Drawable marker, OverlayItem.HotspotPlace hotspot) Adjusts a drawable's bounds so that (0,0) is a pixel in the location described by the hotspot parameter.
protected abstract Item	createItem(int i) Method by which subclasses create the actual Items.
void	draw(Canvas canvas, MapView mapView, boolean shadow) Draw a marker on each of our items.
protected Drawable	getDefaultMarker(int state)
List<Item>	getDisplayedItems() Get the list of all the items that are currently drawn on the canvas.
int	getDrawnItemsLimit()
Item	getFocus()
Item	getItem(int position) Returns the Item at the given index.
protected boolean	hitTest(Item item, Drawable marker, int hitX, int hitY) See if a given hit point is within the bounds of an item's marker.
void	onDetach(MapView mapView) Override to perform clean up of resources before shutdown.
protected boolean	onDrawItem(Canvas canvas, Item item, Point curScreenCoords, MapView mapView) Draws an item located at the provided screen coordinates to the canvas.
boolean	onSingleTapConfirmed(MotionEvent e, MapView mapView) By default does nothing (return false).
protected boolean	onTap(int index) Override this method to handle a "tap" on an item.
protected void	populate() Utility method to perform all processing on a new ItemizedOverlay.
void	setDrawFocusedItem(boolean drawFocusedItem) Set whether or not to draw the focused item.
void	setDrawnItemsLimit(int aLimit)
void	setFocus(Item item) If the given Item is found in the overlay, force it to be the current focus-bearer.
void	setOnFocusChangeListener(ItemizedOverlay.OnFocusChangeListener l)
abstract int	size() The number of items in this overlay.

Methods inherited from class org.osmdroid.views.overlay.Overlay

drawAt, getBounds, getSafeMenuId, getSafeMenuIdSequence, isEnabled, onDoubleTap, onDoubleTapEvent, onDown, onFling, onKeyDown, onKeyUp, onLongPress, onPause, onResume, onScroll, onShowPress, onSingleTapUp, onTouchEvent, onTrackballEvent, setEnabled

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.osmdroid.views.overlay.Overlay.Snappable

onSnapToItem

Field Detail

mDrawnItemsLimit

protected int mDrawnItemsLimit

mDefaultMarker

protected final Drawable mDefaultMarker

mDrawFocusedItem

protected boolean mDrawFocusedItem

scaleX

protected float scaleX

scaleY

protected float scaleY

Constructor Detail

ItemizedOverlay

@Deprecated
public ItemizedOverlay(Context ctx,
                                    Drawable pDefaultMarker)

Deprecated.

Use ItemizedOverlay(Drawable) instead

ItemizedOverlay

public ItemizedOverlay(Drawable pDefaultMarker)

Method Detail

createItem

protected abstract Item createItem(int i)

Method by which subclasses create the actual Items. This will only be called from populate() we'll cache them for later use.

size

public abstract int size()

The number of items in this overlay.

getDrawnItemsLimit

public int getDrawnItemsLimit()

setDrawnItemsLimit

public void setDrawnItemsLimit(int aLimit)

onDetach

public void onDetach(MapView mapView)

Description copied from class: Overlay

Override to perform clean up of resources before shutdown. By default does nothing.

Overrides:

onDetach in class Overlay

draw

public void draw(Canvas canvas,
                 MapView mapView,
                 boolean shadow)

Draw a marker on each of our items. populate() must have been called first.

The marker will be drawn twice for each Item in the Overlay--once in the shadow phase, skewed and darkened, then again in the non-shadow phase. The bottom-center of the marker will be aligned with the geographical coordinates of the Item.

The order of drawing may be changed by overriding the getIndexToDraw(int) method. An item may provide an alternate marker via its OverlayItem.getMarker(int) method. If that method returns null, the default marker is used.

The focused item is always drawn last, which puts it visually on top of the other items.

Specified by:

draw in class Overlay

Parameters:

canvas - the Canvas upon which to draw. Note that this may already have a transformation applied, so be sure to leave it the way you found it

mapView - the MapView that requested the draw. Use MapView.getProjection() to convert between on-screen pixels and latitude/longitude pairs

shadow - if true, draw the shadow layer. If false, draw the overlay contents.

populate

protected final void populate()

Utility method to perform all processing on a new ItemizedOverlay. Subclasses provide Items through the createItem(int) method. The subclass should call this as soon as it has data, before anything else gets called.

getItem

public final Item getItem(int position)

Returns the Item at the given index.

Parameters:

position - the position of the item to return

Returns:

the Item of the given index, or null if not found at position

onDrawItem

protected boolean onDrawItem(Canvas canvas,
                             Item item,
                             Point curScreenCoords,
                             MapView mapView)

Draws an item located at the provided screen coordinates to the canvas.

Parameters:

canvas - what the item is drawn upon

item - the item to be drawn

curScreenCoords -

mapView -

Returns:

true if the item was actually drawn

getDisplayedItems

public List<Item> getDisplayedItems()

Get the list of all the items that are currently drawn on the canvas. The obvious use case is a "share" or "export" button on a map, restricted to what is displayed. The order of the items is kept

Returns:

the items that have actually been drawn

Since:

5.6.7

getDefaultMarker

protected Drawable getDefaultMarker(int state)

hitTest

protected boolean hitTest(Item item,
                          Drawable marker,
                          int hitX,
                          int hitY)

See if a given hit point is within the bounds of an item's marker. Override to modify the way an item is hit tested. The hit point is relative to the marker's bounds. The default implementation just checks to see if the hit point is within the touchable bounds of the marker.

Parameters:

item - the item to hit test

marker - the item's marker

hitX - x coordinate of point to check

hitY - y coordinate of point to check

Returns:

true if the hit point is within the marker

onSingleTapConfirmed

public boolean onSingleTapConfirmed(MotionEvent e,
                                    MapView mapView)

Description copied from class: Overlay

By default does nothing (return false). If you handled the Event, return true , otherwise return false. If you returned true none of the following Overlays or the underlying MapView has the chance to handle this event.

Overrides:

onSingleTapConfirmed in class Overlay

onTap

protected boolean onTap(int index)

Override this method to handle a "tap" on an item. This could be from a touchscreen tap on an onscreen Item, or from a trackball click on a centered, selected Item. By default, does nothing and returns false.

Returns:

true if you handled the tap, false if you want the event that generated it to pass to other overlays.

setDrawFocusedItem

public void setDrawFocusedItem(boolean drawFocusedItem)

Set whether or not to draw the focused item. The default is to draw it, but some clients may prefer to draw the focused item themselves.

setFocus

public void setFocus(Item item)

If the given Item is found in the overlay, force it to be the current focus-bearer. Any registered ItemizedOverlay.OnFocusChangeListener will be notified. This does not move the map, so if the Item isn't already centered, the user may get confused. If the Item is not found, this is a no-op. You can also pass null to remove focus.

getFocus

public Item getFocus()

Returns:

the currently-focused item, or null if no item is currently focused.

boundToHotspot

protected Drawable boundToHotspot(Drawable marker,
                                  OverlayItem.HotspotPlace hotspot)

Adjusts a drawable's bounds so that (0,0) is a pixel in the location described by the hotspot parameter. Useful for "pin"-like graphics. For convenience, returns the same drawable that was passed in.

Parameters:

marker - the drawable to adjust

hotspot - the hotspot for the drawable

Returns:

the same drawable that was passed in.

setOnFocusChangeListener

public void setOnFocusChangeListener(ItemizedOverlay.OnFocusChangeListener l)