Emit SIGINT event.
@returns {void}
963579
function emitSIGINT() {
    if (rl) {
        rl.close()
        rl = null
    }
    if (ipcListener) {
        process.removeListener("message", ipcListener)
        ipcListener = null
    }

    emitter.emit("SIGINT")
}
208789
function (input) {
    var self = this;
    var state = this.state;

    function emit(withState) {
      self.manager.emit(self.options.event + (withState ? stateStr(state) : ''), input);
    }

    // 'panstart' and 'panmove'
    if (state < STATE_ENDED) {
      emit(true);
    }

    emit(); // simple 'eventName' events

    // panend and pancancel
    if (state >= STATE_ENDED) {
      emit(true);
    }
  }
1282709
function emit() {
  if (arguments.length) this.emitted.push(arguments);
  while (!this.paused && this.emitted.length && this.readable) {
    var emitArgs = this.emitted.shift();
    this.emit.apply(this, emitArgs);
    if (emitArgs[0] == 'end') {
      this.readable = false;
    }
  }
}
99607
public EventBus emitAsync(Enum<?> event, Object... args) {
        return _emitWithOnceBus(eventContextAsync(event, args));
    }
1314098
function initApi(opts) {
	var logMarker = require.emitter.id + ':' + process.pid
	log = function () {
		console.log(logMarker, util.format.apply(this, Array.prototype.slice.call(arguments)))
	}
	var logger

	if (Array.isArray(opts.ignoredSignals)) 	opts.ignoredSignals.forEach(function (signal) {
		process.on(signal, getSignalHandler(signal))
	})


	if (process.send) {
		logger = new rotatedlogger.RotatedLog({stdout: false, file: true, streamOpts: {logFile: opts.logName}})

		process.stdin.setEncoding('utf-8') // returns undefined
		process.stdin.on('data', stdinDataListener) // returns this
			.once('close', stdinCloseListener)
			.resume()
		process.send('ok') // let parent know we are ready
	} else {
		log('Fatal: ipc not available')
		shutdown()
	}

	function stdinDataListener(data) {
		logger.write(data)
	}
	function stdinCloseListener() {
		log('Detected pipe close')
		logger.write('Log pipe close event ' + (new Date).toISOString())
		logger.close(cleanup)
	}

	function cleanup(err) {
		if (err) log('logger.close:', err)
		process.stdin.removeListener('data', stdinDataListener)
		process.stdin.removeListener('close', stdinCloseListener)
		process.stdin.pause()
		logger = null
		shutdown()
	}

	function shutdown() {
		apprunner.shutdown()
	}
}
1303972
def send_sigint(self) -> None:
        """"""
        import signal
        if sys.platform.startswith('win'):
            signal_to_send = signal.CTRL_C_EVENT
        else:
            signal_to_send = signal.SIGINT
        self._proc.send_signal(signal_to_send)
547004
function emitElement(element, name, onLeave) {
  if (Array.isArray(element)) {
    var i;
    for (i = 0; i < element.length - 1; i++) {
      emitOneElement.call(this, element[i], name);
    }
    emitOneElement.call(this, element[i], name, onLeave);
  } else {
    emitOneElement.call(this, element, name, onLeave);
  }
}
1153325
function(events,fct) {
            
            var that=this;
                              
            function offFct() {
                that.off(events,fct);
                that.off(events,offFct);
            }
            
            this.on(events,fct);
            this.on(events,offFct);
            
            return this;
        }
212568
function onVolumeChange() {
		const volumePercentage = media.muted ? 0 : media.volume;
		const isMuted = !volumePercentage;

		$(self.volume, { 'aria-valuenow': volumePercentage, 'aria-valuemin': 0, 'aria-valuemax': 1 });

		const dirIsInline = /^(ltr|rtl)$/i.test(volumeDir);
		const axisProp = dirIsInline ? 'width' : 'height';

		self.volumeMeter.style[axisProp] = `${volumePercentage * 100}%`;

		$(self.mute, { 'aria-label': isMuted ? lang.unmute || 'unmute' : lang.mute || 'mute' });
		$(self.muteSymbol, { 'aria-hidden': isMuted });
		$(self.unmuteSymbol, { 'aria-hidden': !isMuted });
	}
624639
function onDeactivateEvent() {
         // release pointer events
         me.input.releasePointerEvent("pointerdown", this);
         me.input.releasePointerEvent("pointerup", this);
         me.input.releasePointerEvent("pointercancel", this);
         me.input.releasePointerEvent("pointerenter", this);
         me.input.releasePointerEvent("pointerleave", this);
         me.timer.clearTimeout(this.holdTimeout);
       }
758223
function EventEmitter(isAsync) {
        if (isAsync === void 0) { isAsync = false; }
        var _this = _super.call(this) || this;
        _this.__isAsync = isAsync;
        return _this;
    }
31340
function getEmitter(config) {
      function Emitter(n) {
        n = n || this;
        n.__events = n.__events || {};
        n.__once = n.__once || {};
      }

      Emitter.prototype.on = function(name, fn) {
        fn = fn || Function();
        this.__events[name] = (this.__events[name] || [])
        this.__events[name].push(fn);
      }

      Emitter.prototype.once = function(name, fn) {
        fn = fn || Function();
        this.__once[name] = (this.__once[name] || []);
        this.__once[name].push(fn);
      }

      Emitter.prototype.off = function(name, fn) {
        var i;

        fn = fn || Function();
        i = (this.__events[name] || []).indexOf(fn);
        if (~i) this.__events[name].splice(i, 1);

        i = (this.__once[name] || []).indexOf(fn);
        if (~i) this.__once[name].splice(i, 1);
      }

      Emitter.prototype.emit = function(name) {
        var args = [].slice.call(arguments),
            es = (this.__events[name] || []).slice(),
            i, self = this;

        args.shift();
        es.push.apply(es, this.__once[name] || []);

        for (i = 0; i < es.length; i++) {
          es[i].apply(self, args);
        }

        this.__once[name] = [];
      }

      Emitter.prototype.emitCtx = function(name, ctx) {
        var args = [].slice.call(arguments),
            es = (this.__events[name] || []).slice(),
            i, self = this;

        args.shift(); args.shift();
        es.push.apply(es, this.__once[name] || []);

        for (i = 0; i < es.length; i++) {
          es[i].apply(ctx, args);
        }

        this.__once[name] = [];
      }

      return Emitter;
    }
991276
function() {
		
		if (!this.__destroyed) {
			this.__$emitterPublic.off.apply(this.__$emitterPublic, Array.prototype.slice.apply(arguments));
		}
		
		return this;
	}
858076
function isSoftNewlineEvent(event: Object): boolean {
  return (
    event.which === 13 &&
    (event.getModifierState('Shift') ||
      event.getModifierState('Alt') ||
      event.getModifierState('Control'))
  );
}
1228628
def _sig_handler(self, signum, stack):
        '''
        
        '''
        log_debug("Got SIGINT.")
        if signum == signal.SIGINT:
            LLNetReal.running = False
            if self._pktqueue.qsize() == 0:
                # put dummy pkt in queue to unblock a 
                # possibly stuck user thread
                self._pktqueue.put( (None,None,None) )
643900
function emitSDAMEvent(self, event, description) {
  if (self.listeners(event).length > 0) {
    self.emit(event, description);
  }
}
151164
function() {
        this.fireEvent('hiding');

        if (this.shadow) {
            this.shadow.val('');
        }

        this.input.aria('expanded', false);
        this.element.conceal();

        this.fireEvent('hidden');
    }