src.android.graphics.RoundRectangle Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.graphics;
import java.awt.geom.AffineTransform;
import java.awt.geom.PathIterator;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RectangularShape;
import java.awt.geom.RoundRectangle2D;
import java.util.EnumSet;
import java.util.NoSuchElementException;
/**
* Defines a rectangle with rounded corners, where the sizes of the corners
* are potentially different.
*/
public class RoundRectangle extends RectangularShape {
public double x;
public double y;
public double width;
public double height;
public double ulWidth;
public double ulHeight;
public double urWidth;
public double urHeight;
public double lrWidth;
public double lrHeight;
public double llWidth;
public double llHeight;
private enum Zone {
CLOSE_OUTSIDE,
CLOSE_INSIDE,
MIDDLE,
FAR_INSIDE,
FAR_OUTSIDE
}
private final EnumSet close = EnumSet.of(Zone.CLOSE_OUTSIDE, Zone.CLOSE_INSIDE);
private final EnumSet far = EnumSet.of(Zone.FAR_OUTSIDE, Zone.FAR_INSIDE);
/**
* @param cornerDimensions array of 8 floating-point number corresponding to the width and
* the height of each corner in the following order: upper-left, upper-right, lower-right,
* lower-left. It assumes for the size the same convention as {@link RoundRectangle2D}, that
* is that the width and height of a corner correspond to the total width and height of the
* ellipse that corner is a quarter of.
*/
public RoundRectangle(float x, float y, float width, float height, float[] cornerDimensions) {
assert cornerDimensions.length == 8 : "The array of corner dimensions must have eight " +
"elements";
this.x = x;
this.y = y;
this.width = width;
this.height = height;
float[] dimensions = cornerDimensions.clone();
// If a value is negative, the corresponding corner is squared
for (int i = 0; i < dimensions.length; i += 2) {
if (dimensions[i] < 0 || dimensions[i + 1] < 0) {
dimensions[i] = 0;
dimensions[i + 1] = 0;
}
}
double topCornerWidth = (dimensions[0] + dimensions[2]) / 2d;
double bottomCornerWidth = (dimensions[4] + dimensions[6]) / 2d;
double leftCornerHeight = (dimensions[1] + dimensions[7]) / 2d;
double rightCornerHeight = (dimensions[3] + dimensions[5]) / 2d;
// Rescale the corner dimensions if they are bigger than the rectangle
double scale = Math.min(1.0, width / topCornerWidth);
scale = Math.min(scale, width / bottomCornerWidth);
scale = Math.min(scale, height / leftCornerHeight);
scale = Math.min(scale, height / rightCornerHeight);
this.ulWidth = dimensions[0] * scale;
this.ulHeight = dimensions[1] * scale;
this.urWidth = dimensions[2] * scale;
this.urHeight = dimensions[3] * scale;
this.lrWidth = dimensions[4] * scale;
this.lrHeight = dimensions[5] * scale;
this.llWidth = dimensions[6] * scale;
this.llHeight = dimensions[7] * scale;
}
@Override
public double getX() {
return x;
}
@Override
public double getY() {
return y;
}
@Override
public double getWidth() {
return width;
}
@Override
public double getHeight() {
return height;
}
@Override
public boolean isEmpty() {
return (width <= 0d) || (height <= 0d);
}
@Override
public void setFrame(double x, double y, double w, double h) {
this.x = x;
this.y = y;
this.width = w;
this.height = h;
}
@Override
public Rectangle2D getBounds2D() {
return new Rectangle2D.Double(x, y, width, height);
}
@Override
public boolean contains(double x, double y) {
if (isEmpty()) {
return false;
}
double x0 = getX();
double y0 = getY();
double x1 = x0 + getWidth();
double y1 = y0 + getHeight();
// Check for trivial rejection - point is outside bounding rectangle
if (x < x0 || y < y0 || x >= x1 || y >= y1) {
return false;
}
double insideTopX0 = x0 + ulWidth / 2d;
double insideLeftY0 = y0 + ulHeight / 2d;
if (x < insideTopX0 && y < insideLeftY0) {
// In the upper-left corner
return isInsideCorner(x - insideTopX0, y - insideLeftY0, ulWidth / 2d, ulHeight / 2d);
}
double insideTopX1 = x1 - urWidth / 2d;
double insideRightY0 = y0 + urHeight / 2d;
if (x > insideTopX1 && y < insideRightY0) {
// In the upper-right corner
return isInsideCorner(x - insideTopX1, y - insideRightY0, urWidth / 2d, urHeight / 2d);
}
double insideBottomX1 = x1 - lrWidth / 2d;
double insideRightY1 = y1 - lrHeight / 2d;
if (x > insideBottomX1 && y > insideRightY1) {
// In the lower-right corner
return isInsideCorner(x - insideBottomX1, y - insideRightY1, lrWidth / 2d,
lrHeight / 2d);
}
double insideBottomX0 = x0 + llWidth / 2d;
double insideLeftY1 = y1 - llHeight / 2d;
if (x < insideBottomX0 && y > insideLeftY1) {
// In the lower-left corner
return isInsideCorner(x - insideBottomX0, y - insideLeftY1, llWidth / 2d,
llHeight / 2d);
}
// In the central part of the rectangle
return true;
}
private boolean isInsideCorner(double x, double y, double width, double height) {
double squareDist = height * height * x * x + width * width * y * y;
return squareDist <= width * width * height * height;
}
private Zone classify(double coord, double side1, double arcSize1, double side2,
double arcSize2) {
if (coord < side1) {
return Zone.CLOSE_OUTSIDE;
} else if (coord < side1 + arcSize1) {
return Zone.CLOSE_INSIDE;
} else if (coord < side2 - arcSize2) {
return Zone.MIDDLE;
} else if (coord < side2) {
return Zone.FAR_INSIDE;
} else {
return Zone.FAR_OUTSIDE;
}
}
public boolean intersects(double x, double y, double w, double h) {
if (isEmpty() || w <= 0 || h <= 0) {
return false;
}
double x0 = getX();
double y0 = getY();
double x1 = x0 + getWidth();
double y1 = y0 + getHeight();
// Check for trivial rejection - bounding rectangles do not intersect
if (x + w <= x0 || x >= x1 || y + h <= y0 || y >= y1) {
return false;
}
double maxLeftCornerWidth = Math.max(ulWidth, llWidth) / 2d;
double maxRightCornerWidth = Math.max(urWidth, lrWidth) / 2d;
double maxUpperCornerHeight = Math.max(ulHeight, urHeight) / 2d;
double maxLowerCornerHeight = Math.max(llHeight, lrHeight) / 2d;
Zone x0class = classify(x, x0, maxLeftCornerWidth, x1, maxRightCornerWidth);
Zone x1class = classify(x + w, x0, maxLeftCornerWidth, x1, maxRightCornerWidth);
Zone y0class = classify(y, y0, maxUpperCornerHeight, y1, maxLowerCornerHeight);
Zone y1class = classify(y + h, y0, maxUpperCornerHeight, y1, maxLowerCornerHeight);
// Trivially accept if any point is inside inner rectangle
if (x0class == Zone.MIDDLE || x1class == Zone.MIDDLE || y0class == Zone.MIDDLE || y1class == Zone.MIDDLE) {
return true;
}
// Trivially accept if either edge spans inner rectangle
if ((close.contains(x0class) && far.contains(x1class)) || (close.contains(y0class) &&
far.contains(y1class))) {
return true;
}
// Since neither edge spans the center, then one of the corners
// must be in one of the rounded edges. We detect this case if
// a [xy]0class is 3 or a [xy]1class is 1. One of those two cases
// must be true for each direction.
// We now find a "nearest point" to test for being inside a rounded
// corner.
if (x1class == Zone.CLOSE_INSIDE && y1class == Zone.CLOSE_INSIDE) {
// Potentially in upper-left corner
x = x + w - x0 - ulWidth / 2d;
y = y + h - y0 - ulHeight / 2d;
return x > 0 || y > 0 || isInsideCorner(x, y, ulWidth / 2d, ulHeight / 2d);
}
if (x1class == Zone.CLOSE_INSIDE) {
// Potentially in lower-left corner
x = x + w - x0 - llWidth / 2d;
y = y - y1 + llHeight / 2d;
return x > 0 || y < 0 || isInsideCorner(x, y, llWidth / 2d, llHeight / 2d);
}
if (y1class == Zone.CLOSE_INSIDE) {
//Potentially in the upper-right corner
x = x - x1 + urWidth / 2d;
y = y + h - y0 - urHeight / 2d;
return x < 0 || y > 0 || isInsideCorner(x, y, urWidth / 2d, urHeight / 2d);
}
// Potentially in the lower-right corner
x = x - x1 + lrWidth / 2d;
y = y - y1 + lrHeight / 2d;
return x < 0 || y < 0 || isInsideCorner(x, y, lrWidth / 2d, lrHeight / 2d);
}
@Override
public boolean contains(double x, double y, double w, double h) {
if (isEmpty() || w <= 0 || h <= 0) {
return false;
}
return (contains(x, y) &&
contains(x + w, y) &&
contains(x, y + h) &&
contains(x + w, y + h));
}
@Override
public PathIterator getPathIterator(final AffineTransform at) {
return new PathIterator() {
int index;
// ArcIterator.btan(Math.PI/2)
public static final double CtrlVal = 0.5522847498307933;
private final double ncv = 1.0 - CtrlVal;
// Coordinates of control points for Bezier curves approximating the straight lines
// and corners of the rounded rectangle.
private final double[][] ctrlpts = {
{0.0, 0.0, 0.0, ulHeight},
{0.0, 0.0, 1.0, -llHeight},
{0.0, 0.0, 1.0, -llHeight * ncv, 0.0, ncv * llWidth, 1.0, 0.0, 0.0, llWidth,
1.0, 0.0},
{1.0, -lrWidth, 1.0, 0.0},
{1.0, -lrWidth * ncv, 1.0, 0.0, 1.0, 0.0, 1.0, -lrHeight * ncv, 1.0, 0.0, 1.0,
-lrHeight},
{1.0, 0.0, 0.0, urHeight},
{1.0, 0.0, 0.0, ncv * urHeight, 1.0, -urWidth * ncv, 0.0, 0.0, 1.0, -urWidth,
0.0, 0.0},
{0.0, ulWidth, 0.0, 0.0},
{0.0, ncv * ulWidth, 0.0, 0.0, 0.0, 0.0, 0.0, ncv * ulHeight, 0.0, 0.0, 0.0,
ulHeight},
{}
};
private final int[] types = {
SEG_MOVETO,
SEG_LINETO, SEG_CUBICTO,
SEG_LINETO, SEG_CUBICTO,
SEG_LINETO, SEG_CUBICTO,
SEG_LINETO, SEG_CUBICTO,
SEG_CLOSE,
};
@Override
public int getWindingRule() {
return WIND_NON_ZERO;
}
@Override
public boolean isDone() {
return index >= ctrlpts.length;
}
@Override
public void next() {
index++;
}
@Override
public int currentSegment(float[] coords) {
if (isDone()) {
throw new NoSuchElementException("roundrect iterator out of bounds");
}
int nc = 0;
double ctrls[] = ctrlpts[index];
for (int i = 0; i < ctrls.length; i += 4) {
coords[nc++] = (float) (x + ctrls[i] * width + ctrls[i + 1] / 2d);
coords[nc++] = (float) (y + ctrls[i + 2] * height + ctrls[i + 3] / 2d);
}
if (at != null) {
at.transform(coords, 0, coords, 0, nc / 2);
}
return types[index];
}
@Override
public int currentSegment(double[] coords) {
if (isDone()) {
throw new NoSuchElementException("roundrect iterator out of bounds");
}
int nc = 0;
double ctrls[] = ctrlpts[index];
for (int i = 0; i < ctrls.length; i += 4) {
coords[nc++] = x + ctrls[i] * width + ctrls[i + 1] / 2d;
coords[nc++] = y + ctrls[i + 2] * height + ctrls[i + 3] / 2d;
}
if (at != null) {
at.transform(coords, 0, coords, 0, nc / 2);
}
return types[index];
}
};
}
}