1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
/*
* Copyright (C) 2014 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.util;
import android.annotation.UnsupportedAppUsage;
import android.graphics.Path;
import dalvik.annotation.optimization.FastNative;
/**
* @hide
*/
public class PathParser {
static final String LOGTAG = PathParser.class.getSimpleName();
/**
* @param pathString The string representing a path, the same as "d" string in svg file.
* @return the generated Path object.
*/
@UnsupportedAppUsage
public static Path createPathFromPathData(String pathString) {
if (pathString == null) {
throw new IllegalArgumentException("Path string can not be null.");
}
Path path = new Path();
nParseStringForPath(path.mNativePath, pathString, pathString.length());
return path;
}
/**
* Interpret PathData as path commands and insert the commands to the given path.
*
* @param data The source PathData to be converted.
* @param outPath The Path object where path commands will be inserted.
*/
public static void createPathFromPathData(Path outPath, PathData data) {
nCreatePathFromPathData(outPath.mNativePath, data.mNativePathData);
}
/**
* @param pathDataFrom The source path represented in PathData
* @param pathDataTo The target path represented in PathData
* @return whether the <code>nodesFrom</code> can morph into <code>nodesTo</code>
*/
public static boolean canMorph(PathData pathDataFrom, PathData pathDataTo) {
return nCanMorph(pathDataFrom.mNativePathData, pathDataTo.mNativePathData);
}
/**
* PathData class is a wrapper around the native PathData object, which contains
* the result of parsing a path string. Specifically, there are verbs and points
* associated with each verb stored in PathData. This data can then be used to
* generate commands to manipulate a Path.
*/
public static class PathData {
long mNativePathData = 0;
public PathData() {
mNativePathData = nCreateEmptyPathData();
}
public PathData(PathData data) {
mNativePathData = nCreatePathData(data.mNativePathData);
}
public PathData(String pathString) {
mNativePathData = nCreatePathDataFromString(pathString, pathString.length());
if (mNativePathData == 0) {
throw new IllegalArgumentException("Invalid pathData: " + pathString);
}
}
public long getNativePtr() {
return mNativePathData;
}
/**
* Update the path data to match the source.
* Before calling this, make sure canMorph(target, source) is true.
*
* @param source The source path represented in PathData
*/
public void setPathData(PathData source) {
nSetPathData(mNativePathData, source.mNativePathData);
}
@Override
protected void finalize() throws Throwable {
if (mNativePathData != 0) {
nFinalize(mNativePathData);
mNativePathData = 0;
}
super.finalize();
}
}
/**
* Interpolate between the <code>fromData</code> and <code>toData</code> according to the
* <code>fraction</code>, and put the resulting path data into <code>outData</code>.
*
* @param outData The resulting PathData of the interpolation
* @param fromData The start value as a PathData.
* @param toData The end value as a PathData
* @param fraction The fraction to interpolate.
*/
public static boolean interpolatePathData(PathData outData, PathData fromData, PathData toData,
float fraction) {
return nInterpolatePathData(outData.mNativePathData, fromData.mNativePathData,
toData.mNativePathData, fraction);
}
// Native functions are defined below.
private static native void nParseStringForPath(long pathPtr, String pathString,
int stringLength);
private static native long nCreatePathDataFromString(String pathString, int stringLength);
// ----------------- @FastNative -----------------------
@FastNative
private static native void nCreatePathFromPathData(long outPathPtr, long pathData);
@FastNative
private static native long nCreateEmptyPathData();
@FastNative
private static native long nCreatePathData(long nativePtr);
@FastNative
private static native boolean nInterpolatePathData(long outDataPtr, long fromDataPtr,
long toDataPtr, float fraction);
@FastNative
private static native void nFinalize(long nativePtr);
@FastNative
private static native boolean nCanMorph(long fromDataPtr, long toDataPtr);
@FastNative
private static native void nSetPathData(long outDataPtr, long fromDataPtr);
}
|
