Ticket #6006: jquery.ui.dialog.js.txt

File jquery.ui.dialog.js.txt, 20.3 KB (added by jakerella, 9 years ago)
Line 
1/*
2 * jQuery UI Dialog 1.8.4
3 *
4 * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
5 * Dual licensed under the MIT or GPL Version 2 licenses.
6 * http://jquery.org/license
7 *
8 * http://docs.jquery.com/UI/Dialog
9 *
10 * REVISED:
11 *   2010-08-30 Jordan Kasper - Added "autoFocus" option to prevent content "jumping" on open
12 *
13 * Depends:
14 *      jquery.ui.core.js
15 *      jquery.ui.widget.js
16 *  jquery.ui.button.js
17 *      jquery.ui.draggable.js
18 *      jquery.ui.mouse.js
19 *      jquery.ui.position.js
20 *      jquery.ui.resizable.js
21 */
22(function( $, undefined ) {
23
24var uiDialogClasses =
25        'ui-dialog ' +
26        'ui-widget ' +
27        'ui-widget-content ' +
28        'ui-corner-all ';
29
30$.widget("ui.dialog", {
31        options: {
32                autoOpen: true,
33                buttons: {},
34                closeOnEscape: true,
35                closeText: 'close',
36                dialogClass: '',
37                draggable: true,
38                hide: null,
39                height: 'auto',
40                maxHeight: false,
41                maxWidth: false,
42                minHeight: 150,
43                minWidth: 150,
44                modal: false,
45    autoFocus: true,
46                position: {
47                        my: 'center',
48                        at: 'center',
49                        of: window,
50                        collision: 'fit',
51                        // ensure that the titlebar is never outside the document
52                        using: function(pos) {
53                                var topOffset = $(this).css(pos).offset().top;
54                                if (topOffset < 0) {
55                                        $(this).css('top', pos.top - topOffset);
56                                }
57                        }
58                },
59                resizable: true,
60                show: null,
61                stack: true,
62                title: '',
63                width: 300,
64                zIndex: 1000
65        },
66
67        _create: function() {
68                this.originalTitle = this.element.attr('title');
69                // #5742 - .attr() might return a DOMElement
70                if ( typeof this.originalTitle !== "string" ) {
71                        this.originalTitle = "";
72                }
73
74                var self = this,
75                        options = self.options,
76
77                        title = options.title || self.originalTitle || '&#160;',
78                        titleId = $.ui.dialog.getTitleId(self.element),
79
80                        uiDialog = (self.uiDialog = $('<div></div>'))
81                                .appendTo(document.body)
82                                .hide()
83                                .addClass(uiDialogClasses + options.dialogClass)
84                                .css({
85                                        zIndex: options.zIndex
86                                })
87                                // setting tabIndex makes the div focusable
88                                // setting outline to 0 prevents a border on focus in Mozilla
89                                .attr('tabIndex', -1).css('outline', 0).keydown(function(event) {
90                                        if (options.closeOnEscape && event.keyCode &&
91                                                event.keyCode === $.ui.keyCode.ESCAPE) {
92                                               
93                                                self.close(event);
94                                                event.preventDefault();
95                                        }
96                                })
97                                .attr({
98                                        role: 'dialog',
99                                        'aria-labelledby': titleId
100                                })
101                                .mousedown(function(event) {
102                                        self.moveToTop(false, event);
103                                }),
104
105                        uiDialogContent = self.element
106                                .show()
107                                .removeAttr('title')
108                                .addClass(
109                                        'ui-dialog-content ' +
110                                        'ui-widget-content')
111                                .appendTo(uiDialog),
112
113                        uiDialogTitlebar = (self.uiDialogTitlebar = $('<div></div>'))
114                                .addClass(
115                                        'ui-dialog-titlebar ' +
116                                        'ui-widget-header ' +
117                                        'ui-corner-all ' +
118                                        'ui-helper-clearfix'
119                                )
120                                .prependTo(uiDialog),
121
122                        uiDialogTitlebarClose = $('<a href="#"></a>')
123                                .addClass(
124                                        'ui-dialog-titlebar-close ' +
125                                        'ui-corner-all'
126                                )
127                                .attr('role', 'button')
128                                .hover(
129                                        function() {
130                                                uiDialogTitlebarClose.addClass('ui-state-hover');
131                                        },
132                                        function() {
133                                                uiDialogTitlebarClose.removeClass('ui-state-hover');
134                                        }
135                                )
136                                .focus(function() {
137                                        uiDialogTitlebarClose.addClass('ui-state-focus');
138                                })
139                                .blur(function() {
140                                        uiDialogTitlebarClose.removeClass('ui-state-focus');
141                                })
142                                .click(function(event) {
143                                        self.close(event);
144                                        return false;
145                                })
146                                .appendTo(uiDialogTitlebar),
147
148                        uiDialogTitlebarCloseText = (self.uiDialogTitlebarCloseText = $('<span></span>'))
149                                .addClass(
150                                        'ui-icon ' +
151                                        'ui-icon-closethick'
152                                )
153                                .text(options.closeText)
154                                .appendTo(uiDialogTitlebarClose),
155
156                        uiDialogTitle = $('<span></span>')
157                                .addClass('ui-dialog-title')
158                                .attr('id', titleId)
159                                .html(title)
160                                .prependTo(uiDialogTitlebar);
161
162                //handling of deprecated beforeclose (vs beforeClose) option
163                //Ticket #4669 http://dev.jqueryui.com/ticket/4669
164                //TODO: remove in 1.9pre
165                if ($.isFunction(options.beforeclose) && !$.isFunction(options.beforeClose)) {
166                        options.beforeClose = options.beforeclose;
167                }
168
169                uiDialogTitlebar.find("*").add(uiDialogTitlebar).disableSelection();
170
171                if (options.draggable && $.fn.draggable) {
172                        self._makeDraggable();
173                }
174                if (options.resizable && $.fn.resizable) {
175                        self._makeResizable();
176                }
177
178                self._createButtons(options.buttons);
179                self._isOpen = false;
180
181                if ($.fn.bgiframe) {
182                        uiDialog.bgiframe();
183                }
184        },
185
186        _init: function() {
187                if ( this.options.autoOpen ) {
188                        this.open();
189                }
190        },
191
192        destroy: function() {
193                var self = this;
194               
195                if (self.overlay) {
196                        self.overlay.destroy();
197                }
198                self.uiDialog.hide();
199                self.element
200                        .unbind('.dialog')
201                        .removeData('dialog')
202                        .removeClass('ui-dialog-content ui-widget-content')
203                        .hide().appendTo('body');
204                self.uiDialog.remove();
205
206                if (self.originalTitle) {
207                        self.element.attr('title', self.originalTitle);
208                }
209
210                return self;
211        },
212
213        widget: function() {
214                return this.uiDialog;
215        },
216
217        close: function(event) {
218                var self = this,
219                        maxZ;
220               
221                if (false === self._trigger('beforeClose', event)) {
222                        return;
223                }
224
225                if (self.overlay) {
226                        self.overlay.destroy();
227                }
228                self.uiDialog.unbind('keypress.ui-dialog');
229
230                self._isOpen = false;
231
232                if (self.options.hide) {
233                        self.uiDialog.hide(self.options.hide, function() {
234                                self._trigger('close', event);
235                        });
236                } else {
237                        self.uiDialog.hide();
238                        self._trigger('close', event);
239                }
240
241                $.ui.dialog.overlay.resize();
242
243                // adjust the maxZ to allow other modal dialogs to continue to work (see #4309)
244                if (self.options.modal) {
245                        maxZ = 0;
246                        $('.ui-dialog').each(function() {
247                                if (this !== self.uiDialog[0]) {
248                                        maxZ = Math.max(maxZ, $(this).css('z-index'));
249                                }
250                        });
251                        $.ui.dialog.maxZ = maxZ;
252                }
253
254                return self;
255        },
256
257        isOpen: function() {
258                return this._isOpen;
259        },
260
261        // the force parameter allows us to move modal dialogs to their correct
262        // position on open
263        moveToTop: function(force, event) {
264                var self = this,
265                        options = self.options,
266                        saveScroll;
267
268                if ((options.modal && !force) ||
269                        (!options.stack && !options.modal)) {
270                        return self._trigger('focus', event);
271                }
272
273                if (options.zIndex > $.ui.dialog.maxZ) {
274                        $.ui.dialog.maxZ = options.zIndex;
275                }
276                if (self.overlay) {
277                        $.ui.dialog.maxZ += 1;
278                        self.overlay.$el.css('z-index', $.ui.dialog.overlay.maxZ = $.ui.dialog.maxZ);
279                }
280
281                //Save and then restore scroll since Opera 9.5+ resets when parent z-Index is changed.
282                //  http://ui.jquery.com/bugs/ticket/3193
283                saveScroll = { scrollTop: self.element.attr('scrollTop'), scrollLeft: self.element.attr('scrollLeft') };
284                $.ui.dialog.maxZ += 1;
285                self.uiDialog.css('z-index', $.ui.dialog.maxZ);
286                self.element.attr(saveScroll);
287                self._trigger('focus', event);
288
289                return self;
290        },
291
292        open: function() {
293                if (this._isOpen) { return; }
294
295                var self = this,
296                        options = self.options,
297                        uiDialog = self.uiDialog;
298
299                self.overlay = options.modal ? new $.ui.dialog.overlay(self) : null;
300                if (uiDialog.next().length) {
301                        uiDialog.appendTo('body');
302                }
303                self._size();
304                self._position(options.position);
305                uiDialog.show(options.show);
306                self.moveToTop(true);
307
308                // prevent tabbing out of modal dialogs
309                if (options.modal) {
310                        uiDialog.bind('keypress.ui-dialog', function(event) {
311                                if (event.keyCode !== $.ui.keyCode.TAB) {
312                                        return;
313                                }
314
315                                var tabbables = $(':tabbable', this),
316                                        first = tabbables.filter(':first'),
317                                        last  = tabbables.filter(':last');
318
319                                if (event.target === last[0] && !event.shiftKey) {
320                                        first.focus(1);
321                                        return false;
322                                } else if (event.target === first[0] && event.shiftKey) {
323                                        last.focus(1);
324                                        return false;
325                                }
326                        });
327                }
328
329    if (options.autoFocus) {
330                  // set focus to the first tabbable element in the content area or the first button
331                  // if there are no tabbable elements, set focus on the dialog itself
332                $(self.element.find(':tabbable').get().concat(
333                        uiDialog.find('.ui-dialog-buttonpane :tabbable').get().concat(
334                                uiDialog.get()))).eq(0).focus();
335    } else {
336      $(uiDialog.get()).focus();
337    }
338   
339                self._trigger('open');
340                self._isOpen = true;
341
342                return self;
343        },
344
345        _createButtons: function(buttons) {
346                var self = this,
347                        hasButtons = false,
348                        uiDialogButtonPane = $('<div></div>')
349                                .addClass(
350                                        'ui-dialog-buttonpane ' +
351                                        'ui-widget-content ' +
352                                        'ui-helper-clearfix'
353                                ),
354                        uiButtonSet = $( "<div></div>" )
355                                .addClass( "ui-dialog-buttonset" )
356                                .appendTo( uiDialogButtonPane );
357
358                // if we already have a button pane, remove it
359                self.uiDialog.find('.ui-dialog-buttonpane').remove();
360
361                if (typeof buttons === 'object' && buttons !== null) {
362                        $.each(buttons, function() {
363                                return !(hasButtons = true);
364                        });
365                }
366                if (hasButtons) {
367                        $.each(buttons, function(name, fn) {
368                                var button = $('<button type="button"></button>')
369                                        .text(name)
370                                        .click(function() { fn.apply(self.element[0], arguments); })
371                                        .appendTo(uiButtonSet);
372                                if ($.fn.button) {
373                                        button.button();
374                                }
375                        });
376                        uiDialogButtonPane.appendTo(self.uiDialog);
377                }
378        },
379
380        _makeDraggable: function() {
381                var self = this,
382                        options = self.options,
383                        doc = $(document),
384                        heightBeforeDrag;
385
386                function filteredUi(ui) {
387                        return {
388                                position: ui.position,
389                                offset: ui.offset
390                        };
391                }
392
393                self.uiDialog.draggable({
394                        cancel: '.ui-dialog-content, .ui-dialog-titlebar-close',
395                        handle: '.ui-dialog-titlebar',
396                        containment: 'document',
397                        start: function(event, ui) {
398                                heightBeforeDrag = options.height === "auto" ? "auto" : $(this).height();
399                                $(this).height($(this).height()).addClass("ui-dialog-dragging");
400                                self._trigger('dragStart', event, filteredUi(ui));
401                        },
402                        drag: function(event, ui) {
403                                self._trigger('drag', event, filteredUi(ui));
404                        },
405                        stop: function(event, ui) {
406                                options.position = [ui.position.left - doc.scrollLeft(),
407                                        ui.position.top - doc.scrollTop()];
408                                $(this).removeClass("ui-dialog-dragging").height(heightBeforeDrag);
409                                self._trigger('dragStop', event, filteredUi(ui));
410                                $.ui.dialog.overlay.resize();
411                        }
412                });
413        },
414
415        _makeResizable: function(handles) {
416                handles = (handles === undefined ? this.options.resizable : handles);
417                var self = this,
418                        options = self.options,
419                        // .ui-resizable has position: relative defined in the stylesheet
420                        // but dialogs have to use absolute or fixed positioning
421                        position = self.uiDialog.css('position'),
422                        resizeHandles = (typeof handles === 'string' ?
423                                handles :
424                                'n,e,s,w,se,sw,ne,nw'
425                        );
426
427                function filteredUi(ui) {
428                        return {
429                                originalPosition: ui.originalPosition,
430                                originalSize: ui.originalSize,
431                                position: ui.position,
432                                size: ui.size
433                        };
434                }
435
436                self.uiDialog.resizable({
437                        cancel: '.ui-dialog-content',
438                        containment: 'document',
439                        alsoResize: self.element,
440                        maxWidth: options.maxWidth,
441                        maxHeight: options.maxHeight,
442                        minWidth: options.minWidth,
443                        minHeight: self._minHeight(),
444                        handles: resizeHandles,
445                        start: function(event, ui) {
446                                $(this).addClass("ui-dialog-resizing");
447                                self._trigger('resizeStart', event, filteredUi(ui));
448                        },
449                        resize: function(event, ui) {
450                                self._trigger('resize', event, filteredUi(ui));
451                        },
452                        stop: function(event, ui) {
453                                $(this).removeClass("ui-dialog-resizing");
454                                options.height = $(this).height();
455                                options.width = $(this).width();
456                                self._trigger('resizeStop', event, filteredUi(ui));
457                                $.ui.dialog.overlay.resize();
458                        }
459                })
460                .css('position', position)
461                .find('.ui-resizable-se').addClass('ui-icon ui-icon-grip-diagonal-se');
462        },
463
464        _minHeight: function() {
465                var options = this.options;
466
467                if (options.height === 'auto') {
468                        return options.minHeight;
469                } else {
470                        return Math.min(options.minHeight, options.height);
471                }
472        },
473
474        _position: function(position) {
475                var myAt = [],
476                        offset = [0, 0],
477                        isVisible;
478
479                if (position) {
480                        // deep extending converts arrays to objects in jQuery <= 1.3.2 :-(
481        //              if (typeof position == 'string' || $.isArray(position)) {
482        //                      myAt = $.isArray(position) ? position : position.split(' ');
483
484                        if (typeof position === 'string' || (typeof position === 'object' && '0' in position)) {
485                                myAt = position.split ? position.split(' ') : [position[0], position[1]];
486                                if (myAt.length === 1) {
487                                        myAt[1] = myAt[0];
488                                }
489
490                                $.each(['left', 'top'], function(i, offsetPosition) {
491                                        if (+myAt[i] === myAt[i]) {
492                                                offset[i] = myAt[i];
493                                                myAt[i] = offsetPosition;
494                                        }
495                                });
496
497                                position = {
498                                        my: myAt.join(" "),
499                                        at: myAt.join(" "),
500                                        offset: offset.join(" ")
501                                };
502                        }
503
504                        position = $.extend({}, $.ui.dialog.prototype.options.position, position);
505                } else {
506                        position = $.ui.dialog.prototype.options.position;
507                }
508
509                // need to show the dialog to get the actual offset in the position plugin
510                isVisible = this.uiDialog.is(':visible');
511                if (!isVisible) {
512                        this.uiDialog.show();
513                }
514                this.uiDialog
515                        // workaround for jQuery bug #5781 http://dev.jquery.com/ticket/5781
516                        .css({ top: 0, left: 0 })
517                        .position(position);
518                if (!isVisible) {
519                        this.uiDialog.hide();
520                }
521        },
522
523        _setOption: function(key, value){
524                var self = this,
525                        uiDialog = self.uiDialog,
526                        isResizable = uiDialog.is(':data(resizable)'),
527                        resize = false;
528
529                switch (key) {
530                        //handling of deprecated beforeclose (vs beforeClose) option
531                        //Ticket #4669 http://dev.jqueryui.com/ticket/4669
532                        //TODO: remove in 1.9pre
533                        case "beforeclose":
534                                key = "beforeClose";
535                                break;
536                        case "buttons":
537                                self._createButtons(value);
538                                resize = true;
539                                break;
540                        case "closeText":
541                                // convert whatever was passed in to a string, for text() to not throw up
542                                self.uiDialogTitlebarCloseText.text("" + value);
543                                break;
544                        case "dialogClass":
545                                uiDialog
546                                        .removeClass(self.options.dialogClass)
547                                        .addClass(uiDialogClasses + value);
548                                break;
549                        case "disabled":
550                                if (value) {
551                                        uiDialog.addClass('ui-dialog-disabled');
552                                } else {
553                                        uiDialog.removeClass('ui-dialog-disabled');
554                                }
555                                break;
556                        case "draggable":
557                                if (value) {
558                                        self._makeDraggable();
559                                } else {
560                                        uiDialog.draggable('destroy');
561                                }
562                                break;
563                        case "height":
564                                resize = true;
565                                break;
566                        case "maxHeight":
567                                if (isResizable) {
568                                        uiDialog.resizable('option', 'maxHeight', value);
569                                }
570                                resize = true;
571                                break;
572                        case "maxWidth":
573                                if (isResizable) {
574                                        uiDialog.resizable('option', 'maxWidth', value);
575                                }
576                                resize = true;
577                                break;
578                        case "minHeight":
579                                if (isResizable) {
580                                        uiDialog.resizable('option', 'minHeight', value);
581                                }
582                                resize = true;
583                                break;
584                        case "minWidth":
585                                if (isResizable) {
586                                        uiDialog.resizable('option', 'minWidth', value);
587                                }
588                                resize = true;
589                                break;
590                        case "position":
591                                self._position(value);
592                                break;
593                        case "resizable":
594                                // currently resizable, becoming non-resizable
595                                if (isResizable && !value) {
596                                        uiDialog.resizable('destroy');
597                                }
598
599                                // currently resizable, changing handles
600                                if (isResizable && typeof value === 'string') {
601                                        uiDialog.resizable('option', 'handles', value);
602                                }
603
604                                // currently non-resizable, becoming resizable
605                                if (!isResizable && value !== false) {
606                                        self._makeResizable(value);
607                                }
608                                break;
609                        case "title":
610                                // convert whatever was passed in o a string, for html() to not throw up
611                                $(".ui-dialog-title", self.uiDialogTitlebar).html("" + (value || '&#160;'));
612                                break;
613                        case "width":
614                                resize = true;
615                                break;
616                }
617
618                $.Widget.prototype._setOption.apply(self, arguments);
619                if (resize) {
620                        self._size();
621                }
622        },
623
624        _size: function() {
625                /* If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
626                 * divs will both have width and height set, so we need to reset them
627                 */
628                var options = this.options,
629                        nonContentHeight;
630
631                // reset content sizing
632                // hide for non content measurement because height: 0 doesn't work in IE quirks mode (see #4350)
633                this.element.css({
634                        width: 'auto',
635                        minHeight: 0,
636                        height: 0
637                });
638
639                if (options.minWidth > options.width) {
640                        options.width = options.minWidth;
641                }
642
643                // reset wrapper sizing
644                // determine the height of all the non-content elements
645                nonContentHeight = this.uiDialog.css({
646                                height: 'auto',
647                                width: options.width
648                        })
649                        .height();
650
651                this.element
652                        .css(options.height === 'auto' ? {
653                                        minHeight: Math.max(options.minHeight - nonContentHeight, 0),
654                                        height: 'auto'
655                                } : {
656                                        minHeight: 0,
657                                        height: Math.max(options.height - nonContentHeight, 0)                         
658                        })
659                        .show();
660
661                if (this.uiDialog.is(':data(resizable)')) {
662                        this.uiDialog.resizable('option', 'minHeight', this._minHeight());
663                }
664        }
665});
666
667$.extend($.ui.dialog, {
668        version: "1.8.4",
669
670        uuid: 0,
671        maxZ: 0,
672
673        getTitleId: function($el) {
674                var id = $el.attr('id');
675                if (!id) {
676                        this.uuid += 1;
677                        id = this.uuid;
678                }
679                return 'ui-dialog-title-' + id;
680        },
681
682        overlay: function(dialog) {
683                this.$el = $.ui.dialog.overlay.create(dialog);
684        }
685});
686
687$.extend($.ui.dialog.overlay, {
688        instances: [],
689        // reuse old instances due to IE memory leak with alpha transparency (see #5185)
690        oldInstances: [],
691        maxZ: 0,
692        events: $.map('focus,mousedown,mouseup,keydown,keypress,click'.split(','),
693                function(event) { return event + '.dialog-overlay'; }).join(' '),
694        create: function(dialog) {
695                if (this.instances.length === 0) {
696                        // prevent use of anchors and inputs
697                        // we use a setTimeout in case the overlay is created from an
698                        // event that we're going to be cancelling (see #2804)
699                        setTimeout(function() {
700                                // handle $(el).dialog().dialog('close') (see #4065)
701                                if ($.ui.dialog.overlay.instances.length) {
702                                        $(document).bind($.ui.dialog.overlay.events, function(event) {
703                                                // stop events if the z-index of the target is < the z-index of the overlay
704                                                return ($(event.target).zIndex() >= $.ui.dialog.overlay.maxZ);
705                                        });
706                                }
707                        }, 1);
708
709                        // allow closing by pressing the escape key
710                        $(document).bind('keydown.dialog-overlay', function(event) {
711                                if (dialog.options.closeOnEscape && event.keyCode &&
712                                        event.keyCode === $.ui.keyCode.ESCAPE) {
713                                       
714                                        dialog.close(event);
715                                        event.preventDefault();
716                                }
717                        });
718
719                        // handle window resize
720                        $(window).bind('resize.dialog-overlay', $.ui.dialog.overlay.resize);
721                }
722
723                var $el = (this.oldInstances.pop() || $('<div></div>').addClass('ui-widget-overlay'))
724                        .appendTo(document.body)
725                        .css({
726                                width: this.width(),
727                                height: this.height()
728                        });
729
730                if ($.fn.bgiframe) {
731                        $el.bgiframe();
732                }
733
734                this.instances.push($el);
735                return $el;
736        },
737
738        destroy: function($el) {
739                this.oldInstances.push(this.instances.splice($.inArray($el, this.instances), 1)[0]);
740
741                if (this.instances.length === 0) {
742                        $([document, window]).unbind('.dialog-overlay');
743                }
744
745                $el.remove();
746               
747                // adjust the maxZ to allow other modal dialogs to continue to work (see #4309)
748                var maxZ = 0;
749                $.each(this.instances, function() {
750                        maxZ = Math.max(maxZ, this.css('z-index'));
751                });
752                this.maxZ = maxZ;
753        },
754
755        height: function() {
756                var scrollHeight,
757                        offsetHeight;
758                // handle IE 6
759                if ($.browser.msie && $.browser.version < 7) {
760                        scrollHeight = Math.max(
761                                document.documentElement.scrollHeight,
762                                document.body.scrollHeight
763                        );
764                        offsetHeight = Math.max(
765                                document.documentElement.offsetHeight,
766                                document.body.offsetHeight
767                        );
768
769                        if (scrollHeight < offsetHeight) {
770                                return $(window).height() + 'px';
771                        } else {
772                                return scrollHeight + 'px';
773                        }
774                // handle "good" browsers
775                } else {
776                        return $(document).height() + 'px';
777                }
778        },
779
780        width: function() {
781                var scrollWidth,
782                        offsetWidth;
783                // handle IE 6
784                if ($.browser.msie && $.browser.version < 7) {
785                        scrollWidth = Math.max(
786                                document.documentElement.scrollWidth,
787                                document.body.scrollWidth
788                        );
789                        offsetWidth = Math.max(
790                                document.documentElement.offsetWidth,
791                                document.body.offsetWidth
792                        );
793
794                        if (scrollWidth < offsetWidth) {
795                                return $(window).width() + 'px';
796                        } else {
797                                return scrollWidth + 'px';
798                        }
799                // handle "good" browsers
800                } else {
801                        return $(document).width() + 'px';
802                }
803        },
804
805        resize: function() {
806                /* If the dialog is draggable and the user drags it past the
807                 * right edge of the window, the document becomes wider so we
808                 * need to stretch the overlay. If the user then drags the
809                 * dialog back to the left, the document will become narrower,
810                 * so we need to shrink the overlay to the appropriate size.
811                 * This is handled by shrinking the overlay before setting it
812                 * to the full document size.
813                 */
814                var $overlays = $([]);
815                $.each($.ui.dialog.overlay.instances, function() {
816                        $overlays = $overlays.add(this);
817                });
818
819                $overlays.css({
820                        width: 0,
821                        height: 0
822                }).css({
823                        width: $.ui.dialog.overlay.width(),
824                        height: $.ui.dialog.overlay.height()
825                });
826        }
827});
828
829$.extend($.ui.dialog.overlay.prototype, {
830        destroy: function() {
831                $.ui.dialog.overlay.destroy(this.$el);
832        }
833});
834
835}(jQuery));