@datagrok/helm 2.3.2 → 2.3.3

package/vendor/dojo-1.10.10/dijit/typematic.js.uncompressed.js

@@ -0,0 +1,211 @@
+define("dijit/typematic", [
+	"dojo/_base/array", // array.forEach
+	"dojo/_base/connect", // connect._keyPress
+	"dojo/_base/lang", // lang.mixin, lang.hitch
+	"dojo/on",
+	"dojo/sniff", // has("ie")
+	"./main"        // setting dijit.typematic global
+], function(array, connect, lang, on, has, dijit){
+
+	// module:
+	//		dijit/typematic
+
+	var typematic = (dijit.typematic = {
+		// summary:
+		//		These functions are used to repetitively call a user specified callback
+		//		method when a specific key or mouse click over a specific DOM node is
+		//		held down for a specific amount of time.
+		//		Only 1 such event is allowed to occur on the browser page at 1 time.
+
+		_fireEventAndReload: function(){
+			this._timer = null;
+			this._callback(++this._count, this._node, this._evt);
+
+			// Schedule next event, timer is at most minDelay (default 10ms) to avoid
+			// browser overload (particularly avoiding starving DOH robot so it never gets to send a mouseup)
+			this._currentTimeout = Math.max(
+				this._currentTimeout < 0 ? this._initialDelay :
+					(this._subsequentDelay > 1 ? this._subsequentDelay : Math.round(this._currentTimeout * this._subsequentDelay)),
+				this._minDelay);
+			this._timer = setTimeout(lang.hitch(this, "_fireEventAndReload"), this._currentTimeout);
+		},
+
+		trigger: function(/*Event*/ evt, /*Object*/ _this, /*DOMNode*/ node, /*Function*/ callback, /*Object*/ obj, /*Number?*/ subsequentDelay, /*Number?*/ initialDelay, /*Number?*/ minDelay){
+			// summary:
+			//		Start a timed, repeating callback sequence.
+			//		If already started, the function call is ignored.
+			//		This method is not normally called by the user but can be
+			//		when the normal listener code is insufficient.
+			// evt:
+			//		key or mouse event object to pass to the user callback
+			// _this:
+			//		pointer to the user's widget space.
+			// node:
+			//		the DOM node object to pass the the callback function
+			// callback:
+			//		function to call until the sequence is stopped called with 3 parameters:
+			// count:
+			//		integer representing number of repeated calls (0..n) with -1 indicating the iteration has stopped
+			// node:
+			//		the DOM node object passed in
+			// evt:
+			//		key or mouse event object
+			// obj:
+			//		user space object used to uniquely identify each typematic sequence
+			// subsequentDelay:
+			//		if > 1, the number of milliseconds until the 3->n events occur
+			//		or else the fractional time multiplier for the next event's delay, default=0.9
+			// initialDelay:
+			//		the number of milliseconds until the 2nd event occurs, default=500ms
+			// minDelay:
+			//		the maximum delay in milliseconds for event to fire, default=10ms
+			if(obj != this._obj){
+				this.stop();
+				this._initialDelay = initialDelay || 500;
+				this._subsequentDelay = subsequentDelay || 0.90;
+				this._minDelay = minDelay || 10;
+				this._obj = obj;
+				this._node = node;
+				this._currentTimeout = -1;
+				this._count = -1;
+				this._callback = lang.hitch(_this, callback);
+				this._evt = { faux: true };
+				for(var attr in evt){
+					if(attr != "layerX" && attr != "layerY"){ // prevent WebKit warnings
+						var v = evt[attr];
+						if(typeof v != "function" && typeof v != "undefined"){
+							this._evt[attr] = v
+						}
+					}
+				}
+				this._fireEventAndReload();
+			}
+		},
+
+		stop: function(){
+			// summary:
+			//		Stop an ongoing timed, repeating callback sequence.
+			if(this._timer){
+				clearTimeout(this._timer);
+				this._timer = null;
+			}
+			if(this._obj){
+				this._callback(-1, this._node, this._evt);
+				this._obj = null;
+			}
+		},
+
+		addKeyListener: function(/*DOMNode*/ node, /*Object*/ keyObject, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay, /*Number?*/ minDelay){
+			// summary:
+			//		Start listening for a specific typematic key.
+			//		See also the trigger method for other parameters.
+			// keyObject:
+			//		an object defining the key to listen for:
+			//
+			//		- keyCode: the keyCode (number) to listen for, used for non-printable keys
+			//		- charCode: the charCode (number) to listen for, used for printable keys
+			//		- charOrCode: deprecated, use keyCode or charCode
+			//		- ctrlKey: desired ctrl key state to initiate the callback sequence:
+			//			- pressed (true)
+			//			- released (false)
+			//			- either (unspecified)
+			//		- altKey: same as ctrlKey but for the alt key
+			//		- shiftKey: same as ctrlKey but for the shift key
+			// returns:
+			//		a connection handle
+
+			// Setup keydown or keypress listener depending on whether keyCode or charCode was specified.
+			// If charOrCode is specified use deprecated connect._keypress synthetic event (remove for 2.0)
+			var type = "keyCode" in keyObject ? "keydown" : "charCode" in keyObject ? "keypress" : connect._keypress,
+				attr = "keyCode" in keyObject ? "keyCode" : "charCode" in keyObject ? "charCode" : "charOrCode";
+
+			var handles = [
+				on(node, type, lang.hitch(this, function(evt){
+					if(evt[attr] == keyObject[attr] &&
+						(keyObject.ctrlKey === undefined || keyObject.ctrlKey == evt.ctrlKey) &&
+						(keyObject.altKey === undefined || keyObject.altKey == evt.altKey) &&
+						(keyObject.metaKey === undefined || keyObject.metaKey == (evt.metaKey || false)) && // IE doesn't even set metaKey
+						(keyObject.shiftKey === undefined || keyObject.shiftKey == evt.shiftKey)){
+						evt.stopPropagation();
+						evt.preventDefault();
+						typematic.trigger(evt, _this, node, callback, keyObject, subsequentDelay, initialDelay, minDelay);
+					}else if(typematic._obj == keyObject){
+						typematic.stop();
+					}
+				})),
+				on(node, "keyup", lang.hitch(this, function(){
+					if(typematic._obj == keyObject){
+						typematic.stop();
+					}
+				}))
+			];
+			return { remove: function(){
+				array.forEach(handles, function(h){
+					h.remove();
+				});
+			} };
+		},
+
+		addMouseListener: function(/*DOMNode*/ node, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay, /*Number?*/ minDelay){
+			// summary:
+			//		Start listening for a typematic mouse click.
+			//		See the trigger method for other parameters.
+			// returns:
+			//		a connection handle
+			var handles = [
+				on(node, "mousedown", lang.hitch(this, function(evt){
+					evt.preventDefault();
+					typematic.trigger(evt, _this, node, callback, node, subsequentDelay, initialDelay, minDelay);
+				})),
+				on(node, "mouseup", lang.hitch(this, function(evt){
+					if(this._obj){
+						evt.preventDefault();
+					}
+					typematic.stop();
+				})),
+				on(node, "mouseout", lang.hitch(this, function(evt){
+					if(this._obj){
+						evt.preventDefault();
+					}
+					typematic.stop();
+				})),
+				on(node, "dblclick", lang.hitch(this, function(evt){
+					evt.preventDefault();
+					if(has("ie") < 9){
+						typematic.trigger(evt, _this, node, callback, node, subsequentDelay, initialDelay, minDelay);
+						setTimeout(lang.hitch(this, typematic.stop), 50);
+					}
+				}))
+			];
+			return { remove: function(){
+				array.forEach(handles, function(h){
+					h.remove();
+				});
+			} };
+		},
+
+		addListener: function(/*Node*/ mouseNode, /*Node*/ keyNode, /*Object*/ keyObject, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay, /*Number?*/ minDelay){
+			// summary:
+			//		Start listening for a specific typematic key and mouseclick.
+			//		This is a thin wrapper to addKeyListener and addMouseListener.
+			//		See the addMouseListener and addKeyListener methods for other parameters.
+			// mouseNode:
+			//		the DOM node object to listen on for mouse events.
+			// keyNode:
+			//		the DOM node object to listen on for key events.
+			// returns:
+			//		a connection handle
+			var handles = [
+				this.addKeyListener(keyNode, keyObject, _this, callback, subsequentDelay, initialDelay, minDelay),
+				this.addMouseListener(mouseNode, _this, callback, subsequentDelay, initialDelay, minDelay)
+			];
+			return { remove: function(){
+				array.forEach(handles, function(h){
+					h.remove();
+				});
+			} };
+		}
+	});
+
+	return typematic;
+});

package/vendor/dojo-1.10.10/dojo/NodeList-manipulate.js

@@ -0,0 +1,195 @@
+/*
+	Copyright (c) 2004-2017, The JS Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+//>>built
+define("dojo/NodeList-manipulate",["./query","./_base/lang","./_base/array","./dom-construct","./dom-attr","./NodeList-dom"],function(_1,_2,_3,_4,_5){
+var _6=_1.NodeList;
+function _7(_8){
+while(_8.childNodes[0]&&_8.childNodes[0].nodeType==1){
+_8=_8.childNodes[0];
+}
+return _8;
+};
+function _9(_a,_b){
+if(typeof _a=="string"){
+_a=_4.toDom(_a,(_b&&_b.ownerDocument));
+if(_a.nodeType==11){
+_a=_a.childNodes[0];
+}
+}else{
+if(_a.nodeType==1&&_a.parentNode){
+_a=_a.cloneNode(false);
+}
+}
+return _a;
+};
+_2.extend(_6,{_placeMultiple:function(_c,_d){
+var _e=typeof _c=="string"||_c.nodeType?_1(_c):_c;
+var _f=[];
+for(var i=0;i<_e.length;i++){
+var _10=_e[i];
+var _11=this.length;
+for(var j=_11-1,_12;_12=this[j];j--){
+if(i>0){
+_12=this._cloneNode(_12);
+_f.unshift(_12);
+}
+if(j==_11-1){
+_4.place(_12,_10,_d);
+}else{
+_10.parentNode.insertBefore(_12,_10);
+}
+_10=_12;
+}
+}
+if(_f.length){
+_f.unshift(0);
+_f.unshift(this.length-1);
+Array.prototype.splice.apply(this,_f);
+}
+return this;
+},innerHTML:function(_13){
+if(arguments.length){
+return this.addContent(_13,"only");
+}else{
+return this[0].innerHTML;
+}
+},text:function(_14){
+if(arguments.length){
+for(var i=0,_15;_15=this[i];i++){
+if(_15.nodeType==1){
+_5.set(_15,"textContent",_14);
+}
+}
+return this;
+}else{
+var _16="";
+for(i=0;_15=this[i];i++){
+_16+=_5.get(_15,"textContent");
+}
+return _16;
+}
+},val:function(_17){
+if(arguments.length){
+var _18=_2.isArray(_17);
+for(var _19=0,_1a;_1a=this[_19];_19++){
+var _1b=_1a.nodeName.toUpperCase();
+var _1c=_1a.type;
+var _1d=_18?_17[_19]:_17;
+if(_1b=="SELECT"){
+var _1e=_1a.options;
+for(var i=0;i<_1e.length;i++){
+var opt=_1e[i];
+if(_1a.multiple){
+opt.selected=(_3.indexOf(_17,opt.value)!=-1);
+}else{
+opt.selected=(opt.value==_1d);
+}
+}
+}else{
+if(_1c=="checkbox"||_1c=="radio"){
+_1a.checked=(_1a.value==_1d);
+}else{
+_1a.value=_1d;
+}
+}
+}
+return this;
+}else{
+_1a=this[0];
+if(!_1a||_1a.nodeType!=1){
+return undefined;
+}
+_17=_1a.value||"";
+if(_1a.nodeName.toUpperCase()=="SELECT"&&_1a.multiple){
+_17=[];
+_1e=_1a.options;
+for(i=0;i<_1e.length;i++){
+opt=_1e[i];
+if(opt.selected){
+_17.push(opt.value);
+}
+}
+if(!_17.length){
+_17=null;
+}
+}
+return _17;
+}
+},append:function(_1f){
+return this.addContent(_1f,"last");
+},appendTo:function(_20){
+return this._placeMultiple(_20,"last");
+},prepend:function(_21){
+return this.addContent(_21,"first");
+},prependTo:function(_22){
+return this._placeMultiple(_22,"first");
+},after:function(_23){
+return this.addContent(_23,"after");
+},insertAfter:function(_24){
+return this._placeMultiple(_24,"after");
+},before:function(_25){
+return this.addContent(_25,"before");
+},insertBefore:function(_26){
+return this._placeMultiple(_26,"before");
+},remove:_6.prototype.orphan,wrap:function(_27){
+if(this[0]){
+_27=_9(_27,this[0]);
+for(var i=0,_28;_28=this[i];i++){
+var _29=this._cloneNode(_27);
+if(_28.parentNode){
+_28.parentNode.replaceChild(_29,_28);
+}
+var _2a=_7(_29);
+_2a.appendChild(_28);
+}
+}
+return this;
+},wrapAll:function(_2b){
+if(this[0]){
+_2b=_9(_2b,this[0]);
+this[0].parentNode.replaceChild(_2b,this[0]);
+var _2c=_7(_2b);
+for(var i=0,_2d;_2d=this[i];i++){
+_2c.appendChild(_2d);
+}
+}
+return this;
+},wrapInner:function(_2e){
+if(this[0]){
+_2e=_9(_2e,this[0]);
+for(var i=0;i<this.length;i++){
+var _2f=this._cloneNode(_2e);
+this._wrap(_2._toArray(this[i].childNodes),null,this._NodeListCtor).wrapAll(_2f);
+}
+}
+return this;
+},replaceWith:function(_30){
+_30=this._normalize(_30,this[0]);
+for(var i=0,_31;_31=this[i];i++){
+this._place(_30,_31,"before",i>0);
+_31.parentNode.removeChild(_31);
+}
+return this;
+},replaceAll:function(_32){
+var nl=_1(_32);
+var _33=this._normalize(this,this[0]);
+for(var i=0,_34;_34=nl[i];i++){
+this._place(_33,_34,"before",i>0);
+_34.parentNode.removeChild(_34);
+}
+return this;
+},clone:function(){
+var ary=[];
+for(var i=0;i<this.length;i++){
+ary.push(this._cloneNode(this[i]));
+}
+return this._wrap(ary,this,this._NodeListCtor);
+}});
+if(!_6.prototype.html){
+_6.prototype.html=_6.prototype.innerHTML;
+}
+return _6;
+});