package com.mapbox.mapboxsdk.views.safecanvas;
import android.graphics.Matrix;
import android.graphics.Path;
import android.graphics.Rect;
import android.graphics.RectF;
/**
* The SafeTranslatedPath class is designed to work in conjunction with {@link
* SafeTranslatedCanvas}
* to work around various Android issues with large canvases. For the two classes to work together,
* call {@link #onDrawCycleStart} at the start of the
* {@link com.mapbox.mapboxsdk.overlay.Overlay.Overlay#drawSafe}
* method of your
* {@link com.mapbox.mapboxsdk.overlay.Overlay.Overlay}. This will set the adjustment needed to
* draw
* your Path safely on the canvas
* without any drawing distortion at high zoom levels. Methods of the {@link Path} class that use
* unsafe float types have been deprecated in favor of replacement methods that use doubles.
*
* @author Marc Kurtz
* @see {@link ISafeCanvas}
*/
public class SafeTranslatedPath extends Path {
private static final RectF sRectF = new RectF();
public int xOffset = 0;
public int yOffset = 0;
/**
* This method <b>must</b> be called at the start of the {@link Overlay#drawSafe} draw cycle
* method. This will adjust the Path to the current state of the {@link ISafeCanvas} passed to
* it.
*/
public void onDrawCycleStart(ISafeCanvas canvas) {
// Adjust the current position of the path
int deltaX = canvas.getXOffset() - xOffset;
int deltaY = canvas.getYOffset() - yOffset;
super.offset(deltaX, deltaY);
// Record the new offset
xOffset = canvas.getXOffset();
yOffset = canvas.getYOffset();
}
@Override
public void reset() {
super.reset();
}
@Override
public void rewind() {
super.rewind();
}
@Override
public void set(Path src) {
super.set(src);
}
@Override
public FillType getFillType() {
return super.getFillType();
}
@Override
public void setFillType(FillType ft) {
super.setFillType(ft);
}
@Override
public boolean isInverseFillType() {
return super.isInverseFillType();
}
@Override
public void toggleInverseFillType() {
super.toggleInverseFillType();
}
@Override
public boolean isEmpty() {
return super.isEmpty();
}
/**
* @see {@link #isRect(RectF)}
*/
public boolean isRect(Rect rect) {
// Should we offset here?
rect.offset(xOffset, yOffset);
boolean result = super.isRect(this.toOffsetRectF(rect, sRectF));
rect.offset(-xOffset, -yOffset);
return result;
}
/**
* @see {@link #computeBounds(RectF, boolean)}
*/
public void computeBounds(Rect bounds, boolean exact) {
super.computeBounds(sRectF, exact);
bounds.set((int) sRectF.left, (int) sRectF.top, (int) sRectF.right, (int) sRectF.bottom);
bounds.offset(-xOffset, -yOffset);
}
@Override
public void incReserve(int extraPtCount) {
super.incReserve(extraPtCount);
}
/**
* @see {@link #moveTo(float, float)}
*/
public void moveTo(double x, double y) {
super.moveTo((float) (x + xOffset), (float) (y + yOffset));
}
@Override
public void rMoveTo(float dx, float dy) {
super.rMoveTo(dx, dy);
}
/**
* @see {@link #lineTo(float, float)}
*/
public void lineTo(double x, double y) {
super.lineTo((float) (x + xOffset), (float) (y + yOffset));
}
@Override
public void rLineTo(float dx, float dy) {
super.rLineTo(dx, dy);
}
/**
* @see {@link #quadTo(float, float, float, float)}
*/
public void quadTo(double x1, double y1, double x2, double y2) {
super.quadTo((float) (x1 + xOffset), (float) (y1 + yOffset), (float) (x2 + xOffset),
(float) (y2 + yOffset));
}
@Override
public void rQuadTo(float dx1, float dy1, float dx2, float dy2) {
super.rQuadTo(dx1, dy1, dx2, dy2);
}
/**
* @see {@link #cubicTo(float, float, float, float, float, float)}
*/
public void cubicTo(double x1, double y1, double x2, double y2, double x3, double y3) {
super.cubicTo((float) (x1 + xOffset), (float) (y1 + yOffset), (float) (x2 + xOffset),
(float) (y2 + yOffset), (float) (x3 + xOffset), (float) (y3 + yOffset));
}
@Override
public void rCubicTo(float x1, float y1, float x2, float y2, float x3, float y3) {
super.rCubicTo(x1, y1, x2, y2, x3, y3);
}
/**
* @see {@link #arcTo(RectF, float, float, boolean)}
*/
public void arcTo(Rect oval, float startAngle, float sweepAngle, boolean forceMoveTo) {
oval.offset(xOffset, yOffset);
super.arcTo(this.toOffsetRectF(oval, sRectF), startAngle, sweepAngle, forceMoveTo);
oval.offset(-xOffset, -yOffset);
}
/**
* @see {@link #arcTo(RectF, float, float)}
*/
public void arcTo(Rect oval, float startAngle, float sweepAngle) {
oval.offset(xOffset, yOffset);
super.arcTo(this.toOffsetRectF(oval, sRectF), startAngle, sweepAngle);
oval.offset(-xOffset, -yOffset);
}
@Override
public void close() {
super.close();
}
/**
* @see {@link #addRect(RectF, Direction)}
*/
public void addRect(Rect rect, Direction dir) {
rect.offset(xOffset, yOffset);
super.addRect(this.toOffsetRectF(rect, sRectF), dir);
rect.offset(-xOffset, -yOffset);
}
/**
* @see {@link #addRect(float, float, float, float, Direction)}
*/
public void addRect(double left, double top, double right, double bottom, Direction dir) {
super.addRect((float) (left + xOffset), (float) (top + yOffset), (float) (right + xOffset),
(float) (bottom + yOffset), dir);
}
/**
* @see {@link #addOval(RectF, Direction)
*/
public void addOval(Rect oval, Direction dir) {
oval.offset(xOffset, yOffset);
super.addOval(this.toOffsetRectF(oval, sRectF), dir);
oval.offset(-xOffset, -yOffset);
}
/**
* @see {@link #addCircle(float, float, float, Direction)}
*/
public void addCircle(double x, double y, float radius, Direction dir) {
super.addCircle((float) (x + xOffset), (float) (y + yOffset), radius, dir);
}
/**
* @see {@link #addArc(RectF, float, float)}
*/
public void addArc(Rect oval, float startAngle, float sweepAngle) {
oval.offset(xOffset, yOffset);
super.addArc(this.toOffsetRectF(oval, sRectF), startAngle, sweepAngle);
oval.offset(-xOffset, -yOffset);
}
/**
* @see {@link #addRoundRect(RectF, float, float)}
*/
public void addRoundRect(Rect rect, float rx, float ry, Direction dir) {
rect.offset(xOffset, yOffset);
super.addRoundRect(this.toOffsetRectF(rect, sRectF), rx, ry, dir);
rect.offset(-xOffset, -yOffset);
}
/**
* @see {@link #addRoundRect(RectF, float, Direction)}
*/
public void addRoundRect(Rect rect, float[] radii, Direction dir) {
rect.offset(xOffset, yOffset);
super.addRoundRect(this.toOffsetRectF(rect, sRectF), radii, dir);
rect.offset(-xOffset, -yOffset);
}
@Override
public void addPath(Path src, float dx, float dy) {
boolean safePath = src instanceof SafeTranslatedPath;
if (!safePath) {
src.offset(xOffset, yOffset);
}
super.addPath(src, dx, dy);
if (!safePath) {
src.offset(-xOffset, -yOffset);
}
}
@Override
public void addPath(Path src) {
boolean safePath = src instanceof SafeTranslatedPath;
if (!safePath) {
src.offset(xOffset, yOffset);
}
super.addPath(src);
if (!safePath) {
src.offset(-xOffset, -yOffset);
}
}
@Override
public void addPath(Path src, Matrix matrix) {
boolean safePath = src instanceof SafeTranslatedPath;
if (!safePath) {
matrix.preTranslate(xOffset, yOffset);
}
super.addPath(src, matrix);
if (!safePath) {
matrix.preTranslate(-xOffset, -yOffset);
}
}
@Override
public void offset(float dx, float dy, Path dst) {
super.offset(dx, dy, dst);
}
@Override
public void offset(float dx, float dy) {
super.offset(dx, dy);
}
/**
* @see {@link #setLastPoint(float, float)}
*/
public void setLastPoint(double dx, double dy) {
super.setLastPoint((float) (dx + xOffset), (float) (dy + yOffset));
}
@Override
public void transform(Matrix matrix, Path dst) {
// Should we offset here?
super.transform(matrix, dst);
}
@Override
public void transform(Matrix matrix) {
// Should we offset here?
super.transform(matrix);
}
@Override
protected void finalize() throws Throwable {
super.finalize();
}
/**
* Helper function to convert a Rect to RectF and adjust the values of the Rect by the offsets.
*/
protected final RectF toOffsetRectF(Rect rect, RectF reuse) {
if (reuse == null) {
reuse = new RectF();
}
reuse.set(rect.left + xOffset, rect.top + yOffset, rect.right + xOffset,
rect.bottom + yOffset);
return reuse;
}
}
