Called on each scene tick.
513930
function (t) {

    // Refresh every 250 millis

    if(typeof(this.last_time) === "undefined" || (t - this.last_time ) > 250) {

        // At the very least, have all video metadata
        // (https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/readyState)

        if(this.video_el.readyState > 0) {

            // Get current position minutes and second, and add leading zeroes if needed

            var current_minutes = Math.floor(this.video_el.currentTime / 60);
            var current_seconds = Math.floor(this.video_el.currentTime % 60);


            current_minutes = current_minutes < 10 ? "0" + current_minutes : current_minutes;
            current_seconds = current_seconds < 10 ? "0" + current_seconds : current_seconds;

            // Get video duration in  minutes and second, and add leading zeroes if needed

            var duration_minutes = Math.floor(this.video_el.duration / 60);
            var duration_seconds = Math.floor(this.video_el.duration % 60);


            duration_minutes = duration_minutes < 10 ? "0" + duration_minutes : duration_minutes;
            duration_seconds = duration_seconds < 10 ? "0" + duration_seconds : duration_seconds;

            // Refresh time information : currentTime / duration

            var time_info_text = current_minutes + ":" + current_seconds + " / " + duration_minutes + ":" + duration_seconds;

            //  Refresh transport bar canvas

            var inc = this.bar_canvas.width / this.video_el.duration;

            //  display buffered TimeRanges

            if (this.video_el.buffered.length > 0) {

                // Synchronize current step with currentTime

                this.current_step = Math.round((this.video_el.currentTime/this.video_el.duration)*this.bar_steps);

                var ctx = this.context;
                ctx.fillStyle = this.data.backgroundColor;
                ctx.fillRect(0, 0, this.bar_canvas.width, this.bar_canvas.height);

                // Uncomment to draw a single bar for loaded data instead of 'bins'

                //                ctx.fillStyle = "grey";
                //
                //                ctx.fillRect(0, 0,
                //                    (this.video_el.buffered.end(this.video_el.buffered.length - 1) / this.video_el.duration)*this.bar_canvas.width,
                //                    this.bar_canvas.height/2);



                // Display time info text

                ctx.font = this.data.timeTextFont;
                ctx.fillStyle = "white";
                ctx.textAlign = "center";
                ctx.fillText(time_info_text, this.bar_canvas.width/2, this.bar_canvas.height* 0.65);

                // DEBUG PURPOSES

//                ctx.fillText(this.video_el.readyState, this.bar_canvas.width*0.1, this.bar_canvas.height* 0.65);

                // If seeking to position, show

                if(this.video_el.seeking){
                    ctx.font = this.data.statusTextFont;
                    ctx.fillStyle = this.data.textColor;
                    ctx.textAlign = "end";
                    ctx.fillText("Seeking", this.bar_canvas.width * 0.95, this.bar_canvas.height * 0.60);
                }

                // Uncomment below to see % of video loaded...

                else {

                    var percent = (this.video_el.buffered.end(this.video_el.buffered.length - 1) / this.video_el.duration) * 100;

                    ctx.font = this.data.statusTextFont;
                    ctx.fillStyle = this.data.textColor;
                    ctx.textAlign = "end";

                    ctx.fillText(percent.toFixed(0) + "% loaded", this.bar_canvas.width * 0.95, this.bar_canvas.height * 0.60);
                }


                // Info text

                ctx.fillStyle = this.data.textColor;
                ctx.font = this.data.infoTextFont;
                ctx.textAlign = "center";
                ctx.fillText(this.data.infoTextTop, this.bar_canvas.width/2, this.bar_canvas.height* 0.8);
                ctx.fillText(this.data.infoTextBottom, this.bar_canvas.width/2, this.bar_canvas.height* 0.95);

                // Show buffered ranges 'bins'

                for (var i = 0; i < this.video_el.buffered.length; i++) {

                    var startX = this.video_el.buffered.start(i) * inc;
                    var endX = this.video_el.buffered.end(i) * inc;
                    var width = endX - startX;

                    ctx.fillStyle = "grey";
                    ctx.fillRect(startX, 0, width, this.bar_canvas.height/3);

                }

                // Red bar with already played range

                ctx.fillStyle = this.data.barColor;
                ctx.fillRect(0, 0,
                    (this.video_el.currentTime / this.video_el.duration)*this.bar_canvas.width,
                    this.bar_canvas.height/3);

            }


            // If material is not mapped yet to canvas texture and bar object3D is ready
            // assign canvas as a texture

            if(this.bar.object3D.children.length > 0) {

                // If material is not mapped yet to canvas texture...

                if(this.bar.object3D.children[0].material.map === null) {
                    this.bar.object3D.children[0].material = new THREE.MeshBasicMaterial();
                    this.bar.object3D.children[0].material.map = this.texture;
                }

                this.texture.needsUpdate = true;
            }


        }

        // Save this 't' to last_time

        this.last_time = t;
    }
  }
779179
protected final void tickMedia (AbstractMedia media, long tickStamp)
    {
        if (media._firstTick == 0L) {
            media.willStart(tickStamp);
        }
        media.tick(tickStamp);
    }
212032
function(context) {
      this._context = context;
      if (this.scenes) {
        _.each(this.scenes, function(scene) {
          scene.setContext(context);
        });
      }
    }
449613
def _update_display(self, event=None):
        """"""
        try:
            if self._showvalue:
                self.display_value(self.scale.get())
            if self._tickinterval:
                self.place_ticks()
        except IndexError:
            # happens when configure is called during a orientation change
            # because self.ticks is empty
            pass
443297
function () {

			if ( 'GlobalSettings' in fbxTree && 'AmbientColor' in fbxTree.GlobalSettings ) {

				var ambientColor = fbxTree.GlobalSettings.AmbientColor.value;
				var r = ambientColor[ 0 ];
				var g = ambientColor[ 1 ];
				var b = ambientColor[ 2 ];

				if ( r !== 0 || g !== 0 || b !== 0 ) {

					var color = new THREE.Color( r, g, b );
					sceneGraph.add( new THREE.AmbientLight( color, 1 ) );

				}

			}

		}
975008
def _set_windows(self, ticks, bars):
        
        self.tick_window = ticks
        self.bar_window = bars
32522
function () {
            each(this.series, function (serie) {
                serie.translate();
                if (serie.setTooltipPoints) {
                    serie.setTooltipPoints();
                }
                serie.render();
            });
        }
1312856
def sync(self):
        
        layerData = self.layerData()
        for item in self.scene().items():
            try:
                if item._layer == self:
                    item.syncLayerData(layerData)
            except AttributeError:
                continue
867416
private void drawTicks() {
		// Abort if not attached
		if (!isAttached()) {
			return;
		}

		// Draw the ticks
		int lineWidth = lineElement.getOffsetWidth();
		if (numTicks > 0) {
			// Create the ticks or make them visible
			for (int i = 0; i <= numTicks; i++) {
				Element tick = null;
				if (i < tickElements.size()) {
					tick = tickElements.get(i);
				} else { // Create the new tick
					tick = DOM.createDiv();
					DOM.setStyleAttribute(tick, "position", "absolute");
					DOM.setStyleAttribute(tick, "display", "none");
					DOM.appendChild(getElement(), tick);
					tickElements.add(tick);
				}
				if (enabled) {
					DOM.setElementProperty(tick, "className", SLIDER_TICK);
				} else {
					DOM.setElementProperty(tick, "className", SLIDER_TICK + " "
							+ SLIDER_TICK_SLIDING);
				}
				// Position the tick and make it visible
				DOM.setStyleAttribute(tick, "visibility", "hidden");
				DOM.setStyleAttribute(tick, "display", "");
				int tickWidth = tick.getOffsetWidth();
				int tickLeftOffset = lineLeftOffset + (lineWidth * i / numTicks) - (tickWidth / 2);
				tickLeftOffset = Math.min(tickLeftOffset, lineLeftOffset + lineWidth - tickWidth);
				DOM.setStyleAttribute(tick, "left", tickLeftOffset + "px");
				DOM.setStyleAttribute(tick, "visibility", "visible");
			}

			// Hide unused ticks
			for (int i = (numTicks + 1); i < tickElements.size(); i++) {
				DOM.setStyleAttribute(tickElements.get(i), "display", "none");
			}
		} else { // Hide all ticks
			for (Element elem : tickElements) {
				DOM.setStyleAttribute(elem, "display", "none");
			}
		}
	}
767578
function(tick) {
			var list = this._tempname.handlers[tick.type];
			if (list) {
				list.slice().forEach(function(handler) {
					handler.ontick(tick);
				});
			}
		}
474239
private void touchFixed() {
        assert this.dense;
        assert this.level == 0;
        assert this.schedule;
        while (this.touched < this.trail.size()) {
            final int lit = this.trail.get(this.touched++);
            assert val(lit) > 0;
            assert var(lit).level() == 0;
            final CLOccs os = occs(lit);
            for (final CLClause c : os) {
                for (int i = 0; i < c.lits().size(); i++) {
                    final int other = c.lits().get(i);
                    if (val(other) == VALUE_TRUE) { continue; }
                    assert other != lit;
                    touch(other);
                }
            }
        }
    }
1277082
private void tick(long tickIntervalMs) {
        for (int i = 0; i < NUM_AVERAGES; ++i) {
            stat[i].tick(tickIntervalMs);
        }
    }
136203
def _init(self):
        """"""
        for label in self.ticklabels:
            label.destroy()
        self.label.place_forget()
        self.ticks = []
        self.ticklabels = []
        if self._resolution > 0:
            nb_steps = round((self.scale.cget('to') - self.scale.cget('from')) / self._resolution)
            self.scale.configure(to=self.scale.cget('from') + nb_steps * self._resolution)
            self._extent = self.scale.cget('to') - self.scale.cget('from')
        if str(self.scale.cget('orient')) == "horizontal":
            self.get_scale_length = self.scale.winfo_width
            self.display_value = self._display_value_horizontal
            self._update_slider_length = self._update_slider_length_horizontal
            self.place_ticks = self._place_ticks_horizontal
            self._init_horizontal()
        else:
            self.get_scale_length = self.scale.winfo_height
            self.display_value = self._display_value_vertical
            self._update_slider_length = self._update_slider_length_vertical
            self.place_ticks = self._place_ticks_vertical
            self._init_vertical()
        self.scale.lift()
        try:
            self._var.trace_remove('write', self._trace)
            self._trace = self._var.trace_add('write', self._increment)
        except AttributeError:
            # backward compatibility
            self._var.trace_vdelete('w', self._trace)
            self._trace = self._var.trace('w', self._increment)
        self._update_slider_length()
933407
protected void tickAllMedia (long tickStamp)
    {
        // we use _tickpos so that it can be adjusted if media is added or removed during the tick
        // dispatch
        for (_tickpos = 0; _tickpos < _media.size(); _tickpos++) {
            tickMedia(_media.get(_tickpos), tickStamp);
        }
        _tickpos = -1;
    }
1187192
def tick(self):
        """"""

        instant_rate = float(self.value) / float(self.tick_interval)

        with self.lock:
            if self.initialized:
                self.rate += (self.alpha * (instant_rate - self.rate))
            else:
                self.initialized = True
                self.rate = instant_rate

            self.value = 0
813936
def plotit(self):
        '''
        
        '''
        [self._plot(i) for i in range(len(self.plots))]
745630
public void tick() {
	log.trace("Tick {}", cycles);

	cycles++;

	// check for robots up for unblocking
	for (BlockedEntry entry : blockedCollection) {
	    if (entry.getTimeout() >= cycles) {
		entry.getSync().release();
	    }
	}
    }