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

package org.mapsforge.android.maps;

import java.util.ArrayList;

import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;

/**
 * CirclesOverlay is a special Overlay to display a series of circles on top of
 * the map. The radius of a circle is specified in meters and will be
 * automatically converted to pixels at each redraw.
 * <p>
 * All rendering parameters like color, stroke width, pattern and transparency
 * can be configured via the two {@link android.graphics.Paint Paint} objects in
 * the {@link #CircleOverlay(Paint,Paint)} constructor.
 */

public class CirclesOverlay extends Overlay {
    private static final String THREAD_NAME = "CirclesOverlay";

    private byte cachedZoomLevel;

    private Paint fillPaint;
    private Paint outlinePaint;

    private final Path path;
    private ArrayList<GeoPoint> center;
    private ArrayList<Float> radius;
    private ArrayList<Point> cachedCenterPosition;

    /**
     * Constructs a new CircleOverlay.
     * 
     * @param fillPaint
     *            the paint object which will be used to fill the overlay.
     * @param outlinePaint
     *            the paint object which will be used to draw the outline of the
     *            overlay.
     */
    public CirclesOverlay(Paint fillPaint, Paint outlinePaint) {
        this.path = new Path();

        this.center = new ArrayList<GeoPoint>();
        this.radius = new ArrayList<Float>();
        this.cachedCenterPosition = new ArrayList<Point>();

        setPaint(fillPaint, outlinePaint);
    }

    public synchronized void reset() {
        this.center = new ArrayList<GeoPoint>();
        this.radius = new ArrayList<Float>();
        this.cachedCenterPosition = new ArrayList<Point>();
        path.reset();
        super.requestRedraw();
    }

    /**
     * Sets the parameters of the circle.
     * 
     * @param center
     *            the geographical coordinates of the centre point.
     * @param radius
     *            the radius of the circle in meters.
     */
    public synchronized void addCircleData(GeoPoint center, float radius) {
        this.center.add(center);
        this.radius.add(radius);
        this.cachedCenterPosition.add(new Point());

        this.cachedZoomLevel = Byte.MIN_VALUE;
        super.requestRedraw();
    }

    /**
     * Sets the paint objects which will be used to draw the overlay.
     * 
     * @param fillPaint
     *            the paint object which will be used to fill the overlay.
     * @param outlinePaint
     *            the paint object which will be used to draw the outline of the
     *            overlay.
     */
    public synchronized void setPaint(Paint fillPaint, Paint outlinePaint) {
        this.fillPaint = fillPaint;
        this.outlinePaint = outlinePaint;
    }

    @Override
    protected synchronized void drawOverlayBitmap(Canvas canvas,
            Point drawPosition, Projection projection, byte drawZoomLevel) {
        if (this.center.size() == 0 || this.radius.size() == 0) {
            // no valid parameters to draw the circle
            return;
        } else if (this.fillPaint == null && this.outlinePaint == null) {
            // no paint to draw
            return;
        }

        // make sure that the cached centre position is valid
        if (drawZoomLevel != this.cachedZoomLevel) {
            for (int i = 0; i < center.size(); i++) {
                Point cachedPoint = projection.toPoint(this.center.get(i),
                        this.cachedCenterPosition.get(i), drawZoomLevel);
                this.cachedCenterPosition.set(i, cachedPoint);
            }

            this.cachedZoomLevel = drawZoomLevel;
        }

        // assemble the path
        this.path.reset();
        for (int i = 0; i < cachedCenterPosition.size(); i++) {
            float radius_meters = projection.metersToPixels(this.radius.get(i),
                    drawZoomLevel);

            this.path.addCircle(this.cachedCenterPosition.get(i).x
                    - drawPosition.x, this.cachedCenterPosition.get(i).y
                    - drawPosition.y, radius_meters, Path.Direction.CCW);
        }

        // draw the path on the canvas
        if (this.fillPaint != null) {
            canvas.drawPath(this.path, this.fillPaint);
        }
        if (this.outlinePaint != null) {
            canvas.drawPath(this.path, this.outlinePaint);
        }
    }

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