--- /dev/null
+/*
+ Copyright (c) 2004-2008, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/book/dojo-book-0-9/introduction/licensing
+*/
+
+/*
+ This is a compiled version of Dojo, built for deployment and not for
+ development. To get an editable version, please visit:
+
+ http://dojotoolkit.org
+
+ for documentation and information on getting the source.
+*/
+
+if(!dojo._hasResource["dijit._base.focus"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.focus"] = true;
+dojo.provide("dijit._base.focus");
+
+// summary:
+// These functions are used to query or set the focus and selection.
+//
+// Also, they trace when widgets become actived/deactivated,
+// so that the widget can fire _onFocus/_onBlur events.
+// "Active" here means something similar to "focused", but
+// "focus" isn't quite the right word because we keep track of
+// a whole stack of "active" widgets. Example: Combobutton --> Menu -->
+// MenuItem. The onBlur event for Combobutton doesn't fire due to focusing
+// on the Menu or a MenuItem, since they are considered part of the
+// Combobutton widget. It only happens when focus is shifted
+// somewhere completely different.
+
+dojo.mixin(dijit,
+{
+ // _curFocus: DomNode
+ // Currently focused item on screen
+ _curFocus: null,
+
+ // _prevFocus: DomNode
+ // Previously focused item on screen
+ _prevFocus: null,
+
+ isCollapsed: function(){
+ // summary: tests whether the current selection is empty
+ var _window = dojo.global;
+ var _document = dojo.doc;
+ if(_document.selection){ // IE
+ return !_document.selection.createRange().text; // Boolean
+ }else{
+ var selection = _window.getSelection();
+ if(dojo.isString(selection)){ // Safari
+ return !selection; // Boolean
+ }else{ // Mozilla/W3
+ return selection.isCollapsed || !selection.toString(); // Boolean
+ }
+ }
+ },
+
+ getBookmark: function(){
+ // summary: Retrieves a bookmark that can be used with moveToBookmark to return to the same range
+ var bookmark, selection = dojo.doc.selection;
+ if(selection){ // IE
+ var range = selection.createRange();
+ if(selection.type.toUpperCase()=='CONTROL'){
+ if(range.length){
+ bookmark=[];
+ var i=0,len=range.length;
+ while(i<len){
+ bookmark.push(range.item(i++));
+ }
+ }else{
+ bookmark=null;
+ }
+ }else{
+ bookmark = range.getBookmark();
+ }
+ }else{
+ if(window.getSelection){
+ selection = dojo.global.getSelection();
+ if(selection){
+ range = selection.getRangeAt(0);
+ bookmark = range.cloneRange();
+ }
+ }else{
+ console.warn("No idea how to store the current selection for this browser!");
+ }
+ }
+ return bookmark; // Array
+ },
+
+ moveToBookmark: function(/*Object*/bookmark){
+ // summary: Moves current selection to a bookmark
+ // bookmark: This should be a returned object from dojo.html.selection.getBookmark()
+ var _document = dojo.doc;
+ if(_document.selection){ // IE
+ var range;
+ if(dojo.isArray(bookmark)){
+ range = _document.body.createControlRange();
+ dojo.forEach(bookmark, "range.addElement(item)"); //range.addElement does not have call/apply method, so can not call it directly
+ }else{
+ range = _document.selection.createRange();
+ range.moveToBookmark(bookmark);
+ }
+ range.select();
+ }else{ //Moz/W3C
+ var selection = dojo.global.getSelection && dojo.global.getSelection();
+ if(selection && selection.removeAllRanges){
+ selection.removeAllRanges();
+ selection.addRange(bookmark);
+ }else{
+ console.warn("No idea how to restore selection for this browser!");
+ }
+ }
+ },
+
+ getFocus: function(/*Widget?*/menu, /*Window?*/openedForWindow){
+ // summary:
+ // Returns the current focus and selection.
+ // Called when a popup appears (either a top level menu or a dialog),
+ // or when a toolbar/menubar receives focus
+ //
+ // menu:
+ // The menu that's being opened
+ //
+ // openedForWindow:
+ // iframe in which menu was opened
+ //
+ // returns:
+ // A handle to restore focus/selection
+
+ return {
+ // Node to return focus to
+ node: menu && dojo.isDescendant(dijit._curFocus, menu.domNode) ? dijit._prevFocus : dijit._curFocus,
+
+ // Previously selected text
+ bookmark:
+ !dojo.withGlobal(openedForWindow||dojo.global, dijit.isCollapsed) ?
+ dojo.withGlobal(openedForWindow||dojo.global, dijit.getBookmark) :
+ null,
+
+ openedForWindow: openedForWindow
+ }; // Object
+ },
+
+ focus: function(/*Object || DomNode */ handle){
+ // summary:
+ // Sets the focused node and the selection according to argument.
+ // To set focus to an iframe's content, pass in the iframe itself.
+ // handle:
+ // object returned by get(), or a DomNode
+
+ if(!handle){ return; }
+
+ var node = "node" in handle ? handle.node : handle, // because handle is either DomNode or a composite object
+ bookmark = handle.bookmark,
+ openedForWindow = handle.openedForWindow;
+
+ // Set the focus
+ // Note that for iframe's we need to use the <iframe> to follow the parentNode chain,
+ // but we need to set focus to iframe.contentWindow
+ if(node){
+ var focusNode = (node.tagName.toLowerCase()=="iframe") ? node.contentWindow : node;
+ if(focusNode && focusNode.focus){
+ try{
+ // Gecko throws sometimes if setting focus is impossible,
+ // node not displayed or something like that
+ focusNode.focus();
+ }catch(e){/*quiet*/}
+ }
+ dijit._onFocusNode(node);
+ }
+
+ // set the selection
+ // do not need to restore if current selection is not empty
+ // (use keyboard to select a menu item)
+ if(bookmark && dojo.withGlobal(openedForWindow||dojo.global, dijit.isCollapsed)){
+ if(openedForWindow){
+ openedForWindow.focus();
+ }
+ try{
+ dojo.withGlobal(openedForWindow||dojo.global, dijit.moveToBookmark, null, [bookmark]);
+ }catch(e){
+ /*squelch IE internal error, see http://trac.dojotoolkit.org/ticket/1984 */
+ }
+ }
+ },
+
+ // _activeStack: Array
+ // List of currently active widgets (focused widget and it's ancestors)
+ _activeStack: [],
+
+ registerWin: function(/*Window?*/targetWindow){
+ // summary:
+ // Registers listeners on the specified window (either the main
+ // window or an iframe) to detect when the user has clicked somewhere.
+ // Anyone that creates an iframe should call this function.
+
+ if(!targetWindow){
+ targetWindow = window;
+ }
+
+ dojo.connect(targetWindow.document, "onmousedown", function(evt){
+ dijit._justMouseDowned = true;
+ setTimeout(function(){ dijit._justMouseDowned = false; }, 0);
+ dijit._onTouchNode(evt.target||evt.srcElement);
+ });
+ //dojo.connect(targetWindow, "onscroll", ???);
+
+ // Listen for blur and focus events on targetWindow's body
+ var body = targetWindow.document.body || targetWindow.document.getElementsByTagName("body")[0];
+ if(body){
+ if(dojo.isIE){
+ body.attachEvent('onactivate', function(evt){
+ if(evt.srcElement.tagName.toLowerCase() != "body"){
+ dijit._onFocusNode(evt.srcElement);
+ }
+ });
+ body.attachEvent('ondeactivate', function(evt){ dijit._onBlurNode(evt.srcElement); });
+ }else{
+ body.addEventListener('focus', function(evt){ dijit._onFocusNode(evt.target); }, true);
+ body.addEventListener('blur', function(evt){ dijit._onBlurNode(evt.target); }, true);
+ }
+ }
+ body = null; // prevent memory leak (apparent circular reference via closure)
+ },
+
+ _onBlurNode: function(/*DomNode*/ node){
+ // summary:
+ // Called when focus leaves a node.
+ // Usually ignored, _unless_ it *isn't* follwed by touching another node,
+ // which indicates that we tabbed off the last field on the page,
+ // in which case every widget is marked inactive
+ dijit._prevFocus = dijit._curFocus;
+ dijit._curFocus = null;
+
+ if(dijit._justMouseDowned){
+ // the mouse down caused a new widget to be marked as active; this blur event
+ // is coming late, so ignore it.
+ return;
+ }
+
+ // if the blur event isn't followed by a focus event then mark all widgets as inactive.
+ if(dijit._clearActiveWidgetsTimer){
+ clearTimeout(dijit._clearActiveWidgetsTimer);
+ }
+ dijit._clearActiveWidgetsTimer = setTimeout(function(){
+ delete dijit._clearActiveWidgetsTimer;
+ dijit._setStack([]);
+ dijit._prevFocus = null;
+ }, 100);
+ },
+
+ _onTouchNode: function(/*DomNode*/ node){
+ // summary:
+ // Callback when node is focused or mouse-downed
+
+ // ignore the recent blurNode event
+ if(dijit._clearActiveWidgetsTimer){
+ clearTimeout(dijit._clearActiveWidgetsTimer);
+ delete dijit._clearActiveWidgetsTimer;
+ }
+
+ // compute stack of active widgets (ex: ComboButton --> Menu --> MenuItem)
+ var newStack=[];
+ try{
+ while(node){
+ if(node.dijitPopupParent){
+ node=dijit.byId(node.dijitPopupParent).domNode;
+ }else if(node.tagName && node.tagName.toLowerCase()=="body"){
+ // is this the root of the document or just the root of an iframe?
+ if(node===dojo.body()){
+ // node is the root of the main document
+ break;
+ }
+ // otherwise, find the iframe this node refers to (can't access it via parentNode,
+ // need to do this trick instead). window.frameElement is supported in IE/FF/Webkit
+ node=dijit.getDocumentWindow(node.ownerDocument).frameElement;
+ }else{
+ var id = node.getAttribute && node.getAttribute("widgetId");
+ if(id){
+ newStack.unshift(id);
+ }
+ node=node.parentNode;
+ }
+ }
+ }catch(e){ /* squelch */ }
+
+ dijit._setStack(newStack);
+ },
+
+ _onFocusNode: function(/*DomNode*/ node){
+ // summary
+ // Callback when node is focused
+ if(node && node.tagName && node.tagName.toLowerCase() == "body"){
+ return;
+ }
+ dijit._onTouchNode(node);
+
+ if(node==dijit._curFocus){ return; }
+ if(dijit._curFocus){
+ dijit._prevFocus = dijit._curFocus;
+ }
+ dijit._curFocus = node;
+ dojo.publish("focusNode", [node]);
+ },
+
+ _setStack: function(newStack){
+ // summary
+ // The stack of active widgets has changed. Send out appropriate events and record new stack
+
+ var oldStack = dijit._activeStack;
+ dijit._activeStack = newStack;
+
+ // compare old stack to new stack to see how many elements they have in common
+ for(var nCommon=0; nCommon<Math.min(oldStack.length, newStack.length); nCommon++){
+ if(oldStack[nCommon] != newStack[nCommon]){
+ break;
+ }
+ }
+
+ // for all elements that have gone out of focus, send blur event
+ for(var i=oldStack.length-1; i>=nCommon; i--){
+ var widget = dijit.byId(oldStack[i]);
+ if(widget){
+ widget._focused = false;
+ widget._hasBeenBlurred = true;
+ if(widget._onBlur){
+ widget._onBlur();
+ }
+ if (widget._setStateClass){
+ widget._setStateClass();
+ }
+ dojo.publish("widgetBlur", [widget]);
+ }
+ }
+
+ // for all element that have come into focus, send focus event
+ for(i=nCommon; i<newStack.length; i++){
+ widget = dijit.byId(newStack[i]);
+ if(widget){
+ widget._focused = true;
+ if(widget._onFocus){
+ widget._onFocus();
+ }
+ if (widget._setStateClass){
+ widget._setStateClass();
+ }
+ dojo.publish("widgetFocus", [widget]);
+ }
+ }
+ }
+});
+
+// register top window and all the iframes it contains
+dojo.addOnLoad(dijit.registerWin);
+
+}
+
+if(!dojo._hasResource["dijit._base.manager"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.manager"] = true;
+dojo.provide("dijit._base.manager");
+
+dojo.declare("dijit.WidgetSet", null, {
+ // summary:
+ // A set of widgets indexed by id
+
+ constructor: function(){
+ this._hash={};
+ },
+
+ add: function(/*Widget*/ widget){
+ if(this._hash[widget.id]){
+ throw new Error("Tried to register widget with id==" + widget.id + " but that id is already registered");
+ }
+ this._hash[widget.id]=widget;
+ },
+
+ remove: function(/*String*/ id){
+ delete this._hash[id];
+ },
+
+ forEach: function(/*Function*/ func){
+ for(var id in this._hash){
+ func(this._hash[id]);
+ }
+ },
+
+ filter: function(/*Function*/ filter){
+ var res = new dijit.WidgetSet();
+ this.forEach(function(widget){
+ if(filter(widget)){ res.add(widget); }
+ });
+ return res; // dijit.WidgetSet
+ },
+
+ byId: function(/*String*/ id){
+ return this._hash[id];
+ },
+
+ byClass: function(/*String*/ cls){
+ return this.filter(function(widget){ return widget.declaredClass==cls; }); // dijit.WidgetSet
+ }
+ });
+
+/*=====
+dijit.registry = {
+ // summary: A list of widgets on a page.
+ // description: Is an instance of dijit.WidgetSet
+};
+=====*/
+dijit.registry = new dijit.WidgetSet();
+
+dijit._widgetTypeCtr = {};
+
+dijit.getUniqueId = function(/*String*/widgetType){
+ // summary
+ // Generates a unique id for a given widgetType
+
+ var id;
+ do{
+ id = widgetType + "_" +
+ (widgetType in dijit._widgetTypeCtr ?
+ ++dijit._widgetTypeCtr[widgetType] : dijit._widgetTypeCtr[widgetType] = 0);
+ }while(dijit.byId(id));
+ return id; // String
+};
+
+
+if(dojo.isIE){
+ // Only run this for IE because we think it's only necessary in that case,
+ // and because it causes problems on FF. See bug #3531 for details.
+ dojo.addOnUnload(function(){
+ dijit.registry.forEach(function(widget){ widget.destroy(); });
+ });
+}
+
+dijit.byId = function(/*String|Widget*/id){
+ // summary:
+ // Returns a widget by its id, or if passed a widget, no-op (like dojo.byId())
+ return (dojo.isString(id)) ? dijit.registry.byId(id) : id; // Widget
+};
+
+dijit.byNode = function(/* DOMNode */ node){
+ // summary:
+ // Returns the widget as referenced by node
+ return dijit.registry.byId(node.getAttribute("widgetId")); // Widget
+};
+
+dijit.getEnclosingWidget = function(/* DOMNode */ node){
+ // summary:
+ // Returns the widget whose dom tree contains node or null if
+ // the node is not contained within the dom tree of any widget
+ while(node){
+ if(node.getAttribute && node.getAttribute("widgetId")){
+ return dijit.registry.byId(node.getAttribute("widgetId"));
+ }
+ node = node.parentNode;
+ }
+ return null;
+};
+
+// elements that are tab-navigable if they have no tabindex value set
+// (except for "a", which must have an href attribute)
+dijit._tabElements = {
+ area: true,
+ button: true,
+ input: true,
+ object: true,
+ select: true,
+ textarea: true
+};
+
+dijit._isElementShown = function(/*Element*/elem){
+ var style = dojo.style(elem);
+ return (style.visibility != "hidden")
+ && (style.visibility != "collapsed")
+ && (style.display != "none");
+}
+
+dijit.isTabNavigable = function(/*Element*/elem){
+ // summary:
+ // Tests if an element is tab-navigable
+ if(dojo.hasAttr(elem, "disabled")){ return false; }
+ var hasTabindex = dojo.hasAttr(elem, "tabindex");
+ var tabindex = dojo.attr(elem, "tabindex");
+ if(hasTabindex && tabindex >= 0) {
+ return true; // boolean
+ }
+ var name = elem.nodeName.toLowerCase();
+ if(((name == "a" && dojo.hasAttr(elem, "href"))
+ || dijit._tabElements[name])
+ && (!hasTabindex || tabindex >= 0)){
+ return true; // boolean
+ }
+ return false; // boolean
+};
+
+dijit._getTabNavigable = function(/*DOMNode*/root){
+ // summary:
+ // Finds the following descendants of the specified root node:
+ // * the first tab-navigable element in document order
+ // without a tabindex or with tabindex="0"
+ // * the last tab-navigable element in document order
+ // without a tabindex or with tabindex="0"
+ // * the first element in document order with the lowest
+ // positive tabindex value
+ // * the last element in document order with the highest
+ // positive tabindex value
+ var first, last, lowest, lowestTabindex, highest, highestTabindex;
+ var walkTree = function(/*DOMNode*/parent){
+ dojo.query("> *", parent).forEach(function(child){
+ var isShown = dijit._isElementShown(child);
+ if(isShown && dijit.isTabNavigable(child)){
+ var tabindex = dojo.attr(child, "tabindex");
+ if(!dojo.hasAttr(child, "tabindex") || tabindex == 0){
+ if(!first){ first = child; }
+ last = child;
+ }else if(tabindex > 0){
+ if(!lowest || tabindex < lowestTabindex){
+ lowestTabindex = tabindex;
+ lowest = child;
+ }
+ if(!highest || tabindex >= highestTabindex){
+ highestTabindex = tabindex;
+ highest = child;
+ }
+ }
+ }
+ if(isShown){ walkTree(child) }
+ });
+ };
+ if(dijit._isElementShown(root)){ walkTree(root) }
+ return { first: first, last: last, lowest: lowest, highest: highest };
+}
+
+dijit.getFirstInTabbingOrder = function(/*String|DOMNode*/root){
+ // summary:
+ // Finds the descendant of the specified root node
+ // that is first in the tabbing order
+ var elems = dijit._getTabNavigable(dojo.byId(root));
+ return elems.lowest ? elems.lowest : elems.first; // Element
+};
+
+dijit.getLastInTabbingOrder = function(/*String|DOMNode*/root){
+ // summary:
+ // Finds the descendant of the specified root node
+ // that is last in the tabbing order
+ var elems = dijit._getTabNavigable(dojo.byId(root));
+ return elems.last ? elems.last : elems.highest; // Element
+};
+
+}
+
+if(!dojo._hasResource["dijit._base.place"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.place"] = true;
+dojo.provide("dijit._base.place");
+
+// ported from dojo.html.util
+
+dijit.getViewport = function(){
+ // summary
+ // Returns the dimensions and scroll position of the viewable area of a browser window
+
+ var _window = dojo.global;
+ var _document = dojo.doc;
+
+ // get viewport size
+ var w = 0, h = 0;
+ var de = _document.documentElement;
+ var dew = de.clientWidth, deh = de.clientHeight;
+ if(dojo.isMozilla){
+ // mozilla
+ // _window.innerHeight includes the height taken by the scroll bar
+ // clientHeight is ideal but has DTD issues:
+ // #4539: FF reverses the roles of body.clientHeight/Width and documentElement.clientHeight/Width based on the DTD!
+ // check DTD to see whether body or documentElement returns the viewport dimensions using this algorithm:
+ var minw, minh, maxw, maxh;
+ var dbw = _document.body.clientWidth;
+ if(dbw > dew){
+ minw = dew;
+ maxw = dbw;
+ }else{
+ maxw = dew;
+ minw = dbw;
+ }
+ var dbh = _document.body.clientHeight;
+ if(dbh > deh){
+ minh = deh;
+ maxh = dbh;
+ }else{
+ maxh = deh;
+ minh = dbh;
+ }
+ w = (maxw > _window.innerWidth) ? minw : maxw;
+ h = (maxh > _window.innerHeight) ? minh : maxh;
+ }else if(!dojo.isOpera && _window.innerWidth){
+ //in opera9, dojo.body().clientWidth should be used, instead
+ //of window.innerWidth/document.documentElement.clientWidth
+ //so we have to check whether it is opera
+ w = _window.innerWidth;
+ h = _window.innerHeight;
+ }else if(dojo.isIE && de && deh){
+ w = dew;
+ h = deh;
+ }else if(dojo.body().clientWidth){
+ // IE5, Opera
+ w = dojo.body().clientWidth;
+ h = dojo.body().clientHeight;
+ }
+
+ // get scroll position
+ var scroll = dojo._docScroll();
+
+ return { w: w, h: h, l: scroll.x, t: scroll.y }; // object
+};
+
+dijit.placeOnScreen = function(
+ /* DomNode */ node,
+ /* Object */ pos,
+ /* Object */ corners,
+ /* boolean? */ tryOnly){
+ // summary:
+ // Keeps 'node' in the visible area of the screen while trying to
+ // place closest to pos.x, pos.y. The input coordinates are
+ // expected to be the desired document position.
+ //
+ // Set which corner(s) you want to bind to, such as
+ //
+ // placeOnScreen(node, {x: 10, y: 20}, ["TR", "BL"])
+ //
+ // The desired x/y will be treated as the topleft(TL)/topright(TR) or
+ // BottomLeft(BL)/BottomRight(BR) corner of the node. Each corner is tested
+ // and if a perfect match is found, it will be used. Otherwise, it goes through
+ // all of the specified corners, and choose the most appropriate one.
+ //
+ // NOTE: node is assumed to be absolutely or relatively positioned.
+
+ var choices = dojo.map(corners, function(corner){ return { corner: corner, pos: pos }; });
+
+ return dijit._place(node, choices);
+}
+
+dijit._place = function(/*DomNode*/ node, /* Array */ choices, /* Function */ layoutNode){
+ // summary:
+ // Given a list of spots to put node, put it at the first spot where it fits,
+ // of if it doesn't fit anywhere then the place with the least overflow
+ // choices: Array
+ // Array of elements like: {corner: 'TL', pos: {x: 10, y: 20} }
+ // Above example says to put the top-left corner of the node at (10,20)
+ // layoutNode: Function(node, aroundNodeCorner, nodeCorner)
+ // for things like tooltip, they are displayed differently (and have different dimensions)
+ // based on their orientation relative to the parent. This adjusts the popup based on orientation.
+
+ // get {x: 10, y: 10, w: 100, h:100} type obj representing position of
+ // viewport over document
+ var view = dijit.getViewport();
+
+ // This won't work if the node is inside a <div style="position: relative">,
+ // so reattach it to dojo.doc.body. (Otherwise, the positioning will be wrong
+ // and also it might get cutoff)
+ if(!node.parentNode || String(node.parentNode.tagName).toLowerCase() != "body"){
+ dojo.body().appendChild(node);
+ }
+
+ var best = null;
+ dojo.some(choices, function(choice){
+ var corner = choice.corner;
+ var pos = choice.pos;
+
+ // configure node to be displayed in given position relative to button
+ // (need to do this in order to get an accurate size for the node, because
+ // a tooltips size changes based on position, due to triangle)
+ if(layoutNode){
+ layoutNode(node, choice.aroundCorner, corner);
+ }
+
+ // get node's size
+ var style = node.style;
+ var oldDisplay = style.display;
+ var oldVis = style.visibility;
+ style.visibility = "hidden";
+ style.display = "";
+ var mb = dojo.marginBox(node);
+ style.display = oldDisplay;
+ style.visibility = oldVis;
+
+ // coordinates and size of node with specified corner placed at pos,
+ // and clipped by viewport
+ var startX = (corner.charAt(1) == 'L' ? pos.x : Math.max(view.l, pos.x - mb.w)),
+ startY = (corner.charAt(0) == 'T' ? pos.y : Math.max(view.t, pos.y - mb.h)),
+ endX = (corner.charAt(1) == 'L' ? Math.min(view.l + view.w, startX + mb.w) : pos.x),
+ endY = (corner.charAt(0) == 'T' ? Math.min(view.t + view.h, startY + mb.h) : pos.y),
+ width = endX - startX,
+ height = endY - startY,
+ overflow = (mb.w - width) + (mb.h - height);
+
+ if(best == null || overflow < best.overflow){
+ best = {
+ corner: corner,
+ aroundCorner: choice.aroundCorner,
+ x: startX,
+ y: startY,
+ w: width,
+ h: height,
+ overflow: overflow
+ };
+ }
+ return !overflow;
+ });
+
+ node.style.left = best.x + "px";
+ node.style.top = best.y + "px";
+ if(best.overflow && layoutNode){
+ layoutNode(node, best.aroundCorner, best.corner);
+ }
+ return best;
+}
+
+dijit.placeOnScreenAroundElement = function(
+ /* DomNode */ node,
+ /* DomNode */ aroundNode,
+ /* Object */ aroundCorners,
+ /* Function */ layoutNode){
+
+ // summary
+ // Like placeOnScreen, except it accepts aroundNode instead of x,y
+ // and attempts to place node around it. Uses margin box dimensions.
+ //
+ // aroundCorners
+ // specify Which corner of aroundNode should be
+ // used to place the node => which corner(s) of node to use (see the
+ // corners parameter in dijit.placeOnScreen)
+ // e.g. {'TL': 'BL', 'BL': 'TL'}
+ //
+ // layoutNode: Function(node, aroundNodeCorner, nodeCorner)
+ // for things like tooltip, they are displayed differently (and have different dimensions)
+ // based on their orientation relative to the parent. This adjusts the popup based on orientation.
+
+
+ // get coordinates of aroundNode
+ aroundNode = dojo.byId(aroundNode);
+ var oldDisplay = aroundNode.style.display;
+ aroundNode.style.display="";
+ // #3172: use the slightly tighter border box instead of marginBox
+ var aroundNodeW = aroundNode.offsetWidth; //mb.w;
+ var aroundNodeH = aroundNode.offsetHeight; //mb.h;
+ var aroundNodePos = dojo.coords(aroundNode, true);
+ aroundNode.style.display=oldDisplay;
+
+ // Generate list of possible positions for node
+ var choices = [];
+ for(var nodeCorner in aroundCorners){
+ choices.push( {
+ aroundCorner: nodeCorner,
+ corner: aroundCorners[nodeCorner],
+ pos: {
+ x: aroundNodePos.x + (nodeCorner.charAt(1) == 'L' ? 0 : aroundNodeW),
+ y: aroundNodePos.y + (nodeCorner.charAt(0) == 'T' ? 0 : aroundNodeH)
+ }
+ });
+ }
+
+ return dijit._place(node, choices, layoutNode);
+}
+
+}
+
+if(!dojo._hasResource["dijit._base.window"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.window"] = true;
+dojo.provide("dijit._base.window");
+
+dijit.getDocumentWindow = function(doc){
+ // summary
+ // Get window object associated with document doc
+
+ // With Safari, there is not way to retrieve the window from the document, so we must fix it.
+ if(dojo.isSafari && !doc._parentWindow){
+ /*
+ This is a Safari specific function that fix the reference to the parent
+ window from the document object.
+ TODO: #5711: should the use of document below reference dojo.doc instead
+ in case they're not the same?
+ */
+ var fix=function(win){
+ win.document._parentWindow=win;
+ for(var i=0; i<win.frames.length; i++){
+ fix(win.frames[i]);
+ }
+ }
+ fix(window.top);
+ }
+
+ //In some IE versions (at least 6.0), document.parentWindow does not return a
+ //reference to the real window object (maybe a copy), so we must fix it as well
+ //We use IE specific execScript to attach the real window reference to
+ //document._parentWindow for later use
+ //TODO: #5711: should the use of document below reference dojo.doc instead in case they're not the same?
+ if(dojo.isIE && window !== document.parentWindow && !doc._parentWindow){
+ /*
+ In IE 6, only the variable "window" can be used to connect events (others
+ may be only copies).
+ */
+ doc.parentWindow.execScript("document._parentWindow = window;", "Javascript");
+ //to prevent memory leak, unset it after use
+ //another possibility is to add an onUnload handler which seems overkill to me (liucougar)
+ var win = doc._parentWindow;
+ doc._parentWindow = null;
+ return win; // Window
+ }
+
+ return doc._parentWindow || doc.parentWindow || doc.defaultView; // Window
+}
+
+}
+
+if(!dojo._hasResource["dijit._base.popup"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.popup"] = true;
+dojo.provide("dijit._base.popup");
+
+
+
+
+
+dijit.popup = new function(){
+ // summary:
+ // This class is used to show/hide widgets as popups.
+ //
+
+ var stack = [],
+ beginZIndex=1000,
+ idGen = 1;
+
+ this.prepare = function(/*DomNode*/ node){
+ // summary:
+ // Prepares a node to be used as a popup
+ //
+ // description:
+ // Attaches node to dojo.doc.body, and
+ // positions it off screen, but not display:none, so that
+ // the widget doesn't appear in the page flow and/or cause a blank
+ // area at the bottom of the viewport (making scrollbar longer), but
+ // initialization of contained widgets works correctly
+
+ dojo.body().appendChild(node);
+ var s = node.style;
+ if(s.display == "none"){
+ s.display="";
+ }
+ s.visibility = "hidden"; // not needed for hiding, but used as flag that node is off-screen
+ s.position = "absolute";
+ s.top = "-9999px";
+ };
+
+ this.open = function(/*Object*/ args){
+ // summary:
+ // Popup the widget at the specified position
+ //
+ // args: Object
+ // popup: Widget
+ // widget to display,
+ // parent: Widget
+ // the button etc. that is displaying this popup
+ // around: DomNode
+ // DOM node (typically a button); place popup relative to this node
+ // orient: Object
+ // structure specifying possible positions of popup relative to "around" node
+ // onCancel: Function
+ // callback when user has canceled the popup by
+ // 1. hitting ESC or
+ // 2. by using the popup widget's proprietary cancel mechanism (like a cancel button in a dialog);
+ // ie: whenever popupWidget.onCancel() is called, args.onCancel is called
+ // onClose: Function
+ // callback whenever this popup is closed
+ // onExecute: Function
+ // callback when user "executed" on the popup/sub-popup by selecting a menu choice, etc. (top menu only)
+ //
+ // examples:
+ // 1. opening at the mouse position
+ // dijit.popup.open({popup: menuWidget, x: evt.pageX, y: evt.pageY});
+ // 2. opening the widget as a dropdown
+ // dijit.popup.open({parent: this, popup: menuWidget, around: this.domNode, onClose: function(){...} });
+ //
+ // Note that whatever widget called dijit.popup.open() should also listen to it's own _onBlur callback
+ // (fired from _base/focus.js) to know that focus has moved somewhere else and thus the popup should be closed.
+
+ var widget = args.popup,
+ orient = args.orient || {'BL':'TL', 'TL':'BL'},
+ around = args.around,
+ id = (args.around && args.around.id) ? (args.around.id+"_dropdown") : ("popup_"+idGen++);
+
+ // make wrapper div to hold widget and possibly hold iframe behind it.
+ // we can't attach the iframe as a child of the widget.domNode because
+ // widget.domNode might be a <table>, <ul>, etc.
+ var wrapper = dojo.doc.createElement("div");
+ dijit.setWaiRole(wrapper, "presentation");
+ wrapper.id = id;
+ wrapper.className="dijitPopup";
+ wrapper.style.zIndex = beginZIndex + stack.length;
+ wrapper.style.visibility = "hidden";
+ if(args.parent){
+ wrapper.dijitPopupParent=args.parent.id;
+ }
+ dojo.body().appendChild(wrapper);
+
+ var s = widget.domNode.style;
+ s.display = "";
+ s.visibility = "";
+ s.position = "";
+ wrapper.appendChild(widget.domNode);
+
+ var iframe = new dijit.BackgroundIframe(wrapper);
+
+ // position the wrapper node
+ var best = around ?
+ dijit.placeOnScreenAroundElement(wrapper, around, orient, widget.orient ? dojo.hitch(widget, "orient") : null) :
+ dijit.placeOnScreen(wrapper, args, orient == 'R' ? ['TR','BR','TL','BL'] : ['TL','BL','TR','BR']);
+
+ wrapper.style.visibility = "visible";
+ // TODO: use effects to fade in wrapper
+
+ var handlers = [];
+
+ // Compute the closest ancestor popup that's *not* a child of another popup.
+ // Ex: For a TooltipDialog with a button that spawns a tree of menus, find the popup of the button.
+ var getTopPopup = function(){
+ for(var pi=stack.length-1; pi > 0 && stack[pi].parent === stack[pi-1].widget; pi--){
+ /* do nothing, just trying to get right value for pi */
+ }
+ return stack[pi];
+ }
+
+ // provide default escape and tab key handling
+ // (this will work for any widget, not just menu)
+ handlers.push(dojo.connect(wrapper, "onkeypress", this, function(evt){
+ if(evt.keyCode == dojo.keys.ESCAPE && args.onCancel){
+ dojo.stopEvent(evt);
+ args.onCancel();
+ }else if(evt.keyCode == dojo.keys.TAB){
+ dojo.stopEvent(evt);
+ var topPopup = getTopPopup();
+ if(topPopup && topPopup.onCancel){
+ topPopup.onCancel();
+ }
+ }
+ }));
+
+ // watch for cancel/execute events on the popup and notify the caller
+ // (for a menu, "execute" means clicking an item)
+ if(widget.onCancel){
+ handlers.push(dojo.connect(widget, "onCancel", null, args.onCancel));
+ }
+
+ handlers.push(dojo.connect(widget, widget.onExecute ? "onExecute" : "onChange", null, function(){
+ var topPopup = getTopPopup();
+ if(topPopup && topPopup.onExecute){
+ topPopup.onExecute();
+ }
+ }));
+
+ stack.push({
+ wrapper: wrapper,
+ iframe: iframe,
+ widget: widget,
+ parent: args.parent,
+ onExecute: args.onExecute,
+ onCancel: args.onCancel,
+ onClose: args.onClose,
+ handlers: handlers
+ });
+
+ if(widget.onOpen){
+ widget.onOpen(best);
+ }
+
+ return best;
+ };
+
+ this.close = function(/*Widget*/ popup){
+ // summary:
+ // Close specified popup and any popups that it parented
+ while(dojo.some(stack, function(elem){return elem.widget == popup;})){
+ var top = stack.pop(),
+ wrapper = top.wrapper,
+ iframe = top.iframe,
+ widget = top.widget,
+ onClose = top.onClose;
+
+ if(widget.onClose){
+ widget.onClose();
+ }
+ dojo.forEach(top.handlers, dojo.disconnect);
+
+ // #2685: check if the widget still has a domNode so ContentPane can change its URL without getting an error
+ if(!widget||!widget.domNode){ return; }
+
+ this.prepare(widget.domNode);
+
+ iframe.destroy();
+ dojo._destroyElement(wrapper);
+
+ if(onClose){
+ onClose();
+ }
+ }
+ };
+}();
+
+dijit._frames = new function(){
+ // summary: cache of iframes
+ var queue = [];
+
+ this.pop = function(){
+ var iframe;
+ if(queue.length){
+ iframe = queue.pop();
+ iframe.style.display="";
+ }else{
+ if(dojo.isIE){
+ var html="<iframe src='javascript:\"\"'"
+ + " style='position: absolute; left: 0px; top: 0px;"
+ + "z-index: -1; filter:Alpha(Opacity=\"0\");'>";
+ iframe = dojo.doc.createElement(html);
+ }else{
+ iframe = dojo.doc.createElement("iframe");
+ iframe.src = 'javascript:""';
+ iframe.className = "dijitBackgroundIframe";
+ }
+ iframe.tabIndex = -1; // Magic to prevent iframe from getting focus on tab keypress - as style didnt work.
+ dojo.body().appendChild(iframe);
+ }
+ return iframe;
+ };
+
+ this.push = function(iframe){
+ iframe.style.display="";
+ if(dojo.isIE){
+ iframe.style.removeExpression("width");
+ iframe.style.removeExpression("height");
+ }
+ queue.push(iframe);
+ }
+}();
+
+// fill the queue
+if(dojo.isIE && dojo.isIE < 7){
+ dojo.addOnLoad(function(){
+ var f = dijit._frames;
+ dojo.forEach([f.pop()], f.push);
+ });
+}
+
+
+dijit.BackgroundIframe = function(/* DomNode */node){
+ // summary:
+ // For IE z-index schenanigans. id attribute is required.
+ //
+ // description:
+ // new dijit.BackgroundIframe(node)
+ // Makes a background iframe as a child of node, that fills
+ // area (and position) of node
+
+ if(!node.id){ throw new Error("no id"); }
+ if((dojo.isIE && dojo.isIE < 7) || (dojo.isFF && dojo.isFF < 3 && dojo.hasClass(dojo.body(), "dijit_a11y"))){
+ var iframe = dijit._frames.pop();
+ node.appendChild(iframe);
+ if(dojo.isIE){
+ iframe.style.setExpression("width", dojo._scopeName + ".doc.getElementById('" + node.id + "').offsetWidth");
+ iframe.style.setExpression("height", dojo._scopeName + ".doc.getElementById('" + node.id + "').offsetHeight");
+ }
+ this.iframe = iframe;
+ }
+};
+
+dojo.extend(dijit.BackgroundIframe, {
+ destroy: function(){
+ // summary: destroy the iframe
+ if(this.iframe){
+ dijit._frames.push(this.iframe);
+ delete this.iframe;
+ }
+ }
+});
+
+}
+
+if(!dojo._hasResource["dijit._base.scroll"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.scroll"] = true;
+dojo.provide("dijit._base.scroll");
+
+dijit.scrollIntoView = function(/* DomNode */node){
+ // summary
+ // Scroll the passed node into view, if it is not.
+
+ // don't rely on that node.scrollIntoView works just because the function is there
+ // it doesnt work in Konqueror or Opera even though the function is there and probably
+ // not safari either
+ // native scrollIntoView() causes FF3's whole window to scroll if there is no scroll bar
+ // on the immediate parent
+ // dont like browser sniffs implementations but sometimes you have to use it
+ // #6146: IE scrollIntoView is broken
+ // It's not enough just to scroll the menu node into view if
+ // node.scrollIntoView hides part of the parent's scrollbar,
+ // so just manage the parent scrollbar ourselves
+ var parent = node.parentNode;
+ var parentBottom = parent.scrollTop + dojo.marginBox(parent).h; //PORT was getBorderBox
+ var nodeBottom = node.offsetTop + dojo.marginBox(node).h;
+ if(parentBottom < nodeBottom){
+ parent.scrollTop += (nodeBottom - parentBottom);
+ }else if(parent.scrollTop > node.offsetTop){
+ parent.scrollTop -= (parent.scrollTop - node.offsetTop);
+ }
+};
+
+}
+
+if(!dojo._hasResource["dijit._base.sniff"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.sniff"] = true;
+dojo.provide("dijit._base.sniff");
+
+// ported from dojo.html.applyBrowserClass (style.js)
+
+// summary:
+// Applies pre-set class names based on browser & version to the
+// top-level HTML node. Simply doing a require on this module will
+// establish this CSS. Modified version of Morris' CSS hack.
+(function(){
+ var d = dojo;
+ var ie = d.isIE;
+ var opera = d.isOpera;
+ var maj = Math.floor;
+ var ff = d.isFF;
+ var classes = {
+ dj_ie: ie,
+// dj_ie55: ie == 5.5,
+ dj_ie6: maj(ie) == 6,
+ dj_ie7: maj(ie) == 7,
+ dj_iequirks: ie && d.isQuirks,
+// NOTE: Opera not supported by dijit
+ dj_opera: opera,
+ dj_opera8: maj(opera) == 8,
+ dj_opera9: maj(opera) == 9,
+ dj_khtml: d.isKhtml,
+ dj_safari: d.isSafari,
+ dj_gecko: d.isMozilla,
+ dj_ff2: maj(ff) == 2
+ }; // no dojo unsupported browsers
+
+ for(var p in classes){
+ if(classes[p]){
+ var html = dojo.doc.documentElement; //TODO browser-specific DOM magic needed?
+ if(html.className){
+ html.className += " " + p;
+ }else{
+ html.className = p;
+ }
+ }
+ }
+})();
+
+}
+
+if(!dojo._hasResource["dijit._base.bidi"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.bidi"] = true;
+dojo.provide("dijit._base.bidi");
+
+// summary: applies a class to the top of the document for right-to-left stylesheet rules
+
+dojo.addOnLoad(function(){
+ if(!dojo._isBodyLtr()){
+ dojo.addClass(dojo.body(), "dijitRtl");
+ }
+});
+
+}
+
+if(!dojo._hasResource["dijit._base.typematic"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.typematic"] = true;
+dojo.provide("dijit._base.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);
+ this._currentTimeout = (this._currentTimeout < 0) ? this._initialDelay : ((this._subsequentDelay > 1) ? this._subsequentDelay : Math.round(this._currentTimeout * this._subsequentDelay));
+ this._timer = setTimeout(dojo.hitch(this, "_fireEventAndReload"), this._currentTimeout);
+ },
+
+ trigger: function(/*Event*/ evt, /* Object */ _this, /*DOMNode*/ node, /* Function */ callback, /* Object */ obj, /* Number */ subsequentDelay, /* Number */ initialDelay){
+ // 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.
+ // Parameters:
+ // 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
+ if(obj != this._obj){
+ this.stop();
+ this._initialDelay = initialDelay || 500;
+ this._subsequentDelay = subsequentDelay || 0.90;
+ this._obj = obj;
+ this._evt = evt;
+ this._node = node;
+ this._currentTimeout = -1;
+ this._count = -1;
+ this._callback = dojo.hitch(_this, callback);
+ 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){
+ // summary: Start listening for a specific typematic key.
+ // keyObject: an object defining the key to listen for.
+ // key: (mandatory) the keyCode (number) or character (string) to listen for.
+ // ctrlKey: desired ctrl key state to initiate the calback 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
+ // See the trigger method for other parameters.
+ // Returns an array of dojo.connect handles
+ return [
+ dojo.connect(node, "onkeypress", this, function(evt){
+ if(evt.keyCode == keyObject.keyCode && (!keyObject.charCode || keyObject.charCode == evt.charCode) &&
+ (keyObject.ctrlKey === undefined || keyObject.ctrlKey == evt.ctrlKey) &&
+ (keyObject.altKey === undefined || keyObject.altKey == evt.ctrlKey) &&
+ (keyObject.shiftKey === undefined || keyObject.shiftKey == evt.ctrlKey)){
+ dojo.stopEvent(evt);
+ dijit.typematic.trigger(keyObject, _this, node, callback, keyObject, subsequentDelay, initialDelay);
+ }else if(dijit.typematic._obj == keyObject){
+ dijit.typematic.stop();
+ }
+ }),
+ dojo.connect(node, "onkeyup", this, function(evt){
+ if(dijit.typematic._obj == keyObject){
+ dijit.typematic.stop();
+ }
+ })
+ ];
+ },
+
+ addMouseListener: function(/*DOMNode*/ node, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay){
+ // summary: Start listening for a typematic mouse click.
+ // See the trigger method for other parameters.
+ // Returns an array of dojo.connect handles
+ var dc = dojo.connect;
+ return [
+ dc(node, "mousedown", this, function(evt){
+ dojo.stopEvent(evt);
+ dijit.typematic.trigger(evt, _this, node, callback, node, subsequentDelay, initialDelay);
+ }),
+ dc(node, "mouseup", this, function(evt){
+ dojo.stopEvent(evt);
+ dijit.typematic.stop();
+ }),
+ dc(node, "mouseout", this, function(evt){
+ dojo.stopEvent(evt);
+ dijit.typematic.stop();
+ }),
+ dc(node, "mousemove", this, function(evt){
+ dojo.stopEvent(evt);
+ }),
+ dc(node, "dblclick", this, function(evt){
+ dojo.stopEvent(evt);
+ if(dojo.isIE){
+ dijit.typematic.trigger(evt, _this, node, callback, node, subsequentDelay, initialDelay);
+ setTimeout(dojo.hitch(this, dijit.typematic.stop), 50);
+ }
+ })
+ ];
+ },
+
+ addListener: function(/*Node*/ mouseNode, /*Node*/ keyNode, /*Object*/ keyObject, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay){
+ // summary: Start listening for a specific typematic key and mouseclick.
+ // This is a thin wrapper to addKeyListener and addMouseListener.
+ // mouseNode: the DOM node object to listen on for mouse events.
+ // keyNode: the DOM node object to listen on for key events.
+ // See the addMouseListener and addKeyListener methods for other parameters.
+ // Returns an array of dojo.connect handles
+ return this.addKeyListener(keyNode, keyObject, _this, callback, subsequentDelay, initialDelay).concat(
+ this.addMouseListener(mouseNode, _this, callback, subsequentDelay, initialDelay));
+ }
+};
+
+}
+
+if(!dojo._hasResource["dijit._base.wai"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.wai"] = true;
+dojo.provide("dijit._base.wai");
+
+dijit.wai = {
+ onload: function(){
+ // summary:
+ // Detects if we are in high-contrast mode or not
+
+ // This must be a named function and not an anonymous
+ // function, so that the widget parsing code can make sure it
+ // registers its onload function after this function.
+ // DO NOT USE "this" within this function.
+
+ // create div for testing if high contrast mode is on or images are turned off
+ var div = dojo.doc.createElement("div");
+ div.id = "a11yTestNode";
+ div.style.cssText = 'border: 1px solid;'
+ + 'border-color:red green;'
+ + 'position: absolute;'
+ + 'height: 5px;'
+ + 'top: -999px;'
+ + 'background-image: url("' + dojo.moduleUrl("dojo", "resources/blank.gif") + '");';
+ dojo.body().appendChild(div);
+
+ // test it
+ var cs = dojo.getComputedStyle(div);
+ if(cs){
+ var bkImg = cs.backgroundImage;
+ var needsA11y = (cs.borderTopColor==cs.borderRightColor) || (bkImg != null && (bkImg == "none" || bkImg == "url(invalid-url:)" ));
+ dojo[needsA11y ? "addClass" : "removeClass"](dojo.body(), "dijit_a11y");
+ dojo.body().removeChild(div);
+ }
+ }
+};
+
+// Test if computer is in high contrast mode.
+// Make sure the a11y test runs first, before widgets are instantiated.
+if(dojo.isIE || dojo.isMoz){ // NOTE: checking in Safari messes things up
+ dojo._loaders.unshift(dijit.wai.onload);
+}
+
+dojo.mixin(dijit,
+{
+ hasWaiRole: function(/*Element*/ elem){
+ // summary: Determines if an element has a role.
+ // returns: true if elem has a role attribute and false if not.
+ return elem.hasAttribute ? elem.hasAttribute("role") : !!elem.getAttribute("role");
+ },
+
+ getWaiRole: function(/*Element*/ elem){
+ // summary: Gets the role for an element.
+ // returns:
+ // The role of elem or an empty string if elem
+ // does not have a role.
+ var value = elem.getAttribute("role");
+ if(value){
+ var prefixEnd = value.indexOf(":");
+ return prefixEnd == -1 ? value : value.substring(prefixEnd+1);
+ }else{
+ return "";
+ }
+ },
+
+ setWaiRole: function(/*Element*/ elem, /*String*/ role){
+ // summary: Sets the role on an element.
+ // description:
+ // On Firefox 2 and below, "wairole:" is
+ // prepended to the provided role value.
+ elem.setAttribute("role", (dojo.isFF && dojo.isFF < 3) ? "wairole:" + role : role);
+ },
+
+ removeWaiRole: function(/*Element*/ elem){
+ // summary: Removes the role from an element.
+ elem.removeAttribute("role");
+ },
+
+ hasWaiState: function(/*Element*/ elem, /*String*/ state){
+ // summary: Determines if an element has a given state.
+ // description:
+ // On Firefox 2 and below, we check for an attribute in namespace
+ // "http://www.w3.org/2005/07/aaa" with a name of the given state.
+ // On all other browsers, we check for an attribute
+ // called "aria-"+state.
+ // returns:
+ // true if elem has a value for the given state and
+ // false if it does not.
+ if(dojo.isFF && dojo.isFF < 3){
+ return elem.hasAttributeNS("http://www.w3.org/2005/07/aaa", state);
+ }else{
+ return elem.hasAttribute ? elem.hasAttribute("aria-"+state) : !!elem.getAttribute("aria-"+state);
+ }
+ },
+
+ getWaiState: function(/*Element*/ elem, /*String*/ state){
+ // summary: Gets the value of a state on an element.
+ // description:
+ // On Firefox 2 and below, we check for an attribute in namespace
+ // "http://www.w3.org/2005/07/aaa" with a name of the given state.
+ // On all other browsers, we check for an attribute called
+ // "aria-"+state.
+ // returns:
+ // The value of the requested state on elem
+ // or an empty string if elem has no value for state.
+ if(dojo.isFF && dojo.isFF < 3){
+ return elem.getAttributeNS("http://www.w3.org/2005/07/aaa", state);
+ }else{
+ var value = elem.getAttribute("aria-"+state);
+ return value ? value : "";
+ }
+ },
+
+ setWaiState: function(/*Element*/ elem, /*String*/ state, /*String*/ value){
+ // summary: Sets a state on an element.
+ // description:
+ // On Firefox 2 and below, we set an attribute in namespace
+ // "http://www.w3.org/2005/07/aaa" with a name of the given state.
+ // On all other browsers, we set an attribute called
+ // "aria-"+state.
+ if(dojo.isFF && dojo.isFF < 3){
+ elem.setAttributeNS("http://www.w3.org/2005/07/aaa",
+ "aaa:"+state, value);
+ }else{
+ elem.setAttribute("aria-"+state, value);
+ }
+ },
+
+ removeWaiState: function(/*Element*/ elem, /*String*/ state){
+ // summary: Removes a state from an element.
+ // description:
+ // On Firefox 2 and below, we remove the attribute in namespace
+ // "http://www.w3.org/2005/07/aaa" with a name of the given state.
+ // On all other browsers, we remove the attribute called
+ // "aria-"+state.
+ if(dojo.isFF && dojo.isFF < 3){
+ elem.removeAttributeNS("http://www.w3.org/2005/07/aaa", state);
+ }else{
+ elem.removeAttribute("aria-"+state);
+ }
+ }
+});
+
+}
+
+if(!dojo._hasResource["dijit._base"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base"] = true;
+dojo.provide("dijit._base");
+
+
+
+
+
+
+
+
+
+
+
+
+// FIXME: Find a better way of solving this bug!
+if(dojo.isSafari){
+ // Ugly-ass hack to solve bug #5626 for 1.1; basically force Safari to re-layout.
+ // Note that we can't reliably use dojo.addOnLoad here because this bug is basically
+ // a timing / race condition; so instead we use window.onload.
+ dojo.connect(window, "load", function(){
+ window.resizeBy(1,0);
+ setTimeout(function(){ window.resizeBy(-1,0); }, 10);
+ });
+}
+
+}
+
+if(!dojo._hasResource["dojo.date.stamp"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo.date.stamp"] = true;
+dojo.provide("dojo.date.stamp");
+
+// Methods to convert dates to or from a wire (string) format using well-known conventions
+
+dojo.date.stamp.fromISOString = function(/*String*/formattedString, /*Number?*/defaultTime){
+ // summary:
+ // Returns a Date object given a string formatted according to a subset of the ISO-8601 standard.
+ //
+ // description:
+ // Accepts a string formatted according to a profile of ISO8601 as defined by
+ // [RFC3339](http://www.ietf.org/rfc/rfc3339.txt), except that partial input is allowed.
+ // Can also process dates as specified [by the W3C](http://www.w3.org/TR/NOTE-datetime)
+ // The following combinations are valid:
+ //
+ // * dates only
+ // | * yyyy
+ // | * yyyy-MM
+ // | * yyyy-MM-dd
+ // * times only, with an optional time zone appended
+ // | * THH:mm
+ // | * THH:mm:ss
+ // | * THH:mm:ss.SSS
+ // * and "datetimes" which could be any combination of the above
+ //
+ // timezones may be specified as Z (for UTC) or +/- followed by a time expression HH:mm
+ // Assumes the local time zone if not specified. Does not validate. Improperly formatted
+ // input may return null. Arguments which are out of bounds will be handled
+ // by the Date constructor (e.g. January 32nd typically gets resolved to February 1st)
+ // Only years between 100 and 9999 are supported.
+ //
+ // formattedString:
+ // A string such as 2005-06-30T08:05:00-07:00 or 2005-06-30 or T08:05:00
+ //
+ // defaultTime:
+ // Used for defaults for fields omitted in the formattedString.
+ // Uses 1970-01-01T00:00:00.0Z by default.
+
+ if(!dojo.date.stamp._isoRegExp){
+ dojo.date.stamp._isoRegExp =
+//TODO: could be more restrictive and check for 00-59, etc.
+ /^(?:(\d{4})(?:-(\d{2})(?:-(\d{2}))?)?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(.\d+)?)?((?:[+-](\d{2}):(\d{2}))|Z)?)?$/;
+ }
+
+ var match = dojo.date.stamp._isoRegExp.exec(formattedString);
+ var result = null;
+
+ if(match){
+ match.shift();
+ if(match[1]){match[1]--;} // Javascript Date months are 0-based
+ if(match[6]){match[6] *= 1000;} // Javascript Date expects fractional seconds as milliseconds
+
+ if(defaultTime){
+ // mix in defaultTime. Relatively expensive, so use || operators for the fast path of defaultTime === 0
+ defaultTime = new Date(defaultTime);
+ dojo.map(["FullYear", "Month", "Date", "Hours", "Minutes", "Seconds", "Milliseconds"], function(prop){
+ return defaultTime["get" + prop]();
+ }).forEach(function(value, index){
+ if(match[index] === undefined){
+ match[index] = value;
+ }
+ });
+ }
+ result = new Date(match[0]||1970, match[1]||0, match[2]||1, match[3]||0, match[4]||0, match[5]||0, match[6]||0);
+// result.setFullYear(match[0]||1970); // for year < 100
+
+ var offset = 0;
+ var zoneSign = match[7] && match[7].charAt(0);
+ if(zoneSign != 'Z'){
+ offset = ((match[8] || 0) * 60) + (Number(match[9]) || 0);
+ if(zoneSign != '-'){ offset *= -1; }
+ }
+ if(zoneSign){
+ offset -= result.getTimezoneOffset();
+ }
+ if(offset){
+ result.setTime(result.getTime() + offset * 60000);
+ }
+ }
+
+ return result; // Date or null
+}
+
+/*=====
+ dojo.date.stamp.__Options = function(){
+ // selector: String
+ // "date" or "time" for partial formatting of the Date object.
+ // Both date and time will be formatted by default.
+ // zulu: Boolean
+ // if true, UTC/GMT is used for a timezone
+ // milliseconds: Boolean
+ // if true, output milliseconds
+ this.selector = selector;
+ this.zulu = zulu;
+ this.milliseconds = milliseconds;
+ }
+=====*/
+
+dojo.date.stamp.toISOString = function(/*Date*/dateObject, /*dojo.date.stamp.__Options?*/options){
+ // summary:
+ // Format a Date object as a string according a subset of the ISO-8601 standard
+ //
+ // description:
+ // When options.selector is omitted, output follows [RFC3339](http://www.ietf.org/rfc/rfc3339.txt)
+ // The local time zone is included as an offset from GMT, except when selector=='time' (time without a date)
+ // Does not check bounds. Only years between 100 and 9999 are supported.
+ //
+ // dateObject:
+ // A Date object
+
+ var _ = function(n){ return (n < 10) ? "0" + n : n; };
+ options = options || {};
+ var formattedDate = [];
+ var getter = options.zulu ? "getUTC" : "get";
+ var date = "";
+ if(options.selector != "time"){
+ var year = dateObject[getter+"FullYear"]();
+ date = ["0000".substr((year+"").length)+year, _(dateObject[getter+"Month"]()+1), _(dateObject[getter+"Date"]())].join('-');
+ }
+ formattedDate.push(date);
+ if(options.selector != "date"){
+ var time = [_(dateObject[getter+"Hours"]()), _(dateObject[getter+"Minutes"]()), _(dateObject[getter+"Seconds"]())].join(':');
+ var millis = dateObject[getter+"Milliseconds"]();
+ if(options.milliseconds){
+ time += "."+ (millis < 100 ? "0" : "") + _(millis);
+ }
+ if(options.zulu){
+ time += "Z";
+ }else if(options.selector != "time"){
+ var timezoneOffset = dateObject.getTimezoneOffset();
+ var absOffset = Math.abs(timezoneOffset);
+ time += (timezoneOffset > 0 ? "-" : "+") +
+ _(Math.floor(absOffset/60)) + ":" + _(absOffset%60);
+ }
+ formattedDate.push(time);
+ }
+ return formattedDate.join('T'); // String
+}
+
+}
+
+if(!dojo._hasResource["dojo.parser"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo.parser"] = true;
+dojo.provide("dojo.parser");
+
+
+dojo.parser = new function(){
+ // summary: The Dom/Widget parsing package
+
+ var d = dojo;
+ var dtName = d._scopeName + "Type";
+ var qry = "[" + dtName + "]";
+
+ function val2type(/*Object*/ value){
+ // summary:
+ // Returns name of type of given value.
+
+ if(d.isString(value)){ return "string"; }
+ if(typeof value == "number"){ return "number"; }
+ if(typeof value == "boolean"){ return "boolean"; }
+ if(d.isFunction(value)){ return "function"; }
+ if(d.isArray(value)){ return "array"; } // typeof [] == "object"
+ if(value instanceof Date) { return "date"; } // assume timestamp
+ if(value instanceof d._Url){ return "url"; }
+ return "object";
+ }
+
+ function str2obj(/*String*/ value, /*String*/ type){
+ // summary:
+ // Convert given string value to given type
+ switch(type){
+ case "string":
+ return value;
+ case "number":
+ return value.length ? Number(value) : NaN;
+ case "boolean":
+ // for checked/disabled value might be "" or "checked". interpret as true.
+ return typeof value == "boolean" ? value : !(value.toLowerCase()=="false");
+ case "function":
+ if(d.isFunction(value)){
+ // IE gives us a function, even when we say something like onClick="foo"
+ // (in which case it gives us an invalid function "function(){ foo }").
+ // Therefore, convert to string
+ value=value.toString();
+ value=d.trim(value.substring(value.indexOf('{')+1, value.length-1));
+ }
+ try{
+ if(value.search(/[^\w\.]+/i) != -1){
+ // TODO: "this" here won't work
+ value = d.parser._nameAnonFunc(new Function(value), this);
+ }
+ return d.getObject(value, false);
+ }catch(e){ return new Function(); }
+ case "array":
+ return value.split(/\s*,\s*/);
+ case "date":
+ switch(value){
+ case "": return new Date(""); // the NaN of dates
+ case "now": return new Date(); // current date
+ default: return d.date.stamp.fromISOString(value);
+ }
+ case "url":
+ return d.baseUrl + value;
+ default:
+ return d.fromJson(value);
+ }
+ }
+
+ var instanceClasses = {
+ // map from fully qualified name (like "dijit.Button") to structure like
+ // { cls: dijit.Button, params: {label: "string", disabled: "boolean"} }
+ };
+
+ function getClassInfo(/*String*/ className){
+ // className:
+ // fully qualified name (like "dijit.Button")
+ // returns:
+ // structure like
+ // {
+ // cls: dijit.Button,
+ // params: { label: "string", disabled: "boolean"}
+ // }
+
+ if(!instanceClasses[className]){
+ // get pointer to widget class
+ var cls = d.getObject(className);
+ if(!d.isFunction(cls)){
+ throw new Error("Could not load class '" + className +
+ "'. Did you spell the name correctly and use a full path, like 'dijit.form.Button'?");
+ }
+ var proto = cls.prototype;
+
+ // get table of parameter names & types
+ var params={};
+ for(var name in proto){
+ if(name.charAt(0)=="_"){ continue; } // skip internal properties
+ var defVal = proto[name];
+ params[name]=val2type(defVal);
+ }
+
+ instanceClasses[className] = { cls: cls, params: params };
+ }
+ return instanceClasses[className];
+ }
+
+ this._functionFromScript = function(script){
+ var preamble = "";
+ var suffix = "";
+ var argsStr = script.getAttribute("args");
+ if(argsStr){
+ d.forEach(argsStr.split(/\s*,\s*/), function(part, idx){
+ preamble += "var "+part+" = arguments["+idx+"]; ";
+ });
+ }
+ var withStr = script.getAttribute("with");
+ if(withStr && withStr.length){
+ d.forEach(withStr.split(/\s*,\s*/), function(part){
+ preamble += "with("+part+"){";
+ suffix += "}";
+ });
+ }
+ return new Function(preamble+script.innerHTML+suffix);
+ }
+
+ this.instantiate = function(/* Array */nodes){
+ // summary:
+ // Takes array of nodes, and turns them into class instances and
+ // potentially calls a layout method to allow them to connect with
+ // any children
+ var thelist = [];
+ d.forEach(nodes, function(node){
+ if(!node){ return; }
+ var type = node.getAttribute(dtName);
+ if((!type)||(!type.length)){ return; }
+ var clsInfo = getClassInfo(type);
+ var clazz = clsInfo.cls;
+ var ps = clazz._noScript||clazz.prototype._noScript;
+
+ // read parameters (ie, attributes).
+ // clsInfo.params lists expected params like {"checked": "boolean", "n": "number"}
+ var params = {};
+ var attributes = node.attributes;
+ for(var name in clsInfo.params){
+ var item = attributes.getNamedItem(name);
+ if(!item || (!item.specified && (!dojo.isIE || name.toLowerCase()!="value"))){ continue; }
+ var value = item.value;
+ // Deal with IE quirks for 'class' and 'style'
+ switch(name){
+ case "class":
+ value = node.className;
+ break;
+ case "style":
+ value = node.style && node.style.cssText; // FIXME: Opera?
+ }
+ var _type = clsInfo.params[name];
+ params[name] = str2obj(value, _type);
+ }
+
+ // Process <script type="dojo/*"> script tags
+ // <script type="dojo/method" event="foo"> tags are added to params, and passed to
+ // the widget on instantiation.
+ // <script type="dojo/method"> tags (with no event) are executed after instantiation
+ // <script type="dojo/connect" event="foo"> tags are dojo.connected after instantiation
+ // note: dojo/* script tags cannot exist in self closing widgets, like <input />
+ if(!ps){
+ var connects = [], // functions to connect after instantiation
+ calls = []; // functions to call after instantiation
+
+ d.query("> script[type^='dojo/']", node).orphan().forEach(function(script){
+ var event = script.getAttribute("event"),
+ type = script.getAttribute("type"),
+ nf = d.parser._functionFromScript(script);
+ if(event){
+ if(type == "dojo/connect"){
+ connects.push({event: event, func: nf});
+ }else{
+ params[event] = nf;
+ }
+ }else{
+ calls.push(nf);
+ }
+ });
+ }
+
+ var markupFactory = clazz["markupFactory"];
+ if(!markupFactory && clazz["prototype"]){
+ markupFactory = clazz.prototype["markupFactory"];
+ }
+ // create the instance
+ var instance = markupFactory ? markupFactory(params, node, clazz) : new clazz(params, node);
+ thelist.push(instance);
+
+ // map it to the JS namespace if that makes sense
+ var jsname = node.getAttribute("jsId");
+ if(jsname){
+ d.setObject(jsname, instance);
+ }
+
+ // process connections and startup functions
+ if(!ps){
+ d.forEach(connects, function(connect){
+ d.connect(instance, connect.event, null, connect.func);
+ });
+ d.forEach(calls, function(func){
+ func.call(instance);
+ });
+ }
+ });
+
+ // Call startup on each top level instance if it makes sense (as for
+ // widgets). Parent widgets will recursively call startup on their
+ // (non-top level) children
+ d.forEach(thelist, function(instance){
+ if( instance &&
+ instance.startup &&
+ !instance._started &&
+ (!instance.getParent || !instance.getParent())
+ ){
+ instance.startup();
+ }
+ });
+ return thelist;
+ };
+
+ this.parse = function(/*DomNode?*/ rootNode){
+ // summary:
+ // Search specified node (or root node) recursively for class instances,
+ // and instantiate them Searches for
+ // dojoType="qualified.class.name"
+ var list = d.query(qry, rootNode);
+ // go build the object instances
+ var instances = this.instantiate(list);
+ return instances;
+ };
+}();
+
+//Register the parser callback. It should be the first callback
+//after the a11y test.
+
+(function(){
+ var parseRunner = function(){
+ if(dojo.config["parseOnLoad"] == true){
+ dojo.parser.parse();
+ }
+ };
+
+ // FIXME: need to clobber cross-dependency!!
+ if(dojo.exists("dijit.wai.onload") && (dijit.wai.onload === dojo._loaders[0])){
+ dojo._loaders.splice(1, 0, parseRunner);
+ }else{
+ dojo._loaders.unshift(parseRunner);
+ }
+})();
+
+//TODO: ported from 0.4.x Dojo. Can we reduce this?
+dojo.parser._anonCtr = 0;
+dojo.parser._anon = {}; // why is this property required?
+dojo.parser._nameAnonFunc = function(/*Function*/anonFuncPtr, /*Object*/thisObj){
+ // summary:
+ // Creates a reference to anonFuncPtr in thisObj with a completely
+ // unique name. The new name is returned as a String.
+ var jpn = "$joinpoint";
+ var nso = (thisObj|| dojo.parser._anon);
+ if(dojo.isIE){
+ var cn = anonFuncPtr["__dojoNameCache"];
+ if(cn && nso[cn] === anonFuncPtr){
+ return anonFuncPtr["__dojoNameCache"];
+ }
+ }
+ var ret = "__"+dojo.parser._anonCtr++;
+ while(typeof nso[ret] != "undefined"){
+ ret = "__"+dojo.parser._anonCtr++;
+ }
+ nso[ret] = anonFuncPtr;
+ return ret; // String
+}
+
+}
+
+if(!dojo._hasResource["dijit._Widget"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._Widget"] = true;
+dojo.provide("dijit._Widget");
+
+dojo.require( "dijit._base" );
+
+dojo.declare("dijit._Widget", null, {
+ // summary:
+ // The foundation of dijit widgets.
+ //
+ // id: String
+ // a unique, opaque ID string that can be assigned by users or by the
+ // system. If the developer passes an ID which is known not to be
+ // unique, the specified ID is ignored and the system-generated ID is
+ // used instead.
+ id: "",
+
+ // lang: String
+ // Rarely used. Overrides the default Dojo locale used to render this widget,
+ // as defined by the [HTML LANG](http://www.w3.org/TR/html401/struct/dirlang.html#adef-lang) attribute.
+ // Value must be among the list of locales specified during by the Dojo bootstrap,
+ // formatted according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt) (like en-us).
+ lang: "",
+
+ // dir: String
+ // Unsupported by Dijit, but here for completeness. Dijit only supports setting text direction on the
+ // entire document.
+ // Bi-directional support, as defined by the [HTML DIR](http://www.w3.org/TR/html401/struct/dirlang.html#adef-dir)
+ // attribute. Either left-to-right "ltr" or right-to-left "rtl".
+ dir: "",
+
+ // class: String
+ // HTML class attribute
+ "class": "",
+
+ // style: String
+ // HTML style attribute
+ style: "",
+
+ // title: String
+ // HTML title attribute
+ title: "",
+
+ // srcNodeRef: DomNode
+ // pointer to original dom node
+ srcNodeRef: null,
+
+ // domNode: DomNode
+ // this is our visible representation of the widget! Other DOM
+ // Nodes may by assigned to other properties, usually through the
+ // template system's dojoAttachPonit syntax, but the domNode
+ // property is the canonical "top level" node in widget UI.
+ domNode: null,
+
+ // attributeMap: Object
+ // A map of attributes and attachpoints -- typically standard HTML attributes -- to set
+ // on the widget's dom, at the "domNode" attach point, by default.
+ // Other node references can be specified as properties of 'this'
+ attributeMap: {id:"", dir:"", lang:"", "class":"", style:"", title:""}, // TODO: add on* handlers?
+
+ //////////// INITIALIZATION METHODS ///////////////////////////////////////
+//TODOC: params and srcNodeRef need docs. Is srcNodeRef optional?
+//TODOC: summary needed for postscript
+ postscript: function(/*Object?*/params, /*DomNode|String*/srcNodeRef){
+ this.create(params, srcNodeRef);
+ },
+
+ create: function(/*Object?*/params, /*DomNode|String*/srcNodeRef){
+ // summary:
+ // Kick off the life-cycle of a widget
+ // description:
+ // To understand the process by which widgets are instantiated, it
+ // is critical to understand what other methods create calls and
+ // which of them you'll want to override. Of course, adventurous
+ // developers could override create entirely, but this should
+ // only be done as a last resort.
+ //
+ // Below is a list of the methods that are called, in the order
+ // they are fired, along with notes about what they do and if/when
+ // you should over-ride them in your widget:
+ //
+ // * postMixInProperties:
+ // | * a stub function that you can over-ride to modify
+ // variables that may have been naively assigned by
+ // mixInProperties
+ // * widget is added to manager object here
+ // * buildRendering:
+ // | * Subclasses use this method to handle all UI initialization
+ // Sets this.domNode. Templated widgets do this automatically
+ // and otherwise it just uses the source dom node.
+ // * postCreate:
+ // | * a stub function that you can over-ride to modify take
+ // actions once the widget has been placed in the UI
+
+ // store pointer to original dom tree
+ this.srcNodeRef = dojo.byId(srcNodeRef);
+
+ // For garbage collection. An array of handles returned by Widget.connect()
+ // Each handle returned from Widget.connect() is an array of handles from dojo.connect()
+ this._connects=[];
+
+ // _attaches: String[]
+ // names of all our dojoAttachPoint variables
+ this._attaches=[];
+
+ //mixin our passed parameters
+ if(this.srcNodeRef && (typeof this.srcNodeRef.id == "string")){ this.id = this.srcNodeRef.id; }
+ if(params){
+ this.params = params;
+ dojo.mixin(this,params);
+ }
+ this.postMixInProperties();
+
+ // generate an id for the widget if one wasn't specified
+ // (be sure to do this before buildRendering() because that function might
+ // expect the id to be there.
+ if(!this.id){
+ this.id=dijit.getUniqueId(this.declaredClass.replace(/\./g,"_"));
+ }
+ dijit.registry.add(this);
+
+ this.buildRendering();
+
+ // Copy attributes listed in attributeMap into the [newly created] DOM for the widget.
+ // The placement of these attributes is according to the property mapping in attributeMap.
+ // Note special handling for 'style' and 'class' attributes which are lists and can
+ // have elements from both old and new structures, and some attributes like "type"
+ // cannot be processed this way as they are not mutable.
+ if(this.domNode){
+ for(var attr in this.attributeMap){
+ var value = this[attr];
+ if(typeof value != "object" && ((value !== "" && value !== false) || (params && params[attr]))){
+ this.setAttribute(attr, value);
+ }
+ }
+ }
+
+ if(this.domNode){
+ this.domNode.setAttribute("widgetId", this.id);
+ }
+ this.postCreate();
+
+ // If srcNodeRef has been processed and removed from the DOM (e.g. TemplatedWidget) then delete it to allow GC.
+ if(this.srcNodeRef && !this.srcNodeRef.parentNode){
+ delete this.srcNodeRef;
+ }
+ },
+
+ postMixInProperties: function(){
+ // summary
+ // Called after the parameters to the widget have been read-in,
+ // but before the widget template is instantiated.
+ // Especially useful to set properties that are referenced in the widget template.
+ },
+
+ buildRendering: function(){
+ // summary:
+ // Construct the UI for this widget, setting this.domNode.
+ // Most widgets will mixin TemplatedWidget, which overrides this method.
+ this.domNode = this.srcNodeRef || dojo.doc.createElement('div');
+ },
+
+ postCreate: function(){
+ // summary:
+ // Called after a widget's dom has been setup
+ },
+
+ startup: function(){
+ // summary:
+ // Called after a widget's children, and other widgets on the page, have been created.
+ // Provides an opportunity to manipulate any children before they are displayed.
+ // This is useful for composite widgets that need to control or layout sub-widgets.
+ // Many layout widgets can use this as a wiring phase.
+ this._started = true;
+ },
+
+ //////////// DESTROY FUNCTIONS ////////////////////////////////
+
+ destroyRecursive: function(/*Boolean*/ finalize){
+ // summary:
+ // Destroy this widget and it's descendants. This is the generic
+ // "destructor" function that all widget users should call to
+ // cleanly discard with a widget. Once a widget is destroyed, it's
+ // removed from the manager object.
+ // finalize: Boolean
+ // is this function being called part of global environment
+ // tear-down?
+
+ this.destroyDescendants();
+ this.destroy();
+ },
+
+ destroy: function(/*Boolean*/ finalize){
+ // summary:
+ // Destroy this widget, but not its descendants
+ // finalize: Boolean
+ // is this function being called part of global environment
+ // tear-down?
+
+ this.uninitialize();
+ dojo.forEach(this._connects, function(array){
+ dojo.forEach(array, dojo.disconnect);
+ });
+
+ // destroy widgets created as part of template, etc.
+ dojo.forEach(this._supportingWidgets || [], function(w){ w.destroy(); });
+
+ this.destroyRendering(finalize);
+ dijit.registry.remove(this.id);
+ },
+
+ destroyRendering: function(/*Boolean*/ finalize){
+ // summary:
+ // Destroys the DOM nodes associated with this widget
+ // finalize: Boolean
+ // is this function being called part of global environment
+ // tear-down?
+
+ if(this.bgIframe){
+ this.bgIframe.destroy();
+ delete this.bgIframe;
+ }
+
+ if(this.domNode){
+ dojo._destroyElement(this.domNode);
+ delete this.domNode;
+ }
+
+ if(this.srcNodeRef){
+ dojo._destroyElement(this.srcNodeRef);
+ delete this.srcNodeRef;
+ }
+ },
+
+ destroyDescendants: function(){
+ // summary:
+ // Recursively destroy the children of this widget and their
+ // descendants.
+
+ // TODO: should I destroy in the reverse order, to go bottom up?
+ dojo.forEach(this.getDescendants(), function(widget){ widget.destroy(); });
+ },
+
+ uninitialize: function(){
+ // summary:
+ // stub function. Override to implement custom widget tear-down
+ // behavior.
+ return false;
+ },
+
+ ////////////////// MISCELLANEOUS METHODS ///////////////////
+
+ onFocus: function(){
+ // summary:
+ // stub function. Override or connect to this method to receive
+ // notifications for when the widget moves into focus.
+ },
+
+ onBlur: function(){
+ // summary:
+ // stub function. Override or connect to this method to receive
+ // notifications for when the widget moves out of focus.
+ },
+
+ _onFocus: function(e){
+ this.onFocus();
+ },
+
+ _onBlur: function(){
+ this.onBlur();
+ },
+
+ setAttribute: function(/*String*/ attr, /*anything*/ value){
+ // summary
+ // Set native HTML attributes reflected in the widget,
+ // such as readOnly, disabled, and maxLength in TextBox widgets.
+ // description
+ // In general, a widget's "value" is controlled via setValue()/getValue(),
+ // rather than this method. The exception is for widgets where the
+ // end user can't adjust the value, such as Button and CheckBox;
+ // in the unusual case that you want to change the value attribute of
+ // those widgets, use setAttribute().
+ var mapNode = this[this.attributeMap[attr]||'domNode'];
+ this[attr] = value;
+ switch(attr){
+ case "class":
+ dojo.addClass(mapNode, value);
+ break;
+ case "style":
+ if(mapNode.style.cssText){
+ mapNode.style.cssText += "; " + value;// FIXME: Opera
+ }else{
+ mapNode.style.cssText = value;
+ }
+ break;
+ default:
+ if(/^on[A-Z]/.test(attr)){ // eg. onSubmit needs to be onsubmit
+ attr = attr.toLowerCase();
+ }
+ if(typeof value == "function"){ // functions execute in the context of the widget
+ value = dojo.hitch(this, value);
+ }
+ dojo.attr(mapNode, attr, value);
+ }
+ },
+
+ toString: function(){
+ // summary:
+ // returns a string that represents the widget. When a widget is
+ // cast to a string, this method will be used to generate the
+ // output. Currently, it does not implement any sort of reversable
+ // serialization.
+ return '[Widget ' + this.declaredClass + ', ' + (this.id || 'NO ID') + ']'; // String
+ },
+
+ getDescendants: function(){
+ // summary:
+ // Returns all the widgets that contained by this, i.e., all widgets underneath this.containerNode.
+ if(this.containerNode){
+ var list= dojo.query('[widgetId]', this.containerNode);
+ return list.map(dijit.byNode); // Array
+ }else{
+ return [];
+ }
+ },
+
+//TODOC
+ nodesWithKeyClick: ["input", "button"],
+
+ connect: function(
+ /*Object|null*/ obj,
+ /*String*/ event,
+ /*String|Function*/ method){
+ // summary:
+ // Connects specified obj/event to specified method of this object
+ // and registers for disconnect() on widget destroy.
+ // Special event: "ondijitclick" triggers on a click or enter-down or space-up
+ // Similar to dojo.connect() but takes three arguments rather than four.
+ var handles =[];
+ if(event == "ondijitclick"){
+ // add key based click activation for unsupported nodes.
+ if(!this.nodesWithKeyClick[obj.nodeName]){
+ handles.push(dojo.connect(obj, "onkeydown", this,
+ function(e){
+ if(e.keyCode == dojo.keys.ENTER){
+ return (dojo.isString(method))?
+ this[method](e) : method.call(this, e);
+ }else if(e.keyCode == dojo.keys.SPACE){
+ // stop space down as it causes IE to scroll
+ // the browser window
+ dojo.stopEvent(e);
+ }
+ }));
+ handles.push(dojo.connect(obj, "onkeyup", this,
+ function(e){
+ if(e.keyCode == dojo.keys.SPACE){
+ return dojo.isString(method) ?
+ this[method](e) : method.call(this, e);
+ }
+ }));
+ }
+ event = "onclick";
+ }
+ handles.push(dojo.connect(obj, event, this, method));
+
+ // return handles for FormElement and ComboBox
+ this._connects.push(handles);
+ return handles;
+ },
+
+ disconnect: function(/*Object*/ handles){
+ // summary:
+ // Disconnects handle created by this.connect.
+ // Also removes handle from this widget's list of connects
+ for(var i=0; i<this._connects.length; i++){
+ if(this._connects[i]==handles){
+ dojo.forEach(handles, dojo.disconnect);
+ this._connects.splice(i, 1);
+ return;
+ }
+ }
+ },
+
+ isLeftToRight: function(){
+ // summary:
+ // Checks the DOM to for the text direction for bi-directional support
+ // description:
+ // This method cannot be used during widget construction because the widget
+ // must first be connected to the DOM tree. Parent nodes are searched for the
+ // 'dir' attribute until one is found, otherwise left to right mode is assumed.
+ // See HTML spec, DIR attribute for more information.
+
+ if(!("_ltr" in this)){
+ this._ltr = dojo.getComputedStyle(this.domNode).direction != "rtl";
+ }
+ return this._ltr; //Boolean
+ },
+
+ isFocusable: function(){
+ // summary:
+ // Return true if this widget can currently be focused
+ // and false if not
+ return this.focus && (dojo.style(this.domNode, "display") != "none");
+ }
+});
+
+}
+
+if(!dojo._hasResource["dojo.string"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo.string"] = true;
+dojo.provide("dojo.string");
+
+/*=====
+dojo.string = {
+ // summary: String utilities for Dojo
+};
+=====*/
+
+dojo.string.pad = function(/*String*/text, /*int*/size, /*String?*/ch, /*boolean?*/end){
+ // summary:
+ // Pad a string to guarantee that it is at least `size` length by
+ // filling with the character `ch` at either the start or end of the
+ // string. Pads at the start, by default.
+ // text: the string to pad
+ // size: length to provide padding
+ // ch: character to pad, defaults to '0'
+ // end: adds padding at the end if true, otherwise pads at start
+
+ var out = String(text);
+ if(!ch){
+ ch = '0';
+ }
+ while(out.length < size){
+ if(end){
+ out += ch;
+ }else{
+ out = ch + out;
+ }
+ }
+ return out; // String
+};
+
+dojo.string.substitute = function( /*String*/template,
+ /*Object|Array*/map,
+ /*Function?*/transform,
+ /*Object?*/thisObject){
+ // summary:
+ // Performs parameterized substitutions on a string. Throws an
+ // exception if any parameter is unmatched.
+ // description:
+ // For example,
+ // | dojo.string.substitute("File '${0}' is not found in directory '${1}'.",["foo.html","/temp"]);
+ // | dojo.string.substitute("File '${name}' is not found in directory '${info.dir}'.",
+ // | {name: "foo.html", info: {dir: "/temp"}});
+ // both return
+ // | "File 'foo.html' is not found in directory '/temp'."
+ // template:
+ // a string with expressions in the form `${key}` to be replaced or
+ // `${key:format}` which specifies a format function.
+ // map: hash to search for substitutions
+ // transform:
+ // a function to process all parameters before substitution takes
+ // place, e.g. dojo.string.encodeXML
+ // thisObject:
+ // where to look for optional format function; default to the global
+ // namespace
+
+ return template.replace(/\$\{([^\s\:\}]+)(?:\:([^\s\:\}]+))?\}/g, function(match, key, format){
+ var value = dojo.getObject(key,false,map);
+ if(format){ value = dojo.getObject(format,false,thisObject)(value);}
+ if(transform){ value = transform(value, key); }
+ return value.toString();
+ }); // string
+};
+
+dojo.string.trim = function(/*String*/ str){
+ // summary: trims whitespaces from both sides of the string
+ // description:
+ // This version of trim() was taken from [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript).
+ // The short yet performant version of this function is
+ // dojo.trim(), which is part of Dojo base.
+ str = str.replace(/^\s+/, '');
+ for(var i = str.length - 1; i > 0; i--){
+ if(/\S/.test(str.charAt(i))){
+ str = str.substring(0, i + 1);
+ break;
+ }
+ }
+ return str; // String
+};
+
+}
+
+if(!dojo._hasResource["dijit._Templated"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._Templated"] = true;
+dojo.provide("dijit._Templated");
+
+
+
+
+
+dojo.declare("dijit._Templated",
+ null,
+ {
+ // summary:
+ // Mixin for widgets that are instantiated from a template
+ //
+ // templateNode: DomNode
+ // a node that represents the widget template. Pre-empts both templateString and templatePath.
+ templateNode: null,
+
+ // templateString: String
+ // a string that represents the widget template. Pre-empts the
+ // templatePath. In builds that have their strings "interned", the
+ // templatePath is converted to an inline templateString, thereby
+ // preventing a synchronous network call.
+ templateString: null,
+
+ // templatePath: String
+ // Path to template (HTML file) for this widget relative to dojo.baseUrl
+ templatePath: null,
+
+ // widgetsInTemplate: Boolean
+ // should we parse the template to find widgets that might be
+ // declared in markup inside it? false by default.
+ widgetsInTemplate: false,
+
+ // containerNode: DomNode
+ // holds child elements. "containerNode" is generally set via a
+ // dojoAttachPoint assignment and it designates where children of
+ // the src dom node will be placed
+ containerNode: null,
+
+ // skipNodeCache: Boolean
+ // if using a cached widget template node poses issues for a
+ // particular widget class, it can set this property to ensure
+ // that its template is always re-built from a string
+ _skipNodeCache: false,
+
+ _stringRepl: function(tmpl){
+ var className = this.declaredClass, _this = this;
+ // Cache contains a string because we need to do property replacement
+ // do the property replacement
+ return dojo.string.substitute(tmpl, this, function(value, key){
+ if(key.charAt(0) == '!'){ value = _this[key.substr(1)]; }
+ if(typeof value == "undefined"){ throw new Error(className+" template:"+key); } // a debugging aide
+ if(!value){ return ""; }
+
+ // Substitution keys beginning with ! will skip the transform step,
+ // in case a user wishes to insert unescaped markup, e.g. ${!foo}
+ return key.charAt(0) == "!" ? value :
+ // Safer substitution, see heading "Attribute values" in
+ // http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.3.2
+ value.toString().replace(/"/g,"""); //TODO: add &? use encodeXML method?
+ }, this);
+ },
+
+ // method over-ride
+ buildRendering: function(){
+ // summary:
+ // Construct the UI for this widget from a template, setting this.domNode.
+
+ // Lookup cached version of template, and download to cache if it
+ // isn't there already. Returns either a DomNode or a string, depending on
+ // whether or not the template contains ${foo} replacement parameters.
+ var cached = dijit._Templated.getCachedTemplate(this.templatePath, this.templateString, this._skipNodeCache);
+
+ var node;
+ if(dojo.isString(cached)){
+ node = dijit._Templated._createNodesFromText(this._stringRepl(cached))[0];
+ }else{
+ // if it's a node, all we have to do is clone it
+ node = cached.cloneNode(true);
+ }
+
+ // recurse through the node, looking for, and attaching to, our
+ // attachment points which should be defined on the template node.
+ this._attachTemplateNodes(node);
+
+ var source = this.srcNodeRef;
+ if(source && source.parentNode){
+ source.parentNode.replaceChild(node, source);
+ }
+
+ this.domNode = node;
+ if(this.widgetsInTemplate){
+ var cw = this._supportingWidgets = dojo.parser.parse(node);
+ this._attachTemplateNodes(cw, function(n,p){
+ return n[p];
+ });
+ }
+
+ this._fillContent(source);
+ },
+
+ _fillContent: function(/*DomNode*/ source){
+ // summary:
+ // relocate source contents to templated container node
+ // this.containerNode must be able to receive children, or exceptions will be thrown
+ var dest = this.containerNode;
+ if(source && dest){
+ while(source.hasChildNodes()){
+ dest.appendChild(source.firstChild);
+ }
+ }
+ },
+
+ _attachTemplateNodes: function(rootNode, getAttrFunc){
+ // summary: Iterate through the template and attach functions and nodes accordingly.
+ // description:
+ // Map widget properties and functions to the handlers specified in
+ // the dom node and it's descendants. This function iterates over all
+ // nodes and looks for these properties:
+ // * dojoAttachPoint
+ // * dojoAttachEvent
+ // * waiRole
+ // * waiState
+ // rootNode: DomNode|Array[Widgets]
+ // the node to search for properties. All children will be searched.
+ // getAttrFunc: function?
+ // a function which will be used to obtain property for a given
+ // DomNode/Widget
+
+ getAttrFunc = getAttrFunc || function(n,p){ return n.getAttribute(p); };
+
+ var nodes = dojo.isArray(rootNode) ? rootNode : (rootNode.all || rootNode.getElementsByTagName("*"));
+ var x=dojo.isArray(rootNode)?0:-1;
+ for(; x<nodes.length; x++){
+ var baseNode = (x == -1) ? rootNode : nodes[x];
+ if(this.widgetsInTemplate && getAttrFunc(baseNode,'dojoType')){
+ continue;
+ }
+ // Process dojoAttachPoint
+ var attachPoint = getAttrFunc(baseNode, "dojoAttachPoint");
+ if(attachPoint){
+ var point, points = attachPoint.split(/\s*,\s*/);
+ while((point = points.shift())){
+ if(dojo.isArray(this[point])){
+ this[point].push(baseNode);
+ }else{
+ this[point]=baseNode;
+ }
+ }
+ }
+
+ // Process dojoAttachEvent
+ var attachEvent = getAttrFunc(baseNode, "dojoAttachEvent");
+ if(attachEvent){
+ // NOTE: we want to support attributes that have the form
+ // "domEvent: nativeEvent; ..."
+ var event, events = attachEvent.split(/\s*,\s*/);
+ var trim = dojo.trim;
+ while((event = events.shift())){
+ if(event){
+ var thisFunc = null;
+ if(event.indexOf(":") != -1){
+ // oh, if only JS had tuple assignment
+ var funcNameArr = event.split(":");
+ event = trim(funcNameArr[0]);
+ thisFunc = trim(funcNameArr[1]);
+ }else{
+ event = trim(event);
+ }
+ if(!thisFunc){
+ thisFunc = event;
+ }
+ this.connect(baseNode, event, thisFunc);
+ }
+ }
+ }
+
+ // waiRole, waiState
+ var role = getAttrFunc(baseNode, "waiRole");
+ if(role){
+ dijit.setWaiRole(baseNode, role);
+ }
+ var values = getAttrFunc(baseNode, "waiState");
+ if(values){
+ dojo.forEach(values.split(/\s*,\s*/), function(stateValue){
+ if(stateValue.indexOf('-') != -1){
+ var pair = stateValue.split('-');
+ dijit.setWaiState(baseNode, pair[0], pair[1]);
+ }
+ });
+ }
+
+ }
+ }
+ }
+);
+
+// key is either templatePath or templateString; object is either string or DOM tree
+dijit._Templated._templateCache = {};
+
+dijit._Templated.getCachedTemplate = function(templatePath, templateString, alwaysUseString){
+ // summary:
+ // Static method to get a template based on the templatePath or
+ // templateString key
+ // templatePath: String
+ // The URL to get the template from. dojo.uri.Uri is often passed as well.
+ // templateString: String?
+ // a string to use in lieu of fetching the template from a URL. Takes precedence
+ // over templatePath
+ // Returns: Mixed
+ // Either string (if there are ${} variables that need to be replaced) or just
+ // a DOM tree (if the node can be cloned directly)
+
+ // is it already cached?
+ var tmplts = dijit._Templated._templateCache;
+ var key = templateString || templatePath;
+ var cached = tmplts[key];
+ if(cached){
+ return cached;
+ }
+
+ // If necessary, load template string from template path
+ if(!templateString){
+ templateString = dijit._Templated._sanitizeTemplateString(dojo._getText(templatePath));
+ }
+
+ templateString = dojo.string.trim(templateString);
+
+ if(alwaysUseString || templateString.match(/\$\{([^\}]+)\}/g)){
+ // there are variables in the template so all we can do is cache the string
+ return (tmplts[key] = templateString); //String
+ }else{
+ // there are no variables in the template so we can cache the DOM tree
+ return (tmplts[key] = dijit._Templated._createNodesFromText(templateString)[0]); //Node
+ }
+};
+
+dijit._Templated._sanitizeTemplateString = function(/*String*/tString){
+ // summary:
+ // Strips <?xml ...?> declarations so that external SVG and XML
+ // documents can be added to a document without worry. Also, if the string
+ // is an HTML document, only the part inside the body tag is returned.
+ if(tString){
+ tString = tString.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, "");
+ var matches = tString.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+ if(matches){
+ tString = matches[1];
+ }
+ }else{
+ tString = "";
+ }
+ return tString; //String
+};
+
+
+if(dojo.isIE){
+ dojo.addOnUnload(function(){
+ var cache = dijit._Templated._templateCache;
+ for(var key in cache){
+ var value = cache[key];
+ if(!isNaN(value.nodeType)){ // isNode equivalent
+ dojo._destroyElement(value);
+ }
+ delete cache[key];
+ }
+ });
+}
+
+(function(){
+ var tagMap = {
+ cell: {re: /^<t[dh][\s\r\n>]/i, pre: "<table><tbody><tr>", post: "</tr></tbody></table>"},
+ row: {re: /^<tr[\s\r\n>]/i, pre: "<table><tbody>", post: "</tbody></table>"},
+ section: {re: /^<(thead|tbody|tfoot)[\s\r\n>]/i, pre: "<table>", post: "</table>"}
+ };
+
+ // dummy container node used temporarily to hold nodes being created
+ var tn;
+
+ dijit._Templated._createNodesFromText = function(/*String*/text){
+ // summary:
+ // Attempts to create a set of nodes based on the structure of the passed text.
+
+ if(!tn){
+ tn = dojo.doc.createElement("div");
+ tn.style.display="none";
+ dojo.body().appendChild(tn);
+ }
+ var tableType = "none";
+ var rtext = text.replace(/^\s+/, "");
+ for(var type in tagMap){
+ var map = tagMap[type];
+ if(map.re.test(rtext)){
+ tableType = type;
+ text = map.pre + text + map.post;
+ break;
+ }
+ }
+
+ tn.innerHTML = text;
+ if(tn.normalize){
+ tn.normalize();
+ }
+
+ var tag = { cell: "tr", row: "tbody", section: "table" }[tableType];
+ var _parent = (typeof tag != "undefined") ?
+ tn.getElementsByTagName(tag)[0] :
+ tn;
+
+ var nodes = [];
+ while(_parent.firstChild){
+ nodes.push(_parent.removeChild(_parent.firstChild));
+ }
+ tn.innerHTML="";
+ return nodes; // Array
+ }
+})();
+
+// These arguments can be specified for widgets which are used in templates.
+// Since any widget can be specified as sub widgets in template, mix it
+// into the base widget class. (This is a hack, but it's effective.)
+dojo.extend(dijit._Widget,{
+ dojoAttachEvent: "",
+ dojoAttachPoint: "",
+ waiRole: "",
+ waiState:""
+})
+
+}
+
+if(!dojo._hasResource["dijit._Container"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._Container"] = true;
+dojo.provide("dijit._Container");
+
+dojo.declare("dijit._Contained",
+ null,
+ {
+ // summary
+ // Mixin for widgets that are children of a container widget
+ //
+ // example:
+ // | // make a basic custom widget that knows about it's parents
+ // | dojo.declare("my.customClass",[dijit._Widget,dijit._Contained],{});
+ //
+ getParent: function(){
+ // summary:
+ // Returns the parent widget of this widget, assuming the parent
+ // implements dijit._Container
+ for(var p=this.domNode.parentNode; p; p=p.parentNode){
+ var id = p.getAttribute && p.getAttribute("widgetId");
+ if(id){
+ var parent = dijit.byId(id);
+ return parent.isContainer ? parent : null;
+ }
+ }
+ return null;
+ },
+
+ _getSibling: function(which){
+ var node = this.domNode;
+ do{
+ node = node[which+"Sibling"];
+ }while(node && node.nodeType != 1);
+ if(!node){ return null; } // null
+ var id = node.getAttribute("widgetId");
+ return dijit.byId(id);
+ },
+
+ getPreviousSibling: function(){
+ // summary:
+ // Returns null if this is the first child of the parent,
+ // otherwise returns the next element sibling to the "left".
+
+ return this._getSibling("previous"); // Mixed
+ },
+
+ getNextSibling: function(){
+ // summary:
+ // Returns null if this is the last child of the parent,
+ // otherwise returns the next element sibling to the "right".
+
+ return this._getSibling("next"); // Mixed
+ }
+ }
+);
+
+dojo.declare("dijit._Container",
+ null,
+ {
+ // summary:
+ // Mixin for widgets that contain a list of children.
+ // description:
+ // Use this mixin when the widget needs to know about and
+ // keep track of it's widget children. Widgets like SplitContainer
+ // and TabContainer.
+
+ isContainer: true,
+
+ addChild: function(/*Widget*/ widget, /*int?*/ insertIndex){
+ // summary:
+ // Process the given child widget, inserting it's dom node as
+ // a child of our dom node
+
+ if(insertIndex === undefined){
+ insertIndex = "last";
+ }
+ var refNode = this.containerNode || this.domNode;
+ if(insertIndex && typeof insertIndex == "number"){
+ var children = dojo.query("> [widgetid]", refNode);
+ if(children && children.length >= insertIndex){
+ refNode = children[insertIndex-1]; insertIndex = "after";
+ }
+ }
+ dojo.place(widget.domNode, refNode, insertIndex);
+
+ // If I've been started but the child widget hasn't been started,
+ // start it now. Make sure to do this after widget has been
+ // inserted into the DOM tree, so it can see that it's being controlled by me,
+ // so it doesn't try to size itself.
+ if(this._started && !widget._started){
+ widget.startup();
+ }
+ },
+
+ removeChild: function(/*Widget*/ widget){
+ // summary:
+ // Removes the passed widget instance from this widget but does
+ // not destroy it
+ var node = widget.domNode;
+ node.parentNode.removeChild(node); // detach but don't destroy
+ },
+
+ _nextElement: function(node){
+ do{
+ node = node.nextSibling;
+ }while(node && node.nodeType != 1);
+ return node;
+ },
+
+ _firstElement: function(node){
+ node = node.firstChild;
+ if(node && node.nodeType != 1){
+ node = this._nextElement(node);
+ }
+ return node;
+ },
+
+ getChildren: function(){
+ // summary:
+ // Returns array of children widgets
+ return dojo.query("> [widgetId]", this.containerNode || this.domNode).map(dijit.byNode); // Array
+ },
+
+ hasChildren: function(){
+ // summary:
+ // Returns true if widget has children
+ var cn = this.containerNode || this.domNode;
+ return !!this._firstElement(cn); // Boolean
+ },
+
+ _getSiblingOfChild: function(/*Widget*/ child, /*int*/ dir){
+ // summary:
+ // Get the next or previous widget sibling of child
+ // dir:
+ // if 1, get the next sibling
+ // if -1, get the previous sibling
+ var node = child.domNode;
+ var which = (dir>0 ? "nextSibling" : "previousSibling");
+ do{
+ node = node[which];
+ }while(node && (node.nodeType != 1 || !dijit.byNode(node)));
+ return node ? dijit.byNode(node) : null;
+ }
+ }
+);
+
+dojo.declare("dijit._KeyNavContainer",
+ [dijit._Container],
+ {
+
+ // summary: A _Container with keyboard navigation of its children.
+ // decscription:
+ // To use this mixin, call connectKeyNavHandlers() in
+ // postCreate() and call startupKeyNavChildren() in startup().
+ // It provides normalized keyboard and focusing code for Container
+ // widgets.
+/*=====
+ // focusedChild: Widget
+ // The currently focused child widget, or null if there isn't one
+ focusedChild: null,
+=====*/
+
+ _keyNavCodes: {},
+
+ connectKeyNavHandlers: function(/*Array*/ prevKeyCodes, /*Array*/ nextKeyCodes){
+ // summary:
+ // Call in postCreate() to attach the keyboard handlers
+ // to the container.
+ // preKeyCodes: Array
+ // Key codes for navigating to the previous child.
+ // nextKeyCodes: Array
+ // Key codes for navigating to the next child.
+
+ var keyCodes = this._keyNavCodes = {};
+ var prev = dojo.hitch(this, this.focusPrev);
+ var next = dojo.hitch(this, this.focusNext);
+ dojo.forEach(prevKeyCodes, function(code){ keyCodes[code] = prev });
+ dojo.forEach(nextKeyCodes, function(code){ keyCodes[code] = next });
+ this.connect(this.domNode, "onkeypress", "_onContainerKeypress");
+ this.connect(this.domNode, "onfocus", "_onContainerFocus");
+ },
+
+ startupKeyNavChildren: function(){
+ // summary:
+ // Call in startup() to set child tabindexes to -1
+ dojo.forEach(this.getChildren(), dojo.hitch(this, "_startupChild"));
+ },
+
+ addChild: function(/*Widget*/ widget, /*int?*/ insertIndex){
+ // summary: Add a child to our _Container
+ dijit._KeyNavContainer.superclass.addChild.apply(this, arguments);
+ this._startupChild(widget);
+ },
+
+ focus: function(){
+ // summary: Default focus() implementation: focus the first child.
+ this.focusFirstChild();
+ },
+
+ focusFirstChild: function(){
+ // summary: Focus the first focusable child in the container.
+ this.focusChild(this._getFirstFocusableChild());
+ },
+
+ focusNext: function(){
+ // summary: Focus the next widget or focal node (for widgets
+ // with multiple focal nodes) within this container.
+ if(this.focusedChild && this.focusedChild.hasNextFocalNode
+ && this.focusedChild.hasNextFocalNode()){
+ this.focusedChild.focusNext();
+ return;
+ }
+ var child = this._getNextFocusableChild(this.focusedChild, 1);
+ if(child.getFocalNodes){
+ this.focusChild(child, child.getFocalNodes()[0]);
+ }else{
+ this.focusChild(child);
+ }
+ },
+
+ focusPrev: function(){
+ // summary: Focus the previous widget or focal node (for widgets
+ // with multiple focal nodes) within this container.
+ if(this.focusedChild && this.focusedChild.hasPrevFocalNode
+ && this.focusedChild.hasPrevFocalNode()){
+ this.focusedChild.focusPrev();
+ return;
+ }
+ var child = this._getNextFocusableChild(this.focusedChild, -1);
+ if(child.getFocalNodes){
+ var nodes = child.getFocalNodes();
+ this.focusChild(child, nodes[nodes.length-1]);
+ }else{
+ this.focusChild(child);
+ }
+ },
+
+ focusChild: function(/*Widget*/ widget, /*Node?*/ node){
+ // summary: Focus widget. Optionally focus 'node' within widget.
+ if(widget){
+ if(this.focusedChild && widget !== this.focusedChild){
+ this._onChildBlur(this.focusedChild);
+ }
+ this.focusedChild = widget;
+ if(node && widget.focusFocalNode){
+ widget.focusFocalNode(node);
+ }else{
+ widget.focus();
+ }
+ }
+ },
+
+ _startupChild: function(/*Widget*/ widget){
+ // summary:
+ // Set tabindex="-1" on focusable widgets so that we
+ // can focus them programmatically and by clicking.
+ // Connect focus and blur handlers.
+ if(widget.getFocalNodes){
+ dojo.forEach(widget.getFocalNodes(), function(node){
+ dojo.attr(node, "tabindex", -1);
+ this._connectNode(node);
+ }, this);
+ }else{
+ var node = widget.focusNode || widget.domNode;
+ if(widget.isFocusable()){
+ dojo.attr(node, "tabindex", -1);
+ }
+ this._connectNode(node);
+ }
+ },
+
+ _connectNode: function(/*Element*/ node){
+ this.connect(node, "onfocus", "_onNodeFocus");
+ this.connect(node, "onblur", "_onNodeBlur");
+ },
+
+ _onContainerFocus: function(evt){
+ // focus bubbles on Firefox,
+ // so just make sure that focus has really gone to the container
+ if(evt.target === this.domNode){
+ this.focusFirstChild();
+ }
+ },
+
+ _onContainerKeypress: function(evt){
+ if(evt.ctrlKey || evt.altKey){ return; }
+ var func = this._keyNavCodes[evt.keyCode];
+ if(func){
+ func();
+ dojo.stopEvent(evt);
+ }
+ },
+
+ _onNodeFocus: function(evt){
+ // while focus is on a child,
+ // take the container out of the tab order so that
+ // we can shift-tab to the element before the container
+ dojo.attr(this.domNode, "tabindex", -1);
+ // record the child that has been focused
+ var widget = dijit.getEnclosingWidget(evt.target);
+ if(widget && widget.isFocusable()){
+ this.focusedChild = widget;
+ }
+ dojo.stopEvent(evt);
+ },
+
+ _onNodeBlur: function(evt){
+ // when focus leaves a child,
+ // reinstate the container's tabindex
+ if(this.tabIndex){
+ dojo.attr(this.domNode, "tabindex", this.tabIndex);
+ }
+ dojo.stopEvent(evt);
+ },
+
+ _onChildBlur: function(/*Widget*/ widget){
+ // summary:
+ // Called when focus leaves a child widget to go
+ // to a sibling widget.
+ },
+
+ _getFirstFocusableChild: function(){
+ return this._getNextFocusableChild(null, 1);
+ },
+
+ _getNextFocusableChild: function(child, dir){
+ if(child){
+ child = this._getSiblingOfChild(child, dir);
+ }
+ var children = this.getChildren();
+ for(var i=0; i < children.length; i++){
+ if(!child){
+ child = children[(dir>0) ? 0 : (children.length-1)];
+ }
+ if(child.isFocusable()){
+ return child;
+ }
+ child = this._getSiblingOfChild(child, dir);
+ }
+ // no focusable child found
+ return null;
+ }
+ }
+);
+
+}
+
+if(!dojo._hasResource["dijit.layout._LayoutWidget"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit.layout._LayoutWidget"] = true;
+dojo.provide("dijit.layout._LayoutWidget");
+
+
+
+
+dojo.declare("dijit.layout._LayoutWidget",
+ [dijit._Widget, dijit._Container, dijit._Contained],
+ {
+ // summary
+ // Mixin for widgets that contain a list of children like SplitContainer.
+ // Widgets which mixin this code must define layout() to lay out the children
+
+ isLayoutContainer: true,
+
+ postCreate: function(){
+ dojo.addClass(this.domNode, "dijitContainer");
+ },
+
+ startup: function(){
+ // summary:
+ // Called after all the widgets have been instantiated and their
+ // dom nodes have been inserted somewhere under dojo.doc.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; }
+
+ dojo.forEach(this.getChildren(), function(child){ child.startup(); });
+
+ // If I am a top level widget
+ if(!this.getParent || !this.getParent()){
+ // 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 is width=height=100% (or something similar),
+ // then I need to watch when the window resizes, and size myself accordingly
+ // (passing in no argument to resize means that it has to glean the size itself)
+ this.connect(window, 'onresize', function(){this.resize();});
+ }
+
+ this.inherited(arguments);
+ },
+
+ resize: function(args){
+ // summary:
+ // Explicitly set this widget's size (in pixels),
+ // and then call layout() to resize contents (and maybe adjust child widgets)
+ //
+ // args: Object?
+ // {w: int, h: int, l: int, t: int}
+
+ var node = this.domNode;
+
+ // set margin box size, unless it wasn't specified, in which case use current size
+ if(args){
+ dojo.marginBox(node, args);
+
+ // set offset of the node
+ if(args.t){ node.style.top = args.t + "px"; }
+ if(args.l){ node.style.left = args.l + "px"; }
+ }
+ // 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 = dojo.mixin(dojo.marginBox(node), args||{});
+
+// console.log(this, ": setting size to ", mb);
+
+ // Save the size of my content box.
+ this._contentBox = dijit.layout.marginBox2contentBox(node, mb);
+
+ // Callback for widget to adjust size of it's children
+ this.layout();
+ },
+
+ layout: function(){
+ // summary
+ // Widgets override this method to size & 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.
+ }
+ }
+);
+
+dijit.layout.marginBox2contentBox = function(/*DomNode*/ node, /*Object*/ mb){
+ // summary:
+ // Given the margin-box size of a node, return it's content box size.
+ // Functions like dojo.contentBox() but is more reliable since it doesn't have
+ // to wait for the browser to compute sizes.
+ var cs = dojo.getComputedStyle(node);
+ var me=dojo._getMarginExtents(node, cs);
+ var pb=dojo._getPadBorderExtents(node, cs);
+ return {
+ l: dojo._toPixelValue(node, cs.paddingLeft),
+ t: dojo._toPixelValue(node, cs.paddingTop),
+ w: mb.w - (me.w + pb.w),
+ h: mb.h - (me.h + pb.h)
+ };
+};
+
+(function(){
+ var capitalize = function(word){
+ return word.substring(0,1).toUpperCase() + word.substring(1);
+ };
+
+ var size = function(widget, dim){
+ // size the child
+ widget.resize ? widget.resize(dim) : dojo.marginBox(widget.domNode, dim);
+
+ // record child's size, but favor our own numbers when we have them.
+ // the browser lies sometimes
+ dojo.mixin(widget, dojo.marginBox(widget.domNode));
+ dojo.mixin(widget, dim);
+ };
+
+ dijit.layout.layoutChildren = function(/*DomNode*/ container, /*Object*/ dim, /*Object[]*/ children){
+ /**
+ * summary
+ * Layout a bunch of child dom nodes within a parent dom node
+ * container:
+ * parent node
+ * dim:
+ * {l, t, w, h} object specifying dimensions of container into which to place children
+ * children:
+ * an array like [ {domNode: foo, layoutAlign: "bottom" }, {domNode: bar, layoutAlign: "client"} ]
+ */
+
+ // copy dim because we are going to modify it
+ dim = dojo.mixin({}, dim);
+
+ dojo.addClass(container, "dijitLayoutContainer");
+
+ // Move "client" elements to the end of the array for layout. a11y dictates that the author
+ // needs to be able to put them in the document in tab-order, but this algorithm requires that
+ // client be last.
+ children = dojo.filter(children, function(item){ return item.layoutAlign != "client"; })
+ .concat(dojo.filter(children, function(item){ return item.layoutAlign == "client"; }));
+
+ // set positions/sizes
+ dojo.forEach(children, function(child){
+ var elm = child.domNode,
+ pos = child.layoutAlign;
+
+ // set elem to upper left corner of unused space; may move it later
+ var elmStyle = elm.style;
+ elmStyle.left = dim.l+"px";
+ elmStyle.top = dim.t+"px";
+ elmStyle.bottom = elmStyle.right = "auto";
+
+ dojo.addClass(elm, "dijitAlign" + capitalize(pos));
+
+ // set size && adjust record of remaining space.
+ // note that setting the width of a <div> may affect it's height.
+ if(pos=="top" || pos=="bottom"){
+ size(child, { w: dim.w });
+ dim.h -= child.h;
+ if(pos=="top"){
+ dim.t += child.h;
+ }else{
+ elmStyle.top = dim.t + dim.h + "px";
+ }
+ }else if(pos=="left" || pos=="right"){
+ size(child, { h: dim.h });
+ dim.w -= child.w;
+ if(pos=="left"){
+ dim.l += child.w;
+ }else{
+ elmStyle.left = dim.l + dim.w + "px";
+ }
+ }else if(pos=="client"){
+ size(child, dim);
+ }
+ });
+ };
+
+})();
+
+}
+
+if(!dojo._hasResource["dijit.form._FormWidget"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit.form._FormWidget"] = true;
+dojo.provide("dijit.form._FormWidget");
+
+
+
+
+dojo.declare("dijit.form._FormWidget", [dijit._Widget, dijit._Templated],
+{
+ /*
+ Summary:
+ _FormWidget's correspond to native HTML elements such as <checkbox> or <button>.
+ Each _FormWidget represents a single HTML element.
+
+ All these widgets should have these attributes just like native HTML input elements.
+ You can set them during widget construction.
+
+ They also share some common methods.
+ */
+
+ // baseClass: String
+ // Root CSS class of the widget (ex: dijitTextBox), used to add CSS classes of widget
+ // (ex: "dijitTextBox dijitTextBoxInvalid dijitTextBoxFocused dijitTextBoxInvalidFocused")
+ // See _setStateClass().
+ baseClass: "",
+
+ // name: String
+ // Name used when submitting form; same as "name" attribute or plain HTML elements
+ name: "",
+
+ // alt: String
+ // Corresponds to the native HTML <input> element's attribute.
+ alt: "",
+
+ // value: String
+ // Corresponds to the native HTML <input> element's attribute.
+ value: "",
+
+ // type: String
+ // Corresponds to the native HTML <input> element's attribute.
+ type: "text",
+
+ // tabIndex: Integer
+ // Order fields are traversed when user hits the tab key
+ tabIndex: "0",
+
+ // disabled: Boolean
+ // Should this widget respond to user input?
+ // In markup, this is specified as "disabled='disabled'", or just "disabled".
+ disabled: false,
+
+ // readOnly: Boolean
+ // Should this widget respond to user input?
+ // In markup, this is specified as "readOnly".
+ // Similar to disabled except readOnly form values are submitted
+ readOnly: false,
+
+ // intermediateChanges: Boolean
+ // Fires onChange for each value change or only on demand
+ intermediateChanges: false,
+
+ // These mixins assume that the focus node is an INPUT, as many but not all _FormWidgets are.
+ // Don't attempt to mixin the 'type', 'name' attributes here programatically -- they must be declared
+ // directly in the template as read by the parser in order to function. IE is known to specifically
+ // require the 'name' attribute at element creation time.
+ attributeMap: dojo.mixin(dojo.clone(dijit._Widget.prototype.attributeMap),
+ {value:"focusNode", disabled:"focusNode", readOnly:"focusNode", id:"focusNode", tabIndex:"focusNode", alt:"focusNode"}),
+
+ setAttribute: function(/*String*/ attr, /*anything*/ value){
+ this.inherited(arguments);
+ switch(attr){
+ case "disabled":
+ var tabIndexNode = this[this.attributeMap['tabIndex']||'domNode'];
+ if(value){
+ //reset those, because after the domNode is disabled, we can no longer receive
+ //mouse related events, see #4200
+ this._hovering = false;
+ this._active = false;
+ // remove the tabIndex, especially for FF
+ tabIndexNode.removeAttribute('tabIndex');
+ }else{
+ tabIndexNode.setAttribute('tabIndex', this.tabIndex);
+ }
+ dijit.setWaiState(this[this.attributeMap['disabled']||'domNode'], "disabled", value);
+ this._setStateClass();
+ }
+ },
+
+ setDisabled: function(/*Boolean*/ disabled){
+ // summary:
+ // Set disabled state of widget (Deprecated).
+ dojo.deprecated("setDisabled("+disabled+") is deprecated. Use setAttribute('disabled',"+disabled+") instead.", "", "2.0");
+ this.setAttribute('disabled', disabled);
+ },
+
+
+ _onMouse : function(/*Event*/ event){
+ // summary:
+ // Sets _hovering, _active, and stateModifier properties depending on mouse state,
+ // then calls setStateClass() to set appropriate CSS classes for this.domNode.
+ //
+ // To get a different CSS class for hover, send onmouseover and onmouseout events to this method.
+ // To get a different CSS class while mouse button is depressed, send onmousedown to this method.
+
+ var mouseNode = event.currentTarget;
+ if(mouseNode && mouseNode.getAttribute){
+ this.stateModifier = mouseNode.getAttribute("stateModifier") || "";
+ }
+
+ if(!this.disabled){
+ switch(event.type){
+ case "mouseenter":
+ case "mouseover":
+ this._hovering = true;
+ this._active = this._mouseDown;
+ break;
+
+ case "mouseout":
+ case "mouseleave":
+ this._hovering = false;
+ this._active = false;
+ break;
+
+ case "mousedown" :
+ this._active = true;
+ this._mouseDown = true;
+ // set a global event to handle mouseup, so it fires properly
+ // even if the cursor leaves the button
+ var mouseUpConnector = this.connect(dojo.body(), "onmouseup", function(){
+ this._active = false;
+ this._mouseDown = false;
+ this._setStateClass();
+ this.disconnect(mouseUpConnector);
+ });
+ if(this.isFocusable()){ this.focus(); }
+ break;
+ }
+ this._setStateClass();
+ }
+ },
+
+ isFocusable: function(){
+ return !this.disabled && !this.readOnly && this.focusNode && (dojo.style(this.domNode, "display") != "none");
+ },
+
+ focus: function(){
+ setTimeout(dojo.hitch(this, dijit.focus, this.focusNode), 0); // cannot call focus() from an event handler directly
+ },
+
+ _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).
+ //
+ // 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".
+ //
+ // For complex widgets with multiple regions, there can be various hover/active states,
+ // such as "Hover" or "CloseButtonHover" (for tab buttons).
+ // This is controlled by a stateModifier="CloseButton" attribute on the close button node.
+ //
+ // 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
+ // 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, 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
+
+ // Get original (non state related, non baseClass related) class specified in template
+ if(!("staticClass" in this)){
+ this.staticClass = (this.stateNode||this.domNode).className;
+ }
+
+ // Compute new set of classes
+ var classes = [ this.baseClass ];
+
+ function multiply(modifier){
+ classes=classes.concat(dojo.map(classes, function(c){ return c+modifier; }), "dijit"+modifier);
+ }
+
+ if(this.checked){
+ multiply("Checked");
+ }
+ if(this.state){
+ multiply(this.state);
+ }
+ if(this.selected){
+ multiply("Selected");
+ }
+
+ if(this.disabled){
+ multiply("Disabled");
+ }else if(this.readOnly){
+ multiply("ReadOnly");
+ }else if(this._active){
+ multiply(this.stateModifier+"Active");
+ }else{
+ if(this._focused){
+ multiply("Focused");
+ }
+ if(this._hovering){
+ multiply(this.stateModifier+"Hover");
+ }
+ }
+
+ (this.stateNode || this.domNode).className = this.staticClass + " " + classes.join(" ");
+ },
+
+ onChange: function(newValue){
+ // summary: callback when value is changed
+ },
+
+ _onChangeMonitor: 'value',
+ _onChangeActive: false,
+
+ _handleOnChange: function(/*anything*/ newValue, /*Boolean, optional*/ priorityChange){
+ // summary: set the value of the widget.
+ this._lastValue = newValue;
+ if(this._lastValueReported == undefined && (priorityChange === null || !this._onChangeActive)){
+ this._resetValue = this._lastValueReported = newValue;
+ }
+ if((this.intermediateChanges || priorityChange || priorityChange === undefined) &&
+ ((newValue && newValue.toString)?newValue.toString():newValue) !== ((this._lastValueReported && this._lastValueReported.toString)?this._lastValueReported.toString():this._lastValueReported)){
+ this._lastValueReported = newValue;
+ if(this._onChangeActive){ this.onChange(newValue); }
+ }
+ },
+
+ reset: function(){
+ this._hasBeenBlurred = false;
+ if(this.setValue && !this._getValueDeprecated){
+ this.setValue(this._resetValue, true);
+ }else if(this._onChangeMonitor){
+ this.setAttribute(this._onChangeMonitor, (this._resetValue !== undefined && this._resetValue !== null)? this._resetValue : '');
+ }
+ },
+
+ create: function(){
+ this.inherited(arguments);
+ this._onChangeActive = true;
+ this._setStateClass();
+ },
+
+ destroy: function(){
+ if(this._layoutHackHandle){
+ clearTimeout(this._layoutHackHandle);
+ }
+ this.inherited(arguments);
+ },
+
+ setValue: function(/*String*/ value){
+ dojo.deprecated("dijit.form._FormWidget:setValue("+value+") is deprecated. Use setAttribute('value',"+value+") instead.", "", "2.0");
+ this.setAttribute('value', value);
+ },
+
+ _getValueDeprecated: true, // Form uses this, remove when getValue is removed
+ getValue: function(){
+ dojo.deprecated("dijit.form._FormWidget:getValue() is deprecated. Use widget.value instead.", "", "2.0");
+ return this.value;
+ },
+
+ _layoutHack: function(){
+ // summary: work around table sizing bugs on FF2 by forcing redraw
+ if(dojo.isFF == 2){
+ var node=this.domNode;
+ var old = node.style.opacity;
+ node.style.opacity = "0.999";
+ this._layoutHackHandle = setTimeout(dojo.hitch(this, function(){
+ this._layoutHackHandle = null;
+ node.style.opacity = old;
+ }), 0);
+ }
+ }
+});
+
+dojo.declare("dijit.form._FormValueWidget", dijit.form._FormWidget,
+{
+ /*
+ Summary:
+ _FormValueWidget's correspond to native HTML elements such as <input> or <select> that have user changeable values.
+ Each _ValueWidget represents a single input value, and has a (possibly hidden) <input> element,
+ to which it serializes its input value, so that form submission (either normal submission or via FormBind?)
+ works as expected.
+ */
+
+ attributeMap: dojo.mixin(dojo.clone(dijit.form._FormWidget.prototype.attributeMap),
+ {value:""}),
+
+ postCreate: function(){
+ this.setValue(this.value, null);
+ },
+
+ setValue: function(/*anything*/ newValue, /*Boolean, optional*/ priorityChange){
+ // summary: set the value of the widget.
+ this.value = newValue;
+ this._handleOnChange(newValue, priorityChange);
+ },
+
+ _getValueDeprecated: false, // remove when _FormWidget:getValue is removed
+ getValue: function(){
+ // summary: get the value of the widget.
+ return this._lastValue;
+ },
+
+ undo: function(){
+ // summary: restore the value to the last value passed to onChange
+ this.setValue(this._lastValueReported, false);
+ },
+
+ _valueChanged: function(){
+ var v = this.getValue();
+ var lv = this._lastValueReported;
+ // Equality comparison of objects such as dates are done by reference so
+ // two distinct objects are != even if they have the same data. So use
+ // toStrings in case the values are objects.
+ return ((v !== null && (v !== undefined) && v.toString)?v.toString():'') !== ((lv !== null && (lv !== undefined) && lv.toString)?lv.toString():'');
+ },
+
+ _onKeyPress: function(e){
+ if(e.keyCode == dojo.keys.ESCAPE && !e.shiftKey && !e.ctrlKey && !e.altKey){
+ if(this._valueChanged()){
+ this.undo();
+ dojo.stopEvent(e);
+ return false;
+ }
+ }
+ return true;
+ }
+});
+
+}
+
+if(!dojo._hasResource["dijit.dijit"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit.dijit"] = true;
+dojo.provide("dijit.dijit");
+
+/*=====
+dijit.dijit = {
+ // summary: A roll-up for common dijit methods
+ // description:
+ // A rollup file for the build system including the core and common
+ // dijit files.
+ //
+ // example:
+ // | <script type="text/javascript" src="js/dojo/dijit/dijit.js"></script>
+ //
+};
+=====*/
+
+// All the stuff in _base (these are the function that are guaranteed available without an explicit dojo.require)
+
+
+// And some other stuff that we tend to pull in all the time anyway
+
+
+
+
+
+
+
+}
+
projects / eow / blobdiff