Control's update. Should be invoked every frame.

@param {number} frameTime Frame time.
432180
function (frameTime) {

        if (!this._standardGamepadAvailable) {
            return;
        }

        this._scanPressedGamepadButtons();
        this._scanInclinedGamepadAxes();

        // Update target depending on user input.

        var target = this.target;

        var position = this.target.position;
        var xAxis = target.localTransform.x.normalize();
        var zAxis = target.localTransform.z.normalize();

        var moveSpeed = this.moveSpeed * frameTime / 20;

        if (this._moveForward) {
            // Opposite direction of z.
            position.scaleAndAdd(zAxis, -moveSpeed);
        }
        if (this._moveBackward) {
            position.scaleAndAdd(zAxis, moveSpeed);
        }
        if (this._moveLeft) {
            position.scaleAndAdd(xAxis, -moveSpeed);
        }
        if (this._moveRight) {
            position.scaleAndAdd(xAxis, moveSpeed);
        }

        target.rotateAround(target.position, this.up, -this._offsetPitch * frameTime * Math.PI / 360);
        var xAxis = target.localTransform.x;
        target.rotateAround(target.position, xAxis, -this._offsetRoll * frameTime * Math.PI / 360);

        /*
         * If necessary: trigger `update` event.
         * XXX This can economize rendering OPs.
         */
        if (this._moveForward === true || this._moveBackward === true || this._moveLeft === true
            || this._moveRight === true || this._offsetPitch !== 0 || this._offsetRoll !== 0)
        {
            this.trigger('update');
        }

        // Reset values to avoid lost of control.

        this._moveForward = this._moveBackward = this._moveLeft = this._moveRight = false;
        this._offsetPitch = this._offsetRoll = 0;

    }
1274495
@Override
	public void setFrameInterval(int num, int denom) throws InvalidValue{
		synchronized(state){
			if(state.isStarted())
				throw new StateException("Invalid method call");
			doSetFrameIntv(object, num, denom);
		}
	}
443706
private void fireUpdated(Object control) {
		if (control.equals(minSpinner)) {
			int minY = ((Integer) minSpinner.getValue()).intValue();
			if (minY < panel.getWorldMaxY()) {
				panel.setWorldMinY(minY);
				panel.makeSureCurveFits();
				panel.repaint();
			} else {
				minSpinner.setValue(new Integer((int) panel.getWorldMinY()));
			}
		} else if (control.equals(maxSpinner)) {
			int maxY = ((Integer) maxSpinner.getValue()).intValue();
			if (maxY > panel.getWorldMinY()) {
				panel.setWorldMaxY(maxY);
				panel.makeSureCurveFits();
				panel.repaint();
			} else {
				maxSpinner.setValue(new Integer((int) panel.getWorldMaxY()));
			}
		}
	}
994335
public void update() {
        final long time = System.currentTimeMillis();
        elapsedTime += time - lastUpdateTime;
        lastUpdateTime = time;
        frameCount++;
        if (elapsedTime >= 1000) {
            tps = frameCount;
            frameCount = 0;
            elapsedTime = 0;
        }
    }
1144402
function updateCallback(that) {
        var i;
        that.status = GameTimer.RUNNING;
        that.timePassed += that.update;
        that.timeLeft -= that.update;
        that.updateStart = J.now();
        // Fire custom hooks from the latest to the first if any.
        for (i = that.hooks.length; i > 0; i--) {
            that.fire(that.hooks[(i-1)]);
        }
        // Fire Timeup Event
        if (that.timeLeft <= 0) {
            that.doTimeup();
            return false;
        }
        else {
            return true;
        }
    }
850705
public void addFrame(int duration, int x, int y){
	   if (duration == 0) {
	      Log.error("Invalid duration: "+duration);
	      throw new RuntimeException("Invalid duration: "+duration);
	   }
	 
	    if (frames.isEmpty()) {
	      nextChange = (int) (duration / speed);
	   }
	   
	   frames.add(new Frame(duration, x, y));
	   currentFrame = 0;      
	}
453114
function updateTimer(element) {
  // If the element is playing and we haven't started a timer yet, do so now.
  // Also, if the element's selectedIndex changed for any reason, restart the
  // timer. This ensures that the timer restarts no matter why the selection
  // changes: it could have been us moving to the next slide because the timer
  // elapsed, or the user might have directly manipulated the selection, etc.
  if (element.state.playing &&
      (!element.state.timerTimeout || element.state.selectedIndex !== element.state.selectedIndexForTimer)) {
    restartTimer(element);
  } else if (!element.state.playing && element.state.timerTimeout) {
    clearTimer(element);
  }
}
932847
function(time) {
    var self = this;
    self.eventDetection.recordRelease(time);

    if (self.eventDetection.isLongPress()) {
      // this is a "long-press" -  reset detection states and notify the "long-press" observers
      self.eventDetection.reset();
      self._notifyObservers(self.onLongPressCallbackRegistry);
    } else {
      if (self.eventDetection.onReleaseCount >= 2) {
        // this is a double-press (or more) event, so notify the "double-press" observers
        self.eventDetection.reset();
        self._notifyObservers(self.onDoublePressCallbackRegistry);
      }

      setTimeout(function(){
        if (self.eventDetection.onReleaseCount == 1) {
          // second press did not occur within the allotted time, so notify the "short-press" observers
          self.eventDetection.reset();
          self._notifyObservers(self.onShortPressCallbackRegistry);
        }
      }, 300); // @-@:p0 make this configurable?
    }
  }
1308156
private void updatePlaying(double extrp)
    {
        current += speed * extrp;

        // Last frame reached
        if (Double.compare(current, last + FRAME) >= 0)
        {
            // If not reversed, done, else, reverse
            current = last + HALF_FRAME;
            checkStatePlaying();
        }
    }
1285624
function (event) {
            var inst = $.timepicker._getInst(event.target);
            $.timepicker._setTimeFromField(inst);
            $.timepicker._updateTimepicker(inst);
        }
781200
function somethingChanged() {
                // don't fire events if the editor is readOnly as they are false detections
                if (editor.readOnly)
                    return;

                if (timer)
                    return;

                timer = setTimeout(function () {
                    timer = 0;
                    editor.fire('change');
                }, editor.config.minimumChangeMilliseconds || 100);
            }
1086099
function(){

            canvas = document.getElementById("canvas");
            canvas.width = Zone.prototype.WIDTH;
            canvas.height =  Zone.prototype.HEIGHT;

            frameCount = 0;

            if (GameView.isRunning()){
                run();
            }

            //Add a listener on our global gameData object, to know when our game starts/stops
            gameData.on("change:isRunning", function(model, value){
                value ? run() : reset();
            });
        }
497281
function () {
        function checkUpdate() {
            var current = module.exports.current();
            if (current !== last) {
                last = current;
                events.trigger('update', current);
            }
        }

        // Do not run unless breakpoints are available.
        if (!running && breakpoints.length) {
            running = true;
            global.addEventListener('resize', function () {
                if (!working) {
                    working = true;
                    global.requestAnimationFrame(function () {
                        checkUpdate();
                        working = false;
                    });
                }
            });
        }
        checkUpdate();
    }
985547
function() {
		var t = this;

		var time = document.createElement('div');
		time.className = 'zy_time';
		time.innerHTML = '<span class="zy_currenttime">' +
			timeFormat(0, t.options) +
			'</span>/' +
			'<span class="zy_duration">' +
			timeFormat(t.options.duration, t.options) +
			'</span>';
		t.controls.appendChild(time);

		t.currentTime = time.children[0];
		t.durationDuration = time.children[1];

		//4Hz ~ 66Hz, no longer than 250ms
		t.media.addEventListener('timeupdate', function() {
			t.updateTime()
		});
	}
492345
function () {
    this.updateConfig();
    this.animation.began = true;
    this.time = 0;
    this.animationIsPlaying = true;
    this.stopRelatedAnimations();
    this.el.emit('animationbegin', this.eventDetail, false);
  }
23222
function fireWindowResizeEvent(event) {
        frameIsRequested = false;
        if (!componentInformation) {
            return;
        }
        var handlerResults = [];
        componentInformation.forEach(function (componentInformation, i) {
            // Skip if the component is not running anymore
            if (componentInformation.component._stopped) {
                return;
            }
            componentInformation.selectors.forEach(function (selector) {
                return selector.forEach(function (handler) {
                    return handlerResults.push(handler.call(componentInformation.component, event));
                });
            });
        });
        handlerResults.forEach(function (handlerResult) {
            if (typeof handlerResult === "function") {
                handlerResult();
            }
        });
    }
1148901
function update() {
  el.style.transform = 'scale3d(' + s1(x) + ', ' + s2(y) + ', 1)';

  requestAnimationFrame(update);
}