android_view_RenderNode.cpp revision 987f79f60bb1f0a4bcd3ef22e57301c743f0b94f
1/* 2 * Copyright (C) 2012 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 17#define LOG_TAG "OpenGLRenderer" 18 19#include <EGL/egl.h> 20 21#include "jni.h" 22#include "GraphicsJNI.h" 23#include <nativehelper/JNIHelp.h> 24#include <android_runtime/AndroidRuntime.h> 25 26#include <Animator.h> 27#include <DisplayListRenderer.h> 28#include <RenderNode.h> 29#include <Paint.h> 30 31#include "core_jni_helpers.h" 32 33namespace android { 34 35using namespace uirenderer; 36 37/** 38 * Note: OpenGLRenderer JNI layer is generated and compiled only on supported 39 * devices. This means all the logic must be compiled only when the 40 * preprocessor variable USE_OPENGL_RENDERER is defined. 41 */ 42#ifdef USE_OPENGL_RENDERER 43 44#define SET_AND_DIRTY(prop, val, dirtyFlag) \ 45 (reinterpret_cast<RenderNode*>(renderNodePtr)->mutateStagingProperties().prop(val) \ 46 ? (reinterpret_cast<RenderNode*>(renderNodePtr)->setPropertyFieldsDirty(dirtyFlag), true) \ 47 : false) 48 49// ---------------------------------------------------------------------------- 50// DisplayList view properties 51// ---------------------------------------------------------------------------- 52 53static void android_view_RenderNode_output(JNIEnv* env, 54 jobject clazz, jlong renderNodePtr) { 55 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 56 renderNode->output(); 57} 58 59static jint android_view_RenderNode_getDebugSize(JNIEnv* env, 60 jobject clazz, jlong renderNodePtr) { 61 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 62 return renderNode->getDebugSize(); 63} 64 65static jlong android_view_RenderNode_create(JNIEnv* env, jobject clazz, jstring name) { 66 RenderNode* renderNode = new RenderNode(); 67 renderNode->incStrong(0); 68 if (name != NULL) { 69 const char* textArray = env->GetStringUTFChars(name, NULL); 70 renderNode->setName(textArray); 71 env->ReleaseStringUTFChars(name, textArray); 72 } 73 return reinterpret_cast<jlong>(renderNode); 74} 75 76static void android_view_RenderNode_destroyRenderNode(JNIEnv* env, 77 jobject clazz, jlong renderNodePtr) { 78 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 79 renderNode->decStrong(0); 80} 81 82static void android_view_RenderNode_setDisplayListData(JNIEnv* env, 83 jobject clazz, jlong renderNodePtr, jlong newDataPtr) { 84 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 85 DisplayListData* newData = reinterpret_cast<DisplayListData*>(newDataPtr); 86 renderNode->setStagingDisplayList(newData); 87} 88 89// ---------------------------------------------------------------------------- 90// RenderProperties - setters 91// ---------------------------------------------------------------------------- 92 93static jboolean android_view_RenderNode_setLayerType(JNIEnv* env, 94 jobject clazz, jlong renderNodePtr, jint jlayerType) { 95 LayerType layerType = static_cast<LayerType>(jlayerType); 96 return SET_AND_DIRTY(mutateLayerProperties().setType, layerType, RenderNode::GENERIC); 97} 98 99static jboolean android_view_RenderNode_setLayerPaint(JNIEnv* env, 100 jobject clazz, jlong renderNodePtr, jlong paintPtr) { 101 Paint* paint = reinterpret_cast<Paint*>(paintPtr); 102 return SET_AND_DIRTY(mutateLayerProperties().setFromPaint, paint, RenderNode::GENERIC); 103} 104 105static jboolean android_view_RenderNode_setStaticMatrix(JNIEnv* env, 106 jobject clazz, jlong renderNodePtr, jlong matrixPtr) { 107 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr); 108 return SET_AND_DIRTY(setStaticMatrix, matrix, RenderNode::GENERIC); 109} 110 111static jboolean android_view_RenderNode_setAnimationMatrix(JNIEnv* env, 112 jobject clazz, jlong renderNodePtr, jlong matrixPtr) { 113 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr); 114 return SET_AND_DIRTY(setAnimationMatrix, matrix, RenderNode::GENERIC); 115} 116 117static jboolean android_view_RenderNode_setClipToBounds(JNIEnv* env, 118 jobject clazz, jlong renderNodePtr, jboolean clipToBounds) { 119 return SET_AND_DIRTY(setClipToBounds, clipToBounds, RenderNode::GENERIC); 120} 121 122static jboolean android_view_RenderNode_setClipBounds(JNIEnv* env, 123 jobject clazz, jlong renderNodePtr, jint left, jint top, jint right, jint bottom) { 124 android::uirenderer::Rect clipBounds(left, top, right, bottom); 125 return SET_AND_DIRTY(setClipBounds, clipBounds, RenderNode::GENERIC); 126} 127 128static jboolean android_view_RenderNode_setClipBoundsEmpty(JNIEnv* env, 129 jobject clazz, jlong renderNodePtr) { 130 return SET_AND_DIRTY(setClipBoundsEmpty,, RenderNode::GENERIC); 131} 132 133static jboolean android_view_RenderNode_setProjectBackwards(JNIEnv* env, 134 jobject clazz, jlong renderNodePtr, jboolean shouldProject) { 135 return SET_AND_DIRTY(setProjectBackwards, shouldProject, RenderNode::GENERIC); 136} 137 138static jboolean android_view_RenderNode_setProjectionReceiver(JNIEnv* env, 139 jobject clazz, jlong renderNodePtr, jboolean shouldRecieve) { 140 return SET_AND_DIRTY(setProjectionReceiver, shouldRecieve, RenderNode::GENERIC); 141} 142 143static jboolean android_view_RenderNode_setOutlineRoundRect(JNIEnv* env, 144 jobject clazz, jlong renderNodePtr, jint left, jint top, 145 jint right, jint bottom, jfloat radius, jfloat alpha) { 146 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 147 renderNode->mutateStagingProperties().mutableOutline().setRoundRect(left, top, right, bottom, 148 radius, alpha); 149 renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); 150 return true; 151} 152 153static jboolean android_view_RenderNode_setOutlineConvexPath(JNIEnv* env, 154 jobject clazz, jlong renderNodePtr, jlong outlinePathPtr, jfloat alpha) { 155 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 156 SkPath* outlinePath = reinterpret_cast<SkPath*>(outlinePathPtr); 157 renderNode->mutateStagingProperties().mutableOutline().setConvexPath(outlinePath, alpha); 158 renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); 159 return true; 160} 161 162static jboolean android_view_RenderNode_setOutlineEmpty(JNIEnv* env, 163 jobject clazz, jlong renderNodePtr) { 164 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 165 renderNode->mutateStagingProperties().mutableOutline().setEmpty(); 166 renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); 167 return true; 168} 169 170static jboolean android_view_RenderNode_setOutlineNone(JNIEnv* env, 171 jobject clazz, jlong renderNodePtr) { 172 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 173 renderNode->mutateStagingProperties().mutableOutline().setNone(); 174 renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); 175 return true; 176} 177 178static jboolean android_view_RenderNode_hasShadow(JNIEnv* env, 179 jobject clazz, jlong renderNodePtr) { 180 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 181 return renderNode->stagingProperties().hasShadow(); 182} 183 184static jboolean android_view_RenderNode_setClipToOutline(JNIEnv* env, 185 jobject clazz, jlong renderNodePtr, jboolean clipToOutline) { 186 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 187 renderNode->mutateStagingProperties().mutableOutline().setShouldClip(clipToOutline); 188 renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); 189 return true; 190} 191 192static jboolean android_view_RenderNode_setRevealClip(JNIEnv* env, 193 jobject clazz, jlong renderNodePtr, jboolean shouldClip, 194 jfloat x, jfloat y, jfloat radius) { 195 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 196 renderNode->mutateStagingProperties().mutableRevealClip().set( 197 shouldClip, x, y, radius); 198 renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); 199 return true; 200} 201 202static jboolean android_view_RenderNode_setAlpha(JNIEnv* env, 203 jobject clazz, jlong renderNodePtr, float alpha) { 204 return SET_AND_DIRTY(setAlpha, alpha, RenderNode::ALPHA); 205} 206 207static jboolean android_view_RenderNode_setHasOverlappingRendering(JNIEnv* env, 208 jobject clazz, jlong renderNodePtr, bool hasOverlappingRendering) { 209 return SET_AND_DIRTY(setHasOverlappingRendering, hasOverlappingRendering, 210 RenderNode::GENERIC); 211} 212 213static jboolean android_view_RenderNode_setElevation(JNIEnv* env, 214 jobject clazz, jlong renderNodePtr, float elevation) { 215 return SET_AND_DIRTY(setElevation, elevation, RenderNode::Z); 216} 217 218static jboolean android_view_RenderNode_setTranslationX(JNIEnv* env, 219 jobject clazz, jlong renderNodePtr, float tx) { 220 return SET_AND_DIRTY(setTranslationX, tx, RenderNode::TRANSLATION_X | RenderNode::X); 221} 222 223static jboolean android_view_RenderNode_setTranslationY(JNIEnv* env, 224 jobject clazz, jlong renderNodePtr, float ty) { 225 return SET_AND_DIRTY(setTranslationY, ty, RenderNode::TRANSLATION_Y | RenderNode::Y); 226} 227 228static jboolean android_view_RenderNode_setTranslationZ(JNIEnv* env, 229 jobject clazz, jlong renderNodePtr, float tz) { 230 return SET_AND_DIRTY(setTranslationZ, tz, RenderNode::TRANSLATION_Z | RenderNode::Z); 231} 232 233static jboolean android_view_RenderNode_setRotation(JNIEnv* env, 234 jobject clazz, jlong renderNodePtr, float rotation) { 235 return SET_AND_DIRTY(setRotation, rotation, RenderNode::ROTATION); 236} 237 238static jboolean android_view_RenderNode_setRotationX(JNIEnv* env, 239 jobject clazz, jlong renderNodePtr, float rx) { 240 return SET_AND_DIRTY(setRotationX, rx, RenderNode::ROTATION_X); 241} 242 243static jboolean android_view_RenderNode_setRotationY(JNIEnv* env, 244 jobject clazz, jlong renderNodePtr, float ry) { 245 return SET_AND_DIRTY(setRotationY, ry, RenderNode::ROTATION_Y); 246} 247 248static jboolean android_view_RenderNode_setScaleX(JNIEnv* env, 249 jobject clazz, jlong renderNodePtr, float sx) { 250 return SET_AND_DIRTY(setScaleX, sx, RenderNode::SCALE_X); 251} 252 253static jboolean android_view_RenderNode_setScaleY(JNIEnv* env, 254 jobject clazz, jlong renderNodePtr, float sy) { 255 return SET_AND_DIRTY(setScaleY, sy, RenderNode::SCALE_Y); 256} 257 258static jboolean android_view_RenderNode_setPivotX(JNIEnv* env, 259 jobject clazz, jlong renderNodePtr, float px) { 260 return SET_AND_DIRTY(setPivotX, px, RenderNode::GENERIC); 261} 262 263static jboolean android_view_RenderNode_setPivotY(JNIEnv* env, 264 jobject clazz, jlong renderNodePtr, float py) { 265 return SET_AND_DIRTY(setPivotY, py, RenderNode::GENERIC); 266} 267 268static jboolean android_view_RenderNode_setCameraDistance(JNIEnv* env, 269 jobject clazz, jlong renderNodePtr, float distance) { 270 return SET_AND_DIRTY(setCameraDistance, distance, RenderNode::GENERIC); 271} 272 273static jboolean android_view_RenderNode_setLeft(JNIEnv* env, 274 jobject clazz, jlong renderNodePtr, int left) { 275 return SET_AND_DIRTY(setLeft, left, RenderNode::X); 276} 277 278static jboolean android_view_RenderNode_setTop(JNIEnv* env, 279 jobject clazz, jlong renderNodePtr, int top) { 280 return SET_AND_DIRTY(setTop, top, RenderNode::Y); 281} 282 283static jboolean android_view_RenderNode_setRight(JNIEnv* env, 284 jobject clazz, jlong renderNodePtr, int right) { 285 return SET_AND_DIRTY(setRight, right, RenderNode::X); 286} 287 288static jboolean android_view_RenderNode_setBottom(JNIEnv* env, 289 jobject clazz, jlong renderNodePtr, int bottom) { 290 return SET_AND_DIRTY(setBottom, bottom, RenderNode::Y); 291} 292 293static jboolean android_view_RenderNode_setLeftTopRightBottom(JNIEnv* env, 294 jobject clazz, jlong renderNodePtr, int left, int top, 295 int right, int bottom) { 296 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 297 if (renderNode->mutateStagingProperties().setLeftTopRightBottom(left, top, right, bottom)) { 298 renderNode->setPropertyFieldsDirty(RenderNode::X | RenderNode::Y); 299 return true; 300 } 301 return false; 302} 303 304static jboolean android_view_RenderNode_offsetLeftAndRight(JNIEnv* env, 305 jobject clazz, jlong renderNodePtr, jint offset) { 306 return SET_AND_DIRTY(offsetLeftRight, offset, RenderNode::X); 307} 308 309static jboolean android_view_RenderNode_offsetTopAndBottom(JNIEnv* env, 310 jobject clazz, jlong renderNodePtr, jint offset) { 311 return SET_AND_DIRTY(offsetTopBottom, offset, RenderNode::Y); 312} 313 314// ---------------------------------------------------------------------------- 315// RenderProperties - getters 316// ---------------------------------------------------------------------------- 317 318static jboolean android_view_RenderNode_hasOverlappingRendering(JNIEnv* env, 319 jobject clazz, jlong renderNodePtr) { 320 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 321 return renderNode->stagingProperties().hasOverlappingRendering(); 322} 323 324static jboolean android_view_RenderNode_getClipToOutline(JNIEnv* env, 325 jobject clazz, jlong renderNodePtr) { 326 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 327 return renderNode->stagingProperties().getOutline().getShouldClip(); 328} 329 330static jfloat android_view_RenderNode_getAlpha(JNIEnv* env, 331 jobject clazz, jlong renderNodePtr) { 332 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 333 return renderNode->stagingProperties().getAlpha(); 334} 335 336static jfloat android_view_RenderNode_getCameraDistance(JNIEnv* env, 337 jobject clazz, jlong renderNodePtr) { 338 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 339 return renderNode->stagingProperties().getCameraDistance(); 340} 341 342static jfloat android_view_RenderNode_getScaleX(JNIEnv* env, 343 jobject clazz, jlong renderNodePtr) { 344 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 345 return renderNode->stagingProperties().getScaleX(); 346} 347 348static jfloat android_view_RenderNode_getScaleY(JNIEnv* env, 349 jobject clazz, jlong renderNodePtr) { 350 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 351 return renderNode->stagingProperties().getScaleY(); 352} 353 354static jfloat android_view_RenderNode_getElevation(JNIEnv* env, 355 jobject clazz, jlong renderNodePtr) { 356 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 357 return renderNode->stagingProperties().getElevation(); 358} 359 360static jfloat android_view_RenderNode_getTranslationX(JNIEnv* env, 361 jobject clazz, jlong renderNodePtr) { 362 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 363 return renderNode->stagingProperties().getTranslationX(); 364} 365 366static jfloat android_view_RenderNode_getTranslationY(JNIEnv* env, 367 jobject clazz, jlong renderNodePtr) { 368 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 369 return renderNode->stagingProperties().getTranslationY(); 370} 371 372static jfloat android_view_RenderNode_getTranslationZ(JNIEnv* env, 373 jobject clazz, jlong renderNodePtr) { 374 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 375 return renderNode->stagingProperties().getTranslationZ(); 376} 377 378static jfloat android_view_RenderNode_getRotation(JNIEnv* env, 379 jobject clazz, jlong renderNodePtr) { 380 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 381 return renderNode->stagingProperties().getRotation(); 382} 383 384static jfloat android_view_RenderNode_getRotationX(JNIEnv* env, 385 jobject clazz, jlong renderNodePtr) { 386 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 387 return renderNode->stagingProperties().getRotationX(); 388} 389 390static jfloat android_view_RenderNode_getRotationY(JNIEnv* env, 391 jobject clazz, jlong renderNodePtr) { 392 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 393 return renderNode->stagingProperties().getRotationY(); 394} 395 396static jboolean android_view_RenderNode_isPivotExplicitlySet(JNIEnv* env, 397 jobject clazz, jlong renderNodePtr) { 398 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 399 return renderNode->stagingProperties().isPivotExplicitlySet(); 400} 401 402static jboolean android_view_RenderNode_hasIdentityMatrix(JNIEnv* env, 403 jobject clazz, jlong renderNodePtr) { 404 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 405 renderNode->mutateStagingProperties().updateMatrix(); 406 return !renderNode->stagingProperties().hasTransformMatrix(); 407} 408 409// ---------------------------------------------------------------------------- 410// RenderProperties - computed getters 411// ---------------------------------------------------------------------------- 412 413static void android_view_RenderNode_getTransformMatrix(JNIEnv* env, 414 jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) { 415 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 416 SkMatrix* outMatrix = reinterpret_cast<SkMatrix*>(outMatrixPtr); 417 418 renderNode->mutateStagingProperties().updateMatrix(); 419 const SkMatrix* transformMatrix = renderNode->stagingProperties().getTransformMatrix(); 420 421 if (transformMatrix) { 422 *outMatrix = *transformMatrix; 423 } else { 424 outMatrix->setIdentity(); 425 } 426} 427 428static void android_view_RenderNode_getInverseTransformMatrix(JNIEnv* env, 429 jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) { 430 // load transform matrix 431 android_view_RenderNode_getTransformMatrix(env, clazz, renderNodePtr, outMatrixPtr); 432 SkMatrix* outMatrix = reinterpret_cast<SkMatrix*>(outMatrixPtr); 433 434 // return it inverted 435 if (!outMatrix->invert(outMatrix)) { 436 // failed to load inverse, pass back identity 437 outMatrix->setIdentity(); 438 } 439} 440 441static jfloat android_view_RenderNode_getPivotX(JNIEnv* env, 442 jobject clazz, jlong renderNodePtr) { 443 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 444 renderNode->mutateStagingProperties().updateMatrix(); 445 return renderNode->stagingProperties().getPivotX(); 446} 447 448static jfloat android_view_RenderNode_getPivotY(JNIEnv* env, 449 jobject clazz, jlong renderNodePtr) { 450 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 451 renderNode->mutateStagingProperties().updateMatrix(); 452 return renderNode->stagingProperties().getPivotY(); 453} 454 455// ---------------------------------------------------------------------------- 456// RenderProperties - Animations 457// ---------------------------------------------------------------------------- 458 459static void android_view_RenderNode_addAnimator(JNIEnv* env, jobject clazz, 460 jlong renderNodePtr, jlong animatorPtr) { 461 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 462 RenderPropertyAnimator* animator = reinterpret_cast<RenderPropertyAnimator*>(animatorPtr); 463 renderNode->addAnimator(animator); 464} 465 466static void android_view_RenderNode_endAllAnimators(JNIEnv* env, jobject clazz, 467 jlong renderNodePtr) { 468 RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); 469 renderNode->animators().endAllStagingAnimators(); 470} 471 472#endif // USE_OPENGL_RENDERER 473 474// ---------------------------------------------------------------------------- 475// JNI Glue 476// ---------------------------------------------------------------------------- 477 478const char* const kClassPathName = "android/view/RenderNode"; 479 480static JNINativeMethod gMethods[] = { 481#ifdef USE_OPENGL_RENDERER 482 { "nCreate", "(Ljava/lang/String;)J", (void*) android_view_RenderNode_create }, 483 { "nDestroyRenderNode", "(J)V", (void*) android_view_RenderNode_destroyRenderNode }, 484 { "nSetDisplayListData", "(JJ)V", (void*) android_view_RenderNode_setDisplayListData }, 485 { "nOutput", "(J)V", (void*) android_view_RenderNode_output }, 486 { "nGetDebugSize", "(J)I", (void*) android_view_RenderNode_getDebugSize }, 487 488 { "nSetLayerType", "(JI)Z", (void*) android_view_RenderNode_setLayerType }, 489 { "nSetLayerPaint", "(JJ)Z", (void*) android_view_RenderNode_setLayerPaint }, 490 { "nSetStaticMatrix", "(JJ)Z", (void*) android_view_RenderNode_setStaticMatrix }, 491 { "nSetAnimationMatrix", "(JJ)Z", (void*) android_view_RenderNode_setAnimationMatrix }, 492 { "nSetClipToBounds", "(JZ)Z", (void*) android_view_RenderNode_setClipToBounds }, 493 { "nSetClipBounds", "(JIIII)Z", (void*) android_view_RenderNode_setClipBounds }, 494 { "nSetClipBoundsEmpty", "(J)Z", (void*) android_view_RenderNode_setClipBoundsEmpty }, 495 { "nSetProjectBackwards", "(JZ)Z", (void*) android_view_RenderNode_setProjectBackwards }, 496 { "nSetProjectionReceiver","(JZ)Z", (void*) android_view_RenderNode_setProjectionReceiver }, 497 498 { "nSetOutlineRoundRect", "(JIIIIFF)Z", (void*) android_view_RenderNode_setOutlineRoundRect }, 499 { "nSetOutlineConvexPath", "(JJF)Z", (void*) android_view_RenderNode_setOutlineConvexPath }, 500 { "nSetOutlineEmpty", "(J)Z", (void*) android_view_RenderNode_setOutlineEmpty }, 501 { "nSetOutlineNone", "(J)Z", (void*) android_view_RenderNode_setOutlineNone }, 502 { "nHasShadow", "(J)Z", (void*) android_view_RenderNode_hasShadow }, 503 { "nSetClipToOutline", "(JZ)Z", (void*) android_view_RenderNode_setClipToOutline }, 504 { "nSetRevealClip", "(JZFFF)Z", (void*) android_view_RenderNode_setRevealClip }, 505 506 { "nSetAlpha", "(JF)Z", (void*) android_view_RenderNode_setAlpha }, 507 { "nSetHasOverlappingRendering", "(JZ)Z", 508 (void*) android_view_RenderNode_setHasOverlappingRendering }, 509 { "nSetElevation", "(JF)Z", (void*) android_view_RenderNode_setElevation }, 510 { "nSetTranslationX", "(JF)Z", (void*) android_view_RenderNode_setTranslationX }, 511 { "nSetTranslationY", "(JF)Z", (void*) android_view_RenderNode_setTranslationY }, 512 { "nSetTranslationZ", "(JF)Z", (void*) android_view_RenderNode_setTranslationZ }, 513 { "nSetRotation", "(JF)Z", (void*) android_view_RenderNode_setRotation }, 514 { "nSetRotationX", "(JF)Z", (void*) android_view_RenderNode_setRotationX }, 515 { "nSetRotationY", "(JF)Z", (void*) android_view_RenderNode_setRotationY }, 516 { "nSetScaleX", "(JF)Z", (void*) android_view_RenderNode_setScaleX }, 517 { "nSetScaleY", "(JF)Z", (void*) android_view_RenderNode_setScaleY }, 518 { "nSetPivotX", "(JF)Z", (void*) android_view_RenderNode_setPivotX }, 519 { "nSetPivotY", "(JF)Z", (void*) android_view_RenderNode_setPivotY }, 520 { "nSetCameraDistance", "(JF)Z", (void*) android_view_RenderNode_setCameraDistance }, 521 { "nSetLeft", "(JI)Z", (void*) android_view_RenderNode_setLeft }, 522 { "nSetTop", "(JI)Z", (void*) android_view_RenderNode_setTop }, 523 { "nSetRight", "(JI)Z", (void*) android_view_RenderNode_setRight }, 524 { "nSetBottom", "(JI)Z", (void*) android_view_RenderNode_setBottom }, 525 { "nSetLeftTopRightBottom","(JIIII)Z", (void*) android_view_RenderNode_setLeftTopRightBottom }, 526 { "nOffsetLeftAndRight", "(JI)Z", (void*) android_view_RenderNode_offsetLeftAndRight }, 527 { "nOffsetTopAndBottom", "(JI)Z", (void*) android_view_RenderNode_offsetTopAndBottom }, 528 529 { "nHasOverlappingRendering", "(J)Z", (void*) android_view_RenderNode_hasOverlappingRendering }, 530 { "nGetClipToOutline", "(J)Z", (void*) android_view_RenderNode_getClipToOutline }, 531 { "nGetAlpha", "(J)F", (void*) android_view_RenderNode_getAlpha }, 532 { "nGetCameraDistance", "(J)F", (void*) android_view_RenderNode_getCameraDistance }, 533 { "nGetScaleX", "(J)F", (void*) android_view_RenderNode_getScaleX }, 534 { "nGetScaleY", "(J)F", (void*) android_view_RenderNode_getScaleY }, 535 { "nGetElevation", "(J)F", (void*) android_view_RenderNode_getElevation }, 536 { "nGetTranslationX", "(J)F", (void*) android_view_RenderNode_getTranslationX }, 537 { "nGetTranslationY", "(J)F", (void*) android_view_RenderNode_getTranslationY }, 538 { "nGetTranslationZ", "(J)F", (void*) android_view_RenderNode_getTranslationZ }, 539 { "nGetRotation", "(J)F", (void*) android_view_RenderNode_getRotation }, 540 { "nGetRotationX", "(J)F", (void*) android_view_RenderNode_getRotationX }, 541 { "nGetRotationY", "(J)F", (void*) android_view_RenderNode_getRotationY }, 542 { "nIsPivotExplicitlySet", "(J)Z", (void*) android_view_RenderNode_isPivotExplicitlySet }, 543 { "nHasIdentityMatrix", "(J)Z", (void*) android_view_RenderNode_hasIdentityMatrix }, 544 545 { "nGetTransformMatrix", "(JJ)V", (void*) android_view_RenderNode_getTransformMatrix }, 546 { "nGetInverseTransformMatrix","(JJ)V", (void*) android_view_RenderNode_getInverseTransformMatrix }, 547 548 { "nGetPivotX", "(J)F", (void*) android_view_RenderNode_getPivotX }, 549 { "nGetPivotY", "(J)F", (void*) android_view_RenderNode_getPivotY }, 550 551 { "nAddAnimator", "(JJ)V", (void*) android_view_RenderNode_addAnimator }, 552 { "nEndAllAnimators", "(J)V", (void*) android_view_RenderNode_endAllAnimators }, 553#endif 554}; 555 556int register_android_view_RenderNode(JNIEnv* env) { 557 return RegisterMethodsOrDie(env, kClassPathName, gMethods, NELEM(gMethods)); 558} 559 560}; 561 562