When the given event type occurs, runs the given action, and then attempts
to pattern match the event type with the next {@code InputMap} (if one exists).
503134
public static <S, T extends Event> InputMapTemplate<S, T> process(
            EventType<? extends T> eventType,
            BiFunction<? super S, ? super T, InputHandler.Result> action) {
        return process(EventPattern.eventType(eventType), action);
    }
632211
public static final boolean matchTypeMap(Map<String, Class<?>> m1, Map<String, Class<?>> m2) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();

        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "matchTypeMap", new Object[] { m1, m2 });

        boolean match = false;

        if (m1 == m2)
            match = true;
        else if (m1 != null && m1.equals(m2))
            match = true;
        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "matchTypeMap", match);
        return match;
    }
624782
public static <S, T extends Event> InputMapTemplate<S, T> consume(
            EventType<? extends T> eventType,
            BiConsumer<? super S, ? super T> action) {
        return consume(EventPattern.eventType(eventType), action);
    }
1279109
public void subscribe(Class<? extends Event> eventType, Class<? extends Subscriber> subscriberType) {
        if (!subscriptionMap.containsKey(eventType)) {
            subscriptionMap.put(eventType, new ArrayList<>());
        }
        final ArrayList<Class<? extends Subscriber>> subscribers = subscriptionMap.get(eventType);
        if (!subscribers.contains(subscriberType)) {
            subscribers.add(subscriberType);
        }
    }
566182
function executeDispatch(event, listener, inst) {
  var type = event.type || 'unknown-event';
  event.currentTarget = getNodeFromInstance(inst);
  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
  event.currentTarget = null;
}
217960
public void processResponseEvent(FireableEventType eventType, ResponseEvent event, XCAPResourceAdaptorActivityHandle handle){
        
    	if (tracer.isFineEnabled()) {    		            		
    		tracer.fine("NEW RESPONSE EVENT");        
    	}
                        
        try {                	
            sleeEndpoint.fireEvent(handle,eventType, event, null, null);
        } catch (Exception e) {           
            tracer.severe("unable to fire event",e);
        }        
    }
32981
function(fieldInstance,fieldValue) {
      
      var index = inputEx.indexOf(fieldInstance, this.inputs);
      var fieldConfig = this.options.fields[index];
      if( YAHOO.lang.isUndefined(fieldConfig.interactions) ) return;
      
      // Let's run the interactions !
      var interactions = fieldConfig.interactions;
      for(var i = 0 ; i < interactions.length ; i++) {
         var interaction = interactions[i];
         if(interaction.valueTrigger === fieldValue) {
            for(var j = 0 ; j < interaction.actions.length ; j++) {
               this.runAction(interaction.actions[j], fieldValue);
            }
         }
      }
      
   }
310223
@Override protected void handleEvents(final String EVENT_TYPE) {
        super.handleEvents(EVENT_TYPE);

        if ("VISIBILITY".equals(EVENT_TYPE)) {
            Helper.enableNode(titleText, !tile.getTitle().isEmpty());
            Helper.enableNode(text, tile.isTextVisible());
            webView.setMaxSize(size * 0.9, tile.isTextVisible() ? size * 0.68 : size * 0.795);
            webView.setPrefSize(size * 0.9, tile.isTextVisible() ? size * 0.68 : size * 0.795);
        } else if ("LOCATION".equals(EVENT_TYPE)) {
            tile.getCurrentLocation().addLocationEventListener(locationListener);
            updateLocation();
        } else if ("TRACK".equals(EVENT_TYPE)) {
            addTrack(tile.getTrack());
        } else if ("MAP_PROVIDER".equals(EVENT_TYPE)) {
            changeMapProvider(tile.getMapProvider());
        }
    }
398310
@Override
    public void eventCallback(String eventName, Object eventData) {
        for (IActionTarget target : new ArrayList<>(targets)) {
            try {
                target.doAction(action);
            } catch (Throwable t) {
                
            }
        }
    }
525526
@Handler
    @SuppressWarnings("PMD.SystemPrintln")
    public void onInput(Input<ByteBuffer> event) {
        String data = Charset.defaultCharset().decode(event.data()).toString();
        System.out.print(data);
        if (data.trim().equals("QUIT")) {
            fire(new Stop());
        }
    }
1016095
public void trigger(Object event){

        Set<Class> eventTypes = getAllInheritedClasses(event.getClass());

        for (Class eventType : eventTypes) {
            if(observers.containsKey(eventType)){
                for (EventObserver eventObserver : observers.get(eventType)) {
                    executionQueue.get().add(new EventExecution(event, eventObserver));
                }
            }
        }

        triggerQueue();
    }
849357
function(input) {
		gui.Class.ancestorsAndSelf(input.type, function(Type) {
			var list = this._trackedtypes[Type.$classid];
			if (list) {
				list.forEach(function(checks) {
					var handler = checks[0];
					handler.oninput(input);
				});
			}
		}, this);
	}
293157
public static EventType map(Event event) {
        EventType eventType = new EventType();
        eventType.setTimestamp(Converter.convertDate(event.getTimestamp()));
        eventType.setEventType(convertEventType(event.getEventType()));
        OriginatorType origType = mapOriginator(event.getOriginator());
        eventType.setOriginator(origType);
        MessageInfoType miType = mapMessageInfo(event.getMessageInfo());
        eventType.setMessageInfo(miType);
        eventType.setCustomInfo(convertCustomInfo(event.getCustomInfo()));
        eventType.setContentCut(event.isContentCut());
        if (event.getContent() != null) {
            DataHandler datHandler = getDataHandlerForString(event);
            eventType.setContent(datHandler);
        }
        return eventType;
    }
350768
public void fireEvent(Type eventType, Object event, Annotation... qualifiers) {
        final EventMetadata metadata = new EventMetadataImpl(eventType, null, qualifiers);
        notifier.fireEvent(eventType, event, metadata, qualifiers);
    }
1279790
public static <S, T extends Event, U extends T> InputMapTemplate<S, U> consumeWhen(
            EventPattern<? super T, ? extends U> eventPattern,
            Predicate<? super S> condition,
            BiConsumer<? super S, ? super U> action) {
        return process(eventPattern, (s, u) -> {
            if(condition.test(s)) {
                action.accept(s, u);
                return Result.CONSUME;
            } else {
                return Result.PROCEED;
            }
        });
    }
549589
public static void checkEventCriteria(final AttributeImpl attribute, final EventType eventType) throws DevFailed {
        switch (eventType) {
            case CHANGE_EVENT:
                ChangeEventTrigger.checkEventCriteria(attribute);
                break;
            case ARCHIVE_EVENT:
                ArchiveEventTrigger.checkEventCriteria(attribute);
                break;
            default:
                break;
        }
    }
194890
public void fireEvent(int type, Map<String, Object> data) {

        fireEvent(new CmsEvent(type, data));
    }