@datagrok/helm 2.3.2 → 2.3.3

package/vendor/dojo-1.10.10/dijit/layout/_ContentPaneResizeMixin.js.uncompressed.js

@@ -0,0 +1,236 @@
+define("dijit/layout/_ContentPaneResizeMixin", [
+	"dojo/_base/array", // array.filter array.forEach
+	"dojo/_base/declare", // declare
+	"dojo/dom-class", // domClass.contains domClass.toggle
+	"dojo/dom-geometry", // domGeometry.contentBox domGeometry.marginBox
+	"dojo/dom-style",
+	"dojo/_base/lang", // lang.mixin
+	"dojo/query", // query
+	"../registry", // registry.byId
+	"../Viewport",
+	"./utils" // marginBox2contextBox
+], function(array, declare, domClass, domGeometry, domStyle, lang, query,
+			registry, Viewport, layoutUtils){
+
+	// module:
+	//		dijit/layout/_ContentPaneResizeMixin
+
+	return declare("dijit.layout._ContentPaneResizeMixin", null, {
+		// summary:
+		//		Resize() functionality of ContentPane.   If there's a single layout widget
+		//		child then it will call resize() with the same dimensions as the ContentPane.
+		//		Otherwise just calls resize on each child.
+		//
+		//		Also implements basic startup() functionality, where starting the parent
+		//		will start the children
+
+		// doLayout: Boolean
+		//		- false - don't adjust size of children
+		//		- true - if there is a single visible child widget, set it's size to however big the ContentPane is
+		doLayout: true,
+
+		// isLayoutContainer: [protected] Boolean
+		//		Indicates that this widget will call resize() on it's child widgets
+		//		when they become visible.
+		isLayoutContainer: true,
+
+		startup: function(){
+			// summary:
+			//		See `dijit/layout/_LayoutWidget.startup()` for description.
+			//		Although ContentPane doesn't extend _LayoutWidget, it does implement
+			//		the same API.
+
+			if(this._started){
+				return;
+			}
+
+			var parent = this.getParent();
+			this._childOfLayoutWidget = parent && parent.isLayoutContainer;
+
+			// I need to call resize() on my child/children (when I become visible), unless
+			// I'm the child of a layout widget in which case my parent will call resize() on me and I'll do it then.
+			this._needLayout = !this._childOfLayoutWidget;
+
+			this.inherited(arguments);
+
+			if(this._isShown()){
+				this._onShow();
+			}
+
+			if(!this._childOfLayoutWidget){
+				// Since my parent isn't a layout container, and my style *may be* width=height=100%
+				// or something similar (either set directly or via a CSS class),
+				// monitor when viewport size changes so that I can re-layout.
+				// This is more for subclasses of ContentPane than ContentPane itself, although it
+				// could be useful for a ContentPane if it has a single child widget inheriting ContentPane's size.
+				this.own(Viewport.on("resize", lang.hitch(this, "resize")));
+			}
+		},
+
+		_checkIfSingleChild: function(){
+			// summary:
+			//		Test if we have exactly one visible widget as a child,
+			//		and if so assume that we are a container for that widget,
+			//		and should propagate startup() and resize() calls to it.
+			//		Skips over things like data stores since they aren't visible.
+
+			if(!this.doLayout){ return; }
+
+			var candidateWidgets = [],
+				otherVisibleNodes = false;
+
+			query("> *", this.containerNode).some(function(node){
+				var widget = registry.byNode(node);
+				if(widget && widget.resize){
+					candidateWidgets.push(widget);
+				}else if(!/script|link|style/i.test(node.nodeName) && node.offsetHeight){
+					otherVisibleNodes = true;
+				}
+			});
+
+			this._singleChild = candidateWidgets.length == 1 && !otherVisibleNodes ?
+				candidateWidgets[0] : null;
+
+			// So we can set overflow: hidden to avoid a safari bug w/scrollbars showing up (#9449)
+			domClass.toggle(this.containerNode, this.baseClass + "SingleChild", !!this._singleChild);
+		},
+
+		resize: function(changeSize, resultSize){
+			// summary:
+			//		See `dijit/layout/_LayoutWidget.resize()` for description.
+			//		Although ContentPane doesn't extend _LayoutWidget, it does implement
+			//		the same API.
+
+			this._resizeCalled = true;
+
+			this._scheduleLayout(changeSize, resultSize);
+		},
+
+		_scheduleLayout: function(changeSize, resultSize){
+			// summary:
+			//		Resize myself, and call resize() on each of my child layout widgets, either now
+			//		(if I'm currently visible) or when I become visible
+			if(this._isShown()){
+				this._layout(changeSize, resultSize);
+			}else{
+				this._needLayout = true;
+				this._changeSize = changeSize;
+				this._resultSize = resultSize;
+			}
+		},
+
+		_layout: function(changeSize, resultSize){
+			// summary:
+			//		Resize myself according to optional changeSize/resultSize parameters, like a layout widget.
+			//		Also, since I am an isLayoutContainer widget, each of my children expects me to
+			//		call resize() or layout() on it.
+			//
+			//		Should be called on initialization and also whenever we get new content
+			//		(from an href, or from set('content', ...))... but deferred until
+			//		the ContentPane is visible
+
+			delete this._needLayout;
+
+			// For the TabContainer --> BorderContainer --> ContentPane case, _onShow() is
+			// never called directly, so resize() is our trigger to do the initial href download (see [20099]).
+			// However, don't load href for closed TitlePanes.
+			if(!this._wasShown && this.open !== false){
+				this._onShow();
+			}
+
+			// Set margin box size, unless it wasn't specified, in which case use current size.
+			if(changeSize){
+				domGeometry.setMarginBox(this.domNode, changeSize);
+			}
+
+			// Compute content box size of containerNode in case we [later] need to size our single child.
+			var cn = this.containerNode;
+			if(cn === this.domNode){
+				// If changeSize or resultSize was passed to this method and this.containerNode ==
+				// this.domNode then we can compute the content-box size without querying the node,
+				// which is more reliable (similar to LayoutWidget.resize) (see for example #9449).
+				var mb = resultSize || {};
+				lang.mixin(mb, changeSize || {}); // changeSize overrides resultSize
+				if(!("h" in mb) || !("w" in mb)){
+					mb = lang.mixin(domGeometry.getMarginBox(cn), mb); // just use domGeometry.setMarginBox() to fill in missing values
+				}
+				this._contentBox = layoutUtils.marginBox2contentBox(cn, mb);
+			}else{
+				this._contentBox = domGeometry.getContentBox(cn);
+			}
+
+			this._layoutChildren();
+		},
+
+		_layoutChildren: function(){
+			// Call _checkIfSingleChild() again in case app has manually mucked w/the content
+			// of the ContentPane (rather than changing it through the set("content", ...) API.
+			this._checkIfSingleChild();
+
+			if(this._singleChild && this._singleChild.resize){
+				var cb = this._contentBox || domGeometry.getContentBox(this.containerNode);
+
+				// note: if widget has padding this._contentBox will have l and t set,
+				// but don't pass them to resize() or it will doubly-offset the child
+				this._singleChild.resize({w: cb.w, h: cb.h});
+			}else{
+				// All my child widgets are independently sized (rather than matching my size),
+				// but I still need to call resize() on each child to make it layout.
+				var children = this.getChildren(),
+					widget,
+					i = 0;
+				while(widget = children[i++]){
+					if(widget.resize){
+						widget.resize();
+					}
+				}
+			}
+		},
+
+		_isShown: function(){
+			// summary:
+			//		Returns true if the content is currently shown.
+			// description:
+			//		If I am a child of a layout widget then it actually returns true if I've ever been visible,
+			//		not whether I'm currently visible, since that's much faster than tracing up the DOM/widget
+			//		tree every call, and at least solves the performance problem on page load by deferring loading
+			//		hidden ContentPanes until they are first shown
+
+			if(this._childOfLayoutWidget){
+				// If we are TitlePane, etc - we return that only *IF* we've been resized
+				if(this._resizeCalled && "open" in this){
+					return this.open;
+				}
+				return this._resizeCalled;
+			}else if("open" in this){
+				return this.open;		// for TitlePane, etc.
+			}else{
+				var node = this.domNode, parent = this.domNode.parentNode;
+				return (node.style.display != 'none') && (node.style.visibility != 'hidden') && !domClass.contains(node, "dijitHidden") &&
+					parent && parent.style && (parent.style.display != 'none');
+			}
+		},
+
+		_onShow: function(){
+			// summary:
+			//		Called when the ContentPane is made visible
+			// description:
+			//		For a plain ContentPane, this is called on initialization, from startup().
+			//		If the ContentPane is a hidden pane of a TabContainer etc., then it's
+			//		called whenever the pane is made visible.
+			//
+			//		Does layout/resize of child widget(s)
+
+			// Need to keep track of whether ContentPane has been shown (which is different than
+			// whether or not it's currently visible).
+			this._wasShown = true;
+
+			if(this._needLayout){
+				// If a layout has been scheduled for when we become visible, do it now
+				this._layout(this._changeSize, this._resultSize);
+			}
+
+			this.inherited(arguments);
+		}
+	});
+});

package/vendor/dojo-1.10.10/dijit/layout/_LayoutWidget.js

@@ -0,0 +1,47 @@
+//>>built
+define("dijit/layout/_LayoutWidget",["dojo/_base/lang","../_Widget","../_Container","../_Contained","../Viewport","dojo/_base/declare","dojo/dom-class","dojo/dom-geometry","dojo/dom-style"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9){
+return _6("dijit.layout._LayoutWidget",[_2,_3,_4],{baseClass:"dijitLayoutContainer",isLayoutContainer:true,_setTitleAttr:null,buildRendering:function(){
+this.inherited(arguments);
+_7.add(this.domNode,"dijitContainer");
+},startup:function(){
+if(this._started){
+return;
+}
+this.inherited(arguments);
+var _a=this.getParent&&this.getParent();
+if(!(_a&&_a.isLayoutContainer)){
+this.resize();
+this.own(_5.on("resize",_1.hitch(this,"resize")));
+}
+},resize:function(_b,_c){
+var _d=this.domNode;
+if(_b){
+_8.setMarginBox(_d,_b);
+}
+var mb=_c||{};
+_1.mixin(mb,_b||{});
+if(!("h" in mb)||!("w" in mb)){
+mb=_1.mixin(_8.getMarginBox(_d),mb);
+}
+var cs=_9.getComputedStyle(_d);
+var me=_8.getMarginExtents(_d,cs);
+var be=_8.getBorderExtents(_d,cs);
+var bb=(this._borderBox={w:mb.w-(me.w+be.w),h:mb.h-(me.h+be.h)});
+var pe=_8.getPadExtents(_d,cs);
+this._contentBox={l:_9.toPixelValue(_d,cs.paddingLeft),t:_9.toPixelValue(_d,cs.paddingTop),w:bb.w-pe.w,h:bb.h-pe.h};
+this.layout();
+},layout:function(){
+},_setupChild:function(_e){
+var _f=this.baseClass+"-child "+(_e.baseClass?this.baseClass+"-"+_e.baseClass:"");
+_7.add(_e.domNode,_f);
+},addChild:function(_10,_11){
+this.inherited(arguments);
+if(this._started){
+this._setupChild(_10);
+}
+},removeChild:function(_12){
+var cls=this.baseClass+"-child"+(_12.baseClass?" "+this.baseClass+"-"+_12.baseClass:"");
+_7.remove(_12.domNode,cls);
+this.inherited(arguments);
+}});
+});

package/vendor/dojo-1.10.10/dijit/layout/_LayoutWidget.js.uncompressed.js

@@ -0,0 +1,190 @@
+define("dijit/layout/_LayoutWidget", [
+	"dojo/_base/lang", // lang.mixin
+	"../_Widget",
+	"../_Container",
+	"../_Contained",
+	"../Viewport",
+	"dojo/_base/declare", // declare
+	"dojo/dom-class", // domClass.add domClass.remove
+	"dojo/dom-geometry", // domGeometry.marginBox
+	"dojo/dom-style" // domStyle.getComputedStyle
+], function(lang, _Widget, _Container, _Contained, Viewport,
+	declare, domClass, domGeometry, domStyle){
+
+	// module:
+	//		dijit/layout/_LayoutWidget
+
+
+	return declare("dijit.layout._LayoutWidget", [_Widget, _Container, _Contained], {
+		// summary:
+		//		Base class for a _Container widget which is responsible for laying out its children.
+		//		Widgets which mixin this code must define layout() to manage placement and sizing of the children.
+
+		// baseClass: [protected extension] String
+		//		This class name is applied to the widget's domNode
+		//		and also may be used to generate names for sub nodes,
+		//		for example dijitTabContainer-content.
+		baseClass: "dijitLayoutContainer",
+
+		// isLayoutContainer: [protected] Boolean
+		//		Indicates that this widget is going to call resize() on its
+		//		children widgets, setting their size, when they become visible.
+		isLayoutContainer: true,
+
+		// Cancel _WidgetBase's _setTitleAttr because we don't want the title property (used to specify
+		// tab labels) to be set as an attribute on this.domNode... otherwise a tooltip shows up over the
+		// entire widget.
+		_setTitleAttr: null,
+
+		buildRendering: function(){
+			this.inherited(arguments);
+			domClass.add(this.domNode, "dijitContainer");
+		},
+
+		startup: function(){
+			// summary:
+			//		Called after all the widgets have been instantiated and their
+			//		dom nodes have been inserted somewhere under <body>.
+			//
+			//		Widgets should override this method to do any initialization
+			//		dependent on other widgets existing, and then call
+			//		this superclass method to finish things off.
+			//
+			//		startup() in subclasses shouldn't do anything
+			//		size related because the size of the widget hasn't been set yet.
+
+			if(this._started){ return; }
+
+			// Need to call inherited first - so that child widgets get started
+			// up correctly
+			this.inherited(arguments);
+
+			// If I am a not being controlled by a parent layout widget...
+			var parent = this.getParent && this.getParent();
+			if(!(parent && parent.isLayoutContainer)){
+				// Do recursive sizing and layout of all my descendants
+				// (passing in no argument to resize means that it has to glean the size itself)
+				this.resize();
+
+				// Since my parent isn't a layout container, and my style *may be* width=height=100%
+				// or something similar (either set directly or via a CSS class),
+				// monitor when viewport size changes so that I can re-layout.
+				this.own(Viewport.on("resize", lang.hitch(this, "resize")));
+			}
+		},
+
+		resize: function(changeSize, resultSize){
+			// summary:
+			//		Call this to resize a widget, or after its size has changed.
+			// description:
+			//		####Change size mode:
+			//
+			//		When changeSize is specified, changes the marginBox of this widget
+			//		and forces it to re-layout its contents accordingly.
+			//		changeSize may specify height, width, or both.
+			//
+			//		If resultSize is specified it indicates the size the widget will
+			//		become after changeSize has been applied.
+			//
+			//		####Notification mode:
+			//
+			//		When changeSize is null, indicates that the caller has already changed
+			//		the size of the widget, or perhaps it changed because the browser
+			//		window was resized.  Tells widget to re-layout its contents accordingly.
+			//
+			//		If resultSize is also specified it indicates the size the widget has
+			//		become.
+			//
+			//		In either mode, this method also:
+			//
+			//		1. Sets this._borderBox and this._contentBox to the new size of
+			//			the widget.  Queries the current domNode size if necessary.
+			//		2. Calls layout() to resize contents (and maybe adjust child widgets).
+			// changeSize: Object?
+			//		Sets the widget to this margin-box size and position.
+			//		May include any/all of the following properties:
+			//	|	{w: int, h: int, l: int, t: int}
+			// resultSize: Object?
+			//		The margin-box size of this widget after applying changeSize (if
+			//		changeSize is specified).  If caller knows this size and
+			//		passes it in, we don't need to query the browser to get the size.
+			//	|	{w: int, h: int}
+
+			var node = this.domNode;
+
+			// set margin box size, unless it wasn't specified, in which case use current size
+			if(changeSize){
+				domGeometry.setMarginBox(node, changeSize);
+			}
+
+			// If either height or width wasn't specified by the user, then query node for it.
+			// But note that setting the margin box and then immediately querying dimensions may return
+			// inaccurate results, so try not to depend on it.
+			var mb = resultSize || {};
+			lang.mixin(mb, changeSize || {});	// changeSize overrides resultSize
+			if( !("h" in mb) || !("w" in mb) ){
+				mb = lang.mixin(domGeometry.getMarginBox(node), mb);	// just use domGeometry.marginBox() to fill in missing values
+			}
+
+			// Compute and save the size of my border box and content box
+			// (w/out calling domGeometry.getContentBox() since that may fail if size was recently set)
+			var cs = domStyle.getComputedStyle(node);
+			var me = domGeometry.getMarginExtents(node, cs);
+			var be = domGeometry.getBorderExtents(node, cs);
+			var bb = (this._borderBox = {
+				w: mb.w - (me.w + be.w),
+				h: mb.h - (me.h + be.h)
+			});
+			var pe = domGeometry.getPadExtents(node, cs);
+			this._contentBox = {
+				l: domStyle.toPixelValue(node, cs.paddingLeft),
+				t: domStyle.toPixelValue(node, cs.paddingTop),
+				w: bb.w - pe.w,
+				h: bb.h - pe.h
+			};
+
+			// Callback for widget to adjust size of its children
+			this.layout();
+		},
+
+		layout: function(){
+			// summary:
+			//		Widgets override this method to size and position their contents/children.
+			//		When this is called this._contentBox is guaranteed to be set (see resize()).
+			//
+			//		This is called after startup(), and also when the widget's size has been
+			//		changed.
+			// tags:
+			//		protected extension
+		},
+
+		_setupChild: function(/*dijit/_WidgetBase*/child){
+			// summary:
+			//		Common setup for initial children and children which are added after startup
+			// tags:
+			//		protected extension
+
+			var cls = this.baseClass + "-child "
+				+ (child.baseClass ? this.baseClass + "-" + child.baseClass : "");
+			domClass.add(child.domNode, cls);
+		},
+
+		addChild: function(/*dijit/_WidgetBase*/ child, /*Integer?*/ insertIndex){
+			// Overrides _Container.addChild() to call _setupChild()
+			this.inherited(arguments);
+			if(this._started){
+				this._setupChild(child);
+			}
+		},
+
+		removeChild: function(/*dijit/_WidgetBase*/ child){
+			// Overrides _Container.removeChild() to remove class added by _setupChild()
+			var cls = this.baseClass + "-child"
+					+ (child.baseClass ?
+						" " + this.baseClass + "-" + child.baseClass : "");
+			domClass.remove(child.domNode, cls);
+
+			this.inherited(arguments);
+		}
+	});
+});

package/vendor/dojo-1.10.10/dijit/layout/utils.js

@@ -0,0 +1,77 @@
+//>>built
+define("dijit/layout/utils",["dojo/_base/array","dojo/dom-class","dojo/dom-geometry","dojo/dom-style","dojo/_base/lang"],function(_1,_2,_3,_4,_5){
+function _6(_7){
+return _7.substring(0,1).toUpperCase()+_7.substring(1);
+};
+function _8(_9,_a){
+var _b=_9.resize?_9.resize(_a):_3.setMarginBox(_9.domNode,_a);
+if(_b){
+_5.mixin(_9,_b);
+}else{
+_5.mixin(_9,_3.getMarginBox(_9.domNode));
+_5.mixin(_9,_a);
+}
+};
+var _c={marginBox2contentBox:function(_d,mb){
+var cs=_4.getComputedStyle(_d);
+var me=_3.getMarginExtents(_d,cs);
+var pb=_3.getPadBorderExtents(_d,cs);
+return {l:_4.toPixelValue(_d,cs.paddingLeft),t:_4.toPixelValue(_d,cs.paddingTop),w:mb.w-(me.w+pb.w),h:mb.h-(me.h+pb.h)};
+},layoutChildren:function(_e,_f,_10,_11,_12){
+_f=_5.mixin({},_f);
+_2.add(_e,"dijitLayoutContainer");
+_10=_1.filter(_10,function(_13){
+return _13.region!="center"&&_13.layoutAlign!="client";
+}).concat(_1.filter(_10,function(_14){
+return _14.region=="center"||_14.layoutAlign=="client";
+}));
+_1.forEach(_10,function(_15){
+var elm=_15.domNode,pos=(_15.region||_15.layoutAlign);
+if(!pos){
+throw new Error("No region setting for "+_15.id);
+}
+var _16=elm.style;
+_16.left=_f.l+"px";
+_16.top=_f.t+"px";
+_16.position="absolute";
+_2.add(elm,"dijitAlign"+_6(pos));
+var _17={};
+if(_11&&_11==_15.id){
+_17[_15.region=="top"||_15.region=="bottom"?"h":"w"]=_12;
+}
+if(pos=="leading"){
+pos=_15.isLeftToRight()?"left":"right";
+}
+if(pos=="trailing"){
+pos=_15.isLeftToRight()?"right":"left";
+}
+if(pos=="top"||pos=="bottom"){
+_17.w=_f.w;
+_8(_15,_17);
+_f.h-=_15.h;
+if(pos=="top"){
+_f.t+=_15.h;
+}else{
+_16.top=_f.t+_f.h+"px";
+}
+}else{
+if(pos=="left"||pos=="right"){
+_17.h=_f.h;
+_8(_15,_17);
+_f.w-=_15.w;
+if(pos=="left"){
+_f.l+=_15.w;
+}else{
+_16.left=_f.l+_f.w+"px";
+}
+}else{
+if(pos=="client"||pos=="center"){
+_8(_15,_f);
+}
+}
+}
+});
+}};
+_5.setObject("dijit.layout.utils",_c);
+return _c;
+});