Stop a running scene. If there's a scene on the stack, it resumes.
165542
def on_stop_scene(self, event: events.StopScene, signal: Callable[[Any], None]):
        
        self.stop_scene()
        if self.current_scene is not None:
            signal(events.SceneContinued())
        else:
            signal(events.Quit())
477629
def stop(self):
        
        self.camera._get_config()['actions']['movie'].set(False)
        self.videofile = self.camera._wait_for_event(
            event_type=lib.GP_EVENT_FILE_ADDED)
        if self._old_captarget != "Memory card":
            self.camera.config['settings']['capturetarget'].set(
                self._old_captarget)
336512
def _stop_instance(self):
        """"""
        instance = self._get_instance()
        instance.stop()
        self._wait_on_instance('stopped', self.timeout)
310756
def stop(self):
        '''
        
        '''
        # avoid getting called twice
        self.cleanup()
        if self.running:
            self.running = False
            self.timer_stop.set()
            self.timer.join()
1330628
def stop(self):
        
        self._running.clear()
        with self._lock:
            if self._timer:
                self._timer.cancel()
            self._timer = None
1079803
def stop
      if(@runner.nil? && @stop)
        raise NotRunning.new
      elsif(@runner.nil? || !@runner.alive?)
        @stop = true
        @runner = nil
      else
        @stop = true
        if(@runner)
          @runner.raise Resync.new if @runner.alive? && @runner.stop?
          @runner.join(0.05) if @runner
          @runner.kill if @runner && @runner.alive?
        end
        @runner = nil
      end
      nil
    end
139721
def on_start_scene(self, event: StartScene, signal: Callable[[Any], None]):
        
        self.pause_scene()
        self.start_scene(event.new_scene, event.kwargs)
1000095
def stop(self, actor=None):
        
        if actor is None:
            actor = get_actor()
        if actor and actor.is_arbiter():
            monitor = actor.get_actor(self.name)
            if monitor:
                return monitor.stop()
        raise RuntimeError('Cannot stop application')
550480
def stop(self):
        """"""
        self._stop_event.set()
        if not self.persistence:
            return
        if self._cancel_save is not None:
            self._cancel_save()
            self._cancel_save = None
        self.persistence.save_sensors()
599494
def stop(self):
        
        if not self._started:
            raise NotRunningError("This AutobahnSync instance is not started")
        self._callbacks_runner.stop()
        self._started = False
605815
def stop(self, actor, exc=None, exit_code=None):
        
        if actor.state <= ACTOR_STATES.RUN:
            # The actor has not started the stopping process. Starts it now.
            actor.state = ACTOR_STATES.STOPPING
            actor.event('start').clear()
            if exc:
                if not exit_code:
                    exit_code = getattr(exc, 'exit_code', 1)
                if exit_code == 1:
                    exc_info = sys.exc_info()
                    if exc_info[0] is not None:
                        actor.logger.critical('Stopping', exc_info=exc_info)
                    else:
                        actor.logger.critical('Stopping: %s', exc)
                elif exit_code == 2:
                    actor.logger.error(str(exc))
                elif exit_code:
                    actor.stream.writeln(str(exc))
            else:
                if not exit_code:
                    exit_code = getattr(actor._loop, 'exit_code', 0)
            #
            # Fire stopping event
            actor.exit_code = exit_code
            actor.stopping_waiters = []
            actor.event('stopping').fire()

            if actor.stopping_waiters and actor._loop.is_running():
                actor.logger.info('asynchronous stopping')
                # make sure to return the future (used by arbiter for waiting)
                return actor._loop.create_task(self._async_stopping(actor))
            else:
                if actor.logger:
                    actor.logger.info('stopping')
                self._stop_actor(actor)

        elif actor.stopped():
            return self._stop_actor(actor, True)
541033
def Stop(self):
    """"""
    self._Close()

    if self._rpc_thread.isAlive():
      self._rpc_thread.join()
    self._rpc_thread = None
1317893
def stop(self):
        
        # Check that everything is running
        if not self._running:
            logging.warning('Webcam not running. Aborting stop')
            return False

        if self._cap:
            self._cap.release()
            self._cap = None
        self._running = False

        return True
427667
def stop(self):
        
        # check that everything is running
        if not self._running:
            logging.warning('Realsense not running. Aborting stop.')
            return False

        self._pipe.stop()
        self._running = False
        return True
436541
async def stop(self):
        """"""

        if self._rpc_task is not None:
            self._rpc_task.cancel()

        try:
            await self._rpc_task
        except asyncio.CancelledError:
            pass

        self._rpc_task = None
378817
void stopAnimation() {
        mAnimation = null;
        mTransformation = null;
        if (mIndeterminateDrawable instanceof Animatable) {
            ((Animatable) mIndeterminateDrawable).stop();
            mShouldStartAnimationDrawable = false;
        }
        postInvalidate();
    }
12847
def stop(self):
        """"""
        if not self.stopped:
            self.stopped = True
            if self.pendingHeartbeat is not None:
                self.pendingHeartbeat.cancel()
                self.pendingHeartbeat = None