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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/*
* Copyright (C) 2006 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 android.annotation.NonNull;
import android.annotation.Nullable;
import libcore.util.NativeAllocationRegistry;
/**
* Shader is the based class for objects that return horizontal spans of colors
* during drawing. A subclass of Shader is installed in a Paint calling
* paint.setShader(shader). After that any object (other than a bitmap) that is
* drawn with that paint will get its color(s) from the shader.
*/
public class Shader {
private static class NoImagePreloadHolder {
public static final NativeAllocationRegistry sRegistry = new NativeAllocationRegistry(
Shader.class.getClassLoader(), nativeGetFinalizer(), 50);
}
/**
* @deprecated Use subclass constructors directly instead.
*/
@Deprecated
public Shader() {}
/**
* Current native shader instance. Created and updated lazily when {@link #getNativeInstance()}
* is called - otherwise may be out of date with java setters/properties.
*/
private long mNativeInstance;
// Runnable to do immediate destruction
private Runnable mCleaner;
/**
* Current matrix - always set to null if local matrix is identity.
*/
private Matrix mLocalMatrix;
public enum TileMode {
/**
* replicate the edge color if the shader draws outside of its
* original bounds
*/
CLAMP (0),
/**
* repeat the shader's image horizontally and vertically
*/
REPEAT (1),
/**
* repeat the shader's image horizontally and vertically, alternating
* mirror images so that adjacent images always seam
*/
MIRROR (2);
TileMode(int nativeInt) {
this.nativeInt = nativeInt;
}
final int nativeInt;
}
/**
* Return true if the shader has a non-identity local matrix.
* @param localM Set to the local matrix of the shader, if the shader's matrix is non-null.
* @return true if the shader has a non-identity local matrix
*/
public boolean getLocalMatrix(@NonNull Matrix localM) {
if (mLocalMatrix != null) {
localM.set(mLocalMatrix);
return true; // presence of mLocalMatrix means it's not identity
}
return false;
}
/**
* Set the shader's local matrix. Passing null will reset the shader's
* matrix to identity. If the matrix has scale value as 0, the drawing
* result is undefined.
*
* @param localM The shader's new local matrix, or null to specify identity
*/
public void setLocalMatrix(@Nullable Matrix localM) {
if (localM == null || localM.isIdentity()) {
if (mLocalMatrix != null) {
mLocalMatrix = null;
discardNativeInstance();
}
} else {
if (mLocalMatrix == null) {
mLocalMatrix = new Matrix(localM);
discardNativeInstance();
} else if (!mLocalMatrix.equals(localM)) {
mLocalMatrix.set(localM);
discardNativeInstance();
}
}
}
long createNativeInstance(long nativeMatrix) {
return 0;
}
/** @hide */
protected final void discardNativeInstance() {
if (mNativeInstance != 0) {
mCleaner.run();
mCleaner = null;
mNativeInstance = 0;
}
}
/**
* Callback for subclasses to call {@link #discardNativeInstance()} if the most recently
* constructed native instance is no longer valid.
* @hide
*/
protected void verifyNativeInstance() {
}
/**
* @hide
*/
protected Shader copy() {
final Shader copy = new Shader();
copyLocalMatrix(copy);
return copy;
}
/**
* @hide
*/
protected void copyLocalMatrix(Shader dest) {
dest.mLocalMatrix.set(mLocalMatrix);
}
/**
* @hide
*/
public final long getNativeInstance() {
// verify mNativeInstance is valid
verifyNativeInstance();
if (mNativeInstance == 0) {
mNativeInstance = createNativeInstance(mLocalMatrix == null
? 0 : mLocalMatrix.native_instance);
if (mNativeInstance != 0) {
mCleaner = NoImagePreloadHolder.sRegistry.registerNativeAllocation(
this, mNativeInstance);
}
}
return mNativeInstance;
}
private static native long nativeGetFinalizer();
}
|
