ViewCompat

Live region mode specifying that accessibility services should interrupt ongoing speech to immediately announce changes to this view.

Use with setAccessibilityLiveRegion(View, int).

Live region mode specifying that accessibility services should not automatically announce changes to this view. This is the default live region mode for most views.

Use with setAccessibilityLiveRegion(View, int).

Live region mode specifying that accessibility services should announce changes to this view.

Use with setAccessibilityLiveRegion(View, int).

Automatically determine whether a view is important for accessibility.

The view is not important for accessibility.

The view is not important for accessibility, nor are any of its descendant views.

The view is important for accessibility.

Indicates that the view has a hardware layer. A hardware layer is backed by a hardware specific texture (generally Frame Buffer Objects or FBO on OpenGL hardware) and causes the view to be rendered using Android's hardware rendering pipeline, but only if hardware acceleration is turned on for the view hierarchy. When hardware acceleration is turned off, hardware layers behave exactly as software layers.

A hardware layer is useful to apply a specific color filter and/or blending mode and/or translucency to a view and all its children.

A hardware layer can be used to cache a complex view tree into a texture and reduce the complexity of drawing operations. For instance, when animating a complex view tree with a translation, a hardware layer can be used to render the view tree only once.

A hardware layer can also be used to increase the rendering quality when rotation transformations are applied on a view. It can also be used to prevent potential clipping issues when applying 3D transforms on a view.

Indicates that the view does not have a layer.

Indicates that the view has a software layer. A software layer is backed by a bitmap and causes the view to be rendered using Android's software rendering pipeline, even if hardware acceleration is enabled.

Software layers have various usages:

When the application is not using hardware acceleration, a software layer is useful to apply a specific color filter and/or blending mode and/or translucency to a view and all its children.

When the application is using hardware acceleration, a software layer is useful to render drawing primitives not supported by the hardware accelerated pipeline. It can also be used to cache a complex view tree into a texture and reduce the complexity of drawing operations. For instance, when animating a complex view tree with a translation, a software layer can be used to render the view tree only once.

Software layers should be avoided when the affected view tree updates often. Every update will require to re-render the software layer, which can potentially be slow (particularly when hardware acceleration is turned on since the layer will have to be uploaded into a hardware texture after every update.)

Horizontal layout direction of this view is inherited from its parent. Use with setLayoutDirection(View, int).

Horizontal layout direction of this view is from deduced from the default language script for the locale. Use with setLayoutDirection(View, int).

Horizontal layout direction of this view is from Left to Right.

Horizontal layout direction of this view is from Right to Left.

Bit shift of MEASURED_STATE_MASK to get to the height bits for functions that combine both width and height into a single int, such as getMeasuredState(View) and the childState argument of resolveSizeAndState(int, int, int).

Bits of getMeasuredWidthAndState(View) and getMeasuredWidthAndState(View) that provide the actual measured size.

Bits of getMeasuredWidthAndState(View) and getMeasuredWidthAndState(View) that provide the additional state bits.

Bit of getMeasuredWidthAndState(View) and getMeasuredWidthAndState(View) that indicates the measured size is smaller that the space the view would like to have.

Always allow a user to over-scroll this view, provided it is a view that can scroll.

Allow a user to over-scroll this view only if the content is large enough to meaningfully scroll, provided it is a view that can scroll.

Never allow a user to over-scroll this view.

Indicates scrolling along the horizontal axis.

Indicates no axis of view scrolling.

Indicates scrolling along the vertical axis.

This method returns a ViewPropertyAnimator object, which can be used to animate specific properties on this View.

Prior to API 14, this method will do nothing.

Check if this view can be scrolled horizontally in a certain direction.

Check if this view can be scrolled vertically in a certain direction.

Merge two states as returned by getMeasuredState(View).

Request to apply the given window insets to this view or another view in its subtree.

This method should be called by clients wishing to apply insets corresponding to areas obscured by window decorations or overlays. This can include the status and navigation bars, action bars, input methods and more. New inset categories may be added in the future. The method returns the insets provided minus any that were applied by this view or its children.

Notify a view that its temporary detach has ended; the view is now reattached.

Dispatch a fling to a nested scrolling parent.

This method should be used to indicate that a nested scrolling child has detected suitable conditions for a fling. Generally this means that a touch scroll has ended with a velocity in the direction of scrolling that meets or exceeds the minimum fling velocity along a scrollable axis.

If a nested scrolling child view would normally fling but it is at the edge of its own content, it can use this method to delegate the fling to its nested scrolling parent instead. The parent may optionally consume the fling or observe a child fling.

Dispatch a fling to a nested scrolling parent before it is processed by this view.

Nested pre-fling events are to nested fling events what touch intercept is to touch and what nested pre-scroll is to nested scroll. dispatchNestedPreFling offsets an opportunity for the parent view in a nested fling to fully consume the fling before the child view consumes it. If this method returns true, a nested parent view consumed the fling and this view should not scroll as a result.

For a better user experience, only one view in a nested scrolling chain should consume the fling at a time. If a parent view consumed the fling this method will return false. Custom view implementations should account for this in two ways:

• If a custom view is paged and needs to settle to a fixed page-point, do not call dispatchNestedPreFling; consume the fling and settle to a valid position regardless.
• If a nested parent does consume the fling, this view should not scroll at all, even to settle back to a valid idle position.

Views should also not offer fling velocities to nested parent views along an axis where scrolling is not currently supported; a ScrollView should not offer a horizontal fling velocity to its parents since scrolling along that axis is not permitted and carrying velocity along that motion does not make sense.

Dispatch one step of a nested scroll in progress before this view consumes any portion of it.

Nested pre-scroll events are to nested scroll events what touch intercept is to touch. dispatchNestedPreScroll offers an opportunity for the parent view in a nested scrolling operation to consume some or all of the scroll operation before the child view consumes it.

Dispatch one step of a nested scroll in progress.

Implementations of views that support nested scrolling should call this to report info about a scroll in progress to the current nested scrolling parent. If a nested scroll is not currently in progress or nested scrolling is not enabled for this view this method does nothing.

Compatible View implementations should also call dispatchNestedPreScroll before consuming a component of the scroll event themselves.

Notify a view that it is being temporarily detached.

Gets the live region mode for the specified View.

Gets the provider for managing a virtual view hierarchy rooted at this View and reported to AccessibilityServices that explore the window content.

If this method returns an instance, this instance is responsible for managing AccessibilityNodeInfoCompats describing the virtual sub-tree rooted at this View including the one representing the View itself. Similarly the returned instance is responsible for performing accessibility actions on any virtual view or the root view itself.

If an AccessibilityDelegateCompat has been specified via calling setAccessibilityDelegate(View, AccessibilityDelegateCompat) its getAccessibilityNodeProvider(View) is responsible for handling this call.

The opacity of the view. This is a value from 0 to 1, where 0 means the view is completely transparent and 1 means the view is completely opaque.

By default this is 1.0f. Prior to API 11, the returned value is always 1.0f.

Return the tint applied to the background drawable, if specified.

Only returns meaningful info when running on API v21 or newer, or if view implements the TintableBackgroundView interface.

Return the blending mode used to apply the tint to the background drawable, if specified.

Only returns meaningful info when running on API v21 or newer, or if view implements the TintableBackgroundView interface.

Returns a copy of the current setClipBounds(View, Rect).

Prior to API 18 this will return null.

The base elevation of this view relative to its parent, in pixels.

Returns true if this view should adapt to fit system window insets. This method will always return false before API 16 (Jellybean).

Gets the mode for determining whether this View is important for accessibility which is if it fires accessibility events and if it is reported to accessibility services that query the screen.

Gets the id of a view for which a given view serves as a label for accessibility purposes.

Indicates what type of layer is currently associated with this view. By default a view does not have a layer, and the layer type is LAYER_TYPE_NONE. Refer to the documentation of setLayerType(android.view.View, int, android.graphics.Paint) for more information on the different types of layers.

Returns the resolved layout direction for this view.

Return the full height measurement information for this view as computed by the most recent call to measure(int, int). This result is a bit mask as defined by MEASURED_SIZE_MASK and MEASURED_STATE_TOO_SMALL. This should be used during measurement and layout calculations only. Use getHeight() to see how wide a view is after layout.

Return only the state bits of getMeasuredWidthAndState(View) and getMeasuredHeightAndState(View), combined into one integer. The width component is in the regular bits MEASURED_STATE_MASK and the height component is at the shifted bits MEASURED_HEIGHT_STATE_SHIFT>>MEASURED_STATE_MASK.

Return the full width measurement information for this view as computed by the most recent call to measure(int, int). This result is a bit mask as defined by MEASURED_SIZE_MASK and MEASURED_STATE_TOO_SMALL. This should be used during measurement and layout calculations only. Use getWidth() to see how wide a view is after layout.

Returns the minimum height of the view.

Prior to API 16 this will return 0.

Returns the minimum width of the view.

Prior to API 16 this will return 0.

Returns the over-scroll mode for this view. The result will be one of OVER_SCROLL_ALWAYS (default), OVER_SCROLL_IF_CONTENT_SCROLLS (allow over-scrolling only if the view content is larger than the container), or OVER_SCROLL_NEVER.

Returns the end padding of the specified view depending on its resolved layout direction. If there are inset and enabled scrollbars, this value may include the space required to display the scrollbars as well.

Returns the start padding of the specified view depending on its resolved layout direction. If there are inset and enabled scrollbars, this value may include the space required to display the scrollbars as well.

Gets the parent for accessibility purposes. Note that the parent for accessibility is not necessary the immediate parent. It is the first predecessor that is important for accessibility.

The x location of the point around which the view is rotated and scaled.

Prior to API 11 this will have no effect.

The y location of the point around which the view is rotated and scaled.

Prior to API 11 this will return 0.

Returns the name of the View to be used to identify Views in Transitions. Names should be unique in the View hierarchy.

This returns null if the View has not been given a name.

The horizontal location of this view relative to its left position. This position is post-layout, in addition to wherever the object's layout placed it.

Prior to API 11 this will return 0.

The vertical location of this view relative to its left position. This position is post-layout, in addition to wherever the object's layout placed it.

Prior to API 11 this will return 0.

The depth location of this view relative to its elevation.

Returns the current system UI visibility that is currently set for the entire window.

The visual z position of this view, in pixels. This is equivalent to the translationZ property plus the current elevation property.

Checks whether provided View has an accessibility delegate attached to it.

Returns true if this view has a nested scrolling parent.

The presence of a nested scrolling parent indicates that this view has initiated a nested scroll and it was accepted by an ancestor view further up the view hierarchy.

Returns whether this View has content which overlaps.

This function, intended to be overridden by specific View types, is an optimization when alpha is set on a view. If rendering overlaps in a view with alpha < 1, that view is drawn to an offscreen buffer and then composited into place, which can be expensive. If the view has no overlapping rendering, the view can draw each primitive with the appropriate alpha value directly. An example of overlapping rendering is a TextView with a background image, such as a Button. An example of non-overlapping rendering is a TextView with no background, or an ImageView with only the foreground image. The default implementation returns true; subclasses should override if they have cases which can be optimized.

Indicates whether the view is currently tracking transient state that the app should not need to concern itself with saving and restoring, but that the framework should take special note to preserve when possible.

Returns true if the provided view is currently attached to a window.

Returns true if view has been through at least one layout since it was last attached to or detached from a window.

Returns true if nested scrolling is enabled for this view.

If nested scrolling is enabled and this View class implementation supports it, this view will act as a nested scrolling child view when applicable, forwarding data about the scroll operation in progress to a compatible and cooperating nested scrolling parent.

Indicates whether this View is opaque. An opaque View guarantees that it will draw all the pixels overlapping its bounds using a fully opaque color. On API 7 and above this will call View's true isOpaque method. On previous platform versions it will check the opacity of the view's background drawable if present.

Return if the padding as been set through relative values View.setPaddingRelative(int, int, int, int) or thru

On API 11 devices and above, call Drawable.jumpToCurrentState() on all Drawable objects associated with this view.

On API 21 and above, also calls StateListAnimator#jumpToCurrentState() if there is a StateListAnimator attached to this view.

Offset this view's horizontal location by the specified amount of pixels.

Offset this view's vertical location by the specified number of pixels.

Called when the view should apply WindowInsetsCompat according to its internal policy.

Clients may supply an OnApplyWindowInsetsListener to a view. If one is set it will be called during dispatch instead of this method. The listener may optionally call this method from its own implementation if it wishes to apply the view's default insets policy in addition to its own.

Initializes an AccessibilityEvent with information about this View which is the event source. In other words, the source of an accessibility event is the view whose state change triggered firing the event.

Example: Setting the password property of an event in addition to properties set by the super implementation:

 public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
     super.onInitializeAccessibilityEvent(event);
     event.setPassword(true);
 }

If an View.AccessibilityDelegate has been specified via calling setAccessibilityDelegate(android.view.View.AccessibilityDelegate) its onInitializeAccessibilityEvent(View, AccessibilityEvent) is responsible for handling this call.

Note: Always call the super implementation before adding information to the event, in case the default implementation has basic information to add.

Initializes an AccessibilityNodeInfo with information about this view. The base implementation sets:

• setParent(View),
• setBoundsInParent(Rect),
• setBoundsInScreen(Rect),
• setPackageName(CharSequence),
• setClassName(CharSequence),
• setContentDescription(CharSequence),
• setEnabled(boolean),
• setClickable(boolean),
• setFocusable(boolean),
• setFocused(boolean),
• setLongClickable(boolean),
• setSelected(boolean),

Subclasses should override this method, call the super implementation, and set additional attributes.

If an View.AccessibilityDelegate has been specified via calling setAccessibilityDelegate(android.view.View.AccessibilityDelegate) its onInitializeAccessibilityNodeInfo(View, android.view.accessibility.AccessibilityNodeInfo) is responsible for handling this call.

Called from dispatchPopulateAccessibilityEvent(AccessibilityEvent) giving a chance to this View to populate the accessibility event with its text content. While this method is free to modify event attributes other than text content, doing so should normally be performed in onInitializeAccessibilityEvent(AccessibilityEvent).

Example: Adding formatted date string to an accessibility event in addition to the text added by the super implementation:

 public void onPopulateAccessibilityEvent(AccessibilityEvent event) {
     super.onPopulateAccessibilityEvent(event);
     final int flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_WEEKDAY;
     String selectedDateUtterance = DateUtils.formatDateTime(mContext,
         mCurrentDate.getTimeInMillis(), flags);
     event.getText().add(selectedDateUtterance);
 }

If an View.AccessibilityDelegate has been specified via calling setAccessibilityDelegate(android.view.View.AccessibilityDelegate) its onPopulateAccessibilityEvent(View, AccessibilityEvent) is responsible for handling this call.

Note: Always call the super implementation before adding information to the event, in case the default implementation has basic information to add.

Performs the specified accessibility action on the view. For possible accessibility actions look at AccessibilityNodeInfoCompat.

If an AccessibilityDelegateCompat has been specified via calling setAccessibilityDelegate(View, AccessibilityDelegateCompat) its performAccessibilityAction(View, int, Bundle) is responsible for handling this call.

Cause an invalidate to happen on the next animation time step, typically the next display frame.

This method can be invoked from outside of the UI thread only when this View is attached to a window.

Cause an invalidate of the specified area to happen on the next animation time step, typically the next display frame.

This method can be invoked from outside of the UI thread only when this View is attached to a window.

Causes the Runnable to execute on the next animation time step. The runnable will be run on the user interface thread.

This method can be invoked from outside of the UI thread only when this View is attached to a window.

Causes the Runnable to execute on the next animation time step, after the specified amount of time elapses. The runnable will be run on the user interface thread.

This method can be invoked from outside of the UI thread only when this View is attached to a window.

Ask that a new dispatch of View.onApplyWindowInsets(WindowInsets) be performed. This falls back to View.requestFitSystemWindows() where available.

Utility to reconcile a desired size and state, with constraints imposed by a MeasureSpec. Will take the desired size, unless a different size is imposed by the constraints. The returned value is a compound integer, with the resolved size in the MEASURED_SIZE_MASK bits and optionally the bit MEASURED_STATE_TOO_SMALL set if the resulting size is smaller than the size the view wants to be.

Sets a delegate for implementing accessibility support via compositon as opposed to inheritance. The delegate's primary use is for implementing backwards compatible widgets. For more details see View.AccessibilityDelegate.

Sets the live region mode for the specified view. This indicates to accessibility services whether they should automatically notify the user about changes to the view's content description or text, or to the content descriptions or text of the view's children (where applicable).

For example, in a login screen with a TextView that displays an "incorrect password" notification, that view should be marked as a live region with mode ACCESSIBILITY_LIVE_REGION_POLITE.

To disable change notifications for this view, use ACCESSIBILITY_LIVE_REGION_NONE. This is the default live region mode for most views.

To indicate that the user should be notified of changes, use ACCESSIBILITY_LIVE_REGION_POLITE.

If the view's changes should interrupt ongoing speech and notify the user immediately, use ACCESSIBILITY_LIVE_REGION_ASSERTIVE.

Changes the activated state of this view. A view can be activated or not. Note that activation is not the same as selection. Selection is a transient property, representing the view (hierarchy) the user is currently interacting with. Activation is a longer-term state that the user can move views in and out of.

Sets the opacity of the view. This is a value from 0 to 1, where 0 means the view is completely transparent and 1 means the view is completely opaque.

Note that setting alpha to a translucent value (0 < alpha < 1) can have significant performance implications, especially for large views. It is best to use the alpha property sparingly and transiently, as in the case of fading animations.

Prior to API 11 this will have no effect.

Applies a tint to the background drawable.

This will always take effect when running on API v21 or newer. When running on platforms previous to API v21, it will only take effect if view implement the TintableBackgroundView interface.

Specifies the blending mode used to apply the tint specified by setBackgroundTintList(android.view.View, android.content.res.ColorStateList) to the background drawable. The default mode is SRC_IN.

This will always take effect when running on API v21 or newer. When running on platforms previous to API v21, it will only take effect if view implement the TintableBackgroundView interface.

Tells the ViewGroup whether to draw its children in the order defined by the method ViewGroup.getChildDrawingOrder(int, int).

Sets a rectangular area on this view to which the view will be clipped when it is drawn. Setting the value to null will remove the clip bounds and the view will draw normally, using its full bounds.

Prior to API 18 this does nothing.

Sets the base elevation of this view, in pixels.

Sets whether or not this view should account for system screen decorations such as the status bar and inset its content; that is, controlling whether the default implementation of fitSystemWindows(Rect) will be executed. See that method for more details.

Set whether this view is currently tracking transient state that the framework should attempt to preserve when possible.

Sets how to determine whether this view is important for accessibility which is if it fires accessibility events and if it is reported to accessibility services that query the screen.

Note: If the current paltform version does not support the IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS mode, then IMPORTANT_FOR_ACCESSIBILITY_NO will be used as it is the closest terms of semantics.

Sets the id of a view for which a given view serves as a label for accessibility purposes.

Updates the Paint object used with the current layer (used only if the current layer type is not set to LAYER_TYPE_NONE). Changed properties of the Paint provided to setLayerType(android.view.View, int, android.graphics.Paint) will be used the next time the View is redrawn, but setLayerPaint(android.view.View, android.graphics.Paint) must be called to ensure that the view gets redrawn immediately.

A layer is associated with an optional Paint instance that controls how the layer is composed on screen. The following properties of the paint are taken into account when composing the layer:

• Translucency (alpha)
• Blending mode
• Color filter

If this view has an alpha value set to < 1.0 by calling View#setAlpha(float), the alpha value of the layer's paint is replaced by this view's alpha value. Calling View#setAlpha(float) is therefore equivalent to setting a hardware layer on this view and providing a paint with the desired alpha value.

Specifies the type of layer backing this view. The layer can be disabled, software or hardware.

A layer is associated with an optional Paint instance that controls how the layer is composed on screen. The following properties of the paint are taken into account when composing the layer:

• Translucency (alpha)
• Blending mode
• Color filter

If this view has an alpha value set to < 1.0 by calling setAlpha(float), the alpha value of the layer's paint is replaced by this view's alpha value. Calling setAlpha(float) is therefore equivalent to setting a hardware layer on this view and providing a paint with the desired alpha value.

Refer to the documentation of disabled, software and hardware for more information on when and how to use layers.

Set the layout direction for this view. This will propagate a reset of layout direction resolution to the view's children and resolve layout direction for this view.

Enable or disable nested scrolling for this view.

If this property is set to true the view will be permitted to initiate nested scrolling operations with a compatible parent view in the current hierarchy. If this view does not implement nested scrolling this will have no effect. Disabling nested scrolling while a nested scroll is in progress has the effect of stopping the nested scroll.

Set an OnApplyWindowInsetsListener to take over the policy for applying window insets to this view. This will only take effect on devices with API 21 or above.

Set the over-scroll mode for this view. Valid over-scroll modes are OVER_SCROLL_ALWAYS (default), OVER_SCROLL_IF_CONTENT_SCROLLS (allow over-scrolling only if the view content is larger than the container), or OVER_SCROLL_NEVER. Setting the over-scroll mode of a view will have an effect only if the view is capable of scrolling.

Sets the relative 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 getPaddingStart(View), getPaddingTop(), getPaddingEnd(View) and getPaddingBottom() may be different from the values set in this call.

Sets the x location of the point around which the view is rotated and scaled. By default, the pivot point is centered on the object. Setting this property disables this behavior and causes the view to use only the explicitly set pivotX and pivotY values.

Prior to API 11 this will have no effect.

Sets the y location of the point around which the view is rotated and scaled. By default, the pivot point is centered on the object. Setting this property disables this behavior and causes the view to use only the explicitly set pivotX and pivotY values.

Prior to API 11 this will have no effect.

Sets the degrees that the view is rotated around the pivot point. Increasing values result in clockwise rotation.

Prior to API 11 this will have no effect.

Sets the degrees that the view is rotated around the horizontal axis through the pivot point. Increasing values result in clockwise rotation from the viewpoint of looking down the x axis.

Prior to API 11 this will have no effect.

Sets the degrees that the view is rotated around the vertical axis through the pivot point. Increasing values result in counter-clockwise rotation from the viewpoint of looking down the y axis.

Prior to API 11 this will have no effect.

Controls whether the entire hierarchy under this view will save its state when a state saving traversal occurs from its parent.

Sets the amount that the view is scaled in x around the pivot point, as a proportion of the view's unscaled width. A value of 1 means that no scaling is applied.

Prior to API 11 this will have no effect.

Sets the amount that the view is scaled in Y around the pivot point, as a proportion of the view's unscaled width. A value of 1 means that no scaling is applied.

Prior to API 11 this will have no effect.

Sets the name of the View to be used to identify Views in Transitions. Names should be unique in the View hierarchy.

Sets the horizontal location of this view relative to its left position. This effectively positions the object post-layout, in addition to wherever the object's layout placed it.

Prior to API 11 this will have no effect.

Sets the vertical location of this view relative to its top position. This effectively positions the object post-layout, in addition to wherever the object's layout placed it.

Prior to API 11 this will have no effect.

Sets the depth location of this view relative to its elevation.

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 of the view as determined by the layout bounds.

Prior to API 11 this will have no effect.

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 of the view as determined by the layout bounds.

Prior to API 11 this will have no effect.

Begin a nestable scroll operation along the given axes.

A view starting a nested scroll promises to abide by the following contract:

The view will call startNestedScroll upon initiating a scroll operation. In the case of a touch scroll this corresponds to the initial ACTION_DOWN. In the case of touch scrolling the nested scroll will be terminated automatically in the same manner as requestDisallowInterceptTouchEvent(boolean). In the event of programmatic scrolling the caller must explicitly call stopNestedScroll(View) to indicate the end of the nested scroll.

If startNestedScroll returns true, a cooperative parent was found. If it returns false the caller may ignore the rest of this contract until the next scroll. Calling startNestedScroll while a nested scroll is already in progress will return true.

At each incremental step of the scroll the caller should invoke dispatchNestedPreScroll once it has calculated the requested scrolling delta. If it returns true the nested scrolling parent at least partially consumed the scroll and the caller should adjust the amount it scrolls by.

After applying the remainder of the scroll delta the caller should invoke dispatchNestedScroll, passing both the delta consumed and the delta unconsumed. A nested scrolling parent may treat these values differently. See onNestedScroll(View, int, int, int, int).

Stop a nested scroll in progress.

Calling this method when a nested scroll is not currently in progress is harmless.