Lines Matching refs:options
4328 function createContainer(options) { argument
4330 options = assign({}, { width: '100%', height: '100%' }, options);
4332 var container = options.container || document.body;
4343 width: ensurePx(options.width),
4344 height: ensurePx(options.height)
7317 function createInjector(options) { argument
7319 options = options || {};
7322 'config': ['value', options]
7325 var modules = [ configModule, CoreModule$1 ].concat(options.modules || []);
7380 function Diagram(options, injector) { argument
7383 this.injector = injector = injector || createInjector(options);
8100 Properties.prototype.define = function(target, name, options) { argument
8101 Object.defineProperty(target, name, options);
8464 function Parser(options) { argument
8467 return new Parser(options);
8470 var proxy = options && options['proxy'];
9506 function Context(options) { argument
9516 assign(this, options);
10020 function Reader(options) { argument
10022 if (options instanceof Moddle) {
10023 options = { class in Reader
10024 model: options
10028 assign(this, { lax: false }, options);
10058 Reader.prototype.fromXML = function(xml, options, done) { argument
10060 var rootHandler = options.rootHandler;
10062 if (options instanceof ElementHandler) {
10065 rootHandler = options;
10066 options = {};
10068 if (typeof options === 'string') {
10071 rootHandler = this.handler(options);
10072 options = {};
10083 var context = new Context(assign({}, options, { rootHandler: rootHandler })),
11169 function Writer(options) { argument
11171 options = assign({ format: false, preamble: true }, options || {});
11175 var formatingWriter = new FormatingWriter(internalWriter, options.format);
11177 if (options.preamble) {
11202 function BpmnModdle(packages, options) { argument
11203 Moddle.call(this, packages, options);
11236 BpmnModdle.prototype.fromXML = function(xmlStr, typeName, options) { argument
11239 options = typeName;
11243 var reader = new Reader(assign({ model: this, lax: true }, options));
11266 BpmnModdle.prototype.toXML = function(element, options) { argument
11268 var writer = new Writer(options);
14929 function simple(additionalPackages, options) { argument
14932 return new BpmnModdle(pks, options);
15637 function BaseViewer(options) { argument
15639 options = assign({}, DEFAULT_OPTIONS, options);
15641 this._moddle = this._createModdle(options);
15643 this._container = this._createContainer(options);
15651 this._init(this._container, this._moddle, options);
15939 BaseViewer.prototype.saveXML = wrapForCompatibility(function saveXML(options) { argument
15941 options = options || {};
15960 self._moddle.toXML(definitions, options).then(function(result) {
16013 BaseViewer.prototype.saveSVG = wrapForCompatibility(function saveSVG(options) { argument
16213 BaseViewer.prototype._init = function(container, moddle, options) { argument
16215 var baseModules = options.modules || this.getModules(),
16216 additionalModules = options.additionalModules || [],
16226 var diagramOptions = assign(omit(options, [ 'additionalModules' ]), {
16227 canvas: assign({}, options.canvas, { container: container }),
16234 if (options && options.container) {
16235 this.attachTo(options.container);
16251 BaseViewer.prototype._createContainer = function(options) { argument
16256 width: ensureUnit(options.width),
16257 height: ensureUnit(options.height),
16258 position: options.position
16264 BaseViewer.prototype._createModdle = function(options) { argument
16265 var moddleOptions = assign({}, this._moddleExtensions, options.moddleExtensions);
16375 function BaseModeler(options) { argument
16376 BaseViewer.call(this, options);
16398 BaseModeler.prototype._createModdle = function(options) { argument
16399 var moddle = BaseViewer.prototype._createModdle.call(this, options);
16744 function addMarker(id, options) { argument
16750 }, options.attrs);
16752 var ref = options.ref || { x: 0, y: 0 };
16754 var scale = options.scale || 1;
16764 attr(options.element, attrs);
16766 append(marker, options.element);
17110 function renderLabel(parentGfx, label, options) { argument
17112 options = assign({
17116 }, options);
17118 var text = textRenderer.createText(label || '', options);
18807 Text.prototype.createText = function(text, options) { argument
18808 return this.layoutText(text, options).element;
18819 Text.prototype.getDimensions = function(text, options) { argument
18820 return this.layoutText(text, options).dimensions;
18839 Text.prototype.layoutText = function(text, options) { argument
18840 var box = assign({}, this._config.size, options.box),
18841 style = assign({}, this._config.style, options.style),
18842 align = parseAlign(options.align || this._config.align),
18843 … padding = parsePadding(options.padding !== undefined ? options.padding : this._config.padding),
18844 fitBox = options.fitBox || false;
19037 this.createText = function(text, options) { argument
19038 return textUtil.createText(text, options || {});
21727 function Viewer(options) { argument
21728 BaseViewer.call(this, options);
22708 function NavigatedViewer(options) { argument
22709 Viewer.call(this, options);
23152 this.target = manager.options.inputTarget;
23157 if (boolOrFn(manager.options.enable, [manager])) {
23200 var inputClass = manager.options.inputClass;
23960 this.set(this.manager.options.touchAction);
23970 if (boolOrFn(recognizer.options.enable, [recognizer])) {
24121 function Recognizer(options) { argument
24122 this.options = assign({}, this.defaults, options || {});
24129 this.options.enable = ifUndefined(this.options.enable, true);
24149 set: function(options) { argument
24150 assign(this.options, options);
24260 emit(self.options.event + stateStr(state));
24263 emit(self.options.event); // simple 'eventName' events
24271 emit(self.options.event + stateStr(state));
24314 if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
24437 var optionPointers = this.options.pointers;
24495 var direction = this.options.direction;
24507 var options = this.options;
24515 if (!(direction & options.direction)) {
24516 if (options.direction & DIRECTION_HORIZONTAL) {
24527 return hasMoved && distance > options.threshold && direction & options.direction;
24543 input.additionalEvent = this.options.event + direction;
24576 (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
24582 input.additionalEvent = this.options.event + inOut;
24618 var options = this.options;
24619 var validPointers = input.pointers.length === options.pointers;
24620 var validMovement = input.distance < options.threshold;
24621 var validTime = input.deltaTime > options.time;
24634 }, options.time, this);
24651 this.manager.emit(this.options.event + 'up', input);
24654 this.manager.emit(this.options.event, this._input);
24686 (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
24718 var direction = this.options.direction;
24731 input.distance > this.options.threshold &&
24732 input.maxPointers == this.options.pointers &&
24733 abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
24739 this.manager.emit(this.options.event + direction, input);
24742 this.manager.emit(this.options.event, input);
24789 var options = this.options;
24791 var validPointers = input.pointers.length === options.pointers;
24792 var validMovement = input.distance < options.threshold;
24793 var validTouchTime = input.deltaTime < options.time;
24808 … var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;
24809 …var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshol…
24824 var tapCount = this.count % options.taps;
24834 }, options.interval, this);
24845 }, this.options.interval, this);
24856 this.manager.emit(this.options.event, this._input);
24867 function Hammer(element, options) { argument
24868 options = options || {};
24869 options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);
24870 return new Manager(element, options);
24999 function Manager(element, options) { argument
25000 this.options = assign({}, Hammer.defaults, options || {});
25002 this.options.inputTarget = this.options.inputTarget || element;
25011 this.touchAction = new TouchAction(this, this.options.touchAction);
25015 each(this.options.recognizers, function(item) {
25028 set: function(options) { argument
25029 assign(this.options, options);
25032 if (options.touchAction) {
25035 if (options.inputTarget) {
25038 this.input.target = options.inputTarget;
25122 if (recognizers[i].options.event == recognizer) {
25141 var existing = this.get(recognizer.options.event);
25230 if (this.options.domEvents) {
25277 each(manager.options.cssProps, function(value, name) {
27678 function init(event, relativeTo, prefix, options) { argument
27686 options = prefix;
27691 options = assign({}, defaultOptions, options || {});
27693 var data = options.data || {},
27700 if (options.trapClick) {
27737 }, options);
27741 if (!options.manual) {
27771 if (options.autoActivate) {
27796 this.setOptions = function(options) { argument
27797 assign(defaultOptions, options);
27932 AutoScroll.prototype.setOptions = function(options) { argument
27933 this._opts = assign({}, this._opts, options);
30500 function TextBox(options) { argument
30501 this.container = options.container;
30511 this.keyHandler = options.keyHandler || function() {};
30512 this.resizeHandler = options.resizeHandler || function() {};
30536 TextBox.prototype.create = function(bounds, style, value, options) { argument
30543 options = this.options = options || {};
30604 if (options.centerVertically) {
30618 if (options.autoResize) {
30622 if (options.resizable) {
30638 var options = this.options,
30657 if (options.autoResize) {
31078 context.options
31087 if (context.options && context.options.resizable) {
33894 Replace.prototype.replaceElement = function(oldElement, newElementData, options) { argument
33926 options
35536 loopCharacteristics = self._moddle.create(entry.options.loopCharacteristics);
35538 if (entry.options.isSequential) {
35539 loopCharacteristics.isSequential = entry.options.isSequential;
35566 options: {
35577 options: {
35588 options: {
36200 function appendAction(type, className, title, options) { argument
36203 options = title;
36209 var shape = elementFactory.createShape(assign({ type: type }, options));
36217 var shape = elementFactory.createShape(assign({ type: type }, options));
37299 var options = {};
37305 options.offset = snapOffset;
37312 assign(options, snapConstraints);
37316 self.snapEvent(event, axis, options);
37331 GridSnapping.prototype.snapEvent = function(event, axis, options) { argument
37332 var snappedValue = this.snapValue(event[ axis ], options);
37355 GridSnapping.prototype.snapValue = function(value, options) { argument
37358 if (options && options.offset) {
37359 offset = options.offset;
37368 if (options && options.min) {
37369 min = options.min;
37378 if (options && options.max) {
37379 max = options.max;
37822 var options = {};
37830 options.min = position[ axis ];
37832 options.max = position[ axis ];
37838 options.offset = -shape.width / 2;
37840 options.offset = -shape.height / 2;
37845 position[ axis ] = gridSnapping.snapValue(position[ axis ], options);
39234 var options = {};
39246 assign(options, {
39253 assign(options, {
39260 assign(options, {
39267 options: options
55437 function createAction(type, group, className, title, options) { argument
55440 var shape = elementFactory.createShape(assign({ type: type }, options));
55442 if (options) {
55443 shape.businessObject.di.isExpanded = options.isExpanded;
57552 function Modeler(options) { argument
57553 BaseModeler.call(this, options);