/*
 * SimpleModal 1.2.3 - jQuery Plugin
 * http://www.ericmmartin.com/projects/simplemodal/
 * Copyright (c) 2009 Eric Martin
 * Dual licensed under the MIT and GPL licenses
 * Revision: $Id: jquery.simplemodal.js 185 2009-02-09 21:51:12Z emartin24 $
 */

/**
 * SimpleModal is a lightweight jQuery plugin that provides a simple
 * interface to create a modal dialog.
 *
 * The goal of SimpleModal is to provide developers with a cross-browser 
 * overlay and container that will be populated with data provided to
 * SimpleModal.
 *
 * There are two ways to call SimpleModal:
 * 1) As a chained function on a jQuery object, like $('#myDiv').modal();.
 * This call would place the DOM object, #myDiv, inside a modal dialog.
 * Chaining requires a jQuery object. An optional options object can be
 * passed as a parameter.
 *
 * @example $('<div>my data</div>').modal({options});
 * @example $('#myDiv').modal({options});
 * @example jQueryObject.modal({options});
 *
 * 2) As a stand-alone function, like $.modal(data). The data parameter
 * is required and an optional options object can be passed as a second
 * parameter. This method provides more flexibility in the types of data 
 * that are allowed. The data could be a DOM object, a jQuery object, HTML
 * or a string.
 * 
 * @example $.modal('<div>my data</div>', {options});
 * @example $.modal('my data', {options});
 * @example $.modal($('#myDiv'), {options});
 * @example $.modal(jQueryObject, {options});
 * @example $.modal(document.getElementById('myDiv'), {options}); 
 * 
 * A SimpleModal call can contain multiple elements, but only one modal 
 * dialog can be created at a time. Which means that all of the matched
 * elements will be displayed within the modal container.
 * 
 * SimpleModal internally sets the CSS needed to display the modal dialog
 * properly in all browsers, yet provides the developer with the flexibility
 * to easily control the look and feel. The styling for SimpleModal can be 
 * done through external stylesheets, or through SimpleModal, using the
 * overlayCss and/or containerCss options.
 *
 * SimpleModal has been tested in the following browsers:
 * - IE 6, 7
 * - Firefox 2, 3
 * - Opera 9
 * - Safari 3
 *
 * @name SimpleModal
 * @type jQuery
 * @requires jQuery v1.2.2
 * @cat Plugins/Windows and Overlays
 * @author Eric Martin (http://ericmmartin.com)
 * @version 1.2.3
 */
(function ($) {
	var ie6 = $.browser.msie && parseInt($.browser.version) == 6 && typeof window['XMLHttpRequest'] != "object",
		ieQuirks = null,
		w = [];

	/*
	 * Stand-alone function to create a modal dialog.
	 * 
	 * @param {string, object} data A string, jQuery object or DOM object
	 * @param {object} [options] An optional object containing options overrides
	 */
	$.modal = function (data, options) {
		return $.modal.impl.init(data, options);
	};

	/*
	 * Stand-alone close function to close the modal dialog
	 */
	$.modal.close = function () {
		$.modal.impl.close();
	};

	/*
	 * Chained function to create a modal dialog.
	 * 
	 * @param {object} [options] An optional object containing options overrides
	 */
	$.fn.modal = function (options) {
		return $.modal.impl.init(this, options);
	};

	/*
	 * SimpleModal default options
	 * 
	 * opacity: (Number:50) The opacity value for the overlay div, from 0 - 100
	 * overlayId: (String:'simplemodal-overlay') The DOM element id for the overlay div
	 * overlayCss: (Object:{}) The CSS styling for the overlay div
	 * containerId: (String:'simplemodal-container') The DOM element id for the container div
	 * containerCss: (Object:{}) The CSS styling for the container div
	 * dataCss: (Object:{}) The CSS styling for the data div
	 * zIndex: (Number: 1000) Starting z-index value
	 * close: (Boolean:true) Show closeHTML?
	 * closeHTML: (String:'<a class="modalCloseImg" title="Close"></a>') The HTML for the 
	              default close link. SimpleModal will automatically add the closeClass to this element.
	 * closeClass: (String:'simplemodal-close') The CSS class used to bind to the close event
	 * position: (Array:null) Position of container [top, left]. Can be number of pixels or percentage
	 * persist: (Boolean:false) Persist the data across modal calls? Only used for existing
	            DOM elements. If true, the data will be maintained across modal calls, if false,
				   the data will be reverted to its original state.
	 * onOpen: (Function:null) The callback function used in place of SimpleModal's open
	 * onShow: (Function:null) The callback function used after the modal dialog has opened
	 * onClose: (Function:null) The callback function used in place of SimpleModal's close
	 */
	$.modal.defaults = {
		opacity: 50,
		overlayId: 'simplemodal-overlay',
		overlayCss: {},
		containerId: 'simplemodal-container',
		containerCss: {},
		dataCss: {},
		zIndex: 1000,
		close: true,
		closeHTML: '<a class="modalCloseImg" title="Close"></a>',
		closeClass: 'simplemodal-close',
		position: null,
		persist: false,
		onOpen: null,
		onShow: null,
		onClose: null
	};

	/*
	 * Main modal object
	 */
	$.modal.impl = {
		/*
		 * Modal dialog options
		 */
		opts: null,
		/*
		 * Contains the modal dialog elements and is the object passed 
		 * back to the callback (onOpen, onShow, onClose) functions
		 */
		dialog: {},
		/*
		 * Initialize the modal dialog
		 */
		init: function (data, options) {
			// don't allow multiple calls
			if (this.dialog.data) {
				return false;
			}

			// $.boxModel is undefined if checked earlier
			ieQuirks = $.browser.msie && !$.boxModel;

			// merge defaults and user options
			this.opts = $.extend({}, $.modal.defaults, options);

			// keep track of z-index
			this.zIndex = this.opts.zIndex;

			// set the onClose callback flag
			this.occb = false;

			// determine how to handle the data based on its type
			if (typeof data == 'object') {
				// convert DOM object to a jQuery object
				data = data instanceof jQuery ? data : $(data);

				// if the object came from the DOM, keep track of its parent
				if (data.parent().parent().size() > 0) {
					this.dialog.parentNode = data.parent();

					// persist changes? if not, make a clone of the element
					if (!this.opts.persist) {
						this.dialog.orig = data.clone(true);
					}
				}
			}
			else if (typeof data == 'string' || typeof data == 'number') {
				// just insert the data as innerHTML
				data = $('<div/>').html(data);
			}
			else {
				// unsupported data type!
				alert('SimpleModal Error: Unsupported data type: ' + typeof data);
				return false;
			}
			this.dialog.data = data.addClass('simplemodal-data').css(this.opts.dataCss);
			data = null;

			// create the modal overlay, container and, if necessary, iframe
			this.create();

			// display the modal dialog
			this.open();

			// useful for adding events/manipulating data in the modal dialog
			if ($.isFunction(this.opts.onShow)) {
				this.opts.onShow.apply(this, [this.dialog]);
			}

			// don't break the chain =)
			return this;
		},
		/*
		 * Create and add the modal overlay and container to the page
		 */
		create: function () {
			// get the window properties
			w = this.getDimensions();

			// add an iframe to prevent select options from bleeding through
			if (ie6) {
				this.dialog.iframe = $('<iframe src="javascript:false;"/>')
					.css($.extend(this.opts.iframeCss, {
						display: 'none',
						opacity: 0, 
						position: 'fixed',
						height: w[0],
						width: w[1],
						zIndex: this.opts.zIndex,
						top: 0,
						left: 0
					}))
					.appendTo('body');
			}

			// create the overlay
			this.dialog.overlay = $('<div/>')
				.attr('id', this.opts.overlayId)
				.addClass('simplemodal-overlay')
				.css($.extend(this.opts.overlayCss, {
					display: 'none',
					opacity: this.opts.opacity / 100,
					height: w[0],
					width: w[1],
					position: 'fixed',
					left: 0,
					top: 0,
					zIndex: this.opts.zIndex + 1
				}))
				.appendTo('body');

			// create the container
			this.dialog.container = $('<div/>')
				.attr('id', this.opts.containerId)
				.addClass('simplemodal-container')
				.css($.extend(this.opts.containerCss, {
					display: 'none',
					position: 'fixed', 
					zIndex: this.opts.zIndex + 2
				}))
				.append(this.opts.close 
					? $(this.opts.closeHTML).addClass(this.opts.closeClass)
					: '')
				.appendTo('body');

			this.setPosition();

			// fix issues with IE
			if (ie6 || ieQuirks) {
				this.fixIE();
			}

			// hide the data and add it to the container
			this.dialog.container.append(this.dialog.data.hide());
		},
		/*
		 * Bind events
		 */
		bindEvents: function () {
			var self = this;

			// bind the close event to any element with the closeClass class
			$('.' + this.opts.closeClass).bind('click.simplemodal', function (e) {
				e.preventDefault();
				self.close();
			});

			// update window size
			$(window).bind('resize.simplemodal', function () {
				// redetermine the window width/height
				w = self.getDimensions();

				// reposition the dialog
				self.setPosition();
	
				if (ie6 || ieQuirks) {
					self.fixIE();
				}
				else {
					// update the iframe & overlay
					self.dialog.iframe && self.dialog.iframe.css({height: w[0], width: w[1]});
					self.dialog.overlay.css({height: w[0], width: w[1]});
				}
			});
		},
		/*
		 * Unbind events
		 */
		unbindEvents: function () {
			$('.' + this.opts.closeClass).unbind('click.simplemodal');
			$(window).unbind('resize.simplemodal');
		},
		/*
		 * Fix issues in IE6 and IE7 in quirks mode
		 */
		fixIE: function () {
			var p = this.opts.position;

			// simulate fixed position - adapted from BlockUI
			$.each([this.dialog.iframe || null, this.dialog.overlay, this.dialog.container], function (i, el) {
				if (el) {
					var bch = 'document.body.clientHeight', bcw = 'document.body.clientWidth',
						bsh = 'document.body.scrollHeight', bsl = 'document.body.scrollLeft',
						bst = 'document.body.scrollTop', bsw = 'document.body.scrollWidth',
						ch = 'document.documentElement.clientHeight', cw = 'document.documentElement.clientWidth',
						sl = 'document.documentElement.scrollLeft', st = 'document.documentElement.scrollTop',
						s = el[0].style;

					s.position = 'absolute';
					if (i < 2) {
						s.removeExpression('height');
						s.removeExpression('width');
						s.setExpression('height','' + bsh + ' > ' + bch + ' ? ' + bsh + ' : ' + bch + ' + "px"');
						s.setExpression('width','' + bsw + ' > ' + bcw + ' ? ' + bsw + ' : ' + bcw + ' + "px"');
					}
					else {
						var te, le;
						if (p && p.constructor == Array) {
							var top = p[0] 
								? typeof p[0] == 'number' ? p[0].toString() : p[0].replace(/px/, '')
								: el.css('top').replace(/px/, '');
							te = top.indexOf('%') == -1 
								? top + ' + (t = ' + st + ' ? ' + st + ' : ' + bst + ') + "px"'
								: parseInt(top.replace(/%/, '')) + ' * ((' + ch + ' || ' + bch + ') / 100) + (t = ' + st + ' ? ' + st + ' : ' + bst + ') + "px"';

							if (p[1]) {
								var left = typeof p[1] == 'number' ? p[1].toString() : p[1].replace(/px/, '');
								le = left.indexOf('%') == -1 
									? left + ' + (t = ' + sl + ' ? ' + sl + ' : ' + bsl + ') + "px"'
									: parseInt(left.replace(/%/, '')) + ' * ((' + cw + ' || ' + bcw + ') / 100) + (t = ' + sl + ' ? ' + sl + ' : ' + bsl + ') + "px"';
							}
						}
						else {
							te = '(' + ch + ' || ' + bch + ') / 2 - (this.offsetHeight / 2) + (t = ' + st + ' ? ' + st + ' : ' + bst + ') + "px"';
							le = '(' + cw + ' || ' + bcw + ') / 2 - (this.offsetWidth / 2) + (t = ' + sl + ' ? ' + sl + ' : ' + bsl + ') + "px"';
						}
						s.removeExpression('top');
						s.removeExpression('left');
						s.setExpression('top', te);
						s.setExpression('left', le);
					}
				}
			});
		},
		getDimensions: function () {
			var el = $(window);

			// fix a jQuery/Opera bug with determining the window height
			var h = $.browser.opera && $.browser.version > '9.5' && $.fn.jquery <= '1.2.6' ?
				document.documentElement['clientHeight'] : 
				el.height();

			return [h, el.width()];
		},
		setPosition: function () {
			var top, left,
				hCenter = (w[0]/2) - ((this.dialog.container.height() || this.dialog.data.height())/2),
				vCenter = (w[1]/2) - ((this.dialog.container.width() || this.dialog.data.width())/2);

			if (this.opts.position && this.opts.position.constructor == Array) {
				top = this.opts.position[0] || hCenter;
				left = this.opts.position[1] || vCenter;
			} else {
				top = hCenter;
				left = vCenter;
			}
			this.dialog.container.css({left: left, top: top});
		},
		/*
		 * Open the modal dialog elements
		 * - Note: If you use the onOpen callback, you must "show" the 
		 *	        overlay and container elements manually 
		 *         (the iframe will be handled by SimpleModal)
		 */
		open: function () {
			// display the iframe
			this.dialog.iframe && this.dialog.iframe.show();

			if ($.isFunction(this.opts.onOpen)) {
				// execute the onOpen callback 
				this.opts.onOpen.apply(this, [this.dialog]);
			}
			else {
				// display the remaining elements
				this.dialog.overlay.show();
				this.dialog.container.show();
				this.dialog.data.show();
			}

			// bind default events
			this.bindEvents();
		},
		/*
		 * Close the modal dialog
		 * - Note: If you use an onClose callback, you must remove the 
		 *         overlay, container and iframe elements manually
		 *
		 * @param {boolean} external Indicates whether the call to this
		 *     function was internal or external. If it was external, the
		 *     onClose callback will be ignored
		 */
		close: function () {
			// prevent close when dialog does not exist
			if (!this.dialog.data) {
				return false;
			}

			if ($.isFunction(this.opts.onClose) && !this.occb) {
				// set the onClose callback flag
				this.occb = true;

				// execute the onClose callback
				this.opts.onClose.apply(this, [this.dialog]);
			}
			else {
				// if the data came from the DOM, put it back
				if (this.dialog.parentNode) {
					// save changes to the data?
					if (this.opts.persist) {
						// insert the (possibly) modified data back into the DOM
						this.dialog.data.hide().appendTo(this.dialog.parentNode);
					}
					else {
						// remove the current and insert the original, 
						// unmodified data back into the DOM
						this.dialog.data.remove();
						this.dialog.orig.appendTo(this.dialog.parentNode);
					}
				}
				else {
					// otherwise, remove it
					this.dialog.data.remove();
				}

				// remove the remaining elements
				this.dialog.container.remove();
				this.dialog.overlay.remove();
				this.dialog.iframe && this.dialog.iframe.remove();

				// reset the dialog object
				this.dialog = {};
			}

			// remove the default events
			this.unbindEvents();
		}
	};
})(jQuery);

/*	Enhancing jquery.simplemodal for product defaults and behavior changes.

	Doug Puchalski, Virtual Software Inc.

	* Allow a new dialog to be opened if one is already shown. This will retain the overlay, close the
		old dialog, and re-open the new one.
	* Fade in the overlay and dialog contents

*/

// Create a new open function that allows a new dialog to replace an existing one
// Does not return the dialog, as it may be open asynchronously in a callback
$j.modal.open = function(data, options) {
	// If open is called a second time before the first dialog is opened, the first one will be cancelled
	if ($j.modal.impl.openPending || $j.modal.impl.dialog.data) {
		// Another dialog is currently open. It will be closed, and the overlay will be preserved to prevent flashing
		$j.modal.impl.openPending = true;
		// Keep reference of current overlay. A new one will be created by $j.modal, which we will remove
		//  and replace the reference with this one. Otherwise there would be two overlays on the screen.
		$j.modal.impl.oldOverlay = $j.modal.impl.dialog.overlay;
		// Place a one-time callback which will open the new one once the old one is closed.
		// This is done because there's a fade-out and the old dialog is not closed immediately
		$j.modal.impl.afterClose = function() {
			// Open the new dialog
			$j.modal(data, options);
			$j.modal.impl.openPending = false;
		};
		$j.modal.close({retainOverlay: true});
	} else {
		$j.modal(data, options);
		$j.modal.impl.openPending = false;
	}
};

/*	Override close
	This code copied from jquery.simplemodal-1.2.3.js and modified so we can retain the overlay
*/

$j.modal.close = function(options) {

	var options = $j.extend({}, options);
	var dialog = $j.modal.impl.dialog;
	var savedDialog = $j.modal.impl.dialog;
	var savedOpts = $j.modal.impl.opts;
	
	if (!dialog.container)
		return; // No dialog is currently open

	function doClose() {

		// If the data came from the DOM, put it back
		// We've dereferenced everything from the dialog options since it will have been destroyed by now
		if (savedDialog.parentNode) {
			// save changes to the data?
			if (savedOpts.persist) {
				// insert the (possibly) modified data back into the DOM
				savedDialog.data.hide().appendTo(savedDialog.parentNode);
			}
			else {
				// remove the current and insert the original, 
				// unmodified data back into the DOM
				savedDialog.data.remove();
				savedDialog.orig.appendTo(savedDialog.parentNode);
			}
		}
		else {
			// otherwise, remove it
			savedDialog.data.remove();
		}

		// remove the remaining elements
		savedDialog.container.remove();
		// Check if retaining the overlay for the next dialog
		if (!options.retainOverlay) {
			savedDialog.overlay.remove();
		}
		savedDialog.iframe && savedDialog.iframe.remove();

		// reset the dialog object
		$j.modal.impl.dialog = {};

		// remove the default events
		$j.modal.impl.unbindEvents();
		
		if ($j.isFunction(options.afterClose))
			options.afterClose();
		
		if ($j.isFunction($j.modal.impl.afterClose)) {
			$j.modal.impl.afterClose();
			$j.modal.impl.afterClose = null;
		}
	}

	// Fade out the container and the overlay, and remove them.
	// We've captured the references because they'll be destoyed before the animation completes below

	var container = dialog.container;
	var fadeOptions = { speed: 100, disableFade: false };

	Effects.fadeOut(dialog.container, fadeOptions, function() {
		if (!options.retainOverlay) {
			Effects.fadeOut(dialog.overlay, fadeOptions, function() {
				doClose();
			});
		} else
			doClose();
	});

	// reset the dialog object
	//$j.modal.impl.dialog = {};
	
};

/* Override setPosition to support new options. We also do some resizing. */
$j.modal.impl.setPosition = function() {
	/* Size control
		size: {
			id: id string of element to size
			shrinkToChild: if true, assumes that id contains a child witih class 'contents' that will be checked after sizing. 
				This allows the contents to be rendered using the max size as specified, and then is reduced to fit.
			deprecated--overflow: boolean, passed into css
			fill: boolean, if true, also set height and width
			height/width: multipier, fraction of screen size
		}
	*/
	var dialog = $j.modal.impl.dialog;
	var opts = $j.modal.impl.opts;
	var w = $j.modal.impl.getDimensions();
	var size = opts ? opts.size : null;		// VSI BP check opts
	var contentsElem, contentsHeight, contentsWidth;

	var containerVisibility, containerDisplay;
	if (!dialog.container.is(':visible')) {
		// Show the dialog, but make it visibility: none, so we can properly get the size
		containerVisibility = dialog.container.css('visibility');
		containerDisplay = dialog.container.css('display');
		dialog.data.show();
		dialog.container.css({ visibility: 'hidden', display: ''});
		containerVisiblityChanged = true;
	}

	//if (dialog.container.height() == 0 || dialog.container.width() == 0)
		//return;

	if (size) {
		/* 	It's a bit tricky to get scrolling and the placement of the resizer icon correct.
			div.resizable uses jQUery.ui.resizable() and gets the resizer icon, and receives the first event.
			We install a callback to propagate that same size to resizeReceiver.
			Note that if #popupContent is replaced by ajax, the class must be restored as shown here.

			<div class='dialogPopup dialog draggable'>
				<div class='sizeWrapper resizable'>
					<div id='popupContent' class='contents scrollable resizeReceiver'>
						.... contents goes here ....
					</div>
				/div>
			</div>
		*/
		
		contentsElem = $j('.resizable:first', dialog.container);
		contentsHeight = contentsElem.outerHeight(true);
		contentsWidth = contentsElem.outerWidth(true);

		//console.log("width " + contentsWidth);

		//var style = {};
		var contentsStyle = {};
		if (size.fill) {
			// Set max size by multipling the size.height/width (which s/b fractions) by the window dimensions
			contentsStyle.height = size.height * w[0];
			contentsStyle.width = size.width * w[1];
		}
		
		if (size.shrinkToContents == true) {
			// Sometimes this is called before we have contents
			contentsWidth += size.widthPadding ? opts.size.widthPadding : 0;	// VSI BP use size not opts.size
			contentsStyle.height = Math.min(contentsStyle.height, contentsHeight);
			contentsStyle.width = Math.min(contentsStyle.width, contentsWidth);
		}
		contentsElem.css(contentsStyle);
		
		// Trigger an event if necessary
		var resize = contentsElem.resize();
		if ($j.isFunction(resize))
			resize();
	}

	var top, left,
		hCenter = (w[0]/2) - ((dialog.container.height() || dialog.data.height())/2),
		vCenter = (w[1]/2) - ((dialog.container.width() || dialog.data.width())/2);

	if (opts && opts.position && opts.position.constructor == Array) {	// VSI BP test opts
		top = opts.position[0] || hCenter;
		left = opts.position[1] || vCenter;
	} else {
		top = hCenter;
		left = vCenter;
	}
	dialog.container.css({left: left, top: top});

	if (containerVisiblityChanged) {
		// Restore container visibility
		dialog.container.css({ visibility: containerVisibility, display: containerDisplay});
	}
}

$j.extend($j.modal.defaults, {

	onOpen: function(dialog) {
		var opts = $j.modal.impl.opts;
		
		if ($j.isFunction(opts.beforeOpen))
			opts.beforeOpen(dialog);
	
		if ($j.modal.impl.oldOverlay) {
			// We have an old overlay, retain that one
			dialog.overlay.remove();
			dialog.overlay = $j.modal.impl.oldOverlay;
			$j.modal.impl.oldOverlay = null;
		} else {
			Effects.fadeIn(dialog.overlay);
		}
		
		opts.doShow.apply(this, [dialog]);

		// If there are images, call resize after each one is loaded
		dialog.container.find('img').each(function() {
			opts.doResize.apply(this, [dialog]);
		});
		
		if ($j.isFunction(opts.afterOpen))
			opts.afterOpen(dialog);
	},
	
	doShow: function(dialog) {
		$j.modal.impl.opts.doResize.apply(this, [dialog]);
		// Delay the fadeIn in case images need to load first. Just giving it a small arbitrary amount of time
		// dialog.opts.afterVisible is good for things like setting focus.
		var self = this;

		$j.modal.impl.setPosition();
		
		if (dialog.data.is('.draggable')) {
			dialog.container.draggable({
				handle: '.draggableHandle'
			});
		}
		dialog.data.find('.resizable').resizable({
			handles: 'se'
		});
		
		// This was previously delayed by 100ms. If necessary, add an option to fadeIn
		Effects.fadeIn(dialog.container, null, function() {
			// afterVisible
			// Note: can't reference 'this' as $j.modal here, we have a new 'this', use $j.modal.impl directly
			if ($j.isFunction(window.pngfix))
				pngfix(dialog); // IE6 only - VSI
			if ($j.isFunction(self.opts.afterVisible))
				self.opts.afterVisible(dialog);
		});
	},

	doResize: function(dialog) {
		// Must show data to be reflected in container dimensions
		// TODO: might be able to set visibility to hidden, such that contents takes up space but is not shown
		
		
		dialog.data.show(); 


		// TODO not sure this is needed anymore with thie 1.2.3 version

		/*
		var width = dialog.container.outerWidth();
		if ($j.modal.impl.opts.maxWidth && width > $j.modal.impl.opts.maxWidth) {
			width = $j.modal.impl.opts.maxWidth;
			dialog.container.width(width);
		}

		// Make sure it's visible within the window
		// TODO: test on resize of window, doResize s/b called again
		var padding = 10;
		var offset = dialog.container.offset();
		if (offset.top < 0) {
			var top = parseInt(dialog.container.css('marginTop'));
			dialog.container.css('marginTop', top - offset.top + padding);
		}
		var containerHeight = dialog.container.height();
		var containerWidth = dialog.container.width();
		var parentHeight = $j(dialog.container.parentNode).height();
		var parentWidth = $j(dialog.container.parentNode).width();
		if (containerHeight + 2 * padding > parentHeight) {
			var containerHeightNew = parentHeight - 2 * padding;
			dialog.container.height(containerHeightNew);
			dialog.data.height(dialog.data.height() + containerHeightNew - containerHeight);
		}
		if (containerWidth + 2 * padding > parentWidth) {
			var containerWidthNew = parentWidth - 2 * padding;
			dialog.container.width(containerWidthNew);
			dialog.data.width(dialog.data.width() + containerWidthNew - containerHeight);
		}

		// Center
		dialog.container.css('marginLeft', -width / 2);
		dialog.container.css('marginTop', -dialog.container.outerHeight() / 2);
		*/
	}

	
});