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