1/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.view;
18
19import com.android.layoutlib.bridge.impl.DelegateManager;
20import com.android.tools.layoutlib.annotations.LayoutlibDelegate;
21
22import android.graphics.Matrix;
23
24/**
25 * Delegate implementing the native methods of {@link RenderNode}
26 * <p/>
27 * Through the layoutlib_create tool, some native methods of RenderNode have been replaced by calls
28 * to methods of the same name in this delegate class.
29 *
30 * @see DelegateManager
31 */
32public class RenderNode_Delegate {
33
34
35    // ---- delegate manager ----
36    private static final DelegateManager<RenderNode_Delegate> sManager =
37            new DelegateManager<RenderNode_Delegate>(RenderNode_Delegate.class);
38
39
40    private float mLift;
41    private float mTranslationX;
42    private float mTranslationY;
43    private float mTranslationZ;
44    private float mRotation;
45    private float mScaleX = 1;
46    private float mScaleY = 1;
47    private float mPivotX;
48    private float mPivotY;
49    private boolean mPivotExplicitlySet;
50    private int mLeft;
51    private int mRight;
52    private int mTop;
53    private int mBottom;
54    @SuppressWarnings("UnusedDeclaration")
55    private String mName;
56
57    @LayoutlibDelegate
58    /*package*/ static long nCreate(RenderNode thisRenderNode, String name) {
59        RenderNode_Delegate renderNodeDelegate = new RenderNode_Delegate();
60        renderNodeDelegate.mName = name;
61        return sManager.addNewDelegate(renderNodeDelegate);
62    }
63
64    @LayoutlibDelegate
65    /*package*/ static void nDestroyRenderNode(long renderNode) {
66        sManager.removeJavaReferenceFor(renderNode);
67    }
68
69    @LayoutlibDelegate
70    /*package*/ static boolean nSetElevation(long renderNode, float lift) {
71        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
72        if (delegate != null && delegate.mLift != lift) {
73            delegate.mLift = lift;
74            return true;
75        }
76        return false;
77    }
78
79    @LayoutlibDelegate
80    /*package*/ static float nGetElevation(long renderNode) {
81        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
82        if (delegate != null) {
83            return delegate.mLift;
84        }
85        return 0f;
86    }
87
88    @LayoutlibDelegate
89    /*package*/ static boolean nSetTranslationX(long renderNode, float translationX) {
90        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
91        if (delegate != null && delegate.mTranslationX != translationX) {
92            delegate.mTranslationX = translationX;
93            return true;
94        }
95        return false;
96    }
97
98    @LayoutlibDelegate
99    /*package*/ static float nGetTranslationX(long renderNode) {
100        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
101        if (delegate != null) {
102            return delegate.mTranslationX;
103        }
104        return 0f;
105    }
106
107    @LayoutlibDelegate
108    /*package*/ static boolean nSetTranslationY(long renderNode, float translationY) {
109        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
110        if (delegate != null && delegate.mTranslationY != translationY) {
111            delegate.mTranslationY = translationY;
112            return true;
113        }
114        return false;
115    }
116
117    @LayoutlibDelegate
118    /*package*/ static float nGetTranslationY(long renderNode) {
119        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
120        if (delegate != null) {
121            return delegate.mTranslationY;
122        }
123        return 0f;
124    }
125
126    @LayoutlibDelegate
127    /*package*/ static boolean nSetTranslationZ(long renderNode, float translationZ) {
128        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
129        if (delegate != null && delegate.mTranslationZ != translationZ) {
130            delegate.mTranslationZ = translationZ;
131            return true;
132        }
133        return false;
134    }
135
136    @LayoutlibDelegate
137    /*package*/ static float nGetTranslationZ(long renderNode) {
138        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
139        if (delegate != null) {
140            return delegate.mTranslationZ;
141        }
142        return 0f;
143    }
144
145    @LayoutlibDelegate
146    /*package*/ static boolean nSetRotation(long renderNode, float rotation) {
147        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
148        if (delegate != null && delegate.mRotation != rotation) {
149            delegate.mRotation = rotation;
150            return true;
151        }
152        return false;
153    }
154
155    @LayoutlibDelegate
156    /*package*/ static float nGetRotation(long renderNode) {
157        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
158        if (delegate != null) {
159            return delegate.mRotation;
160        }
161        return 0f;
162    }
163
164    @LayoutlibDelegate
165    /*package*/ static void getMatrix(RenderNode renderNode, Matrix outMatrix) {
166        outMatrix.reset();
167        if (renderNode != null) {
168            float rotation = renderNode.getRotation();
169            float translationX = renderNode.getTranslationX();
170            float translationY = renderNode.getTranslationY();
171            float pivotX = renderNode.getPivotX();
172            float pivotY = renderNode.getPivotY();
173            float scaleX = renderNode.getScaleX();
174            float scaleY = renderNode.getScaleY();
175
176            outMatrix.setTranslate(translationX, translationY);
177            outMatrix.preRotate(rotation, pivotX, pivotY);
178            outMatrix.preScale(scaleX, scaleY, pivotX, pivotY);
179        }
180    }
181
182    @LayoutlibDelegate
183    /*package*/ static boolean nSetLeft(long renderNode, int left) {
184        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
185        if (delegate != null && delegate.mLeft != left) {
186            delegate.mLeft = left;
187            return true;
188        }
189        return false;
190    }
191
192    @LayoutlibDelegate
193    /*package*/ static boolean nSetTop(long renderNode, int top) {
194        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
195        if (delegate != null && delegate.mTop != top) {
196            delegate.mTop = top;
197            return true;
198        }
199        return false;
200    }
201
202    @LayoutlibDelegate
203    /*package*/ static boolean nSetRight(long renderNode, int right) {
204        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
205        if (delegate != null && delegate.mRight != right) {
206            delegate.mRight = right;
207            return true;
208        }
209        return false;
210    }
211
212    @LayoutlibDelegate
213    /*package*/ static boolean nSetBottom(long renderNode, int bottom) {
214        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
215        if (delegate != null && delegate.mBottom != bottom) {
216            delegate.mBottom = bottom;
217            return true;
218        }
219        return false;
220    }
221
222    @LayoutlibDelegate
223    /*package*/ static boolean nSetLeftTopRightBottom(long renderNode, int left, int top, int right,
224            int bottom) {
225        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
226        if (delegate != null && (delegate.mLeft != left || delegate.mTop != top || delegate
227                .mRight != right || delegate.mBottom != bottom)) {
228            delegate.mLeft = left;
229            delegate.mTop = top;
230            delegate.mRight = right;
231            delegate.mBottom = bottom;
232            return true;
233        }
234        return false;
235    }
236
237    @LayoutlibDelegate
238    /*package*/ static boolean nIsPivotExplicitlySet(long renderNode) {
239        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
240        return delegate != null && delegate.mPivotExplicitlySet;
241    }
242
243    @LayoutlibDelegate
244    /*package*/ static boolean nSetPivotX(long renderNode, float pivotX) {
245        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
246        if (delegate != null) {
247            delegate.mPivotX = pivotX;
248            delegate.mPivotExplicitlySet = true;
249            return true;
250        }
251        return false;
252    }
253
254    @LayoutlibDelegate
255    /*package*/ static float nGetPivotX(long renderNode) {
256        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
257        if (delegate != null) {
258            if (delegate.mPivotExplicitlySet) {
259                return delegate.mPivotX;
260            } else {
261                return (delegate.mRight - delegate.mLeft) / 2.0f;
262            }
263        }
264        return 0f;
265    }
266
267    @LayoutlibDelegate
268    /*package*/ static boolean nSetPivotY(long renderNode, float pivotY) {
269        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
270        if (delegate != null) {
271            delegate.mPivotY = pivotY;
272            delegate.mPivotExplicitlySet = true;
273            return true;
274        }
275        return false;
276    }
277
278    @LayoutlibDelegate
279    /*package*/ static float nGetPivotY(long renderNode) {
280        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
281        if (delegate != null) {
282            if (delegate.mPivotExplicitlySet) {
283                return delegate.mPivotY;
284            } else {
285                return (delegate.mBottom - delegate.mTop) / 2.0f;
286            }
287        }
288        return 0f;
289    }
290
291    @LayoutlibDelegate
292    /*package*/ static boolean nSetScaleX(long renderNode, float scaleX) {
293        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
294        if (delegate != null && delegate.mScaleX != scaleX) {
295            delegate.mScaleX = scaleX;
296            return true;
297        }
298        return false;
299    }
300
301    @LayoutlibDelegate
302    /*package*/ static float nGetScaleX(long renderNode) {
303        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
304        if (delegate != null) {
305            return delegate.mScaleX;
306        }
307        return 0f;
308    }
309
310    @LayoutlibDelegate
311    /*package*/ static boolean nSetScaleY(long renderNode, float scaleY) {
312        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
313        if (delegate != null && delegate.mScaleY != scaleY) {
314            delegate.mScaleY = scaleY;
315            return true;
316        }
317        return false;
318    }
319
320    @LayoutlibDelegate
321    /*package*/ static float nGetScaleY(long renderNode) {
322        RenderNode_Delegate delegate = sManager.getDelegate(renderNode);
323        if (delegate != null) {
324            return delegate.mScaleY;
325        }
326        return 0f;
327    }
328}
329