Performs a **flick** heading _left_ inside the first view that matches
 `query`.
 @see #flick
 @param [Number] duration (default: 1.0) The amount of time in seconds the
  gesture lasts.
433772
def flick_left(query, duration: nil)
      flick(query, {x: 90, y: 50}, {x: 10, y: 50}, duration: duration)
    end
45085
function captionTransition(caption, duration) {
          if (caption.hasClass("center-align")) {
            caption.velocity({opacity: 0, translateY: -100}, {duration: duration, queue: false});
          }
          else if (caption.hasClass("right-align")) {
            caption.velocity({opacity: 0, translateX: 100}, {duration: duration, queue: false});
          }
          else if (caption.hasClass("left-align")) {
            caption.velocity({opacity: 0, translateX: -100}, {duration: duration, queue: false});
          }
        }
1188910
function(left, top, animate) {

			var self = this;

			var startLeft = self.__isAnimating ? self.__scheduledLeft : self.__scrollLeft;
			var startTop = self.__isAnimating ? self.__scheduledTop : self.__scrollTop;

			self.scrollTo(startLeft + (left || 0), startTop + (top || 0), animate);

		}
878182
function moveToValue(value) {
    const left = 100 * (value - this.min) / (this.max - this.min);
    Dom.css(this.$elements.button, { left: `${left}%` });
}
196080
function gestureEnd(element, clientX, clientY) {

  // Examine velocity of last movement to see if user is flicking.
  const velocity = element[previousVelocityKey];
  const flickThresholdVelocity = 800; // speed in pixels/second

  let flickPositive;
  if (velocity >= flickThresholdVelocity) {
    // Flicked right/down at high speed.
    flickPositive = true;
  } else if (velocity <= -flickThresholdVelocity) {
    // Flicked left/up at high speed.
    flickPositive = false;
  } else {
    // Finished at low speed.
    const swipeFraction = getSwipeFraction(element, clientX, clientY);
    if (swipeFraction <= -0.5) {
      flickPositive = false;
    } else if (swipeFraction >= 0.5) {
      flickPositive = true;
    }
  }

  if (typeof flickPositive !== 'undefined') {
    const vertical = element.state.swipeAxis === 'vertical';
    const gesture = vertical ?
      (flickPositive ? symbols.swipeDown : symbols.swipeUp) :
      (flickPositive ? symbols.swipeRight : symbols.swipeLeft);
    // If component has method for indicated gesture, invoke it.
    if (gesture && element[gesture]) {
      element[gesture]();
    }
  }

  element.setState({ swipeFraction: null });
}
181328
public function flickLeft($x, $y, $distance, $duration)
    {
        return $this
            ->flick($x, $y, WebDriver_Server_Selendroid::DIRECTION_LEFT, $distance, $duration);
    }
1101984
function tap(position, element, done) {
                var touches = getTouches(position, 1);
                var gesture = {
                    duration: config.randomizer.integer({ min: 20, max: 700 })
                };

                triggerTouch(touches, element, 'start');

                setTimeout(function() {
                    triggerTouch(touches, element, 'end');
                    done(touches, gesture);
                }, gesture.duration);
            }
260130
def focus_left(pymux):
    "  "
    _move_focus(pymux,
                lambda wp: wp.xpos - 2,  # 2 in order to skip over the border.
                lambda wp: wp.ypos)
620352
public function flickDown($x, $y, $distance, $duration)
    {
        return $this
            ->flick($x, $y, WebDriver_Server_Selendroid::DIRECTION_DOWN, $distance, $duration);
    }
330685
function scrollTo({ container, element, key, options }) {
  // if duration is ero then set it to very small so that we do not divide by zero
  if (options.duration <= 0) options.duration = 0.1;

  // width or height
  const sizeKey = SIZE_KEYS[key];
  // destination measurement
  let to = Math.min(
    element[`offset${key}`] + options[`offset${key}`],
    (container[`scroll${sizeKey}`] - container[`offset${sizeKey}`])
  );
  // if destination is greater than avaialable space then limit to avaialable space
  if (to > container[`scroll${sizeKey}`]) to = container[`scroll${sizeKey}`];
  // if destination is less than zero then make it zero
  if (to < 0) to = 0;
  // amount that needs to be scrolled
  const difference = to - container[`scroll${key}`];
  // amount thats needs to be scrolled every tick
  const perTick = difference / options.duration * options.tick;
  // if we are already scrolled to that point then exit
  if (perTick === 0) return;

  // scroll the amount for one tick
  const doScroll = () => {
    setTimeout(() => {
      // scroll container
      container[`scroll${key}`] = container[`scroll${key}`] + perTick;
      // if we have reached desired position then exit
      if (
        (container[`scroll${key}`] >= to && perTick > 0) ||
        (container[`scroll${key}`] <= to && perTick < 0)
      ) return;
      // else repeat after `TICK` interval
      doScroll();
    }, options.tick);
  };

  doScroll();
}
1356277
function(duration, callback) {
      return this.each(function(index, el) {
        u(el).scrollTo(0, duration, callback);
      });
    }
509243
public void showToast(final String message, float duration) {
        final float quadWidth = 1.2f;
        final GVRTextViewSceneObject toastSceneObject = new GVRTextViewSceneObject(this, quadWidth, quadWidth / 5,
                message);

        toastSceneObject.setTextSize(6);
        toastSceneObject.setTextColor(Color.WHITE);
        toastSceneObject.setGravity(Gravity.CENTER_HORIZONTAL|Gravity.TOP);
        toastSceneObject.setBackgroundColor(Color.DKGRAY);
        toastSceneObject.setRefreshFrequency(GVRTextViewSceneObject.IntervalFrequency.REALTIME);

        final GVRTransform t = toastSceneObject.getTransform();
        t.setPositionZ(-1.5f);

        final GVRRenderData rd = toastSceneObject.getRenderData();
        final float finalOpacity = 0.7f;
        rd.getMaterial().setOpacity(0);
        rd.setRenderingOrder(2 * GVRRenderData.GVRRenderingOrder.OVERLAY);
        rd.setDepthTest(false);

        final GVRCameraRig rig = getMainScene().getMainCameraRig();
        rig.addChildObject(toastSceneObject);

        final GVRMaterialAnimation fadeOut = new GVRMaterialAnimation(rd.getMaterial(), duration / 4.0f) {
            @Override
            protected void animate(GVRHybridObject target, float ratio) {
                final GVRMaterial material = (GVRMaterial) target;
                material.setOpacity(finalOpacity - ratio * finalOpacity);
            }
        };
        fadeOut.setOnFinish(new GVROnFinish() {
            @Override
            public void finished(GVRAnimation animation) {
                rig.removeChildObject(toastSceneObject);
            }
        });

        final GVRMaterialAnimation fadeIn = new GVRMaterialAnimation(rd.getMaterial(), 3.0f * duration / 4.0f) {
            @Override
            protected void animate(GVRHybridObject target, float ratio) {
                final GVRMaterial material = (GVRMaterial) target;
                material.setOpacity(ratio * finalOpacity);
            }
        };
        fadeIn.setOnFinish(new GVROnFinish() {
            @Override
            public void finished(GVRAnimation animation) {
                getAnimationEngine().start(fadeOut);
            }
        });

        getAnimationEngine().start(fadeIn);
    }
711295
def flick_up(query, duration: nil)
      flick(query, {x: 50, y: 90}, {x: 50, y: 10}, duration: duration)
    end
457744
function() {

		this._is_reversed = !this._is_reversed;

		if (this._is_running) {

			var now = new Date().getTime(),
				new_end = 2 * now - this._started_time;

			// it's possible in case of script lags. Must not allow negative transition values.
			if (now > this._end_time) {

				this._started_time = this._end_time;
				this._end_time = this._started_time + this._duration;

			} else {

				this._end_time = new_end;
				this._started_time = new_end - this._duration;

			}

			this._afterMirror(now);

		}

	}
1284593
def move_red_right(self):
        

        self = self.flip()
        if self.left is not NULL and self.left.left.red:
            self = self.rotate_right().flip()

        return self
642589
function(time, x, y) {
		if(time - _gestureCheckSpeedTime > 50) {
			var o = _posPoints.length > 2 ? _posPoints.shift() : {};
			o.x = x;
			o.y = y; 
			_posPoints.push(o);
			_gestureCheckSpeedTime = time;
		}
	}
262621
function gesture(position, element, done) {
                var gesture = {
                    distanceX: config.randomizer.integer({ min: -100, max: 200 }),
                    distanceY: config.randomizer.integer({ min: -100, max: 200 }),
                    duration:  config.randomizer.integer({ min: 20, max: 500 })
                };
                var touches = getTouches(position, 1, gesture.radius);

                triggerGesture(element, position, touches, gesture, function(touches) {
                    done(touches, gesture);
                });
            }