Implementation of the OnItemPickerEventListener interface
190409
@Override
    public void onSelectionChanged(FloatingLabelItemChooser<Product> source, Product selectedItem) {
        Toast.makeText(getActivity(), source.getItemPrinter().print(selectedItem), Toast.LENGTH_SHORT).show();
    }
201528
public void onClick(MenuItemClickEvent event) {
		final FeatureTransaction ft = mapWidget.getMapModel().getFeatureEditor().getFeatureTransaction();
		if (ft != null) {
			SimpleFeatureAttributeWindow window = new SimpleFeatureAttributeWindow(ft.getNewFeatures()[0]) {

				public void onOk(Feature feature) {
					// Copy the attributes to the real feature:
					// Don't overwrite the feature itself, as the GraphicsContext expects the same object for rendering!
					ft.getNewFeatures()[0].setAttributes(feature.getAttributes());
				}

				public void onClose() {
				}
			};
			window.show();
		}
	}
1131400
function dispatchEvent(normalizedEvents) {
       var handled = false;

       while (normalizedEvents.length > 0) {
         // keep a reference to the last item
         var pointer = normalizedEvents.pop(); // and put it back into our cache

         T_POINTERS.push(pointer); // Do not fire older events

         if (typeof pointer.event.timeStamp !== "undefined") {
           if (pointer.event.timeStamp < lastTimeStamp) {
             continue;
           }

           lastTimeStamp = pointer.event.timeStamp;
         }

         currentPointer.setShape(pointer.gameWorldX, pointer.gameWorldY, pointer.width, pointer.height); // trigger a global event for pointer move

         if (POINTER_MOVE.includes(pointer.type)) {
           pointer.gameX = pointer.gameLocalX = pointer.gameScreenX;
           pointer.gameY = pointer.gameLocalY = pointer.gameScreenY;
           me.event.publish(me.event.POINTERMOVE, [pointer]);
         }

         var candidates = me.collision.quadTree.retrieve(currentPointer, me.Container.prototype._sortReverseZ); // add the main viewport to the list of candidates

         candidates = candidates.concat([me.game.viewport]);

         for (var c = candidates.length, candidate; c--, candidate = candidates[c];) {
           if (eventHandlers.has(candidate) && candidate.isKinematic !== true) {
             var handlers = eventHandlers.get(candidate);
             var region = handlers.region;
             var ancestor = region.ancestor;
             var bounds = region.getBounds();
             var eventInBounds = false;

             if (region.floating === true) {
               pointer.gameX = pointer.gameLocalX = pointer.gameScreenX;
               pointer.gameY = pointer.gameLocalY = pointer.gameScreenY;
             } else {
               pointer.gameX = pointer.gameLocalX = pointer.gameWorldX;
               pointer.gameY = pointer.gameLocalY = pointer.gameWorldY;
             } // adjust gameLocalX to specify coordinates
             // within the region ancestor container


             if (typeof ancestor !== "undefined") {
               var parentPos = ancestor.getBounds().pos;
               pointer.gameLocalX = pointer.gameX - parentPos.x;
               pointer.gameLocalY = pointer.gameY - parentPos.y;
             }

             if (region instanceof me.Sprite) {
               var gameX = pointer.gameX;
               var gameY = pointer.gameY;

               if (!region.currentTransform.isIdentity()) {
                 var invV = region.currentTransform.multiplyVectorInverse(me.pool.pull("me.Vector2d", gameX, gameY));
                 gameX = invV.x;
                 gameY = invV.y;
                 me.pool.push(invV);
               }

               eventInBounds = bounds.containsPoint(gameX, gameY);
             } else {
               eventInBounds = bounds.containsPoint(pointer.gameX, pointer.gameY) && (bounds === region || // if the given target is another shape than me.Rect
               region.containsPoint(pointer.gameLocalX, pointer.gameLocalY));
             }

             switch (pointer.type) {
               case POINTER_MOVE[0]:
               case POINTER_MOVE[1]:
               case POINTER_MOVE[2]:
               case POINTER_MOVE[3]:
                 // moved out of bounds: trigger the POINTER_LEAVE callbacks
                 if (handlers.pointerId === pointer.pointerId && !eventInBounds) {
                   if (triggerEvent(handlers, findActiveEvent(activeEventList, POINTER_LEAVE), pointer, null)) {
                     handled = true;
                     break;
                   }
                 } // no pointer & moved inside of bounds: trigger the POINTER_ENTER callbacks
                 else if (handlers.pointerId === null && eventInBounds) {
                     if (triggerEvent(handlers, findActiveEvent(activeEventList, POINTER_ENTER), pointer, pointer.pointerId)) {
                       handled = true;
                       break;
                     }
                   } // trigger the POINTER_MOVE callbacks


                 if (eventInBounds && triggerEvent(handlers, pointer.type, pointer, pointer.pointerId)) {
                   handled = true;
                   break;
                 }

                 break;

               case POINTER_UP[0]:
               case POINTER_UP[1]:
               case POINTER_UP[2]:
               case POINTER_UP[3]:
                 // pointer defined & inside of bounds: trigger the POINTER_UP callback
                 if (handlers.pointerId === pointer.pointerId && eventInBounds) {
                   // trigger the corresponding callback
                   if (triggerEvent(handlers, pointer.type, pointer, null)) {
                     handled = true;
                     break;
                   }
                 }

                 break;

               case POINTER_CANCEL[0]:
               case POINTER_CANCEL[1]:
               case POINTER_CANCEL[2]:
               case POINTER_CANCEL[3]:
                 // pointer defined: trigger the POINTER_CANCEL callback
                 if (handlers.pointerId === pointer.pointerId) {
                   // trigger the corresponding callback
                   if (triggerEvent(handlers, pointer.type, pointer, null)) {
                     handled = true;
                     break;
                   }
                 }

                 break;

               default:
                 // event inside of bounds: trigger the POINTER_DOWN or WHEEL callback
                 if (eventInBounds) {
                   // trigger the corresponding callback
                   if (triggerEvent(handlers, pointer.type, pointer, pointer.pointerId)) {
                     handled = true;

                     if (pointer.type === "wheel") {
                       api._preventDefaultFn(pointer.event);
                     }

                     break;
                   }
                 }

                 break;
             }
           }

           if (handled === true) {
             // stop iterating through this list of candidates
             break;
           }
         }
       }

       return handled;
     }
676775
function(oThis, oEvent){
		var jRef = jQuery(oEvent.target);
		if (!jRef.attr("itemidx")) {
			jRef = jRef.parent();
		}
		return jRef.attr("itemidx") ? jRef : null;
	}
1277155
public T itemClicked(AdapterView.OnItemClickListener listener) {

        if (view instanceof AdapterView) {

            AdapterView<?> alv = (AdapterView<?>) view;
            alv.setOnItemClickListener(listener);

        }

        return self();

    }
515770
void onItemClick(MouseEvents.ClickEvent event, Object itemId, Object propertyId) {

        setValue(null);
        select(itemId);
        if (event.getButton().equals(MouseButton.RIGHT) || (propertyId == null)) {
            m_menu.setEntries(
                getMenuEntries(),
                Collections.singleton((((CmsPublishJobBase)getValue()).getPublishHistoryId()).getStringValue()));
            m_menu.openForTable(event, itemId, propertyId, CmsQueuedTable.this);
        } else if (event.getButton().equals(MouseButton.LEFT) && PROP_RESOURCES.equals(propertyId)) {
            showResourceDialog(((CmsPublishJobBase)getValue()).getPublishHistoryId().getStringValue());
        } else if (event.getButton().equals(MouseButton.LEFT) && PROP_PROJECT.equals(propertyId)) {
            if (!(getValue() instanceof CmsPublishJobEnqueued)) {
                showReportDialog((((CmsPublishJobBase)getValue()).getPublishHistoryId().getStringValue()));
            }
        }
    }
853178
function onPointerEvent(e) {
       var ret = true; // normalize eventTypes

       normalizeEvent(e); // remember/use the first "primary" normalized event for pointer.bind

       var button = normalizedEvents[0].button; // dispatch event to registered objects

       if (dispatchEvent(normalizedEvents) || api.preventDefault) {
         // prevent default action
         ret = api._preventDefaultFn(e);
       }

       var keycode = api.pointer.bind[button]; // check if mapped to a key

       if (keycode) {
         if (POINTER_DOWN.includes(e.type)) {
           return api._keydown(e, keycode, button + 1);
         } else {
           // 'mouseup' or 'touchend'
           return api._keyup(e, keycode, button + 1);
         }
       }

       return ret;
     }
195689
function ontap(oEvent) {
			var item = oEvent.srcControl;
			var value;
			if (item instanceof SuggestionItem ) {
				value = item.getSuggestionText();
				picker.close();
				window.setTimeout(function() {
					oInput.setValue(value);
					oInput.fireSearch({
						query: value,
						suggestionItem: item,
						refreshButtonPressed: false,
						clearButtonPressed: false
					});
				}, 0);
			}
		}
1281608
public void onClick(MenuItemClickEvent event) {
		if (feature != null && feature.isSelected()) {
			SC.confirm(
					I18nProvider.getGlobal().confirmDeleteFeature(feature.getLabel(), feature.getLayer().getLabel()),
					new BooleanCallback() {

						public void execute(Boolean value) {
							if (value) {
								feature.getLayer().deselectFeature(feature);
								mapWidget.getMapModel().getFeatureEditor()
										.startEditing(new Feature[] { feature }, null);
								SaveEditingAction action = new SaveEditingAction(mapWidget, controller);
								action.onClick(null);
							}
						}
					});
		}
	}
695574
function() {

    this.on = this.addEventListener = function(type, listener) {
        if (!this.events[type]) {
            this.events[type] = [];
        }

        this.events[type].push(listener);
    };

    this.off = this.removeEventListener = function (type, listener) {
        if (!!this.events[type]) {
            for(var i = 0; i < this.events[type].length; i++) {
                if (this.events[type][i] === listener) {
                    this.events[type][i] = null;
                    this.events[type].splice(i, 1);
                    return;
                }
            }
        }
    };

    this.removeAllListeners = function (type) {
        this.events[type] = [];
    };

    var emit = function(cb, event) {
        // Handle callbacks asynchronously
        setTimeout(function() {
            cb(event);
        }, 0);

    };

    this.dispatchEvent = function (event) {
        if (!!event.type) {
            var type = event.type;
            if (!!this.events[type]) {
                event.target = this;
                for (var i = 0; i < this.events[type].length && (event.returnValue === undefined || event.returnValue) ; i++) {
                    var cb = this.events[type][i];
                    // Dereference cb for async
                    emit(cb.bind(event.target), event);
                }
            }
        }
    };
}
565216
function (newItems) {

            var itemsListener = this._itemsListener;
            var json = this.json;
            var oldItems = this._data.items;
            var numberOfItems;

            if (oldItems == newItems) {
                // items did not change
                // return;
                numberOfItems = newItems.length;
            } else {
                if (oldItems) {
                    // remove the listener on the old items object:
                    for (var i = 0, l = oldItems.length; i < l; i++) {
                        json.removeListener(oldItems[i], null, itemsListener);
                    }
                }
                json.setValue(this._data, "items", newItems);

                if (newItems) {
                    numberOfItems = newItems.length;
                    // add the listener on the new items object:
                    for (var i = 0, l = newItems.length; i < l; i++) {
                        json.addListener(newItems[i], null, itemsListener);
                    }
                    var view = this._data.itemsView;
                    if (view) {
                        view.initialArray = newItems;
                        view.refresh(view.CHANGED_INITIAL_ARRAY);
                    }
                }
            }

            if (this._data.displayOptions) {
                this._calcRowCols(this._data.displayOptions.flowOrientation, this._data.numberOfRows, this._data.numberOfColumns, numberOfItems);
            }

        }
1263655
function processAfterStateChange(itemIndexes) {
    const itemIndex = itemIndexes[(itemIndexes.length - 1)];
    const itemEl = this.itemEls[itemIndex];

    // enforce single selection on radio items
    if (this.state.isRadio) {
        this.state.items.forEach((eachItem, i) => {
            if (i !== itemIndex) {
                eachItem.checked = false;
            }
        });
    }

    if (this.state.isRadio || this.state.isCheckbox) {
        elementScroll.scroll(itemEl);
    }

    if (this.state.isCheckbox && itemIndexes.length > 1) {
        // only calling via API can have multiple item indexes
        this.setState('checked', this.getCheckedList());
        emitAndFire(this, 'menu-change', { indexes: itemIndexes, checked: this.getCheckedList(), el: null });
    } else if (this.state.isCheckbox) {
        this.setState('checked', this.getCheckedList());
        emitAndFire(this, 'menu-change', { index: itemIndex, checked: this.getCheckedList(), el: itemEl });
    } else if (this.state.isRadio) {
        this.setState('checked', itemIndex);
        emitAndFire(this, 'menu-change', { index: itemIndex, checked: [itemIndex], el: itemEl });
    } else {
        this.setState('checked', itemIndex);
        emitAndFire(this, 'menu-select', { index: itemIndex, checked: [itemIndex], el: itemEl });
    }
}
819638
def enterEvent( self, event ):
        
        item = self.trackerItem()
        if ( item ):
            item.setVisible(True)
1373807
protected void onItemClick(View view, int position){
        if(itemClickListener != null) itemClickListener.onItemClick(view, getItem(position), position);
    }
1059773
function(event, callback) {	
	var args = Array.prototype.slice.call(arguments, 1);

	localnwt.event._eventData = args;

	var customEvt = y.createEvent("UIEvents");
	customEvt.initEvent(event, true, false);
	this._node.dispatchEvent(customEvt);
}
398310
@Override
    public void eventCallback(String eventName, Object eventData) {
        for (IActionTarget target : new ArrayList<>(targets)) {
            try {
                target.doAction(action);
            } catch (Throwable t) {
                
            }
        }
    }
831108
function PointerEventInput() {
    this.evEl = POINTER_ELEMENT_EVENTS;
    this.evWin = POINTER_WINDOW_EVENTS;

    Input.apply(this, arguments);

    this.store = (this.manager.session.pointerEvents = []);
}