Package icyllis.modernui.graphics

# Class RenderProperties

java.lang.Object
icyllis.modernui.graphics.RenderProperties

Direct Known Subclasses:
  `RenderNode`

public class RenderProperties extends Object
Data structure that holds the properties for a RenderNode.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `RenderProperties()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `float`
  `getAlpha()`
  Returns the translucency level of this RenderNode.
  `Matrix`
  `getAnimationMatrix()`
  Returns the previously set animation matrix.
  `int`
  `getBottom()`
  Gets the bottom position for the RenderNode.
  `float`
  `getCameraDistance()`
  Returns the distance in Z of the camera for this RenderNode
  `boolean`
  `getClipToBounds()`
  Returns whether the RenderNode is clipping to its bounds.
  `float`
  `getElevation()`
  See `setElevation(float)`
  `boolean`
  `getHasOverlappingRendering()`
  Indicates whether the content of this RenderNode overlaps.
  `int`
  `getHeight()`
  Gets the height of the RenderNode, which is the bottom - top.
  `Matrix`
  `getInverseMatrix()`
  Gets the current transform inverted.
  `int`
  `getLayerAlpha()`
  Returns the alpha value if a compositing layer is used.
  `BlendMode`
  `getLayerBlendMode()`
  Returns the blend mode if a compositing layer is used.
  `int`
  `getLeft()`
  Gets the left position for the RenderNode.
  `Matrix`
  `getMatrix()`
  Gets the current transform matrix.
  `float`
  `getPivotX()`
  Returns the pivot value for this RenderNode on the X axis, in pixels.
  `float`
  `getPivotY()`
  Returns the pivot value for this RenderNode on the Y axis, in pixels.
  `int`
  `getRight()`
  Gets the right position for the RenderNode.
  `float`
  `getRotationX()`
  Returns the rotation value for this RenderNode around the X axis, in degrees.
  `float`
  `getRotationY()`
  Returns the rotation value for this RenderNode around the Y axis, in degrees.
  `float`
  `getRotationZ()`
  Returns the rotation value for this RenderNode around the Z axis, in degrees.
  `float`
  `getScaleX()`
  Returns the scale value for this RenderNode on the X axis.
  `float`
  `getScaleY()`
  Returns the scale value for this RenderNode on the Y axis.
  `int`
  `getTop()`
  Gets the top position for the RenderNode.
  `float`
  `getTranslationX()`
  Returns the translation value for this RenderNode on the X axis, in pixels.
  `float`
  `getTranslationY()`
  Returns the translation value for this RenderNode on the Y axis, in pixels.
  `float`
  `getTranslationZ()`
  Returns the translation value for this RenderNode on the Z axis.
  `boolean`
  `getUseCompositingLayer()`
  Gets whether a compositing layer is forced to be used.
  `boolean`
  `getUseTransientLayer()`
  Gets whether a compositing layer should be used.
  `int`
  `getWidth()`
  Gets the width of the RenderNode, which is the right - left.
  `float`
  `getX()`
  The visual x position of this view, in pixels.
  `float`
  `getY()`
  The visual y position of this view, in pixels.
  `float`
  `getZ()`
  The visual z position of this view, in pixels.
  `boolean`
  `isCameraDistanceExplicitlySet()`
  `boolean`
  `isPivotExplicitlySet()`
  `boolean`
  `offsetLeftAndRight(int offset)`
  Offsets the left and right positions for the RenderNode
  `boolean`
  `offsetTopAndBottom(int offset)`
  Offsets the top and bottom values for the RenderNode
  `boolean`
  `resetCameraDistance()`
  Clears any camera distance previously set by a call to `setCameraDistance(float)`.
  `boolean`
  `resetPivot()`
  Clears any pivot previously set by a call to `setPivotX(float)` or `setPivotY(float)`.
  `boolean`
  `setAlpha(float alpha)`
  Sets the translucency level for the RenderNode.
  `boolean`
  `setAnimationMatrix(Matrix matrix)`
  Set the animation matrix on the RenderNode.
  `boolean`
  `setBottom(int bottom)`
  Sets the bottom position for the RenderNode.
  `boolean`
  `setCameraDistance(float distance)`
  Sets the distance along the Z axis (orthogonal to the X/Y plane on which RenderNodes are drawn) from the camera to this RenderNode.
  `boolean`
  `setClipBounds(Rect clipBounds)`
  Sets an additional clip on the RenderNode.
  `boolean`
  `setClipToBounds(boolean clipToBounds)`
  Set whether the RenderNode should clip itself to its bounds.
  `boolean`
  `setElevation(float lift)`
  Sets the base elevation of this RenderNode in pixels
  `boolean`
  `setHasOverlappingRendering(boolean hasOverlappingRendering)`
  Sets whether the RenderNode renders content which overlaps.
  `boolean`
  `setLeft(int left)`
  Sets the left position for the RenderNode.
  `boolean`
  `setPivotX(float pivotX)`
  Sets the pivot value for the RenderNode on the X axis
  `boolean`
  `setPivotY(float pivotY)`
  Sets the pivot value for the RenderNode on the Y axis
  `boolean`
  `setPosition(int left, int top, int right, int bottom)`
  Sets the position of the RenderNode.
  `boolean`
  `setPosition(Rect position)`
  Sets the position of the RenderNode.
  `boolean`
  `setRight(int right)`
  Sets the right position for the RenderNode.
  `boolean`
  `setRotationX(float rotationX)`
  Sets the rotation value for the RenderNode around the X axis.
  `boolean`
  `setRotationY(float rotationY)`
  Sets the rotation value for the RenderNode around the Y axis.
  `boolean`
  `setRotationZ(float rotationZ)`
  Sets the rotation value for the RenderNode around the Z axis.
  `boolean`
  `setScaleX(float scaleX)`
  Sets the scale value for the RenderNode on the X axis.
  `boolean`
  `setScaleY(float scaleY)`
  Sets the scale value for the RenderNode on the Y axis.
  `boolean`
  `setTop(int top)`
  Sets the top position for the RenderNode.
  `boolean`
  `setTranslationX(float translationX)`
  Sets the translation value for the RenderNode on the X axis.
  `boolean`
  `setTranslationY(float translationY)`
  Sets the translation value for the RenderNode on the Y axis.
  `boolean`
  `setTranslationZ(float translationZ)`
  Sets the translation value for the RenderNode on the Z axis.
  `boolean`
  `setUseCompositingLayer(boolean forceToLayer, Paint paint)`
  Controls whether to force this RenderNode to render to an intermediate render target.
  `boolean`
  `setX(float x)`
  Sets the visual x position of this view, in pixels.
  `boolean`
  `setY(float y)`
  Sets the visual y position of this view, in pixels.
  `boolean`
  `setZ(float z)`
  Sets the visual z position of this view, in pixels.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### RenderProperties

    public RenderProperties()

- ## Method Details

  - ### getMatrix

    @Nullable public Matrix getMatrix()
    Gets the current transform matrix. The return value may be null, indicating that it is identity. Note that the returned matrix is READ-ONLY currently. If you want to record this matrix, you need to make a copy.
    Returns:
      The current transform matrix, may be null

  - ### getInverseMatrix

    @Nullable public Matrix getInverseMatrix()
    Gets the current transform inverted. The return value may be null, indicating that it is identity. Note that the returned matrix is READ-ONLY currently. If you want to record this matrix, you need to make a copy.
    Returns:
      The inverse of current transform matrix, may be null

  - ### setUseCompositingLayer

    public boolean setUseCompositingLayer(boolean forceToLayer, @Nullable Paint paint)
    Controls whether to force this RenderNode to render to an intermediate render target. Internally RenderNode will already promote itself to a composition layer if it's useful for performance or required for the current combination of `setAlpha(float)` and `setHasOverlappingRendering(boolean)`.

    The usage of this is instead to allow for either overriding of the internal behavior if it's measured to be necessary for the particular rendering content in question or, more usefully, to add a composition effect to the RenderNode via the optional paint parameter.

    Note: When a RenderNode is using a compositing layer it will also result in clipToBounds=true behavior.

    Parameters:
      `forceToLayer` - if true this forces the RenderNode to use an intermediate buffer. Default invalid input: '&' generally recommended value is false.
      `paint` - The blend mode, alpha, and ColorFilter to apply to the compositing layer. Only applies if forceToLayer is true. The paint's alpha is multiplied with `getAlpha()` to resolve the final alpha of the RenderNode. If null then no additional composition effects are applied on top of the composition layer.
    Returns:
      True if the value changed, false if the new value was the same as the previous value.

  - ### getUseCompositingLayer

    public boolean getUseCompositingLayer()
    Gets whether a compositing layer is forced to be used. The default invalid input: '&' recommended is false, as it is typically faster to avoid using compositing layers. See `setUseCompositingLayer(boolean, Paint)`.
    Returns:
      true if a compositing layer is forced, false otherwise

  - ### getUseTransientLayer

    public boolean getUseTransientLayer()
    Gets whether a compositing layer should be used. This pushes the RenderNode into a cached color buffer stack and avoids creating a new layer.
    Returns:
      true if a compositing layer should be used, false otherwise

  - ### getLayerAlpha

    public int getLayerAlpha()
    Returns the alpha value if a compositing layer is used. This alpha is multiplied with `getAlpha()` to resolve the final alpha of the RenderNode.
    Returns:
      the layer's alpha

  - ### getLayerBlendMode

    public BlendMode getLayerBlendMode()
    Returns the blend mode if a compositing layer is used.
    Returns:
      the layer's blend mode

  - ### setClipBounds

    public boolean setClipBounds(@Nullable Rect clipBounds)
    Sets an additional clip on the RenderNode. If null, the extra clip is removed from the RenderNode. If non-null, the RenderNode will be clipped to this rect. In addition, if `setClipToBounds(boolean)` is true, then the RenderNode will be clipped to the intersection of this rectangle and the bounds of the RenderNode, which is set with `setPosition(Rect)`.
    Parameters:
      `clipBounds` - the bounds to clip to. If null, the additional clip is removed.
    Returns:
      True if the value changed, false if the new value was the same as the previous value.

  - ### setClipToBounds

    public boolean setClipToBounds(boolean clipToBounds)
    Set whether the RenderNode should clip itself to its bounds. This defaults to true, and is useful to the RenderNode in enable quick-rejection of chunks of the tree as well as better partial invalidation support. Clipping can be further restricted or controlled through the combination of this property as well as `setClipBounds(Rect)`, which allows for a different clipping rectangle to be used in addition to or instead of the `setPosition(int, int, int, int)` or the RenderNode.
    Parameters:
      `clipToBounds` - true if the RenderNode should clip to its bounds, false otherwise.
    Returns:
      True if the value changed, false if the new value was the same as the previous value.

  - ### getClipToBounds

    public boolean getClipToBounds()
    Returns whether the RenderNode is clipping to its bounds. See `setClipToBounds(boolean)` and `setPosition(int, int, int, int)`
    Returns:
      true if the render node clips to its bounds, false otherwise.

  - ### setAnimationMatrix

    public boolean setAnimationMatrix(@Nullable Matrix matrix)
    Set the animation matrix on the RenderNode. This matrix exists if an animation is currently playing on a View, and is set on the RenderNode during at draw time. When the animation finishes, the matrix should be cleared by sending `null` for the matrix parameter.
    Parameters:
      `matrix` - The matrix, null indicates that the matrix should be cleared.
    See Also:
      - `getAnimationMatrix()`

  - ### getAnimationMatrix

    @Nullable public Matrix getAnimationMatrix()
    Returns the previously set animation matrix. This matrix exists if an animation is currently playing on a View, and is set on the RenderNode during at draw time. Returns `null` when there is no transformation provided by `setAnimationMatrix(Matrix)`.
    Returns:
      the current Animation matrix.
    See Also:
      - `setAnimationMatrix(Matrix)`

  - ### setAlpha

    public boolean setAlpha(float alpha)
    Sets the translucency level for the RenderNode.
    Parameters:
      `alpha` - The translucency of the RenderNode, must be a value between 0.0f and 1.0f
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `getAlpha()`

  - ### getAlpha

    public float getAlpha()
    Returns the translucency level of this RenderNode.
    Returns:
      A value between 0.0f and 1.0f
    See Also:
      - `setAlpha(float)`

  - ### setHasOverlappingRendering

    public boolean setHasOverlappingRendering(boolean hasOverlappingRendering)
    Sets whether the RenderNode renders content which overlaps. Non-overlapping rendering can use a fast path for alpha that avoids rendering to an offscreen buffer. By default, RenderNodes consider they do not have overlapping content.
    Parameters:
      `hasOverlappingRendering` - False if the content is guaranteed to be non-overlapping, true otherwise.
    See Also:
      - `getHasOverlappingRendering()`

  - ### getHasOverlappingRendering

    public boolean getHasOverlappingRendering()
    Indicates whether the content of this RenderNode overlaps.
    Returns:
      True if this RenderNode renders content which overlaps, false otherwise.
    See Also:
      - `setHasOverlappingRendering(boolean)`

  - ### setElevation

    public boolean setElevation(float lift)
    Sets the base elevation of this RenderNode in pixels
    Parameters:
      `lift` - the elevation in pixels
    Returns:
      True if the value changed, false if the new value was the same as the previous value.

  - ### getElevation

    public float getElevation()
    See `setElevation(float)`
    Returns:
      The RenderNode's current elevation

  - ### setTranslationX

    public boolean setTranslationX(float translationX)
    Sets the translation value for the RenderNode on the X axis.
    Parameters:
      `translationX` - The X axis translation value of the RenderNode, in pixels
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `View.setTranslationX(float)`
      - `getTranslationX()`

  - ### getTranslationX

    public float getTranslationX()
    Returns the translation value for this RenderNode on the X axis, in pixels.
    See Also:
      - `setTranslationX(float)`

  - ### setTranslationY

    public boolean setTranslationY(float translationY)
    Sets the translation value for the RenderNode on the Y axis.
    Parameters:
      `translationY` - The Y axis translation value of the RenderNode, in pixels
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `View.setTranslationY(float)`
      - `getTranslationY()`

  - ### getTranslationY

    public float getTranslationY()
    Returns the translation value for this RenderNode on the Y axis, in pixels.
    See Also:
      - `setTranslationY(float)`

  - ### setTranslationZ

    public boolean setTranslationZ(float translationZ)
    Sets the translation value for the RenderNode on the Z axis.
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `View.setTranslationZ(float)`
      - `getTranslationZ()`

  - ### getTranslationZ

    public float getTranslationZ()
    Returns the translation value for this RenderNode on the Z axis.
    See Also:
      - `setTranslationZ(float)`

  - ### setX

    public boolean setX(float x)
    Sets the visual x position of this view, in pixels. This is equivalent to setting the `translationX` property to be the difference between the x value passed in and the current `left` property.
    Parameters:
      `x` - The visual x position of this view, in pixels.

  - ### getX

    public float getX()
    The visual x position of this view, in pixels. This is equivalent to the `translationX` property plus the current `left` property.
    Returns:
      The visual x position of this view, in pixels.

  - ### setY

    public boolean setY(float y)
    Sets the visual y position of this view, in pixels. This is equivalent to setting the `translationY` property to be the difference between the y value passed in and the current `top` property.
    Parameters:
      `y` - The visual y position of this view, in pixels.

  - ### getY

    public float getY()
    The visual y position of this view, in pixels. This is equivalent to the `translationY` property plus the current `top` property.
    Returns:
      The visual y position of this view, in pixels.

  - ### setZ

    public boolean setZ(float z)
    Sets the visual z position of this view, in pixels. This is equivalent to setting the `translationZ` property to be the difference between the z value passed in and the current `elevation` property.
    Parameters:
      `z` - The visual z position of this view, in pixels.

  - ### getZ

    public float getZ()
    The visual z position of this view, in pixels. This is equivalent to the `translationZ` property plus the current `elevation` property.
    Returns:
      The visual z position of this view, in pixels.

  - ### setRotationX

    public boolean setRotationX(float rotationX)
    Sets the rotation value for the RenderNode around the X axis.
    Parameters:
      `rotationX` - The rotation value of the RenderNode, in degrees
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `View.setRotationX(float)`
      - `getRotationX()`

  - ### getRotationX

    public float getRotationX()
    Returns the rotation value for this RenderNode around the X axis, in degrees.
    See Also:
      - `setRotationX(float)`

  - ### setRotationY

    public boolean setRotationY(float rotationY)
    Sets the rotation value for the RenderNode around the Y axis.
    Parameters:
      `rotationY` - The rotation value of the RenderNode, in degrees
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `View.setRotationY(float)`
      - `getRotationY()`

  - ### getRotationY

    public float getRotationY()
    Returns the rotation value for this RenderNode around the Y axis, in degrees.
    See Also:
      - `setRotationY(float)`

  - ### setRotationZ

    public boolean setRotationZ(float rotationZ)
    Sets the rotation value for the RenderNode around the Z axis.
    Parameters:
      `rotationZ` - The rotation value of the RenderNode, in degrees
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `getRotationZ()`

  - ### getRotationZ

    public float getRotationZ()
    Returns the rotation value for this RenderNode around the Z axis, in degrees.
    See Also:
      - `setRotationZ(float)`

  - ### setScaleX

    public boolean setScaleX(float scaleX)
    Sets the scale value for the RenderNode on the X axis.
    Parameters:
      `scaleX` - The scale value of the RenderNode
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `View.setScaleX(float)`
      - `getScaleX()`

  - ### getScaleX

    public float getScaleX()
    Returns the scale value for this RenderNode on the X axis.
    See Also:
      - `setScaleX(float)`

  - ### setScaleY

    public boolean setScaleY(float scaleY)
    Sets the scale value for the RenderNode on the Y axis.
    Parameters:
      `scaleY` - The scale value of the RenderNode
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `View.setScaleY(float)`
      - `getScaleY()`

  - ### getScaleY

    public float getScaleY()
    Returns the scale value for this RenderNode on the Y axis.
    See Also:
      - `setScaleY(float)`

  - ### setPivotX

    public boolean setPivotX(float pivotX)
    Sets the pivot value for the RenderNode on the X axis
    Parameters:
      `pivotX` - The pivot value of the RenderNode on the X axis, in pixels
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `View.setPivotX(float)`
      - `getPivotX()`

  - ### getPivotX

    public float getPivotX()
    Returns the pivot value for this RenderNode on the X axis, in pixels.
    See Also:
      - `setPivotX(float)`

  - ### setPivotY

    public boolean setPivotY(float pivotY)
    Sets the pivot value for the RenderNode on the Y axis
    Parameters:
      `pivotY` - The pivot value of the RenderNode on the Y axis, in pixels
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `View.setPivotY(float)`
      - `getPivotY()`

  - ### getPivotY

    public float getPivotY()
    Returns the pivot value for this RenderNode on the Y axis, in pixels.
    See Also:
      - `setPivotY(float)`

  - ### isPivotExplicitlySet

    public boolean isPivotExplicitlySet()
    Returns:
      Whether a pivot was explicitly set with `setPivotX(float)` or `setPivotY(float)`. If no pivot has been set then the pivot will be the center of the RenderNode.

  - ### resetPivot

    public boolean resetPivot()
    Clears any pivot previously set by a call to `setPivotX(float)` or `setPivotY(float)`. After calling this `isPivotExplicitlySet()` will be false and the pivot used for rotation will return to default of being centered on the view.
    Returns:
      True if the value changed, false if the new value was the same as the previous value.

  - ### setCameraDistance

    public boolean setCameraDistance(@FloatRange(from=0.0,to=3.4028234663852886E38) float distance)

    Sets the distance along the Z axis (orthogonal to the X/Y plane on which RenderNodes are drawn) from the camera to this RenderNode. The camera's distance affects 3D transformations, for instance rotations around the X and Y axis. If the rotationX or rotationY properties are changed and this view is large (more than half the size of the screen), it is recommended to always use a camera distance that's greater than the height (X axis rotation) or the width (Y axis rotation) of this view.

    The distance of the camera from the drawing plane can have an affect on the perspective distortion of the RenderNode when it is rotated around the x or y axis. For example, a large distance will result in a large viewing angle, and there will not be much perspective distortion of the view as it rotates. A short distance may cause much more perspective distortion upon rotation, and can also result in some drawing artifacts if the rotated view ends up partially behind the camera (which is why the recommendation is to use a distance at least as far as the size of the view, if the view is to be rotated.)

    The distance is expressed in pixels and must always be positive

    Parameters:
      `distance` - The distance in pixels, must always be positive
    Returns:
      True if the value changed, false if the new value was the same as the previous value.
    See Also:
      - `setRotationX(float)`
      - `setRotationY(float)`

  - ### getCameraDistance

    @FloatRange(from=0.0, to=3.4028234663852886E38) public float getCameraDistance()
    Returns the distance in Z of the camera for this RenderNode
    Returns:
      the distance along the Z axis in pixels.
    See Also:
      - `setCameraDistance(float)`

  - ### isCameraDistanceExplicitlySet

    public boolean isCameraDistanceExplicitlySet()
    Returns:
      Whether a camera distance was explicitly set with `setCameraDistance(float)`. If no camera distance has been set then the camera distance will be the max(width,height) of the RenderNode.

  - ### resetCameraDistance

    public boolean resetCameraDistance()
    Clears any camera distance previously set by a call to `setCameraDistance(float)`. After calling this `isCameraDistanceExplicitlySet()` will be false and the camera distance used for rotation will return to default to the max(width,height) of the view.
    Returns:
      True if the value changed, false if the new value was the same as the previous value.

  - ### setLeft

    public boolean setLeft(int left)
    Sets the left position for the RenderNode.
    Parameters:
      `left` - The left position, in pixels, of the RenderNode
    Returns:
      true if the value changed, false otherwise

  - ### getLeft

    public int getLeft()
    Gets the left position for the RenderNode.
    Returns:
      the left position in pixels

  - ### setTop

    public boolean setTop(int top)
    Sets the top position for the RenderNode.
    Parameters:
      `top` - The top position, in pixels, of the RenderNode
    Returns:
      true if the value changed, false otherwise.

  - ### getTop

    public int getTop()
    Gets the top position for the RenderNode.
    Returns:
      the top position in pixels

  - ### setRight

    public boolean setRight(int right)
    Sets the right position for the RenderNode.
    Parameters:
      `right` - The right position, in pixels, of the RenderNode
    Returns:
      true if the value changed, false otherwise.

  - ### getRight

    public int getRight()
    Gets the right position for the RenderNode.
    Returns:
      the right position in pixels

  - ### setBottom

    public boolean setBottom(int bottom)
    Sets the bottom position for the RenderNode.
    Parameters:
      `bottom` - The bottom position, in pixels, of the RenderNode
    Returns:
      true if the value changed, false otherwise.

  - ### getBottom

    public int getBottom()
    Gets the bottom position for the RenderNode.
    Returns:
      the bottom position in pixels

  - ### setPosition

    public boolean setPosition(int left, int top, int right, int bottom)
    Sets the position of the RenderNode.
    Parameters:
      `left` - The left position of the RenderNode, in pixels
      `top` - The top position of the RenderNode, in pixels
      `right` - The right position of the RenderNode, in pixels
      `bottom` - The bottom position of the RenderNode, in pixels
    Returns:
      True if the value changed, false if the new value was the same as the previous value.

  - ### setPosition

    public boolean setPosition(@Nonnull Rect position)
    Sets the position of the RenderNode.
    Parameters:
      `position` - The position rectangle in pixels
    Returns:
      True if the value changed, false if the new value was the same as the previous value.

  - ### offsetLeftAndRight

    public boolean offsetLeftAndRight(int offset)
    Offsets the left and right positions for the RenderNode
    Parameters:
      `offset` - The amount that the left and right positions are offset in pixels
    Returns:
      True if the value changed, false if the new value was the same as the previous value.

  - ### offsetTopAndBottom

    public boolean offsetTopAndBottom(int offset)
    Offsets the top and bottom values for the RenderNode
    Parameters:
      `offset` - The amount that the left and right positions are offset in pixels
    Returns:
      True if the value changed, false if the new value was the same as the previous value.

  - ### getWidth

    public int getWidth()
    Gets the width of the RenderNode, which is the right - left.
    Returns:
      the width of the RenderNode

  - ### getHeight

    public int getHeight()
    Gets the height of the RenderNode, which is the bottom - top.
    Returns:
      the height of the RenderNode