Fires a summernote key down event on all registered handlers in the handler
manager. If no such handlers exist, this method will do nothing.

@param source the source of the handlers
@param nativeEvent native key down event
195809
public static void fire(final HasSummernoteKeyDownHandlers source, NativeEvent nativeEvent) {
        if (TYPE != null) {
            SummernoteKeyDownEvent event = new SummernoteKeyDownEvent(nativeEvent);
            source.fireEvent(event);
        }
    }
224847
function msPointerDown(inEvent) {
  this.pointerMap[inEvent.pointerId.toString()] = inEvent;
  const e = this.prepareEvent_(inEvent);
  this.dispatcher.down(e, inEvent);
}
1021866
public final void event(Object source,
                            Class sourceClass,
                            String methodName,
                            Throwable throwable) {
        internalEvent(source,
                      sourceClass,
                      methodName,
                      throwable);
    }
694264
public void deleteCustomerSource(
            @NonNull String sourceId,
            @Nullable SourceRetrievalListener listener) {
        Map<String, Object> arguments = new HashMap<>();
        arguments.put(KEY_SOURCE, sourceId);

        final String operationId = UUID.randomUUID().toString();
        if (listener != null) {
            mSourceRetrievalListeners.put(operationId, listener);
        }
        mEphemeralKeyManager.retrieveEphemeralKey(operationId, ACTION_DELETE_SOURCE, arguments);
    }
752805
@SuppressWarnings("PMD.SwitchStmtsShouldHaveDefault")
  public void dispatch(@NonNull JCacheEntryEvent<K, V> event) {
    try {
      if (event.getSource().isClosed()) {
        return;
      }
      switch (event.getEventType()) {
        case CREATED:
          onCreated(event);
          return;
        case UPDATED:
          onUpdated(event);
          return;
        case REMOVED:
          onRemoved(event);
          return;
        case EXPIRED:
          onExpired(event);
          return;
      }
      throw new IllegalStateException("Unknown event type: " + event.getEventType());
    } catch (Exception e) {
      logger.log(Level.WARNING, null, e);
    } catch (Throwable t) {
      logger.log(Level.SEVERE, null, t);
    }
  }
646046
public void keyReleased(KeyEvent keyEvent) {
        int i = keyEvent.KeyChar;
        int n = keyEvent.KeyCode;
        int m = keyEvent.KeyFunc;
    }
56982
function(nativeEvent, typeOverride) {
  var evt = eventWrapper(nativeEvent);
  if (typeOverride !== undefined) {
    evt.type = typeOverride;
  }
  var activePath = [];
  var elem = evt.target;
  var events;

  /**
   * Handle calling bound functions with the proper targets set
   * @TODO move this outside eventHandler
   * @param  {Element}         elem      DOM element to trigger events on
   * @param  {Array<Function>} funcArr   Array of bound functions to trigger
   * @param  {String}          selector  Selector string that the event was bound to
   * @param  {Element}         delegate  DOM element this event was bound to for delegation
   */
  var triggerEventFunctions = function(elem, funcArr, selector, delegate) {
    var result;
    evt.currentTarget = elem;
    evt.delegateTarget = delegate;
    for (var i = 0; i < funcArr.length; i++) {
      if (!evt.isImmediatePropagationStopped()) {
        evt.vEvent = {
          handler: funcArr[i].method,
          selector: selector
        };

        result = funcArr[i].method(evt);
        if (result === false) {
          falseHandler(evt);
        }
      }
    }
  };

  /**
   * Checks if bound events should fire
   * @param  {Object}    typeEvents        Event object of events to check if should fire
   */
  var checkEvents = function(typeEvents) {
    var elemClasses, elemClass;

    // Iterate over previously passed elements to check for any delegated events
    var activePathLength = activePath.length;
    for (var i = 0; i < activePathLength; i++) {
      elemClasses = activePath[i].classes;
      // Once stopPropagation is called stop
      if (!evt.isPropagationStopped()) {
        var elemClassesLength = elemClasses.length;
        for (var j = 0; j < elemClassesLength; j++) {
          elemClass = elemClasses[j];
          if (typeEvents[elemClass]) {
            triggerEventFunctions(activePath[i].element, typeEvents[elemClass], elemClass, elem);
          }
        }
      }
    }

    // Check for any non-delegated events
    if (!evt.isPropagationStopped() && typeEvents.self) {
      triggerEventFunctions(elem, typeEvents.self);
    }
  };

  while (elem && !evt.isPropagationStopped()) {
    events = module.exports.getEvents(elem);
    if (events) {
      // Generic events
      if (events[evt.type]) {
        checkEvents(events[evt.type]);
      }
    }
    // Create array of class names that match our pattern to check for delegation later
    var elemActiveClasses = module.exports.getActiveClasses(elem);
    if (elemActiveClasses.length) {
      activePath.push({
        element: elem,
        classes: elemActiveClasses
      });
    }
    elem = elem.parentNode;
  }
}
712616
public void setOnkeydown(java.lang.String onkeydown) {
        getStateHelper().put(PropertyKeys.onkeydown, onkeydown);
        handleAttribute("onkeydown", onkeydown);
    }
849112
public static <T> void fire(final HasSlideStopHandlers<T> source, final T value) {
        if (TYPE != null) {
            SlideStopEvent<T> event = new SlideStopEvent<T>(value);
            source.fireEvent(event);
        }
    }
1030440
@Override
	public void userEventTriggered(ChannelHandlerContext ctx, Object msg) throws Exception {
		if (msg instanceof RemoteInputChannel) {
			boolean triggerWrite = inputChannelsWithCredit.isEmpty();

			inputChannelsWithCredit.add((RemoteInputChannel) msg);

			if (triggerWrite) {
				writeAndFlushNextMessageIfPossible(ctx.channel());
			}
		} else {
			ctx.fireUserEventTriggered(msg);
		}
	}
167265
public void fireEvent(final InvalidationEvent event) {
        if (bUpdateInvalidationListener) {
            synchronized (hsInvalidationListeners) {
                if (invalidationListenerCount > 0) {
                    currentInvalidationListeners = new InvalidationListener[invalidationListenerCount];
                    hsInvalidationListeners.toArray(currentInvalidationListeners);
                } else {
                    currentInvalidationListeners = EMPTY_INV_LISTENERS;
                }
                bUpdateInvalidationListener = false;
            }
        }
        try {
        	event.m_cacheName = this.cacheNameNonPrefixed;
			for (int i = 0; i < currentInvalidationListeners.length; i++) {
				final InvalidationListener currentIL = currentInvalidationListeners[i];
				if (_async) {
					Scheduler.submit(new Runnable() {
						@Override
						public void run() {
							currentIL.fireEvent(event);
						}
					});
				} else {
					currentIL.fireEvent(event);
				}
			}
        }
        catch (Throwable t) {
        	com.ibm.ws.ffdc.FFDCFilter.processException(t, "com.ibm.ws.cache.DCEventSource.fireEvent", "85", this);
        	if (tc.isDebugEnabled()) {
        		Tr.debug(tc, "Exception thrown in fireEvent method of InvalidationListener\n" + t.toString());
        	}
        }
    }
741101
@Override
	protected boolean handleCtrlKeyDown(int keyCode)
	{
		return GuiScreen.isCtrlKeyDown() && !(keyCode == Keyboard.KEY_C || keyCode == Keyboard.KEY_X) && super.handleCtrlKeyDown(keyCode);
	}
237511
@Override
    public void onKeyDown(KeyDownEvent event) {
	char c = MiscUtils.getCharCode(event.getNativeEvent());
	onKeyCodeEvent(event, box.getValue()+c);
    }
665424
def keyReleaseEvent(self, event):
        """"""
        if event.key() == Qt.Key_Alt:
            self._alt_key_is_down = False
            self.update()
1237906
function _handleKeydown(e) {
            if (e.keyCode === KeyEvent.DOM_VK_ESCAPE) {
                e.stopPropagation();
                e.preventDefault();
                self.close();
            }
        }
1341569
public void fireEvent(EventModel event) throws IllegalIDException, org.intellimate.izou.events.MultipleEventsException {
        if(events == null) return;
        if(events.isEmpty()) {
            events.add(event);
        } else {
            throw new org.intellimate.izou.events.MultipleEventsException();
        }
    }
583334
public static void fire(final HasSlideDisabledHandlers source) {
        if (TYPE != null) {
            SlideDisabledEvent event = new SlideDisabledEvent();
            source.fireEvent(event);
        }
    }