Scroll the screen to the left. The underlying application should have atleast one scroll view belonging to the
class 'android.widget.ScrollView'.
773141
public void scrollLeft() {
        logger.entering();
        WebElement webElement = this.findElement(By.className(SCROLLVIEW_CLASS));
        swipeLeft(webElement);
        logger.exiting();
    }
85150
function enterFullScreen() {
    if (Windows.UI.ViewManagement.ApplicationViewBoundsMode) { // else crash on 8.1
        var view = Windows.UI.ViewManagement.ApplicationView.getForCurrentView();
        view.setDesiredBoundsMode(Windows.UI.ViewManagement.ApplicationViewBoundsMode.useCoreWindow);
        view.suppressSystemOverlays = true;
    }
}
108382
public void scrollToFinishActivity() {
        final int childWidth = mContentView.getWidth();
        final int childHeight = mContentView.getHeight();

        int left = 0, top = 0;
        if ((mEdgeFlag & EDGE_LEFT) != 0) {
            left = childWidth + mShadowLeft.getIntrinsicWidth() + OVERSCROLL_DISTANCE;
            mTrackingEdge = EDGE_LEFT;
        } else if ((mEdgeFlag & EDGE_RIGHT) != 0) {
            left = -childWidth - mShadowRight.getIntrinsicWidth() - OVERSCROLL_DISTANCE;
            mTrackingEdge = EDGE_RIGHT;
        } else if ((mEdgeFlag & EDGE_BOTTOM) != 0) {
            top = -childHeight - mShadowBottom.getIntrinsicHeight() - OVERSCROLL_DISTANCE;
            mTrackingEdge = EDGE_BOTTOM;
        }

        mDragHelper.smoothSlideViewTo(mContentView, left, top);
        invalidate();
    }
341312
function onScroll() {
		// unique tick id
		++ticks;

		// viewport rectangle
		var top = jWindow.scrollTop(),
			left = jWindow.scrollLeft(),
			right = left + jWindow.width(),
			bottom = top + jWindow.height();

		// determine which elements are in view
//        + 60 accounts for fixed nav
		var intersections = findElements(top+offset.top + 200, right+offset.right, bottom+offset.bottom, left+offset.left);
		$.each(intersections, function(i, element) {

			var lastTick = element.data('scrollSpy:ticks');
			if (typeof lastTick != 'number') {
				// entered into view
				element.triggerHandler('scrollSpy:enter');
			}

			// update tick id
			element.data('scrollSpy:ticks', ticks);
		});

		// determine which elements are no longer in view
		$.each(elementsInView, function(i, element) {
			var lastTick = element.data('scrollSpy:ticks');
			if (typeof lastTick == 'number' && lastTick !== ticks) {
				// exited from view
				element.triggerHandler('scrollSpy:exit');
				element.data('scrollSpy:ticks', null);
			}
		});

		// remember elements in view for next tick
		elementsInView = intersections;
	}
291912
private void registerScrollLayoutListener() {
        if (scrollView != null) {
            scrollView.getViewTreeObserver()
                    .addOnGlobalLayoutListener(createScrollViewLayoutListener(scrollView));
        } else if (listView != null) {
            listView.getViewTreeObserver()
                    .addOnGlobalLayoutListener(createScrollViewLayoutListener(listView));
        }
    }
480332
function() {
      var self = this;
      self.update();
      return {
        left: self.__scrollLeft,
        top: self.__scrollTop,
        zoom: 1
      };
    }
134445
public void scrollTo() {
        String action = "Scrolling screen to " + prettyOutput();
        String expected = prettyOutputStart() + " is now within the current viewport";
        try {
            // wait for element to be present
            if (isNotPresent(action, expected, CANT_SCROLL)) {
                return;
            }
            // perform the move action
            WebElement webElement = getWebElement();
            Actions builder = new Actions(driver);
            builder.moveToElement(webElement);
        } catch (Exception e) {
            cantScroll(e, action, expected);
            return;
        }
        isScrolledTo(action, expected);
    }
505102
def snap_left(window, width=None):
    
    if not width:
        width = window.width()
    rect = QApplication.desktop().screenGeometry()
    window.setGeometry(_DESKTOP_OFFSET_LEFT, _DESKTOP_OFFSET_TOP, width, rect.height())
717321
def scrollToEnd(self):
        
        vsbar = self.verticalScrollBar()
        vsbar.setValue(vsbar.maximum())
        
        hbar = self.horizontalScrollBar()
        hbar.setValue(0)
1081184
function() {

			var self = this;

			return {
				left: self.__scrollLeft,
				top: self.__scrollTop,
				zoom: self.__zoomLevel
			};

		}
215232
def startEdit( self ):
        
        self._originalText = self.text()
        self.scrollWidget().hide()
        self.setFocus()
        self.selectAll()
620095
def _set_scroll(self, *args):
        """"""
        self._canvas_scroll.xview(*args)
        self._canvas_ticks.xview(*args)
45187
public void onScrolled() {
        //  due to a bug in 21: https://code.google.com/p/android/issues/detail?id=162753, which cause getDecoratedStart() throws NullPointException
        // officially reported it has been fixed in v22

        final int lastPosition = getLayoutManager().findLastVisibleItemPosition();
        final int firstPosition = getLayoutManager().findFirstVisibleItemPosition();

        int lastCardIndex = -1;
        int firstCardIndex = -1;
        int position = lastPosition;
        //find the last visible item in card
        for (int i = lastPosition; i >= firstPosition; i--) {
            lastCardIndex = mGroupBasicAdapter.findCardIdxFor(i);
            if (lastCardIndex >= 0) {
                position = i;
                break;
            }
        }

        for (int i = firstCardIndex; i <= lastPosition; i++) {
            firstCardIndex = mGroupBasicAdapter.findCardIdxFor(i);
            if (firstCardIndex >= 0) {
                break;
            }
        }

        if (lastCardIndex < 0 || firstCardIndex < 0) return;

        final CardLoadSupport loadSupport = getService(CardLoadSupport.class);
        if (loadSupport == null) return;

        List<Card> cards = mGroupBasicAdapter.getGroups();
        //check the loadmore state of current card first  range is inclusive-exclusive
        Card current = cards.get(lastCardIndex);
        Pair<Range<Integer>, Card> pair = mGroupBasicAdapter.getCardRange(lastCardIndex);
        if (pair != null && position >= pair.first.getUpper() - mPreLoadNumber) {
            // async load
            if (!TextUtils.isEmpty(current.load) && current.loaded) {
                // page load
                if (current.loadMore) {
                    loadSupport.loadMore(current);
                    loadSupport.reactiveDoLoadMore(current);
                }
                return;
            }
        }


        boolean loadedMore = false;

        for (int i = firstCardIndex; i < Math.min(lastCardIndex + mPreLoadNumber, cards.size()); i++) {
            Card c = cards.get(i);
            // async load
            if (!TextUtils.isEmpty(c.load) && !c.loaded) {
                // page load
                if (c.loadMore && !loadedMore) {
                    // only load one load more card
                    loadSupport.loadMore(c);
                    loadSupport.reactiveDoLoadMore(c);
                    loadedMore = true;
                } else {
                    loadSupport.doLoad(c);
                    loadSupport.reactiveDoLoad(c);
                }
                c.loaded = true;
            }
        }


        if (mEnableAutoLoadMore && mGroupBasicAdapter.getItemCount() - position < mPreLoadNumber) {
            loadMoreCard();
        }
    }
1096586
def scroll_y(self, pixels, relative=True):
        '''
        
        '''
        if relative:
            self.offset.y += int(pixels)
        else:
            self.offset.y = int(pixels)
        self._update()
862918
@Override
	public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
		boolean bCanScrollUp;
		if (android.os.Build.VERSION.SDK_INT < 14) {
			bCanScrollUp = view.getChildCount() > 0
				&& (view.getFirstVisiblePosition() > 0 ||
				view.getChildAt(0).getTop() < view.getPaddingTop());
		} else {
			bCanScrollUp = ViewCompat.canScrollVertically(view, -1);
		}
		showToolbarElevation(bCanScrollUp);
	}
676881
def scroll(self, lines):
        
        line = [(ord(u" "), Screen.COLOUR_WHITE, 0, 0, 1) for _ in range(self._width)]
        if lines > 0:
            # Limit to buffer size - this will just invalidate all the data
            lines = min(lines, self._height)
            for y in range(0, self._height - lines):
                self._double_buffer[y] = self._double_buffer[y + lines]
                self._screen_buffer[y] = self._screen_buffer[y + lines]
            for y in range(self._height - lines, self._height):
                self._double_buffer[y] = line[:]
                self._screen_buffer[y] = line[:]
        else:
            # Limit to buffer size - this will just invalidate all the data
            lines = max(lines, -self._height)
            for y in range(0, -lines):
                self._double_buffer[self._height + lines + y] = line[:]
                self._screen_buffer[y] = line[:]
            for y in range(self._height - 1, -lines, -1):
                self._double_buffer[y] = self._double_buffer[y + lines]
                self._screen_buffer[y] = self._screen_buffer[y + lines]
594797
void scrollByInternal(int x, int y) {
        int overscrollX = 0, overscrollY = 0;
        consumePendingUpdateOperations();
        if (mAdapter != null) {
            eatRequestLayout();
            if (x != 0) {
                final int hresult = mLayout.scrollHorizontallyBy(x, mRecycler, mState);
                overscrollX = x - hresult;
            }
            if (y != 0) {
                final int vresult = mLayout.scrollVerticallyBy(y, mRecycler, mState);
                overscrollY = y - vresult;
            }
            resumeRequestLayout(false);
        }

        if (!mItemDecorations.isEmpty()) {
            invalidate();
        }
        if (ViewCompat.getOverScrollMode(this) != ViewCompat.OVER_SCROLL_NEVER) {
            pullGlows(overscrollX, overscrollY);
        }
        if (mScrollListener != null && (x != 0 || y != 0)) {
            mScrollListener.onScrolled(x, y);
        }
        if (!awakenScrollBars()) {
            invalidate();
        }
    }