dijit/Dialog.js

  • Provides:

    • dijit.Dialog
  • dijit._DialogBase

    • type
      Function
    • chains:
      • dijit._Templated: (prototype)
      • dijit._Templated: (call)
      • dijit.form._FormMixin: (call)
      • dijit._DialogMixin: (call)
      • dijit._CssStateMixin: (call)
    • mixins:
      • dijit.form._FormMixin.prototype: (prototype)
      • dijit._DialogMixin.prototype: (prototype)
      • dijit._CssStateMixin.prototype: (prototype)
    • 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 dojoType="dijit.Dialog" href="test.html"></div>
    • example
      
      	var foo = new dijit.Dialog({ title: "test dialog", content: "test content" };
      	dojo.body().appendChild(foo.domNode);
      	foo.startup();
  • dijit._DialogBase.templateString

    • summary
  • dijit._DialogBase.baseClass

    • summary
  • dijit._DialogBase.cssStateNodes

    • type
      Object
    • summary
  • dijit._DialogBase.attributeMap

    • summary
  • dijit._DialogBase.open

    • tags: readonly
    • type
      Boolean
    • summary
      True if Dialog is currently displayed on screen.
  • dijit._DialogBase.duration

    • type
      Integer
    • summary
      The time in milliseconds it takes the dialog to fade in and out
  • dijit._DialogBase.refocus

    • type
      Boolean
    • summary
      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
  • dijit._DialogBase.autofocus

    • type
      Boolean
    • summary
      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
  • dijit._DialogBase._firstFocusItem

    • tags: private readonly
    • type
      DomNode
    • summary
      The pointer to the first focusable node in the dialog.
      Set by `dijit._DialogMixin._getFocusItems`.
  • dijit._DialogBase._lastFocusItem

    • tags: private readonly
    • type
      DomNode
    • summary
      The pointer to which node has focus prior to our dialog.
      Set by `dijit._DialogMixin._getFocusItems`.
  • dijit._DialogBase.doLayout

    • tags: protected
    • type
      Boolean
    • summary
      Don't change this parameter from the default value.
      This ContentPane parameter doesn't make sense for Dialog, since Dialog
      is never a child of a layout container, nor can you specify the size of
      Dialog in order to control the size of an inner widget.
  • dijit._DialogBase.draggable

    • type
      Boolean
    • summary
      Toggles the moveable aspect of the Dialog. If true, Dialog
      can be dragged by it's title. If false it will remain centered
      in the viewport.
  • dijit._DialogBase.aria-describedby

    • type
      String
    • summary
      Allows the user to add an aria-describedby attribute onto the dialog.   The value should
      be the id of the container element of text that describes the dialog purpose (usually
      the first text in the dialog).
      &lt;div dojoType=&quot;dijit.Dialog&quot; aria-describedby=&quot;intro&quot; .....&gt;
      &lt;div id=&quot;intro&quot;&gt;Introductory text&lt;/div&gt;
      &lt;div&gt;rest of dialog contents&lt;/div&gt;
      &lt;/div&gt;
  • dijit._DialogBase.postMixInProperties

    • type
      Function
    • source: [view]
         var _nlsResources = dojo.i18n.getLocalization("dijit", "common");
         dojo.mixin(this, _nlsResources);
         this.inherited(arguments);
    • summary
  • dijit._DialogBase.postCreate

    • type
      Function
    • source: [view]
         dojo.style(this.domNode, {
          display: "none",
          position:"absolute"
         });
         dojo.body().appendChild(this.domNode);


         this.inherited(arguments);


         this.connect(this, "onExecute", "hide");
         this.connect(this, "onCancel", "hide");
         this._modalconnects = [];
    • summary
  • dijit._DialogBase.onLoad

    • type
      Function
    • source: [view]
      define("dijit/Dialog", ["dojo", "dijit", "text!dijit/templates/Dialog.html", "dojo/dnd/move", "dojo/dnd/TimedMoveable", "dojo/fx", "dojo/window", "dijit/_Widget", "dijit/_Templated", "dijit/_CssStateMixin", "dijit/form/_FormMixin", "dijit/_DialogMixin", "dijit/DialogUnderlay", "dijit/layout/ContentPane", "i18n!dijit/nls/common", "dijit/TooltipDialog"], function(dojo, dijit) {


      // dijit/TooltipDialog required for back-compat. TODO: remove in 2.0




      dijit._underlay = function(kwArgs){
       // summary:
       //  A shared instance of a `dijit.DialogUnderlay`
       //
       // description:
       //  A shared instance of a `dijit.DialogUnderlay` created and
       //  used by `dijit.Dialog`, though never created until some Dialog
       //  or subclass thereof is shown.
      };


      dojo.declare(
       "dijit._DialogBase",
       [dijit._Templated, dijit.form._FormMixin, dijit._DialogMixin, dijit._CssStateMixin],
       {
        // 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:
        // | 

        //
        // example:
        // | var foo = new dijit.Dialog({ title: "test dialog", content: "test content" };
        // | dojo.body().appendChild(foo.domNode);
        // | foo.startup();


        templateString: dojo.cache("dijit", "templates/Dialog.html"),

        
        baseClass: "dijitDialog",

        
        cssStateNodes: {
         closeButtonNode: "dijitDialogCloseIcon"
        },


        attributeMap: dojo.delegate(dijit._Widget.prototype.attributeMap, {
         title: [
          { node: "titleNode", type: "innerHTML" },
          { node: "titleBar", type: "attribute" }
         ],
         "aria-describedby":""
        }),


        // 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: dijit.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,


        // doLayout: [protected] Boolean
        //  Don't change this parameter from the default value.
        //  This ContentPane parameter doesn't make sense for Dialog, since Dialog
        //  is never a child of a layout container, nor can you specify the size of
        //  Dialog in order to control the size of an inner widget.
        doLayout: false,


        // draggable: Boolean
        //  Toggles the moveable 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,


        //aria-describedby: String
        //  Allows the user to add an aria-describedby attribute onto the dialog. The value should
        //  be the id of the container element of text that describes the dialog purpose (usually
        //  the first text in the dialog).
        //  

        //   
      Introductory text

        //   
      rest of dialog contents

        //  

        "aria-describedby":"",


        postMixInProperties: function(){
         var _nlsResources = dojo.i18n.getLocalization("dijit", "common");
         dojo.mixin(this, _nlsResources);
         this.inherited(arguments);
        },


        postCreate: function(){
         dojo.style(this.domNode, {
          display: "none",
          position:"absolute"
         });
         dojo.body().appendChild(this.domNode);


         this.inherited(arguments);


         this.connect(this, "onExecute", "hide");
         this.connect(this, "onCancel", "hide");
         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._position();
         if(this.autofocus && dijit._DialogLevelManager.isTop(this)){
          this._getFocusItems(this.domNode);
          dijit.focus(this._firstFocusItem);
         }
         this.inherited(arguments);
    • 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.
  • dijit._DialogBase._endDrag

    • type
      Function
    • parameters:
      • e: (typeof )
    • source: [view]
         if(e && e.node && e.node === this.domNode){
          this._relativePosition = dojo.position(e.node);
         }
    • summary
      Called after dragging the Dialog. Saves the position of the dialog in the viewport.
    • tags:
  • dijit._DialogBase._setup

    • type
      Function
    • source: [view]
         var node = this.domNode;


         if(this.titleBar && this.draggable){
          this._moveable = (dojo.isIE == 6) ?
           new dojo.dnd.TimedMoveable(node, { handle: this.titleBar }) : // prevent overload, see #5285
           new dojo.dnd.Moveable(node, { handle: this.titleBar, timeout: 0 });
          this._dndListener = dojo.subscribe("/dnd/move/stop",this,"_endDrag");
         }else{
          dojo.addClass(node,"dijitDialogFixed");
         }


         this.underlayAttrs = {
          dialogId: this.id,
          "class": dojo.map(this["class"].split(/\s/), function(s){ return s+"_underlay"; }).join(" ")
         };
    • 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:
  • dijit._DialogBase._size

    • type
      Function
    • source: [view]
         this._checkIfSingleChild();


         // If we resized the dialog contents earlier, reset them back to original size, so
         // that if the user later increases the viewport size, the dialog can display w/out a scrollbar.
         // Need to do this before the dojo.marginBox(this.domNode) call below.
         if(this._singleChild){
          if(this._singleChildOriginalStyle){
           this._singleChild.domNode.style.cssText = this._singleChildOriginalStyle;
          }
          delete this._singleChildOriginalStyle;
         }else{
          dojo.style(this.containerNode, {
           width:"auto",
           height:"auto"
          });
         }


         var mb = dojo._getMarginSize(this.domNode);
         var viewport = dojo.window.getBox();
         if(mb.w >= viewport.w || mb.h >= viewport.h){
          // Reduce size of dialog contents so that dialog fits in viewport


          var w = Math.min(mb.w, Math.floor(viewport.w * 0.75)),
           h = Math.min(mb.h, Math.floor(viewport.h * 0.75));


          if(this._singleChild && this._singleChild.resize){
           this._singleChildOriginalStyle = this._singleChild.domNode.style.cssText;
           this._singleChild.resize({w: w, h: h});
          }else{
           dojo.style(this.containerNode, {
            width: w + "px",
            height: h + "px",
            overflow: "auto",
            position: "relative" // workaround IE bug moving scrollbar or dragging dialog
           });
          }
         }else{
          if(this._singleChild && this._singleChild.resize){
           this._singleChild.resize();
          }
         }
    • summary
      If necessary, shrink dialog contents so dialog fits in viewport
    • tags:
  • dijit._DialogBase._position

    • type
      Function
    • source: [view]
         if(!dojo.hasClass(dojo.body(),"dojoMove")){
          var node = this.domNode,
           viewport = dojo.window.getBox(),
           p = this._relativePosition,
           bb = p ? null : dojo._getBorderBox(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))
          ;
          dojo.style(node,{
           left: l + "px",
           top: t + "px"
          });
         }
    • summary
      Position modal dialog in the viewport. If no relative offset
      in the viewport has been determined (by dragging, for instance),
      center the node. Otherwise, use the Dialog's stored relative offset,
      and position the node to top: left: values based on the viewport.
    • tags:
  • dijit._DialogBase._onKey

    • type
      Function
    • parameters:
      • evt: (typeof Event)
    • source: [view]
         if(evt.charOrCode){
          var dk = dojo.keys;
          var node = evt.target;
          if(evt.charOrCode === dk.TAB){
           this._getFocusItems(this.domNode);
          }
          var singleFocusItem = (this._firstFocusItem == this._lastFocusItem);
          // see if we are shift-tabbing from first focusable item on dialog
          if(node == this._firstFocusItem && evt.shiftKey && evt.charOrCode === dk.TAB){
           if(!singleFocusItem){
            dijit.focus(this._lastFocusItem); // send focus to last item in dialog
           }
           dojo.stopEvent(evt);
          }else if(node == this._lastFocusItem && evt.charOrCode === dk.TAB && !evt.shiftKey){
           if(!singleFocusItem){
            dijit.focus(this._firstFocusItem); // send focus to first item in dialog
           }
           dojo.stopEvent(evt);
          }else{
           // see if the key is for the dialog
           while(node){
            if(node == this.domNode || dojo.hasClass(node, "dijitPopup")){
             if(evt.charOrCode == dk.ESCAPE){
              this.onCancel();
             }else{
              return; // just let it go
             }
            }
            node = node.parentNode;
           }
           // this key is for the disabled document window
           if(evt.charOrCode !== dk.TAB){ // allow tabbing into the dialog for a11y
            dojo.stopEvent(evt);
           // opera won't tab to a div
           }else if(!dojo.isOpera){
            try{
             this._firstFocusItem.focus();
            }catch(e){ /*squelch*/ }
           }
          }
         }
    • summary
      Handles the keyboard events for accessibility reasons
    • tags:
    • returns
      just let it go
  • dijit._DialogBase.show

    • type
      Function
    • source: [view]
         if(this.open){ return; }


         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){
          this._fadeOutDeferred.cancel();
         }


         this._modalconnects.push(dojo.connect(window, "onscroll", this, "layout"));
         this._modalconnects.push(dojo.connect(window, "onresize", this, function(){
          // IE gives spurious resize events and can actually get stuck
          // in an infinite loop if we don't ignore them
          var viewport = dojo.window.getBox();
          if(!this._oldViewport ||
            viewport.h != this._oldViewport.h ||
            viewport.w != this._oldViewport.w){
           this.layout();
           this._oldViewport = viewport;
          }
         }));
         this._modalconnects.push(dojo.connect(this.domNode, "onkeypress", this, "_onKey"));


         dojo.style(this.domNode, {
          opacity:0,
          display:""
         });


         this._set("open", true);
         this._onShow(); // lazy load trigger


         this._size();
         this._position();


         // fade-in Animation object, setup below
         var fadeIn;


         this._fadeInDeferred = new dojo.Deferred(dojo.hitch(this, function(){
          fadeIn.stop();
          delete this._fadeInDeferred;
         }));


         fadeIn = dojo.fadeIn({
          node: this.domNode,
          duration: this.duration,
          beforeBegin: dojo.hitch(this, function(){
           dijit._DialogLevelManager.show(this, this.underlayAttrs);
          }),
          onEnd: dojo.hitch(this, function(){
           if(this.autofocus && dijit._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(this.domNode);
            dijit.focus(this._firstFocusItem);
           }
           this._fadeInDeferred.callback(true);
           delete this._fadeInDeferred;
          })
         }).play();

         
         return this._fadeInDeferred;
    • summary
      Display the dialog
    • return_summary
      dojo.Deferred
      Deferred object that resolves when the display animation is complete
  • dijit._DialogBase.hide

    • type
      Function
    • source: [view]
      define("dijit/Dialog", ["dojo", "dijit", "text!dijit/templates/Dialog.html", "dojo/dnd/move", "dojo/dnd/TimedMoveable", "dojo/fx", "dojo/window", "dijit/_Widget", "dijit/_Templated", "dijit/_CssStateMixin", "dijit/form/_FormMixin", "dijit/_DialogMixin", "dijit/DialogUnderlay", "dijit/layout/ContentPane", "i18n!dijit/nls/common", "dijit/TooltipDialog"], function(dojo, dijit) {


      // dijit/TooltipDialog required for back-compat. TODO: remove in 2.0




      dijit._underlay = function(kwArgs){
       // summary:
       //  A shared instance of a `dijit.DialogUnderlay`
       //
       // description:
       //  A shared instance of a `dijit.DialogUnderlay` created and
       //  used by `dijit.Dialog`, though never created until some Dialog
       //  or subclass thereof is shown.
      };


      dojo.declare(
       "dijit._DialogBase",
       [dijit._Templated, dijit.form._FormMixin, dijit._DialogMixin, dijit._CssStateMixin],
       {
        // 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:
        // | 

        //
        // example:
        // | var foo = new dijit.Dialog({ title: "test dialog", content: "test content" };
        // | dojo.body().appendChild(foo.domNode);
        // | foo.startup();


        templateString: dojo.cache("dijit", "templates/Dialog.html"),

        
        baseClass: "dijitDialog",

        
        cssStateNodes: {
         closeButtonNode: "dijitDialogCloseIcon"
        },


        attributeMap: dojo.delegate(dijit._Widget.prototype.attributeMap, {
         title: [
          { node: "titleNode", type: "innerHTML" },
          { node: "titleBar", type: "attribute" }
         ],
         "aria-describedby":""
        }),


        // 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: dijit.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,


        // doLayout: [protected] Boolean
        //  Don't change this parameter from the default value.
        //  This ContentPane parameter doesn't make sense for Dialog, since Dialog
        //  is never a child of a layout container, nor can you specify the size of
        //  Dialog in order to control the size of an inner widget.
        doLayout: false,


        // draggable: Boolean
        //  Toggles the moveable 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,


        //aria-describedby: String
        //  Allows the user to add an aria-describedby attribute onto the dialog. The value should
        //  be the id of the container element of text that describes the dialog purpose (usually
        //  the first text in the dialog).
        //  

        //   
      Introductory text

        //   
      rest of dialog contents

        //  

        "aria-describedby":"",


        postMixInProperties: function(){
         var _nlsResources = dojo.i18n.getLocalization("dijit", "common");
         dojo.mixin(this, _nlsResources);
         this.inherited(arguments);
        },


        postCreate: function(){
         dojo.style(this.domNode, {
          display: "none",
          position:"absolute"
         });
         dojo.body().appendChild(this.domNode);


         this.inherited(arguments);


         this.connect(this, "onExecute", "hide");
         this.connect(this, "onCancel", "hide");
         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._position();
         if(this.autofocus && dijit._DialogLevelManager.isTop(this)){
          this._getFocusItems(this.domNode);
          dijit.focus(this._firstFocusItem);
         }
         this.inherited(arguments);
        },


        _endDrag: function(e){
         // summary:
         //  Called after dragging the Dialog. Saves the position of the dialog in the viewport.
         // tags:
         //  private
         if(e && e.node && e.node === this.domNode){
          this._relativePosition = dojo.position(e.node);
         }
        },


        _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 = (dojo.isIE == 6) ?
           new dojo.dnd.TimedMoveable(node, { handle: this.titleBar }) : // prevent overload, see #5285
           new dojo.dnd.Moveable(node, { handle: this.titleBar, timeout: 0 });
          this._dndListener = dojo.subscribe("/dnd/move/stop",this,"_endDrag");
         }else{
          dojo.addClass(node,"dijitDialogFixed");
         }


         this.underlayAttrs = {
          dialogId: this.id,
          "class": dojo.map(this["class"].split(/\s/), function(s){ return s+"_underlay"; }).join(" ")
         };
        },


        _size: function(){
         // summary:
         //   If necessary, shrink dialog contents so dialog fits in viewport
         // tags:
         //  private


         this._checkIfSingleChild();


         // If we resized the dialog contents earlier, reset them back to original size, so
         // that if the user later increases the viewport size, the dialog can display w/out a scrollbar.
         // Need to do this before the dojo.marginBox(this.domNode) call below.
         if(this._singleChild){
          if(this._singleChildOriginalStyle){
           this._singleChild.domNode.style.cssText = this._singleChildOriginalStyle;
          }
          delete this._singleChildOriginalStyle;
         }else{
          dojo.style(this.containerNode, {
           width:"auto",
           height:"auto"
          });
         }


         var mb = dojo._getMarginSize(this.domNode);
         var viewport = dojo.window.getBox();
         if(mb.w >= viewport.w || mb.h >= viewport.h){
          // Reduce size of dialog contents so that dialog fits in viewport


          var w = Math.min(mb.w, Math.floor(viewport.w * 0.75)),
           h = Math.min(mb.h, Math.floor(viewport.h * 0.75));


          if(this._singleChild && this._singleChild.resize){
           this._singleChildOriginalStyle = this._singleChild.domNode.style.cssText;
           this._singleChild.resize({w: w, h: h});
          }else{
           dojo.style(this.containerNode, {
            width: w + "px",
            height: h + "px",
            overflow: "auto",
            position: "relative" // workaround IE bug moving scrollbar or dragging dialog
           });
          }
         }else{
          if(this._singleChild && this._singleChild.resize){
           this._singleChild.resize();
          }
         }
        },


        _position: function(){
         // summary:
         //  Position modal dialog in the viewport. If no relative offset
         //  in the viewport has been determined (by dragging, for instance),
         //  center the node. Otherwise, use the Dialog's stored relative offset,
         //  and position the node to top: left: values based on the viewport.
         // tags:
         //  private
         if(!dojo.hasClass(dojo.body(),"dojoMove")){
          var node = this.domNode,
           viewport = dojo.window.getBox(),
           p = this._relativePosition,
           bb = p ? null : dojo._getBorderBox(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))
          ;
          dojo.style(node,{
           left: l + "px",
           top: t + "px"
          });
         }
        },


        _onKey: function(/*Event*/ evt){
         // summary:
         //  Handles the keyboard events for accessibility reasons
         // tags:
         //  private


         if(evt.charOrCode){
          var dk = dojo.keys;
          var node = evt.target;
          if(evt.charOrCode === dk.TAB){
           this._getFocusItems(this.domNode);
          }
          var singleFocusItem = (this._firstFocusItem == this._lastFocusItem);
          // see if we are shift-tabbing from first focusable item on dialog
          if(node == this._firstFocusItem && evt.shiftKey && evt.charOrCode === dk.TAB){
           if(!singleFocusItem){
            dijit.focus(this._lastFocusItem); // send focus to last item in dialog
           }
           dojo.stopEvent(evt);
          }else if(node == this._lastFocusItem && evt.charOrCode === dk.TAB && !evt.shiftKey){
           if(!singleFocusItem){
            dijit.focus(this._firstFocusItem); // send focus to first item in dialog
           }
           dojo.stopEvent(evt);
          }else{
           // see if the key is for the dialog
           while(node){
            if(node == this.domNode || dojo.hasClass(node, "dijitPopup")){
             if(evt.charOrCode == dk.ESCAPE){
              this.onCancel();
             }else{
              return; // just let it go
             }
            }
            node = node.parentNode;
           }
           // this key is for the disabled document window
           if(evt.charOrCode !== dk.TAB){ // allow tabbing into the dialog for a11y
            dojo.stopEvent(evt);
           // opera won't tab to a div
           }else if(!dojo.isOpera){
            try{
             this._firstFocusItem.focus();
            }catch(e){ /*squelch*/ }
           }
          }
         }
        },


        show: function(){
         // summary:
         //  Display the dialog
         // returns: dojo.Deferred
         //  Deferred object that resolves when the display animation is complete


         if(this.open){ return; }


         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){
          this._fadeOutDeferred.cancel();
         }


         this._modalconnects.push(dojo.connect(window, "onscroll", this, "layout"));
         this._modalconnects.push(dojo.connect(window, "onresize", this, function(){
          // IE gives spurious resize events and can actually get stuck
          // in an infinite loop if we don't ignore them
          var viewport = dojo.window.getBox();
          if(!this._oldViewport ||
            viewport.h != this._oldViewport.h ||
            viewport.w != this._oldViewport.w){
           this.layout();
           this._oldViewport = viewport;
          }
         }));
         this._modalconnects.push(dojo.connect(this.domNode, "onkeypress", this, "_onKey"));


         dojo.style(this.domNode, {
          opacity:0,
          display:""
         });


         this._set("open", true);
         this._onShow(); // lazy load trigger


         this._size();
         this._position();


         // fade-in Animation object, setup below
         var fadeIn;


         this._fadeInDeferred = new dojo.Deferred(dojo.hitch(this, function(){
          fadeIn.stop();
          delete this._fadeInDeferred;
         }));


         fadeIn = dojo.fadeIn({
          node: this.domNode,
          duration: this.duration,
          beforeBegin: dojo.hitch(this, function(){
           dijit._DialogLevelManager.show(this, this.underlayAttrs);
          }),
          onEnd: dojo.hitch(this, function(){
           if(this.autofocus && dijit._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(this.domNode);
            dijit.focus(this._firstFocusItem);
           }
           this._fadeInDeferred.callback(true);
           delete this._fadeInDeferred;
          })
         }).play();

         
         return this._fadeInDeferred;
        },


        hide: function(){
         // summary:
         //  Hide the dialog
         // returns: dojo.Deferred
         //  Deferred object that resolves when the hide animation is complete


         // if we haven't been initialized yet then we aren't showing and we can just return
         if(!this._alreadyInitialized){
          return;
         }
         if(this._fadeInDeferred){
          this._fadeInDeferred.cancel();
         }


         // fade-in Animation object, setup below
         var fadeOut;


         this._fadeOutDeferred = new dojo.Deferred(dojo.hitch(this, function(){
          fadeOut.stop();
          delete this._fadeOutDeferred;
         }));


         fadeOut = dojo.fadeOut({
          node: this.domNode,
          duration: this.duration,
          onEnd: dojo.hitch(this, function(){
           this.domNode.style.display = "none";
           dijit._DialogLevelManager.hide(this);
           this.onHide();
           this._fadeOutDeferred.callback(true);
           delete this._fadeOutDeferred;
          })
          }).play();


         if(this._scrollConnected){
          this._scrollConnected = false;
         }
         dojo.forEach(this._modalconnects, dojo.disconnect);
         this._modalconnects = [];


         if(this._relativePosition){
          delete this._relativePosition;
         }
         this._set("open", false);


         return this._fadeOutDeferred;
    • summary
      Hide the dialog
    • returns
      just let it go
  • dijit._DialogBase.layout

    • type
      Function
    • source: [view]
         if(this.domNode.style.display != "none"){
          if(dijit._underlay){ // avoid race condition during show()
           dijit._underlay.layout();
          }
          this._position();
         }
    • summary
      Position the Dialog and the underlay
    • tags:
  • dijit._DialogBase.destroy

    • type
      Function
    • source: [view]
         if(this._fadeInDeferred){
          this._fadeInDeferred.cancel();
         }
         if(this._fadeOutDeferred){
          this._fadeOutDeferred.cancel();
         }
         if(this._moveable){
          this._moveable.destroy();
         }
         if(this._dndListener){
          dojo.unsubscribe(this._dndListener);
         }
         dojo.forEach(this._modalconnects, dojo.disconnect);


         dijit._DialogLevelManager.hide(this);


         this.inherited(arguments);
    • summary
  • dijit._DialogBase.cssStateNodes.closeButtonNode

    • summary
  • dijit._DialogBase._modalconnects

    • summary
  • dijit._DialogBase._relativePosition

    • summary
  • dijit._DialogBase._moveable

    • summary
  • dijit._DialogBase._dndListener

    • summary
  • dijit._DialogBase.underlayAttrs

    • summary
  • dijit._DialogBase._singleChild.domNode.style.cssText

    • summary
  • dijit._DialogBase._singleChildOriginalStyle

    • summary
  • dijit._DialogBase._alreadyInitialized

    • summary
  • dijit._DialogBase._oldViewport

    • summary
  • dijit._DialogBase._fadeInDeferred

    • summary
  • dijit._DialogBase._fadeOutDeferred

    • summary
  • dijit._DialogBase.domNode.style.display

    • summary
  • dijit._DialogBase._scrollConnected

    • summary
  • dijit.Dialog

    • type
      Function
    • chains:
      • dijit.layout.ContentPane: (prototype)
      • dijit.layout.ContentPane: (call)
      • dijit._DialogBase: (call)
    • mixins:
      • dijit._DialogBase.prototype: (prototype)
    • summary
  • dijit._DialogLevelManager

    • type
      Object
    • summary
      Controls the various active &quot;levels&quot; 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.
  • dijit._DialogLevelManager.show

    • type
      Function
    • parameters:
      • dialog: (typeof dijit._Widget)
      • underlayAttrs: (typeof Object)
    • source: [view]
        var ds = dijit._dialogStack;


        // Save current focus
        ds[ds.length-1].focus = dijit.getFocus(dialog);


        // Display the underlay, or if already displayed then adjust for this new dialog
        var underlay = dijit._underlay;
        if(!underlay || underlay._destroyed){
         underlay = dijit._underlay = new dijit.DialogUnderlay(underlayAttrs);
        }else{
         underlay.set(dialog.underlayAttrs);
        }


        // Set z-index a bit above previous dialog
        var zIndex = ds[ds.length-1].dialog ? ds[ds.length-1].zIndex + 2 : 950;
        if(ds.length == 1){ // first dialog
         underlay.show();
        }
        dojo.style(dijit._underlay.domNode, 'zIndex', zIndex - 1);


        // Dialog
        dojo.style(dialog.domNode, 'zIndex', zIndex);


        ds.push({dialog: dialog, underlayAttrs: underlayAttrs, zIndex: zIndex});
    • 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.
  • dijit._DialogLevelManager.hide

    • type
      Function
    • parameters:
      • dialog: (typeof dijit._Widget)
    • source: [view]
        var ds = dijit._dialogStack;


        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, unless the underlay widget has already been destroyed
          // because we are being called during page unload (when all widgets are destroyed)
          if(!dijit._underlay._destroyed){
           dijit._underlay.hide();
          }
         }else{
          // Popping back to previous dialog, adjust underlay
          dojo.style(dijit._underlay.domNode, 'zIndex', pd.zIndex - 1);
          dijit._underlay.set(pd.underlayAttrs);
         }


         // Adjust focus
         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(!focus || (pd.dialog && !dojo.isDescendant(focus.node, pd.dialog.domNode))){
           pd.dialog._getFocusItems(pd.dialog.domNode);
           focus = pd.dialog._firstFocusItem;
          }

       
          try{
           dijit.focus(focus);
          }catch(e){
           /* focus() will fail if user opened the dialog by clicking a non-focusable element */
          }
         }
        }else{
         // Removing a dialog out of order (#9944, #10705).
         // Don't need to mess with underlay or z-index or anything.
         var idx = dojo.indexOf(dojo.map(ds, function(elem){return elem.dialog}), dialog);
         if(idx != -1){
          ds.splice(idx, 1);
         }
        }
    • 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.
  • dijit._DialogLevelManager.isTop

    • type
      Function
    • parameters:
      • dialog: (typeof dijit._Widget)
    • source: [view]
        var ds = dijit._dialogStack;
        return ds[ds.length-1].dialog == dialog;
    • summary
      Returns true if specified Dialog is the top in the task
  • dijit._underlay

    • type
      Function
    • parameters:
      • kwArgs: (typeof )
    • source: [view]
       // summary:
       //  A shared instance of a `dijit.DialogUnderlay`
       //
       // description:
       //  A shared instance of a `dijit.DialogUnderlay` created and
       //  used by `dijit.Dialog`, though never created until some Dialog
       //  or subclass thereof is shown.
    • summary
      A shared instance of a `dijit.DialogUnderlay`
    • description
      A shared instance of a `dijit.DialogUnderlay` created and
      used by `dijit.Dialog`, though never created until some Dialog
      or subclass thereof is shown.
  • this

    • mixins:
      • _nlsResources: (normal)
    • summary
  • dijit._dialogStack

    • summary
  • dijit

    • type
      Object
    • summary