source: other-projects/tipple-android/tipple-ar/tipple-standalone-hpg/src/org/mapsforge/android/maps/CirclesOverlay.java@ 26528

package org.mapsforge.android.maps;

import java.util.ArrayList;

import org.mapsforge.android.maps.overlay.Overlay;
import org.mapsforge.core.GeoPoint;

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;
    }
    
    /* public synchronized void setCircleData(GeoPoint center, float radius) {
        this.center.add(center);
        this.radius.add(radius);
        this.cachedZoomLevel = Byte.MIN_VALUE;
    } */

    @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;
    }
}