method public void cubicTo(float, float, float, float, float, float);
method public android.graphics.Path.FillType getFillType();
method public void incReserve(int);
+ method public boolean isConvex();
method public boolean isEmpty();
method public boolean isInverseFillType();
method public boolean isRect(android.graphics.RectF);
* Sets the outline of the view, which defines the shape of the shadow it
* casts, and can used for clipping.
* <p>
+ * The outline path of a View must be {@link android.graphics.Path#isConvex() convex}.
+ * <p>
* If the outline is not set, or {@link Path#isEmpty()}, shadows will be
* cast from the bounds of the View, and clipToOutline will be ignored.
*
- * @param outline The new outline of the view. Must be non-null.
+ * @param outline The new outline of the view. Must be non-null, and convex.
*
+ * @see #setCastsShadow(boolean)
* @see #getOutline(Path)
* @see #getClipToOutline()
* @see #setClipToOutline(boolean)
if (outline == null) {
throw new IllegalArgumentException("Path must be non-null");
}
+ if (!outline.isConvex()) {
+ throw new IllegalArgumentException("Path must be convex");
+ }
// always copy the path since caller may reuse
if (mOutline == null) {
mOutline = new Path(outline);
*dst = *src;
}
+ static jboolean isConvex(JNIEnv* env, jobject clazz, jlong objHandle) {
+ SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
+ return obj->isConvex();
+ }
+
static jint getFillType(JNIEnv* env, jobject clazz, jlong objHandle) {
SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
return obj->getFillType();
}
-
+
static void setFillType(JNIEnv* env, jobject clazz, jlong pathHandle, jint ftHandle) {
SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
SkPath::FillType ft = static_cast<SkPath::FillType>(ftHandle);
{"native_reset","(J)V", (void*) SkPathGlue::reset},
{"native_rewind","(J)V", (void*) SkPathGlue::rewind},
{"native_set","(JJ)V", (void*) SkPathGlue::assign},
+ {"native_isConvex","(J)Z", (void*) SkPathGlue::isConvex},
{"native_getFillType","(J)I", (void*) SkPathGlue::getFillType},
{"native_setFillType","(JI)V", (void*) SkPathGlue::setFillType},
{"native_isEmpty","(J)Z", (void*) SkPathGlue::isEmpty},
}
/**
+ * Returns the path's convexity, as defined by the content of the path.
+ * <p>
+ * A path is convex if it has a single contour, and only ever curves in a
+ * single direction.
+ * <p>
+ * This function will calculate the convexity of the path from its control
+ * points, and cache the result.
+ *
+ * @return True if the path is convex.
+ */
+ public boolean isConvex() {
+ return native_isConvex(mNativePath);
+ }
+
+ /**
* Enum for the ways a path may be filled.
*/
public enum FillType {
public void setFillType(FillType ft) {
native_setFillType(mNativePath, ft.nativeInt);
}
-
+
/**
* Returns true if the filltype is one of the INVERSE variants
*
*/
public boolean isInverseFillType() {
final int ft = native_getFillType(mNativePath);
- return (ft & 2) != 0;
+ return (ft & FillType.INVERSE_WINDING.nativeInt) != 0;
}
-
+
/**
* Toggles the INVERSE state of the filltype
*/
public void toggleInverseFillType() {
int ft = native_getFillType(mNativePath);
- ft ^= 2;
+ ft ^= FillType.INVERSE_WINDING.nativeInt;
native_setFillType(mNativePath, ft);
}
-
+
/**
* Returns true if the path is empty (contains no lines or curves)
*
private static native void native_reset(long nPath);
private static native void native_rewind(long nPath);
private static native void native_set(long native_dst, long native_src);
+ private static native boolean native_isConvex(long nPath);
private static native int native_getFillType(long nPath);
private static native void native_setFillType(long nPath, int ft);
private static native boolean native_isEmpty(long nPath);