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	/*!
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 ) );