third-party/jquery-ui-1.10.2/ui/jquery.ui.dialog.js

   1 /*!
   2  * jQuery UI Dialog 1.10.2
   3  * http://jqueryui.com
   4  *
   5  * Copyright 2013 jQuery Foundation and other contributors
   6  * Released under the MIT license.
   7  * http://jquery.org/license
   8  *
   9  * http://api.jqueryui.com/dialog/
  10  *
  11  * Depends:
  12  *      jquery.ui.core.js
  13  *      jquery.ui.widget.js
  14  *  jquery.ui.button.js
  15  *      jquery.ui.draggable.js
  16  *      jquery.ui.mouse.js
  17  *      jquery.ui.position.js
  18  *      jquery.ui.resizable.js
  19  */
  20 (function( $, undefined ) {
  21
  22 var sizeRelatedOptions = {
  23                 buttons: true,
  24                 height: true,
  25                 maxHeight: true,
  26                 maxWidth: true,
  27                 minHeight: true,
  28                 minWidth: true,
  29                 width: true
  30         },
  31         resizableRelatedOptions = {
  32                 maxHeight: true,
  33                 maxWidth: true,
  34                 minHeight: true,
  35                 minWidth: true
  36         };
  37
  38 $.widget( "ui.dialog", {
  39         version: "1.10.2",
  40         options: {
  41                 appendTo: "body",
  42                 autoOpen: true,
  43                 buttons: [],
  44                 closeOnEscape: true,
  45                 closeText: "close",
  46                 dialogClass: "",
  47                 draggable: true,
  48                 hide: null,
  49                 height: "auto",
  50                 maxHeight: null,
  51                 maxWidth: null,
  52                 minHeight: 150,
  53                 minWidth: 150,
  54                 modal: false,
  55                 position: {
  56                         my: "center",
  57                         at: "center",
  58                         of: window,
  59                         collision: "fit",
  60                         // Ensure the titlebar is always visible
  61                         using: function( pos ) {
  62                                 var topOffset = $( this ).css( pos ).offset().top;
  63                                 if ( topOffset < 0 ) {
  64                                         $( this ).css( "top", pos.top - topOffset );
  65                                 }
  66                         }
  67                 },
  68                 resizable: true,
  69                 show: null,
  70                 title: null,
  71                 width: 300,
  72
  73                 // callbacks
  74                 beforeClose: null,
  75                 close: null,
  76                 drag: null,
  77                 dragStart: null,
  78                 dragStop: null,
  79                 focus: null,
  80                 open: null,
  81                 resize: null,
  82                 resizeStart: null,
  83                 resizeStop: null
  84         },
  85
  86         _create: function() {
  87                 this.originalCss = {
  88                         display: this.element[0].style.display,
  89                         width: this.element[0].style.width,
  90                         minHeight: this.element[0].style.minHeight,
  91                         maxHeight: this.element[0].style.maxHeight,
  92                         height: this.element[0].style.height
  93                 };
  94                 this.originalPosition = {
  95                         parent: this.element.parent(),
  96                         index: this.element.parent().children().index( this.element )
  97                 };
  98                 this.originalTitle = this.element.attr("title");
  99                 this.options.title = this.options.title || this.originalTitle;
 100
 101                 this._createWrapper();
 102
 103                 this.element
 104                         .show()
 105                         .removeAttr("title")
 106                         .addClass("ui-dialog-content ui-widget-content")
 107                         .appendTo( this.uiDialog );
 108
 109                 this._createTitlebar();
 110                 this._createButtonPane();
 111
 112                 if ( this.options.draggable && $.fn.draggable ) {
 113                         this._makeDraggable();
 114                 }
 115                 if ( this.options.resizable && $.fn.resizable ) {
 116                         this._makeResizable();
 117                 }
 118
 119                 this._isOpen = false;
 120         },
 121
 122         _init: function() {
 123                 if ( this.options.autoOpen ) {
 124                         this.open();
 125                 }
 126         },
 127
 128         _appendTo: function() {
 129                 var element = this.options.appendTo;
 130                 if ( element && (element.jquery || element.nodeType) ) {
 131                         return $( element );
 132                 }
 133                 return this.document.find( element || "body" ).eq( 0 );
 134         },
 135
 136         _destroy: function() {
 137                 var next,
 138                         originalPosition = this.originalPosition;
 139
 140                 this._destroyOverlay();
 141
 142                 this.element
 143                         .removeUniqueId()
 144                         .removeClass("ui-dialog-content ui-widget-content")
 145                         .css( this.originalCss )
 146                         // Without detaching first, the following becomes really slow
 147                         .detach();
 148
 149                 this.uiDialog.stop( true, true ).remove();
 150
 151                 if ( this.originalTitle ) {
 152                         this.element.attr( "title", this.originalTitle );
 153                 }
 154
 155                 next = originalPosition.parent.children().eq( originalPosition.index );
 156                 // Don't try to place the dialog next to itself (#8613)
 157                 if ( next.length && next[0] !== this.element[0] ) {
 158                         next.before( this.element );
 159                 } else {
 160                         originalPosition.parent.append( this.element );
 161                 }
 162         },
 163
 164         widget: function() {
 165                 return this.uiDialog;
 166         },
 167
 168         disable: $.noop,
 169         enable: $.noop,
 170
 171         close: function( event ) {
 172                 var that = this;
 173
 174                 if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
 175                         return;
 176                 }
 177
 178                 this._isOpen = false;
 179                 this._destroyOverlay();
 180
 181                 if ( !this.opener.filter(":focusable").focus().length ) {
 182                         // Hiding a focused element doesn't trigger blur in WebKit
 183                         // so in case we have nothing to focus on, explicitly blur the active element
 184                         // https://bugs.webkit.org/show_bug.cgi?id=47182
 185                         $( this.document[0].activeElement ).blur();
 186                 }
 187
 188                 this._hide( this.uiDialog, this.options.hide, function() {
 189                         that._trigger( "close", event );
 190                 });
 191         },
 192
 193         isOpen: function() {
 194                 return this._isOpen;
 195         },
 196
 197         moveToTop: function() {
 198                 this._moveToTop();
 199         },
 200
 201         _moveToTop: function( event, silent ) {
 202                 var moved = !!this.uiDialog.nextAll(":visible").insertBefore( this.uiDialog ).length;
 203                 if ( moved && !silent ) {
 204                         this._trigger( "focus", event );
 205                 }
 206                 return moved;
 207         },
 208
 209         open: function() {
 210                 var that = this;
 211                 if ( this._isOpen ) {
 212                         if ( this._moveToTop() ) {
 213                                 this._focusTabbable();
 214                         }
 215                         return;
 216                 }
 217
 218                 this._isOpen = true;
 219                 this.opener = $( this.document[0].activeElement );
 220
 221                 this._size();
 222                 this._position();
 223                 this._createOverlay();
 224                 this._moveToTop( null, true );
 225                 this._show( this.uiDialog, this.options.show, function() {
 226                         that._focusTabbable();
 227                         that._trigger("focus");
 228                 });
 229
 230                 this._trigger("open");
 231         },
 232
 233         _focusTabbable: function() {
 234                 // Set focus to the first match:
 235                 // 1. First element inside the dialog matching [autofocus]
 236                 // 2. Tabbable element inside the content element
 237                 // 3. Tabbable element inside the buttonpane
 238                 // 4. The close button
 239                 // 5. The dialog itself
 240                 var hasFocus = this.element.find("[autofocus]");
 241                 if ( !hasFocus.length ) {
 242                         hasFocus = this.element.find(":tabbable");
 243                 }
 244                 if ( !hasFocus.length ) {
 245                         hasFocus = this.uiDialogButtonPane.find(":tabbable");
 246                 }
 247                 if ( !hasFocus.length ) {
 248                         hasFocus = this.uiDialogTitlebarClose.filter(":tabbable");
 249                 }
 250                 if ( !hasFocus.length ) {
 251                         hasFocus = this.uiDialog;
 252                 }
 253                 hasFocus.eq( 0 ).focus();
 254         },
 255
 256         _keepFocus: function( event ) {
 257                 function checkFocus() {
 258                         var activeElement = this.document[0].activeElement,
 259                                 isActive = this.uiDialog[0] === activeElement ||
 260                                         $.contains( this.uiDialog[0], activeElement );
 261                         if ( !isActive ) {
 262                                 this._focusTabbable();
 263                         }
 264                 }
 265                 event.preventDefault();
 266                 checkFocus.call( this );
 267                 // support: IE
 268                 // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
 269                 // so we check again later
 270                 this._delay( checkFocus );
 271         },
 272
 273         _createWrapper: function() {
 274                 this.uiDialog = $("<div>")
 275                         .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
 276                                 this.options.dialogClass )
 277                         .hide()
 278                         .attr({
 279                                 // Setting tabIndex makes the div focusable
 280                                 tabIndex: -1,
 281                                 role: "dialog"
 282                         })
 283                         .appendTo( this._appendTo() );
 284
 285                 this._on( this.uiDialog, {
 286                         keydown: function( event ) {
 287                                 if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
 288                                                 event.keyCode === $.ui.keyCode.ESCAPE ) {
 289                                         event.preventDefault();
 290                                         this.close( event );
 291                                         return;
 292                                 }
 293
 294                                 // prevent tabbing out of dialogs
 295                                 if ( event.keyCode !== $.ui.keyCode.TAB ) {
 296                                         return;
 297                                 }
 298                                 var tabbables = this.uiDialog.find(":tabbable"),
 299                                         first = tabbables.filter(":first"),
 300                                         last  = tabbables.filter(":last");
 301
 302                                 if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
 303                                         first.focus( 1 );
 304                                         event.preventDefault();
 305                                 } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
 306                                         last.focus( 1 );
 307                                         event.preventDefault();
 308                                 }
 309                         },
 310                         mousedown: function( event ) {
 311                                 if ( this._moveToTop( event ) ) {
 312                                         this._focusTabbable();
 313                                 }
 314                         }
 315                 });
 316
 317                 // We assume that any existing aria-describedby attribute means
 318                 // that the dialog content is marked up properly
 319                 // otherwise we brute force the content as the description
 320                 if ( !this.element.find("[aria-describedby]").length ) {
 321                         this.uiDialog.attr({
 322                                 "aria-describedby": this.element.uniqueId().attr("id")
 323                         });
 324                 }
 325         },
 326
 327         _createTitlebar: function() {
 328                 var uiDialogTitle;
 329
 330                 this.uiDialogTitlebar = $("<div>")
 331                         .addClass("ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix")
 332                         .prependTo( this.uiDialog );
 333                 this._on( this.uiDialogTitlebar, {
 334                         mousedown: function( event ) {
 335                                 // Don't prevent click on close button (#8838)
 336                                 // Focusing a dialog that is partially scrolled out of view
 337                                 // causes the browser to scroll it into view, preventing the click event
 338                                 if ( !$( event.target ).closest(".ui-dialog-titlebar-close") ) {
 339                                         // Dialog isn't getting focus when dragging (#8063)
 340                                         this.uiDialog.focus();
 341                                 }
 342                         }
 343                 });
 344
 345                 this.uiDialogTitlebarClose = $("<button></button>")
 346                         .button({
 347                                 label: this.options.closeText,
 348                                 icons: {
 349                                         primary: "ui-icon-closethick"
 350                                 },
 351                                 text: false
 352                         })
 353                         .addClass("ui-dialog-titlebar-close")
 354                         .appendTo( this.uiDialogTitlebar );
 355                 this._on( this.uiDialogTitlebarClose, {
 356                         click: function( event ) {
 357                                 event.preventDefault();
 358                                 this.close( event );
 359                         }
 360                 });
 361
 362                 uiDialogTitle = $("<span>")
 363                         .uniqueId()
 364                         .addClass("ui-dialog-title")
 365                         .prependTo( this.uiDialogTitlebar );
 366                 this._title( uiDialogTitle );
 367
 368                 this.uiDialog.attr({
 369                         "aria-labelledby": uiDialogTitle.attr("id")
 370                 });
 371         },
 372
 373         _title: function( title ) {
 374                 if ( !this.options.title ) {
 375                         title.html("&#160;");
 376                 }
 377                 title.text( this.options.title );
 378         },
 379
 380         _createButtonPane: function() {
 381                 this.uiDialogButtonPane = $("<div>")
 382                         .addClass("ui-dialog-buttonpane ui-widget-content ui-helper-clearfix");
 383
 384                 this.uiButtonSet = $("<div>")
 385                         .addClass("ui-dialog-buttonset")
 386                         .appendTo( this.uiDialogButtonPane );
 387
 388                 this._createButtons();
 389         },
 390
 391         _createButtons: function() {
 392                 var that = this,
 393                         buttons = this.options.buttons;
 394
 395                 // if we already have a button pane, remove it
 396                 this.uiDialogButtonPane.remove();
 397                 this.uiButtonSet.empty();
 398
 399                 if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
 400                         this.uiDialog.removeClass("ui-dialog-buttons");
 401                         return;
 402                 }
 403
 404                 $.each( buttons, function( name, props ) {
 405                         var click, buttonOptions;
 406                         props = $.isFunction( props ) ?
 407                                 { click: props, text: name } :
 408                                 props;
 409                         // Default to a non-submitting button
 410                         props = $.extend( { type: "button" }, props );
 411                         // Change the context for the click callback to be the main element
 412                         click = props.click;
 413                         props.click = function() {
 414                                 click.apply( that.element[0], arguments );
 415                         };
 416                         buttonOptions = {
 417                                 icons: props.icons,
 418                                 text: props.showText
 419                         };
 420                         delete props.icons;
 421                         delete props.showText;
 422                         $( "<button></button>", props )
 423                                 .button( buttonOptions )
 424                                 .appendTo( that.uiButtonSet );
 425                 });
 426                 this.uiDialog.addClass("ui-dialog-buttons");
 427                 this.uiDialogButtonPane.appendTo( this.uiDialog );
 428         },
 429
 430         _makeDraggable: function() {
 431                 var that = this,
 432                         options = this.options;
 433
 434                 function filteredUi( ui ) {
 435                         return {
 436                                 position: ui.position,
 437                                 offset: ui.offset
 438                         };
 439                 }
 440
 441                 this.uiDialog.draggable({
 442                         cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
 443                         handle: ".ui-dialog-titlebar",
 444                         containment: "document",
 445                         start: function( event, ui ) {
 446                                 $( this ).addClass("ui-dialog-dragging");
 447                                 that._blockFrames();
 448                                 that._trigger( "dragStart", event, filteredUi( ui ) );
 449                         },
 450                         drag: function( event, ui ) {
 451                                 that._trigger( "drag", event, filteredUi( ui ) );
 452                         },
 453                         stop: function( event, ui ) {
 454                                 options.position = [
 455                                         ui.position.left - that.document.scrollLeft(),
 456                                         ui.position.top - that.document.scrollTop()
 457                                 ];
 458                                 $( this ).removeClass("ui-dialog-dragging");
 459                                 that._unblockFrames();
 460                                 that._trigger( "dragStop", event, filteredUi( ui ) );
 461                         }
 462                 });
 463         },
 464
 465         _makeResizable: function() {
 466                 var that = this,
 467                         options = this.options,
 468                         handles = options.resizable,
 469                         // .ui-resizable has position: relative defined in the stylesheet
 470                         // but dialogs have to use absolute or fixed positioning
 471                         position = this.uiDialog.css("position"),
 472                         resizeHandles = typeof handles === "string" ?
 473                                 handles :
 474                                 "n,e,s,w,se,sw,ne,nw";
 475
 476                 function filteredUi( ui ) {
 477                         return {
 478                                 originalPosition: ui.originalPosition,
 479                                 originalSize: ui.originalSize,
 480                                 position: ui.position,
 481                                 size: ui.size
 482                         };
 483                 }
 484
 485                 this.uiDialog.resizable({
 486                         cancel: ".ui-dialog-content",
 487                         containment: "document",
 488                         alsoResize: this.element,
 489                         maxWidth: options.maxWidth,
 490                         maxHeight: options.maxHeight,
 491                         minWidth: options.minWidth,
 492                         minHeight: this._minHeight(),
 493                         handles: resizeHandles,
 494                         start: function( event, ui ) {
 495                                 $( this ).addClass("ui-dialog-resizing");
 496                                 that._blockFrames();
 497                                 that._trigger( "resizeStart", event, filteredUi( ui ) );
 498                         },
 499                         resize: function( event, ui ) {
 500                                 that._trigger( "resize", event, filteredUi( ui ) );
 501                         },
 502                         stop: function( event, ui ) {
 503                                 options.height = $( this ).height();
 504                                 options.width = $( this ).width();
 505                                 $( this ).removeClass("ui-dialog-resizing");
 506                                 that._unblockFrames();
 507                                 that._trigger( "resizeStop", event, filteredUi( ui ) );
 508                         }
 509                 })
 510                 .css( "position", position );
 511         },
 512
 513         _minHeight: function() {
 514                 var options = this.options;
 515
 516                 return options.height === "auto" ?
 517                         options.minHeight :
 518                         Math.min( options.minHeight, options.height );
 519         },
 520
 521         _position: function() {
 522                 // Need to show the dialog to get the actual offset in the position plugin
 523                 var isVisible = this.uiDialog.is(":visible");
 524                 if ( !isVisible ) {
 525                         this.uiDialog.show();
 526                 }
 527                 this.uiDialog.position( this.options.position );
 528                 if ( !isVisible ) {
 529                         this.uiDialog.hide();
 530                 }
 531         },
 532
 533         _setOptions: function( options ) {
 534                 var that = this,
 535                         resize = false,
 536                         resizableOptions = {};
 537
 538                 $.each( options, function( key, value ) {
 539                         that._setOption( key, value );
 540
 541                         if ( key in sizeRelatedOptions ) {
 542                                 resize = true;
 543                         }
 544                         if ( key in resizableRelatedOptions ) {
 545                                 resizableOptions[ key ] = value;
 546                         }
 547                 });
 548
 549                 if ( resize ) {
 550                         this._size();
 551                         this._position();
 552                 }
 553                 if ( this.uiDialog.is(":data(ui-resizable)") ) {
 554                         this.uiDialog.resizable( "option", resizableOptions );
 555                 }
 556         },
 557
 558         _setOption: function( key, value ) {
 559                 /*jshint maxcomplexity:15*/
 560                 var isDraggable, isResizable,
 561                         uiDialog = this.uiDialog;
 562
 563                 if ( key === "dialogClass" ) {
 564                         uiDialog
 565                                 .removeClass( this.options.dialogClass )
 566                                 .addClass( value );
 567                 }
 568
 569                 if ( key === "disabled" ) {
 570                         return;
 571                 }
 572
 573                 this._super( key, value );
 574
 575                 if ( key === "appendTo" ) {
 576                         this.uiDialog.appendTo( this._appendTo() );
 577                 }
 578
 579                 if ( key === "buttons" ) {
 580                         this._createButtons();
 581                 }
 582
 583                 if ( key === "closeText" ) {
 584                         this.uiDialogTitlebarClose.button({
 585                                 // Ensure that we always pass a string
 586                                 label: "" + value
 587                         });
 588                 }
 589
 590                 if ( key === "draggable" ) {
 591                         isDraggable = uiDialog.is(":data(ui-draggable)");
 592                         if ( isDraggable && !value ) {
 593                                 uiDialog.draggable("destroy");
 594                         }
 595
 596                         if ( !isDraggable && value ) {
 597                                 this._makeDraggable();
 598                         }
 599                 }
 600
 601                 if ( key === "position" ) {
 602                         this._position();
 603                 }
 604
 605                 if ( key === "resizable" ) {
 606                         // currently resizable, becoming non-resizable
 607                         isResizable = uiDialog.is(":data(ui-resizable)");
 608                         if ( isResizable && !value ) {
 609                                 uiDialog.resizable("destroy");
 610                         }
 611
 612                         // currently resizable, changing handles
 613                         if ( isResizable && typeof value === "string" ) {
 614                                 uiDialog.resizable( "option", "handles", value );
 615                         }
 616
 617                         // currently non-resizable, becoming resizable
 618                         if ( !isResizable && value !== false ) {
 619                                 this._makeResizable();
 620                         }
 621                 }
 622
 623                 if ( key === "title" ) {
 624                         this._title( this.uiDialogTitlebar.find(".ui-dialog-title") );
 625                 }
 626         },
 627
 628         _size: function() {
 629                 // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
 630                 // divs will both have width and height set, so we need to reset them
 631                 var nonContentHeight, minContentHeight, maxContentHeight,
 632                         options = this.options;
 633
 634                 // Reset content sizing
 635                 this.element.show().css({
 636                         width: "auto",
 637                         minHeight: 0,
 638                         maxHeight: "none",
 639                         height: 0
 640                 });
 641
 642                 if ( options.minWidth > options.width ) {
 643                         options.width = options.minWidth;
 644                 }
 645
 646                 // reset wrapper sizing
 647                 // determine the height of all the non-content elements
 648                 nonContentHeight = this.uiDialog.css({
 649                                 height: "auto",
 650                                 width: options.width
 651                         })
 652                         .outerHeight();
 653                 minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
 654                 maxContentHeight = typeof options.maxHeight === "number" ?
 655                         Math.max( 0, options.maxHeight - nonContentHeight ) :
 656                         "none";
 657
 658                 if ( options.height === "auto" ) {
 659                         this.element.css({
 660                                 minHeight: minContentHeight,
 661                                 maxHeight: maxContentHeight,
 662                                 height: "auto"
 663                         });
 664                 } else {
 665                         this.element.height( Math.max( 0, options.height - nonContentHeight ) );
 666                 }
 667
 668                 if (this.uiDialog.is(":data(ui-resizable)") ) {
 669                         this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
 670                 }
 671         },
 672
 673         _blockFrames: function() {
 674                 this.iframeBlocks = this.document.find( "iframe" ).map(function() {
 675                         var iframe = $( this );
 676
 677                         return $( "<div>" )
 678                                 .css({
 679                                         position: "absolute",
 680                                         width: iframe.outerWidth(),
 681                                         height: iframe.outerHeight()
 682                                 })
 683                                 .appendTo( iframe.parent() )
 684                                 .offset( iframe.offset() )[0];
 685                 });
 686         },
 687
 688         _unblockFrames: function() {
 689                 if ( this.iframeBlocks ) {
 690                         this.iframeBlocks.remove();
 691                         delete this.iframeBlocks;
 692                 }
 693         },
 694
 695         _allowInteraction: function( event ) {
 696                 if ( $( event.target ).closest(".ui-dialog").length ) {
 697                         return true;
 698                 }
 699
 700                 // TODO: Remove hack when datepicker implements
 701                 // the .ui-front logic (#8989)
 702                 return !!$( event.target ).closest(".ui-datepicker").length;
 703         },
 704
 705         _createOverlay: function() {
 706                 if ( !this.options.modal ) {
 707                         return;
 708                 }
 709
 710                 var that = this,
 711                         widgetFullName = this.widgetFullName;
 712                 if ( !$.ui.dialog.overlayInstances ) {
 713                         // Prevent use of anchors and inputs.
 714                         // We use a delay in case the overlay is created from an
 715                         // event that we're going to be cancelling. (#2804)
 716                         this._delay(function() {
 717                                 // Handle .dialog().dialog("close") (#4065)
 718                                 if ( $.ui.dialog.overlayInstances ) {
 719                                         this.document.bind( "focusin.dialog", function( event ) {
 720                                                 if ( !that._allowInteraction( event ) ) {
 721                                                         event.preventDefault();
 722                                                         $(".ui-dialog:visible:last .ui-dialog-content")
 723                                                                 .data( widgetFullName )._focusTabbable();
 724                                                 }
 725                                         });
 726                                 }
 727                         });
 728                 }
 729
 730                 this.overlay = $("<div>")
 731                         .addClass("ui-widget-overlay ui-front")
 732                         .appendTo( this._appendTo() );
 733                 this._on( this.overlay, {
 734                         mousedown: "_keepFocus"
 735                 });
 736                 $.ui.dialog.overlayInstances++;
 737         },
 738
 739         _destroyOverlay: function() {
 740                 if ( !this.options.modal ) {
 741                         return;
 742                 }
 743
 744                 if ( this.overlay ) {
 745                         $.ui.dialog.overlayInstances--;
 746
 747                         if ( !$.ui.dialog.overlayInstances ) {
 748                                 this.document.unbind( "focusin.dialog" );
 749                         }
 750                         this.overlay.remove();
 751                         this.overlay = null;
 752                 }
 753         }
 754 });
 755
 756 $.ui.dialog.overlayInstances = 0;
 757
 758 // DEPRECATED
 759 if ( $.uiBackCompat !== false ) {
 760         // position option with array notation
 761         // just override with old implementation
 762         $.widget( "ui.dialog", $.ui.dialog, {
 763                 _position: function() {
 764                         var position = this.options.position,
 765                                 myAt = [],
 766                                 offset = [ 0, 0 ],
 767                                 isVisible;
 768
 769                         if ( position ) {
 770                                 if ( typeof position === "string" || (typeof position === "object" && "0" in position ) ) {
 771                                         myAt = position.split ? position.split(" ") : [ position[0], position[1] ];
 772                                         if ( myAt.length === 1 ) {
 773                                                 myAt[1] = myAt[0];
 774                                         }
 775
 776                                         $.each( [ "left", "top" ], function( i, offsetPosition ) {
 777                                                 if ( +myAt[ i ] === myAt[ i ] ) {
 778                                                         offset[ i ] = myAt[ i ];
 779                                                         myAt[ i ] = offsetPosition;
 780                                                 }
 781                                         });
 782
 783                                         position = {
 784                                                 my: myAt[0] + (offset[0] < 0 ? offset[0] : "+" + offset[0]) + " " +
 785                                                         myAt[1] + (offset[1] < 0 ? offset[1] : "+" + offset[1]),
 786                                                 at: myAt.join(" ")
 787                                         };
 788                                 }
 789
 790                                 position = $.extend( {}, $.ui.dialog.prototype.options.position, position );
 791                         } else {
 792                                 position = $.ui.dialog.prototype.options.position;
 793                         }
 794
 795                         // need to show the dialog to get the actual offset in the position plugin
 796                         isVisible = this.uiDialog.is(":visible");
 797                         if ( !isVisible ) {
 798                                 this.uiDialog.show();
 799                         }
 800                         this.uiDialog.position( position );
 801                         if ( !isVisible ) {
 802                                 this.uiDialog.hide();
 803                         }
 804                 }
 805         });
 806 }
 807
 808 }( jQuery ) );