Lines Matching refs:event
6592 EventBus.prototype.once = function(event, priority, callback, that) { argument
6610 self.off(event, wrappedCallback);
6620 this.on(event, priority, wrappedCallback);
6638 events.forEach(function(event) { argument
6639 self._removeListener(event, callback);
6653 var event = new InternalEvent();
6655 event.init(data);
6657 return event;
6692 var event,
6719 event = data;
6721 event = this.createEvent(data);
6725 args[0] = event;
6728 var originalType = event.type;
6732 event.type = type;
6736 returnValue = this._invokeListeners(event, args, firstListener);
6741 event.type = originalType;
6747 if (returnValue === undefined && event.defaultPrevented) {
6764 EventBus.prototype._invokeListeners = function(event, args, listener) { argument
6771 if (event.cancelBubble) {
6775 returnValue = this._invokeListener(event, args, listener);
6783 EventBus.prototype._invokeListener = function(event, args, listener) { argument
6798 event.returnValue = returnValue;
6799 event.stopPropagation();
6804 event.preventDefault();
6833 EventBus.prototype._addListener = function(event, newListener) { argument
6835 var listener = this._getListeners(event),
6840 this._setListeners(event, newListener);
6856 this._setListeners(event, newListener);
6879 EventBus.prototype._removeListener = function(event, callback) { argument
6881 var listener = this._getListeners(event),
6889 this._setListeners(event, null);
6906 this._setListeners(event, nextListener);
15608 delegate.bind(lightbox, '.backdrop', 'click', function(event) { argument
15701 var event = self.get('eventBus').createEvent(data);
15704 Object.defineProperty(event, 'context', {
15721 return event;
16155 BaseViewer.prototype.on = function(event, priority, callback, target) { argument
16156 return this.get('eventBus').on(event, priority, callback, target);
16165 BaseViewer.prototype.off = function(event, callback) { argument
16166 this.get('eventBus').off(event, callback);
16247 BaseViewer.prototype._emit = function(type, event) { argument
16248 return this.get('eventBus').fire(type, event);
16353 componentEvent.bind(linkElement, 'click', function(event) { argument
16356 event.preventDefault();
16379 this.on('import.parse.complete', function(event) { argument
16380 if (!event.error) {
16381 this._collectIds(event.definitions, event.elementsById);
16486 forEach(bo.eventDefinitions, function(event) { argument
16487 if (is$1(event, eventType)) {
16581 function isTypedEvent(event, eventDefinitionType, filter) { argument
16593 return some(event.eventDefinitions, function(definition) {
16594 return definition.$type === eventDefinitionType && matches(event, filter);
16598 function isThrowEvent(event) { argument
16599 return (event.$type === 'bpmn:IntermediateThrowEvent') || (event.$type === 'bpmn:EndEvent');
17055 var event = getSemantic(element);
17056 var isThrowing = isThrowEvent(event);
17058 if (event.eventDefinitions && event.eventDefinitions.length>1) {
17059 if (event.parallelMultiple) {
17067 if (isTypedEvent(event, 'bpmn:MessageEventDefinition')) {
17071 if (isTypedEvent(event, 'bpmn:TimerEventDefinition')) {
17075 if (isTypedEvent(event, 'bpmn:ConditionalEventDefinition')) {
17079 if (isTypedEvent(event, 'bpmn:SignalEventDefinition')) {
17083 if (isTypedEvent(event, 'bpmn:EscalationEventDefinition')) {
17087 if (isTypedEvent(event, 'bpmn:LinkEventDefinition')) {
17091 if (isTypedEvent(event, 'bpmn:ErrorEventDefinition')) {
17095 if (isTypedEvent(event, 'bpmn:CancelEventDefinition')) {
17099 if (isTypedEvent(event, 'bpmn:CompensateEventDefinition')) {
17103 if (isTypedEvent(event, 'bpmn:TerminateEventDefinition')) {
17294 'bpmn:EscalationEventDefinition': function(parentGfx, event, isThrowing) {
17298 containerWidth: event.width,
17299 containerHeight: event.height,
17306 var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
17311 stroke: getStrokeColor$1(event, defaultStrokeColor)
17314 'bpmn:ConditionalEventDefinition': function(parentGfx, event) {
17318 containerWidth: event.width,
17319 containerHeight: event.height,
17328 stroke: getStrokeColor$1(event, defaultStrokeColor)
17331 'bpmn:LinkEventDefinition': function(parentGfx, event, isThrowing) {
17335 containerWidth: event.width,
17336 containerHeight: event.height,
17343 var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
17348 stroke: getStrokeColor$1(event, defaultStrokeColor)
17351 'bpmn:ErrorEventDefinition': function(parentGfx, event, isThrowing) {
17355 containerWidth: event.width,
17356 containerHeight: event.height,
17363 var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
17368 stroke: getStrokeColor$1(event, defaultStrokeColor)
17371 'bpmn:CancelEventDefinition': function(parentGfx, event, isThrowing) {
17375 containerWidth: event.width,
17376 containerHeight: event.height,
17383 var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
17388 stroke: getStrokeColor$1(event, defaultStrokeColor)
17395 'bpmn:CompensateEventDefinition': function(parentGfx, event, isThrowing) {
17399 containerWidth: event.width,
17400 containerHeight: event.height,
17407 var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
17412 stroke: getStrokeColor$1(event, defaultStrokeColor)
17415 'bpmn:SignalEventDefinition': function(parentGfx, event, isThrowing) {
17419 containerWidth: event.width,
17420 containerHeight: event.height,
17427 var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
17432 stroke: getStrokeColor$1(event, defaultStrokeColor)
17435 'bpmn:MultipleEventDefinition': function(parentGfx, event, isThrowing) {
17439 containerWidth: event.width,
17440 containerHeight: event.height,
17447 var fill = isThrowing ? getStrokeColor$1(event, defaultStrokeColor) : 'none';
17454 'bpmn:ParallelMultipleEventDefinition': function(parentGfx, event) {
17458 containerWidth: event.width,
17459 containerHeight: event.height,
17468 fill: getStrokeColor$1(event, defaultStrokeColor),
17469 stroke: getStrokeColor$1(event, defaultStrokeColor)
20050 function __stopPropagation(event) { argument
20051 if (!event || typeof event.stopPropagation !== 'function') {
20055 event.stopPropagation();
20059 function getOriginal$1(event) { argument
20060 return event.originalEvent || event.srcEvent;
20064 function stopPropagation$1(event, immediate) { argument
20065 __stopPropagation(event);
20066 __stopPropagation(getOriginal$1(event));
20070 function toPoint(event) { argument
20072 if (event.pointers && event.pointers.length) {
20073 event = event.pointers[0];
20076 if (event.touches && event.touches.length) {
20077 event = event.touches[0];
20080 return event ? {
20081 x: event.clientX,
20082 y: event.clientY
20090 function isButton(event, button) { argument
20091 return (getOriginal$1(event) || event).button === button;
20094 function isPrimaryButton(event) { argument
20097 return isButton(event, 0);
20100 function isAuxiliaryButton(event) { argument
20103 return isButton(event, 1);
20106 function hasPrimaryModifier(event) { argument
20107 var originalEvent = getOriginal$1(event) || event;
20109 if (!isPrimaryButton(event)) {
20122 function hasSecondaryModifier(event) { argument
20123 var originalEvent = getOriginal$1(event) || event;
20125 return isPrimaryButton(event) && originalEvent.shiftKey;
20128 function allowAll(event) { return true; } argument
20130 function allowPrimaryAndAuxiliary(event) { argument
20131 return isPrimaryButton(event) || isAuxiliaryButton(event);
20170 function fire(type, event, element) { argument
20172 if (isIgnored(type, event)) {
20179 target = event.delegateTarget || event.target;
20196 originalEvent: event
20200 event.stopPropagation();
20201 event.preventDefault();
20212 function isIgnored(localEventName, event) { argument
20219 return !filter(event);
20252 function triggerMouseEvent(eventName, event, targetElement) { argument
20261 return fire(localEventName, event, targetElement);
20269 function registerEvent(node, event, localEvent, ignoredFilter) { argument
20271 var handler = handlers[localEvent] = function(event) {
20272 fire(localEvent, event);
20279 handler.$delegate = delegate.bind(node, ELEMENT_SELECTOR, event, handler);
20282 function unregisterEvent(node, event, localEvent) { argument
20290 delegate.unbind(node, event, handler.$delegate);
20305 eventBus.on('canvas.destroy', function(event) { argument
20306 unregisterEvents(event.svg);
20309 eventBus.on('canvas.init', function(event) { argument
20310 registerEvents(event.svg);
20316 eventBus.on([ 'shape.added', 'connection.added' ], function(event) { argument
20317 var element = event.element,
20318 gfx = event.gfx;
20329 ], LOW_PRIORITY$m, function(event) { argument
20331 var element = event.element,
20332 gfx = event.gfx;
20337 eventBus.on('interactionEvents.createHit', LOW_PRIORITY$m, function(event) { argument
20338 var element = event.element,
20339 gfx = event.gfx;
20344 eventBus.on('interactionEvents.updateHit', function(event) { argument
20345 var element = event.element,
20346 gfx = event.gfx;
20649 eventBus.on([ 'shape.added', 'shape.changed' ], LOW_PRIORITY$l, function(event) { argument
20650 var element = event.element,
20651 gfx = event.gfx;
20662 eventBus.on([ 'connection.added', 'connection.changed' ], function(event) { argument
20663 var element = event.element,
20664 gfx = event.gfx;
20852 events.on('element.hover', function(event) { argument
20853 addMarker(event.element, MARKER_HOVER);
20856 events.on('element.out', function(event) { argument
20857 removeMarker(event.element, MARKER_HOVER);
20860 events.on('selection.changed', function(event) { argument
20870 var oldSelection = event.oldSelection,
20871 newSelection = event.newSelection;
20897 eventBus.on('create.end', 500, function(event) { argument
20898 var context = event.context,
20922 eventBus.on('connect.end', 500, function(event) { argument
20923 var context = event.context,
20933 eventBus.on('shape.move.end', 500, function(event) { argument
20934 var previousSelection = event.previousSelection || [];
20936 var shape = elementRegistry.get(event.context.shape.id);
20949 eventBus.on('element.click', function(event) { argument
20951 if (!isPrimaryButton(event)) {
20955 var element = event.element;
20965 var add = hasPrimaryModifier(event) || hasSecondaryModifier(event);
21575 eventBus.on('canvas.viewbox.changing', function(event) { argument
21579 eventBus.on('canvas.viewbox.changed', function(event) { argument
21580 updateViewbox(event.viewbox);
21748 function hasModifier(event) { argument
21749 return (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey);
21755 function isCmd(event) { argument
21759 if (event.altKey) {
21763 return event.ctrlKey || event.metaKey;
21772 function isKey(keys, event) { argument
21775 return keys.indexOf(event.key) !== -1 || keys.indexOf(event.keyCode) !== -1;
21781 function isShift(event) { argument
21782 return event.shiftKey;
21852 Keyboard.prototype._keydownHandler = function(event) { argument
21853 this._keyHandler(event, KEYDOWN_EVENT);
21856 Keyboard.prototype._keyupHandler = function(event) { argument
21857 this._keyHandler(event, KEYUP_EVENT);
21860 Keyboard.prototype._keyHandler = function(event, type) { argument
21863 if (this._isEventIgnored(event)) {
21868 keyEvent: event
21874 event.preventDefault();
21878 Keyboard.prototype._isEventIgnored = function(event) { argument
21879 return isInput(event.target) && this._isModifiedKeyIgnored(event);
21882 Keyboard.prototype._isModifiedKeyIgnored = function(event) { argument
21883 if (!isCmd(event)) {
21887 var allowedModifiers = this._getAllowedModifiers(event.target);
21888 return !allowedModifiers.includes(event.key);
21933 Keyboard.prototype._fire = function(event) { argument
21934 this._eventBus.fire('keyboard.' + event, { node: this._node });
21999 eventBus.on('editorActions.init', LOW_PRIORITY$j, function(event) { argument
22001 var editorActions = event.editorActions;
22040 var event = context.keyEvent;
22042 if (isCmd(event) && !isShift(event) && isKey(KEYS_UNDO, event)) {
22054 var event = context.keyEvent;
22056 if (isCmd(event) && (isKey(KEYS_REDO, event) || (isKey(KEYS_UNDO, event) && isShift(event)))) {
22067 var event = context.keyEvent;
22069 if (isCmd(event) && isKey(KEYS_COPY, event)) {
22080 var event = context.keyEvent;
22082 if (isCmd(event) && isKey(KEYS_PASTE, event)) {
22093 var event = context.keyEvent;
22097 if (isKey([ '+', 'Add', '=' ], event) && isCmd(event)) {
22108 var event = context.keyEvent;
22110 if (isKey([ '-', 'Subtract' ], event) && isCmd(event)) {
22121 var event = context.keyEvent;
22123 if (isKey('0', event) && isCmd(event)) {
22134 var event = context.keyEvent;
22136 if (isKey(['Backspace', 'Delete', 'Del' ], event)) {
22180 var event = context.keyEvent,
22183 if (!keyboard.isCmd(event)) {
22192 ], event)) {
22195 keyboard.isShift(event) ?
22202 switch (event.key) {
22352 function handleMove(event) { argument
22356 position = toPoint(event),
22384 event.preventDefault();
22388 function handleEnd(event) { argument
22397 function handleStart(event) { argument
22400 if (closest(event.target, '.djs-draggable')) {
22404 var button = event.button;
22407 if (button >= 2 || event.ctrlKey || event.shiftKey || event.altKey) {
22413 start: toPoint(event)
22560 ZoomScroll.prototype._handleWheel = function handleWheel(event) { argument
22563 if (closest(event.target, '.djs-scrollable', true)) {
22569 event.preventDefault();
22574 var isZoom = event.ctrlKey;
22576 var isHorizontalScroll = event.shiftKey;
22582 factor *= event.deltaMode === 0 ? 0.020 : 0.32;
22584 factor *= event.deltaMode === 0 ? 1.0 : 16.0;
22591 x: event.clientX - elementRect.left,
22592 y: event.clientY - elementRect.top
22597 Math.pow(event.deltaY, 2) +
22598 Math.pow(event.deltaX, 2)
22599 ) * sign(event.deltaY) * factor
22608 dx: factor * event.deltaY,
22613 dx: factor * event.deltaX,
22614 dy: factor * event.deltaY
24254 function emit(event) { argument
24255 self.manager.emit(event, input);
24260 emit(self.options.event + stateStr(state));
24263 emit(self.options.event); // simple 'eventName' events
24271 emit(self.options.event + stateStr(state));
24488 event: 'pan',
24543 input.additionalEvent = this.options.event + direction;
24565 event: 'pinch',
24582 input.additionalEvent = this.options.event + inOut;
24607 event: 'press',
24651 this.manager.emit(this.options.event + 'up', input);
24654 this.manager.emit(this.options.event, this._input);
24675 event: 'rotate',
24706 event: 'swipe',
24739 this.manager.emit(this.options.event + direction, input);
24742 this.manager.emit(this.options.event, input);
24775 event: 'tap',
24856 this.manager.emit(this.options.event, this._input);
24933 [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],
25122 if (recognizers[i].options.event == recognizer) {
25141 var existing = this.get(recognizer.options.event);
25194 each(splitStr(events), function(event) { argument
25195 handlers[event] = handlers[event] || [];
25196 handlers[event].push(handler);
25213 each(splitStr(events), function(event) { argument
25215 delete handlers[event];
25217 handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
25228 emit: function(event, data) { argument
25231 triggerDomEvent(event, data);
25235 var handlers = this.handlers[event] && this.handlers[event].slice();
25240 data.type = event;
25296 function triggerDomEvent(event, data) { argument
25298 gestureEvent.initEvent(event, true, true);
25392 function stopEvent(event) { argument
25394 event.preventDefault();
25396 if (typeof event.stopPropagation === 'function') {
25397 event.stopPropagation();
25398 } else if (event.srcEvent && typeof event.srcEvent.stopPropagation === 'function') {
25401 event.srcEvent.stopPropagation();
25404 if (typeof event.stopImmediatePropagation === 'function') {
25405 event.stopImmediatePropagation();
25412 function stopMouse(event) { argument
25419 function allowMouse(event) { argument
25447 var doubleTap = new Hammer.Tap({ event: 'doubletap', taps: 2 });
25475 recognizer.on('hammer.input', function(event) { argument
25476 if (event.srcEvent.defaultPrevented) {
25505 return function(event) { argument
25507 interactionEvents.fire(type, event);
25525 function startGrabCanvas(event) { argument
25551 function startGrab(event) { argument
25553 var gfx = getGfx(event.target),
25558 return move.start(event, element, true);
25601 eventBus.on('drag.move', function(event) { argument
25603 var originalEvent = event.originalEvent;
25616 if (element !== event.hover) {
25617 if (event.hover) {
25618 dragging.out(event);
25624 event.hover = element;
25625 event.hoverGfx = gfx;
25633 eventBus.on('contextPad.create', function(event) { argument
25634 var node = event.pad.html;
25639 padRecognizer.on('panstart', function(event) { argument
25640 contextPad.trigger('dragstart', event, true);
25643 padRecognizer.on('press', function(event) { argument
25644 contextPad.trigger('dragstart', event, true);
25647 padRecognizer.on('tap', function(event) { argument
25648 contextPad.trigger('click', event);
25654 eventBus.on('palette.create', function(event) { argument
25655 var node = event.container;
25660 padRecognizer.on('panstart', function(event) { argument
25661 palette.trigger('dragstart', event, true);
25664 padRecognizer.on('press', function(event) { argument
25665 palette.trigger('dragstart', event, true);
25668 padRecognizer.on('tap', function(event) { argument
25669 palette.trigger('click', event);
25674 eventBus.on('canvas.init', function(event) { argument
25675 initEvents(event.svg);
26231 eventBus.on('autoPlace.end', function(event) { argument
26232 canvas.scrollToElement(event.shape);
26544 return function(event) { argument
26545 return fn.call(that || null, event.context, event.command, event);
26592 forEach(events, function(event) { argument
26595 var fullEvent = [ 'commandStack', event, hook ].filter(function(e) { return e; }).join('.');
26667 this.postExecuted([ 'shape.create' ], function(event) { argument
26668 var context = event.context,
26680 this.postExecuted([ 'elements.move' ], function(event) { argument
26681 var context = event.context,
26708 this.postExecuted([ 'shape.toggleCollapse' ], function(event) { argument
26709 var context = event.context,
26724 this.postExecuted([ 'shape.resize' ], function(event) { argument
26725 var context = event.context,
27020 self.canExecute(action, priority, function(context, action, event) { argument
27142 function ensureHover(event) { argument
27144 if (event.hover) {
27148 var originalEvent = event.originalEvent;
27157 event.stopPropagation();
27179 eventBus.on('drag.start', function(event) { argument
27181 eventBus.once('drag.move', HIGH_PRIORITY$j, function(event) { argument
27183 ensureHover(event);
27205 eventBus.on('element.hover', function(event) { argument
27208 hoverGfx = event.gfx;
27209 hover = event.element;
27212 eventBus.on('element.hover', HIGH_PRIORITY$j, function(event) { argument
27235 this._findTargetGfx = function(event) { argument
27239 if (!(event instanceof MouseEvent)) {
27243 position = toPoint(event);
27278 function preventDefault$1(event) { argument
27279 event.preventDefault();
27282 function isTouchEvent(event) { argument
27286 return typeof TouchEvent !== 'undefined' && event instanceof TouchEvent;
27402 var event = eventBus.createEvent(
27412 if (eventBus.fire('drag.' + type, event) === false) {
27416 return eventBus.fire(dragContext.prefix + '.' + type, event);
27429 function move(event, activate) { argument
27434 globalCurrent = toPoint(event),
27453 }, { originalEvent: event });
27478 stopPropagation$1(event);
27488 }, { originalEvent: event });
27495 function end(event) { argument
27501 if (event) {
27502 context.payload.originalEvent = event;
27506 stopPropagation$1(event);
27530 function checkCancel(event) { argument
27532 if (event.which === 27) {
27533 preventDefault$1(event);
27543 function trapClickAndEnd(event) { argument
27558 preventDefault$1(event);
27561 end(event);
27564 function trapTouch(event) { argument
27565 move(event);
27572 function hover(event) { argument
27575 payload.hoverGfx = event.gfx;
27576 payload.hover = event.element;
27581 function out(event) { argument
27678 function init(event, relativeTo, prefix, options) { argument
27706 if (event) {
27707 originalEvent = getOriginal$1(event) || event;
27708 globalStart = toPoint(event);
27710 stopPropagation$1(event);
27772 move(event, true);
27943 AutoScroll.prototype._toBorderPoint = function(event) { argument
27946 var globalPosition = toPoint(event.originalEvent);
28125 function toCanvasCoordinates(canvas, event) { argument
28127 var position = toPoint(event),
28148 function getConnectionIntersection(canvas, waypoints, event) { argument
28149 var localPosition = toCanvasCoordinates(canvas, event),
28455 function activateBendpointMove(event, connection) { argument
28457 intersection = getConnectionIntersection(canvas, waypoints, event),
28467 connectionSegmentMove.start(event, connection, intersection.index);
28469 bendpointMove.start(event, connection, intersection.index, !intersection.bendpoint);
28478 componentEvent.bind(node, eventName, function(event) { argument
28479 interactionEvents.triggerMouseEvent(eventName, event, element);
28480 event.stopPropagation();
28630 eventBus.on('connection.changed', function(event) { argument
28631 updateHandles(event.element);
28634 eventBus.on('connection.remove', function(event) { argument
28635 var gfx = getBendpointsContainer(event.element);
28642 eventBus.on('element.marker.update', function(event) { argument
28644 var element = event.element,
28653 if (event.add) {
28654 classes(bendpointsGfx).add(event.marker);
28656 classes(bendpointsGfx).remove(event.marker);
28660 eventBus.on('element.mousemove', function(event) { argument
28662 var element = event.element,
28670 intersection = getConnectionIntersection(canvas, waypoints, event.originalEvent);
28685 eventBus.on('element.mousedown', function(event) { argument
28687 if (!isPrimaryButton(event)) {
28691 var originalEvent = event.originalEvent,
28692 element = event.element;
28701 eventBus.on('selection.changed', function(event) { argument
28702 var newSelection = event.newSelection,
28710 eventBus.on('element.hover', function(event) { argument
28711 var element = event.element;
28715 interactionEvents.registerEvent(event.gfx, 'mousemove', 'element.mousemove');
28719 eventBus.on('element.out', function(event) { argument
28720 interactionEvents.unregisterEvent(event.gfx, 'mousemove', 'element.mousemove');
28774 this.start = function(event, connection, bendpointIndex, insert) { argument
28810 dragging.init(event, 'bendpoint.move', {
28827 eventBus.on('bendpoint.move.hover', function(event) { argument
28828 var context = event.context,
28832 hover = event.hover,
28873 eventBus.on([ 'bendpoint.move.out', 'bendpoint.move.cleanup' ], function(event) { argument
28874 var context = event.context,
28886 eventBus.on('bendpoint.move.end', function(event) { argument
28887 var context = event.context,
28900 x: round$8(event.x),
28901 y: round$8(event.y)
29020 eventBus.on('bendpoint.move.start', function(event) { argument
29021 var context = event.context,
29033 newWaypoints.splice(bendpointIndex, 0, { x: event.x, y: event.y });
29047 eventBus.on('bendpoint.move.hover', function(event) { argument
29048 var context = event.context,
29073 ], HIGH_PRIORITY$i, function(event) { argument
29074 var context = event.context,
29084 eventBus.on('bendpoint.move.move', function(event) { argument
29085 var context = event.context,
29095 bendpoint = { x: event.x, y: event.y },
29153 translate$2(draggerGfx, event.x, event.y);
29159 ], HIGH_PRIORITY$i, function(event) { argument
29160 var context = event.context,
29263 this.start = function(event, connection, idx) { argument
29272 intersection = getConnectionIntersection(canvas, waypoints, event),
29314 dragging.init(event, dragPosition, 'connectionSegment.move', {
29359 function updateDragger(context, segmentOffset, event) { argument
29370 var draggerPosition = axisFenced(event, segmentStart, segmentEnd, axis);
29407 eventBus.on('connectionSegment.move.start', function(event) { argument
29409 var context = event.context,
29410 connection = event.connection,
29422 eventBus.on('connectionSegment.move.move', function(event) { argument
29424 var context = event.context,
29433 newSegmentStart = axisAdd(segmentStart, axis, event['d' + axis]),
29434 newSegmentEnd = axisAdd(segmentEnd, axis, event['d' + axis]);
29497 updateDragger(context, segmentOffset, event);
29503 redrawConnection(event);
29506 eventBus.on('connectionSegment.move.hover', function(event) { argument
29508 event.context.hover = event.hover;
29509 canvas.addMarker(event.hover, MARKER_CONNECT_HOVER);
29515 ], function(event) { argument
29519 var hover = event.context.hover;
29526 eventBus.on('connectionSegment.move.cleanup', function(event) { argument
29528 var context = event.context,
29542 ], function(event) { argument
29543 var context = event.context,
29548 redrawConnection(event);
29551 eventBus.on('connectionSegment.move.end', function(event) { argument
29553 var context = event.context,
29660 function isSnapped(event, axis) { argument
29661 var snapped = event.snapped;
29687 function setSnapped(event, axis, value) { argument
29697 previousValue = event[axis];
29699 var snapped = event.snapped = (event.snapped || {});
29709 event[axis] += delta;
29710 event['d' + axis] += delta;
29822 eventBus.on('connectionSegment.move.move', 1500, function(event) { argument
29823 var context = event.context,
29825 x = event.x,
29826 y = event.y,
29843 assign(event, {
29844 dx: event.dx - cx,
29845 dy: event.dy - cy,
29852 setSnapped(event, 'x', sx);
29856 setSnapped(event, 'y', sy);
29893 eventBus.on([ 'bendpoint.move.move', 'bendpoint.move.end' ], 1500, function(event) { argument
29895 var context = event.context,
29899 x = event.x,
29900 y = event.y,
29916 assign(event, {
29917 dx: event.dx - cx,
29918 dy: event.dy - cy,
29919 x: event.x - cx,
29920 y: event.y - cy
29925 setSnapped(event, 'x', sx);
29929 setSnapped(event, 'y', sy);
29968 eventBus.on('connect.hover', function(event) { argument
29969 var context = event.context,
29971 hover = event.hover,
30004 eventBus.on([ 'connect.out', 'connect.cleanup' ], function(event) { argument
30005 var context = event.context;
30014 eventBus.on('connect.end', function(event) { argument
30015 var context = event.context,
30019 x: event.x,
30020 y: event.y
30053 this.start = function(event, start, connectionStart, autoActivate) { argument
30059 dragging.init(event, 'connect', {
30106 connectionPreview && eventBus.on('connect.move', function(event) { argument
30107 var context = event.context,
30116 x: event.x,
30117 y: event.y
30135 eventBus.on('connect.hover', LOW_PRIORITY$h, function(event) { argument
30136 var context = event.context,
30137 hover = event.hover,
30151 ], HIGH_PRIORITY$h, function(event) { argument
30152 var hover = event.hover;
30160 connectionPreview && eventBus.on('connect.cleanup', function(event) { argument
30161 connectionPreview.cleanUp(event.context);
30973 DirectEditing.prototype._fire = function(event, context) { argument
30974 this._eventBus.fire('directEditing.' + event, context || { active: this._active });
31049 DirectEditing.prototype._handleResize = function(event) { argument
31050 this._fire('resize', event);
31171 eventBus.on('elements.delete', function(event) { argument
31172 var elements = event.elements;
31181 eventBus.on('element.changed', function(event) { argument
31182 var element = event.element,
31222 this._eventBus.on('contextPad.getProviders', priority, function(event) { argument
31223 event.providers.push(provider);
31265 ContextPad.prototype.trigger = function(action, event, autoActivate) { argument
31272 button = event.delegateTarget || event.target;
31275 return event.preventDefault();
31281 originalEvent = event.originalEvent || event;
31295 event.preventDefault();
31316 var event = this._eventBus.createEvent({
31321 this._eventBus.fire(event);
31323 return event.providers;
31387 delegate.bind(html, entrySelector, 'click', function(event) { argument
31388 self.trigger('click', event);
31391 delegate.bind(html, entrySelector, 'dragstart', function(event) { argument
31392 self.trigger('dragstart', event);
31396 componentEvent.bind(html, 'mousedown', function(event) { argument
31397 event.stopPropagation();
31826 eventBus.on([ 'create.move', 'create.hover' ], function(event) { argument
31827 var context = event.context,
31829 hover = event.hover,
31840 ensureConstraints$2(event);
31843 x: event.x,
31844 y: event.y
31860 eventBus.on([ 'create.end', 'create.out', 'create.cleanup' ], function(event) { argument
31861 var hover = event.hover;
31868 eventBus.on('create.end', function(event) { argument
31869 var context = event.context,
31883 ensureConstraints$2(event);
31886 x: event.x,
31887 y: event.y
31913 assign(event, {
31938 this.start = function(event, elements, context) { argument
31989 dragging.init(event, PREFIX, {
32011 function ensureConstraints$2(event) { argument
32012 var context = event.context,
32020 event.x = Math.max(event.x, createConstraints.left);
32024 event.x = Math.min(event.x, createConstraints.right);
32028 event.y = Math.max(event.y, createConstraints.top);
32032 event.y = Math.min(event.y, createConstraints.bottom);
32093 eventBus.on('create.move', LOW_PRIORITY$g, function(event) { argument
32095 var hover = event.hover,
32096 context = event.context,
32114 translate$2(dragGroup, event.x, event.y);
32120 eventBus.on('create.cleanup', function(event) { argument
32121 var context = event.context,
32227 this._eventBus.on('popupMenu.getProviders.' + id, priority, function(event) { argument
32228 event.providers.push(provider);
32360 PopupMenu.prototype.trigger = function(event) { argument
32363 event.preventDefault();
32365 var element = event.delegateTarget || event.target,
32371 return entry.action.call(null, event, entry);
32377 var event = this._eventBus.createEvent({
32382 this._eventBus.fire(event);
32384 return event.providers;
32518 delegate.bind(container, '.entry' ,'click', function(event) { argument
32519 self.trigger(event);
32787 var event = document.createEvent('MouseEvent');
32794 if (event.initMouseEvent) {
32795 event.initMouseEvent(
32814 return event;
35530 function toggleLoopEntry(event, entry) { argument
35608 function toggleIsCollection(event, entry) { argument
35643 function toggleParticipantMultiplicity(event, entry) { argument
35691 action: function(event, entry) { argument
36106 eventBus.on('create.end', 250, function(event) { argument
36107 var context = event.context,
36110 if (!hasPrimaryModifier(event) || !contextPad.isOpen(shape)) {
36117 entries.replace.action.click(event, shape);
36160 function startConnect(event, element) { argument
36161 connect.start(event, element);
36207 function appendStart(event, element) { argument
36210 create.start(event, shape, {
36216 var append = autoPlace ? function(event, element) {
36236 return function(event, element) { argument
36258 click: function(event, element) { argument
36300 click: function(event, element) { argument
36400 click: function(event, element) { argument
36403 cursor: { x: event.x, y: event.y }
37222 ], function(event) { argument
37223 var context = event.context,
37224 shape = event.shape;
37284 ], LOWER_PRIORITY, function(event) { argument
37285 var originalEvent = event.originalEvent;
37291 var context = event.context,
37302 var snapOffset = getSnapOffset(event, axis, elementRegistry);
37309 var snapConstraints = getSnapConstraints(event, axis);
37315 if (!isSnapped(event, axis)) {
37316 self.snapEvent(event, axis, options);
37331 GridSnapping.prototype.snapEvent = function(event, axis, options) { argument
37332 var snappedValue = this.snapValue(event[ axis ], options);
37334 setSnapped(event, axis, snappedValue);
37425 function getSnapConstraints(event, axis) { argument
37426 var context = event.context,
37515 function getSnapOffset(event, axis, elementRegistry) { argument
37516 var context = event.context,
37517 shape = event.shape,
37591 this.preExecute('shape.resize', function(event) { argument
37592 var context = event.context,
37761 ], HIGH_PRIORITY$f, function(event) { argument
37762 var context = event.context;
37775 snapped = gridSnapping.snapValue(event.dx);
37777 event.x = event.x + snapped - event.dx;
37778 event.dx = snapped;
37782 snapped = gridSnapping.snapValue(event.dy);
37784 event.y = event.y + snapped - event.dy;
37785 event.dy = snapped;
37872 ], HIGHER_PRIORITY$4, function(event) { argument
37873 var context = event.context,
37916 ], HIGH_PRIORITY$d, function(event) { argument
37917 var context = event.context,
38208 var event = context.keyEvent;
38210 if (keyboard.isKey(['a', 'A'], event) && keyboard.isCmd(event)) {
38221 var event = context.keyEvent;
38223 if (keyboard.isKey(['f', 'F'], event) && keyboard.isCmd(event)) {
38234 var event = context.keyEvent;
38236 if (keyboard.hasModifier(event)) {
38240 if (keyboard.isKey(['s', 'S'], event)) {
38251 var event = context.keyEvent;
38253 if (keyboard.hasModifier(event)) {
38257 if (keyboard.isKey(['l', 'L'], event)) {
38268 var event = context.keyEvent;
38270 if (keyboard.hasModifier(event)) {
38274 if (keyboard.isKey(['h', 'H'], event)) {
38285 var event = context.keyEvent;
38287 if (keyboard.hasModifier(event)) {
38291 if (keyboard.isKey(['c', 'C'], event)) {
38302 var event = context.keyEvent;
38304 if (keyboard.hasModifier(event)) {
38308 if (keyboard.isKey(['e', 'E'], event)) {
38400 keyboard.addListener(HIGHER_PRIORITY$3, function(event) { argument
38402 var keyEvent = event.keyEvent;
38494 eventBus.on('element.changed', function(event) { argument
38496 var element = event.element;
38501 event.gfx = elementRegistry.getGraphics(element);
38505 if (!event.gfx) {
38509 eventBus.fire(getType(element) + '.changed', event);
38512 eventBus.on('elements.changed', function(event) { argument
38514 var elements = event.elements;
38523 eventBus.on('shape.changed', function(event) { argument
38524 graphicsFactory.update('shape', event.element, event.gfx);
38527 eventBus.on('connection.changed', function(event) { argument
38528 graphicsFactory.update('connection', event.element, event.gfx);
38669 eventBus.on('resize.start', function(event) { argument
38670 handleStart(event.context);
38673 eventBus.on('resize.move', function(event) { argument
38675 x: event.dx,
38676 y: event.dy
38679 handleMove(event.context, delta);
38682 eventBus.on('resize.end', function(event) { argument
38683 handleEnd(event.context);
38707 Resize.prototype.activate = function(event, shape, contextOrDirection) { argument
38726 dragging.init(event, getReferencePoint$1(shape, direction), 'resize', {
38874 eventBus.on('resize.move', LOW_PRIORITY$d, function(event) { argument
38875 updateFrame(event.context);
38879 eventBus.on('resize.cleanup', function(event) { argument
38880 removeFrame(event.context);
38942 function startResize(event) { argument
38945 if (isPrimaryButton(event)) {
38946 resize.activate(event, element, direction);
39122 eventBus.on('element.dblclick', function(event) { argument
39123 activateDirectEdit(event.element, true);
39133 ], function(event) { argument
39148 eventBus.on('directEditing.activate', function(event) { argument
39152 eventBus.on('create.end', 500, function(event) { argument
39154 var context = event.context,
39156 canExecute = event.context.canExecute,
39157 isTouch = event.isTouch;
39182 eventBus.on('autoPlace.end', 500, function(event) { argument
39183 activateDirectEdit(event.shape);
39679 ], function(event) { argument
39680 var context = event.context,
39695 ], function(event) { argument
39696 var context = event.context,
39708 ], function(event) { argument
39709 var context = event.context,
40077 this.postExecute('connection.create', function(event) { argument
40078 var source = event.context.source,
40079 target = event.context.target,
40093 this.postExecute('connection.reconnect', function(event) { argument
40094 var oldSource = event.context.oldSource,
40095 newSource = event.context.newSource;
40297 this.preExecute('shape.create', 1500, function(event) { argument
40298 var context = event.context,
40336 ], HIGH_PRIORITY$b, function(event) { argument
40337 var context = event.context,
40338 shape = context.shape || event.shape,
40339 hover = event.hover;
40344 event.hover = getLanesRoot(hover);
40345 event.hoverGfx = elementRegistry.getGraphics(event.hover);
40353 event.hover = rootElement;
40354 event.hoverGfx = elementRegistry.getGraphics(event.hover);
40367 ], HIGH_PRIORITY$b, function(event) { argument
40368 var hover = event.hover;
40373 event.hover = getLanesRoot(hover) || hover;
40374 event.hoverGfx = elementRegistry.getGraphics(event.hover);
40381 ], HIGH_PRIORITY$b, function(event) { argument
40382 var context = event.context,
40383 hover = event.hover,
40389 event.hover = getLanesRoot(hover) || hover;
40390 event.hoverGfx = elementRegistry.getGraphics(event.hover);
40397 ], HIGH_PRIORITY$b, function(event) { argument
40398 var context = event.context,
40410 eventBus.on('shape.move.start', HIGHEST_PRIORITY, function(event) { argument
40411 var shape = event.shape;
40414 event.shape = getLanesRoot(shape) || shape;
40433 this.preExecute('shape.create', function(event) { argument
40435 var context = event.context,
40476 ], HIGH_PRIORITY$a, function(event) { argument
40477 var context = event.context,
40511 eventBus.on('create.start', HIGH_PRIORITY$a, function(event) { argument
40512 var context = event.context,
40517 function ensureHoveringProcess(event) { argument
40518 event.element = rootElement;
40519 event.gfx = rootElementGfx;
40780 function fixTargetRef(event) { argument
40782 var context = event.context,
40829 return function(event) { argument
40830 var context = event.context,
40834 return fn(event);
40914 this.preExecute('shape.create', function(event) { argument
40916 var context = event.context,
40933 this.preExecute('elements.move', function(event) { argument
40934 var context = event.context,
40955 this.postExecute('shape.create', function(event) { argument
40956 var context = event.context,
40971 this.postExecute('shape.move', function(event) { argument
40972 var context = event.context,
40997 this.postExecute('shape.delete', function(event) { argument
40998 var context = event.context,
41015 this.postExecute('canvas.updateRoot', function(event) { argument
41016 var context = event.context,
41139 this.postExecuted('shape.delete', LOW_PRIORITY$a, function(event) { argument
41141 var context = event.context,
41453 this.preExecuted('connection.create', function(event) { argument
41455 var context = event.context,
41481 this.preExecuted('shape.replace', function(event) { argument
41483 var newShape = event.context.newShape,
41624 this.executed('shape.delete', function(event) { argument
41626 var context = event.context,
41644 this.reverted('shape.delete', function(event) { argument
41646 var context = event.context,
41664 this.execute('shape.create', function(event) { argument
41665 var context = event.context,
41680 this.revert('shape.create', function(event) { argument
41682 var context = event.context,
41846 this.executed([ 'shape.move', 'shape.create', 'shape.resize' ], function(event) { argument
41847 var bo = getBusinessObject(event.context.shape);
42642 this.postExecute('shape.delete', function(event) { argument
42643 var context = event.context,
42654 this.postExecute([ 'label.create' ], function(event) { argument
42656 var context = event.context,
42689 function getVisibleLabelAdjustment(event) { argument
42691 var context = event.context,
42713 ], function(event) { argument
42714 var context = event.context,
42734 labelAdjustment = getVisibleLabelAdjustment(event);
42741 this.postExecute([ 'shape.replace' ], function(event) { argument
42742 var context = event.context,
42759 this.postExecute('shape.resize', function(event) { argument
42761 var context = event.context,
43099 eventBus.on([ 'shape.move.rejected', 'create.rejected' ], function(event) { argument
43100 var context = event.context,
43105 showError(event, translate(COLLAB_ERR_MSG));
43191 function replaceReconnectedConnection(event) { argument
43193 var context = event.context,
43254 this.postExecuted('element.updateProperties', function(event) { argument
43255 var context = event.context,
43349 this.postExecuted([ 'elements.create' ], 500, function(event) { argument
43350 var context = event.context,
43362 this.postExecuted([ 'elements.move' ], 500, function(event) { argument
43363 var context = event.context,
43464 eventBus.on('resize.start', HIGH_PRIORITY$8, function(event) { argument
43465 var context = event.context,
43620 eventBus.on('resize.start', SLIGHTLY_HIGHER_PRIORITY + 500, function(event) { argument
43621 var context = event.context,
43628 context.balanced = !hasPrimaryModifier(event);
43635 eventBus.on('resize.end', SLIGHTLY_HIGHER_PRIORITY, function(event) { argument
43636 var context = event.context,
43857 this.postExecuted('shape.replace', function(event) { argument
43858 var oldShape = event.context.oldShape,
43859 newShape = event.context.newShape;
44038 this.preExecute('shape.delete', function(event) { argument
44039 var context = event.context,
44055 this.preExecute('connection.delete', function(event) { argument
44056 var context = event.context,
44153 this.preExecute(laneRefUpdateEvents, HIGH_PRIORITY$7, function(event) { argument
44157 this.postExecuted(laneRefUpdateEvents, LOW_PRIORITY$7, function(event) { argument
44169 ], function(event) { argument
44171 var context = event.context,
44239 this.preExecute('connection.delete', function(event) { argument
44240 var context = event.context,
44844 function isDroppableBoundaryEvent(event) { argument
44845 return getBusinessObject(event).cancelActivity && (
44846 hasNoEventDefinition(event) || hasCommonBoundaryIntermediateEventDefinition(event)
45357 this.preExecute([ 'shape.create', 'connection.create' ], function(event) { argument
45359 var context = event.context,
45375 this.preExecute([ 'shape.move', 'connection.move' ], function(event) { argument
45377 var context = event.context,
45923 CommandStack.prototype._fire = function(command, qualifier, event) { argument
45925 event = qualifier;
45932 event = this._eventBus.createEvent(event);
45935 result = this._eventBus.fire('commandStack.' + name, event);
45937 if (event.cancelBubble) {
46192 delegate.bind(this._tooltipRoot, tooltipSelector, 'mousedown', function(event) { argument
46193 event.stopPropagation();
46196 delegate.bind(this._tooltipRoot, tooltipSelector, 'mouseover', function(event) { argument
46197 self.trigger('mouseover', event);
46200 delegate.bind(this._tooltipRoot, tooltipSelector, 'mouseout', function(event) { argument
46201 self.trigger('mouseout', event);
46254 Tooltips.prototype.trigger = function(action, event) { argument
46256 var node = event.delegateTarget || event.target;
46447 this._eventBus.on('canvas.viewbox.changing', function(event) { argument
46451 this._eventBus.on('canvas.viewbox.changed', function(event) { argument
46452 updateViewbox(event.viewbox);
46714 movePreview && eventBus.on('shape.move.start', function(event) { argument
46715 var context = event.context,
46862 this.postExecute('shape.resize', function(event) { argument
46863 var context = event.context,
46886 this.preExecute('shape.delete', function(event) { argument
46888 var shape = event.context.shape;
47035 eventBus.on(events.tool + '.init', function(event) { argument
47036 var context = event.context;
47051 forEach(events, function(event) { argument
47052 eventsToRegister.push(event + '.ended');
47053 eventsToRegister.push(event + '.canceled');
47056 eventBus.on(eventsToRegister, LOW_PRIORITY$4, function(event) { argument
47065 if (isPaletteClick(event)) {
47084 function isPaletteClick(event) { argument
47085 var target = event.originalEvent && event.originalEvent.target;
47287 eventBus.on('spaceTool.selection.end', function(event) { argument
47289 self.activateMakeSpace(event.originalEvent);
47293 eventBus.on('spaceTool.move', HIGH_PRIORITY$3 , function(event) { argument
47294 var context = event.context,
47298 initialized = context.initialized = self.init(event, context);
47302 ensureConstraints(event);
47306 eventBus.on('spaceTool.end', function(event) { argument
47307 var context = event.context,
47318 ensureConstraints(event);
47325 delta[ axis ] = round$4(event[ 'd' + axis ]);
47329 eventBus.once('spaceTool.ended', function(event) { argument
47332 self.activateSelection(event.originalEvent, true, true);
47353 SpaceTool.prototype.activateSelection = function(event, autoActivate, reactivate) { argument
47354 this._dragging.init(event, 'spaceTool.selection', {
47371 SpaceTool.prototype.activateMakeSpace = function(event) { argument
47372 this._dragging.init(event, 'spaceTool', {
47404 SpaceTool.prototype.init = function(event, context) { argument
47405 var axis = abs$1(event.dx) > abs$1(event.dy) ? 'x' : 'y',
47406 delta = event[ 'd' + axis ],
47407 start = event[ axis ] - delta;
47419 if (hasPrimaryModifier(event)) {
47529 function ensureConstraints(event) { argument
47530 var context = event.context,
47540 x = Math.max(event.x, spaceToolConstraints.left);
47542 event.dx = event.dx + x - event.x;
47543 event.x = x;
47547 x = Math.min(event.x, spaceToolConstraints.right);
47549 event.dx = event.dx + x - event.x;
47550 event.x = x;
47554 y = Math.max(event.y, spaceToolConstraints.top);
47556 event.dy = event.dy + y - event.y;
47557 event.y = y;
47561 y = Math.min(event.y, spaceToolConstraints.bottom);
47563 event.dy = event.dy + y - event.y;
47564 event.y = y;
47711 eventBus.on('spaceTool.selection.start', function(event) { argument
47713 context = event.context;
47743 eventBus.on('spaceTool.selection.move', function(event) { argument
47744 var crosshairGroup = event.context.crosshairGroup;
47746 translate$2(crosshairGroup, event.x, event.y);
47750 eventBus.on('spaceTool.selection.cleanup', function(event) { argument
47751 var context = event.context,
47760 eventBus.on('spaceTool.move', LOW_PRIORITY$3, function(event) { argument
47762 var context = event.context,
47870 x: 'M' + event.x + ', -10000 L' + event.x + ', 10000',
47871 y: 'M -10000, ' + event.y + ' L 10000, ' + event.y
47877 var delta = { x: event.dx, y: event.dy };
47920 eventBus.on('spaceTool.cleanup', function(event) { argument
47922 var context = event.context,
48185 function updateRoot(event) { argument
48186 var context = event.context,
48212 this.executed([ 'shape.move', 'shape.create', 'shape.resize' ], ifBpmn(function(event) { argument
48215 if (event.context.shape.type === 'label') {
48219 updateBounds(event);
48222 this.reverted([ 'shape.move', 'shape.create', 'shape.resize' ], ifBpmn(function(event) { argument
48225 if (event.context.shape.type === 'label') {
48229 updateBounds(event);
48234 eventBus.on('shape.changed', function(event) { argument
48235 if (event.element.type === 'label') {
48236 updateBounds({ context: { shape: event.element } });
48278 this.executed('connection.reconnect', ifBpmn(function(event) { argument
48279 var context = event.context,
48308 this.reverted('connection.reconnect', ifBpmn(function(event) { argument
48309 var context = event.context,
48770 return function(event) { argument
48772 var context = event.context,
48776 fn(event);
53942 eventBus.on('shape.move.start', HIGH_PRIORITY$2, function(event) { argument
53944 var context = event.context,
53945 shape = event.shape,
53971 eventBus.on('shape.move.start', MEDIUM_PRIORITY, function(event) { argument
53973 var context = event.context,
53989 eventBus.on('shape.move.move', LOW_PRIORITY$2, function(event) { argument
53991 var context = event.context,
53993 hover = event.hover,
53994 delta = { x: event.dx, y: event.dy },
53995 position = { x: event.x, y: event.y },
54014 eventBus.on('shape.move.end', function(event) { argument
54016 var context = event.context;
54047 eventBus.on('element.mousedown', function(event) { argument
54049 if (!isPrimaryButton(event)) {
54053 var originalEvent = getOriginal$1(event);
54059 return start(originalEvent, event.element);
54070 function start(event, element, activate, context) { argument
54083 dragging.init(event, referencePoint, 'shape.move', {
54213 eventBus.on('shape.move.start', LOW_PRIORITY$1, function(event) { argument
54214 var context = event.context,
54260 eventBus.on('shape.move.move', LOW_PRIORITY$1, function(event) { argument
54262 var context = event.context,
54278 translate$2(dragGroup, event.dx, event.dy);
54281 eventBus.on([ 'shape.move.out', 'shape.move.cleanup' ], function(event) { argument
54282 var context = event.context,
54291 eventBus.on('shape.move.cleanup', function(event) { argument
54293 var context = event.context,
54401 eventBus.on('tool-manager.update', function(event) { argument
54402 var tool = event.tool;
54451 this._eventBus.on('palette.getProviders', priority, function(event) { argument
54452 event.providers.push(provider);
54504 delegate.bind(container, ELEMENT_SELECTOR, 'click', function(event) { argument
54506 var target = event.delegateTarget;
54512 self.trigger('click', event);
54516 componentEvent.bind(container, 'mousedown', function(event) { argument
54517 event.stopPropagation();
54521 delegate.bind(container, ENTRY_SELECTOR, 'dragstart', function(event) { argument
54522 self.trigger('dragstart', event);
54534 var event = this._eventBus.createEvent({
54539 this._eventBus.fire(event);
54541 return event.providers;
54635 Palette.prototype.trigger = function(action, event, autoActivate) { argument
54640 button = event.delegateTarget || event.target;
54643 return event.preventDefault();
54655 originalEvent = event.originalEvent || event;
54669 event.preventDefault();
54890 eventBus.on('lasso.selection.end', function(event) { argument
54891 var target = event.originalEvent.target;
54895 if (!event.hover && !(target instanceof SVGElement)) {
54900 self.activateLasso(event.originalEvent, true);
54906 eventBus.on('lasso.end', function(event) { argument
54908 var bbox = toBBox(event);
54917 eventBus.on('lasso.start', function(event) { argument
54919 var context = event.context;
54921 context.bbox = toBBox(event);
54925 eventBus.on('lasso.move', function(event) { argument
54927 var context = event.context;
54929 context.bbox = toBBox(event);
54933 eventBus.on('lasso.cleanup', function(event) { argument
54935 var context = event.context;
54943 eventBus.on('element.mousedown', 1500, function(event) { argument
54945 if (!hasSecondaryModifier(event)) {
54949 self.activateLasso(event.originalEvent);
54967 LassoTool.prototype.activateLasso = function(event, autoActivate) { argument
54969 this._dragging.init(event, 'lasso', {
54978 LassoTool.prototype.activateSelection = function(event, autoActivate) { argument
54980 this._dragging.init(event, 'lasso.selection', {
55014 function toBBox(event) { argument
55018 x: event.x - event.dx,
55019 y: event.y - event.dy
55023 x: event.x,
55024 y: event.y
55105 eventBus.on('element.mousedown', HIGH_PRIORITY$1, function(event) { argument
55107 if (!hasPrimaryModifier(event)) {
55111 self.activateMove(event.originalEvent, true);
55134 eventBus.on('hand.end', function(event) { argument
55135 var target = event.originalEvent.target;
55139 if (!event.hover && !(target instanceof SVGElement)) {
55144 self.activateMove(event.originalEvent, { reactivate: true });
55149 eventBus.on('hand.move.move', function(event) { argument
55153 dx: event.dx * scale,
55154 dy: event.dy * scale
55158 eventBus.on('hand.move.end', function(event) { argument
55159 var context = event.context,
55163 if (!hasPrimaryModifier(event) && reactivate) {
55165 eventBus.once('hand.move.ended', function(event) { argument
55166 self.activateHand(event.originalEvent, true, true);
55186 HandTool.prototype.activateMove = function(event, autoActivate, context) { argument
55192 this._dragging.init(event, 'hand.move', {
55201 HandTool.prototype.activateHand = function(event, autoActivate, reactivate) { argument
55202 this._dragging.init(event, 'hand', {
55280 eventBus.on('global-connect.hover', function(event) { argument
55281 var context = event.context,
55282 startTarget = event.hover;
55297 eventBus.on([ 'global-connect.out', 'global-connect.cleanup' ], function(event) { argument
55298 var startTarget = event.context.startTarget,
55299 canStartConnect = event.context.canStartConnect;
55307 eventBus.on([ 'global-connect.ended' ], function(event) { argument
55308 var context = event.context,
55311 x: event.x,
55312 y: event.y
55346 GlobalConnect.prototype.start = function(event, autoActivate) { argument
55347 this._dragging.init(event, 'global-connect', {
55439 function createListener(event) { argument
55446 create.start(event, shape);
55462 function createSubprocess(event) { argument
55477 create.start(event, [ subProcess, startEvent ], {
55484 function createParticipant(event) { argument
55485 create.start(event, elementFactory.createParticipantShape());
55494 click: function(event) { argument
55495 handTool.activateHand(event);
55504 click: function(event) { argument
55505 lassoTool.activateSelection(event);
55514 click: function(event) { argument
55515 spaceTool.activateSelection(event);
55524 click: function(event) { argument
55525 globalConnect.start(event);
55683 eventBus.on('shape.move.move', LOW_PRIORITY, function(event) { argument
55685 var context = event.context,
55741 ], HIGHER_PRIORITY$2, function(event) { argument
55742 var context = event.context,
55750 if (event.originalEvent && isCmd(event.originalEvent)) {
55760 snapToShape(event, hover, getTargetBoundsPadding(hover));
55773 snapToPosition(event, mid$2(hover));
55778 snapToTargetMid(event, hover);
55783 snapBoundaryEventLoop(event);
55797 snapToPosition(event, mid$2(hover));
55814 function snapToShape(event, target, padding) { argument
55818 if (event[ axis ] < target[ axis ] + padding) {
55819 setSnapped(event, axis, target[ axis ] + padding);
55820 } else if (event[ axis ] > target[ axis ] + dimensionForAxis - padding) {
55821 setSnapped(event, axis, target[ axis ] + dimensionForAxis - padding);
55827 function snapToTargetMid(event, target) { argument
55831 if (isMid(event, target, axis)) {
55832 setSnapped(event, axis, targetMid[ axis ]);
55838 function snapBoundaryEventLoop(event) { argument
55839 var context = event.context,
55860 var coordinate = event[ axis ], newCoordinate;
55870 setSnapped(event, axis, newCoordinate);
55875 function snapToPosition(event, position) { argument
55876 setSnapped(event, 'x', position.x);
55877 setSnapped(event, 'y', position.y);
55902 function isMid(event, target, axis) { argument
55903 return event[ axis ] > target[ axis ] + TARGET_CENTER_PADDING
55904 && event[ axis ] < target[ axis ] + getDimensionForAxis(axis, target) - TARGET_CENTER_PADDING;
56094 ], function(event) { argument
56095 self.initSnap(event);
56103 ], HIGHER_PRIORITY$1, function(event) { argument
56104 var context = event.context,
56109 if (event.originalEvent && isCmd(event.originalEvent)) {
56113 if (isSnapped(event) || !target) {
56125 snapping.snap(event, snapPoints);
56142 CreateMoveSnapping.prototype.initSnap = function(event) { argument
56145 var context = event.context,
56158 shapeMid = mid$2(shape, event);
56163 x: event.x + mid$2(shape).x,
56164 y: event.y + mid$2(shape).y
56178 x: shapeMid.x - event.x,
56179 y: shapeMid.y - event.y
56188 x: shapeTopLeft.x - event.x,
56189 y: shapeTopLeft.y - event.y
56193 x: shapeBottomRight.x - event.x,
56194 y: shapeBottomRight.y - event.y
56290 ], HIGH_PRIORITY, function(event) { argument
56291 var context = event.context,
56297 if (canAttach && !isSnapped(event)) {
56298 snapBoundaryEvent(event, target);
56310 BpmnCreateMoveSnapping.prototype.initSnap = function(event) { argument
56311 var snapContext = CreateMoveSnapping.prototype.initSnap.call(this, event);
56313 var shape = event.shape;
56323 …napContext.setSnapOrigin(connection.id + '-docking', getDockingSnapOrigin(docking, isMove, event));
56331 …napContext.setSnapOrigin(connection.id + '-docking', getDockingSnapOrigin(docking, isMove, event));
56407 function snapBoundaryEvent(event, target) { argument
56410 var direction = getBoundaryAttachment(event, target);
56412 var context = event.context,
56424 setSnapped(event, 'y', targetTRBL.top - offset.y);
56426 setSnapped(event, 'y', targetTRBL.bottom - offset.y);
56430 setSnapped(event, 'x', targetTRBL.left - offset.x);
56432 setSnapped(event, 'x', targetTRBL.right - offset.x);
56451 function setSnappedIfConstrained(event) { argument
56452 var context = event.context,
56464 if ((left && left >= event.x) || (right && right <= event.x)) {
56465 setSnapped(event, 'x', event.x);
56468 if ((top && top >= event.y) || (bottom && bottom <= event.y)) {
56469 setSnapped(event, 'y', event.y);
56477 function getDockingSnapOrigin(docking, isMove, event) { argument
56480 x: docking.x - event.x,
56481 y: docking.y - event.y
56501 eventBus.on([ 'resize.start' ], function(event) { argument
56502 self.initSnap(event);
56508 ], HIGHER_PRIORITY, function(event) { argument
56509 var context = event.context,
56515 if (event.originalEvent && isCmd(event.originalEvent)) {
56519 if (isSnapped(event)) {
56532 setSnapped(event, 'x', event.x);
56536 setSnapped(event, 'y', event.y);
56539 snapping.snap(event, snapPoints);
56547 ResizeSnapping.prototype.initSnap = function(event) { argument
56548 var context = event.context,
56560 x: snapOrigin.x - event.x,
56561 y: snapOrigin.y - event.y
56670 Snapping.prototype.snap = function(event, snapPoints) { argument
56671 var context = event.context,
56676 x: isSnapped(event, 'x'),
56677 y: isSnapped(event, 'y')
56684 x: event.x + snapOrigin.x,
56685 y: event.y + snapOrigin.y
56719 setSnapped(event, axis, axisSnapping.originValue);