FileDocCategorySizeDatePackage
Gravity.javaAPI DocAndroid 5.1 API19917Thu Mar 12 22:22:10 GMT 2015android.view

Gravity

public class Gravity extends Object
Standard constants and tools for placing an object within a potentially larger container.

Fields Summary
public static final int
NO_GRAVITY
Constant indicating that no gravity has been set
public static final int
AXIS_SPECIFIED
Raw bit indicating the gravity for an axis has been specified.
public static final int
AXIS_PULL_BEFORE
Raw bit controlling how the left/top edge is placed.
public static final int
AXIS_PULL_AFTER
Raw bit controlling how the right/bottom edge is placed.
public static final int
AXIS_CLIP
Raw bit controlling whether the right/bottom edge is clipped to its container, based on the gravity direction being applied.
public static final int
AXIS_X_SHIFT
Bits defining the horizontal axis.
public static final int
AXIS_Y_SHIFT
Bits defining the vertical axis.
public static final int
TOP
Push object to the top of its container, not changing its size.
public static final int
BOTTOM
Push object to the bottom of its container, not changing its size.
public static final int
LEFT
Push object to the left of its container, not changing its size.
public static final int
RIGHT
Push object to the right of its container, not changing its size.
public static final int
CENTER_VERTICAL
Place object in the vertical center of its container, not changing its size.
public static final int
FILL_VERTICAL
Grow the vertical size of the object if needed so it completely fills its container.
public static final int
CENTER_HORIZONTAL
Place object in the horizontal center of its container, not changing its size.
public static final int
FILL_HORIZONTAL
Grow the horizontal size of the object if needed so it completely fills its container.
public static final int
CENTER
Place the object in the center of its container in both the vertical and horizontal axis, not changing its size.
public static final int
FILL
Grow the horizontal and vertical size of the object if needed so it completely fills its container.
public static final int
CLIP_VERTICAL
Flag to clip the edges of the object to its container along the vertical axis.
public static final int
CLIP_HORIZONTAL
Flag to clip the edges of the object to its container along the horizontal axis.
public static final int
RELATIVE_LAYOUT_DIRECTION
Raw bit controlling whether the layout direction is relative or not (START/END instead of absolute LEFT/RIGHT).
public static final int
HORIZONTAL_GRAVITY_MASK
Binary mask to get the absolute horizontal gravity of a gravity.
public static final int
VERTICAL_GRAVITY_MASK
Binary mask to get the vertical gravity of a gravity.
public static final int
DISPLAY_CLIP_VERTICAL
Special constant to enable clipping to an overall display along the vertical dimension. This is not applied by default by {@link #apply(int, int, int, Rect, int, int, Rect)}; you must do so yourself by calling {@link #applyDisplay}.
public static final int
DISPLAY_CLIP_HORIZONTAL
Special constant to enable clipping to an overall display along the horizontal dimension. This is not applied by default by {@link #apply(int, int, int, Rect, int, int, Rect)}; you must do so yourself by calling {@link #applyDisplay}.
public static final int
START
Push object to x-axis position at the start of its container, not changing its size.
public static final int
END
Push object to x-axis position at the end of its container, not changing its size.
public static final int
RELATIVE_HORIZONTAL_GRAVITY_MASK
Binary mask for the horizontal gravity and script specific direction bit.
Constructors Summary
Methods Summary
public static voidapply(int gravity, int w, int h, android.graphics.Rect container, android.graphics.Rect outRect)
Apply a gravity constant to an object. This supposes that the layout direction is LTR.

param
gravity The desired placement of the object, as defined by the constants in this class.
param
w The horizontal size of the object.
param
h The vertical size of the object.
param
container The frame of the containing space, in which the object will be placed. Should be large enough to contain the width and height of the object.
param
outRect Receives the computed frame of the object in its container.


                                                                                                                                                                  
                 
        apply(gravity, w, h, container, 0, 0, outRect);
public static voidapply(int gravity, int w, int h, android.graphics.Rect container, android.graphics.Rect outRect, int layoutDirection)
Apply a gravity constant to an object and take care if layout direction is RTL or not.

param
gravity The desired placement of the object, as defined by the constants in this class.
param
w The horizontal size of the object.
param
h The vertical size of the object.
param
container The frame of the containing space, in which the object will be placed. Should be large enough to contain the width and height of the object.
param
outRect Receives the computed frame of the object in its container.
param
layoutDirection The layout direction.
see
View#LAYOUT_DIRECTION_LTR
see
View#LAYOUT_DIRECTION_RTL

        int absGravity = getAbsoluteGravity(gravity, layoutDirection);
        apply(absGravity, w, h, container, 0, 0, outRect);
public static voidapply(int gravity, int w, int h, android.graphics.Rect container, int xAdj, int yAdj, android.graphics.Rect outRect)
Apply a gravity constant to an object.

param
gravity The desired placement of the object, as defined by the constants in this class.
param
w The horizontal size of the object.
param
h The vertical size of the object.
param
container The frame of the containing space, in which the object will be placed. Should be large enough to contain the width and height of the object.
param
xAdj Offset to apply to the X axis. If gravity is LEFT this pushes it to the right; if gravity is RIGHT it pushes it to the left; if gravity is CENTER_HORIZONTAL it pushes it to the right or left; otherwise it is ignored.
param
yAdj Offset to apply to the Y axis. If gravity is TOP this pushes it down; if gravity is BOTTOM it pushes it up; if gravity is CENTER_VERTICAL it pushes it down or up; otherwise it is ignored.
param
outRect Receives the computed frame of the object in its container.

        switch (gravity&((AXIS_PULL_BEFORE|AXIS_PULL_AFTER)<<AXIS_X_SHIFT)) {
            case 0:
                outRect.left = container.left
                        + ((container.right - container.left - w)/2) + xAdj;
                outRect.right = outRect.left + w;
                if ((gravity&(AXIS_CLIP<<AXIS_X_SHIFT))
                        == (AXIS_CLIP<<AXIS_X_SHIFT)) {
                    if (outRect.left < container.left) {
                        outRect.left = container.left;
                    }
                    if (outRect.right > container.right) {
                        outRect.right = container.right;
                    }
                }
                break;
            case AXIS_PULL_BEFORE<<AXIS_X_SHIFT:
                outRect.left = container.left + xAdj;
                outRect.right = outRect.left + w;
                if ((gravity&(AXIS_CLIP<<AXIS_X_SHIFT))
                        == (AXIS_CLIP<<AXIS_X_SHIFT)) {
                    if (outRect.right > container.right) {
                        outRect.right = container.right;
                    }
                }
                break;
            case AXIS_PULL_AFTER<<AXIS_X_SHIFT:
                outRect.right = container.right - xAdj;
                outRect.left = outRect.right - w;
                if ((gravity&(AXIS_CLIP<<AXIS_X_SHIFT))
                        == (AXIS_CLIP<<AXIS_X_SHIFT)) {
                    if (outRect.left < container.left) {
                        outRect.left = container.left;
                    }
                }
                break;
            default:
                outRect.left = container.left + xAdj;
                outRect.right = container.right + xAdj;
                break;
        }
        
        switch (gravity&((AXIS_PULL_BEFORE|AXIS_PULL_AFTER)<<AXIS_Y_SHIFT)) {
            case 0:
                outRect.top = container.top
                        + ((container.bottom - container.top - h)/2) + yAdj;
                outRect.bottom = outRect.top + h;
                if ((gravity&(AXIS_CLIP<<AXIS_Y_SHIFT))
                        == (AXIS_CLIP<<AXIS_Y_SHIFT)) {
                    if (outRect.top < container.top) {
                        outRect.top = container.top;
                    }
                    if (outRect.bottom > container.bottom) {
                        outRect.bottom = container.bottom;
                    }
                }
                break;
            case AXIS_PULL_BEFORE<<AXIS_Y_SHIFT:
                outRect.top = container.top + yAdj;
                outRect.bottom = outRect.top + h;
                if ((gravity&(AXIS_CLIP<<AXIS_Y_SHIFT))
                        == (AXIS_CLIP<<AXIS_Y_SHIFT)) {
                    if (outRect.bottom > container.bottom) {
                        outRect.bottom = container.bottom;
                    }
                }
                break;
            case AXIS_PULL_AFTER<<AXIS_Y_SHIFT:
                outRect.bottom = container.bottom - yAdj;
                outRect.top = outRect.bottom - h;
                if ((gravity&(AXIS_CLIP<<AXIS_Y_SHIFT))
                        == (AXIS_CLIP<<AXIS_Y_SHIFT)) {
                    if (outRect.top < container.top) {
                        outRect.top = container.top;
                    }
                }
                break;
            default:
                outRect.top = container.top + yAdj;
                outRect.bottom = container.bottom + yAdj;
                break;
        }
public static voidapply(int gravity, int w, int h, android.graphics.Rect container, int xAdj, int yAdj, android.graphics.Rect outRect, int layoutDirection)
Apply a gravity constant to an object.

param
gravity The desired placement of the object, as defined by the constants in this class.
param
w The horizontal size of the object.
param
h The vertical size of the object.
param
container The frame of the containing space, in which the object will be placed. Should be large enough to contain the width and height of the object.
param
xAdj Offset to apply to the X axis. If gravity is LEFT this pushes it to the right; if gravity is RIGHT it pushes it to the left; if gravity is CENTER_HORIZONTAL it pushes it to the right or left; otherwise it is ignored.
param
yAdj Offset to apply to the Y axis. If gravity is TOP this pushes it down; if gravity is BOTTOM it pushes it up; if gravity is CENTER_VERTICAL it pushes it down or up; otherwise it is ignored.
param
outRect Receives the computed frame of the object in its container.
param
layoutDirection The layout direction.
see
View#LAYOUT_DIRECTION_LTR
see
View#LAYOUT_DIRECTION_RTL

        int absGravity = getAbsoluteGravity(gravity, layoutDirection);
        apply(absGravity, w, h, container, xAdj, yAdj, outRect);
public static voidapplyDisplay(int gravity, android.graphics.Rect display, android.graphics.Rect inoutObj)
Apply additional gravity behavior based on the overall "display" that an object exists in. This can be used after {@link #apply(int, int, int, Rect, int, int, Rect)} to place the object within a visible display. By default this moves or clips the object to be visible in the display; the gravity flags {@link #DISPLAY_CLIP_HORIZONTAL} and {@link #DISPLAY_CLIP_VERTICAL} can be used to change this behavior.

param
gravity Gravity constants to modify the placement within the display.
param
display The rectangle of the display in which the object is being placed.
param
inoutObj Supplies the current object position; returns with it modified if needed to fit in the display.

        if ((gravity&DISPLAY_CLIP_VERTICAL) != 0) {
            if (inoutObj.top < display.top) inoutObj.top = display.top;
            if (inoutObj.bottom > display.bottom) inoutObj.bottom = display.bottom;
        } else {
            int off = 0;
            if (inoutObj.top < display.top) off = display.top-inoutObj.top;
            else if (inoutObj.bottom > display.bottom) off = display.bottom-inoutObj.bottom;
            if (off != 0) {
                if (inoutObj.height() > (display.bottom-display.top)) {
                    inoutObj.top = display.top;
                    inoutObj.bottom = display.bottom;
                } else {
                    inoutObj.top += off;
                    inoutObj.bottom += off;
                }
            }
        }
        
        if ((gravity&DISPLAY_CLIP_HORIZONTAL) != 0) {
            if (inoutObj.left < display.left) inoutObj.left = display.left;
            if (inoutObj.right > display.right) inoutObj.right = display.right;
        } else {
            int off = 0;
            if (inoutObj.left < display.left) off = display.left-inoutObj.left;
            else if (inoutObj.right > display.right) off = display.right-inoutObj.right;
            if (off != 0) {
                if (inoutObj.width() > (display.right-display.left)) {
                    inoutObj.left = display.left;
                    inoutObj.right = display.right;
                } else {
                    inoutObj.left += off;
                    inoutObj.right += off;
                }
            }
        }
public static voidapplyDisplay(int gravity, android.graphics.Rect display, android.graphics.Rect inoutObj, int layoutDirection)
Apply additional gravity behavior based on the overall "display" that an object exists in. This can be used after {@link #apply(int, int, int, Rect, int, int, Rect)} to place the object within a visible display. By default this moves or clips the object to be visible in the display; the gravity flags {@link #DISPLAY_CLIP_HORIZONTAL} and {@link #DISPLAY_CLIP_VERTICAL} can be used to change this behavior.

param
gravity Gravity constants to modify the placement within the display.
param
display The rectangle of the display in which the object is being placed.
param
inoutObj Supplies the current object position; returns with it modified if needed to fit in the display.
param
layoutDirection The layout direction.
see
View#LAYOUT_DIRECTION_LTR
see
View#LAYOUT_DIRECTION_RTL

        int absGravity = getAbsoluteGravity(gravity, layoutDirection);
        applyDisplay(absGravity, display, inoutObj);
public static intgetAbsoluteGravity(int gravity, int layoutDirection)

Convert script specific gravity to absolute horizontal value.

if horizontal direction is LTR, then START will set LEFT and END will set RIGHT. if horizontal direction is RTL, then START will set RIGHT and END will set LEFT.

param
gravity The gravity to convert to absolute (horizontal) values.
param
layoutDirection The layout direction.
return
gravity converted to absolute (horizontal) values.

        int result = gravity;
        // If layout is script specific and gravity is horizontal relative (START or END)
        if ((result & RELATIVE_LAYOUT_DIRECTION) > 0) {
            if ((result & Gravity.START) == Gravity.START) {
                // Remove the START bit
                result &= ~START;
                if (layoutDirection == View.LAYOUT_DIRECTION_RTL) {
                    // Set the RIGHT bit
                    result |= RIGHT;
                } else {
                    // Set the LEFT bit
                    result |= LEFT;
                }
            } else if ((result & Gravity.END) == Gravity.END) {
                // Remove the END bit
                result &= ~END;
                if (layoutDirection == View.LAYOUT_DIRECTION_RTL) {
                    // Set the LEFT bit
                    result |= LEFT;
                } else {
                    // Set the RIGHT bit
                    result |= RIGHT;
                }
            }
            // Don't need the script specific bit any more, so remove it as we are converting to
            // absolute values (LEFT or RIGHT)
            result &= ~RELATIVE_LAYOUT_DIRECTION;
        }
        return result;
public static booleanisHorizontal(int gravity)

Indicate whether the supplied gravity has an horizontal pull.

param
gravity the gravity to check for horizontal pull
return
true if the supplied gravity has an horizontal pull

        return gravity > 0 && (gravity & RELATIVE_HORIZONTAL_GRAVITY_MASK) != 0;
public static booleanisVertical(int gravity)

Indicate whether the supplied gravity has a vertical pull.

param
gravity the gravity to check for vertical pull
return
true if the supplied gravity has a vertical pull

        return gravity > 0 && (gravity & VERTICAL_GRAVITY_MASK) != 0;