jquery-ui-1.10.3/ui/jquery.ui.dialog.js

/*!
 * jQuery UI Dialog 1.10.3
 * http://jqueryui.com
 *
 * Copyright 2013 jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 *
 * http://api.jqueryui.com/dialog/
 *
 * Depends:
 *      jquery.ui.core.js
 *      jquery.ui.widget.js
 *  jquery.ui.button.js
 *      jquery.ui.draggable.js
 *      jquery.ui.mouse.js
 *      jquery.ui.position.js
 *      jquery.ui.resizable.js
 */
(function( $, undefined ) {

var sizeRelatedOptions = {
                buttons: true,
                height: true,
                maxHeight: true,
                maxWidth: true,
                minHeight: true,
                minWidth: true,
                width: true
        },
        resizableRelatedOptions = {
                maxHeight: true,
                maxWidth: true,
                minHeight: true,
                minWidth: true
        };

$.widget( "ui.dialog", {
        version: "1.10.3",
        options: {
                appendTo: "body",
                autoOpen: true,
                buttons: [],
                closeOnEscape: true,
                closeText: "close",
                dialogClass: "",
                draggable: true,
                hide: null,
                height: "auto",
                maxHeight: null,
                maxWidth: null,
                minHeight: 150,
                minWidth: 150,
                modal: false,
                position: {
                        my: "center",
                        at: "center",
                        of: window,
                        collision: "fit",
                        // Ensure the titlebar is always visible
                        using: function( pos ) {
                                var topOffset = $( this ).css( pos ).offset().top;
                                if ( topOffset < 0 ) {
                                        $( this ).css( "top", pos.top - topOffset );
                                }
                        }
                },
                resizable: true,
                show: null,
                title: null,
                width: 300,

                // callbacks
                beforeClose: null,
                close: null,
                drag: null,
                dragStart: null,
                dragStop: null,
                focus: null,
                open: null,
                resize: null,
                resizeStart: null,
                resizeStop: null
        },

        _create: function() {
                this.originalCss = {
                        display: this.element[0].style.display,
                        width: this.element[0].style.width,
                        minHeight: this.element[0].style.minHeight,
                        maxHeight: this.element[0].style.maxHeight,
                        height: this.element[0].style.height
                };
                this.originalPosition = {
                        parent: this.element.parent(),
                        index: this.element.parent().children().index( this.element )
                };
                this.originalTitle = this.element.attr("title");
                this.options.title = this.options.title || this.originalTitle;

                this._createWrapper();

                this.element
                        .show()
                        .removeAttr("title")
                        .addClass("ui-dialog-content ui-widget-content")
                        .appendTo( this.uiDialog );

                this._createTitlebar();
                this._createButtonPane();

                if ( this.options.draggable && $.fn.draggable ) {
                        this._makeDraggable();
                }
                if ( this.options.resizable && $.fn.resizable ) {
                        this._makeResizable();
                }

                this._isOpen = false;
        },

        _init: function() {
                if ( this.options.autoOpen ) {
                        this.open();
                }
        },

        _appendTo: function() {
                var element = this.options.appendTo;
                if ( element && (element.jquery || element.nodeType) ) {
                        return $( element );
                }
                return this.document.find( element || "body" ).eq( 0 );
        },

        _destroy: function() {
                var next,
                        originalPosition = this.originalPosition;

                this._destroyOverlay();

                this.element
                        .removeUniqueId()
                        .removeClass("ui-dialog-content ui-widget-content")
                        .css( this.originalCss )
                        // Without detaching first, the following becomes really slow
                        .detach();

                this.uiDialog.stop( true, true ).remove();

                if ( this.originalTitle ) {
                        this.element.attr( "title", this.originalTitle );
                }

                next = originalPosition.parent.children().eq( originalPosition.index );
                // Don't try to place the dialog next to itself (#8613)
                if ( next.length && next[0] !== this.element[0] ) {
                        next.before( this.element );
                } else {
                        originalPosition.parent.append( this.element );
                }
        },

        widget: function() {
                return this.uiDialog;
        },

        disable: $.noop,
        enable: $.noop,

        close: function( event ) {
                var that = this;

                if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
                        return;
                }

                this._isOpen = false;
                this._destroyOverlay();

                if ( !this.opener.filter(":focusable").focus().length ) {
                        // Hiding a focused element doesn't trigger blur in WebKit
                        // so in case we have nothing to focus on, explicitly blur the active element
                        // https://bugs.webkit.org/show_bug.cgi?id=47182
                        $( this.document[0].activeElement ).blur();
                }

                this._hide( this.uiDialog, this.options.hide, function() {
                        that._trigger( "close", event );
                });
        },

        isOpen: function() {
                return this._isOpen;
        },

        moveToTop: function() {
                this._moveToTop();
        },

        _moveToTop: function( event, silent ) {
                var moved = !!this.uiDialog.nextAll(":visible").insertBefore( this.uiDialog ).length;
                if ( moved && !silent ) {
                        this._trigger( "focus", event );
                }
                return moved;
        },

        open: function() {
                var that = this;
                if ( this._isOpen ) {
                        if ( this._moveToTop() ) {
                                this._focusTabbable();
                        }
                        return;
                }

                this._isOpen = true;
                this.opener = $( this.document[0].activeElement );

                this._size();
                this._position();
                this._createOverlay();
                this._moveToTop( null, true );
                this._show( this.uiDialog, this.options.show, function() {
                        that._focusTabbable();
                        that._trigger("focus");
                });

                this._trigger("open");
        },

        _focusTabbable: function() {
                // Set focus to the first match:
                // 1. First element inside the dialog matching [autofocus]
                // 2. Tabbable element inside the content element
                // 3. Tabbable element inside the buttonpane
                // 4. The close button
                // 5. The dialog itself
                var hasFocus = this.element.find("[autofocus]");
                if ( !hasFocus.length ) {
                        hasFocus = this.element.find(":tabbable");
                }
                if ( !hasFocus.length ) {
                        hasFocus = this.uiDialogButtonPane.find(":tabbable");
                }
                if ( !hasFocus.length ) {
                        hasFocus = this.uiDialogTitlebarClose.filter(":tabbable");
                }
                if ( !hasFocus.length ) {
                        hasFocus = this.uiDialog;
                }
                hasFocus.eq( 0 ).focus();
        },

        _keepFocus: function( event ) {
                function checkFocus() {
                        var activeElement = this.document[0].activeElement,
                                isActive = this.uiDialog[0] === activeElement ||
                                        $.contains( this.uiDialog[0], activeElement );
                        if ( !isActive ) {
                                this._focusTabbable();
                        }
                }
                event.preventDefault();
                checkFocus.call( this );
                // support: IE
                // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
                // so we check again later
                this._delay( checkFocus );
        },

        _createWrapper: function() {
                this.uiDialog = $("<div>")
                        .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
                                this.options.dialogClass )
                        .hide()
                        .attr({
                                // Setting tabIndex makes the div focusable
                                tabIndex: -1,
                                role: "dialog"
                        })
                        .appendTo( this._appendTo() );

                this._on( this.uiDialog, {
                        keydown: function( event ) {
                                if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
                                                event.keyCode === $.ui.keyCode.ESCAPE ) {
                                        event.preventDefault();
                                        this.close( event );
                                        return;
                                }

                                // prevent tabbing out of dialogs
                                if ( event.keyCode !== $.ui.keyCode.TAB ) {
                                        return;
                                }
                                var tabbables = this.uiDialog.find(":tabbable"),
                                        first = tabbables.filter(":first"),
                                        last  = tabbables.filter(":last");

                                if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
                                        first.focus( 1 );
                                        event.preventDefault();
                                } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
                                        last.focus( 1 );
                                        event.preventDefault();
                                }
                        },
                        mousedown: function( event ) {
                                if ( this._moveToTop( event ) ) {
                                        this._focusTabbable();
                                }
                        }
                });

                // We assume that any existing aria-describedby attribute means
                // that the dialog content is marked up properly
                // otherwise we brute force the content as the description
                if ( !this.element.find("[aria-describedby]").length ) {
                        this.uiDialog.attr({
                                "aria-describedby": this.element.uniqueId().attr("id")
                        });
                }
        },

        _createTitlebar: function() {
                var uiDialogTitle;

                this.uiDialogTitlebar = $("<div>")
                        .addClass("ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix")
                        .prependTo( this.uiDialog );
                this._on( this.uiDialogTitlebar, {
                        mousedown: function( event ) {
                                // Don't prevent click on close button (#8838)
                                // Focusing a dialog that is partially scrolled out of view
                                // causes the browser to scroll it into view, preventing the click event
                                if ( !$( event.target ).closest(".ui-dialog-titlebar-close") ) {
                                        // Dialog isn't getting focus when dragging (#8063)
                                        this.uiDialog.focus();
                                }
                        }
                });

                this.uiDialogTitlebarClose = $("<button></button>")
                        .button({
                                label: this.options.closeText,
                                icons: {
                                        primary: "ui-icon-closethick"
                                },
                                text: false
                        })
                        .addClass("ui-dialog-titlebar-close")
                        .appendTo( this.uiDialogTitlebar );
                this._on( this.uiDialogTitlebarClose, {
                        click: function( event ) {
                                event.preventDefault();
                                this.close( event );
                        }
                });

                uiDialogTitle = $("<span>")
                        .uniqueId()
                        .addClass("ui-dialog-title")
                        .prependTo( this.uiDialogTitlebar );
                this._title( uiDialogTitle );

                this.uiDialog.attr({
                        "aria-labelledby": uiDialogTitle.attr("id")
                });
        },

        _title: function( title ) {
                if ( !this.options.title ) {
                        title.html("&#160;");
                }
                title.text( this.options.title );
        },

        _createButtonPane: function() {
                this.uiDialogButtonPane = $("<div>")
                        .addClass("ui-dialog-buttonpane ui-widget-content ui-helper-clearfix");

                this.uiButtonSet = $("<div>")
                        .addClass("ui-dialog-buttonset")
                        .appendTo( this.uiDialogButtonPane );

                this._createButtons();
        },

        _createButtons: function() {
                var that = this,
                        buttons = this.options.buttons;

                // if we already have a button pane, remove it
                this.uiDialogButtonPane.remove();
                this.uiButtonSet.empty();

                if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
                        this.uiDialog.removeClass("ui-dialog-buttons");
                        return;
                }

                $.each( buttons, function( name, props ) {
                        var click, buttonOptions;
                        props = $.isFunction( props ) ?
                                { click: props, text: name } :
                                props;
                        // Default to a non-submitting button
                        props = $.extend( { type: "button" }, props );
                        // Change the context for the click callback to be the main element
                        click = props.click;
                        props.click = function() {
                                click.apply( that.element[0], arguments );
                        };
                        buttonOptions = {
                                icons: props.icons,
                                text: props.showText
                        };
                        delete props.icons;
                        delete props.showText;
                        $( "<button></button>", props )
                                .button( buttonOptions )
                                .appendTo( that.uiButtonSet );
                });
                this.uiDialog.addClass("ui-dialog-buttons");
                this.uiDialogButtonPane.appendTo( this.uiDialog );
        },

        _makeDraggable: function() {
                var that = this,
                        options = this.options;

                function filteredUi( ui ) {
                        return {
                                position: ui.position,
                                offset: ui.offset
                        };
                }

                this.uiDialog.draggable({
                        cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
                        handle: ".ui-dialog-titlebar",
                        containment: "document",
                        start: function( event, ui ) {
                                $( this ).addClass("ui-dialog-dragging");
                                that._blockFrames();
                                that._trigger( "dragStart", event, filteredUi( ui ) );
                        },
                        drag: function( event, ui ) {
                                that._trigger( "drag", event, filteredUi( ui ) );
                        },
                        stop: function( event, ui ) {
                                options.position = [
                                        ui.position.left - that.document.scrollLeft(),
                                        ui.position.top - that.document.scrollTop()
                                ];
                                $( this ).removeClass("ui-dialog-dragging");
                                that._unblockFrames();
                                that._trigger( "dragStop", event, filteredUi( ui ) );
                        }
                });
        },

        _makeResizable: function() {
                var that = this,
                        options = this.options,
                        handles = options.resizable,
                        // .ui-resizable has position: relative defined in the stylesheet
                        // but dialogs have to use absolute or fixed positioning
                        position = this.uiDialog.css("position"),
                        resizeHandles = typeof handles === "string" ?
                                handles :
                                "n,e,s,w,se,sw,ne,nw";

                function filteredUi( ui ) {
                        return {
                                originalPosition: ui.originalPosition,
                                originalSize: ui.originalSize,
                                position: ui.position,
                                size: ui.size
                        };
                }

                this.uiDialog.resizable({
                        cancel: ".ui-dialog-content",
                        containment: "document",
                        alsoResize: this.element,
                        maxWidth: options.maxWidth,
                        maxHeight: options.maxHeight,
                        minWidth: options.minWidth,
                        minHeight: this._minHeight(),
                        handles: resizeHandles,
                        start: function( event, ui ) {
                                $( this ).addClass("ui-dialog-resizing");
                                that._blockFrames();
                                that._trigger( "resizeStart", event, filteredUi( ui ) );
                        },
                        resize: function( event, ui ) {
                                that._trigger( "resize", event, filteredUi( ui ) );
                        },
                        stop: function( event, ui ) {
                                options.height = $( this ).height();
                                options.width = $( this ).width();
                                $( this ).removeClass("ui-dialog-resizing");
                                that._unblockFrames();
                                that._trigger( "resizeStop", event, filteredUi( ui ) );
                        }
                })
                .css( "position", position );
        },

        _minHeight: function() {
                var options = this.options;

                return options.height === "auto" ?
                        options.minHeight :
                        Math.min( options.minHeight, options.height );
        },

        _position: function() {
                // Need to show the dialog to get the actual offset in the position plugin
                var isVisible = this.uiDialog.is(":visible");
                if ( !isVisible ) {
                        this.uiDialog.show();
                }
                this.uiDialog.position( this.options.position );
                if ( !isVisible ) {
                        this.uiDialog.hide();
                }
        },

        _setOptions: function( options ) {
                var that = this,
                        resize = false,
                        resizableOptions = {};

                $.each( options, function( key, value ) {
                        that._setOption( key, value );

                        if ( key in sizeRelatedOptions ) {
                                resize = true;
                        }
                        if ( key in resizableRelatedOptions ) {
                                resizableOptions[ key ] = value;
                        }
                });

                if ( resize ) {
                        this._size();
                        this._position();
                }
                if ( this.uiDialog.is(":data(ui-resizable)") ) {
                        this.uiDialog.resizable( "option", resizableOptions );
                }
        },

        _setOption: function( key, value ) {
                /*jshint maxcomplexity:15*/
                var isDraggable, isResizable,
                        uiDialog = this.uiDialog;

                if ( key === "dialogClass" ) {
                        uiDialog
                                .removeClass( this.options.dialogClass )
                                .addClass( value );
                }

                if ( key === "disabled" ) {
                        return;
                }

                this._super( key, value );

                if ( key === "appendTo" ) {
                        this.uiDialog.appendTo( this._appendTo() );
                }

                if ( key === "buttons" ) {
                        this._createButtons();
                }

                if ( key === "closeText" ) {
                        this.uiDialogTitlebarClose.button({
                                // Ensure that we always pass a string
                                label: "" + value
                        });
                }

                if ( key === "draggable" ) {
                        isDraggable = uiDialog.is(":data(ui-draggable)");
                        if ( isDraggable && !value ) {
                                uiDialog.draggable("destroy");
                        }

                        if ( !isDraggable && value ) {
                                this._makeDraggable();
                        }
                }

                if ( key === "position" ) {
                        this._position();
                }

                if ( key === "resizable" ) {
                        // currently resizable, becoming non-resizable
                        isResizable = uiDialog.is(":data(ui-resizable)");
                        if ( isResizable && !value ) {
                                uiDialog.resizable("destroy");
                        }

                        // currently resizable, changing handles
                        if ( isResizable && typeof value === "string" ) {
                                uiDialog.resizable( "option", "handles", value );
                        }

                        // currently non-resizable, becoming resizable
                        if ( !isResizable && value !== false ) {
                                this._makeResizable();
                        }
                }

                if ( key === "title" ) {
                        this._title( this.uiDialogTitlebar.find(".ui-dialog-title") );
                }
        },

        _size: function() {
                // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
                // divs will both have width and height set, so we need to reset them
                var nonContentHeight, minContentHeight, maxContentHeight,
                        options = this.options;

                // Reset content sizing
                this.element.show().css({
                        width: "auto",
                        minHeight: 0,
                        maxHeight: "none",
                        height: 0
                });

                if ( options.minWidth > options.width ) {
                        options.width = options.minWidth;
                }

                // reset wrapper sizing
                // determine the height of all the non-content elements
                nonContentHeight = this.uiDialog.css({
                                height: "auto",
                                width: options.width
                        })
                        .outerHeight();
                minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
                maxContentHeight = typeof options.maxHeight === "number" ?
                        Math.max( 0, options.maxHeight - nonContentHeight ) :
                        "none";

                if ( options.height === "auto" ) {
                        this.element.css({
                                minHeight: minContentHeight,
                                maxHeight: maxContentHeight,
                                height: "auto"
                        });
                } else {
                        this.element.height( Math.max( 0, options.height - nonContentHeight ) );
                }

                if (this.uiDialog.is(":data(ui-resizable)") ) {
                        this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
                }
        },

        _blockFrames: function() {
                this.iframeBlocks = this.document.find( "iframe" ).map(function() {
                        var iframe = $( this );

                        return $( "<div>" )
                                .css({
                                        position: "absolute",
                                        width: iframe.outerWidth(),
                                        height: iframe.outerHeight()
                                })
                                .appendTo( iframe.parent() )
                                .offset( iframe.offset() )[0];
                });
        },

        _unblockFrames: function() {
                if ( this.iframeBlocks ) {
                        this.iframeBlocks.remove();
                        delete this.iframeBlocks;
                }
        },

        _allowInteraction: function( event ) {
                if ( $( event.target ).closest(".ui-dialog").length ) {
                        return true;
                }

                // TODO: Remove hack when datepicker implements
                // the .ui-front logic (#8989)
                return !!$( event.target ).closest(".ui-datepicker").length;
        },

        _createOverlay: function() {
                if ( !this.options.modal ) {
                        return;
                }

                var that = this,
                        widgetFullName = this.widgetFullName;
                if ( !$.ui.dialog.overlayInstances ) {
                        // Prevent use of anchors and inputs.
                        // We use a delay in case the overlay is created from an
                        // event that we're going to be cancelling. (#2804)
                        this._delay(function() {
                                // Handle .dialog().dialog("close") (#4065)
                                if ( $.ui.dialog.overlayInstances ) {
                                        this.document.bind( "focusin.dialog", function( event ) {
                                                if ( !that._allowInteraction( event ) ) {
                                                        event.preventDefault();
                                                        $(".ui-dialog:visible:last .ui-dialog-content")
                                                                .data( widgetFullName )._focusTabbable();
                                                }
                                        });
                                }
                        });
                }

                this.overlay = $("<div>")
                        .addClass("ui-widget-overlay ui-front")
                        .appendTo( this._appendTo() );
                this._on( this.overlay, {
                        mousedown: "_keepFocus"
                });
                $.ui.dialog.overlayInstances++;
        },

        _destroyOverlay: function() {
                if ( !this.options.modal ) {
                        return;
                }

                if ( this.overlay ) {
                        $.ui.dialog.overlayInstances--;

                        if ( !$.ui.dialog.overlayInstances ) {
                                this.document.unbind( "focusin.dialog" );
                        }
                        this.overlay.remove();
                        this.overlay = null;
                }
        }
});

$.ui.dialog.overlayInstances = 0;

// DEPRECATED
if ( $.uiBackCompat !== false ) {
        // position option with array notation
        // just override with old implementation
        $.widget( "ui.dialog", $.ui.dialog, {
                _position: function() {
                        var position = this.options.position,
                                myAt = [],
                                offset = [ 0, 0 ],
                                isVisible;

                        if ( position ) {
                                if ( typeof position === "string" || (typeof position === "object" && "0" in position ) ) {
                                        myAt = position.split ? position.split(" ") : [ position[0], position[1] ];
                                        if ( myAt.length === 1 ) {
                                                myAt[1] = myAt[0];
                                        }

                                        $.each( [ "left", "top" ], function( i, offsetPosition ) {
                                                if ( +myAt[ i ] === myAt[ i ] ) {
                                                        offset[ i ] = myAt[ i ];
                                                        myAt[ i ] = offsetPosition;
                                                }
                                        });

                                        position = {
                                                my: myAt[0] + (offset[0] < 0 ? offset[0] : "+" + offset[0]) + " " +
                                                        myAt[1] + (offset[1] < 0 ? offset[1] : "+" + offset[1]),
                                                at: myAt.join(" ")
                                        };
                                }

                                position = $.extend( {}, $.ui.dialog.prototype.options.position, position );
                        } else {
                                position = $.ui.dialog.prototype.options.position;
                        }

                        // need to show the dialog to get the actual offset in the position plugin
                        isVisible = this.uiDialog.is(":visible");
                        if ( !isVisible ) {
                                this.uiDialog.show();
                        }
                        this.uiDialog.position( position );
                        if ( !isVisible ) {
                                this.uiDialog.hide();
                        }
                }
        });
}

}( jQuery ) );
1	torben	2125	/*!
2			* jQuery UI Dialog 1.10.3
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.3",
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(" ");
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 ) );