[Pkg-javascript-commits] [dojo] 05/10: Imported Upstream version 1.10.4+dfsg
David Prévot
taffit at moszumanska.debian.org
Thu Jan 22 21:00:35 UTC 2015
This is an automated email from the git hooks/post-receive script.
taffit pushed a commit to branch master
in repository dojo.
commit cbcce858596aec48894be75ce386ad07e200ba84
Merge: ed4e6ed 4e4ecaf
Author: David Prévot <david at tilapin.org>
Date: Thu Jan 22 14:31:33 2015 -0400
Imported Upstream version 1.10.4+dfsg
dijit/Dialog.js | 30 ++++++++++-----
dijit/package.json | 4 +-
dijit/tests/ConfirmDialog.html | 76 +++++++++++++++++++++++++++++++++++++
dijit/tests/Dialog.html | 32 +++++++++++++++-
dijit/tests/general-module.js | 3 ++
dojo/_base/kernel.js | 4 +-
dojo/cldr/nls/ca/gregorian.js | 22 +++++------
dojo/cldr/nls/da/gregorian.js | 4 +-
dojo/cldr/nls/de/gregorian.js | 30 ++++++---------
dojo/cldr/nls/el/gregorian.js | 12 ++----
dojo/cldr/nls/en/gregorian.js | 12 ++----
dojo/cldr/nls/es/gregorian.js | 12 ++----
dojo/cldr/nls/fi/gregorian.js | 26 +++++--------
dojo/cldr/nls/fr/gregorian.js | 26 +++++--------
dojo/cldr/nls/hu/gregorian.js | 26 +++++--------
dojo/cldr/nls/ja/gregorian.js | 1 -
dojo/cldr/nls/nb/gregorian.js | 8 +---
dojo/cldr/nls/nl/gregorian.js | 4 +-
dojo/cldr/nls/pt-pt/gregorian.js | 12 ++----
dojo/cldr/nls/ru/gregorian.js | 21 +++++-----
dojo/cldr/nls/sv/gregorian.js | 4 +-
dojo/cldr/nls/th/gregorian.js | 4 +-
dojo/cldr/nls/tr/gregorian.js | 12 ++----
dojo/cldr/nls/zh-hant/gregorian.js | 4 +-
dojo/cldr/nls/zh-hk/gregorian.js | 12 ++----
dojo/cldr/nls/zh-tw/gregorian.js | 12 ++----
dojo/on.js | 6 +--
dojo/package.json | 2 +-
dojo/tests/date/locale.js | 2 +
dojox/calendar/CONTRIBUTING.md | 0
dojox/calendar/LICENSE | 0
dojox/calendar/nls/bg/buttons.js | 0
dojox/calendar/nls/he/buttons.js | 0
dojox/calendar/nls/hr/buttons.js | 0
dojox/calendar/nls/uk/buttons.js | 0
dojox/calendar/tests/hcalendar.html | 0
dojox/dgauges/CONTRIBUTING.md | 0
dojox/layout/ResizeHandle.js | 2 +-
dojox/package.json | 6 +--
util/.gitmodules | 2 +-
util/build/version.js | 4 +-
util/doh/_nodeRunner.js | 2 +-
util/doh/_rhinoRunner.js | 2 +-
util/doh/mobileRunner.html | 2 +-
util/doh/package.json | 2 +-
util/doh/runner.html | 2 +-
util/package.json | 2 +-
47 files changed, 240 insertions(+), 209 deletions(-)
diff --cc dijit/Dialog.js
index 94ff87c,0000000..4c3da91
mode 100644,000000..100644
--- a/dijit/Dialog.js
+++ b/dijit/Dialog.js
@@@ -1,686 -1,0 +1,696 @@@
+define([
+ "require",
+ "dojo/_base/array", // array.forEach array.indexOf array.map
+ "dojo/aspect",
+ "dojo/_base/declare", // declare
+ "dojo/Deferred", // Deferred
+ "dojo/dom", // dom.isDescendant
+ "dojo/dom-class", // domClass.add domClass.contains
+ "dojo/dom-geometry", // domGeometry.position
+ "dojo/dom-style", // domStyle.set
+ "dojo/_base/fx", // fx.fadeIn fx.fadeOut
+ "dojo/i18n", // i18n.getLocalization
+ "dojo/keys",
+ "dojo/_base/lang", // lang.mixin lang.hitch
+ "dojo/on",
+ "dojo/ready",
+ "dojo/sniff", // has("ie") has("opera") has("dijit-legacy-requires")
+ "dojo/window", // winUtils.getBox, winUtils.get
+ "dojo/dnd/Moveable", // Moveable
+ "dojo/dnd/TimedMoveable", // TimedMoveable
+ "./focus",
+ "./_base/manager", // manager.defaultDuration
+ "./_Widget",
+ "./_TemplatedMixin",
+ "./_CssStateMixin",
+ "./form/_FormMixin",
+ "./_DialogMixin",
+ "./DialogUnderlay",
+ "./layout/ContentPane",
+ "./layout/utils",
+ "dojo/text!./templates/Dialog.html",
+ "./a11yclick", // template uses ondijitclick
+ "dojo/i18n!./nls/common"
+], function(require, array, aspect, declare, Deferred,
+ dom, domClass, domGeometry, domStyle, fx, i18n, keys, lang, on, ready, has, winUtils,
+ Moveable, TimedMoveable, focus, manager, _Widget, _TemplatedMixin, _CssStateMixin, _FormMixin, _DialogMixin,
+ DialogUnderlay, ContentPane, utils, template){
+
+ // module:
+ // dijit/Dialog
+
+ var resolvedDeferred = new Deferred();
+ resolvedDeferred.resolve(true);
+
+ var _DialogBase = declare("dijit._DialogBase" + (has("dojo-bidi") ? "_NoBidi" : ""), [_TemplatedMixin, _FormMixin, _DialogMixin, _CssStateMixin], {
+ templateString: template,
+
+ baseClass: "dijitDialog",
+
+ cssStateNodes: {
+ closeButtonNode: "dijitDialogCloseIcon"
+ },
+
+ // Map widget attributes to DOMNode attributes.
+ _setTitleAttr: { node: "titleNode", type: "innerHTML" },
+
+ // open: [readonly] Boolean
+ // True if Dialog is currently displayed on screen.
+ open: false,
+
+ // duration: Integer
+ // The time in milliseconds it takes the dialog to fade in and out
+ duration: manager.defaultDuration,
+
+ // refocus: Boolean
+ // A Toggle to modify the default focus behavior of a Dialog, which
+ // is to re-focus the element which had focus before being opened.
+ // False will disable refocusing. Default: true
+ refocus: true,
+
+ // autofocus: Boolean
+ // A Toggle to modify the default focus behavior of a Dialog, which
+ // is to focus on the first dialog element after opening the dialog.
+ // False will disable autofocusing. Default: true
+ autofocus: true,
+
+ // _firstFocusItem: [private readonly] DomNode
+ // The pointer to the first focusable node in the dialog.
+ // Set by `dijit/_DialogMixin._getFocusItems()`.
+ _firstFocusItem: null,
+
+ // _lastFocusItem: [private readonly] DomNode
+ // The pointer to which node has focus prior to our dialog.
+ // Set by `dijit/_DialogMixin._getFocusItems()`.
+ _lastFocusItem: null,
+
+ // draggable: Boolean
+ // Toggles the movable aspect of the Dialog. If true, Dialog
+ // can be dragged by it's title. If false it will remain centered
+ // in the viewport.
+ draggable: true,
+ _setDraggableAttr: function(/*Boolean*/ val){
+ // Avoid _WidgetBase behavior of copying draggable attribute to this.domNode,
+ // as that prevents text select on modern browsers (#14452)
+ this._set("draggable", val);
+ },
+
+ // maxRatio: Number
+ // Maximum size to allow the dialog to expand to, relative to viewport size
+ maxRatio: 0.9,
+
+ // closable: Boolean
+ // Dialog show [x] icon to close itself, and ESC key will close the dialog.
+ closable: true,
+ _setClosableAttr: function(val){
+ this.closeButtonNode.style.display = val ? "" : "none";
+ this._set("closable", val);
+ },
+
+ postMixInProperties: function(){
+ var _nlsResources = i18n.getLocalization("dijit", "common");
+ lang.mixin(this, _nlsResources);
+ this.inherited(arguments);
+ },
+
+ postCreate: function(){
+ domStyle.set(this.domNode, {
+ display: "none",
+ position: "absolute"
+ });
+ this.ownerDocumentBody.appendChild(this.domNode);
+
+ this.inherited(arguments);
+
+ aspect.after(this, "onExecute", lang.hitch(this, "hide"), true);
+ aspect.after(this, "onCancel", lang.hitch(this, "hide"), true);
+
+ this._modalconnects = [];
+ },
+
+ onLoad: function(){
+ // summary:
+ // Called when data has been loaded from an href.
+ // Unlike most other callbacks, this function can be connected to (via `dojo.connect`)
+ // but should *not* be overridden.
+ // tags:
+ // callback
+
+ // when href is specified we need to reposition the dialog after the data is loaded
+ // and find the focusable elements
+ this.resize();
+ this._position();
+
+ if(this.autofocus && DialogLevelManager.isTop(this)){
+ this._getFocusItems();
+ focus.focus(this._firstFocusItem);
+ }
+
+ this.inherited(arguments);
+ },
+
+ focus: function(){
+ this._getFocusItems();
+ focus.focus(this._firstFocusItem);
+ },
+
+ _endDrag: function(){
+ // summary:
+ // Called after dragging the Dialog. Saves the position of the dialog in the viewport,
+ // and also adjust position to be fully within the viewport, so user doesn't lose access to handle
+ var nodePosition = domGeometry.position(this.domNode),
+ viewport = winUtils.getBox(this.ownerDocument);
+ nodePosition.y = Math.min(Math.max(nodePosition.y, 0), (viewport.h - nodePosition.h));
+ nodePosition.x = Math.min(Math.max(nodePosition.x, 0), (viewport.w - nodePosition.w));
+ this._relativePosition = nodePosition;
+ this._position();
+ },
+
+ _setup: function(){
+ // summary:
+ // Stuff we need to do before showing the Dialog for the first
+ // time (but we defer it until right beforehand, for
+ // performance reasons).
+ // tags:
+ // private
+
+ var node = this.domNode;
+
+ if(this.titleBar && this.draggable){
+ this._moveable = new ((has("ie") == 6) ? TimedMoveable // prevent overload, see #5285
+ : Moveable)(node, { handle: this.titleBar });
+ aspect.after(this._moveable, "onMoveStop", lang.hitch(this, "_endDrag"), true);
+ }else{
+ domClass.add(node, "dijitDialogFixed");
+ }
+
+ this.underlayAttrs = {
+ dialogId: this.id,
+ "class": array.map(this["class"].split(/\s/),function(s){
+ return s + "_underlay";
+ }).join(" "),
+ _onKeyDown: lang.hitch(this, "_onKey"),
+ ownerDocument: this.ownerDocument
+ };
+ },
+
+ _size: function(){
+ // TODO: remove for 2.0
+ this.resize();
+ },
+
+ _position: function(){
+ // summary:
+ // Position the dialog in the viewport. If no relative offset
+ // in the viewport has been determined (by dragging, for instance),
+ // center the dialog. Otherwise, use the Dialog's stored relative offset,
+ // adjusted by the viewport's scroll.
+ if(!domClass.contains(this.ownerDocumentBody, "dojoMove")){ // don't do anything if called during auto-scroll
+ var node = this.domNode,
+ viewport = winUtils.getBox(this.ownerDocument),
+ p = this._relativePosition,
+ bb = p ? null : domGeometry.position(node),
+ l = Math.floor(viewport.l + (p ? p.x : (viewport.w - bb.w) / 2)),
+ t = Math.floor(viewport.t + (p ? p.y : (viewport.h - bb.h) / 2))
+ ;
+ domStyle.set(node, {
+ left: l + "px",
+ top: t + "px"
+ });
+ }
+ },
+
+ _onKey: function(/*Event*/ evt){
+ // summary:
+ // Handles the keyboard events for accessibility reasons
+ // tags:
+ // private
+
+ if(evt.keyCode == keys.TAB){
+ this._getFocusItems();
+ var node = evt.target;
+ if(this._firstFocusItem == this._lastFocusItem){
+ // don't move focus anywhere, but don't allow browser to move focus off of dialog either
+ evt.stopPropagation();
+ evt.preventDefault();
+ }else if(node == this._firstFocusItem && evt.shiftKey){
+ // if we are shift-tabbing from first focusable item in dialog, send focus to last item
+ focus.focus(this._lastFocusItem);
+ evt.stopPropagation();
+ evt.preventDefault();
+ }else if(node == this._lastFocusItem && !evt.shiftKey){
+ // if we are tabbing from last focusable item in dialog, send focus to first item
+ focus.focus(this._firstFocusItem);
+ evt.stopPropagation();
+ evt.preventDefault();
+ }
+ }else if(this.closable && evt.keyCode == keys.ESCAPE){
+ this.onCancel();
+ evt.stopPropagation();
+ evt.preventDefault();
+ }
+ },
+
+ show: function(){
+ // summary:
+ // Display the dialog
+ // returns: dojo/promise/Promise
+ // Promise object that resolves when the display animation is complete
+
+ if(this.open){
+ return resolvedDeferred.promise;
+ }
+
+ if(!this._started){
+ this.startup();
+ }
+
+ // first time we show the dialog, there's some initialization stuff to do
+ if(!this._alreadyInitialized){
+ this._setup();
+ this._alreadyInitialized = true;
+ }
+
+ if(this._fadeOutDeferred){
+ // There's a hide() operation in progress, so cancel it, but still call DialogLevelManager.hide()
+ // as though the hide() completed, in preparation for the DialogLevelManager.show() call below.
+ this._fadeOutDeferred.cancel();
+ DialogLevelManager.hide(this);
+ }
+
+ // Recenter Dialog if user scrolls browser. Connecting to document doesn't work on IE, need to use window.
+ // Be sure that event object doesn't get passed to resize() method, because it's expecting an optional
+ // {w: ..., h:...} arg.
+ var win = winUtils.get(this.ownerDocument);
+ this._modalconnects.push(on(win, "scroll", lang.hitch(this, "resize", null)));
+
+ this._modalconnects.push(on(this.domNode, "keydown", lang.hitch(this, "_onKey")));
+
+ domStyle.set(this.domNode, {
+ opacity: 0,
+ display: ""
+ });
+
+ this._set("open", true);
+ this._onShow(); // lazy load trigger
+
+ this.resize();
+ this._position();
+
+ // fade-in Animation object, setup below
+ var fadeIn;
+
+ this._fadeInDeferred = new Deferred(lang.hitch(this, function(){
+ fadeIn.stop();
+ delete this._fadeInDeferred;
+ }));
+
+ // If delay is 0, code below will delete this._fadeInDeferred instantly, so grab promise while we can.
+ var promise = this._fadeInDeferred.promise;
+
+ fadeIn = fx.fadeIn({
+ node: this.domNode,
+ duration: this.duration,
+ beforeBegin: lang.hitch(this, function(){
+ DialogLevelManager.show(this, this.underlayAttrs);
+ }),
+ onEnd: lang.hitch(this, function(){
+ if(this.autofocus && DialogLevelManager.isTop(this)){
+ // find focusable items each time dialog is shown since if dialog contains a widget the
+ // first focusable items can change
+ this._getFocusItems();
+ focus.focus(this._firstFocusItem);
+ }
+ this._fadeInDeferred.resolve(true);
+ delete this._fadeInDeferred;
+ })
+ }).play();
+
+ return promise;
+ },
+
+ hide: function(){
+ // summary:
+ // Hide the dialog
+ // returns: dojo/promise/Promise
+ // Promise object that resolves when the display animation is complete
+
+ // If we haven't been initialized yet then we aren't showing and we can just return.
+ // Likewise if we are already hidden, or are currently fading out.
+ if(!this._alreadyInitialized || !this.open){
+ return resolvedDeferred.promise;
+ }
+ if(this._fadeInDeferred){
+ this._fadeInDeferred.cancel();
+ }
+
+ // fade-in Animation object, setup below
+ var fadeOut;
+
+ this._fadeOutDeferred = new Deferred(lang.hitch(this, function(){
+ fadeOut.stop();
+ delete this._fadeOutDeferred;
+ }));
+
+ // fire onHide when the promise resolves.
+ this._fadeOutDeferred.then(lang.hitch(this, 'onHide'));
+
+ // If delay is 0, code below will delete this._fadeOutDeferred instantly, so grab promise while we can.
+ var promise = this._fadeOutDeferred.promise;
+
+ fadeOut = fx.fadeOut({
+ node: this.domNode,
+ duration: this.duration,
+ onEnd: lang.hitch(this, function(){
+ this.domNode.style.display = "none";
+ DialogLevelManager.hide(this);
+ this._fadeOutDeferred.resolve(true);
+ delete this._fadeOutDeferred;
+ })
+ }).play();
+
+ if(this._scrollConnected){
+ this._scrollConnected = false;
+ }
+ var h;
+ while(h = this._modalconnects.pop()){
+ h.remove();
+ }
+
+ if(this._relativePosition){
+ delete this._relativePosition;
+ }
+ this._set("open", false);
+
+ return promise;
+ },
+
+ resize: function(dim){
+ // summary:
+ // Called with no argument when viewport scrolled or viewport size changed. Adjusts Dialog as
+ // necessary to keep it visible.
+ //
+ // Can also be called with an argument (by dojox/layout/ResizeHandle etc.) to explicitly set the
+ // size of the dialog.
+ // dim: Object?
+ // Optional dimension object like {w: 200, h: 300}
+
+ if(this.domNode.style.display != "none"){
+
+ this._checkIfSingleChild();
+
+ if(!dim){
+ if(this._shrunk){
+ // If we earlier shrunk the dialog to fit in the viewport, reset it to its natural size
+ if(this._singleChild){
+ if(typeof this._singleChildOriginalStyle != "undefined"){
+ this._singleChild.domNode.style.cssText = this._singleChildOriginalStyle;
+ delete this._singleChildOriginalStyle;
+ }
+ }
- array.forEach([this.domNode, this.containerNode, this.titleBar], function(node){
- domStyle.set(node, {
- position: "static",
- width: "auto",
- height: "auto"
- });
++ array.forEach([this.domNode, this.containerNode, this.titleBar, this.actionBarNode], function(node){
++ if(node){ // because titleBar may not be defined
++ domStyle.set(node, {
++ position: "static",
++ width: "auto",
++ height: "auto"
++ });
++ }
+ });
+ this.domNode.style.position = "absolute";
+ }
+
+ // If necessary, shrink Dialog to fit in viewport and have some space around it
+ // to indicate that it's a popup. This will also compensate for possible scrollbars on viewport.
+ var viewport = winUtils.getBox(this.ownerDocument);
+ viewport.w *= this.maxRatio;
+ viewport.h *= this.maxRatio;
+
+ var bb = domGeometry.position(this.domNode);
+ if(bb.w >= viewport.w || bb.h >= viewport.h){
+ dim = {
+ w: Math.min(bb.w, viewport.w),
+ h: Math.min(bb.h, viewport.h)
+ };
+ this._shrunk = true;
+ }else{
+ this._shrunk = false;
+ }
+ }
+
+ // Code to run if user has requested an explicit size, or the shrinking code above set an implicit size
+ if(dim){
+ // Set this.domNode to specified size
+ domGeometry.setMarginBox(this.domNode, dim);
+
+ // And then size this.containerNode
- var contentDim = utils.marginBox2contentBox(this.domNode, dim),
- centerSize = {domNode: this.containerNode, region: "center"};
- utils.layoutChildren(this.domNode, contentDim,
- [ {domNode: this.titleBar, region: "top"}, centerSize ]);
++ var layoutNodes = [];
++ if(this.titleBar){
++ layoutNodes.push({domNode: this.titleBar, region: "top"});
++ }
++ if(this.actionBarNode){
++ layoutNodes.push({domNode: this.actionBarNode, region: "bottom"});
++ }
++ var centerSize = {domNode: this.containerNode, region: "center"};
++ layoutNodes.push(centerSize);
++
++ var contentDim = utils.marginBox2contentBox(this.domNode, dim);
++ utils.layoutChildren(this.domNode, contentDim, layoutNodes);
+
+ // And then if this.containerNode has a single layout widget child, size it too.
+ // Otherwise, make this.containerNode show a scrollbar if it's overflowing.
+ if(this._singleChild){
+ var cb = utils.marginBox2contentBox(this.containerNode, centerSize);
+ // note: if containerNode has padding singleChildSize will have l and t set,
+ // but don't pass them to resize() or it will doubly-offset the child
+ this._singleChild.resize({w: cb.w, h: cb.h});
+ // TODO: save original size for restoring it on another show()?
+ }else{
+ this.containerNode.style.overflow = "auto";
+ this._layoutChildren(); // send resize() event to all child widgets
+ }
+ }else{
+ this._layoutChildren(); // send resize() event to all child widgets
+ }
+
+ if(!has("touch") && !dim){
+ // If the user has scrolled the viewport then reposition the Dialog. But don't do it for touch
+ // devices, because it will counteract when a keyboard pops up and then the browser auto-scrolls
+ // the focused node into view.
+ this._position();
+ }
+ }
+ },
+
+ _layoutChildren: function(){
+ // Override _ContentPaneResizeMixin._layoutChildren because even when there's just a single layout child
+ // widget, sometimes we don't want to size it explicitly (i.e. to pass a dim argument to resize())
+
+ array.forEach(this.getChildren(), function(widget){
+ if(widget.resize){
+ widget.resize();
+ }
+ });
+ },
+
+ destroy: function(){
+ if(this._fadeInDeferred){
+ this._fadeInDeferred.cancel();
+ }
+ if(this._fadeOutDeferred){
+ this._fadeOutDeferred.cancel();
+ }
+ if(this._moveable){
+ this._moveable.destroy();
+ }
+ var h;
+ while(h = this._modalconnects.pop()){
+ h.remove();
+ }
+
+ DialogLevelManager.hide(this);
+
+ this.inherited(arguments);
+ }
+ });
+
+ if(has("dojo-bidi")){
+ _DialogBase = declare("dijit._DialogBase", _DialogBase, {
+ _setTitleAttr: function(/*String*/ title){
+ this._set("title", title);
+ this.titleNode.innerHTML = title;
+ this.applyTextDir(this.titleNode);
+ },
+
+ _setTextDirAttr: function(textDir){
+ if(this._created && this.textDir != textDir){
+ this._set("textDir", textDir);
+ this.set("title", this.title);
+ }
+ }
+ });
+ }
+
+ var Dialog = declare("dijit.Dialog", [ContentPane, _DialogBase], {
+ // summary:
+ // A modal dialog Widget.
+ // description:
+ // Pops up a modal dialog window, blocking access to the screen
+ // and also graying out the screen Dialog is extended from
+ // ContentPane so it supports all the same parameters (href, etc.).
+ // example:
+ // | <div data-dojo-type="dijit/Dialog" data-dojo-props="href: 'test.html'"></div>
+ // example:
+ // | var foo = new Dialog({ title: "test dialog", content: "test content" });
+ // | foo.placeAt(win.body());
+ // | foo.startup();
+ });
+ Dialog._DialogBase = _DialogBase; // for monkey patching and dojox/widget/DialogSimple
+
+ var DialogLevelManager = Dialog._DialogLevelManager = {
+ // summary:
+ // Controls the various active "levels" on the page, starting with the
+ // stuff initially visible on the page (at z-index 0), and then having an entry for
+ // each Dialog shown.
+
+ _beginZIndex: 950,
+
+ show: function(/*dijit/_WidgetBase*/ dialog, /*Object*/ underlayAttrs){
+ // summary:
+ // Call right before fade-in animation for new dialog.
+ // Saves current focus, displays/adjusts underlay for new dialog,
+ // and sets the z-index of the dialog itself.
+ //
+ // New dialog will be displayed on top of all currently displayed dialogs.
+ //
+ // Caller is responsible for setting focus in new dialog after the fade-in
+ // animation completes.
+
+ // Save current focus
+ ds[ds.length - 1].focus = focus.curNode;
+
+ // Set z-index a bit above previous dialog
+ var zIndex = ds[ds.length - 1].dialog ? ds[ds.length - 1].zIndex + 2 : Dialog._DialogLevelManager._beginZIndex;
+ domStyle.set(dialog.domNode, 'zIndex', zIndex);
+
+ // Display the underlay, or if already displayed then adjust for this new dialog
+ DialogUnderlay.show(underlayAttrs, zIndex - 1);
+
+ ds.push({dialog: dialog, underlayAttrs: underlayAttrs, zIndex: zIndex});
+ },
+
+ hide: function(/*dijit/_WidgetBase*/ dialog){
+ // summary:
+ // Called when the specified dialog is hidden/destroyed, after the fade-out
+ // animation ends, in order to reset page focus, fix the underlay, etc.
+ // If the specified dialog isn't open then does nothing.
+ //
+ // Caller is responsible for either setting display:none on the dialog domNode,
+ // or calling dijit/popup.hide(), or removing it from the page DOM.
+
+ if(ds[ds.length - 1].dialog == dialog){
+ // Removing the top (or only) dialog in the stack, return focus
+ // to previous dialog
+
+ ds.pop();
+
+ var pd = ds[ds.length - 1]; // the new active dialog (or the base page itself)
+
+ // Adjust underlay
+ if(ds.length == 1){
+ // Returning to original page. Hide the underlay.
+ DialogUnderlay.hide();
+ }else{
+ // Popping back to previous dialog, adjust underlay.
+ DialogUnderlay.show(pd.underlayAttrs, pd.zIndex - 1);
+ }
+
+ // Adjust focus.
+ // TODO: regardless of setting of dialog.refocus, if the exeucte() method set focus somewhere,
+ // don't shift focus back to button. Note that execute() runs at the start of the fade-out but
+ // this code runs later, at the end of the fade-out. Menu has code like this.
+ if(dialog.refocus){
+ // If we are returning control to a previous dialog but for some reason
+ // that dialog didn't have a focused field, set focus to first focusable item.
+ // This situation could happen if two dialogs appeared at nearly the same time,
+ // since a dialog doesn't set it's focus until the fade-in is finished.
+ var focus = pd.focus;
+ if(pd.dialog && (!focus || !dom.isDescendant(focus, pd.dialog.domNode))){
+ pd.dialog._getFocusItems();
+ focus = pd.dialog._firstFocusItem;
+ }
+
+ if(focus){
+ // Refocus the button that spawned the Dialog. This will fail in corner cases including
+ // page unload on IE, because the dijit/form/Button that launched the Dialog may get destroyed
+ // before this code runs. (#15058)
+ try{
+ focus.focus();
+ }catch(e){
+ }
+ }
+ }
+ }else{
+ // Removing a dialog out of order (#9944, #10705).
+ // Don't need to mess with underlay or z-index or anything.
+ var idx = array.indexOf(array.map(ds, function(elem){
+ return elem.dialog;
+ }), dialog);
+ if(idx != -1){
+ ds.splice(idx, 1);
+ }
+ }
+ },
+
+ isTop: function(/*dijit/_WidgetBase*/ dialog){
+ // summary:
+ // Returns true if specified Dialog is the top in the task
+ return ds[ds.length - 1].dialog == dialog;
+ }
+ };
+
+ // Stack representing the various active "levels" on the page, starting with the
+ // stuff initially visible on the page (at z-index 0), and then having an entry for
+ // each Dialog shown.
+ // Each element in stack has form {
+ // dialog: dialogWidget,
+ // focus: returnFromGetFocus(),
+ // underlayAttrs: attributes to set on underlay (when this widget is active)
+ // }
+ var ds = Dialog._dialogStack = [
+ {dialog: null, focus: null, underlayAttrs: null} // entry for stuff at z-index: 0
+ ];
+
+ // If focus was accidentally removed from the dialog, such as if the user clicked a blank
+ // area of the screen, or clicked the browser's address bar and then tabbed into the page,
+ // then refocus. Won't do anything if focus was removed because the Dialog was closed, or
+ // because a new Dialog popped up on top of the old one, or when focus moves to popups
+ focus.watch("curNode", function(attr, oldNode, node){
+ // Note: if no dialogs, ds.length==1 but ds[ds.length-1].dialog is null
+ var topDialog = ds[ds.length - 1].dialog;
+
+ // If a node was focused, and there's a Dialog currently showing, and not in the process of fading out...
+ // Ignore focus events on other document though because it's likely an Editor inside of the Dialog.
+ if(node && topDialog && !topDialog._fadeOutDeferred && node.ownerDocument == topDialog.ownerDocument){
+ // If the node that was focused is inside the dialog or in a popup, even a context menu that isn't
+ // technically a descendant of the the dialog, don't do anything.
+ do{
+ if(node == topDialog.domNode || domClass.contains(node, "dijitPopup")){ return; }
+ }while(node = node.parentNode);
+
+ // Otherwise, return focus to the dialog. Use a delay to avoid confusing dijit/focus code's
+ // own tracking of focus.
+ topDialog.focus();
+ }
+ });
+
+ // Back compat w/1.6, remove for 2.0
+ if(has("dijit-legacy-requires")){
+ ready(0, function(){
+ var requires = ["dijit/TooltipDialog"];
+ require(requires); // use indirection so modules not rolled into a build
+ });
+ }
+
+ return Dialog;
+});
diff --cc dijit/package.json
index 1eee170,0000000..5cd69d5
mode 100644,000000..100644
--- a/dijit/package.json
+++ b/dijit/package.json
@@@ -1,26 -1,0 +1,26 @@@
+{
+ "name": "dijit",
- "version":"1.10.3",
++ "version":"1.10.4",
+ "directories": {
+ "lib": "."
+ },
+ "main":"main",
+ "dependencies": {
- "dojo":"1.10.3"
++ "dojo":"1.10.4"
+ },
+ "description": "Dijit provides a complete collection of user interface controls based on Dojo, giving you the power to create web applications that are highly optimized for usability, performance, internationalization, accessibility, but above all deliver an incredible user experience.",
+ "licenses": [
+ {
+ "type": "AFLv2.1",
+ "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L43"
+ },
+ {
+ "type": "BSD",
+ "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L13"
+ }
+ ],
+ "bugs": "http://bugs.dojotoolkit.org/",
+ "keywords": ["JavaScript", "Dojo", "Widget"],
+ "homepage": "http://dojotoolkit.org/",
+ "dojoBuild": "dijit.profile.js"
+}
diff --cc dijit/tests/ConfirmDialog.html
index 0000000,0000000..2962a02
new file mode 100644
--- /dev/null
+++ b/dijit/tests/ConfirmDialog.html
@@@ -1,0 -1,0 +1,76 @@@
++<!DOCTYPE html>
++<html>
++<head>
++ <title>ConfirmDialog Widget Automated (non-robot) Tests</title>
++
++ <script src="boilerplate.js"></script>
++
++ <script type="text/javascript">
++ require([
++ "doh/runner",
++ "dojo/_base/declare", "dojo/dom", "dojo/dom-geometry", "dojo/dom-style", "dojo/window",
++ "dijit/focus", "dijit/registry", "dijit/ConfirmDialog", "dijit/DialogUnderlay", "dijit/_WidgetBase",
++ "dijit/tests/helpers", "dojo/domReady!"
++ ], function(doh, declare, dom, domGeom, domStyle, winUtils,
++ focus, registry, ConfirmDialog, DialogUnderlay, _WidgetBase, helpers){
++
++ doh.register("resize", [
++ {
++ name: "create",
++ timeout: 10000,
++ runTest: function () {
++ // Create and show ConfirmDialog
++ dlg1 = new ConfirmDialog({
++ id: "dlg1",
++ title: "ConfirmDialog 1",
++ content: "<input id='dlg1_inputA'><br>" +
++ "<input id='dlg1_inputB'><br>" +
++ "<input id='dlg1_inputC'><br>" +
++ "<input id='dlg1_inputD'><br>" +
++ "<input id='dlg1_inputE'><br>" +
++ "<input id='dlg1_inputF'><br>" +
++ "<input id='dlg1_inputG'><br>" +
++ "<input id='dlg1_inputH'><br>"
++ });
++
++ return dlg1.show().then(function() {
++ doh.t(helpers.isVisible(dlg1), "ConfirmDialog 1 is visible");
++ });
++ }
++ },
++
++ {
++ name: "resize",
++ timeout: 10000,
++ runTest: function(){
++ dlg1.resize({h: 150, w: 300});
++
++ var domPos = domGeom.position(dlg1.domNode);
++ doh.is(150, domPos.h, "domNode.h");
++ doh.is(300, domPos.w, "domNode.w");
++
++ // dialog should show title, containerNode, then finally actionBar
++ var titlePos = domGeom.position(dlg1.titleBar),
++ containerPos = domGeom.position(dlg1.containerNode),
++ actionBarPos = domGeom.position(dlg1.actionBarNode);
++ doh.t(Math.abs(titlePos.h + containerPos.h + actionBarPos.h - 148) < 1, "heights add up");
++ doh.t(titlePos.h > 0, "title has height");
++ doh.t(containerPos.h > 0, "container has height");
++ doh.t(actionBarPos.h > 0, "container has height");
++
++ // and the containerNode should have a scroll bar
++ doh.is("auto", dlg1.containerNode.style.overflow, "overflow style");
++ }
++ }
++ ]);
++
++ doh.run();
++ });
++ </script>
++</head>
++<body>
++ <h1 class="testTitle">Dijit ConfirmDialog Automated (non-robot) tests</h1>
++</body>
++</html>
++
++
diff --cc dijit/tests/Dialog.html
index f877538,0000000..6c3b5c9
mode 100644,000000..100644
--- a/dijit/tests/Dialog.html
+++ b/dijit/tests/Dialog.html
@@@ -1,659 -1,0 +1,687 @@@
+<!DOCTYPE html>
+<html>
+<head>
+ <title>Dialog Widget Automated (non-robot) Tests</title>
+
+ <script src="boilerplate.js"></script>
+
+ <script type="text/javascript">
+ require([
+ "doh/runner",
+ "dojo/_base/declare", "dojo/dom", "dojo/dom-geometry", "dojo/dom-style", "dojo/window",
+ "dijit/focus", "dijit/registry", "dijit/Dialog", "dijit/DialogUnderlay", "dijit/_WidgetBase",
+ "dijit/tests/helpers", "dojo/domReady!"
+ ], function(doh, declare, dom, domGeom, domStyle, winUtils,
+ focus, registry, Dialog, DialogUnderlay, _WidgetBase, helpers){
+ // Non robot tests to see if nested dialogs work correctly
+ // when obscured dialogs are destroyed/hidden, on race conditions of
+ // multiple dialogs fading in/out at once, etc.
+
+ doh.register("setup", function(){
+ // Start focus on a button on the page (although we aren't going
+ // to click the button)
+ var d = new doh.Deferred();
+
+ setTimeout(d.getTestErrback(function(){
+ dom.byId("button").focus();
+
+ setTimeout(d.getTestCallback(function(){
+ doh.is("button", focus.curNode.id, "focus is on the main page");
+ }), 100);
+ }), 300);
+
+ return d;
+ });
+
+ doh.register("out-of-order dialog hide/destroy", [
+ {
+ name: "open first dialog",
+ timeout: 10000,
+ runTest: function(){
+ var d = new doh.Deferred(),
+ dlg1;
+
+ // Create and show first dialog
+ dlg1 = new Dialog({
+ id: "dlg1",
+ title: "dialog 1",
+ content:
+ "<input id='dlg1_inputA'><br>" +
+ "<input id='dlg1_inputB'><br>" +
+ "<input id='dlg1_inputC'><br>" +
+ "<input id='dlg1_inputD'><br>" +
+ "<input id='dlg1_inputE'><br>" +
+ "<input id='dlg1_inputF'><br>" +
+ "<input id='dlg1_inputG'><br>" +
+ "<input id='dlg1_inputH'><br>"
+ });
+ dlg1.show().then(d.getTestCallback(function(){
+ doh.t(helpers.isVisible(dlg1), "dialog 1 is visible");
+
+ var dialog1Z = domStyle.get(dlg1.domNode, "zIndex"),
+ underlayZ = domStyle.get(DialogUnderlay._singleton.domNode, "zIndex");
+
+ doh.t(dialog1Z > underlayZ, "dialog1 (zIndex=" + dialog1Z +
+ ") above underlay (zIndex=" + underlayZ + ")");
+
+ doh.is("dlg1_inputA", focus.curNode.id, "focus is on the first field");
+
+ // For back-compat, startup() should be called on children even if Dialog.startup()
+ // isn't called explicitly.
+ doh.t(dlg1._started, "dlg1 started");
+ }));
+
+ return d;
+ }
+ },
+ {
+ name: "open second dialog",
+ timeout: 20000,
+ runTest: function(){
+ var d = new doh.Deferred(),
+ dlg1 = registry.byId("dlg1"),
+ dlg2;
+
+ // Create and show second dialog
+ dlg2 = new Dialog({
+ id: "dlg2",
+ title: "dialog 2",
+ content:
+ "<input id='dlg2_inputA'><br>" +
+ "<input id='dlg2_inputB'><br>" +
+ "<input id='dlg2_inputC'><br>" +
+ "<input id='dlg2_inputD'><br>" +
+ "<input id='dlg2_inputE'><br>" +
+ "<input id='dlg2_inputF'><br>"
+ });
+ dlg2.show().then(d.getTestCallback(function(){
+ doh.t(helpers.isVisible(dlg2), "dialog 2 is visible");
+
+ var dialog1Z = domStyle.get(dlg1.domNode, "zIndex"),
+ dialog2Z = domStyle.get(dlg2.domNode, "zIndex"),
+ underlayZ = domStyle.get(DialogUnderlay._singleton.domNode, "zIndex");
+
+ doh.t(underlayZ > dialog1Z, "underlay (zIndex=" + underlayZ +
+ ") above dialog1 (zIndex=" + dialog1Z + ")");
+ doh.t(dialog2Z > underlayZ, "dialog2 (zIndex=" + dialog2Z +
+ ") above underlay (zIndex=" + underlayZ + ")");
+
+ doh.is("dlg2_inputA", focus.curNode.id, "focus is on the first field");
+ }));
+
+ return d;
+ }
+ },
+ {
+ name: "destroy first dialog",
+ timeout: 20000,
+ runTest: function(){
+ var d = new doh.Deferred(),
+ dlg1 = registry.byId("dlg1"),
+ dlg2 = registry.byId("dlg2");
+
+ dlg1.destroy();
+
+ setTimeout(d.getTestCallback(function(){
+ doh.t(helpers.isVisible(dlg2), "dialog 2 is still visible");
+ doh.t(helpers.isVisible(DialogUnderlay._singleton), "underlay is still visible");
+
+ doh.is("dlg2_inputA", focus.curNode.id, "dialog 2 still has focus");
+
+ var dialog2Z = domStyle.get(dlg2.domNode, "zIndex"),
+ underlayZ = domStyle.get(DialogUnderlay._singleton.domNode, "zIndex");
+
+ doh.t(dialog2Z > underlayZ, "dialog2 (zIndex=" + dialog2Z +
+ ") above underlay (zIndex=" + underlayZ + ")");
+
+ }), 2000);
+
+ return d;
+ }
+ },
+ {
+ name: "open third dialog",
+ timeout: 20000,
+ runTest: function(){
+ var d = new doh.Deferred(),
+ dlg2 = registry.byId("dlg2"),
+ dlg3;
+
+ // Create and show third dialog
+ dlg3 = new Dialog({
+ id: "dlg3",
+ title: "dialog 3",
+ content:
+ "<input id='dlg3_inputA'><br>" +
+ "<input id='dlg3_inputB'><br>" +
+ "<input id='dlg3_inputC'><br>" +
+ "<input id='dlg3_inputD'><br>"
+
+ });
+ dlg3.show().then(d.getTestCallback(function(){
+ doh.t(helpers.isVisible(dlg3), "dialog 3 is visible");
+
+ // Even though a dialog was deleted, the zIndex of the dialog 3
+ // should be above dialog 2. This test is to make sure we don't
+ // merely use _dialogStack.length to compute zIndex
+ var dialog2Z = domStyle.get(dlg2.domNode, "zIndex"),
+ dialog3Z = domStyle.get(dlg3.domNode, "zIndex"),
+ underlayZ = domStyle.get(DialogUnderlay._singleton.domNode, "zIndex");
+ doh.t(underlayZ > dialog2Z, "underlay (zIndex=" + underlayZ +
+ ") above dialog2 (zIndex=" + dialog2Z + ")");
+ doh.t(dialog3Z > underlayZ, "dialog3 (zIndex=" + dialog3Z +
+ ") above underlay (zIndex=" + underlayZ + ")");
+
+ doh.is("dlg3_inputA", focus.curNode.id, "focus is on the first field");
+ }));
+
+ return d;
+ }
+ },
+ {
+ name: "open fourth dialog",
+ timeout: 30000,
+ runTest: function(){
+ var d = new doh.Deferred(),
+ dlg3 = registry.byId("dlg3"),
+ dlg4;
+
+ // Create and show fourth dialog
+ dlg4 = new Dialog({
+ id: "dlg4",
+ title: "dialog 4",
+ content:
+ "<input id='dlg4_inputA'><br>" +
+ "<input id='dlg4_inputB'>"
+ });
+ dlg4.show().then(d.getTestCallback(function(){
+ doh.t(helpers.isVisible(dlg4), "dialog 4 is visible");
+
+ var dialog3Z = domStyle.get(dlg3.domNode, "zIndex"),
+ dialog4Z = domStyle.get(dlg4.domNode, "zIndex"),
+ underlayZ = domStyle.get(DialogUnderlay._singleton.domNode, "zIndex");
+ doh.t(underlayZ > dialog3Z, "underlay (zIndex=" + underlayZ +
+ ") above dialog3 (zIndex=" + dialog3Z + ")");
+ doh.t(dialog4Z > underlayZ, "dialog4 (zIndex=" + dialog4Z +
+ ") above underlay (zIndex=" + underlayZ + ")");
+
+ doh.is("dlg4_inputA", focus.curNode.id, "focus is on the first field");
+ }));
+
+ return d;
+ }
+ },
+ {
+ name: "hide third dialog",
+ timeout: 40000,
+ runTest: function(){
+ var d = new doh.Deferred(),
+ dlg3 = registry.byId("dlg3"),
+ dlg4 = registry.byId("dlg4");
+
+ dlg3.hide().then(d.getTestCallback(function(){
+ doh.t(helpers.isVisible(dlg4), "dialog 4 is still visible");
+ doh.t(helpers.isVisible(DialogUnderlay._singleton), "underlay is still visible");
+
+ doh.is("dlg4_inputA", focus.curNode.id, "dialog 4 still has focus");
+
+ var dialog4Z = domStyle.get(dlg4.domNode, "zIndex"),
+ underlayZ = domStyle.get(DialogUnderlay._singleton.domNode, "zIndex");
+
+ doh.t(dialog4Z > underlayZ, "dialog4 (zIndex=" + dialog4Z +
+ ") above underlay (zIndex=" + underlayZ + ")");
+
+ }));
+
+ return d;
+ }
+ },
+ {
+ name: "close fourth dialog",
+ timeout: 30000,
+ runTest: function(){
+ var d = new doh.Deferred(),
+ dlg2 = registry.byId("dlg2"),
+ dlg3 = registry.byId("dlg3"),
+ dlg4 = registry.byId("dlg4");
+
+ // Closing fourth dialog should move focus to second dialog, since we already destroyed the
+ // third dialog. Delay needed for IE9+ where focus shift is asynchronous.
+ dlg4.hide().then(function(){
+ setTimeout(d.getTestCallback(function(){
+ doh.t(helpers.isHidden(dlg4), "dialog 4 is hidden");
+ doh.t(helpers.isHidden(dlg3), "dialog 3 is hidden");
+ doh.t(helpers.isVisible(dlg2), "dialog 2 is visible");
+
+ var dialog2Z = domStyle.get(dlg2.domNode, "zIndex"),
+ underlayZ = domStyle.get(DialogUnderlay._singleton.domNode, "zIndex");
+ doh.t(dialog2Z > underlayZ, "dialog2 (zIndex=" + dialog2Z +
+ ") above underlay (zIndex=" + underlayZ + ")");
+
+ doh.is("dlg2_inputA", focus.curNode.id, "focus is on the first field");
+ }));
+ });
+
+ return d;
+ }
+ },
+ {
+ name: "close second dialog",
+ timeout: 30000,
+ runTest: function(){
+ var d = new doh.Deferred(),
+ dlg2 = registry.byId("dlg2");
+
+ // Since we already destroyed first dialog, closing second dialog should hide underlay and
+ // revert focus to the main page. Need the setTimeout() for IE9+ where focus change is not
+ // instant.
+ dlg2.hide().then(function(){
+ setTimeout(d.getTestCallback(function(){
+ doh.t(helpers.isHidden(dlg2), "dialog 4 is hidden");
+ doh.t(helpers.isHidden(DialogUnderlay._singleton), "underlay hidden");
+
+ doh.is("button", focus.curNode.id, "focus is on the main page");
+ }));
+ });
+
+ return d;
+ }
+ }
+ ]);
+
+ var dlgA, dlgB;
+ doh.register("concurrent hide show (multiple dialogs)", {
+ name: "concurrent hide show",
+ timeout: 20000,
+ setUp: function(){
+ // Create and show first dialog
+ dlgA = new Dialog({
+ id: "dlgA",
+ title: "Dialog A",
+ content:
+ "<button type='button'>OK</button>"
+ });
+ dlgB = new Dialog({
+ id: "dlgB",
+ title: "dialog B",
+ content:
+ "<button type='button'>OK</button>"
+ });
+ dlgA.show();
+
+ },
+ runTest: function(){
+ var d = new doh.Deferred(),
+ cnt=0;
+
+ handle = setInterval(d.getTestErrback(function(){
+ var hidden = cnt%2 ? dlgA : dlgB,
+ shown = cnt%2 ? dlgB : dlgA;
+
+ if(cnt > 10){
+ clearInterval(handle);
+ handle = null;
+ d.callback(true);
+ return;
+ }
+
+ doh.t(helpers.isVisible(shown), shown.title + " visible");
+ doh.t(helpers.isHidden(hidden), hidden.title + " hidden");
+ doh.t(helpers.isVisible(DialogUnderlay._singleton), "underlay visible");
+
+ var shownZ = domStyle.get(shown.domNode, "zIndex"),
+ underlayZ = domStyle.get(DialogUnderlay._singleton.domNode, "zIndex");
+ doh.t(shownZ > underlayZ, "visible dialog (zIndex=" + shownZ +
+ ") above underlay (zIndex=" + underlayZ + ")");
+
+ hidden.show();
+ shown.hide();
+
+ cnt++;
+ }), 1000);
+
+ return d;
+ },
+ tearDown: function(){
+ dlgA.hide();
+ dlgB.hide();
+ if(handle){
+ clearInterval(handle);
+ }
+ }
+ });
+
+ var slow, fast;
+ doh.register("fast double show", [
+ function create(){
+ console.log("creating slow, fast");
+ var d = new doh.Deferred();
+ slow = new Dialog({
+ id: "slow",
+ title: "Dialog C",
+ content:
+ "Hello world " +
+ "<button type='button' id='slowOK' onfocus='window.slowFocused=true;'>OK</button>" +
+ "<button type='button' id='slowCancel'>Cancel</button>",
+ duration: 500
+ });
+ fast = new Dialog({
+ id: "fast",
+ title: "dialog D",
+ content:
+ "<button type='button'>OK</button>",
+ duration: 100
+ });
+
+ },
+ {
+ name: "show Dialog C then show Dialog D before Dialog C fade-in completes",
+ timeout: 20000,
+ runTest: function(){
+ var d = new doh.Deferred();
+
+ slow.show();
+
+ setTimeout(d.getTestErrback(function(){
+ fast.show();
+ }), slow.duration / 2);
+
+ setTimeout(d.getTestCallback(function(){
+ doh.t(helpers.isVisible(slow), "dialog C visible");
+ doh.t(helpers.isVisible(fast), "dialog D visible");
+ doh.f(window.slowFocused, "dialog C never got focus")
+ }), slow.duration * 2);
+ return d;
+ }
+ },
+ {
+ name: "close dialogD",
+ timeout: 20000,
+ runTest: function(){
+ var d = new doh.Deferred();
+
+ fast.hide();
+
+ setTimeout(d.getTestCallback(function(){
+ doh.is("slowOK", focus.curNode.id, "focused to dialog C");
+ doh.t(window.slowFocused, "onfocus handler working");
+ }), fast.duration * 2);
+
+ return d;
+ }
+ },
+ {
+ name: "close dialogC",
+ timeout: 20000,
+ runTest: function(){
+ return slow.hide();
+ }
+ }
+ ]);
+
+ doh.register("fast double hide", [
+ function create(){
+ var d = new doh.Deferred();
+
+ // Create a test dialog
+ dlg = new Dialog({
+ id: "doubleHide",
+ title: "Double Hide",
+ content: "Hello World",
+ duration: 100
+ });
+
+ // First show it
+ var secondHideCalled;
+ dlg.show().then(d.getTestErrback(function(){
+ // Then call hide(), as though user had clicked close icon.
+ // Return from this test when this hide() call completes.
+ dlg.hide().then(d.getTestCallback(function(){
+ doh.t(secondHideCalled, "hide() was called while hide() in progress and no problems");
+ dlg.hide(); // this should also have no effect
+ }));
+
+ // While first hide() is in progress, call hide() a few more times to make sure it
+ // doesn't break anything
+ dlg.hide(); // should do nothing
+ setTimeout(d.getTestErrback(function(){
+ dlg.hide(); // should also do nothing
+ secondHideCalled = true;
+ }), 10);
+ }));
+ return d;
+ }
+ ]);
+
+ doh.register("concurrent show hide (single dialog)", [
+ function show(){
+ var d = new doh.Deferred();
+
+ var onShowCtr = 0,
+ dlg = new Dialog({
+ id: "show",
+ title: "onShow Dialog",
+ content:"Hello world ",
+ onShow: function(){ onShowCtr++; }
+ });
+
+ doh.is(1, Dialog._dialogStack.length, "initially, no dialogs in stack");
+ dlg.show();
+ doh.is(1, onShowCtr, "onShow first time");
+ dlg.hide();
+ doh.is(1, onShowCtr, "onHide first time");
+ dlg.show();
+ doh.is(2, onShowCtr, "onShow second time");
+ dlg.hide().then(d.getTestCallback(function(){
+ doh.is(2, onShowCtr, "onHide second time");
+ doh.is(1, Dialog._dialogStack.length, "at end, no dialogs in stack");
+ }));
+
+ return d;
+ }
+ ]);
+
+ doh.register("zero duration", [
+ {
+ name: "open",
+ timeout: 10000,
+ runTest: function(){
+ dlg1 = new Dialog({
+ id: "dlg1",
+ title: "dialog 1",
+ duration: 0,
+ content: "<input id='dlg1_inputA'>"
+ });
+
+ var promise = dlg1.show();
+ doh.t(promise.isResolved(), "resolved");
+ doh.t(helpers.isVisible(dlg1), "dialog visible");
+ }
+ },
+ {
+ name: "close",
+ timeout: 10000,
+ runTest: function(){
+ var promise = dlg1.hide();
+ doh.t(promise.isResolved(), "resolved");
+ doh.t(helpers.isHidden(dlg1), "dialog hidden");
+ }
+ }
+ ]);
+
+ doh.register("show/hide return", [
+ {
+ name: "open",
+ timeout: 10000,
+ runTest: function(){
+ var d = new doh.Deferred();
+
+ dlg5 = new Dialog({
+ id: "dlg5",
+ title: "dialog 1",
+ content: "<input id='dlg1_inputA'>"
+ });
+
+ // This tests that show() returns a promise.
+ dlg5.show().then(d.getTestCallback(function(){
+ // And this tests that it still returns a promise even when the Dialog is already shown.
+ var promise = dlg5.show();
+ doh.t(promise.isResolved(), "resolved");
+ doh.t(helpers.isVisible(dlg5), "dialog visible");
+ }));
+
+ return d;
+ }
+ },
+ {
+ name: "close",
+ timeout: 10000,
+ runTest: function(){
+ var d = new doh.Deferred();
+
+ // This tests that hide() returns a promise.
+ dlg5.hide().then(d.getTestCallback(function(){
+ // And this tests that it still returns a promise even when the Dialog is already hidden.
+ var promise = dlg5.hide();
+ doh.t(promise.isResolved(), "resolved");
+ doh.t(helpers.isHidden(dlg5), "dialog hidden");
+ }));
+
+ return d;
+ }
+ }
+ ]);
+
+ LayoutWidget = declare(_WidgetBase, {
+ resize: function(dim){
+ this._resized = true;
+ this._resizeArg = dim;
+ }
+ });
+
+ doh.register("sizing", [
+ {
+ name: "href",
+ timeout: 10000,
+ runTest: function(){
+ hrefDlg = new Dialog({
+ id: "bigHref",
+ title: "big dialog with href",
+ href: "loremIpsum"
+ });
+
+ return hrefDlg.show().then(function(){
+ var dlgPos = domGeom.position(hrefDlg.domNode),
+ viewport = winUtils.getBox();
+ doh.t(dlgPos.h < viewport.h, "viewport height");
+ doh.t(dlgPos.y > 0, "position");
+ });
+ }
+ },
+ {
+ name: "resize",
+ timeout: 10000,
+ runTest: function(){
+ hrefDlg.resize({h: 200, w: 300});
+
+ var domPos = domGeom.position(hrefDlg.domNode);
+ doh.is(200, domPos.h, "domNode.h");
+ doh.is(300, domPos.w, "domNode.w");
+
+ // containerNode should be slightly smaller
+ var containerPos = domGeom.position(hrefDlg.containerNode);
+ doh.t(containerPos.h > 150 && containerPos.h < 190, "containerNode.h " + containerPos.h);
- doh.is(298, containerPos.w, "containerNode.h " + containerPos.h);
++ doh.is(298, containerPos.w, "containerNode.w");
+ doh.is("auto", hrefDlg.containerNode.style.overflow, "overflow style")
+ }
+ },
+ {
+ name: "single layout child",
+ timeout: 10000,
+ runTest: function(){
+ single = new Dialog({
+ id: "singleLayoutChild",
+ title: "single layout child",
+ content: "<div data-dojo-type=LayoutWidget data-dojo-id=layout1></div>"
+ });
+
+ // resize() should be called on the child layout widget, but without any size specified,
+ // because the Dialog itself doesn't have a size specified
+ single.show();
+ doh.t(layout1._resized, "resized");
+ doh.is(undefined, layout1._resizeArg, "resize arg");
+
+ // Calling resize on the Dialog should resize the single layout child widget
+ single.resize({h: 200, w: 300});
+ doh.isNot(undefined, layout1._resizeArg, "resize arg");
+ doh.t(layout1._resizeArg.h > 150 && layout1._resizeArg.h < 190, "single child resize() call param");
+ }
+ },
+ {
+ name: "multiple layout children",
+ timeout: 10000,
+ runTest: function(){
+ multiple = new Dialog({
+ id: "multipleLayoutChildren",
+ title: "multiple layout children",
+ content:
+ "<div data-dojo-type=LayoutWidget data-dojo-id=layout2></div>" +
+ "<div data-dojo-type=LayoutWidget data-dojo-id=layout3></div>"
+ });
+
+ // resize() should be called on each child layout widget, but without any size specified
+ multiple.show();
+ doh.t(layout2._resized, "layout2 resized");
+ doh.is(undefined, layout2._resizeArg, "layout2 resize arg");
+ doh.t(layout3._resized, "layout3 resized");
+ doh.is(undefined, layout3._resizeArg, "layout3 resize arg");
+
+ // Calling resize on the Dialog might resize the layout child widgets, but they still
+ // shouldn't get a size specified
+ multiple.resize({h: 200, w: 300});
+ doh.is(undefined, layout2._resizeArg, "layout2 resize arg after dialog resize");
+ doh.is(undefined, layout3._resizeArg, "layout3 resize arg after dialog resize");
+ }
- }
++ },
++
++ // titlebar is optional for back-compat and to support dojox.image.LightboxDialog
++ {
++ name: "no titlebar node",
++ timeout: 10000,
++ runTest: function() {
++ noTbDialog = new Dialog({
++ id: "noTbDialog",
++ templateString: '<div style="border: 1px solid black">' +
++ '<span data-dojo-attach-point="closeButtonNode" role="button" tabindex="-1">x</span>' +
++ '<div data-dojo-attach-point="containerNode"></div>' +
++ "</div>",
++ content: "custom template w/no titlebar"
++ });
+
++ return noTbDialog.show().then(function () {
++ noTbDialog.resize({h: 200, w: 300});
++
++ var domPos = domGeom.position(noTbDialog.domNode);
++ doh.is(200, domPos.h, "domNode.h");
++ doh.is(300, domPos.w, "domNode.w");
++
++ // containerNode should be slightly smaller
++ var containerPos = domGeom.position(noTbDialog.containerNode);
++ doh.is(198, containerPos.h, "containerNode.h");
++ doh.is(298, containerPos.w, "containerNode.w");
++ });
++ }
++ }
+ ]);
+
+ doh.run();
+ });
+ </script>
+</head>
+<body>
+ <h1 class="testTitle">Dijit Dialog Automated (non-robot) tests</h1>
+ <button id="button">focus point</button>
+</body>
+</html>
+
+
diff --cc dijit/tests/general-module.js
index 753ae72,0000000..3554093
mode 100644,000000..100644
--- a/dijit/tests/general-module.js
+++ b/dijit/tests/general-module.js
@@@ -1,67 -1,0 +1,70 @@@
+define(["doh/main", "require", "dojo/sniff"], function(doh, require, has){
+
+ var test_robot = !has("ios") && !has("android");
+
+ // top level widget tests
+ doh.register("Bidi", require.toUrl("./Bidi.html"), 999999);
+
+ doh.register("Menu", require.toUrl("./Menu.html"), 999999);
+ if(test_robot){
+ doh.register("robot.Menu_mouse", require.toUrl("./robot/Menu_mouse.html"), 999999);
+ doh.register("robot.Menu_a11y", require.toUrl("./robot/Menu_a11y.html"), 999999);
+ doh.register("robot.Menu_iframe", require.toUrl("./robot/Menu_iframe.html"), 999999);
+ }
+
+ doh.register("Dialog", require.toUrl("./Dialog.html"), 999999);
+ if(test_robot){
+ doh.register("robot.Dialog_mouse", require.toUrl("./robot/Dialog_mouse.html"), 999999);
+ doh.register("robot.Dialog_a11y", require.toUrl("./robot/Dialog_a11y.html"), 999999);
+ doh.register("robot.Dialog_focusDestroy", require.toUrl("./robot/Dialog_focusDestroy.html"), 999999);
++ }
++ doh.register("ConfirmDialog", require.toUrl("./ConfirmDialog.html"), 999999);
++ if(test_robot){
+ doh.register("robot.ConfirmDialog_a11y", require.toUrl("./robot/ConfirmDialog_a11y.html"), 999999);
+ }
+
+ doh.register("ProgressBar", require.toUrl("./ProgressBar.html"), 999999);
+
+ if(test_robot){
+ doh.register("robot.Tooltip_a11y", require.toUrl("./robot/Tooltip_a11y.html"), 999999);
+ doh.register("robot.Tooltip_mouse", require.toUrl("./robot/Tooltip_mouse.html"), 999999);
+ doh.register("robot.Tooltip_mouse_quirks", require.toUrl("./robot/Tooltip_mouse_quirks.html"), 999999);
+ }
+ doh.register("Tooltip-placement", require.toUrl("./Tooltip-placement.html"), 999999);
+
+ doh.register("TooltipDialog", require.toUrl("./TooltipDialog.html"), 999999);
+ if(test_robot){
+ doh.register("robot.TooltipDialog_mouse", require.toUrl("./robot/TooltipDialog_mouse.html"), 999999);
+ doh.register("robot.TooltipDialog_a11y", require.toUrl("./robot/TooltipDialog_a11y.html"), 999999);
+ doh.register("robot.ConfirmTooltipDialog_a11y", require.toUrl("./robot/ConfirmTooltipDialog_a11y.html"), 999999);
+ }
+
+ if(test_robot){
+ doh.register("robot.InlineEditBox", require.toUrl("./robot/InlineEditBox.html"), 999999);
+ }
+
+ if(test_robot){
+ doh.register("robot.ColorPalette", require.toUrl("./robot/ColorPalette.html"), 999999);
+ }
+
+ doh.register("CalendarLite", require.toUrl("./CalendarLite.html"), 999999);
+ if(test_robot){
+ doh.register("robot.Calendar_a11y", require.toUrl("./robot/Calendar_a11y.html"), 999999);
+ }
+
+ if(test_robot){
+ doh.register("robot.TitlePane", require.toUrl("./robot/TitlePane.html"), 999999);
+ }
+
+ doh.register("Fieldset", require.toUrl("./Fieldset.html"), 999999);
+ if(test_robot){
+ doh.register("robot.Fieldset", require.toUrl("./robot/Fieldset.html"), 999999);
+ }
+
+ if(test_robot){
+ doh.register("robot.Toolbar", require.toUrl("./robot/Toolbar.html"), 999999);
+ }
+
+ doh.register("_TimePicker", require.toUrl("./_TimePicker.html"), 999999);
+
+});
diff --cc dojox/calendar/CONTRIBUTING.md
index 5ae012f,0000000..5ae012f
mode 100644,000000..100755
--- a/dojox/calendar/CONTRIBUTING.md
+++ b/dojox/calendar/CONTRIBUTING.md
diff --cc dojox/calendar/LICENSE
index b064ab1,0000000..b064ab1
mode 100644,000000..100755
--- a/dojox/calendar/LICENSE
+++ b/dojox/calendar/LICENSE
diff --cc dojox/calendar/nls/bg/buttons.js
index 61eb2fc,0000000..61eb2fc
mode 100644,000000..100755
--- a/dojox/calendar/nls/bg/buttons.js
+++ b/dojox/calendar/nls/bg/buttons.js
diff --cc dojox/calendar/nls/he/buttons.js
index 9271cba,0000000..9271cba
mode 100644,000000..100755
--- a/dojox/calendar/nls/he/buttons.js
+++ b/dojox/calendar/nls/he/buttons.js
diff --cc dojox/calendar/nls/hr/buttons.js
index 93aadf2,0000000..93aadf2
mode 100644,000000..100755
--- a/dojox/calendar/nls/hr/buttons.js
+++ b/dojox/calendar/nls/hr/buttons.js
diff --cc dojox/calendar/nls/uk/buttons.js
index 76522dc,0000000..76522dc
mode 100644,000000..100755
--- a/dojox/calendar/nls/uk/buttons.js
+++ b/dojox/calendar/nls/uk/buttons.js
diff --cc dojox/calendar/tests/hcalendar.html
index 2721891,0000000..2721891
mode 100644,000000..100755
--- a/dojox/calendar/tests/hcalendar.html
+++ b/dojox/calendar/tests/hcalendar.html
diff --cc dojox/dgauges/CONTRIBUTING.md
index 5ae012f,0000000..5ae012f
mode 100644,000000..100755
--- a/dojox/dgauges/CONTRIBUTING.md
+++ b/dojox/dgauges/CONTRIBUTING.md
diff --cc dojox/layout/ResizeHandle.js
index e8b52c2,0000000..3478e26
mode 100644,000000..100644
--- a/dojox/layout/ResizeHandle.js
+++ b/dojox/layout/ResizeHandle.js
@@@ -1,389 -1,0 +1,389 @@@
+define(["dojo/_base/kernel","dojo/_base/lang","dojo/_base/connect","dojo/_base/array","dojo/_base/event",
+ "dojo/_base/fx","dojo/_base/window","dojo/fx","dojo/dom","dojo/dom-class",
+ "dojo/dom-geometry","dojo/dom-style","dojo/_base/declare", "dojo/touch",
- "dijit/_base/manager","dijit/_Widget","dijit/_TemplatedMixin",
++ "dijit/_base/manager","dijit/_Widget","dijit/_TemplatedMixin"
+ ], function (
+ kernel, lang, connect, arrayUtil, eventUtil, fxBase, windowBase, fxUtil,
+ domUtil, domClass, domGeometry, domStyle, declare, touch, manager, Widget, TemplatedMixin) {
+
+kernel.experimental("dojox.layout.ResizeHandle");
+
+var _ResizeHelper = declare("dojox.layout._ResizeHelper", Widget, {
+ // summary:
+ // A global private resize helper shared between any
+ // `dojox.layout.ResizeHandle` with activeSizing off.
+
+ show: function(){
+ // summary:
+ // show helper to start resizing
+ domStyle.set(this.domNode, "display", "");
+ },
+
+ hide: function(){
+ // summary:
+ // hide helper after resizing is complete
+ domStyle.set(this.domNode, "display", "none");
+ },
+
+ resize: function(/* Object */dim){
+ // summary:
+ // size the widget and place accordingly
+ domGeometry.setMarginBox(this.domNode, dim);
+ }
+
+});
+
+var ResizeHandle = declare("dojox.layout.ResizeHandle",[Widget, TemplatedMixin],
+ {
+ // summary:
+ // A draggable handle used to resize an attached node.
+ //
+ // description:
+ // The handle on the bottom-right corner of FloatingPane or other widgets that allows
+ // the widget to be resized.
+ // Typically not used directly.
+
+ // targetId: String
+ // id of the Widget OR DomNode that I will size
+ targetId: "",
+
+ // targetContainer: DomNode
+ // over-ride targetId and attch this handle directly to a reference of a DomNode
+ targetContainer: null,
+
+ // resizeAxis: String
+ // one of: x|y|xy limit resizing to a single axis, default to xy ...
+ resizeAxis: "xy",
+
+ // activeResize: Boolean
+ // if true, node will size realtime with mouse movement,
+ // if false, node will create virtual node, and only resize target on mouseUp
+ activeResize: false,
+
+ // activeResizeClass: String
+ // css class applied to virtual resize node.
+ activeResizeClass: "dojoxResizeHandleClone",
+
+ // animateSizing: Boolean
+ // only applicable if activeResize = false. onMouseup, animate the node to the
+ // new size
+ animateSizing: true,
+
+ // animateMethod: String
+ // one of "chain" or "combine" ... visual effect only. combine will "scale"
+ // node to size, "chain" will alter width, then height
+ animateMethod: "chain",
+
+ // animateDuration: Integer
+ // time in MS to run sizing animation. if animateMethod="chain", total animation
+ // playtime is 2*animateDuration
+ animateDuration: 225,
+
+ // minHeight: Integer
+ // smallest height in px resized node can be
+ minHeight: 100,
+
+ // minWidth: Integer
+ // smallest width in px resize node can be
+ minWidth: 100,
+
+ // constrainMax: Boolean
+ // Toggle if this widget cares about the maxHeight and maxWidth
+ // parameters.
+ constrainMax: false,
+
+ // maxHeight: Integer
+ // Largest height size in px the resize node can become.
+ maxHeight:0,
+
+ // maxWidth: Integer
+ // Largest width size in px the resize node can become.
+ maxWidth:0,
+
+ // fixedAspect: Boolean
+ // Toggle to enable this widget to maintain the aspect
+ // ratio of the attached node.
+ fixedAspect: false,
+
+ // intermediateChanges: Boolean
+ // Toggle to enable/disable this widget from firing onResize
+ // events at every step of a resize. If `activeResize` is true,
+ // and this is false, onResize only fires _after_ the drop
+ // operation. Animated resizing is not affected by this setting.
+ intermediateChanges: false,
+
+ // startTopic: String
+ // The name of the topic this resizehandle publishes when resize is starting
+ startTopic: "/dojo/resize/start",
+
+ // endTopic: String
+ // The name of the topic this resizehandle publishes when resize is complete
+ endTopic:"/dojo/resize/stop",
+
+ templateString: '<div dojoAttachPoint="resizeHandle" class="dojoxResizeHandle"><div></div></div>',
+
+ postCreate: function(){
+ // summary:
+ // setup our one major listener upon creation
+ this.connect(this.resizeHandle, touch.press, "_beginSizing");
+ if(!this.activeResize){
+ // there shall be only a single resize rubberbox that at the top
+ // level so that we can overlay it on anything whenever the user
+ // resizes something. Since there is only one mouse pointer he
+ // can't at once resize multiple things interactively.
+ this._resizeHelper = manager.byId('dojoxGlobalResizeHelper');
+ if(!this._resizeHelper){
+ this._resizeHelper = new _ResizeHelper({
+ id: 'dojoxGlobalResizeHelper'
+ }).placeAt(windowBase.body());
+ domClass.add(this._resizeHelper.domNode, this.activeResizeClass);
+ }
+ }else{ this.animateSizing = false; }
+
+ if(!this.minSize){
+ this.minSize = { w: this.minWidth, h: this.minHeight };
+ }
+
+ if(this.constrainMax){
+ this.maxSize = { w: this.maxWidth, h: this.maxHeight };
+ }
+
+ // should we modify the css for the cursor hover to n-resize nw-resize and w-resize?
+ this._resizeX = this._resizeY = false;
+ var addClass = lang.partial(domClass.add, this.resizeHandle);
+ switch(this.resizeAxis.toLowerCase()){
+ case "xy" :
+ this._resizeX = this._resizeY = true;
+ // FIXME: need logic to determine NW or NE class to see
+ // based on which [todo] corner is clicked
+ addClass("dojoxResizeNW");
+ break;
+ case "x" :
+ this._resizeX = true;
+ addClass("dojoxResizeW");
+ break;
+ case "y" :
+ this._resizeY = true;
+ addClass("dojoxResizeN");
+ break;
+ }
+ },
+
+ _beginSizing: function(/*Event*/ e){
+ // summary:
+ // setup movement listeners and calculate initial size
+
+ if(this._isSizing){ return; }
+
+ connect.publish(this.startTopic, [ this ]);
+ this.targetWidget = manager.byId(this.targetId);
+
+ this.targetDomNode = this.targetWidget ? this.targetWidget.domNode : domUtil.byId(this.targetId);
+ if(this.targetContainer){ this.targetDomNode = this.targetContainer; }
+ if(!this.targetDomNode){ return; }
+
+ if(!this.activeResize){
+ var c = domGeometry.position(this.targetDomNode, true);
+ this._resizeHelper.resize({l: c.x, t: c.y, w: c.w, h: c.h});
+ this._resizeHelper.show();
+ if(!this.isLeftToRight()){
+ this._resizeHelper.startPosition = {l: c.x, t: c.y};
+ }
+ }
+
+ this._isSizing = true;
+ this.startPoint = { x:e.clientX, y:e.clientY };
+
+ // widget.resize() or setting style.width/height expects native box model dimension
+ // (in most cases content-box, but it may be border-box if in backcompact mode)
+ var style = domStyle.getComputedStyle(this.targetDomNode),
+ borderModel = domGeometry.boxModel==='border-model',
+ padborder = borderModel?{w:0,h:0}:domGeometry.getPadBorderExtents(this.targetDomNode, style),
+ margin = domGeometry.getMarginExtents(this.targetDomNode, style);
+ this.startSize = {
+ w: domStyle.get(this.targetDomNode, 'width', style),
+ h: domStyle.get(this.targetDomNode, 'height', style),
+ //ResizeHelper.resize expects a bounding box of the
+ //border box, so let's keep track of padding/border
+ //width/height as well
+ pbw: padborder.w, pbh: padborder.h,
+ mw: margin.w, mh: margin.h};
+ if(!this.isLeftToRight() && domStyle.get(this.targetDomNode, "position") == "absolute"){
+ var p = domGeometry.position(this.targetDomNode, true);
+ this.startPosition = {l: p.x, t: p.y};
+ }
+
+ this._pconnects = [
+ connect.connect(windowBase.doc, touch.move, this,"_updateSizing"),
+ connect.connect(windowBase.doc, touch.release, this, "_endSizing")
+ ];
+
+ eventUtil.stop(e);
+ },
+
+ _updateSizing: function(/*Event*/ e){
+ // summary:
+ // called when moving the ResizeHandle ... determines
+ // new size based on settings/position and sets styles.
+
+ if(this.activeResize){
+ this._changeSizing(e);
+ }else{
+ var tmp = this._getNewCoords(e, 'border', this._resizeHelper.startPosition);
+ if(tmp === false){ return; }
+ this._resizeHelper.resize(tmp);
+ }
+ e.preventDefault();
+ },
+
+ _getNewCoords: function(/* Event */ e, /* String */ box, /* Object */startPosition){
+
+ // On IE, if you move the mouse above/to the left of the object being resized,
+ // sometimes clientX/Y aren't set, apparently. Just ignore the event.
+ try{
+ if(!e.clientX || !e.clientY){ return false; }
+ }catch(err){
+ // sometimes you get an exception accessing above fields...
+ return false;
+ }
+ this._activeResizeLastEvent = e;
+
+ var dx = (this.isLeftToRight()?1:-1) * (this.startPoint.x - e.clientX),
+ dy = this.startPoint.y - e.clientY,
+ newW = this.startSize.w - (this._resizeX ? dx : 0),
+ newH = this.startSize.h - (this._resizeY ? dy : 0),
+ r = this._checkConstraints(newW, newH)
+ ;
+
+ startPosition = (startPosition || this.startPosition);
+ if(startPosition && this._resizeX){
+ // adjust x position for RtoL
+ r.l = startPosition.l + dx;
+ if(r.w != newW){
+ r.l += (newW - r.w);
+ }
+ r.t = startPosition.t;
+ }
+
+ switch(box){
+ case 'margin':
+ r.w += this.startSize.mw;
+ r.h += this.startSize.mh;
+ //pass through
+ case "border":
+ r.w += this.startSize.pbw;
+ r.h += this.startSize.pbh;
+ break;
+ //default: //native, do nothing
+ }
+
+ return r; // Object
+ },
+
+ _checkConstraints: function(newW, newH){
+ // summary:
+ // filter through the various possible constaint possibilities.
+
+ // minimum size check
+ if(this.minSize){
+ var tm = this.minSize;
+ if(newW < tm.w){
+ newW = tm.w;
+ }
+ if(newH < tm.h){
+ newH = tm.h;
+ }
+ }
+
+ // maximum size check:
+ if(this.constrainMax && this.maxSize){
+ var ms = this.maxSize;
+ if(newW > ms.w){
+ newW = ms.w;
+ }
+ if(newH > ms.h){
+ newH = ms.h;
+ }
+ }
+
+ if(this.fixedAspect){
+ var w = this.startSize.w, h = this.startSize.h,
+ delta = w * newH - h * newW;
+ if(delta<0){
+ newW = newH * w / h;
+ }else if(delta>0){
+ newH = newW * h / w;
+ }
+ }
+
+ return { w: newW, h: newH }; // Object
+ },
+
+ _changeSizing: function(/*Event*/ e){
+ // summary:
+ // apply sizing information based on information in (e) to attached node
+
+ var isWidget = this.targetWidget && lang.isFunction(this.targetWidget.resize),
+ tmp = this._getNewCoords(e, isWidget && 'margin');
+ if(tmp === false){ return; }
+
+ if(isWidget){
+ this.targetWidget.resize(tmp);
+ }else{
+ if(this.animateSizing){
+ var anim = fxUtil[this.animateMethod]([
+ fxBase.animateProperty({
+ node: this.targetDomNode,
+ properties: {
+ width: { start: this.startSize.w, end: tmp.w }
+ },
+ duration: this.animateDuration
+ }),
+ fxBase.animateProperty({
+ node: this.targetDomNode,
+ properties: {
+ height: { start: this.startSize.h, end: tmp.h }
+ },
+ duration: this.animateDuration
+ })
+ ]);
+ anim.play();
+ }else{
+ domStyle.set(this.targetDomNode,{
+ width: tmp.w + "px",
+ height: tmp.h + "px"
+ });
+ }
+ }
+ if(this.intermediateChanges){
+ this.onResize(e);
+ }
+ },
+
+ _endSizing: function(/*Event*/ e){
+ // summary:
+ // disconnect listenrs and cleanup sizing
+ arrayUtil.forEach(this._pconnects, connect.disconnect);
+ var pub = lang.partial(connect.publish, this.endTopic, [ this ]);
+ if(!this.activeResize){
+ this._resizeHelper.hide();
+ this._changeSizing(e);
+ setTimeout(pub, this.animateDuration + 15);
+ }else{
+ pub();
+ }
+ this._isSizing = false;
+ this.onResize(e);
+ },
+
+ onResize: function(e){
+ // summary:
+ // Stub fired when sizing is done. Fired once
+ // after resize, or often when `intermediateChanges` is
+ // set to true.
+ }
+
+});
+
+return ResizeHandle;
+});
diff --cc dojox/package.json
index f0211ba,0000000..e81cbda
mode 100644,000000..100644
--- a/dojox/package.json
+++ b/dojox/package.json
@@@ -1,27 -1,0 +1,27 @@@
+{
+ "name": "dojox",
- "version":"1.10.3",
++ "version":"1.10.4",
+ "directories": {
+ "lib": "."
+ },
+ "main": "main",
+ "dependencies": {
- "dojo":"1.10.3",
- "dijit":"1.10.3"
++ "dojo":"1.10.4",
++ "dijit":"1.10.4"
+ },
+ "description": "Dojo eXtensions, a rollup of many useful sub-projects and varying states of maturity – from very stable and robust, to alpha and experimental. See individual projects contain README files for details.",
+ "licenses": [
+ {
+ "type": "AFLv2.1",
+ "url": "http://trac.dojotoolkit.org/browser/dojox/trunk/LICENSE#L43"
+ },
+ {
+ "type": "BSD",
+ "url": "http://trac.dojotoolkit.org/browser/dojox/trunk/LICENSE#L13"
+ }
+ ],
+ "bugs": "http://bugs.dojotoolkit.org/",
+ "keywords": ["JavaScript", "Dojo", "Toolkit", "DojoX"],
+ "homepage": "http://dojotoolkit.org/",
+ "dojoBuild": "dojox.profile.js"
+}
diff --cc util/.gitmodules
index 19a6fb9,0000000..5e96ec5
mode 100644,000000..100644
--- a/util/.gitmodules
+++ b/util/.gitmodules
@@@ -1,3 -1,0 +1,3 @@@
+[submodule "less"]
+ path = less
- url = git://github.com/cloudhead/less.js.git
++ url = https://github.com/less/less.js.git
diff --cc util/build/version.js
index 07310a7,0000000..7d0e524
mode 100644,000000..100644
--- a/util/build/version.js
+++ b/util/build/version.js
@@@ -1,13 -1,0 +1,13 @@@
+define([], function(){
+ var
- rev = "$Rev: 920a75b $".match(/[0-9a-f]{7,}/),
++ rev = "$Rev: 37e1249 $".match(/[0-9a-f]{7,}/),
+ version= {
- major: 1, minor: 10, patch: 3, flag: "",
++ major: 1, minor: 10, patch: 4, flag: "",
+ revision: rev ? rev[0] : NaN,
+ toString: function(){
+ var v= version;
+ return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")";
+ }
+ };
+ return version;
+});
diff --cc util/doh/_nodeRunner.js
index 3007a5a,0000000..831292c
mode 100644,000000..100644
--- a/util/doh/_nodeRunner.js
+++ b/util/doh/_nodeRunner.js
@@@ -1,40 -1,0 +1,40 @@@
+define(["doh/runner", "require", "dojo/_base/config"], function(doh, require, config){
+ /*=====
+ return {
+ // summary:
+ // Module for running DOH tests in node (as opposed to a browser).
+ // Augments return value from doh/runner.
+ };
+ =====*/
+
+ doh.debug= console.log;
+ doh.error= console.log;
+
+ // Override the doh._report method to make it quit with an
+ // appropriate exit code in case of test failures.
+ var oldReport = doh._report;
+ doh._report = function(){
+ oldReport.apply(doh, arguments);
+ if(this._failureCount > 0 || this._errorCount > 0){
+ process.exit(1);
+ }
+ };
+
+ console.log("\n"+doh._line);
- console.log("The Dojo Unit Test Harness, $Rev: 920a75b $");
++ console.log("The Dojo Unit Test Harness, $Rev: 37e1249 $");
+ console.log("Copyright (c) 2011, The Dojo Foundation, All Rights Reserved");
+ console.log("Running with node.js");
+ for (var tests= [], args= config["commandLineArgs"], i= 0, arg; i<args.length; i++) {
+ arg= args[i];
+ if (arg.length==2 && arg[0]=="test") {
+ var test= arg[1];
+ console.log("loading test " + test);
+ tests.push(test);
+ }
+ }
+ console.log(doh._line, "\n");
+
+ require(tests, function() {
+ doh.run();
+ });
+});
diff --cc util/doh/_rhinoRunner.js
index 68574ad,0000000..43cb6de
mode 100644,000000..100644
--- a/util/doh/_rhinoRunner.js
+++ b/util/doh/_rhinoRunner.js
@@@ -1,39 -1,0 +1,39 @@@
+define(["doh/runner", "require", "dojo/_base/config"], function(doh, require, config){
+ /*=====
+ return {
+ // summary:
+ // Module for running DOH tests in rhino (as opposed to a browser).
+ // Augments return value from doh/runner.
+ };
+ =====*/
+
+ doh.debug= print;
+ doh.error= print;
+
+ // Override the doh._report method to make it quit with an
+ // appropriate exit code in case of test failures.
+ var oldReport = doh._report;
+ doh._report = function(){
+ oldReport.apply(doh, arguments);
+ if(this._failureCount > 0 || this._errorCount > 0){
+ quit(1);
+ }
+ };
+
+ print("\n"+doh._line);
- print("The Dojo Unit Test Harness, $Rev: 920a75b $");
++ print("The Dojo Unit Test Harness, $Rev: 37e1249 $");
+ print("Copyright (c) 2011, The Dojo Foundation, All Rights Reserved");
+ for (var tests= [], args= config["commandLineArgs"], i= 0, arg; i<args.length; i++) {
+ arg= (args[i]+"").split("=");
+ if (arg.length==2 && arg[0]=="test") {
+ var test= arg[1];
+ print("loading test " + test);
+ tests.push(test);
+ }
+ }
+ print(doh._line, "\n");
+
+ require(tests, function() {
+ doh.run();
+ });
+});
diff --cc util/doh/mobileRunner.html
index 2a27e89,0000000..35d060b
mode 100644,000000..100644
--- a/util/doh/mobileRunner.html
+++ b/util/doh/mobileRunner.html
@@@ -1,88 -1,0 +1,88 @@@
+<!DOCTYPE html>
+<html style="height:100%;">
+ <head>
- <title>The Dojo Unit Test Harness, $Rev: 920a75b $</title>
++ <title>The Dojo Unit Test Harness, $Rev: 37e1249 $</title>
+ <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1"/>
+ <meta name="apple-mobile-web-app-capable" content="yes">
+ <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
+ <script type="text/javascript">
+ // workaround for bug in Safari 3. See #7189
+ if (/3[\.0-9]+ Safari/.test(navigator.appVersion))
+ {
+ window.console = {
+ origConsole: window.console,
+ log: function(s){
+ this.origConsole.log(s);
+ },
+ info: function(s){
+ this.origConsole.info(s);
+ },
+ error: function(s){
+ this.origConsole.error(s);
+ },
+ warn: function(s){
+ this.origConsole.warn(s);
+ }
+ };
+ }
+ </script>
+
+ <script type="text/javascript" src="_parseURLargs.js"></script>
+
+ <style type="text/css">
+ @import "../../dojo/resources/dojo.css";
+
+ #testLayout {
+ position: relative;
+ left: 0px;
+ top: 0px;
+ width: 100%;
+ height: 100%;
+ border: 1px solid black;
+ border: 0px;
+ }
+
+ .tabBody {
+ margin: 0px;
+ padding: 0px;
+ /*
+ border: 1px solid black;
+ */
+ background-color: #DEDEDE;
+ border: 0px;
+ width: 100%;
+ height: 100%;
+ position: absolute;
+ left: 0px;
+ top: 0px;
+ overflow: auto;
+ }
+
+ #logBody {
+ padding-left: 5px;
+ padding-top: 5px;
+ font-family: Monaco, monospace;
+ font-size: 11px;
+ white-space: pre;
+ }
+
+
+ </style>
+ </head>
+ <body style="height: 100%;">
+ <div style="position: relative; width: 100%; height: 100%; top: 0px; left: 0px;">
+ <div class="tabBody"
+ style="z-index: 1;">
+ <pre id="logBody"></pre>
+ <div id="perfTestsBody" style="background-color: white;"></div>
+ </div>
+ <iframe id="testBody" class="tabBody"
+ style="z-index: -1;"></iframe>
+ <!--
+ src="http://redesign.dojotoolkit.org"></iframe>
+ -->
+ </div>
+ <span id="hiddenAudio"></span>
+ </body>
+</html>
+
diff --cc util/doh/package.json
index b945259,0000000..0fbd7d2
mode 100644,000000..100644
--- a/util/doh/package.json
+++ b/util/doh/package.json
@@@ -1,23 -1,0 +1,23 @@@
+{
+ "name": "doh",
- "version":"1.10.3",
++ "version":"1.10.4",
+ "directories": {
+ "lib": "."
+ },
+ "main": "main",
+ "description": "DOH is a unit test framework developed by the Dojo Toolkit Community.",
+ "licenses": [
+ {
+ "type": "AFLv2.1",
+ "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L43"
+ },
+ {
+ "type": "BSD",
+ "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L13"
+ }
+ ],
+ "bugs": "http://bugs.dojotoolkit.org/",
+ "keywords": ["JavaScript", "Dojo", "Toolkit", "DOH"],
+ "homepage": "http://dojotoolkit.org/",
+ "dojoBuild": "doh.profile.js"
+}
diff --cc util/doh/runner.html
index 5b06bef,0000000..e780aeb
mode 100644,000000..100644
--- a/util/doh/runner.html
+++ b/util/doh/runner.html
@@@ -1,251 -1,0 +1,251 @@@
+<!DOCTYPE html>
+<html style="height:100%;">
+ <head>
- <title>The Dojo Unit Test Harness, $Rev: 920a75b $</title>
++ <title>The Dojo Unit Test Harness, $Rev: 37e1249 $</title>
+
+ <script type="text/javascript" src="_parseURLargs.js"></script>
+
+ <style type="text/css">
+ @import "../../dojo/resources/dojo.css";
+ /*
+ body {
+ margin: 0px;
+ padding: 0px;
+ font-size: 13px;
+ color: #292929;
+ font-family: Myriad, Lucida Grande, Bitstream Vera Sans, Arial, Helvetica, sans-serif;
+ *font-size: small;
+ *font: x-small;
+ }
+
+ th, td {
+ font-size: 13px;
+ color: #292929;
+ font-family: Myriad, Lucida Grande, Bitstream Vera Sans, Arial, Helvetica, sans-serif;
+ font-weight: normal;
+ }
+
+ * body {
+ line-height: 1.25em;
+ }
+
+ table {
+ border-collapse: collapse;
+ }
+ */
+
+ #testLayout {
+ position: relative;
+ left: 0px;
+ top: 0px;
+ width: 100%;
+ height: 100%;
+ border: 1px solid black;
+ border: 0px;
+ }
+
+ .tabBody {
+ margin: 0px;
+ padding: 0px;
+ /*
+ border: 1px solid black;
+ */
+ background-color: #DEDEDE;
+ border: 0px;
+ width: 100%;
+ height: 100%;
+ position: absolute;
+ left: 0px;
+ top: 0px;
+ overflow: auto;
+ }
+
+ #logBody {
+ padding-left: 5px;
+ padding-top: 5px;
+ font-family: Monaco, monospace;
+ font-size: 11px;
+ white-space: pre;
+ }
+
+ #progressOuter {
+ background-color: #e9e9e9;
+ background-image: -webkit-linear-gradient(rgba(255,255,255,1) 0%, rgba(255,255,255,0) 100%);
+ background-image: -moz-linear-gradient(rgba(255,255,255,1) 0%, rgba(255,255,255,0) 100%);
+ background-image: -ms-linear-gradient(rgba(255,255,255,1) 0%, rgba(255,255,255,0) 100%);
+ background-image: -o-linear-gradient(rgba(255,255,255,1) 0%, rgba(255,255,255,0) 100%);
+
+ height: 1em;
+ /*the following trick is necessary to prevent IE from wrapping the last piece of progress bar into a new line*/
+ _margin:1px;
+ _padding: -1px;
+ }
+
+ #progressOuter .success, #progressOuter .failure{
+ float: left;
+ height: 1em;
+ }
+
+ #play, #pause {
+ font-family: Arial;
+ font-size: 1.4em;
+ border: 1px solid #DEDEDE;
+ cursor: pointer;
+ padding-right: 0.5em;
+ }
+
+ .header {
+ border: 1px solid #DEDEDE;
+ }
+
+ button.tab {
+ border-width: 1px 1px 0px 1px;
+ border-style: solid;
+ border-color: #DEDEDE;
+ margin-right: 5px;
+ }
+
+ #testListContainer {
+ /*
+ border: 1px solid black;
+ */
+ position: relative;
+ height: 99%;
+ width: 100%;
+ overflow: auto;
+ }
+
+ #testList {
+ border-collapse: collapse;
+ position: absolute;
+ left: 0px;
+ width: 100%;
+ }
+
+ #testList td {
+ border-bottom: 1px solid #DEDEDE;
+ border-right : 1px solid #DEDEDE;
+ padding: 3px;
+ }
+
+ #testListHeader th {
+ border-bottom: 1px solid #DEDEDE;
+ border-right : 1px solid #DEDEDE;
+ padding: 3px;
+ font-weight: bolder;
+ font-style: italic;
+ }
+
+ #testList tfoot {
+ font-weight: bold;
+ }
+
+ #toggleButtons {
+ float: left;
+ background-color: #DEDEDE;
+ }
+
+ div.testGroupName {
+ position: absolute;
+ }
+
+ .inProgress {
+ background-color: #85afde;
+ }
+
+ .success {
+ background-color: #7cdea7;
+ }
+
+ .failure {
+ background-color: #de827b;
+ }
+ </style>
+ </head>
+ <body style="height: 100%;">
+ <table id="testLayout" cellpadding="0" cellspacing="0" style="margin: 0;">
+ <tr valign="top" height="40">
+ <td colspan="2" id="logoBar">
+ <h3 style="margin: 5px 5px 0px 5px; float: left;">D.O.H.: The Dojo Objective Harness</h3>
+ <img src="small_logo.png" height="40" style="margin: 0px 5px 0px 5px; float: right;">
+ <span style="margin: 10px 5px 0px 5px; float: right;">
+ <input type="checkbox" id="audio" name="audio">
+ <label for="audio">sounds?</label>
+ </span>
+ </td>
+ </tr>
+ <tr valign="top" height="10">
+ <td colspan="2"><div id="progressOuter" onclick="doh._jumpToSuite(arguments[0]);"></div></td>
+ </tr>
+ <tr valign="top" height="30">
+ <td width="30%" class="header">
+ <span id="toggleButtons" onclick="doh.togglePaused();">
+ <button id="play">►</button>
+ <button id="pause" style="display: none;">║</button>
+ </span>
+ <span id="runningStatus">
+ <span id="pausedMsg">Stopped</span>
+ <span id="playingMsg" style="display: none;">Tests Running</span>
+ </span>
+ </td>
+ <td width="*" class="header" valign="bottom">
+ <button class="tab" onclick="doh.showTestPage();">Test Page</button>
+ <button class="tab" onclick="doh.showLogPage();">Log</button>
+ <button class="tab" onclick="doh.showPerfTestsPage();">Performance Tests Results</button>
+ </td>
+ </tr>
+ <tr valign="top" style="border: 0; padding: 0; margin: 0;">
+ <td style="border: 0; padding: 0; margin: 0; height:100%;">
+ <div id="testListContainer">
+ <table cellpadding="0" cellspacing="0" border="0"
+ width="100%" id="testList" style="margin: 0;" onclick="doh._jumpToLog(arguments[0]);">
+ <thead>
+ <tr id="testListHeader" style="border: 0; padding: 0; margin: 0;" >
+ <th> </th>
+ <th width="20">
+ <input type="checkbox" checked
+ onclick="doh.toggleRunAll();">
+ </th>
+ <th width="*" style="text-align: left;">test</th>
+ <th width="50">time</th>
+ </tr>
+ </thead>
+ <tbody valign="top">
+ <tr id="groupTemplate" style="display: none;">
+ <td style="font-family: Arial; width: 15px;">►</td>
+ <td>
+ <input type="checkbox" checked>
+ </td>
+ <td>group name</td>
+ <td>10ms</td>
+ </tr>
+ <tr id="testTemplate" style="display: none;">
+ <td> </td>
+ <td> </td>
+ <td style="padding-left: 20px;">test name</td>
+ <td>10ms</td>
+ </tr>
+ </tbody>
+ </table>
+ </div>
+ </td>
+ <td style="height: 100%;">
+ <div style="position: relative; width: 100%; height: 100%; top: 0px; left: 0px;">
+ <div class="tabBody"
+ style="z-index: 1;">
+ <pre id="logBody"></pre>
+ <div id="perfTestsBody" style="background-color: white;"></div>
+ </div>
+ <iframe id="testBody" class="tabBody"
+ style="z-index: -1;"></iframe>
+ <!--
+ src="http://redesign.dojotoolkit.org"></iframe>
+ -->
+ </div>
+ </td>
+ </tr>
+ </table>
+ <span id="hiddenAudio"></span>
+ </body>
+</html>
+
diff --cc util/package.json
index a8865b7,0000000..f212c61
mode 100644,000000..100644
--- a/util/package.json
+++ b/util/package.json
@@@ -1,20 -1,0 +1,20 @@@
+{
+ "name": "dojo-util",
- "version":"1.10.3",
++ "version":"1.10.4",
+ "licenses": [
+ {
+ "type": "AFLv2.1",
+ "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L43"
+ },
+ {
+ "type": "BSD",
+ "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L13"
+ }
+ ],
+ "description": "Dojo utilities including build system for optimizing JavaScript application performance, and DOH testing tool",
+ "bugs": {
+ "url": "http://bugs.dojotoolkit.org/"
+ },
+ "keywords": ["JavaScript", "Dojo", "Toolkit", "util"],
+ "homepage": "http://dojotoolkit.org/"
+}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-javascript/dojo.git
More information about the Pkg-javascript-commits
mailing list