source: other-projects/tipple-android/src/org/mapsforge/android/maps/ItemizedMarkerOverlay.java@ 26523

package org.mapsforge.android.maps;

import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.Point;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;

/**
 * ItemizedMarkerOverlay is an abstract base class to display a list of
 * OverlayMarkerItems.
 * 
 * @param <Item>
 *            the type of items handled by this Overlay.
 */
public abstract class ItemizedMarkerOverlay<Item extends OverlayMarkerItem>
        extends Overlay {
    private static final int ARRAY_LIST_INITIAL_CAPACITY = 8;
    private static final String THREAD_NAME = "ItemizedMarkerOverlay";

    /**
     * Sets the bounds of the given drawable so that (0,0) is the center of the
     * bottom row.
     * 
     * @param balloon
     *            the drawable whose bounds should be set.
     * @return the given drawable.
     */
    protected static Drawable boundCenter(Drawable balloon) {
        balloon.setBounds(balloon.getIntrinsicWidth() / -2,
                balloon.getIntrinsicHeight() / -2,
                balloon.getIntrinsicWidth() / 2,
                balloon.getIntrinsicHeight() / 2);
        return balloon;
    }

    /**
     * Sets the bounds of the given drawable so that (0,0) is the center of the
     * bounding box.
     * 
     * @param balloon
     *            the drawable whose bounds should be set.
     * @return the given drawable.
     */
    protected static Drawable boundCenterBottom(Drawable balloon) {
        balloon.setBounds(balloon.getIntrinsicWidth() / -2,
                -balloon.getIntrinsicHeight(), balloon.getIntrinsicWidth() / 2,
                0);
        return balloon;
    }

    private int bottom;
    private Drawable defaultMarker;
    private Drawable itemMarker;
    private final Point itemPosition;
    private int left;
    private Rect markerBounds;
    private int numberOfItems;
    private Item overlayItem;
    private int right;
    private int top;

    /**
     * Constructs a new ItemizedOverlay.
     * 
     * @param defaultMarker
     *            the default marker for each item.
     */
    public ItemizedMarkerOverlay(Drawable defaultMarker) {
        this.defaultMarker = defaultMarker;
        this.itemPosition = new Point();
    }

    /**
     * Returns the numbers of items in this Overlay.
     * 
     * @return the numbers of items in this Overlay.
     */
    public abstract int size();

    /**
     * Creates an item in the Overlay.
     * 
     * @param i
     *            the index of the item.
     * @return the item.
     */
    protected abstract Item createItem(int i);

    @Override
    protected synchronized void drawOverlayBitmap(Canvas canvas,
            Point drawPosition, Projection projection, byte drawZoomLevel) {
        this.numberOfItems = size();
        if (this.numberOfItems < 1) {
            // no items to draw
            return;
        }

        // draw the Overlay items
        for (int i = 0; i < this.numberOfItems; ++i) {
            // get the current item
            this.overlayItem = createItem(i);

            // check if the item has a position
            if (this.overlayItem.getPoint() == null) {
                continue;
            }

            // make sure that the cached item position is valid
            if (drawZoomLevel != this.overlayItem.cachedZoomLevel) {
                this.overlayItem.cachedMapPosition = projection.toPoint(
                        this.overlayItem.getPoint(),
                        this.overlayItem.cachedMapPosition, drawZoomLevel);
                this.overlayItem.cachedZoomLevel = drawZoomLevel;
            }

            // calculate the relative item position on the display
            this.itemPosition.x = this.overlayItem.cachedMapPosition.x
                    - drawPosition.x;
            this.itemPosition.y = this.overlayItem.cachedMapPosition.y
                    - drawPosition.y;

            // get the correct marker for the item
            if (this.overlayItem.getMarker() == null) {
                this.itemMarker = this.defaultMarker;
            } else {
                this.itemMarker = this.overlayItem.getMarker();
            }

            // get the position of the marker
            this.markerBounds = this.itemMarker.copyBounds();

            // calculate the bounding box of the marker
            this.left = this.itemPosition.x + this.markerBounds.left;
            this.right = this.itemPosition.x + this.markerBounds.right;
            this.top = this.itemPosition.y + this.markerBounds.top;
            this.bottom = this.itemPosition.y + this.markerBounds.bottom;

            // check if the bounding box of the marker intersects with the
            // canvas
            if (this.right >= 0 && this.left <= canvas.getWidth()
                    && this.bottom >= 0 && this.top <= canvas.getHeight()) {
                // set the position of the marker
                this.itemMarker.setBounds(this.left, this.top, this.right,
                        this.bottom);

                // draw the item marker on the canvas
                this.itemMarker.draw(canvas);

                // restore the position of the marker
                this.itemMarker.setBounds(this.markerBounds);

                // Add text label next to marker
                Paint paint_text = new Paint(Paint.ANTI_ALIAS_FLAG);

                paint_text.setColor(Color.BLACK);
                paint_text.setStyle(Style.FILL);
                paint_text.setTextSize(20);

                canvas.drawText(overlayItem.getTitle(), itemPosition.x - 10,
                        itemPosition.y - 28, paint_text);
            }
        }
    }

    @Override
    protected String getThreadName() {
        return THREAD_NAME;
    }

    /**
     * Handles a tap event.
     * <p>
     * The default implementation of this method does nothing and returns false.
     * 
     * @param index
     *            the position of the item.
     * 
     * @return true if the event was handled, false otherwise. try to make this
     *         Ontap work --option 1
     */

    /**
     * This method should be called after items have been added to the Overlay.
     */
    protected final void populate() {
        super.requestRedraw();
    }

}