Unpause the animation.
509556
def unpause(self):
        
        self._pause_level -= 1
        if not self._pause_level:
            self._offset = self._paused_time - self._clock()
932794
def stop(self):
        
        if not self._enabled:
            return self

        if self._spinner_thread:
            self._stop_spinner.set()
            self._spinner_thread.join()

        self._frame_index = 0
        self._spinner_id = None
        self.clear()

        if self._stream.isatty():
            cursor.show(stream=self._stream)

        return self
1226360
private void stopLoadingAnimation() {

        if (m_loadingTimer != null) {
            m_loadingTimer.cancel();
        }
        if (m_clientLoading) {
            m_contentWrapper.remove(m_loadingPanel);
            doResize();
            m_clientLoading = false;
        }
    }
378338
private void resetAnimation(){		
		mLastUpdateTime = SystemClock.uptimeMillis();
		mLastProgressStateTime = mLastUpdateTime;
		if(mProgressMode == ProgressView.MODE_INDETERMINATE){
			mStartLine = mReverse ? getBounds().width() : 0;
			mStrokeColorIndex = 0;
			mLineWidth = mReverse ? -mMinLineWidth : mMinLineWidth;
			mProgressState = PROGRESS_STATE_STRETCH;
		}
		else if(mProgressMode == ProgressView.MODE_BUFFER){
			mStartLine = 0;
		}	
		else if(mProgressMode == ProgressView.MODE_QUERY){
			mStartLine = !mReverse ? getBounds().width() : 0;
			mStrokeColorIndex = 0;
			mLineWidth = !mReverse ? -mMaxLineWidth : mMaxLineWidth;
		}		
	}
368094
def mute(self):
        """"""
        response = self.rendering_control.GetMute(InstanceID=1, Channel=1)
        return response.CurrentMute == 1
1104383
public void stop()
    {
        if (!mIsRunning || (mAnimations.size() == 0))
        {
            return;
        }
        GVRAnimation anim = mAnimations.get(0);
        mIsRunning = false;
        anim.setOnFinish(null);
        for (int i = 0; i < mAnimations.size(); ++i)
        {
            anim = mAnimations.get(i);
            getGVRContext().getAnimationEngine().stop(anim);
        }
    }
1328713
protected void halt ()
    {
        // only do something if we're actually animating
        if (_animMode != NO_ANIMATION) {
            // disable animation
            setAnimationMode(NO_ANIMATION);
            // come to a halt looking settled and at peace
            String rest = getRestingAction();
            if (rest != null) {
                setActionSequence(rest);
            }
        }
    }
14910
public void close() {
        if (animation != null) {
            animation.setRate(-1);
            animation.play();
            animation.setOnFinished(e -> {
                closeDialog();
            });
        } else {
            setOpacity(0);
            setVisible(false);
            closeDialog();
        }

    }
1051240
def pause(self) -> None:
        """"""
        with self.__state_lock:
            if self.__state == DataChannelBuffer.State.started:
                self.__state = DataChannelBuffer.State.paused
536011
def interrupt(self):
		
		self.image = io.BytesIO()
		self.renderer.screen.save(self.image, "png")
1156001
def unbake(self):
        """"""
        for key in self.dct:
            # pop __abs_time__ if it exists
            self.dct[key].pop('__abs_time__', None)
        self.is_baked = False
1012717
private void stopLoadingAnimation() {

        if (m_loadingTimer != null) {
            m_loadingTimer.cancel();
        }
        if (m_clientLoading) {
            m_mainPanel.removeLoadingAnimation();
            m_clientLoading = false;
        }
    }
1135005
def disable(self):
        """"""
        for arr in self:
            if arr.psy.plotter:
                arr.psy.plotter.disabled = True
446937
public void stop() {
        status = Status.STOPPED;

        // Remove all callbacks
        slideHandler.removeCallbacksAndMessages(null);

        // TODO Use the out transition to hide the current view
        // Hide all visible views
        removeAllViews();
        recycledViews.clear();
    }
605018
public void dismiss(){
		if(mState != STATE_SHOWN)
			return;
		
		removeCallbacks(mDismissRunnable);

        if(mOutAnimation != null){
            mOutAnimation.cancel();
            mOutAnimation.reset();
            mOutAnimation.setAnimationListener(new Animation.AnimationListener() {
				
				@Override
				public void onAnimationStart(Animation animation) {
					setState(STATE_DISMISSING);
				}
				
				@Override
				public void onAnimationRepeat(Animation animation) {}
				
				@Override
				public void onAnimationEnd(Animation animation) {
					if(mRemoveOnDismiss && getParent() != null && getParent() instanceof ViewGroup)
						((ViewGroup)getParent()).removeView(SnackBar.this);
					
					setState(STATE_DISMISSED);
                    setVisibility(View.GONE);
				}
			});
            clearAnimation();
			startAnimation(mOutAnimation);
		}
		else{
			if(mRemoveOnDismiss && getParent() != null && getParent() instanceof ViewGroup)
				((ViewGroup)getParent()).removeView(this);
			
			setState(STATE_DISMISSED);
            setVisibility(View.GONE);
		}		
		
	}
117300
def stop(self) -> None:
        """"""
        self._running = False
        if self._timeout is not None:
            self.io_loop.remove_timeout(self._timeout)
            self._timeout = None
1241832
public void unpause ()
    {
        // Don't unpause the timer if it wasn't paused to begin with
        if (_lastUpdate == Long.MIN_VALUE || _start == Long.MIN_VALUE) {
            return;
        }

        // Adjust the starting time when the timer next ticks
        _processUnpause = true;

        // Start things running again
        _running = true;
    }