Lines Matching refs:prototype
28 ctor.prototype = Object.create(superCtor.prototype, {
44 TempCtor.prototype = superCtor.prototype;
45 ctor.prototype = new TempCtor();
46 ctor.prototype.constructor = ctor;
146 Ids.prototype.next = function (element) {
158 Ids.prototype.nextPrefixed = function (prefix, element) {
178 Ids.prototype.claim = function (id, element) {
189 Ids.prototype.assigned = function (id) {
199 Ids.prototype.unclaim = function (id) {
207 Ids.prototype.clear = function () {
224 return Array.prototype.concat.apply([], arr);
227 var nativeToString = Object.prototype.toString;
228 var nativeHasOwnProperty = Object.prototype.hasOwnProperty;
667 if (Object.prototype.hasOwnProperty.call(source, key)) {
785 var toString$1 = Object.prototype.toString;
822 ClassList$1.prototype.add = function (name) {
847 ClassList$1.prototype.remove = function (name) {
874 ClassList$1.prototype.removeMatching = function (re) {
896 ClassList$1.prototype.toggle = function (name, force) {
934 ClassList$1.prototype.array = function () {
950 ClassList$1.prototype.has = ClassList$1.prototype.contains = function (name) {
969 var proto = typeof Element !== 'undefined' ? Element.prototype : {};
1443 var toString = Object.prototype.toString;
1477 ClassList.prototype.add = function(name) {
1511 ClassList.prototype.remove = function(name) {
1540 ClassList.prototype.removeMatching = function(re) {
1562 ClassList.prototype.toggle = function(name, force) {
1600 ClassList.prototype.array = function() {
1618 ClassList.prototype.has =
1619 ClassList.prototype.contains = function(name) {
1940 return Array.prototype.slice.call(arr);
1996 return Object.prototype.toString.call(obj) === '[object Array]';
2000 return Object.prototype.hasOwnProperty.call(obj, prop);
2004 var args = Array.prototype.slice.call(arguments);
2179 var Constructor = Function.prototype.bind.apply(fn, [ null ].concat(dependencies));
2370 BaseRenderer.prototype.canRender = function() {};
2380 BaseRenderer.prototype.drawShape = function() {};
2390 BaseRenderer.prototype.drawConnection = function() {};
2399 BaseRenderer.prototype.getShapePath = function() {};
2408 BaseRenderer.prototype.getConnectionPath = function() {};
2802 DefaultRenderer.prototype.canRender = function() {
2806 DefaultRenderer.prototype.drawShape = function drawShape(visuals, element) {
2827 DefaultRenderer.prototype.drawConnection = function drawConnection(visuals, connection) {
2835 DefaultRenderer.prototype.getShapePath = function getShapePath(shape) {
2853 DefaultRenderer.prototype.getConnectionPath = function getConnectionPath(connection) {
3206 return Object.prototype.hasOwnProperty.call(obj, property);
3236 var arg = Array.prototype.slice.call(arguments, 0),
4416 Canvas.prototype._init = function(config) {
4475 Canvas.prototype._destroy = function(emit) {
4495 Canvas.prototype._clear = function() {
4526 Canvas.prototype.getDefaultLayer = function() {
4545 Canvas.prototype.getLayer = function(name, index) {
4574 Canvas.prototype._createLayer = function(name, index) {
4602 Canvas.prototype.getPlane = function(name) {
4621 Canvas.prototype.createPlane = function(name, rootElement) {
4659 Canvas.prototype.setActivePlane = function(plane) {
4693 Canvas.prototype.getActiveLayer = function() {
4702 Canvas.prototype.getActivePlane = function() {
4719 Canvas.prototype.findPlane = function(element) {
4737 Canvas.prototype.getContainer = function() {
4744 Canvas.prototype._updateMarker = function(element, marker, add) {
4800 Canvas.prototype.addMarker = function(element, marker) {
4814 Canvas.prototype.removeMarker = function(element, marker) {
4824 Canvas.prototype.hasMarker = function(element, marker) {
4843 Canvas.prototype.toggleMarker = function(element, marker) {
4851 Canvas.prototype.getRootElement = function() {
4870 Canvas.prototype.setRootElement = function(element, override) {
4895 Canvas.prototype.setRootElementForPlane = function(element, plane, override) {
4944 Canvas.prototype._ensureValid = function(type, element) {
4965 Canvas.prototype._setParent = function(element, parent, parentIndex) {
4990 Canvas.prototype._addElement = function(type, element, parent, parentIndex) {
5025 Canvas.prototype.addShape = function(shape, parent, parentIndex) {
5038 Canvas.prototype.addConnection = function(connection, parent, parentIndex) {
5046 Canvas.prototype._removeElement = function(element, type) {
5083 Canvas.prototype.removeShape = function(shape) {
5117 Canvas.prototype.removeConnection = function(connection) {
5152 Canvas.prototype.getGraphics = function(element, secondary) {
5162 Canvas.prototype._changeViewbox = function(changeFn) {
5180 Canvas.prototype._viewboxChanged = function() {
5230 Canvas.prototype.viewbox = function(box) {
5299 Canvas.prototype.scroll = function(delta) {
5325 Canvas.prototype.scrollToElement = function(element, padding) {
5398 Canvas.prototype.zoom = function(newScale, center) {
5433 Canvas.prototype._fitViewport = function(center) {
5477 Canvas.prototype._setZoom = function(scale, center) {
5523 Canvas.prototype.getSize = function() {
5541 Canvas.prototype.getAbsoluteBBox = function(element) {
5577 Canvas.prototype.resized = function() {
5608 ElementRegistry.prototype.add = function(element, gfx, secondaryGfx) {
5629 ElementRegistry.prototype.remove = function(element) {
5653 ElementRegistry.prototype.updateId = function(element, newId) {
5683 ElementRegistry.prototype.updateGraphics = function(filter, gfx, secondary) {
5712 ElementRegistry.prototype.get = function(filter) {
5732 ElementRegistry.prototype.filter = function(fn) {
5752 ElementRegistry.prototype.find = function(fn) {
5773 ElementRegistry.prototype.getAll = function() {
5782 ElementRegistry.prototype.forEach = function(fn) {
5810 ElementRegistry.prototype.getGraphics = function(filter, secondary) {
5825 ElementRegistry.prototype._validateId = function(id) {
5961 return Object.prototype.hasOwnProperty.call(e, property.name || property);
6089 Refs$1.prototype.bind = function(target, property) {
6104 Refs$1.prototype.ensureRefsCollection = function(target, property) {
6115 Refs$1.prototype.ensureBound = function(target, property) {
6121 Refs$1.prototype.unset = function(target, property, value) {
6134 Refs$1.prototype.set = function(target, property, value) {
6397 ElementFactory$1.prototype.createRoot = function(attrs) {
6401 ElementFactory$1.prototype.createLabel = function(attrs) {
6405 ElementFactory$1.prototype.createShape = function(attrs) {
6409 ElementFactory$1.prototype.createConnection = function(attrs) {
6421 ElementFactory$1.prototype.create = function(type, attrs) {
6436 var slice = Array.prototype.slice;
6547 EventBus.prototype.on = function(events, priority, callback, that) {
6592 EventBus.prototype.once = function(event, priority, callback, that) {
6632 EventBus.prototype.off = function(events, callback) {
6652 EventBus.prototype.createEvent = function(data) {
6691 EventBus.prototype.fire = function(type, data) {
6755 EventBus.prototype.handleError = function(error) {
6760 EventBus.prototype._destroy = function() {
6764 EventBus.prototype._invokeListeners = function(event, args, listener) {
6783 EventBus.prototype._invokeListener = function(event, args, listener) {
6833 EventBus.prototype._addListener = function(event, newListener) {
6871 EventBus.prototype._getListeners = function(name) {
6875 EventBus.prototype._setListeners = function(name, listener) {
6879 EventBus.prototype._removeListener = function(event, callback) {
6920 InternalEvent.prototype.stopPropagation = function() {
6924 InternalEvent.prototype.preventDefault = function() {
6928 InternalEvent.prototype.init = function(data) {
7032 GraphicsFactory.prototype._getChildrenContainer = function(element) {
7058 GraphicsFactory.prototype._clear = function(gfx) {
7093 GraphicsFactory.prototype._createContainer = function(
7125 GraphicsFactory.prototype.create = function(type, element, parentIndex) {
7130 GraphicsFactory.prototype.updateContainments = function(elements) {
7165 GraphicsFactory.prototype.drawShape = function(visual, element) {
7171 GraphicsFactory.prototype.getShapePath = function(element) {
7177 GraphicsFactory.prototype.drawConnection = function(visual, element) {
7183 GraphicsFactory.prototype.getConnectionPath = function(waypoints) {
7189 GraphicsFactory.prototype.update = function(type, element, gfx) {
7218 GraphicsFactory.prototype.remove = function(element) {
7438 Diagram.prototype.destroy = function() {
7445 Diagram.prototype.clear = function() {
7454 Base.prototype.get = function(name) {
7458 Base.prototype.set = function(name, value) {
7474 Factory.prototype.createType = function(descriptor) {
7479 prototype = Object.create(Base.prototype);
7484 prototype[p.name] = p.default;
7488 props.defineModel(prototype, model);
7489 props.defineDescriptor(prototype, descriptor);
7506 ModdleElement.prototype = prototype;
7508 ModdleElement.hasType = prototype.$instanceOf = this.model.hasType;
7614 DescriptorBuilder.prototype.build = function() {
7634 DescriptorBuilder.prototype.addProperty = function(p, idx, validate) {
7653 DescriptorBuilder.prototype.replaceProperty = function(oldProperty, newProperty, replace) {
7703 DescriptorBuilder.prototype.redefineProperty = function(p, targetPropertyName, replace) {
7721 DescriptorBuilder.prototype.addNamedProperty = function(p, validate) {
7733 DescriptorBuilder.prototype.removeNamedProperty = function(p) {
7741 DescriptorBuilder.prototype.setBodyProperty = function(p, validate) {
7752 DescriptorBuilder.prototype.setIdProperty = function(p, validate) {
7763 DescriptorBuilder.prototype.assertNotDefined = function(p, name) {
7775 DescriptorBuilder.prototype.hasProperty = function(name) {
7779 DescriptorBuilder.prototype.addTrait = function(t, inherited) {
7841 Registry.prototype.getPackage = function(uriOrPrefix) {
7845 Registry.prototype.getPackages = function() {
7850 Registry.prototype.registerPackage = function(pkg) {
7873 Registry.prototype.registerType = function(type, pkg) {
7937 Registry.prototype.mapTypes = function(nsName, iterator, trait) {
7983 Registry.prototype.getEffectiveDescriptor = function(name) {
8002 Registry.prototype.definePackage = function(target, pkg) {
8037 Properties.prototype.set = function(target, name, value) {
8074 Properties.prototype.get = function(target, name) {
8100 Properties.prototype.define = function(target, name, options) {
8108 Properties.prototype.defineDescriptor = function(target, descriptor) {
8115 Properties.prototype.defineModel = function(target, model) {
8181 Moddle.prototype.create = function(descriptor, attrs) {
8205 Moddle.prototype.getType = function(descriptor) {
8249 Moddle.prototype.createAny = function(name, nsUri, properties) {
8291 Moddle.prototype.getPackage = function(uriOrPrefix) {
8300 Moddle.prototype.getPackages = function() {
8307 Moddle.prototype.getElementDescriptor = function(element) {
8317 Moddle.prototype.hasType = function(element, type) {
8331 Moddle.prototype.getPropertyDescriptor = function(element, property) {
8338 Moddle.prototype.getTypeDescriptor = function(type) {
8344 var hasOwnProperty = Object.prototype.hasOwnProperty;
9582 BaseHandler.prototype.handleEnd = function() {};
9583 BaseHandler.prototype.handleText = function() {};
9584 BaseHandler.prototype.handleNode = function() {};
9596 NoopHandler.prototype = Object.create(BaseHandler.prototype);
9598 NoopHandler.prototype.handleNode = function() {
9604 BodyHandler.prototype = Object.create(BaseHandler.prototype);
9606 BodyHandler.prototype.handleText = function(text) {
9615 ReferenceHandler.prototype = Object.create(BodyHandler.prototype);
9617 ReferenceHandler.prototype.handleNode = function(node) {
9628 ReferenceHandler.prototype.handleEnd = function() {
9632 ReferenceHandler.prototype.createReference = function(node) {
9644 ValueHandler.prototype = Object.create(BodyHandler.prototype);
9646 ValueHandler.prototype.handleEnd = function() {
9664 BaseElementHandler.prototype = Object.create(BodyHandler.prototype);
9666 BaseElementHandler.prototype.handleNode = function(node) {
9691 ElementHandler.prototype = Object.create(BaseElementHandler.prototype);
9693 ElementHandler.prototype.addReference = function(reference) {
9697 ElementHandler.prototype.handleText = function(text) {
9707 BodyHandler.prototype.handleText.call(this, text);
9710 ElementHandler.prototype.handleEnd = function() {
9728 ElementHandler.prototype.createElement = function(node) {
9791 ElementHandler.prototype.getPropertyForNode = function(node) {
9863 ElementHandler.prototype.toString = function() {
9867 ElementHandler.prototype.valueHandler = function(propertyDesc, element) {
9871 ElementHandler.prototype.referenceHandler = function(propertyDesc) {
9875 ElementHandler.prototype.handler = function(type) {
9888 ElementHandler.prototype.handleChild = function(node) {
9947 RootElementHandler.prototype = Object.create(ElementHandler.prototype);
9949 RootElementHandler.prototype.createElement = function(node) {
9966 return ElementHandler.prototype.createElement.call(this, node);
9975 GenericElementHandler.prototype = Object.create(BaseElementHandler.prototype);
9977 GenericElementHandler.prototype.createElement = function(node) {
9988 GenericElementHandler.prototype.handleChild = function(node) {
10007 GenericElementHandler.prototype.handleEnd = function() {
10058 Reader.prototype.fromXML = function(xml, options, done) {
10334 Reader.prototype.handler = function(name) {
10445 ctor.prototype = Object.create(superCtor.prototype, {
10572 ReferenceSerializer.prototype.build = function(element) {
10577 ReferenceSerializer.prototype.serializeTo = function(writer) {
10586 BodySerializer.prototype.serializeValue =
10587 BodySerializer.prototype.serializeTo = function(writer) {
10595 BodySerializer.prototype.build = function(prop, value) {
10611 ValueSerializer.prototype.serializeTo = function(writer) {
10632 ElementSerializer.prototype.build = function(element) {
10670 ElementSerializer.prototype.nsTagName = function(descriptor) {
10675 ElementSerializer.prototype.nsPropertyTagName = function(descriptor) {
10680 ElementSerializer.prototype.isLocalNs = function(ns) {
10692 ElementSerializer.prototype.nsAttributeName = function(element) {
10721 ElementSerializer.prototype.parseGeneric = function(element) {
10752 ElementSerializer.prototype.parseNsAttribute = function(element, name, value) {
10796 ElementSerializer.prototype.parseNsAttributes = function(element, attrs) {
10818 ElementSerializer.prototype.parseGenericAttributes = function(element, attributes) {
10841 ElementSerializer.prototype.parseContainments = function(properties) {
10893 ElementSerializer.prototype.getNamespaces = function(local) {
10912 ElementSerializer.prototype.logNamespace = function(ns, wellknown, local) {
10929 ElementSerializer.prototype.logNamespaceUsed = function(ns, local) {
10979 ElementSerializer.prototype.parseAttributes = function(properties) {
11008 ElementSerializer.prototype.addTagName = function(nsTagName) {
11016 ElementSerializer.prototype.addAttribute = function(name, value) {
11026 ElementSerializer.prototype.serializeAttributes = function(writer) {
11041 ElementSerializer.prototype.serializeTo = function(writer) {
11086 TypeSerializer.prototype.parseNsAttributes = function(element) {
11089 var attributes = ElementSerializer.prototype.parseNsAttributes.call(this, element);
11115 TypeSerializer.prototype.isLocalNs = function(ns) {
11206 BpmnModdle.prototype = Object.create(Moddle.prototype);
11236 BpmnModdle.prototype.fromXML = function(xmlStr, typeName, options) {
11266 BpmnModdle.prototype.toXML = function(element, options) {
15512 var argsWithoutCallback = Array.prototype.slice.call(arguments, 0, -1);
15695 BaseViewer.prototype.importXML = wrapForCompatibility(function importXML(xml, bpmnDiagram) {
15810 …BaseViewer.prototype.importDefinitions = wrapForCompatibility(function importDefinitions(definitio…
15865 BaseViewer.prototype.open = wrapForCompatibility(function open(bpmnDiagramOrId) {
15939 BaseViewer.prototype.saveXML = wrapForCompatibility(function saveXML(options) {
16013 BaseViewer.prototype.saveSVG = wrapForCompatibility(function saveSVG(options) {
16092 BaseViewer.prototype._setDefinitions = function(definitions) {
16096 BaseViewer.prototype.getModules = function() {
16108 BaseViewer.prototype.clear = function() {
16129 Diagram.prototype.clear.call(this);
16136 BaseViewer.prototype.destroy = function() {
16139 Diagram.prototype.destroy.call(this);
16155 BaseViewer.prototype.on = function(event, priority, callback, target) {
16165 BaseViewer.prototype.off = function(event, callback) {
16169 BaseViewer.prototype.attachTo = function(parentNode) {
16180 if (parentNode.get && parentNode.constructor.prototype.jquery) {
16195 BaseViewer.prototype.getDefinitions = function() {
16199 BaseViewer.prototype.detach = function() {
16213 BaseViewer.prototype._init = function(container, moddle, options) {
16247 BaseViewer.prototype._emit = function(type, event) {
16251 BaseViewer.prototype._createContainer = function(options) {
16264 BaseViewer.prototype._createModdle = function(options) {
16270 BaseViewer.prototype._modules = [];
16398 BaseModeler.prototype._createModdle = function(options) {
16399 var moddle = BaseViewer.prototype._createModdle.call(this, options);
16416 BaseModeler.prototype._collectIds = function(definitions, elementsById) {
18548 BpmnRenderer.prototype.canRender = function(element) {
18552 BpmnRenderer.prototype.drawShape = function(parentGfx, element) {
18560 BpmnRenderer.prototype.drawConnection = function(parentGfx, element) {
18568 BpmnRenderer.prototype.getShapePath = function(element) {
18807 Text.prototype.createText = function(text, options) {
18819 Text.prototype.getDimensions = function(text, options) {
18839 Text.prototype.layoutText = function(text, options) {
19788 BpmnImporter.prototype.add = function(semantic, parentElement) {
19902 BpmnImporter.prototype._attachBoundary = function(boundarySemantic, boundaryElement) {
19935 BpmnImporter.prototype.addLabel = function(semantic, element) {
19969 BpmnImporter.prototype._getEnd = function(semantic, side) {
20006 BpmnImporter.prototype._getSource = function(semantic) {
20010 BpmnImporter.prototype._getTarget = function(semantic) {
20015 BpmnImporter.prototype._getElement = function(semantic) {
20684 Outline.prototype.updateShapeOutline = function(outline, element) {
20703 Outline.prototype.updateConnectionOutline = function(outline, connection) {
20754 Selection.prototype.deselect = function(element) {
20769 Selection.prototype.get = function() {
20773 Selection.prototype.isSelected = function(element) {
20789 Selection.prototype.select = function(elements, add) {
21036 IdGenerator.prototype.next = function() {
21178 Overlays.prototype.get = function(search) {
21230 Overlays.prototype.add = function(element, type, overlay) {
21276 Overlays.prototype.remove = function(filter) {
21311 Overlays.prototype.show = function() {
21316 Overlays.prototype.hide = function() {
21320 Overlays.prototype.clear = function() {
21328 Overlays.prototype._updateOverlayContainer = function(container) {
21350 Overlays.prototype._updateOverlay = function(overlay) {
21393 Overlays.prototype._createOverlayContainer = function(element) {
21412 Overlays.prototype._updateRoot = function(viewbox) {
21430 Overlays.prototype._getOverlayContainer = function(element, raw) {
21444 Overlays.prototype._addOverlay = function(overlay) {
21453 if (html.get && html.constructor.prototype.jquery) {
21492 Overlays.prototype._updateOverlayVisibilty = function(overlay, viewbox) {
21514 Overlays.prototype._updateOverlayScale = function(overlay, viewbox) {
21549 Overlays.prototype._updateOverlaysVisibilty = function(viewbox) {
21559 Overlays.prototype._init = function() {
21734 Viewer.prototype._modules = [
21742 Viewer.prototype._moddleExtensions = {};
21852 Keyboard.prototype._keydownHandler = function(event) {
21856 Keyboard.prototype._keyupHandler = function(event) {
21860 Keyboard.prototype._keyHandler = function(event, type) {
21878 Keyboard.prototype._isEventIgnored = function(event) {
21882 Keyboard.prototype._isModifiedKeyIgnored = function(event) {
21891 Keyboard.prototype._getAllowedModifiers = function(element) {
21901 Keyboard.prototype.bind = function(node) {
21915 Keyboard.prototype.getBinding = function() {
21919 Keyboard.prototype.unbind = function() {
21933 Keyboard.prototype._fire = function(event) {
21946 Keyboard.prototype.addListener = function(priority, listener, type) {
21956 Keyboard.prototype.removeListener = function(listener, type) {
21960 Keyboard.prototype.hasModifier = hasModifier;
21961 Keyboard.prototype.isCmd = isCmd;
21962 Keyboard.prototype.isShift = isShift;
21963 Keyboard.prototype.isKey = isKey;
22019 KeyboardBindings.prototype.registerBindings = function(keyboard, editorActions) {
22528 ZoomScroll.prototype.scroll = function scroll(delta) {
22533 ZoomScroll.prototype.reset = function reset() {
22543 ZoomScroll.prototype.zoom = function zoom(delta, position) {
22560 ZoomScroll.prototype._handleWheel = function handleWheel(event) {
22628 ZoomScroll.prototype.stepZoom = function stepZoom(delta, position) {
22643 ZoomScroll.prototype._zoom = function(delta, position, stepSize) {
22669 ZoomScroll.prototype.toggle = function toggle(newEnabled) {
22694 ZoomScroll.prototype._init = function(newEnabled) {
22715 NavigatedViewer.prototype._navigationModules = [
22721 NavigatedViewer.prototype._modules = [].concat(
22722 Viewer.prototype._modules,
22723 NavigatedViewer.prototype._navigationModules
22894 var baseP = base.prototype,
22897 childP = child.prototype = Object.create(baseP);
23030 return Array.prototype.slice.call(obj, 0);
23166 Input.prototype = {
23939 TouchAction.prototype = {
24137 Recognizer.prototype = {
24531 return AttrRecognizer.prototype.attrTest.call(this, input) &&
24714 return PanRecognizer.prototype.getTouchAction.call(this);
25022 Manager.prototype = {
25708 TouchFix.prototype.addBBoxMarker = function(svg) {
25798 AlignElements$1.prototype._getOrientationDetails = function(type) {
25814 AlignElements$1.prototype._isType = function(type, types) {
25826 AlignElements$1.prototype._alignmentPosition = function(type, sortedElements) {
25900 AlignElements$1.prototype.trigger = function(elements, type) {
26560 CommandInterceptor.prototype.on = function(events, hook, priority, handlerFn, unwrap, that) {
26634 CommandInterceptor.prototype[hook] = function(events, priority, handlerFn, unwrap, that) {
26761 AutoResize.prototype._getOptimalBounds = function(elements, target) {
26797 AutoResize.prototype._expand = function(elements, target) {
26842 AutoResize.prototype.getOffset = function(shape) {
26855 AutoResize.prototype.getPadding = function(shape) {
26868 AutoResize.prototype.resize = function(shape, newBounds, hints) {
26938 BpmnAutoResize.prototype.resize = function(target, newBounds, hints) {
27010 RuleProvider.prototype.addRule = function(actions, priority, fn) {
27029 RuleProvider.prototype.init = function() {};
27057 AutoResizeProvider.prototype.canResize = function(elements, target) {
27085 BpmnAutoResizeProvider.prototype.canResize = function(elements, target) {
27867 AutoScroll.prototype.startScroll = function(point) {
27922 AutoScroll.prototype.stopScroll = function() {
27932 AutoScroll.prototype.setOptions = function(options) {
27943 AutoScroll.prototype._toBorderPoint = function(event) {
27996 Rules.prototype.allowed = function(action, context) {
28962 BendpointMove.prototype.cropWaypoints = function(connection, newWaypoints) {
30235 ConnectionPreview.prototype.drawPreview = function(context, canConnect, hints) {
30313 ConnectionPreview.prototype.drawNoopPreview = function(connectionPreviewGfx, hints) {
30336 ConnectionPreview.prototype.cropWaypoints = function(start, end, source, target) {
30354 ConnectionPreview.prototype.cleanUp = function(context) {
30367 ConnectionPreview.prototype.getConnection = function(canConnect) {
30379 ConnectionPreview.prototype.createConnectionPreviewGfx = function() {
30401 ConnectionPreview.prototype.createNoopConnection = function(start, end) {
30536 TextBox.prototype.create = function(bounds, style, value, options) {
30637 TextBox.prototype.handlePaste = function(e) {
30666 TextBox.prototype.insertText = function(text) {
30679 TextBox.prototype._insertTextIE = function(text) {
30744 TextBox.prototype.autoResize = function() {
30769 TextBox.prototype.resizable = function() {
30853 TextBox.prototype.destroy = function() {
30880 TextBox.prototype.getValue = function() {
30885 TextBox.prototype.getSelection = function() {
30893 TextBox.prototype.setSelection = function(container, offset) {
30945 DirectEditing.prototype.registerProvider = function(provider) {
30955 DirectEditing.prototype.isActive = function() {
30963 DirectEditing.prototype.cancel = function() {
30973 DirectEditing.prototype._fire = function(event, context) {
30977 DirectEditing.prototype.close = function() {
30988 DirectEditing.prototype.complete = function() {
31023 DirectEditing.prototype.getValue = function() {
31028 DirectEditing.prototype._handleKey = function(e) {
31049 DirectEditing.prototype._handleResize = function(event) {
31060 DirectEditing.prototype.activate = function(element) {
31154 ContextPad.prototype._init = function() {
31216 ContextPad.prototype.registerProvider = function(priority, provider) {
31235 ContextPad.prototype.getEntries = function(element) {
31265 ContextPad.prototype.trigger = function(action, event, autoActivate) {
31305 ContextPad.prototype.open = function(element, force) {
31314 ContextPad.prototype._getProviders = function() {
31326 ContextPad.prototype._updateAndOpen = function(element) {
31372 ContextPad.prototype.getPad = function(element) {
31413 ContextPad.prototype.close = function() {
31434 ContextPad.prototype.isOpen = function(element) {
31514 PreviewSupport.prototype.getGfx = function(element) {
31527 PreviewSupport.prototype.addDragger = function(element, group, gfx) {
31553 PreviewSupport.prototype.addFrame = function(shape, group) {
31573 PreviewSupport.prototype._cloneMarkers = function(gfx) {
31606 PreviewSupport.prototype._cloneMarker = function(gfx, marker, markerType) {
32221 PopupMenu.prototype.registerProvider = function(id, priority, provider) {
32237 PopupMenu.prototype.isEmpty = function(element, providerId) {
32271 PopupMenu.prototype.open = function(element, id, position) {
32329 PopupMenu.prototype.close = function() {
32348 PopupMenu.prototype.isOpen = function() {
32360 PopupMenu.prototype.trigger = function(event) {
32375 PopupMenu.prototype._getProviders = function(id) {
32387 PopupMenu.prototype._getEntries = function(element, providers) {
32422 PopupMenu.prototype._getHeaderEntries = function(element, providers) {
32470 PopupMenu.prototype._getEntry = function(entryId) {
32481 PopupMenu.prototype._emit = function(eventName) {
32490 PopupMenu.prototype._createContainer = function() {
32514 PopupMenu.prototype._attachContainer = function(container, parent, cursor) {
32540 PopupMenu.prototype._updateScale = function(container) {
32580 PopupMenu.prototype._assureIsInbounds = function(container, cursor) {
32630 PopupMenu.prototype._createEntries = function(entries, className) {
32653 PopupMenu.prototype._createEntry = function(entry, id) {
32697 PopupMenu.prototype._bindAutoClose = function() {
32705 PopupMenu.prototype._unbindAutoClose = function() {
32732 Clipboard.prototype.get = function() {
32736 Clipboard.prototype.set = function(data) {
32740 Clipboard.prototype.clear = function() {
32748 Clipboard.prototype.isEmpty = function() {
32780 Mouse.prototype.getLastMoveEvent = function() {
32978 CopyPaste.prototype.copy = function(elements) {
33016 CopyPaste.prototype.paste = function(context) {
33049 CopyPaste.prototype._paste = function(elements, target, position, hints) {
33087 CopyPaste.prototype._createElements = function(tree) {
33154 CopyPaste.prototype.createConnection = function(attrs) {
33160 CopyPaste.prototype.createLabel = function(attrs) {
33166 CopyPaste.prototype.createShape = function(attrs) {
33180 CopyPaste.prototype.hasRelations = function(element, elements) {
33226 CopyPaste.prototype.createTree = function(elements) {
33702 ModdleCopy.prototype.copyElement = function(sourceElement, targetElement, propertyNames) {
33762 ModdleCopy.prototype.copyProperty = function(property, parent, propertyName) {
33835 ModdleCopy.prototype._copyId = function(id, element) {
33894 Replace.prototype.replaceElement = function(oldElement, newElementData, options) {
35157 ReplaceMenuProvider.prototype.register = function() {
35170 ReplaceMenuProvider.prototype.getEntries = function(element) {
35363 ReplaceMenuProvider.prototype.getHeaderEntries = function(element) {
35398 ReplaceMenuProvider.prototype._createEntries = function(element, replaceOptions) {
35420 ReplaceMenuProvider.prototype._createSequenceFlowEntries = function(element, replaceOptions) {
35493 ReplaceMenuProvider.prototype._createMenuEntry = function(definition, element, action) {
35525 ReplaceMenuProvider.prototype._getLoopEntries = function(element) {
35603 ReplaceMenuProvider.prototype._getDataObjectIsCollection = function(element) {
35637 ReplaceMenuProvider.prototype._getParticipantMultiplicity = function(element) {
35678 ReplaceMenuProvider.prototype._getAdHocEntry = function(element) {
36138 ContextPadProvider.prototype.getContextPadEntries = function(element) {
36585 DistributeElements$1.prototype.registerFilter = function(filterFn) {
36599 DistributeElements$1.prototype.trigger = function(elements, orientation) {
36632 DistributeElements$1.prototype._filterElements = function(elements) {
36669 DistributeElements$1.prototype._createGroups = function(elements) {
36706 DistributeElements$1.prototype._setOrientation = function(direction) {
36722 DistributeElements$1.prototype._hasIntersection = function(rangeA, rangeB) {
36737 DistributeElements$1.prototype._findRange = function(element) {
36843 EditorActions.prototype._registerDefaultActions = function(injector) {
36946 EditorActions.prototype.trigger = function(action, opts) {
36977 EditorActions.prototype.register = function(actions, listener) {
36995 EditorActions.prototype._registerAction = function(action, listener) {
37008 EditorActions.prototype.unregister = function(action) {
37021 EditorActions.prototype.getActions = function() {
37032 EditorActions.prototype.isRegistered = function(action) {
37066 BpmnEditorActions.prototype._registerDefaultActions = function(injector) {
37070 EditorActions.prototype._registerDefaultActions.call(this, injector);
37331 GridSnapping.prototype.snapEvent = function(event, axis, options) {
37342 GridSnapping.prototype.getGridSpacing = function() {
37355 GridSnapping.prototype.snapValue = function(value, options) {
37393 GridSnapping.prototype.isActive = function() {
37397 GridSnapping.prototype.setActive = function(active) {
37403 GridSnapping.prototype.toggleActive = function() {
37627 ResizeBehavior$1.prototype.snapSimple = function(shape, newBounds) {
37652 ResizeBehavior$1.prototype.snapComplex = function(newBounds, directions) {
37672 ResizeBehavior$1.prototype.snapHorizontally = function(newBounds, directions) {
37716 ResizeBehavior$1.prototype.snapVertically = function(newBounds, directions) {
37949 LayoutConnectionBehavior.prototype.snapMiddleSegments = function(waypoints) {
38107 BpmnInteractionEvents.prototype.createDefaultHit = function(element, gfx) {
38116 BpmnInteractionEvents.prototype.createParticipantHit = function(element, gfx) {
38137 BpmnInteractionEvents.prototype.createSubProcessHit = function(element, gfx) {
38185 BpmnKeyboardBindings.prototype.registerBindings = function(keyboard, editorActions) {
38188 KeyboardBindings.prototype.registerBindings.call(this, keyboard, editorActions);
38689 Resize.prototype.canResize = function(context) {
38707 Resize.prototype.activate = function(event, shape, contextOrDirection) {
38736 Resize.prototype.computeMinResizeBox = function(context) {
38939 ResizeHandles.prototype.makeDraggable = function(element, gfx, direction) {
38955 ResizeHandles.prototype._createResizer = function(element, x, y, direction) {
38999 ResizeHandles.prototype.createResizer = function(element, direction) {
39014 ResizeHandles.prototype.addResizer = function(shape) {
39031 ResizeHandles.prototype.removeResizers = function() {
39037 ResizeHandles.prototype._getResizersParent = function() {
39216 LabelEditingProvider.prototype.activate = function(element) {
39282 LabelEditingProvider.prototype.getEditingBBox = function(element) {
39450 LabelEditingProvider.prototype.update = function(
40030 AttachEventBehavior.prototype.replaceShape = function(shape, host) {
40846 UpdateSemanticParentHandler.prototype.execute = function(context) {
40861 UpdateSemanticParentHandler.prototype.revert = function(context) {
41216 DetachEventBehavior.prototype.replaceShape = function(shape) {
43417 ReplaceElementBehaviour.prototype.replaceElements = function(elements, newElements) {
44369 BpmnRules.prototype.init = function() {
44492 BpmnRules.prototype.canConnectMessageFlow = canConnectMessageFlow;
44494 BpmnRules.prototype.canConnectSequenceFlow = canConnectSequenceFlow;
44496 BpmnRules.prototype.canConnectDataAssociation = canConnectDataAssociation;
44498 BpmnRules.prototype.canConnectAssociation = canConnectAssociation;
44500 BpmnRules.prototype.canMove = canMove;
44502 BpmnRules.prototype.canAttach = canAttach;
44504 BpmnRules.prototype.canReplace = canReplace;
44506 BpmnRules.prototype.canDrop = canDrop;
44508 BpmnRules.prototype.canInsert = canInsert;
44510 BpmnRules.prototype.canCreate = canCreate;
44512 BpmnRules.prototype.canConnect = canConnect;
44514 BpmnRules.prototype.canResize = canResize;
44516 BpmnRules.prototype.canCopy = canCopy;
45406 OrderingProvider.prototype.getOrdering = function(element, newParent) {
45722 CommandStack.prototype.execute = function(command, context) {
45757 CommandStack.prototype.canExecute = function(command, context) {
45784 CommandStack.prototype.clear = function(emit) {
45797 CommandStack.prototype.undo = function() {
45825 CommandStack.prototype.redo = function() {
45856 CommandStack.prototype.register = function(command, handler) {
45868 CommandStack.prototype.registerHandler = function(command, handlerCls) {
45878 CommandStack.prototype.canUndo = function() {
45882 CommandStack.prototype.canRedo = function() {
45888 CommandStack.prototype._getRedoAction = function() {
45893 CommandStack.prototype._getUndoAction = function() {
45900 CommandStack.prototype._internalUndo = function(action) {
45923 CommandStack.prototype._fire = function(command, qualifier, event) {
45945 CommandStack.prototype._createId = function() {
45949 CommandStack.prototype._atomicDo = function(fn) {
45962 CommandStack.prototype._internalExecute = function(action, redo) {
46017 CommandStack.prototype._pushAction = function(action) {
46036 CommandStack.prototype._popAction = function() {
46056 CommandStack.prototype._markDirty = function(elements) {
46069 CommandStack.prototype._executedAction = function(action, redo) {
46078 CommandStack.prototype._revertedAction = function(action) {
46083 CommandStack.prototype._getHandler = function(command) {
46087 CommandStack.prototype._setHandler = function(command, handler) {
46229 Tooltips.prototype.add = function(tooltip) {
46254 Tooltips.prototype.trigger = function(action, event) {
46282 Tooltips.prototype.get = function(id) {
46291 Tooltips.prototype.clearTimeout = function(tooltip) {
46307 Tooltips.prototype.setTimeout = function(tooltip) {
46329 Tooltips.prototype.remove = function(id) {
46344 Tooltips.prototype.show = function() {
46349 Tooltips.prototype.hide = function() {
46354 Tooltips.prototype._updateRoot = function(viewbox) {
46365 Tooltips.prototype._addTooltip = function(tooltip) {
46373 if (html.get && html.constructor.prototype.jquery) {
46405 Tooltips.prototype._updateTooltip = function(tooltip) {
46416 Tooltips.prototype._updateTooltipVisibilty = function(viewbox) {
46434 Tooltips.prototype._init = function() {
46999 ToolManager.prototype.registerTool = function(name, events) {
47011 ToolManager.prototype.isActive = function(tool) {
47015 ToolManager.prototype.length = function(tool) {
47019 ToolManager.prototype.setActive = function(tool) {
47029 ToolManager.prototype.bindEvents = function(name, events) {
47353 SpaceTool.prototype.activateSelection = function(event, autoActivate, reactivate) {
47371 SpaceTool.prototype.activateMakeSpace = function(event) {
47392 SpaceTool.prototype.makeSpace = function(movingShapes, resizingShapes, delta, direction, start) {
47404 SpaceTool.prototype.init = function(event, context) {
47466 SpaceTool.prototype.calculateAdjustments = function(elements, axis, delta, start) {
47501 SpaceTool.prototype.toggle = function() {
47512 SpaceTool.prototype.isActive = function() {
47993 BpmnFactory.prototype._needsId = function(element) {
48014 BpmnFactory.prototype._ensureId = function(element) {
48040 BpmnFactory.prototype.create = function(type, attrs) {
48049 BpmnFactory.prototype.createDiLabel = function() {
48056 BpmnFactory.prototype.createDiShape = function(semantic, bounds, attrs) {
48065 BpmnFactory.prototype.createDiBounds = function(bounds) {
48070 BpmnFactory.prototype.createDiWaypoints = function(waypoints) {
48078 BpmnFactory.prototype.createDiWaypoint = function(point) {
48083 BpmnFactory.prototype.createDiEdge = function(semantic, waypoints, attrs) {
48089 BpmnFactory.prototype.createDiPlane = function(semantic) {
48351 BpmnUpdater.prototype.updateAttachment = function(context) {
48360 BpmnUpdater.prototype.updateParent = function(element, oldParent) {
48410 BpmnUpdater.prototype.updateBounds = function(shape) {
48431 …BpmnUpdater.prototype.updateFlowNodeRefs = function(businessObject, newContainment, oldContainment…
48452 BpmnUpdater.prototype.updateDiConnection = function(di, newSource, newTarget) {
48465 BpmnUpdater.prototype.updateDiParent = function(di, parentDi) {
48494 BpmnUpdater.prototype.getLaneSet = function(container) {
48529 BpmnUpdater.prototype.updateSemanticParent = function(businessObject, newParent, visualParent) {
48683 BpmnUpdater.prototype.updateConnectionWaypoints = function(connection) {
48688 BpmnUpdater.prototype.updateConnection = function(context) {
48752 BpmnUpdater.prototype._getLabel = function(di) {
48800 ElementFactory.prototype.baseCreate = ElementFactory$1.prototype.create;
48802 ElementFactory.prototype.create = function(elementType, attrs) {
48814 ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
48904 ElementFactory.prototype._getDefaultSize = function(semantic) {
48966 ElementFactory.prototype.createParticipantShape = function(attrs) {
49028 AlignElements.prototype.preExecute = function(context) {
49064 AlignElements.prototype.postExecute = function(context) {
49095 AppendShapeHandler.prototype.preExecute = function(context) {
49116 AppendShapeHandler.prototype.postExecute = function(context) {
49156 CreateConnectionHandler.prototype.execute = function(context) {
49186 CreateConnectionHandler.prototype.revert = function(context) {
49207 CreateElementsHandler.prototype.preExecute = function(context) {
49328 CreateShapeHandler.prototype.execute = function(context) {
49363 CreateShapeHandler.prototype.revert = function(context) {
49390 var originalExecute = CreateShapeHandler.prototype.execute;
49402 CreateLabelHandler.prototype.execute = function(context) {
49413 var originalRevert = CreateShapeHandler.prototype.revert;
49418 CreateLabelHandler.prototype.revert = function(context) {
49451 DeleteConnectionHandler.prototype.execute = function(context) {
49475 DeleteConnectionHandler.prototype.revert = function(context) {
49503 DeleteElementsHandler.prototype.postExecute = function(context) {
49541 DeleteShapeHandler.prototype.preExecute = function(context) {
49572 DeleteShapeHandler.prototype.execute = function(context) {
49593 DeleteShapeHandler.prototype.revert = function(context) {
49627 DistributeElements.prototype.preExecute = function(context) {
49758 DistributeElements.prototype.postExecute = function(context) {
49772 LayoutConnectionHandler.prototype.execute = function(context) {
49787 LayoutConnectionHandler.prototype.revert = function(context) {
49805 MoveConnectionHandler.prototype.execute = function(context) {
49838 MoveConnectionHandler.prototype.revert = function(context) {
49881 MoveClosure.prototype.add = function(element, isTopLevel) {
49886 MoveClosure.prototype.addAll = function(elements, isTopLevel) {
49917 MoveHelper.prototype.moveRecursive = function(elements, delta, newParent) {
49933 MoveHelper.prototype.moveClosure = function(closure, delta, newParent, newHost, primaryShape) {
49979 MoveHelper.prototype.getClosure = function(elements) {
49992 MoveElementsHandler.prototype.preExecute = function(context) {
49996 MoveElementsHandler.prototype.postExecute = function(context) {
50027 MoveShapeHandler.prototype.execute = function(context) {
50054 MoveShapeHandler.prototype.postExecute = function(context) {
50082 MoveShapeHandler.prototype.revert = function(context) {
50102 MoveShapeHandler.prototype.moveChildren = function(context) {
50110 MoveShapeHandler.prototype.getNewParent = function(context) {
50123 ReconnectConnectionHandler.prototype.execute = function(context) {
50151 ReconnectConnectionHandler.prototype.postExecute = function(context) {
50189 ReconnectConnectionHandler.prototype.revert = function(context) {
50247 ReplaceShapeHandler.prototype.preExecute = function(context) {
50331 ReplaceShapeHandler.prototype.postExecute = function(context) {
50338 ReplaceShapeHandler.prototype.execute = function(context) {};
50341 ReplaceShapeHandler.prototype.revert = function(context) {};
50344 ReplaceShapeHandler.prototype.createShape = function(shape, position, target, hints) {
50349 …ReplaceShapeHandler.prototype.reconnectStart = function(connection, newSource, dockingPoint, hints…
50354 ReplaceShapeHandler.prototype.reconnectEnd = function(connection, newTarget, dockingPoint, hints) {
50381 ResizeShapeHandler.prototype.execute = function(context) {
50418 ResizeShapeHandler.prototype.postExecute = function(context) {
50443 ResizeShapeHandler.prototype.revert = function(context) {
50468 SpaceToolHandler.prototype.preExecute = function(context) {
50499 SpaceToolHandler.prototype.execute = function() {};
50500 SpaceToolHandler.prototype.revert = function() {};
50502 SpaceToolHandler.prototype.moveShapes = function(shapes, delta) {
50514 SpaceToolHandler.prototype.resizeShapes = function(shapes, delta, direction) {
50533 SpaceToolHandler.prototype.updateConnectionWaypoints = function(
50667 ToggleShapeCollapseHandler.prototype.execute = function(context) {
50685 ToggleShapeCollapseHandler.prototype.revert = function(context) {
50767 UpdateAttachmentHandler.prototype.execute = function(context) {
50785 UpdateAttachmentHandler.prototype.revert = function(context) {
50827 UpdateWaypointsHandler.prototype.execute = function(context) {
50839 UpdateWaypointsHandler.prototype.revert = function(context) {
50873 Modeling$1.prototype.getHandlers = function() {
50912 Modeling$1.prototype.registerHandlers = function(commandStack) {
50921 Modeling$1.prototype.moveShape = function(shape, delta, newParent, newParentIndex, hints) {
50946 Modeling$1.prototype.updateAttachment = function(shape, newHost) {
50966 Modeling$1.prototype.moveElements = function(shapes, delta, target, hints) {
50996 …Modeling$1.prototype.moveConnection = function(connection, delta, newParent, newParentIndex, hints…
51015 Modeling$1.prototype.layoutConnection = function(connection, hints) {
51037 …Modeling$1.prototype.createConnection = function(source, target, parentIndex, connection, parent, …
51075 Modeling$1.prototype.createShape = function(shape, position, target, parentIndex, hints) {
51112 Modeling$1.prototype.createElements = function(elements, position, parent, parentIndex, hints) {
51138 Modeling$1.prototype.createLabel = function(labelTarget, position, label, parent) {
51170 Modeling$1.prototype.appendShape = function(source, shape, position, target, hints) {
51192 Modeling$1.prototype.removeElements = function(elements) {
51201 Modeling$1.prototype.distributeElements = function(groups, axis, dimension) {
51212 Modeling$1.prototype.removeShape = function(shape, hints) {
51222 Modeling$1.prototype.removeConnection = function(connection, hints) {
51231 Modeling$1.prototype.replaceShape = function(oldShape, newShape, hints) {
51243 Modeling$1.prototype.alignElements = function(elements, alignment) {
51252 Modeling$1.prototype.resizeShape = function(shape, newBounds, minBounds, hints) {
51263 …Modeling$1.prototype.createSpace = function(movingShapes, resizingShapes, delta, direction, start)…
51275 Modeling$1.prototype.updateWaypoints = function(connection, newWaypoints, hints) {
51285 Modeling$1.prototype.reconnect = function(connection, source, target, dockingOrPoints, hints) {
51297 Modeling$1.prototype.reconnectStart = function(connection, newSource, dockingOrPoints, hints) {
51307 Modeling$1.prototype.reconnectEnd = function(connection, newTarget, dockingOrPoints, hints) {
51317 Modeling$1.prototype.connect = function(source, target, attrs, hints) {
51321 Modeling$1.prototype._create = function(type, attrs) {
51329 Modeling$1.prototype.toggleCollapse = function(shape, hints) {
51344 UpdateModdlePropertiesHandler.prototype.execute = function(context) {
51365 UpdateModdlePropertiesHandler.prototype.revert = function(context) {
51382 UpdateModdlePropertiesHandler.prototype.getVisualReferences = function(moddleElement) {
51468 UpdatePropertiesHandler.prototype.execute = function(context) {
51517 UpdatePropertiesHandler.prototype.postExecute = function(context) {
51541 UpdatePropertiesHandler.prototype.revert = function(context) {
51654 UpdateCanvasRootHandler.prototype.execute = function(context) {
51688 UpdateCanvasRootHandler.prototype.revert = function(context) {
51737 AddLaneHandler.prototype.preExecute = function(context) {
51823 SplitLaneHandler.prototype.preExecute = function(context) {
51902 ResizeLaneHandler.prototype.preExecute = function(context) {
51922 ResizeLaneHandler.prototype.resizeBalanced = function(shape, newBounds) {
51944 ResizeLaneHandler.prototype.resizeSpace = function(shape, newBounds) {
52017 UpdateFlowNodeRefsHandler.prototype.computeUpdates = function(flowNodeShapes, laneShapes) {
52119 UpdateFlowNodeRefsHandler.prototype.execute = function(context) {
52151 UpdateFlowNodeRefsHandler.prototype.revert = function(context) {
52184 IdClaimHandler.prototype.execute = function(context) {
52200 IdClaimHandler.prototype.revert = function(context) {
52246 SetColorHandler.prototype.postExecute = function(context) {
52478 Modeling.prototype.getHandlers = function() {
52479 var handlers = Modeling$1.prototype.getHandlers.call(this);
52496 Modeling.prototype.updateLabel = function(element, newLabel, newBounds, hints) {
52506 Modeling.prototype.connect = function(source, target, attrs, hints) {
52522 Modeling.prototype.updateModdleProperties = function(element, moddleElement, properties) {
52530 Modeling.prototype.updateProperties = function(element, properties) {
52537 Modeling.prototype.resizeLane = function(laneShape, newBounds, balanced) {
52545 Modeling.prototype.addLane = function(targetLaneShape, location) {
52556 Modeling.prototype.splitLane = function(targetLane, count) {
52568 Modeling.prototype.makeCollaboration = function() {
52583 Modeling.prototype.updateLaneRefs = function(flowNodeShapes, laneShapes) {
52596 Modeling.prototype.makeProcess = function() {
52610 Modeling.prototype.claimId = function(id, moddleElement) {
52619 Modeling.prototype.unclaimId = function(id, moddleElement) {
52626 Modeling.prototype.setColor = function(elements, colors) {
52660 BaseLayouter.prototype.layoutConnection = function(connection, hints) {
53426 BpmnLayouter.prototype.layoutConnection = function(connection, hints) {
53800 CroppingConnectionDocking.prototype.getCroppedWaypoints = function(connection, source, target) {
53821 CroppingConnectionDocking.prototype.getDockingPoint = function(connection, shape, dockStart) {
53843 CroppingConnectionDocking.prototype._getIntersection = function(shape, connection, takeFirst) {
53851 CroppingConnectionDocking.prototype._getConnectionPath = function(connection) {
53855 CroppingConnectionDocking.prototype._getShapePath = function(shape) {
53859 CroppingConnectionDocking.prototype._getGfx = function(element) {
54445 Palette.prototype.registerProvider = function(priority, provider) {
54464 Palette.prototype.getEntries = function() {
54470 Palette.prototype._rebuild = function() {
54492 Palette.prototype._init = function() {
54532 Palette.prototype._getProviders = function(id) {
54549 Palette.prototype._toggleState = function(state) {
54581 Palette.prototype._update = function() {
54635 Palette.prototype.trigger = function(action, event, autoActivate) {
54672 Palette.prototype._layoutChanged = function() {
54684 Palette.prototype._needsCollapse = function(availableHeight, entries) {
54699 Palette.prototype.close = function() {
54711 Palette.prototype.open = function() {
54716 Palette.prototype.toggle = function(open) {
54724 Palette.prototype.isActiveTool = function(tool) {
54728 Palette.prototype.updateToolHighlight = function(name) {
54773 Palette.prototype.isOpen = function() {
54782 Palette.prototype._getParentContainer = function() {
54967 LassoTool.prototype.activateLasso = function(event, autoActivate) {
54978 LassoTool.prototype.activateSelection = function(event, autoActivate) {
54990 LassoTool.prototype.select = function(elements, bbox) {
54996 LassoTool.prototype.toggle = function() {
55006 LassoTool.prototype.isActive = function() {
55186 HandTool.prototype.activateMove = function(event, autoActivate, context) {
55201 HandTool.prototype.activateHand = function(event, autoActivate, reactivate) {
55214 HandTool.prototype.toggle = function() {
55224 HandTool.prototype.isActive = function() {
55346 GlobalConnect.prototype.start = function(event, autoActivate) {
55356 GlobalConnect.prototype.toggle = function() {
55367 GlobalConnect.prototype.isActive = function() {
55379 GlobalConnect.prototype.canStartConnect = function(startTarget) {
55426 PaletteProvider.prototype.getPaletteEntries = function(element) {
55953 SnapContext.prototype.getSnapOrigin = function(snapLocation) {
55958 SnapContext.prototype.setSnapOrigin = function(snapLocation, initialValue) {
55967 SnapContext.prototype.addDefaultSnap = function(type, point) {
55984 SnapContext.prototype.getSnapLocations = function() {
55995 SnapContext.prototype.setSnapLocations = function(snapLocations) {
56004 SnapContext.prototype.pointsForTarget = function(target) {
56036 SnapPoints.prototype.add = function(snapLocation, point) {
56054 SnapPoints.prototype.snap = function(point, snapLocation, axis, tolerance) {
56065 SnapPoints.prototype.initDefaults = function(defaultSnaps) {
56142 CreateMoveSnapping.prototype.initSnap = function(event) {
56200 CreateMoveSnapping.prototype.addSnapTargetPoints = function(snapPoints, shape, target) {
56249 CreateMoveSnapping.prototype.getSnapTargets = function(shape, target) {
56310 BpmnCreateMoveSnapping.prototype.initSnap = function(event) {
56311 var snapContext = CreateMoveSnapping.prototype.initSnap.call(this, event);
56343 BpmnCreateMoveSnapping.prototype.addSnapTargetPoints = function(snapPoints, shape, target) {
56344 CreateMoveSnapping.prototype.addSnapTargetPoints.call(this, snapPoints, shape, target);
56396 BpmnCreateMoveSnapping.prototype.getSnapTargets = function(shape, target) {
56397 return CreateMoveSnapping.prototype.getSnapTargets.call(this, shape, target)
56547 ResizeSnapping.prototype.initSnap = function(event) {
56567 ResizeSnapping.prototype.addSnapTargetPoints = function(snapPoints, shape, target, direction) {
56585 ResizeSnapping.prototype.getSnapTargets = function(shape, target) {
56670 Snapping.prototype.snap = function(event, snapPoints) {
56724 Snapping.prototype._createLine = function(orientation) {
56757 Snapping.prototype._createSnapLines = function() {
56764 Snapping.prototype.showSnapLine = function(orientation, position) {
56775 Snapping.prototype.getSnapLine = function(orientation) {
56783 Snapping.prototype.hide = function() {
56847 SearchPad.prototype._bindEvents = function() {
56938 SearchPad.prototype._unbindEvents = function() {
56950 SearchPad.prototype._search = function(pattern) {
56987 SearchPad.prototype._scrollToDirection = function(previous) {
57006 SearchPad.prototype._scrollToNode = function(node) {
57027 SearchPad.prototype._clearResults = function() {
57043 SearchPad.prototype._getCurrentResult = function() {
57060 SearchPad.prototype._createResultNode = function(result, id) {
57087 SearchPad.prototype.registerProvider = function(provider) {
57095 SearchPad.prototype.open = function() {
57119 SearchPad.prototype.close = function() {
57144 SearchPad.prototype.toggle = function() {
57152 SearchPad.prototype.isOpen = function() {
57162 SearchPad.prototype._preselect = function(node) {
57195 SearchPad.prototype._select = function(node) {
57217 SearchPad.prototype._resetOverlay = function(element) {
57368 BpmnSearchProvider.prototype.find = function(pattern) {
57583 Modeler.prototype.createDiagram = wrapForCompatibility(function createDiagram() {
57588 Modeler.prototype._interactionModules = [
57597 Modeler.prototype._modelingModules = [
57633 Modeler.prototype._modules = [].concat(
57634 Viewer.prototype._modules,
57635 Modeler.prototype._interactionModules,
57636 Modeler.prototype._modelingModules