Stops the given animation.

@param {Integer} id Unique animation ID
@return {Boolean} Whether the animation was stopped (aka, was running before)
185614
function(id) {
			var cleared = running[id] != null;
			if (cleared) {
				running[id] = null;
			}

			return cleared;
		}
1347925
function(id) {
            if (!Crafty.support.audio) return;
            var c;
            for (var i in this.channels) {
                c = this.channels[i];
                if ((!id && c.active) || c._is(id)) {
                    c.active = false;
                    c.obj.pause();
                }
            }
            return;
        }
1259680
function stopAnimation() {
    if (isIE8) {
      return;
    }
    // hide animation-element
    removeClass(CTX.box, _const_class_prefix + '-loading');
    // stop animation
    if (!isIE9 && typeof CTX.opt.loadingAnimation !== 'string' && CTX.opt.loadingAnimation) {
      clearInterval(animationInt);
      // do not use animationChildren.length here due to IE8/9 bugs
      for (var i = 0; i < animationChildren.length; i++) {
        removeClass(animationChildren[i], _const_class_prefix + '-active');
      }
    }
  }
860693
public void onWindowClosed(Integer id) {
    services.onWindowClosed(id);
    services.getWindowManager().removeWindow(id);
    services.getDebugger().cleanUpRuntimes(id);
  }
1306032
function  () {
        if (this._intervalId) {
            clearInterval(this._intervalId);
            this._intervalId = undefined;
            this.trigger(this.options.stoppedEventName, this);
            return true;
        }
        return false;
    }
956185
@Override
    public void dismiss(int id) {
        if (restartables.get(id) != null)
            restartables.get(id).dismiss();
    }
519722
public static function cancelTimeout($id)
    {
        if (isset(self::$list[$id])) {
            self::$list[$id]->cancel();
        }
    }
378817
void stopAnimation() {
        mAnimation = null;
        mTransformation = null;
        if (mIndeterminateDrawable instanceof Animatable) {
            ((Animatable) mIndeterminateDrawable).stop();
            mShouldStartAnimationDrawable = false;
        }
        postInvalidate();
    }
189996
public void cancel(long id) {

		// Lookup the background call for the given id.
		Caller cancel = backgroundCalls.get(id);
		if(cancel == null) {
			return;
		}

		// Cancel the thread
		cancel.cancel();

		try {
			// Wait for the thread
			cancel.join();
		} catch (InterruptedException ex) {
			// Ignore this
		}

	}
378217
function(id, internal) {
         var self = this;

         // If the sound hasn't loaded, add it to the load queue to stop when capable.
         if (self._state !== 'loaded' || self._playLock) {
           self._queue.push({
             event: 'stop',
             action: function() {
               self.stop(id);
             }
           });

           return self;
         }

         // If no id is passed, get all ID's to be stopped.
         var ids = self._getSoundIds(id);

         for (var i=0; i<ids.length; i++) {
           // Clear the end timer.
           self._clearTimer(ids[i]);

           // Get the sound.
           var sound = self._soundById(ids[i]);

           if (sound) {
             // Reset the seek position.
             sound._seek = sound._start || 0;
             sound._rateSeek = 0;
             sound._paused = true;
             sound._ended = true;

             // Stop currently running fades.
             self._stopFade(ids[i]);

             if (sound._node) {
               if (self._webAudio) {
                 // Make sure the sound's AudioBufferSourceNode has been created.
                 if (sound._node.bufferSource) {
                   if (typeof sound._node.bufferSource.stop === 'undefined') {
                     sound._node.bufferSource.noteOff(0);
                   } else {
                     sound._node.bufferSource.stop(0);
                   }

                   // Clean up the buffer source.
                   self._cleanBuffer(sound._node);
                 }
               } else if (!isNaN(sound._node.duration) || sound._node.duration === Infinity) {
                 sound._node.currentTime = sound._start || 0;
                 sound._node.pause();
               }
             }

             if (!internal) {
               self._emit('stop', sound._id);
             }
           }
         }

         return self;
       }
1168632
public void stopAnimation() {
        if(widget != null) {
            widget.removeStyleName("animated");
            widget.removeStyleName(transition.getCssName());
            widget.removeStyleName(CssName.INFINITE);
        }
    }
29962
def unpause(self, id): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.post(self.base+str(id)+'/unpause/')
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);
            }
        }
    }
617142
function stopClipWithData(playClipData) {
  const id = playClipData.intervalId;

  if (typeof id !== 'undefined') {
    playClipData.intervalId = undefined;
    if (playClipData.usingFrameTimeVector) {
      clearTimeout(id);
    } else {
      clearInterval(id);
    }
  }
}
789380
private void stopPondLife(int id)
    {
        PondLife pl = null;
        synchronized(this)
        {
            pl=_pondLife[id];
            if (pl!=null)
            {
                _pondLife[id]=null;
                _index[--_size]=id;
                if (_available>_size)
                    _available=_size;
            }
        }
        if (pl!=null)
            pl.leavePool();
    }
1044052
function(id, obj) {
    if (isFunction(obj)) obj = { run: obj };
    if (!obj.stop) obj.noStop = 1;
    delete obj.initialize;
    obj.id = id;
    commands[id] = CommandAbstract.extend(obj);
    return this;
  }
1273628
function pause(id) {
  if (!timers[id]) return start(id);

  timers[id].elapsed += msDiff(process.hrtime(), timers[id].start);
}