Fired whenever a browser event is received.
@param event Event to process
974466
@Override
    public void onBrowserEvent(Event event) {

        super.onBrowserEvent(event);

        switch (DOM.eventGetType(event)) {
            case Event.ONMOUSEUP:
                Event.releaseCapture(m_slider.getElement());
                m_capturedMouse = false;
                break;
            case Event.ONMOUSEDOWN:
                Event.setCapture(m_slider.getElement());
                m_capturedMouse = true;
                //$FALL-THROUGH$
            case Event.ONMOUSEMOVE:
                if (m_capturedMouse) {
                    event.preventDefault();
                    float x = ((event.getClientX() - (m_colorUnderlay.getAbsoluteLeft())) + Window.getScrollLeft());
                    float y = ((event.getClientY() - (m_colorUnderlay.getAbsoluteTop())) + Window.getScrollTop());

                    if (m_parent != null) {
                        m_parent.onMapSelected(x, y);
                    }

                    setSliderPosition(x, y);
                }
                //$FALL-THROUGH$
            default:

        }
    }
995456
@Override
  public void onNext(final T event) {
    final EventHandler<T> handler = (EventHandler<T>) map.get(event.getClass());
    if (handler == null) {
      throw new WakeRuntimeException("No event " + event.getClass() + " handler");
    }
    handler.onNext(event);
  }
788667
public void fire(StepFinishedEvent event) {
        Step step = stepStorage.adopt();
        event.process(step);

        notifier.fire(event);
    }
475123
@Override
    public final void onBrowserEvent(final Event event) {

        super.onBrowserEvent(event);
        switch (DOM.eventGetType(event)) {
            // Unhighlight and cancel keyboard events
            case Event.ONBLUR:
                m_keyTimer.cancel();
                if (m_slidingMouse) {
                    stopMouseSliding(event);

                } else if (m_slidingKeyboard) {
                    m_slidingKeyboard = false;

                }

                break;

            // Mousewheel events
            case Event.ONMOUSEWHEEL:
                int velocityY = event.getMouseWheelVelocityY() * m_stepSize;
                event.preventDefault();
                CmsDebugLog.getInstance().printLine("Whell velocity: " + velocityY);
                if (velocityY > 0) {
                    shiftDown(velocityY);
                } else {
                    shiftUp(-velocityY);
                }
                break;

            // Shift left or right on key press
            case Event.ONKEYDOWN:
                if (!m_slidingKeyboard) {
                    int multiplier = 1;
                    if (event.getCtrlKey() || event.getMetaKey()) {
                        multiplier = m_stepSize;
                    }

                    switch (event.getKeyCode()) {
                        case KeyCodes.KEY_HOME:
                            event.preventDefault();
                            setValue(Integer.valueOf(0));
                            break;
                        case KeyCodes.KEY_END:
                            event.preventDefault();
                            setValue(Integer.valueOf(getMaximumVerticalScrollPosition()));
                            break;
                        case KeyCodes.KEY_PAGEUP:
                            event.preventDefault();
                            m_slidingKeyboard = true;
                            shiftUp(m_pageSize);
                            m_keyTimer.schedule(INITIALDELAY, true, m_pageSize);
                            break;
                        case KeyCodes.KEY_PAGEDOWN:
                            event.preventDefault();
                            m_slidingKeyboard = true;

                            shiftDown(m_pageSize);
                            m_keyTimer.schedule(INITIALDELAY, false, m_pageSize);
                            break;
                        case KeyCodes.KEY_UP:
                            event.preventDefault();
                            m_slidingKeyboard = true;

                            shiftUp(multiplier);
                            m_keyTimer.schedule(INITIALDELAY, true, multiplier);
                            break;
                        case KeyCodes.KEY_DOWN:
                            event.preventDefault();
                            m_slidingKeyboard = true;

                            shiftDown(multiplier);
                            m_keyTimer.schedule(INITIALDELAY, false, multiplier);
                            break;

                        default:
                    }
                }
                break;
            // Stop shifting on key up
            case Event.ONKEYUP:
                m_keyTimer.cancel();
                if (m_slidingKeyboard) {
                    m_slidingKeyboard = false;
                }
                break;

            // Mouse Events
            case Event.ONMOUSEDOWN:
                if (sliderClicked(event)) {
                    startMouseSliding(event);
                    event.preventDefault();
                }
                break;
            case Event.ONMOUSEUP:
                stopMouseSliding(event);
                break;
            case Event.ONMOUSEMOVE:
                slideKnob(event);
                break;
            default:
        }

    }
1029427
public void fireEvent(final Event<?> event)
    {
        Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand() {
            @Override
            public void execute() {
                bus.fireEventFromSource(event, dialog.getInterfaceModel().getId());
            }
        });

    }
329020
public void dispatch(Event<?> event) {
		//eventManagement.dispatch(event);
		for (EventListener listener : KReflection.Holder.INSTANCE.listeners) {
			try {
				listener.handleEvent(event);
			} catch (Exception e) {
				// ignore
				// TODO add message kind
			}
		}
	}
808751
synchronized void fireEvent(final Event<?> event) {
        final String eventType = event.getType();
        List<Event<?>> events = synchronizedEvents.get(eventType);
        if (null == events) {
            events = new ArrayList<>();
            synchronizedEvents.put(eventType, events);
        }

        events.add(event);
        setChanged();
        notifyListeners(event);
    }
414923
@Override
  public synchronized void handleEvent(final Event event) {
    if (event.getType() == EventType.JOB_FINISHED && Status.FAILED
        .equals(event.getData().getStatus())) {
      this.value = this.value + 1;
    }
  }
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());
        	}
        }
    }
675371
protected void __triggerRenderEvent(IEvent<Void, ITemplate> event, RythmEngine engine) {
        event.trigger(engine, this);
    }
12129
@Override
  public void process(WatchedEvent event) {
    if (LOG.isDebugEnabled()) {
      LOG.debug("Received ZooKeeper Event, " + "type=" + event.getType() + ", " + "state="
          + event.getState() + ", " + "path=" + event.getPath());
    }

    switch (event.getType()) {
    case None: {
      processConnection(event);
      break;
    }
    case NodeCreated: {
      processNodeCreated(event.getPath());
      break;
    }
    case NodeDeleted: {
      processNodeDeleted(event.getPath());
      break;
    }
    case NodeDataChanged: {
      processDataChanged(event.getPath());
      break;
    }
    case NodeChildrenChanged: {
      processNodeChildrenChanged(event.getPath());
      break;
    }
    default:
      break;
    }
  }
413995
public void handleEvent(Event event) {
        LOG.fine("PasswordHandler called");

        if (tagnames==null || tagnames.size() == 0) {
            LOG.warning("Password filter is active but there is no filter tagname configured!");
        }

        if (tagnames != null && event.getContent() != null
                && event.getContent().length() > 0) {
            LOG.fine("Content before: " + event.getContent());
            for (String tagname : tagnames) {
                event.setContent(event.getContent().replaceAll(
                        "<([^>]*)" + tagname
                                + "([^>]*)>([^<]*)<([^>]*)/([^>]*)" + tagname
                                + "([^>]*)>", REPLACE));
                event.setContent(event.getContent().replaceAll(
                        "<([^>]*)" + tagname + "([^>]*)/([^>]*)>",
                        REPLACE));

            }
            LOG.fine("Content after: " + event.getContent());
        }
    }
496725
public void fire(T event) {
		ArrayList<Listener<T>> list1;
		ArrayList<Runnable> list2;
		synchronized (this) {
			if (listeners == null) list1 = null;
			else list1 = new ArrayList<>(listeners);
			if (listenersRunnable == null) list2 = null;
			else list2 = new ArrayList<>(listenersRunnable);
		}
		if (list1 != null)
			for (int i = 0; i < list1.size(); ++i)
				try { list1.get(i).fire(event); }
				catch (Throwable t) {
					LCCore.getApplication().getDefaultLogger().error("Event listener error: " + list1.get(i), t);
				}
		if (list2 != null)
			for (int i = 0; i < list2.size(); ++i)
				try { list2.get(i).run(); }
				catch (Throwable t) {
					LCCore.getApplication().getDefaultLogger().error("Event listener error: " + list2.get(i), t);
				}
	}
1337721
def fire(self, event):
        
        self.browser.fire(self.element, event)
        return self
1145324
public void fire(StepEvent event) {
        Step step = stepStorage.getLast();
        event.process(step);

        notifier.fire(event);
    }
856273
static void capturePageEvent(String eventName, final EventHandler handler) {
    HtmlPlatform.captureEvent(eventName, new EventHandler() {
      @Override
      public void handleEvent(NativeEvent evt) {
        handler.handleEvent(evt);
      }
    });
  }
5593
function (event){
		//IE compatibility
		event = event || window.event;
		//Mozilla, Opera, & Legacy
		if(event && event.type && (/DOMContentLoaded|load/).test(event.type)) {
			fireDOMReady();
		//Legacy	
		} else if(document.readyState) {
			if ((/loaded|complete/).test(doc.readyState)) {
				fireDOMReady();
			//IE, courtesy of Diego Perini (http://javascript.nwbox.com/IEContentLoaded/)
			} else if(document.documentElement.doScroll) {
				try {
					ready || document.documentElement.doScroll('left');
				} catch(ex) {
					return;
				}
				//If no error was thrown, the DOM must be ready
				fireDOMReady();
			}
		}
	}