Called when an event is forwarded by the bridge: e.g when contextual menu is used to inspect a template.
@protected
@param {Object} event
975193
function (event) {
            if (event.event.name == "ContextualTargetFound") {
                var templateCtxt = event.event.templateCtxt;
                // NO NEED TO REFRESH -> displaying the context menu does it already
                this._selectFromTemplateCtxt(templateCtxt);
            }
        }
1248644
function (event) {
                var domEvent = /** @type aria.DomEvent */
                new ariaDomEvent(event), target = /** @type HTMLElement */
                domEvent.target;

                if (this.openedPopups.length === 0) {
                    domEvent.$dispose();
                    return;
                }

                // restrict this to the popup on the top
                var popup = /** @type aria.popups.Popup */
                this.openedPopups[this.openedPopups.length - 1];

                var ignoreClick = false;
                for (var j = 0, length = popup._ignoreClicksOn.length; j < length; j++) {
                    if (utilsDom.isAncestor(target, popup._ignoreClicksOn[j])) {
                        ignoreClick = true;
                        break;
                    }
                }

                if (!(ignoreClick || utilsDom.isAncestor(target, popup.getDomElement()))) {
                    popup.closeOnMouseClick(domEvent);
                }

                var topPopup = this.findParentPopup(target);
                if (topPopup) {
                    this.bringToFront(topPopup);
                }

                domEvent.$dispose();
            }
1336168
function (event) {
            var item, c;
            for (var i = 0; i < event.$.items.length; i++) {
                item = event.$.items[i];
                c = this.getComponentForItem(item);
                // TODO:
                this.$parent.removeChild(c);
                this._innerAddChild(c);
            }
        }
275774
function( event ) {
			if ( this._cancelled ) {
				return;
			}
			if (!this._only && this.constructor.responder ) {
				this.constructor.responder.end(event, this);
			}

			this.callEvents('end', this.element, event);

			if ( this._revert ) {
				var self = this;
				this.movingElement.animate({
					top: this.startPosition.top() + "px",
					left: this.startPosition.left() + "px"
				}, function() {
					self.cleanup.apply(self, arguments);
				});
			}
			else {
				this.cleanup();
			}
			this.event = null;
		}
68243
function (event) {
		event.preventDefault();
		if (!currentElement) {
			return;
		}
		var newHeight = currentElement.data('startHeight') + (event.pageY - currentElement.data('startY'));
		currentElement.parent().height(newHeight);
	}
267252
function (event) {
                if (!this._enabled) {
                    return;
                }
                event = new ariaDomEvent(event);
                if (ariaCoreBrowser.isSafari) {
                    event.ctrlKey = this._safariCtrlKey;
                }
                // ctrl right click only
                if (event.ctrlKey) {
                    // stop default behaviour, like opening real
                    // contextual menu
                    event.stopPropagation();
                    event.preventDefault();
                    var target = event.target;
                    this.__callContextualMenu(target, event.clientX, event.clientY);
                    event.$dispose();
                    return false;
                }
                event.$dispose();
            }
1012363
function(event) {
      if (event.guid == undefined)
        throw new Error('Event must have a GUID');

      if (this.contains(event))
        return event;

      this.pushed_guids_[event.guid] = true;
      this[this.length_++] = event;
      this.bounds_dirty_ = true;
      return event;
    }
133761
function(event) {
            var args = Array.prototype.slice.call(arguments);
            (this.emitter || (this.emitter = new emitter())).emit.apply(this, args);
        }
14690
function listenHandler( event ) {
				var handler = rawHandler.apply( this, arguments );
				if ( handler === false) {
					event.stopPropagation();
					event.preventDefault();
				}
				return( handler );
		}
46391
function (event, template) {
            // this.moduleCtrl.clearHighlight();
            this.data.overModuleCtrl = null;
            this.mouseOut(event);
            this._refreshModulesDisplay();
            // prevent propagation
            event.stopPropagation();
        }
718852
@SuppressWarnings("incomplete-switch")
    public void onPipeConnectionEvent(PipeConnectionEvent event) {
        switch (event.getType()) {
            case CONSUMER_CONNECT_PUSH:
                if (event.getConsumer() == this) {
                    Map<String, Object> paramMap = event.getParamMap();
                    if (paramMap != null) {
                        mode = (String) paramMap.get("mode");
                    }
                }
                break;
        }
    }
764933
function (event, module) {
            this.data.overTemplates = module.outerTemplateCtxts;
            this.mouseOver(event);
            this._refreshTemplatesDisplay();
            // prevent propagation
            event.stopPropagation();
        }
980823
function(event) {
        event = event || {};

        if (event.added) {
            this._renderSelectedItem(event.added);

            this._scrollToBottom();
        } else if (event.removed) {
            removeElement(this.$(getItemSelector(SELECTED_ITEM_SELECTOR, event.removed.id)));
        } else {
            this._forEachSelectedItem(removeElement);

            this._data.forEach(this._renderSelectedItem, this);

            this._updateInputWidth();
        }

        if (event.added || event.removed) {
            if (this.dropdown) {
                this.dropdown.showResults(this.filterResults(this.dropdown.results), {
                    hasMore: this.dropdown.hasMore
                });
            }

            if (!hasTouch) {
                this.focus();
            }
        }

        this.positionDropdown();

        this._updatePlaceholder();
    }
657227
function (event, fn) {
		this._events = this._events || {};
		var e = this._events[event];
		if (e) {
			for (var i = 0, l = e.length; i < l; i++) {
				if (e[i][0] === fn) {
					e.splice(i, 1);
					i--;
					l--;
				}
			}
		}
	}
790909
function(event) {
      // Usually, this method will be called while iterating over a list of
      // events sorted by start time, so this method won't usually change
      // this.start. However, this will sometimes be called for ProtoIRs created
      // by previous handlers, in which case event.start could possibly be
      // before this.start.
      this.start = Math.min(this.start, event.start);
      this.end = Math.max(this.end, event.end);
      this.associatedEvents.push(event);
    }
645738
function _onClick(event) {
            var $scope = $(event.delegateTarget).parent();
            _openEditorForContext({
                path: $scope.data("path"),
                paneId: $scope.data("paneId"),
                cursor: $scope.data("cursor"),
                hideOnOpenFile: true
            });
        }
15314
function (event) {
                var
                    reader = event.target,
                    buffer,
                    len,
                    result,
                    idx;
                _gpfAssert(reader === this._reader, "Unexpected change of reader");
                if (reader.error) {
                    gpfFireEvent.call(this,
                        gpfI.IReadableStream.ERROR,
                        {
                            // According to W3C
                            // http://www.w3.org/TR/domcore/#interface-domerror
                            error: {
                                name: reader.error.name,
                                message: reader.error.message
                            }
                        },
                        this._eventsHandler
                    );
                } else if (reader.readyState === FileReader.DONE) {
                    buffer = new Int8Array(reader.result);
                    len = buffer.length;
                    result = [];
                    for (idx = 0; idx < len; ++idx) {
                        result.push(buffer[idx]);
                    }
                    gpfFireEvent.call(this, gpfI.IReadableStream.EVENT_DATA, {buffer: result}, this._eventsHandler);
                }
            }