@datagrok/helm 2.3.2 → 2.3.4

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

@@ -0,0 +1,372 @@
+define("dijit/_CssStateMixin", [
+	"dojo/_base/array", // array.forEach array.map
+	"dojo/_base/declare", // declare
+	"dojo/dom", // dom.isDescendant()
+	"dojo/dom-class", // domClass.toggle
+	"dojo/has",
+	"dojo/_base/lang", // lang.hitch
+	"dojo/on",
+	"dojo/domReady",
+	"dojo/touch",
+	"dojo/_base/window", // win.body
+	"./a11yclick",
+	"./registry"
+], function(array, declare, dom, domClass, has, lang, on, domReady, touch, win, a11yclick, registry){
+
+	// module:
+	//		dijit/_CssStateMixin
+
+	var CssStateMixin = declare("dijit._CssStateMixin", [], {
+		// summary:
+		//		Mixin for widgets to set CSS classes on the widget DOM nodes depending on hover/mouse press/focus
+		//		state changes, and also higher-level state changes such becoming disabled or selected.
+		//
+		// description:
+		//		By mixing this class into your widget, and setting the this.baseClass attribute, it will automatically
+		//		maintain CSS classes on the widget root node (this.domNode) depending on hover,
+		//		active, focus, etc. state.   Ex: with a baseClass of dijitButton, it will apply the classes
+		//		dijitButtonHovered and dijitButtonActive, as the user moves the mouse over the widget and clicks it.
+		//
+		//		It also sets CSS like dijitButtonDisabled based on widget semantic state.
+		//
+		//		By setting the cssStateNodes attribute, a widget can also track events on subnodes (like buttons
+		//		within the widget).
+
+		/*=====
+		 // cssStateNodes: [protected] Object
+		 //		Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
+		 //		need CSS classes applied on mouse hover/press and focus.
+		 //
+		 //		Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
+		 //		(like "dijitUpArrowButton"). Example:
+		 //	|		{
+		 //	|			"upArrowButton": "dijitUpArrowButton",
+		 //	|			"downArrowButton": "dijitDownArrowButton"
+		 //	|		}
+		 //		The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
+		 //		is hovered, etc.
+		 cssStateNodes: {},
+		 =====*/
+
+		// hovering: [readonly] Boolean
+		//		True if cursor is over this widget
+		hovering: false,
+
+		// active: [readonly] Boolean
+		//		True if mouse was pressed while over this widget, and hasn't been released yet
+		active: false,
+
+		_applyAttributes: function(){
+			// This code would typically be in postCreate(), but putting in _applyAttributes() for
+			// performance: so the class changes happen before DOM is inserted into the document.
+			// Change back to postCreate() in 2.0.  See #11635.
+
+			this.inherited(arguments);
+
+			// Monitoring changes to disabled, readonly, etc. state, and update CSS class of root node
+			array.forEach(["disabled", "readOnly", "checked", "selected", "focused", "state", "hovering", "active", "_opened"], function(attr){
+				this.watch(attr, lang.hitch(this, "_setStateClass"));
+			}, this);
+
+			// Track hover and active mouse events on widget root node, plus possibly on subnodes
+			for(var ap in this.cssStateNodes || {}){
+				this._trackMouseState(this[ap], this.cssStateNodes[ap]);
+			}
+			this._trackMouseState(this.domNode, this.baseClass);
+
+			// Set state initially; there's probably no hover/active/focus state but widget might be
+			// disabled/readonly/checked/selected so we want to set CSS classes for those conditions.
+			this._setStateClass();
+		},
+
+		_cssMouseEvent: function(/*Event*/ event){
+			// summary:
+			//		Handler for CSS event on this.domNode. Sets hovering and active properties depending on mouse state,
+			//		which triggers _setStateClass() to set appropriate CSS classes for this.domNode.
+
+			if(!this.disabled){
+				switch(event.type){
+					case "mouseover":
+					case "MSPointerOver":
+					case "pointerover":
+						this._set("hovering", true);
+						this._set("active", this._mouseDown);
+						break;
+					case "mouseout":
+					case "MSPointerOut":
+					case "pointerout":
+						this._set("hovering", false);
+						this._set("active", false);
+						break;
+					case "mousedown":
+					case "touchstart":
+					case "MSPointerDown":
+					case "pointerdown":
+					case "keydown":
+						this._set("active", true);
+						break;
+					case "mouseup":
+					case "dojotouchend":
+					case "MSPointerUp":
+					case "pointerup":
+					case "keyup":
+						this._set("active", false);
+						break;
+				}
+			}
+		},
+
+		_setStateClass: function(){
+			// summary:
+			//		Update the visual state of the widget by setting the css classes on this.domNode
+			//		(or this.stateNode if defined) by combining this.baseClass with
+			//		various suffixes that represent the current widget state(s).
+			//
+			// description:
+			//		In the case where a widget has multiple
+			//		states, it sets the class based on all possible
+			//		combinations.  For example, an invalid form widget that is being hovered
+			//		will be "dijitInput dijitInputInvalid dijitInputHover dijitInputInvalidHover".
+			//
+			//		The widget may have one or more of the following states, determined
+			//		by this.state, this.checked, this.valid, and this.selected:
+			//
+			//		- Error - ValidationTextBox sets this.state to "Error" if the current input value is invalid
+			//		- Incomplete - ValidationTextBox sets this.state to "Incomplete" if the current input value is not finished yet
+			//		- Checked - ex: a checkmark or a ToggleButton in a checked state, will have this.checked==true
+			//		- Selected - ex: currently selected tab will have this.selected==true
+			//
+			//		In addition, it may have one or more of the following states,
+			//		based on this.disabled and flags set in _onMouse (this.active, this.hovering) and from focus manager (this.focused):
+			//
+			//		- Disabled	- if the widget is disabled
+			//		- Active		- if the mouse (or space/enter key?) is being pressed down
+			//		- Focused		- if the widget has focus
+			//		- Hover		- if the mouse is over the widget
+
+			// Compute new set of classes
+			var newStateClasses = this.baseClass.split(" ");
+
+			function multiply(modifier){
+				newStateClasses = newStateClasses.concat(array.map(newStateClasses, function(c){
+					return c + modifier;
+				}), "dijit" + modifier);
+			}
+
+			if(!this.isLeftToRight()){
+				// For RTL mode we need to set an addition class like dijitTextBoxRtl.
+				multiply("Rtl");
+			}
+
+			var checkedState = this.checked == "mixed" ? "Mixed" : (this.checked ? "Checked" : "");
+			if(this.checked){
+				multiply(checkedState);
+			}
+			if(this.state){
+				multiply(this.state);
+			}
+			if(this.selected){
+				multiply("Selected");
+			}
+			if(this._opened){
+				multiply("Opened");
+			}
+
+			if(this.disabled){
+				multiply("Disabled");
+			}else if(this.readOnly){
+				multiply("ReadOnly");
+			}else{
+				if(this.active){
+					multiply("Active");
+				}else if(this.hovering){
+					multiply("Hover");
+				}
+			}
+
+			if(this.focused){
+				multiply("Focused");
+			}
+
+			// Remove old state classes and add new ones.
+			// For performance concerns we only write into domNode.className once.
+			var tn = this.stateNode || this.domNode,
+				classHash = {};	// set of all classes (state and otherwise) for node
+
+			array.forEach(tn.className.split(" "), function(c){
+				classHash[c] = true;
+			});
+
+			if("_stateClasses" in this){
+				array.forEach(this._stateClasses, function(c){
+					delete classHash[c];
+				});
+			}
+
+			array.forEach(newStateClasses, function(c){
+				classHash[c] = true;
+			});
+
+			var newClasses = [];
+			for(var c in classHash){
+				newClasses.push(c);
+			}
+			tn.className = newClasses.join(" ");
+
+			this._stateClasses = newStateClasses;
+		},
+
+		_subnodeCssMouseEvent: function(node, clazz, evt){
+			// summary:
+			//		Handler for hover/active mouse event on widget's subnode
+			if(this.disabled || this.readOnly){
+				return;
+			}
+
+			function hover(isHovering){
+				domClass.toggle(node, clazz + "Hover", isHovering);
+			}
+
+			function active(isActive){
+				domClass.toggle(node, clazz + "Active", isActive);
+			}
+
+			function focused(isFocused){
+				domClass.toggle(node, clazz + "Focused", isFocused);
+			}
+
+			switch(evt.type){
+				case "mouseover":
+				case "MSPointerOver":
+				case "pointerover":
+					hover(true);
+					break;
+				case "mouseout":
+				case "MSPointerOut":
+				case "pointerout":
+					hover(false);
+					active(false);
+					break;
+				case "mousedown":
+				case "touchstart":
+				case "MSPointerDown":
+				case "pointerdown":
+				case "keydown":
+					active(true);
+					break;
+				case "mouseup":
+				case "MSPointerUp":
+				case "pointerup":
+				case "dojotouchend":
+				case "keyup":
+					active(false);
+					break;
+				case "focus":
+				case "focusin":
+					focused(true);
+					break;
+				case "blur":
+				case "focusout":
+					focused(false);
+					break;
+			}
+		},
+
+		_trackMouseState: function(/*DomNode*/ node, /*String*/ clazz){
+			// summary:
+			//		Track mouse/focus events on specified node and set CSS class on that node to indicate
+			//		current state.   Usually not called directly, but via cssStateNodes attribute.
+			// description:
+			//		Given class=foo, will set the following CSS class on the node
+			//
+			//		- fooActive: if the user is currently pressing down the mouse button while over the node
+			//		- fooHover: if the user is hovering the mouse over the node, but not pressing down a button
+			//		- fooFocus: if the node is focused
+			//
+			//		Note that it won't set any classes if the widget is disabled.
+			// node: DomNode
+			//		Should be a sub-node of the widget, not the top node (this.domNode), since the top node
+			//		is handled specially and automatically just by mixing in this class.
+			// clazz: String
+			//		CSS class name (ex: dijitSliderUpArrow)
+
+			// Flag for listener code below to call this._cssMouseEvent() or this._subnodeCssMouseEvent()
+			// when node is hovered/active
+			node._cssState = clazz;
+		}
+	});
+
+	domReady(function(){
+		// Document level listener to catch hover etc. events on widget root nodes and subnodes.
+		// Note that when the mouse is moved quickly, a single onmouseenter event could signal that multiple widgets
+		// have been hovered or unhovered (try test_Accordion.html)
+
+		function pointerHandler(evt, target, relatedTarget){
+			// Handler for mouseover, mouseout, a11yclick.press and a11click.release events
+
+			// Poor man's event propagation.  Don't propagate event to ancestors of evt.relatedTarget,
+			// to avoid processing mouseout events moving from a widget's domNode to a descendant node;
+			// such events shouldn't be interpreted as a mouseleave on the widget.
+			if(relatedTarget && dom.isDescendant(relatedTarget, target)){
+				return;
+			}
+
+			for(var node = target; node && node != relatedTarget; node = node.parentNode){
+				// Process any nodes with _cssState property.   They are generally widget root nodes,
+				// but could also be sub-nodes within a widget
+				if(node._cssState){
+					var widget = registry.getEnclosingWidget(node);
+					if(widget){
+						if(node == widget.domNode){
+							// event on the widget's root node
+							widget._cssMouseEvent(evt);
+						}else{
+							// event on widget's sub-node
+							widget._subnodeCssMouseEvent(node, node._cssState, evt);
+						}
+					}
+				}
+			}
+		}
+
+		var body = win.body(), activeNode;
+
+		// Handle pointer related events (i.e. mouse or touch)
+		on(body, touch.over, function(evt){
+			// Using touch.over rather than mouseover mainly to ignore phantom mouse events on iOS.
+			pointerHandler(evt, evt.target, evt.relatedTarget);
+		});
+		on(body, touch.out, function(evt){
+			// Using touch.out rather than mouseout mainly to ignore phantom mouse events on iOS.
+			pointerHandler(evt, evt.target, evt.relatedTarget);
+		});
+		on(body, a11yclick.press, function(evt){
+			// Save the a11yclick.press target to reference when the a11yclick.release comes.
+			activeNode = evt.target;
+			pointerHandler(evt, activeNode)
+		});
+		on(body, a11yclick.release, function(evt){
+			// The release event could come on a separate node than the press event, if for example user slid finger.
+			// Reference activeNode to reset the state of the node that got state set in the a11yclick.press handler.
+			pointerHandler(evt, activeNode);
+			activeNode = null;
+		});
+
+		// Track focus events on widget sub-nodes that have been registered via _trackMouseState().
+		// However, don't track focus events on the widget root nodes, because focus is tracked via the
+		// focus manager (and it's not really tracking focus, but rather tracking that focus is on one of the widget's
+		// nodes or a subwidget's node or a popup node, etc.)
+		// Remove for 2.0 (if focus CSS needed, just use :focus pseudo-selector).
+		on(body, "focusin, focusout", function(evt){
+			var node = evt.target;
+			if(node._cssState && !node.getAttribute("widgetId")){
+				var widget = registry.getEnclosingWidget(node);
+				if(widget){
+					widget._subnodeCssMouseEvent(node, node._cssState, evt);
+				}
+			}
+		});
+	});
+
+	return CssStateMixin;
+});

package/vendor/dojo-1.10.10/dijit/_FocusMixin.js

@@ -0,0 +1,11 @@
+//>>built
+define("dijit/_FocusMixin",["./focus","./_WidgetBase","dojo/_base/declare","dojo/_base/lang"],function(_1,_2,_3,_4){
+_4.extend(_2,{focused:false,onFocus:function(){
+},onBlur:function(){
+},_onFocus:function(){
+this.onFocus();
+},_onBlur:function(){
+this.onBlur();
+}});
+return _3("dijit._FocusMixin",null,{_focusManager:_1});
+});

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

@@ -0,0 +1,66 @@
+define("dijit/_FocusMixin", [
+	"./focus",
+	"./_WidgetBase",
+	"dojo/_base/declare", // declare
+	"dojo/_base/lang" // lang.extend
+], function(focus, _WidgetBase, declare, lang){
+
+	// module:
+	//		dijit/_FocusMixin
+
+	// We don't know where _FocusMixin will occur in the inheritance chain, but we need the _onFocus()/_onBlur() below
+	// to be last in the inheritance chain, so mixin to _WidgetBase.
+	lang.extend(_WidgetBase, {
+		// focused: [readonly] Boolean
+		//		This widget or a widget it contains has focus, or is "active" because
+		//		it was recently clicked.
+		focused: false,
+
+		onFocus: function(){
+			// summary:
+			//		Called when the widget becomes "active" because
+			//		it or a widget inside of it either has focus, or has recently
+			//		been clicked.
+			// tags:
+			//		callback
+		},
+
+		onBlur: function(){
+			// summary:
+			//		Called when the widget stops being "active" because
+			//		focus moved to something outside of it, or the user
+			//		clicked somewhere outside of it, or the widget was
+			//		hidden.
+			// tags:
+			//		callback
+		},
+
+		_onFocus: function(){
+			// summary:
+			//		This is where widgets do processing for when they are active,
+			//		such as changing CSS classes.  See onFocus() for more details.
+			// tags:
+			//		protected
+			this.onFocus();
+		},
+
+		_onBlur: function(){
+			// summary:
+			//		This is where widgets do processing for when they stop being active,
+			//		such as changing CSS classes.  See onBlur() for more details.
+			// tags:
+			//		protected
+			this.onBlur();
+		}
+	});
+
+	return declare("dijit._FocusMixin", null, {
+		// summary:
+		//		Mixin to widget to provide _onFocus() and _onBlur() methods that
+		//		fire when a widget or its descendants get/lose focus
+
+		// flag that I want _onFocus()/_onBlur() notifications from focus manager
+		_focusManager: focus
+	});
+
+});

package/vendor/dojo-1.10.10/dijit/_HasDropDown.js

@@ -0,0 +1,188 @@
+//>>built
+define("dijit/_HasDropDown",["dojo/_base/declare","dojo/_base/Deferred","dojo/dom","dojo/dom-attr","dojo/dom-class","dojo/dom-geometry","dojo/dom-style","dojo/has","dojo/keys","dojo/_base/lang","dojo/on","dojo/touch","./registry","./focus","./popup","./_FocusMixin"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,on,_b,_c,_d,_e,_f){
+return _1("dijit._HasDropDown",_f,{_buttonNode:null,_arrowWrapperNode:null,_popupStateNode:null,_aroundNode:null,dropDown:null,autoWidth:true,forceWidth:false,maxHeight:-1,dropDownPosition:["below","above"],_stopClickEvents:true,_onDropDownMouseDown:function(e){
+if(this.disabled||this.readOnly){
+return;
+}
+if(e.type!="MSPointerDown"){
+e.preventDefault();
+}
+this.own(on.once(this.ownerDocument,_b.release,_a.hitch(this,"_onDropDownMouseUp")));
+this.toggleDropDown();
+},_onDropDownMouseUp:function(e){
+var _10=this.dropDown,_11=false;
+if(e&&this._opened){
+var c=_6.position(this._buttonNode,true);
+if(!(e.pageX>=c.x&&e.pageX<=c.x+c.w)||!(e.pageY>=c.y&&e.pageY<=c.y+c.h)){
+var t=e.target;
+while(t&&!_11){
+if(_5.contains(t,"dijitPopup")){
+_11=true;
+}else{
+t=t.parentNode;
+}
+}
+if(_11){
+t=e.target;
+if(_10.onItemClick){
+var _12;
+while(t&&!(_12=_c.byNode(t))){
+t=t.parentNode;
+}
+if(_12&&_12.onClick&&_12.getParent){
+_12.getParent().onItemClick(_12,e);
+}
+}
+return;
+}
+}
+}
+if(this._opened){
+if(_10.focus&&(_10.autoFocus!==false||(e.type=="mouseup"&&!this.hovering))){
+this._focusDropDownTimer=this.defer(function(){
+_10.focus();
+delete this._focusDropDownTimer;
+});
+}
+}else{
+if(this.focus){
+this.defer("focus");
+}
+}
+},_onDropDownClick:function(e){
+if(this._stopClickEvents){
+e.stopPropagation();
+e.preventDefault();
+}
+},buildRendering:function(){
+this.inherited(arguments);
+this._buttonNode=this._buttonNode||this.focusNode||this.domNode;
+this._popupStateNode=this._popupStateNode||this.focusNode||this._buttonNode;
+var _13={"after":this.isLeftToRight()?"Right":"Left","before":this.isLeftToRight()?"Left":"Right","above":"Up","below":"Down","left":"Left","right":"Right"}[this.dropDownPosition[0]]||this.dropDownPosition[0]||"Down";
+_5.add(this._arrowWrapperNode||this._buttonNode,"dijit"+_13+"ArrowButton");
+},postCreate:function(){
+this.inherited(arguments);
+var _14=this.focusNode||this.domNode;
+this.own(on(this._buttonNode,_b.press,_a.hitch(this,"_onDropDownMouseDown")),on(this._buttonNode,"click",_a.hitch(this,"_onDropDownClick")),on(_14,"keydown",_a.hitch(this,"_onKey")),on(_14,"keyup",_a.hitch(this,"_onKeyUp")));
+},destroy:function(){
+if(this._opened){
+this.closeDropDown(true);
+}
+if(this.dropDown){
+if(!this.dropDown._destroyed){
+this.dropDown.destroyRecursive();
+}
+delete this.dropDown;
+}
+this.inherited(arguments);
+},_onKey:function(e){
+if(this.disabled||this.readOnly){
+return;
+}
+var d=this.dropDown,_15=e.target;
+if(d&&this._opened&&d.handleKey){
+if(d.handleKey(e)===false){
+e.stopPropagation();
+e.preventDefault();
+return;
+}
+}
+if(d&&this._opened&&e.keyCode==_9.ESCAPE){
+this.closeDropDown();
+e.stopPropagation();
+e.preventDefault();
+}else{
+if(!this._opened&&(e.keyCode==_9.DOWN_ARROW||((e.keyCode==_9.ENTER||(e.keyCode==_9.SPACE&&(!this._searchTimer||(e.ctrlKey||e.altKey||e.metaKey))))&&((_15.tagName||"").toLowerCase()!=="input"||(_15.type&&_15.type.toLowerCase()!=="text"))))){
+this._toggleOnKeyUp=true;
+e.stopPropagation();
+e.preventDefault();
+}
+}
+},_onKeyUp:function(){
+if(this._toggleOnKeyUp){
+delete this._toggleOnKeyUp;
+this.toggleDropDown();
+var d=this.dropDown;
+if(d&&d.focus){
+this.defer(_a.hitch(d,"focus"),1);
+}
+}
+},_onBlur:function(){
+this.closeDropDown(false);
+this.inherited(arguments);
+},isLoaded:function(){
+return true;
+},loadDropDown:function(_16){
+_16();
+},loadAndOpenDropDown:function(){
+var d=new _2(),_17=_a.hitch(this,function(){
+this.openDropDown();
+d.resolve(this.dropDown);
+});
+if(!this.isLoaded()){
+this.loadDropDown(_17);
+}else{
+_17();
+}
+return d;
+},toggleDropDown:function(){
+if(this.disabled||this.readOnly){
+return;
+}
+if(!this._opened){
+this.loadAndOpenDropDown();
+}else{
+this.closeDropDown(true);
+}
+},openDropDown:function(){
+var _18=this.dropDown,_19=_18.domNode,_1a=this._aroundNode||this.domNode,_1b=this;
+var _1c=_e.open({parent:this,popup:_18,around:_1a,orient:this.dropDownPosition,maxHeight:this.maxHeight,onExecute:function(){
+_1b.closeDropDown(true);
+},onCancel:function(){
+_1b.closeDropDown(true);
+},onClose:function(){
+_4.set(_1b._popupStateNode,"popupActive",false);
+_5.remove(_1b._popupStateNode,"dijitHasDropDownOpen");
+_1b._set("_opened",false);
+}});
+if(this.forceWidth||(this.autoWidth&&_1a.offsetWidth>_18._popupWrapper.offsetWidth)){
+var _1d=_1a.offsetWidth-_18._popupWrapper.offsetWidth;
+var _1e={w:_18.domNode.offsetWidth+_1d};
+this._origStyle=_19.style.cssText;
+if(_a.isFunction(_18.resize)){
+_18.resize(_1e);
+}else{
+_6.setMarginBox(_19,_1e);
+}
+if(_1c.corner[1]=="R"){
+_18._popupWrapper.style.left=(_18._popupWrapper.style.left.replace("px","")-_1d)+"px";
+}
+}
+_4.set(this._popupStateNode,"popupActive","true");
+_5.add(this._popupStateNode,"dijitHasDropDownOpen");
+this._set("_opened",true);
+this._popupStateNode.setAttribute("aria-expanded","true");
+this._popupStateNode.setAttribute("aria-owns",_18.id);
+if(_19.getAttribute("role")!=="presentation"&&!_19.getAttribute("aria-labelledby")){
+_19.setAttribute("aria-labelledby",this.id);
+}
+return _1c;
+},closeDropDown:function(_1f){
+if(this._focusDropDownTimer){
+this._focusDropDownTimer.remove();
+delete this._focusDropDownTimer;
+}
+if(this._opened){
+this._popupStateNode.setAttribute("aria-expanded","false");
+if(_1f&&this.focus){
+this.focus();
+}
+_e.close(this.dropDown);
+this._opened=false;
+}
+if(this._origStyle){
+this.dropDown.domNode.style.cssText=this._origStyle;
+delete this._origStyle;
+}
+}});
+});