Update the animation cycle without draw the image, useful
for keeping two animations in sync

@deprecated
424967
public void updateNoDraw() {
		if (autoUpdate) {
			long now = getTime();
			long delta = now - lastUpdate;
			if (firstUpdate) {
				delta = 0;
				firstUpdate = false;
			}
			lastUpdate = now;
			nextFrame(delta);
		}
	}
270595
public void startBackgroundIconColorFadeAnimation(final int cycleCount) {
        if (backgroundIcon == null) {
            LOGGER.warn("Background animation skipped because background icon not set!");
            return;
        }
        backgroundIconColorFadeAnimation = Animations.createFadeTransition(backgroundIcon, JFXConstants.TRANSPARENCY_FULLY, JFXConstants.TRANSPARENCY_NONE, cycleCount, JFXConstants.ANIMATION_DURATION_FADE_SLOW);
        backgroundIconColorFadeAnimation.setOnFinished(event -> backgroundIcon.setOpacity(JFXConstants.TRANSPARENCY_FULLY));
        backgroundIconColorFadeAnimation.play();
    }
1092606
def OnUpdateFigurePanel(self, event):
        """"""

        if self.updating:
            return

        self.updating = True
        self.figure_panel.update(self.get_figure(self.code))
        self.updating = False
50695
def update(self, **kwargs):
        

        # Update node properties with additional elements
        svg_changed = False
        for prop in kwargs:
            if prop == "drawing_id":
                pass  # No good reason to change a drawing_id
            elif getattr(self, prop) != kwargs[prop]:
                if prop == "svg":
                    # To avoid spamming client with large data we don't send the svg if the SVG didn't change
                    svg_changed = True
                setattr(self, prop, kwargs[prop])
        data = self.__json__()
        if not svg_changed:
            del data["svg"]
        self._project.controller.notification.emit("drawing.updated", data)
        self._project.dump()
1047487
private void resetAnimation(){		
		mLastUpdateTime = SystemClock.uptimeMillis();
		mLastProgressStateTime = mLastUpdateTime;
		mStartAngle = mInitialAngle;
		mStrokeColorIndex = 0;
		mSweepAngle = mReverse ? -mMinSweepAngle : mMinSweepAngle;
	}
374356
public void imageUpdate(ImageReader source, BufferedImage theImage,
            int minX, int minY, int width, int height, int periodX,
            int periodY, int[] bands)
    {
        if (image == null || !image.equals(theImage))
        {
            repaint(0);
            image = theImage;
        }
    }
267606
function(xy) {
        if(this.kinetic) {
            this.kinetic.update(xy);
        }
        this.panned = true;
        this.map.pan(
            this.handler.last.x - xy.x,
            this.handler.last.y - xy.y,
            {dragging: true, animate: false}
        );
    }
45899
function nextAnim() {
    const anim = config.animations[++index];
    if (anim) {

        const encoder = new GIFEncoder(app.view.width, app.view.height);

        // Stream output
        encoder.createReadStream().pipe(fs.createWriteStream(
            path.join(outputPath, anim.filename + '.gif')
        ));

        encoder.start();
        encoder.setRepeat(0);   // 0 for repeat, -1 for no-repeat
        encoder.setDelay(anim.delay || 500);  // frame delay in ms
        encoder.setQuality(10); // image quality. 10 is default.

        // Add the frames
        anim.frames.forEach((frame) => {
            encoder.addFrame(frames[frame]);
            delete frames[frame];
        });

        encoder.finish();

        // Wait for next stack to render next animation
        setTimeout(nextAnim, 0);
    }
    else {
        complete();
    }
}
1196020
def _update_method(self, view):
        
        method = self._method
        if method == 'auto':
            if view.transforms.get_transform().Linear:
                method = 'subdivide'
            else:
                method = 'impostor'
        view._method_used = method

        if method == 'subdivide':
            view.view_program['method'] = 0
            view.view_program['a_position'] = self._subdiv_position
            view.view_program['a_texcoord'] = self._subdiv_texcoord
        elif method == 'impostor':
            view.view_program['method'] = 1
            view.view_program['a_position'] = self._impostor_coords
            view.view_program['a_texcoord'] = self._impostor_coords
        else:
            raise ValueError("Unknown image draw method '%s'" % method)

        self.shared_program['image_size'] = self.size
        view._need_method_update = False
        self._prepare_transforms(view)
31153
function invalidate(chart) {
	if (chart.animating) {
		return;
	}

	// `chart.animating` can be `false` even if there is animation in progress,
	// so let's iterate all animations to find if there is one for the `chart`.
	var animations = Chart.animationService.animations;
	for (var i = 0, ilen = animations.length; i < ilen; ++i) {
		if (animations[i].chart === chart) {
			return;
		}
	}

	// No render scheduled: trigger a "lazy" render that can be canceled in case
	// of hover interactions. The 1ms duration is a workaround to make sure an
	// animation is created so the controller can stop it before any transition.
	chart.render({duration: 1, lazy: true});
}
538592
def updateUi(self):
        
        index = self._slideshow.currentIndex()
        count = self._slideshow.count()
        
        self._previousButton.setVisible(index != 0)
        self._nextButton.setText('Finish' if index == count - 1 else 'Next')
        self.autoLayout()
103564
function() {
        var options = this.options,
            animation = options.animation;

        // Cycling more than the show amount causes unexpected issues
        if (options.itemsToCycle > options.itemsToShow) {
            options.itemsToCycle = options.itemsToShow;
        }

        // Fade animations can only display 1 at a time
        if (animation === 'fade') {
            options.itemsToShow = options.itemsToCycle = 1;
            options.infinite = false;

        // Determine the dimension and position based on animation
        } else if (animation === 'slide-up') {
            this._dimension = 'height';
            this._position = 'top';

        } else if (animation === 'slide') {
            this._dimension = 'width';
            this._position = options.rtl ? 'right' : 'left';
        }
    }
1267176
public void updateBackground(MotionModel homeToCurrent, T frame) {
		worldToHome.concat(homeToCurrent, worldToCurrent);
		worldToCurrent.invert(currentToWorld);

		// find the distorted polygon of the current image in the "home" background reference frame
		transform.setModel(currentToWorld);
		transform.compute(0, 0, corners[0]);
		transform.compute(frame.width-1,0,corners[1]);
		transform.compute(frame.width-1,frame.height-1,corners[2]);
		transform.compute(0, frame.height-1, corners[3]);

		// find the bounding box
		int x0 = Integer.MAX_VALUE;
		int y0 = Integer.MAX_VALUE;
		int x1 = -Integer.MAX_VALUE;
		int y1 = -Integer.MAX_VALUE;

		for (int i = 0; i < 4; i++) {
			Point2D_F32 p = corners[i];
			int x = (int)p.x;
			int y = (int)p.y;

			if( x0 > x ) x0 = x;
			if( y0 > y ) y0 = y;
			if( x1 < x ) x1 = x;
			if( y1 < y ) y1 = y;
		}
		x1++;y1++;

		if( x0 < 0 ) x0 = 0;
		if( x1 > backgroundWidth ) x1 = backgroundWidth;
		if( y0 < 0 ) y0 = 0;
		if( y1 > backgroundHeight ) y1 = backgroundHeight;

		updateBackground(x0,y0,x1,y1,frame);
	}
1310477
function () {
        var data = this.data;
        var targetEl = this.data.target;

        // Only set up once.
        if (targetEl.dataset.setImageFadeSetup) { return; }
        targetEl.dataset.setImageFadeSetup = true;

        // Create animation.
        targetEl.setAttribute('animation__fade', {
            property: 'material.color',
            startEvents: 'set-image-fade',
            dir: 'alternate',
            dur: data.dur,
            from: '#FFF',
            to: '#000'
        });
    }
107922
private void updateArt(TrackMetadataUpdate update, AlbumArt art) {
        hotCache.put(DeckReference.getDeckReference(update.player, 0), art);  // Main deck
        if (update.metadata.getCueList() != null) {  // Update the cache with any hot cues in this track as well
            for (CueList.Entry entry : update.metadata.getCueList().entries) {
                if (entry.hotCueNumber != 0) {
                    hotCache.put(DeckReference.getDeckReference(update.player, entry.hotCueNumber), art);
                }
            }
        }
        deliverAlbumArtUpdate(update.player, art);
    }
875429
function () {
        var self = this;

        this._running = true;
        this._time = Date.now();

        this._pausedTime = 0;

        var requestAnimationFrame = vendor.requestAnimationFrame;

        function step() {
            if (self._running) {

                requestAnimationFrame(step);

                if (!self._paused) {
                    self._update();
                }
            }
        }

        requestAnimationFrame(step);

    }
1030269
function (dt) {
            if (this.isAnimated) {
                var result = false;
                for (var i = 0; i < this.animatedTilesets.length; i++) {
                    result = this.animatedTilesets[i].update(dt) || result;
                }
                return result;
            }

            return false;
        }