ViewGroup

Defines whether a child is limited to draw inside of its bounds or not. This is useful with animations that scale the size of the children to more than 100% for instance. In such a case, this property should be set to false to allow the children to draw outside of their bounds. The default value of this property is true.

Must be a boolean value, either "true" or "false".

This may also be a reference to a resource (in the form "@[package:]type:name") or theme attribute (in the form "?[package:][type:]name") containing a value of this type.

This corresponds to the global attribute resource symbol clipChildren.

Defines whether the ViewGroup will clip its drawing surface so as to exclude the padding area. This property is set to true by default.

Must be a boolean value, either "true" or "false".

This may also be a reference to a resource (in the form "@[package:]type:name") or theme attribute (in the form "?[package:][type:]name") containing a value of this type.

This corresponds to the global attribute resource symbol clipToPadding.

We clip to padding when FLAG_CLIP_TO_PADDING and FLAG_PADDING_NOT_NULL are set at the same time.

When set, the drawing method will call getChildDrawingOrder(int, int) to get the index of the child to draw for that iteration.

This view will get focus only if none of its descendants want it.

This view will get focus before any of its descendants.

This view will block any of its descendants from getting focus, even if they are focusable.

Used to indicate that all drawing caches should be kept in memory.

Used to indicate that the animation drawing cache should be kept in memory.

Used to indicate that no drawing cache should be kept in memory.

Used to indicate that the scrolling drawing cache should be kept in memory.

Add any focusable views that are descendants of this view (possibly including this view if it is focusable itself) to views. If we are in touch mode, only add views that are also focusable in touch mode.

Returns whether this ViewGroup's drawable states also include its children's drawable states. This is used, for example, to make a group appear to be focused when its child EditText or button is focused.

Add any touchable views that are descendants of this view (possibly including this view if it is touchable itself) to views.

Adds a child view. If no layout parameters are already set on the child, the default parameters for this ViewGroup are set on the child.

Adds a child view with this ViewGroup's default layout parameters and the specified width and height.

Adds a child view with the specified layout parameters.

Adds a child view with the specified layout parameters.

Adds a child view. If no layout parameters are already set on the child, the default parameters for this ViewGroup are set on the child.

Change the z order of the child so it's on top of all other children

If {link #addStatesFromChildren} is true, refreshes this group's drawable state (to include the states from its children).

Called when a child of this parent is giving up focus

Removes any pending animations for views that have been removed. Call this if you don't want animations for exiting views to stack up.

Called when this view wants to give up focus. This will cause onFocusChanged(boolean, int, Rect) to be called.

Dispatch a key event to the next view on the focus path. This path runs from the top of the view tree down to the currently focused view. If this view has focus, it will dispatch to itself. Otherwise it will dispatch the next node down the focus path. This method also fires any key listeners.

Dispatch a key event before it is processed by any input method associated with the view hierarchy. This can be used to intercept key events in special situations before the IME consumes them; a typical example would be handling the BACK key to update the application's UI instead of allowing the IME to see it and close itself.

Dispatches a key shortcut event.

Dispatch setSelected to all of this View's children.

Pass the touch screen motion event down to the target view, or this view if it is the target.

Pass a trackball motion event down to the focused view.

This method is the last chance for the focused view and its ancestors to respond to an arrow key. This is called when the focused view did not consume the key internally, nor could the view system find a new view in the requested direction to give focus to.

Called when the window containing this view gains or loses window focus. ViewGroups should override to route to their children.

Dispatch a window visibility change down the view hierarchy. ViewGroups should override to route to their children.

Find the view in the hierarchy rooted at this view that currently has focus.

Find the nearest view in the specified direction that wants to take focus.

Tells the parent that a new focusable view has become available. This is to handle transitions from the case where there are no focusable views to the case where the first focusable view appears.

This is used by the RootView to perform an optimization when the view hierarchy contains one or several SurfaceView. SurfaceView is always considered transparent, but its children are not, therefore all View objects remove themselves from the global transparent region (passed as a parameter to this function).

Returns a new set of layout parameters based on the supplied attributes set.

Returns the view at the specified position in the group.

Returns the number of children in the group.

Does the hard part of measureChildren: figuring out the MeasureSpec to pass to a particular child. This method figures out the right MeasureSpec for one dimension (height or width) of one child view. The goal is to combine information from our MeasureSpec with the LayoutParams of the child to get the best possible results. For example, if the this view knows its size (because its MeasureSpec has a mode of EXACTLY), and the child has indicated in its LayoutParams that it wants to be the same size as the parent, the parent should ask the child to layout given an exact size.

Gets the descendant focusability of this view group. The descendant focusability defines the relationship between this view group and its descendants when looking for a view to take focus in requestFocus(int, android.graphics.Rect).

Returns the focused child of this view, if any. The child may have focus or contain focus.

Returns the layout animation controller used to animate the group's children.

Returns the animation listener to which layout animation events are sent.

Returns an integer indicating what types of drawing caches are kept in memory.

Returns true if this view has or contains focus

Returns true if this view is focusable or if it contains a reachable View for which hasFocusable() returns true. A "reachable hasFocusable()" is a View whose parents do not block descendants focus. Only VISIBLE views are considered focusable.

Returns the position in the group of the specified child view.

Don't call or override this method. It is used for the implementation of the view hierarchy.

Don't call or override this method. It is used for the implementation of the view hierarchy. This implementation returns null if this ViewGroup does not have a parent, if this ViewGroup is already fully invalidated or if the dirty rectangle does not intersect with this ViewGroup's bounds.

Indicates whether this ViewGroup will always try to draw its children using their drawing cache. By default this property is enabled.

Indicates whether the children's drawing cache is used during a layout animation. By default, the drawing cache is enabled but this will prevent nested layout animations from working. To nest animations, you must disable the cache.

Offset a rectangle that is in a descendant's coordinate space into our coordinate space.

Offset a rectangle that is in our coordinate space into an ancestor's coordinate space.

Implement this method to intercept all touch screen motion events. This allows you to watch events as they are dispatched to your children, and take ownership of the current gesture at any point.

Using this function takes some care, as it has a fairly complicated interaction with View.onTouchEvent(MotionEvent), and using it requires implementing that method as well as this one in the correct way. Events will be received in the following order:

1. You will receive the down event here.
2. The down event will be handled either by a child of this view group, or given to your own onTouchEvent() method to handle; this means you should implement onTouchEvent() to return true, so you will continue to see the rest of the gesture (instead of looking for a parent view to handle it). Also, by returning true from onTouchEvent(), you will not receive any following events in onInterceptTouchEvent() and all touch processing must happen in onTouchEvent() like normal.
3. For as long as you return false from this function, each following event (up to and including the final up) will be delivered first here and then to the target's onTouchEvent().
4. If you return true from here, you will not receive any following events: the target view will receive the same event but with the action ACTION_CANCEL, and all further events will be delivered to your onTouchEvent() method and no longer appear here.

Tell view hierarchy that the global view attributes need to be re-evaluated.

Call this method to remove all child views from the ViewGroup.

Called by a ViewGroup subclass to remove child views from itself, when it must first know its size on screen before it can calculate how many child views it will render. An example is a Gallery or a ListView, which may "have" 50 children, but actually only render the number of children that can currently fit inside the object on screen. Do not call this method unless you are extending ViewGroup and understand the view measuring and layout pipeline.

Removes the view at the specified position in the group.

Removes a view during layout. This is useful if in your onLayout() method, you need to remove more views.

Removes the specified range of views from the group.

Removes a range of views during layout. This is useful if in your onLayout() method, you need to remove more views.

Called when a child of this parent wants focus

Called when a child of this group wants a particular rectangle to be positioned onto the screen. ViewGroups overriding this can trust that:

• child will be a direct child of this group
• rectangle will be in the child's coordinates

ViewGroups overriding this should uphold the contract:

• nothing will change if the rectangle is already visible
• the view port will be scrolled only just enough to make the rectangle visible

Called when a child does not want this parent and its ancestors to intercept touch events with onInterceptTouchEvent(MotionEvent).

This parent should pass this call onto its parents. This parent must obey this request for the duration of the touch (that is, only clear the flag after this parent has received an up or a cancel.

Call this to try to give focus to a specific view or to one of its descendants and give it hints about the direction and a specific rectangle that the focus is coming from. The rectangle can help give larger views a finer grained hint about where focus is coming from, and therefore, where to show selection, or forward focus change internally. A view will not actually take focus if it is not focusable (isFocusable() returns false), or if it is focusable and it is not focusable in touch mode (isFocusableInTouchMode()) while the device is in touch mode. A View will not take focus if it is not visible. A View will not take focus if one of its parents has getDescendantFocusability() equal to FOCUS_BLOCK_DESCENDANTS. See also focusSearch(int), which is what you call to say that you have focus, and you want your parent to look for the next one. You may wish to override this method if your custom View has an internal View that it wishes to forward the request to. Looks for a view to give focus to respecting the setting specified by getDescendantFocusability(). Uses onRequestFocusInDescendants(int, android.graphics.Rect) to find focus within the children of this group when appropriate.

Called when a child wants the view hierarchy to gather and report transparent regions to the window compositor. Views that "punch" holes in the view hierarchy, such as SurfaceView can use this API to improve performance of the system. When no such a view is present in the hierarchy, this optimization in unnecessary and might slightly reduce the view hierarchy performance.

Schedules the layout animation to be played after the next layout pass of this view group. This can be used to restart the layout animation when the content of the view group changes or when the activity is paused and resumed.

Sets whether this ViewGroup's drawable states also include its children's drawable states. This is used, for example, to make a group appear to be focused when its child EditText or button is focused.

Indicates whether this ViewGroup will always try to draw its children using their drawing cache. This property can be set to true when the cache rendering is slightly different from the children's normal rendering. Renderings can be different, for instance, when the cache's quality is set to low. When this property is disabled, the ViewGroup will use the drawing cache of its children only when asked to. It's usually the task of subclasses to tell ViewGroup when to start using the drawing cache and when to stop using it.

Enables or disables the children's drawing cache during a layout animation. By default, the drawing cache is enabled but this will prevent nested layout animations from working. To nest animations, you must disable the cache.

By default, children are clipped to their bounds before drawing. This allows view groups to override this behavior for animations, etc.

By default, children are clipped to the padding of the ViewGroup. This allows view groups to override this behavior

Set the descendant focusability of this view group. This defines the relationship between this view group and its descendants when looking for a view to take focus in requestFocus(int, android.graphics.Rect).

Sets the layout animation controller used to animate the group's children after the first layout.

Specifies the animation listener to which layout animation events must be sent. Only onAnimationStart(Animation) and onAnimationEnd(Animation) are invoked.

Register a callback to be invoked when a child is added to or removed from this view.

Sets the padding. The view may add on the space required to display the scrollbars, depending on the style and visibility of the scrollbars. So the values returned from getPaddingLeft(), getPaddingTop(), getPaddingRight() and getPaddingBottom() may be different from the values set in this call.

Indicates what types of drawing caches should be kept in memory after they have been created.

Bring up a context menu for the specified view or its ancestors.

In most cases, a subclass does not need to override this. However, if the subclass is added directly to the window manager (for example, addView(View, android.view.ViewGroup.LayoutParams)) then it should override this and show the context menu.

Runs the layout animation. Calling this method triggers a relayout of this view group.

Adds a view during layout. This is useful if in your onLayout() method, you need to add more views (as does the list view for example). If index is negative, it means put it at the end of the list.

Adds a view during layout. This is useful if in your onLayout() method, you need to add more views (as does the list view for example). If index is negative, it means put it at the end of the list.

Subclasses should override this method to set layout animation parameters on the supplied child.

Attaches a view to this view group. Attaching a view assigns this group as the parent, sets the layout parameters and puts the view in the list of children so it can be retrieved by calling getChildAt(int). This method should be called only for view which were detached from their parent.

Indicates whether the view group has the ability to animate its children after the first layout.

Prevents the specified child to be laid out during the next layout pass.

Prints information about this view in the log output, with the tag VIEW_LOG_TAG. Each line in the output is preceded with an indentation defined by the depth.

Detaches all views from the parent. Detaching a view should be temporary and followed either by a call to attachViewToParent(View, int, android.view.ViewGroup.LayoutParams) or a call to removeDetachedView(View, boolean). When a view is detached, its parent is null and cannot be retrieved by a call to getChildAt(int).

Detaches a view from its parent. Detaching a view should be temporary and followed either by a call to attachViewToParent(View, int, android.view.ViewGroup.LayoutParams) or a call to removeDetachedView(View, boolean). When a view is detached, its parent is null and cannot be retrieved by a call to getChildAt(int).

Detaches a view from its parent. Detaching a view should be temporary and followed either by a call to attachViewToParent(View, int, android.view.ViewGroup.LayoutParams) or a call to removeDetachedView(View, boolean). When a view is detached, its parent is null and cannot be retrieved by a call to getChildAt(int).

Detaches a range of view from their parent. Detaching a view should be temporary and followed either by a call to attachViewToParent(View, int, android.view.ViewGroup.LayoutParams) or a call to removeDetachedView(View, boolean). When a view is detached, its parent is null and cannot be retrieved by a call to getChildAt(int).

Called by draw to draw the child views. This may be overridden by derived classes to gain control just before its children are drawn (but after its own view has been drawn).

Perform dispatching of a freeze() to only this view, not to its children. For use when overriding dispatchFreeze() to allow subclasses to freeze their own state but not the state of their children.

Called by restoreHierarchyState(SparseArray) to retrieve the state for this view and its children. May be overridden to modify how restoreing happens to a view's children; for example, some views may want to not store state for their children.

Called by saveHierarchyState(SparseArray) to store the state for this view and its children. May be overridden to modify how freezing happens to a view's children; for example, some views may want to not store state for their children.

Dispatch setPressed to all of this View's children.

Perform dispatching of a thaw() to only this view, not to its children. For use when overriding dispatchThaw() to allow subclasses to thaw their own state but not the state of their children.

Draw one child of this View Group. This method is responsible for getting the canvas in the right state. This includes clipping, translating so that the child's scrolled origin is at 0, 0, and applying any animation transformations.

This function is called whenever the state of the view changes in such a way that it impacts the state of drawables being shown.

Be sure to call through to the superclass when overriding this function.

Apply the insets for system windows to this view, if the FITS_SYSTEM_WINDOWS flag is set

Returns a set of default layout parameters. These parameters are requested when the View passed to addView(View) has no layout parameters already set. If null is returned, an exception is thrown from addView.

Returns a safe set of layout parameters based on the supplied layout params. When a ViewGroup is passed a View whose layout params do not pass the test of checkLayoutParams(android.view.ViewGroup.LayoutParams), this method is invoked. This method should return a new set of layout params suitable for this ViewGroup, possibly by copying the appropriate attributes from the specified set of layout params.

Returns the index of the child to draw for this iteration. Override this if you want to change the drawing order of children. By default, it returns i.

NOTE: In order for this method to be called, the FLAG_USE_CHILD_DRAWING_ORDER must be set.

Indicates whether the ViewGroup is currently drawing its children using their drawing cache.

Ask one of the children of this view to measure itself, taking into account both the MeasureSpec requirements for this view and its padding. The heavy lifting is done in getChildMeasureSpec.

Ask one of the children of this view to measure itself, taking into account both the MeasureSpec requirements for this view and its padding and margins. The child must have MarginLayoutParams The heavy lifting is done in getChildMeasureSpec.

Ask all of the children of this view to measure themselves, taking into account both the MeasureSpec requirements for this view and its padding. We skip children that are in the GONE state The heavy lifting is done in getChildMeasureSpec.

Invoked by a parent ViewGroup to notify the end of the animation currently associated with this view. If you override this method, always call super.onAnimationEnd();

Invoked by a parent ViewGroup to notify the start of the animation currently associated with this view. If you override this method, always call super.onAnimationStart();

Generate the new Drawable state for this view. This is called by the view system when the cached Drawable state is determined to be invalid. To retrieve the current state, you should use getDrawableState().

Called from layout when this view should assign a size and position to each of its children. Derived classes with children should override this method and call layout on each of their their children.

Look for a descendant to call requestFocus() on. Called by requestFocus(int, android.graphics.Rect) when it wants to request focus within its children. Override this to customize how your ViewGroup requests focus within its children.

Finishes the removal of a detached view. This method will dispatch the detached from window event and notify the hierarchy change listener.

Enables or disables the drawing cache for each child of this view group.

Tells the ViewGroup to draw its children using their drawing cache. This property is ignored when isAlwaysDrawnWithCacheEnabled() is true. A child's drawing cache will be used only if it has been enabled. Subclasses should call this method to start and stop using the drawing cache when they perform performance sensitive operations, like scrolling or animating.

When this property is set to true, this ViewGroup supports static transformations on children; this causes getChildStaticTransformation(View, android.view.animation.Transformation) to be invoked when a child is drawn. Any subclass overriding getChildStaticTransformation(View, android.view.animation.Transformation) should set this property to true.