IT. Expert System.

Android Reference

ScrollView


android.widget

Class ScrollView

  • All Implemented Interfaces:
    Drawable.Callback, AccessibilityEventSource, KeyEvent.Callback, ViewManager, ViewParent


    public class ScrollView
    extends FrameLayout
    Layout container for a view hierarchy that can be scrolled by the user, allowing it to be larger than the physical display. A ScrollView is a FrameLayout, meaning you should place one child in it containing the entire contents to scroll; this child may itself be a layout manager with a complex hierarchy of objects. A child that is often used is a LinearLayout in a vertical orientation, presenting a vertical array of top-level items that the user can scroll through.

    You should never use a ScrollView with a ListView, because ListView takes care of its own vertical scrolling. Most importantly, doing this defeats all of the important optimizations in ListView for dealing with large lists, since it effectively forces the ListView to display its entire list of items to fill up the infinite container supplied by ScrollView.

    The TextView class also takes care of its own scrolling, so does not require a ScrollView, but using the two together is possible to achieve the effect of a text view within a larger container.

    ScrollView only supports vertical scrolling. For horizontal scrolling, use HorizontalScrollView.

    • Method Detail

      • shouldDelayChildPressedState

        public boolean shouldDelayChildPressedState()
        Description copied from class: ViewGroup
        Return true if the pressed state should be delayed for children or descendants of this ViewGroup. Generally, this should be done for containers that can scroll, such as a List. This prevents the pressed state from appearing when the user is actually trying to scroll the content. The default implementation returns true for compatibility reasons. Subclasses that do not scroll should generally override this method and return false.
        Overrides:
        shouldDelayChildPressedState in class FrameLayout
      • getTopFadingEdgeStrength

        protected float getTopFadingEdgeStrength()
        Description copied from class: View
        Returns the strength, or intensity, of the top faded edge. The strength is a value between 0.0 (no fade) and 1.0 (full fade). The default implementation returns 0.0 or 1.0 but no value in between. Subclasses should override this method to provide a smoother fade transition when scrolling occurs.
        Overrides:
        getTopFadingEdgeStrength in class View
        Returns:
        the intensity of the top fade as a float between 0.0f and 1.0f
      • getBottomFadingEdgeStrength

        protected float getBottomFadingEdgeStrength()
        Description copied from class: View
        Returns the strength, or intensity, of the bottom faded edge. The strength is a value between 0.0 (no fade) and 1.0 (full fade). The default implementation returns 0.0 or 1.0 but no value in between. Subclasses should override this method to provide a smoother fade transition when scrolling occurs.
        Overrides:
        getBottomFadingEdgeStrength in class View
        Returns:
        the intensity of the bottom fade as a float between 0.0f and 1.0f
      • getMaxScrollAmount

        public int getMaxScrollAmount()
        Returns:
        The maximum amount this scroll view will scroll in response to an arrow event.
      • isFillViewport

        public boolean isFillViewport()
        Indicates whether this ScrollView's content is stretched to fill the viewport.
        Returns:
        True if the content fills the viewport, false otherwise.
      • setFillViewport

        public void setFillViewport(boolean fillViewport)
        Indicates this ScrollView whether it should stretch its content height to fill the viewport or not.
        Parameters:
        fillViewport - True to stretch the content's height to the viewport's boundaries, false otherwise.
      • isSmoothScrollingEnabled

        public boolean isSmoothScrollingEnabled()
        Returns:
        Whether arrow scrolling will animate its transition.
      • setSmoothScrollingEnabled

        public void setSmoothScrollingEnabled(boolean smoothScrollingEnabled)
        Set whether arrow scrolling will animate its transition.
        Parameters:
        smoothScrollingEnabled - whether arrow scrolling will animate its transition
      • dispatchKeyEvent

        public boolean dispatchKeyEvent(KeyEvent event)
        Description copied from class: ViewGroup
        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.
        Overrides:
        dispatchKeyEvent in class ViewGroup
        Parameters:
        event - The key event to be dispatched.
        Returns:
        True if the event was handled, false otherwise.
      • executeKeyEvent

        public boolean executeKeyEvent(KeyEvent event)
        You can call this function yourself to have the scroll view perform scrolling from a key event, just as if the event had been dispatched to it by the view hierarchy.
        Parameters:
        event - The key event to execute.
        Returns:
        Return true if the event was handled, else false.
      • requestDisallowInterceptTouchEvent

        public void requestDisallowInterceptTouchEvent(boolean disallowIntercept)
        Description copied from class: ViewGroup
        Called when a child does not want this parent and its ancestors to intercept touch events with ViewGroup.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.

        Specified by:
        requestDisallowInterceptTouchEvent in interface ViewParent
        Overrides:
        requestDisallowInterceptTouchEvent in class ViewGroup
        Parameters:
        disallowIntercept - True if the child does not want the parent to intercept touch events.
      • onInterceptTouchEvent

        public boolean onInterceptTouchEvent(MotionEvent ev)
        Description copied from class: ViewGroup
        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 MotionEvent.ACTION_CANCEL, and all further events will be delivered to your onTouchEvent() method and no longer appear here.
        Overrides:
        onInterceptTouchEvent in class ViewGroup
        Parameters:
        ev - The motion event being dispatched down the hierarchy.
        Returns:
        Return true to steal motion events from the children and have them dispatched to this ViewGroup through onTouchEvent(). The current target will receive an ACTION_CANCEL event, and no further messages will be delivered here.
      • onTouchEvent

        public boolean onTouchEvent(MotionEvent ev)
        Description copied from class: View
        Implement this method to handle touch screen motion events.
        Overrides:
        onTouchEvent in class View
        Parameters:
        ev - The motion event.
        Returns:
        True if the event was handled, false otherwise.
      • onGenericMotionEvent

        public boolean onGenericMotionEvent(MotionEvent event)
        Description copied from class: View
        Implement this method to handle generic motion events.

        Generic motion events describe joystick movements, mouse hovers, track pad touches, scroll wheel movements and other input events. The source of the motion event specifies the class of input that was received. Implementations of this method must examine the bits in the source before processing the event. The following code example shows how this is done.

        Generic motion events with source class InputDevice.SOURCE_CLASS_POINTER are delivered to the view under the pointer. All other generic motion events are delivered to the focused view.

         public boolean onGenericMotionEvent(MotionEvent event) {
             if ((event.getSource() & InputDevice.SOURCE_CLASS_JOYSTICK) != 0) {
                 if (event.getAction() == MotionEvent.ACTION_MOVE) {
                     // process the joystick movement...
                     return true;
                 }
             }
             if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
                 switch (event.getAction()) {
                     case MotionEvent.ACTION_HOVER_MOVE:
                         // process the mouse hover movement...
                         return true;
                     case MotionEvent.ACTION_SCROLL:
                         // process the scroll wheel movement...
                         return true;
                 }
             }
             return super.onGenericMotionEvent(event);
         }
        Overrides:
        onGenericMotionEvent in class View
        Parameters:
        event - The generic motion event being processed.
        Returns:
        True if the event was handled, false otherwise.
      • onOverScrolled

        protected void onOverScrolled(int scrollX,
                          int scrollY,
                          boolean clampedX,
                          boolean clampedY)
        Description copied from class: View
        Called by View.overScrollBy(int, int, int, int, int, int, int, int, boolean) to respond to the results of an over-scroll operation.
        Overrides:
        onOverScrolled in class View
        Parameters:
        scrollX - New X scroll value in pixels
        scrollY - New Y scroll value in pixels
        clampedX - True if scrollX was clamped to an over-scroll boundary
        clampedY - True if scrollY was clamped to an over-scroll boundary
      • pageScroll

        public boolean pageScroll(int direction)

        Handles scrolling in response to a "page up/down" shortcut press. This method will scroll the view by one page up or down and give the focus to the topmost/bottommost component in the new visible area. If no component is a good candidate for focus, this scrollview reclaims the focus.

        Parameters:
        direction - the scroll direction: View.FOCUS_UP to go one page up or View.FOCUS_DOWN to go one page down
        Returns:
        true if the key event is consumed by this method, false otherwise
      • fullScroll

        public boolean fullScroll(int direction)

        Handles scrolling in response to a "home/end" shortcut press. This method will scroll the view to the top or bottom and give the focus to the topmost/bottommost component in the new visible area. If no component is a good candidate for focus, this scrollview reclaims the focus.

        Parameters:
        direction - the scroll direction: View.FOCUS_UP to go the top of the view or View.FOCUS_DOWN to go the bottom
        Returns:
        true if the key event is consumed by this method, false otherwise
      • arrowScroll

        public boolean arrowScroll(int direction)
        Handle scrolling in response to an up or down arrow click.
        Parameters:
        direction - The direction corresponding to the arrow key that was pressed
        Returns:
        True if we consumed the event, false otherwise
      • smoothScrollBy

        public final void smoothScrollBy(int dx,
                          int dy)
        Like View.scrollBy(int, int), but scroll smoothly instead of immediately.
        Parameters:
        dx - the number of pixels to scroll by on the X axis
        dy - the number of pixels to scroll by on the Y axis
      • smoothScrollTo

        public final void smoothScrollTo(int x,
                          int y)
        Like scrollTo(int, int), but scroll smoothly instead of immediately.
        Parameters:
        x - the position where to scroll on the X axis
        y - the position where to scroll on the Y axis
      • measureChild

        protected void measureChild(View child,
                        int parentWidthMeasureSpec,
                        int parentHeightMeasureSpec)
        Description copied from class: ViewGroup
        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.
        Overrides:
        measureChild in class ViewGroup
        Parameters:
        child - The child to measure
        parentWidthMeasureSpec - The width requirements for this view
        parentHeightMeasureSpec - The height requirements for this view
      • measureChildWithMargins

        protected void measureChildWithMargins(View child,
                                   int parentWidthMeasureSpec,
                                   int widthUsed,
                                   int parentHeightMeasureSpec,
                                   int heightUsed)
        Description copied from class: ViewGroup
        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.
        Overrides:
        measureChildWithMargins in class ViewGroup
        Parameters:
        child - The child to measure
        parentWidthMeasureSpec - The width requirements for this view
        widthUsed - Extra space that has been used up by the parent horizontally (possibly by other children of the parent)
        parentHeightMeasureSpec - The height requirements for this view
        heightUsed - Extra space that has been used up by the parent vertically (possibly by other children of the parent)
      • computeScroll

        public void computeScroll()
        Description copied from class: View
        Called by a parent to request that a child update its values for mScrollX and mScrollY if necessary. This will typically be done if the child is animating a scroll using a Scroller object.
        Overrides:
        computeScroll in class View
      • computeScrollDeltaToGetChildRectOnScreen

        protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect)
        Compute the amount to scroll in the Y direction in order to get a rectangle completely on the screen (or, if taller than the screen, at least the first screen size chunk of it).
        Parameters:
        rect - The rect.
        Returns:
        The scroll delta.
      • requestChildFocus

        public void requestChildFocus(View child,
                             View focused)
        Description copied from class: ViewGroup
        Called when a child of this parent wants focus
        Specified by:
        requestChildFocus in interface ViewParent
        Overrides:
        requestChildFocus in class ViewGroup
        Parameters:
        child - The child of this ViewParent that wants focus. This view will contain the focused view. It is not necessarily the view that actually has focus.
        focused - The view that is a descendant of child that actually has focus
      • onRequestFocusInDescendants

        protected boolean onRequestFocusInDescendants(int direction,
                                          Rect previouslyFocusedRect)
        When looking for focus in children of a scroll view, need to be a little more careful not to give focus to something that is scrolled off screen. This is more expensive than the default ViewGroup implementation, otherwise this behavior might have been made the default.
        Overrides:
        onRequestFocusInDescendants in class ViewGroup
        Parameters:
        direction - One of FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, and FOCUS_RIGHT
        previouslyFocusedRect - The rectangle (in this View's coordinate system) to give a finer grained hint about where focus is coming from. May be null if there is no hint.
        Returns:
        Whether focus was taken.
      • requestChildRectangleOnScreen

        public boolean requestChildRectangleOnScreen(View child,
                                            Rect rectangle,
                                            boolean immediate)
        Description copied from class: ViewGroup
        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
          Specified by:
          requestChildRectangleOnScreen in interface ViewParent
          Overrides:
          requestChildRectangleOnScreen in class ViewGroup
          Parameters:
          child - The direct child making the request.
          rectangle - The rectangle in the child's coordinates the child wishes to be on the screen.
          immediate - True to forbid animated or delayed scrolling, false otherwise
          Returns:
          Whether the group scrolled to handle the operation
        • requestLayout

          public void requestLayout()
          Description copied from class: View
          Call this when something has changed which has invalidated the layout of this view. This will schedule a layout pass of the view tree.
          Specified by:
          requestLayout in interface ViewParent
          Overrides:
          requestLayout in class View
        • onDetachedFromWindow

          protected void onDetachedFromWindow()
          Description copied from class: View
          This is called when the view is detached from a window. At this point it no longer has a surface for drawing.
          Overrides:
          onDetachedFromWindow in class View
          See Also:
          View.onAttachedToWindow()
        • onLayout

          protected void onLayout(boolean changed,
                      int l,
                      int t,
                      int r,
                      int b)
          Description copied from class: FrameLayout
          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 children.
          Overrides:
          onLayout in class FrameLayout
          Parameters:
          changed - This is a new size or position for this view
          l - Left position, relative to parent
          t - Top position, relative to parent
          r - Right position, relative to parent
          b - Bottom position, relative to parent
        • onSizeChanged

          protected void onSizeChanged(int w,
                           int h,
                           int oldw,
                           int oldh)
          Description copied from class: FrameLayout
          This is called during layout when the size of this view has changed. If you were just added to the view hierarchy, you're called with the old values of 0.
          Overrides:
          onSizeChanged in class FrameLayout
          Parameters:
          w - Current width of this view.
          h - Current height of this view.
          oldw - Old width of this view.
          oldh - Old height of this view.
        • fling

          public void fling(int velocityY)
          Fling the scroll view
          Parameters:
          velocityY - The initial velocity in the Y direction. Positive numbers mean that the finger/cursor is moving down the screen, which means we want to scroll towards the top.
        • scrollTo

          public void scrollTo(int x,
                      int y)
          Set the scrolled position of your view. This will cause a call to View.onScrollChanged(int, int, int, int) and the view will be invalidated.

          This version also clamps the scrolling to the bounds of our child.

          Overrides:
          scrollTo in class View
          Parameters:
          x - the x position to scroll to
          y - the y position to scroll to
        • setOverScrollMode

          public void setOverScrollMode(int mode)
          Description copied from class: View
          Set the over-scroll mode for this view. Valid over-scroll modes are View.OVER_SCROLL_ALWAYS (default), View.OVER_SCROLL_IF_CONTENT_SCROLLS (allow over-scrolling only if the view content is larger than the container), or View.OVER_SCROLL_NEVER. Setting the over-scroll mode of a view will have an effect only if the view is capable of scrolling.
          Overrides:
          setOverScrollMode in class View
          Parameters:
          mode - The new over-scroll mode for this view.
        • draw

          public void draw(Canvas canvas)
          Description copied from class: FrameLayout
          Manually render this view (and all of its children) to the given Canvas. The view must have already done a full layout before this function is called. When implementing a view, implement View.onDraw(android.graphics.Canvas) instead of overriding this method. If you do need to override this method, call the superclass version.
          Overrides:
          draw in class FrameLayout
          Parameters:
          canvas - The Canvas to which the View is rendered.


    Content

    Android Reference

    Java basics

    Java Enterprise Edition (EE)

    Java Standard Edition (SE)

    SQL

    HTML

    PHP

    CSS

    Java Script

    MYSQL

    JQUERY

    VBS

    REGEX

    C

    C++

    C#

    Design patterns

    RFC (standard status)

    RFC (proposed standard status)

    RFC (draft standard status)

    RFC (informational status)

    RFC (experimental status)

    RFC (best current practice status)

    RFC (historic status)

    RFC (unknown status)

    IT dictionary

    License.
    All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
    Copyright 2016 © ELTASK.COM. All rights reserved.
    Site is optimized for mobile devices.
    Downloads: 446 / 158861050. Delta: 0.07885 с