Stop a note on a channel.

        If Note.channel is set, it will take presedence over the channel
        argument given here.
357345
def stop_Note(self, note, channel=1):
        
        if hasattr(note, 'channel'):
            channel = note.channel
        self.stop_event(int(note) + 12, int(channel))
        self.notify_listeners(self.MSG_STOP_INT, {'channel': int(channel),
            'note': int(note) + 12})
        self.notify_listeners(self.MSG_STOP_NOTE, {'channel': int(channel),
            'note': note})
        return True
792675
def handle_note(self, note, command='', training_input=''):
		
		shutit_global.shutit_global_object.yield_to_draw()
		if self.build['walkthrough'] and note != None and note != '':
			assert isinstance(note, str), shutit_util.print_debug()
			wait = self.build['walkthrough_wait']
			wrap = '\n' + 80*'=' + '\n'
			message = wrap + note + wrap
			if command != '':
				message += 'Command to be run is:\n\t' + command + wrap
			if wait >= 0:
				self.pause_point(message, color=31, wait=wait)
			else:
				if training_input != '' and self.build['training']:
					if len(training_input.split('\n')) == 1:
						shutit_global.shutit_global_object.shutit_print(shutit_util.colorise('31',message))
						while shutit_util.util_raw_input(prompt=shutit_util.colorise('32','Enter the command to continue (or "s" to skip typing it in): ')) not in (training_input,'s'):
							shutit_global.shutit_global_object.shutit_print('Wrong! Try again!')
						shutit_global.shutit_global_object.shutit_print(shutit_util.colorise('31','OK!'))
					else:
						self.pause_point(message + '\nToo long to use for training, so skipping the option to type in!\nHit CTRL-] to continue', color=31)
				else:
					self.pause_point(message + '\nHit CTRL-] to continue', color=31)
		return True
285022
def __stop(self):  # pragma: no cover
        """"""

        if not self._listener_thread:
            return

        logger.info('Stopping listener')
        self._celery_receiver.should_stop = True
        self._listener_thread.join()
        self._listener_thread = self._celery_receiver = None
572322
public void stop()
    {
        if (mAudioListener != null)
        {
            Log.d("SOUND", "stopping audio source %d %s", getSourceId(), getSoundFile());
            mAudioListener.getAudioEngine().stopSound(getSourceId());
        }
    }
28485
def _stop_transmit(self, stream):
        
        _vv and IOLOG.debug('%r._stop_transmit(%r)', self, stream)
        self.poller.stop_transmit(stream.transmit_side.fd)
261690
def stop_receive(self, stream):
        
        _vv and IOLOG.debug('%r.stop_receive(%r)', self, stream)
        self.defer(self.poller.stop_receive, stream.receive_side.fd)
46207
async def pause(self, pause: bool = True):
        
        self._paused = pause
        await self.node.pause(self.channel.guild.id, pause)
934494
public boolean stop(Long channelId, boolean needTermin) {
        // stop优先级高于pause
        updateStatus(channelId, ChannelStatus.STOP);

        boolean result = !needTermin;

        if (needTermin) {
            try {
                result |= termin(channelId, TerminType.SHUTDOWN);
            } catch (Throwable e) {
                updateStatus(channelId, ChannelStatus.STOP); // 出错了，直接挂起
                throw new ArbitrateException(e);
            }
        }

        return result;
    }
149705
def _end_channel(self, channel):
        
        self.stop_on_empty_queue[channel] = True

        # by joining the we wait until its loop finishes.
        # it won't loop forever since we've set self.stop_on_empty_queue=True
        write_thread = self.thread_write_instances[channel]

        thread_join_non_blocking(write_thread)
901597
def note_off(self, channel, note, velocity):
        """"""
        return self.midi_event(NOTE_OFF, channel, note, velocity)
918069
def cancel(self):
        
        self.sender.send_BasicCancel(self.tag)
        try:
            yield from self.synchroniser.wait(spec.BasicCancelOK)
        except AMQPError:
            pass
        else:
            # No need to call ready if channel closed.
            self.reader.ready()
        self.cancelled = True
        self.cancelled_future.set_result(self)
        if hasattr(self.callback, 'on_cancel'):
            self.callback.on_cancel()
1286071
def turn_off(self, channel, callback=None):
        
        if callback is None:
            def callb():
                """No-op"""
                pass
            callback = callb
        message = velbus.SwitchRelayOffMessage(self._address)
        message.relay_channels = [channel]
        self._controller.send(message, callback)
323871
public final void stop() {
    if (!this.started) {
      log.warn(String.format("Reporter %s has already been stopped.", this.name));
      return;
    }
    try {
      stopImpl();
      this.started = false;
    } catch (Exception exception) {
      log.warn(String.format("Reporter %s did not stop correctly.", this.name), exception);
    }
  }
1009229
def stop(self, signum=None, frame=None):
        self.debug_print("Stopping networking.")

        if self.passive is not None:
            try:
                self.passive.shutdown(1)
            except:
                pass
            self.passive.close()
            self.passive = None

        if self.last_advertise is not None:
            self.rendezvous.leave_fight()

        

        for con in self:
            con.close()

        if signum is not None:
            raise Exception("Process was interrupted.")
511201
def stop_recording(self):
        """"""
        self._stop_recording.set()
        with self._source_lock:
            self._source.stop()
        self._recording = False
919098
def stop(self):
		

		logger.debug("Stopping playback")
		# Stop the clock
		self.clock.stop()
		# Set plauyer status to ready
		self.status = READY
794549
function stop() {
  var time;
  if(!this.enabled) return false;
  time = this._record.isSlowerThan(this._slowerThan);
  if(this._record && time > -1) {
    this._records.unshift(this._record.toArray(id++, time));
    if(this._records.length >= this._maxLen) {
      this._records.pop();
    }
  }
}