/*
 * Definicion de un panel basico utilizado por galileo, este panel sirve
 * tanto en el caso de pop-up como de panel normal
 * @param container Id o contenedor que poseera el panel
 * @param userConfig Particularizacion a agregar a la configuracion por defecto
 */
GALILEO.widget.GBasicPanel = function(container, userConfig) {
	if (container && userConfig && userConfig.width) {
		// Construimos el panel
		var isModal = (userConfig.modal) ? userConfig.modal : false;
		var defaultConf = {width:userConfig.width, iframe:true, fixedcenter: false, constraintoviewport: true, underlay:"shadow", close:true, visible:false, draggable:true, modal:isModal};
		GALILEO.widget.GBasicPanel.superclass.constructor.call(this, container, defaultConf);
		// Comprobamos si existe una imagen definida como icono de ventana
		if (GALILEO.widget.config.pathWinIcon) {
			var img = GALILEO.util.Dom.createElement('img', [{name: 'src', value: GALILEO.widget.config.pathWinIcon},
			                                                 {name: 'className', value: 'icono'}]);
			this.header.insertBefore(img, this.header.firstChild);
		}
		this.render();
	}
};
/*
 * Definicion de los elementos de herencia
 */
YAHOO.extend(GALILEO.widget.GBasicPanel, YAHOO.widget.Panel);

/*
 * Redefinicion del metodo show
 */
GALILEO.widget.GBasicPanel.prototype.show = function() {
	this.center();
	GALILEO.util.Event.modifyDOM.subscribe(this.onChangeDom, this);	
	GALILEO.widget.GBasicPanel.superclass.show.call(this);
};

GALILEO.widget.GBasicPanel.prototype.hide = function() {
	GALILEO.util.Event.modifyDOM.unsubscribe(this.onChangeDom, this);
	GALILEO.widget.GBasicPanel.superclass.hide.call(this);
};

GALILEO.widget.GBasicPanel.prototype.onChangeDom = function(type, args, obj) {
	// Comprobamos el tamano con el fin de eliminar las propiedades inecesarias
	var valor = true;
	if ((YAHOO.util.Dom.get(obj.id).clientHeight - 10) >= YAHOO.util.Dom.getClientHeight()) {
		valor = false;
	}
	obj.cfg.setProperty('constraintoviewport', valor);
	obj.cfg.refireEvent("underlay");
	obj.cfg.refireEvent("iframe");
};
/*
 * Almacena la configuracion base que poseera el dialogo
 */
GALILEO.widget.GBasicPanel._userConfig = null;


/*
 * Definicion de un panel basico utilizado por galileo, este panel sirve
 * tanto en el caso de pop-up como de panel normal
 * @param url Url sobre la cual realizar la peticion
 * @param containerId Id del contenedor que poseera el panel
 * @param userConfig Particularizacion a agregar a la configuracion por defecto
 * @param title Titulo que puede poseer el panel
 * @param calls Llamadas a realizar:
 *    - preShow: Funcion a ejecutar antes de mostrar el panel
 *    - initActions: Acciones a realizar antes de la creacion misma del panel
 * @param parentEl Elemento padre para el panel
 */
GALILEO.widget.GBasicAsyncPanel = function(url, containerId, userConfig, title, calls, parentEl) {
	if (url && userConfig && containerId && userConfig.width) {
		var container = null;
		container = document.createElement('div');
		container.id = (containerId + "_" + YAHOO.util.Dom.generateId() + "_async_panel");
		if (parentEl) {
			if (typeof parentEl == "string") {
				parentEl = YAHOO.util.Dom.get(parentEl);
			}
			parentEl.appendChild(container);
		} else {
			document.body.appendChild(container);
		}
		
		var callback = {
			success: function(o) {
				var hd = null;
				var bd = null;
		
				if (title) {
					hd = document.createElement('div');
					container.appendChild(hd);
					hd.className = 'hd';
					hd.innerHTML = title;
				}
				bd = document.createElement('div');
				container.appendChild(bd);
				bd.className = 'bd';
				bd.innerHTML = o.responseText;

				if (calls.initActions) {
					calls.initActions();
				}
				GALILEO.widget.GBasicAsyncPanel.superclass.constructor.call(this, container, userConfig);

				if (calls.preShow) {
					calls.preShow();
				}
				GALILEO.widget.GBasicAsyncPanel.superclass.show.call(this);
			},
			failure: function(o) {
				if (parentEl) {
					parentEl.removeChild(container);
				} else {
		  	  	  document.body.removeChild(container);
	  	  	  	} 
	  	  	  GALILEO.util.Connect.handlerFailure(o);
			},
			scope: this
		};
	
		GALILEO.util.Connect.asyncRequest(url, callback);
	}
};
/*
 * Definicion de la herencia sobre el panel basico definico
 */
YAHOO.extend(GALILEO.widget.GBasicAsyncPanel, GALILEO.widget.GBasicPanel);

/*
 * Redefinicion del metodo de ocultado para un panel de tipo asincrono
 */
GALILEO.widget.GBasicAsyncPanel.prototype.hide = function() {
	GALILEO.widget.GBasicAsyncPanel.superclass.hide.call(this);
	this.destroy();
};


/*
 * Definicion personalizada para la creacion de un panel
 * @param containerId Id asociado a la capa que contendra el panel
 * @param width Tamano que poseera el panel
 */
GALILEO.widget.GPanel = function(containerId, width, modal) {
	if (containerId && width) {
		var userConfig = {width: width, modal: modal};
		GALILEO.widget.GPanel.superclass.constructor.call(this, containerId, userConfig);
	}
};
/*
 * Definicion de la herencia sobre panel en yahoo
 */
YAHOO.extend(GALILEO.widget.GPanel, GALILEO.widget.GBasicPanel);

/*
 * Definicion del constructor de panel redimensionable
 * @param containerId Id del contenedor
 * @param width Tamano que establecemos al panel
 * @param height Altura del panel
 */
GALILEO.widget.GResizablePanel = function(containerId, width, height) {
	var defaultConfig = {width:width, fixedcenter: true, constraintoviewport: true, underlay:"shadow", close:true, visible:false, draggable:true, modal:false};
	GALILEO.widget.GResizablePanel.superclass.constructor.call(this, containerId, defaultConfig);
	this.render();
	YAHOO.util.Dom.setStyle(this.body.parentNode, "overflow", "visible");
	YAHOO.util.Dom.setStyle(this.body.parentNode, "border-width", "1px");
	YAHOO.util.Dom.setStyle(this.body, "overflow", "auto");
	if (height) {
		YAHOO.util.Dom.setStyle(this.body, "height", height);
	}
	YAHOO.util.Dom.setStyle(this.footer, "padding", "0px");
	YAHOO.util.Dom.setStyle(this.footer, "height", "4px");
	YAHOO.util.Dom.setStyle(this.footer, "font-size", "4px");
};

/*
 * Definicion de la herencia
 */
YAHOO.extend(GALILEO.widget.GResizablePanel, YAHOO.widget.ResizePanel);

/*
 * Definicion de un dialogo de espera
 * @param containerId Id del contenedor que poseera el panel, si no existe se crea un contenedor con ese id, si no
 *        se expecifica se crea un contenedor denominado wait
 * @param modal Especifica si el panel de espera es o no modal, si no se especifica nada, se establece no modal
 * @param width Tamano que asociaremos al panel de espera
 * @param titulo Titulo asociado al panel de espera
 */
GALILEO.widget.GWaitPanel = function(containerId, modal, width, titulo) {
	if (!containerId) {
		containerId = 'wait';
	}
	if (!width) {
		width = GALILEO.widget.WaitPanel.config.width;
	}
	if (!titulo) {
		titulo = GALILEO.widget.WaitPanel.config.title;
	}
	var panelModal = false;
	if (modal) {
		panelModal = true;
	}
	
	if (typeof containerId == "string") {
		if (!YAHOO.util.Dom.get(containerId)) {
			// Creamos el elemento en el DOM
			containerId = GALILEO.util.Dom.createElement('div', [{name: 'id', value: containerId}]);
			if (containerId) {
				document.body.appendChild(containerId);
				GALILEO.util.Event.modifyDOM.fire();
			}
		}
	}
	
	var defaultConf = {width:width, iframe:true, fixedcenter: true, constraintoviewport: true, underlay:"shadow", close:false, visible:false, draggable:true, modal:panelModal};
	GALILEO.widget.GWaitPanel.superclass.constructor.call(this, containerId, defaultConf);

	// Comprobamos si existe una imagen definida como icono de ventana
	var header = "";
	if (GALILEO.widget.config.pathWinIcon) {
		header += "<img src=\"" + GALILEO.widget.config.pathWinIcon + "\" class='icono' />";
	}
	header += titulo;
	
	this.setHeader(header);
	
	this.setBody(GALILEO.widget.WaitPanel.config.waitImg);
	
	this.render();
};

/*
 * Definicion de la herencia sobre el panel propio de yahoo
 */
YAHOO.extend(GALILEO.widget.GWaitPanel, YAHOO.widget.Panel);

/*
 * Definicion del metodo de cierre
 */
GALILEO.widget.GWaitPanel.prototype.hide = function() {
	GALILEO.widget.GWaitPanel.superclass.hide.call(this);
	this.destroy();
};

/*
 * Definicion personalizada para la creacion de un panel que se carga con
 * datos de manera asincrona
 * @param url Url a la cual se realizara la peticion de datos 
 * @param containerId Id asociado al contenedor que poseera el dialogo
 * @param width Tamano que poseera el panel
 * @param title Titulo que puede poseer el panel
 * @param calls Llamadas a realizar:
 *    - preShow: Funcion a ejecutar antes de mostrar el panel
 *    - initActions: Acciones a realizar antes de la creacion misma del panel
 */
GALILEO.widget.GAsyncPanel = function(url, containerId, width, title, calls, parentEl, modal) {
	if (url && width && containerId) {
		var userConfig = {width: width, modal: modal};
		GALILEO.widget.GAsyncPanel.superclass.constructor.call(this, url, containerId, userConfig, title, calls, parentEl); 		
	}
};

/*
 * Definicion de la herencia sobre el GPanel
 */
YAHOO.extend(GALILEO.widget.GAsyncPanel, GALILEO.widget.GBasicAsyncPanel);

/*
 * Definicion personalizada para la creacion de un panel que se carga con
 * datos de manera asincrona y es redimensionable
 * @param url Url a la cual se realizara la peticion de datos 
 * @param containerId Id asociado al contenedor que poseera el dialogo
 * @param width Tamano que poseera el panel
 * @param title Titulo que puede poseer el panel
 */
GALILEO.widget.GResizableAsyncPanel = function(url, containerId, width, height, title, preShow) {
	if (url && width && containerId) {		

		var container = document.createElement('div');
		container.id = (containerId + "_" + YAHOO.util.Dom.generateId() + "_async_panel");
		document.body.appendChild(container);

		// Realizamos la peticion asincrona de datos
		var callback = {
			success: function(o) {
				var defaultConfig = {width:width, fixedcenter: true, constraintoviewport: true, underlay:"shadow", close:true, visible:false, draggable:true, modal:false};
		
				var header = "";
				if (GALILEO.widget.config.pathWinIcon) {
					header += "<img src=\"" + GALILEO.widget.config.pathWinIcon + "\" class='icono' />";
				}
	
				if (title) {
					header += title;
					var hd = document.createElement('div');
					container.appendChild(hd);
					hd.className = 'hd';
				}
				var bd = document.createElement('div');
				container.appendChild(bd);
				bd.className = 'bd';			
				
				hd.innerHTML = header;
				bd.innerHTML = o.responseText;
				if (preShow)
					preShow();
				
				GALILEO.widget.GResizableAsyncPanel.superclass.constructor.call(this, container.id, defaultConfig);
				this.render();				
						
				YAHOO.util.Dom.setStyle(this.body.parentNode, "border-width", "1px");
				YAHOO.util.Dom.setStyle(this.body.parentNode, "overflow", "visible");
				YAHOO.util.Dom.setStyle(this.body, "overflow", "auto");
				if (height) {
					YAHOO.util.Dom.setStyle(this.body, "height", height);
				}
				YAHOO.util.Dom.setStyle(this.footer, "padding", "0px");
				YAHOO.util.Dom.setStyle(this.footer, "height", "4px");
				YAHOO.util.Dom.setStyle(this.footer, "font-size", "4px");

				GALILEO.widget.GResizableAsyncPanel.superclass.show.call(this);				
			},
			failure: function(o) {
				document.body.removeChild(container);
	  		  	GALILEO.util.Connect.handlerFailure(o);
			},
			scope: this
		};
	
		GALILEO.util.Connect.asyncRequest(url, callback);		
	}
};

/*
 * Definicion de la herencia
 */
YAHOO.extend(GALILEO.widget.GResizableAsyncPanel, YAHOO.widget.ResizePanel);

/*
 * Redefinicion del metodo de ocultado para un panel de tipo asincrono
 */
GALILEO.widget.GResizableAsyncPanel.prototype.hide = function() {
	GALILEO.widget.GResizableAsyncPanel.superclass.hide.call(this);
	this.destroy();
};

/*
 * Constructor utilizado para la construccion de un nuevo dialogo de informacion
 * @param contaninerId Contenedor a traves del cual se genera el dialogo simple
 * @param width Tamano que desamos que posea el dialogo
 * @param modal Definicion de un dialogo modal o no (Booleano)
 * @param draggable Definicion de un dialogo draggable o no (Booleano)
 * @param hSuccess Metodo a ejecutar cuando se pulsa el boton aceptar
 * @param hCancel Metodo a ejecutar cuando se pulsa el boton cancelar
 */
GALILEO.widget.GSimpleDialog = function(containerId, width, modal, draggable, hSuccess, hCancel) {
	if (containerId && width) {
		
		if (!YAHOO.util.Dom.get(containerId)) {
			var elemento = GALILEO.util.Dom.createElement('div', {name: 'id', value: containerId});
			document.body.appendChild(elemento);
			GALILEO.util.Event.modifyDOM.fire();
		}
		
		GALILEO.widget.GSimpleDialog.handleSuccess = function() {
			if (hSuccess) {
				hSuccess();
			}
			this.hide();
		}
		
		GALILEO.widget.GSimpleDialog.handleCancel = function() {
			if (hCancel) {
				hCancel();
			}
			this.hide();
		}
		
		var isModal = false;
		var isDraggable = false;
		if (modal) {
			isModal = modal;
			isDraggable = false;
		}
		else {
			isDraggable = draggable;
		}
		
		var defaultConf = {width:width, iframe:true, fixedcenter: true, constraintoviewport: true, close:false, visible:false, draggable:isDraggable, modal:isModal};
		
		GALILEO.widget.GSimpleDialog.superclass.constructor.call(this, containerId, defaultConf);
		
		this.cfg.queueProperty("buttons", [{text:"Aceptar", handler:GALILEO.widget.GSimpleDialog.handleSuccess, isDefault:true},
										   {text:"Cancelar", handler:GALILEO.widget.GSimpleDialog.handleCancel}]);

		var listeners = new YAHOO.util.KeyListener(document, {keys : 27}, {fn:GALILEO.widget.GSimpleDialog.handleCancel ,scope:this, correctScope:true} );
		this.cfg.queueProperty("keylisteners", listeners);
		this.imageRoot = "";										   
	}
};

YAHOO.extend(GALILEO.widget.GSimpleDialog, YAHOO.widget.SimpleDialog);

/* Definicion de los manejadores */
GALILEO.widget.GSimpleDialog.handleSuccess = null;
GALILEO.widget.GSimpleDialog.handleFailure = null;

/*
 * Metodo encargado de permitir el cambio de nombre de los botones para un dialogo
 * @param success Nombre para el boton de aceptar
 * @param cancel Nombre para el boton de cancelar
 * @param hSuccess Metodo a ejecutar cuando se pulsa el boton aceptar
 * @param hCancel Metodo a ejecutar cuando se pulsa el boton cancelar
 * NOTA Si estos manejadores no son asignados, unicamente se ocultara el dialogo
 */
GALILEO.widget.GSimpleDialog.prototype.setButtons = function(success, cancel, hSuccess, hCancel) {
	if (success && cancel) {
		GALILEO.widget.GSimpleDialog.handleSuccess = function(e, obj) {
			if (hSuccess) {
				hSuccess(e, obj);
			}
			this.hide();
		}
		
		GALILEO.widget.GSimpleDialog.handleCancel = function(e, obj) {
			if (hCancel) {
				hCancel(e, obj);
			}
			this.hide();
		}
		
		this.cfg.queueProperty("buttons", [{text:success, handler:GALILEO.widget.GSimpleDialog.handleSuccess, isDefault:true},
										   {text:cancel, handler:GALILEO.widget.GSimpleDialog.handleCancel}]);	}
};

/*
 * Metodo encargado de la reescritura del metodo show
 */
GALILEO.widget.GSimpleDialog.prototype.show = function() {
	this.render(document.body);
	GALILEO.widget.GSimpleDialog.superclass.show.call(this);
};

/*
 * Metodo encargado de cambiar la cabecera del dialogo
 * @param titulo Titulo a utilizar en la cabecera
 */
GALILEO.widget.GSimpleDialog.prototype.setHeader = function(titulo) {
	var header = "";
	if (GALILEO.widget.config.pathWinIcon) {
		header += "<img src=\"" + GALILEO.widget.config.pathWinIcon + "\" class='icono' />";
	}
	
	header += titulo;
	
	GALILEO.widget.GSimpleDialog.superclass.setHeader.call(this, header);
};

/*
 * Metodo encargado de cambiar el icono al dialogo
 * @param icon Constante que identifica al icono
 */
GALILEO.widget.GSimpleDialog.prototype.setIcon = function(icon) {
	this.cfg.queueProperty("icon", icon);
};

/*
 * Constructor de la nueva clase de dialogo personalizada
 * @param container Id o contenedor de la capa que va a contener el dialogo
 * @param userConfig Definicion del tamano del dialogo, especificado por el usuario
 * @param callback Callback que se debe ejecutar en el dialogo
 * @param buttonsName Nombres que asociaremos a los botones del formulario
 * @param handlers Manejadores que asociaremos al dialogo
 * @param preShow Metodo a ejecutar justo antes de mostrar el dialogo
 * @param validate Metodo encargado de validar el formulario
 */
GALILEO.widget.GBasicDialog = function(container, userConfig, callback, buttonsName, handlers, preShow, validate) {
	if (container && callback && userConfig && buttonsName && buttonsName.submit && buttonsName.cancel && handlers && handlers.handlerSubmit && handlers.handlerCancel) {
		var seleccionModal = (userConfig.modal) ? userConfig.modal : false;
		var defaultConf = {modal:seleccionModal, close:false, visible:false, width:userConfig.width, fixedcenter:true, constraintoviewport:true, draggable:true};
		
		// Construimos el dialogo
		GALILEO.widget.GBasicDialog.superclass.constructor.call(this, container, defaultConf);
		
		var buttons = [{text: buttonsName.submit, handler: handlers.handlerSubmit, isDefault: true}, {text: buttonsName.cancel, handler: handlers.handlerCancel}];
		var listeners = new YAHOO.util.KeyListener(document, {keys: 27}, {fn:handlers.handlerCancel, scope:this, correctScope:true});
		this.cfg.queueProperty("keylisteners", listeners);
		this.cfg.queueProperty("buttons", buttons);
		this.callback = callback;
		
		if (handlers.handlerManual) {
			this.manualSubmitEvent.subscribe(handlers.handlerManual, this, true);
			// Suponemos que se desea cambiar el modo de envio a forma manual y lo cambiamos
			this.cfg.setProperty('postmethod', 'none');
		}
		
		if (preShow) {
			this._preShow = preShow;
		}
		if (validate) {
			this._validate = validate;
		}
		
		// Comprobamos si existe una imagen definida como icono de ventana
		if (GALILEO.widget.config.pathWinIcon) {
			var img = GALILEO.util.Dom.createElement('img', [{name: 'src', value: GALILEO.widget.config.pathWinIcon},
															 {name: 'className', value: 'icono'}]);
			this.header.insertBefore(img, this.header.firstChild);
		}
		
		this.render();
	}
};

/* 
 * Realizamos la extension 
 */
YAHOO.extend(GALILEO.widget.GBasicDialog, YAHOO.widget.Dialog);

/*
 * Metodo a invocar una vez que hemos mostrado el dialogo
 */
GALILEO.widget.GBasicDialog._preShow = null;
/*
 * Metodo de validacion del formulario interno del dialogo
 */
GALILEO.widget.GBasicDialog._validate = null;

GALILEO.widget.GBasicDialog.prototype.validate = function() {
	if (this._validate) {
		return this._validate();
	}
	return true;
};

/*
 * Metodo encargado de permitir el cambio de nombre de los botones para un dialogo
 * @param success Nombre para el boton de aceptar
 * @param cancel Nombre para el boton de cancelar
 * @param hSuccess Metodo a ejecutar cuando se pulsa el boton aceptar
 * @param hCancel Metodo a ejecutar cuando se pulsa el boton cancelar
 * NOTA Si estos manejadores no son asignados, unicamente se establece el estandar enviar y ocultara el dialogo
 */
GALILEO.widget.GBasicDialog.prototype.setButtons = function(success, cancel, hSuccess, hCancel) {
	if (success && cancel) {
		var handleSuccess = function(e, obj) {
			if (hSuccess) {
				hSuccess(e, obj);
			}
			else {
				if (this.submit()) {
					this.hide();
				}
			}
		}
		
		var handleCancel = function(e, obj) {
			if (hCancel) {
				hCancel(e, obj);
			}
			this.hide();
		}
		
		var buttons = new Array();
		buttons[0] = [{text:success, handler:handleSuccess, isDefault:true},{text:cancel, handler:handleCancel}];
		this.configButtons("botones", buttons);
	}
};

/*
 * Metodo encargado de gestionar los cambios en el DOM que se realizar en un dialogo
 * @see YAHOO.util.Event.CustomEvent
 */
GALILEO.widget.GBasicDialog.prototype.onChangeDom = function(type, args, obj) {
	// Comprobamos el tamano con el fin de eliminar las propiedades inecesarias
	var valor = true;
	if ((YAHOO.util.Dom.get(obj.id).clientHeight - 10) >= YAHOO.util.Dom.getClientHeight()) {
		valor = false;
	}
	obj.cfg.setProperty('fixedcenter', valor);
	obj.cfg.setProperty('constraintoviewport', valor);
	obj.cfg.refireEvent("underlay");
	obj.cfg.refireEvent("iframe");
};

/*
 * Redefinicion del metodo de mostrado
 */
GALILEO.widget.GBasicDialog.prototype.show = function() {
	GALILEO.util.Event.modifyDOM.subscribe(this.onChangeDom, this);	
	if (this._preShow) {
		this._preShow();
	}
	
	// Cambiamos a .dox la extension del action del formulario
	var action = this.form.action;
	var expresion = /(.*)\.do.?/;
	if (expresion.test(action)) {
		this.form.action = action.replace(expresion, "$1" + ".dox");
	}
	
	GALILEO.widget.GBasicDialog.superclass.show.call(this);
};

/*
 * Reescritura del metodo encargado de ocultar un dialogo
 */
GALILEO.widget.GBasicDialog.prototype.hide = function() {
	GALILEO.util.Event.modifyDOM.unsubscribe(this.onChangeDom, this);
	GALILEO.widget.GBasicDialog.superclass.hide.call(this);
};

/*
 * Definicion del elemento padre para todos los dialogos simples (no con carga asincrona del
 * formulario incluido en el)
 * @param containerId Id del contenedor que forma el dialogo
 * @param width Tamano asociado al dialogo
 * @param callback Metodo a ejecutar una vez que el formulario del dialogo ha sido enviado
 * @param buttonsName Nombres que les asociaremos a los botones de envio y cancelacion
 * @param preShow Metodo a ejecutar justo antes de mostrar el dialogo
 * @param validate Metodo encargado de validar el formulario
 * @param handlerManual Metodo a ejecutar cuando el envio del formulario es manual
 * @param showWaitPanel Indica si se debe o no mostrar un dialogo de espera al enviar el formulario
 */
GALILEO.widget.GSyncDialog = function(containerId, width, callback, buttonsName, preShow, validate, handlerManual, showWaitPanel, modal) {
	if (containerId && width && callback) {
		this._showWaitPanel = showWaitPanel;
		var handlerSubmit = function(e, obj) {
			if (this._panelWait) {
				this._panelWait.show();
			}
			this.submit();
		};
		var handlerCancel = function(e, obj) {
			this.hide();
		};
		var handlers = {
			handlerSubmit: handlerSubmit,
			handlerCancel: handlerCancel,
			handlerManual: handlerManual
		};
		
		var syncDialogCallback = {
			success: function(o) {
				if (o.argument[0]._panelWait) {
					o.argument[0]._panelWait.hide();
				}
				o.argument[1].success(o);
			},
			failure: function(o) {
				if (o.argument[0]._panelWait) {
					o.argument[0]._panelWait.hide();
				}
				o.argument[1].failure(o);
			},
			argument: [this, callback],
			scope: callback.scope
		}
		var userConfig = {width: width, modal: modal};
		
		GALILEO.widget.GSyncDialog.superclass.constructor.call(this, containerId, userConfig, syncDialogCallback, buttonsName, handlers, preShow, validate);
	}
};

/*
 * Definicion de la herencia
 */
YAHOO.extend(GALILEO.widget.GSyncDialog, GALILEO.widget.GBasicDialog);

/**
 * Defincion de variables internas encargadas de almacenar el panel de espera y
 * de si se debe mostrar
 **/
GALILEO.widget.GSyncDialog.prototype._panelWait = null;
GALILEO.widget.GSyncDialog.prototype._showWaitPanel = false;

GALILEO.widget.GSyncDialog.prototype.show = function() {
	if (this._showWaitPanel){
		this._panelWait = new GALILEO.widget.GWaitPanel(false, true, false, 'Por favor, espere...');
	}
	GALILEO.widget.GSyncDialog.superclass.show.call(this);
};

/**
 * Definicion de un dialogo que se genera sobre un formulario ya definido en el documento
 * Este dialogo envia una peticion asincrona escribiendo el resultado en una capa
 * @param containerId Id de la capa que contiene el formulario
 * @param width Tamano que asociaremos al dialogo con el formulario
 * @param containerSuccessId Id de la capa donde escribir el resultado en caso de que todo
 * sea correcto
 * @param containerFailureId Id de la capa donde escribir el resultado en el caso de un fallo
 * @param buttonsName Nombres que les asociaremos a los botones de envio y cancelacion
 * Estos nombres se encontraran almacenados en un objeto que poseera los siguientes atributos:
 *    - submit: Nombre asociado al boton enviar del formulario 
 *    - cancel: Nombre asociado al boton cancelar del formulario
 * @param calls Posibles llamadas que haya que realizar despues de alguna accion
 * Las posibles llamadas a realizar son la siguientes:
 *    - preShow: Metodo a invocar justo antes de realizar el mostrado del dialogo
 *    - validate: Metodo encargado de validar el formulario
 *    - handlerManual: Metodo a invocar si decidimos que el envio del formulario se va a realizar
 *                     de forma manual
 *    - callback: Se define de la siguiente manera
 *         - success: Metodo a invocar si el envio del formulario ha sido correcto
 *         - failure: Metodo a invocar si el envio del formulario es erroneo
 * @param showWaitPanel Indica si se debe o no mostrar un dialogo de espera al enviar el formulario 
 */
GALILEO.widget.GDialog = function(containerId, width, containerSuccessId, containerFailureId, buttonsName, calls, showWaitPanel) {
	if (containerSuccessId) {
		var success = function(o) {
			var element = YAHOO.util.Dom.get(containerSuccessId);
			element.innerHTML = o.responseText;
			if (calls && calls.callback && calls.callback.success) {
				calls.callback.success();
			}
		};
		var failure = function(o) {
			if (o.status != GALILEO.util.Connect.config.server.response.COD_SECURITY_EXCEPTION) {
				if (calls && calls.callback && calls.callback.failure) {
					calls.callback.failure();
				}
				if (containerFailureId) {
					var element = YAHOO.util.Dom.get(containerFailureId);
					element.innerHTML = o.statusText;
				}	
			}
			else {
				GALILEO.util.Connect.handlerFailure(o);
			}
		};
		var callback = {
			success: success,
			failure: failure,
			scope: this
		};
		
		var preShow = null;
		if (calls && calls.preShow) {
			preShow = calls.preShow;
		}
		var validate = null;
		if (calls && calls.validate) {
			validate = calls.validate;
		}
		
		var handlerManual = null;
		if (calls && calls.handlerManual) {
			handlerManual = calls.handlerManual;
		}
		
		GALILEO.widget.GDialog.superclass.constructor.call(this, containerId, width, callback, buttonsName, preShow, validate, handlerManual, showWaitPanel);
	}
};

/*
 * Definicion de la herencia
 */
YAHOO.extend(GALILEO.widget.GDialog, GALILEO.widget.GSyncDialog);


/**
 * Definicion de un dialogo que se genera sobre un formulario ya definido en el documento
 * Este dialogo envia una peticion asincrona escribiendo el resultado en una capa
 * @param containerId Id de la capa que contiene el formulario
 * @param width Tamano que asociaremos al dialogo con el formulario
 * @param buttonsName Nombres que les asociaremos a los botones de envio y cancelacion
 * Estos nombres se encontraran almacenados en un objeto que poseera los siguientes atributos:
 *    - submit: Nombre asociado al boton enviar del formulario 
 *    - cancel: Nombre asociado al boton cancelar del formulario
 * @param calls Posibles llamadas que haya que realizar despues de alguna accion
 * Las posibles llamadas a realizar son la siguientes:
 *    - preShow: Metodo a invocar justo antes de realizar el mostrado del dialogo
 *    - validate: Metodo encargado de validar el formulario
 *    - handlerManual: Metodo a invocar si decidimos que el envio del formulario se va a realizar
 *                     de forma manual
 *    - callback: Se define de la siguiente manera
 *         - success: Metodo a invocar si el envio del formulario ha sido correcto
 *         - failure: Metodo a invocar si el envio del formulario es erroneo
 *		   - scope: Ambito
 * @param showWaitPanel Indica si se debe o no mostrar un dialogo de espera al enviar el formulario
 */
GALILEO.widget.GCDialog = function(containerId, width, buttonsName, calls, showWaitPanel, modal) {
	if (calls && calls.callback) {
		var preShow = null;
		if (calls && calls.preShow) {
			preShow = calls.preShow;
		}
		var validate = null;
		if (calls && calls.validate) {
			validate = calls.validate;
		}
		
		var handlerManual = null;
		if (calls && calls.handlerManual) {
			handlerManual = calls.handlerManual;
		}
		
		GALILEO.widget.GCDialog.superclass.constructor.call(this, containerId, width, calls.callback, buttonsName, preShow, validate, handlerManual, showWaitPanel, modal);
	}
};

YAHOO.extend(GALILEO.widget.GCDialog, GALILEO.widget.GSyncDialog);


/*
 * Definicion del elemento padre para todos los dialogos con carga asincrona del
 * formulario incluido en el
 * @param containerId Id del contenedor que forma el dialogo
 * @param width Tamano asociado al dialogo
 * @param callback Metodo a ejecutar una vez que el formulario del dialogo ha sido enviado
 * @param buttonsName Nombres que les asociaremos a los botones de envio y cancelacion
 * @param preShow Metodo a ejecutar justo antes de mostrar el dialogo
 * @param validate Metodo encargado de validar el formulario
 * @param handlerManual Metodo a ejecutar cuando se selecciona envio manual del formulario
 * @param showWaitPanel Flag que indica si se debe o no mostrar el panel de espera
 */
GALILEO.widget.GBasicAsyncDialog = function(url, containerId, width, callback, buttonsName, preShow, validate, handlerManual, showWaitPanel) {
	if (url && width) {
		var handlerSubmit = function(e, obj) {
			if (this.submit()) {
				this.destroy();
			}
		};
		var handlerCancel = function(e, obj) {
			this.hide();
		};
		var handlers = {
			handlerSubmit: handlerSubmit,
			handlerCancel: handlerCancel,
			handlerManual: handlerManual
		};
		
		userConfig = {width: width};
		
		var container = null;

		container = document.createElement('div');		
		container.id = containerId + "_" + YAHOO.util.Dom.generateId() + '_async_form';
		document.body.appendChild(container);
		
		var panelWait = null;
		if (showWaitPanel != false) {
			panelWait = new GALILEO.widget.GWaitPanel();
		}
		
		var success = function (o) {
			if (panelWait) {
				panelWait.hide();
			}
			container.innerHTML = o.responseText;
			GALILEO.widget.GBasicAsyncDialog.superclass.constructor.call(this, container, userConfig, callback, buttonsName, handlers, preShow, validate);
			
			if ((YAHOO.util.Dom.get(this.id).clientHeight - 10) >= YAHOO.util.Dom.getClientHeight()) {
				this.cfg.setProperty('fixedcenter', false);
				this.cfg.setProperty('constraintoviewport', false);
			}
			
			this.show();
		};
		var failure = function (o) {
			if (panelWait) {
				panelWait.hide();			
			}
			document.body.removeChild(container);
	  	    GALILEO.util.Connect.handlerFailure(o);
		};
		var callbackForm = {
			success: success,
			failure: failure,
			scope: this
		};
		
		if (panelWait) {
			panelWait.show();
		}
		GALILEO.util.Connect.asyncRequest(url, callbackForm);
	}
};

/*
 * Definicion de la herencia
 */
YAHOO.extend(GALILEO.widget.GBasicAsyncDialog, GALILEO.widget.GBasicDialog);

/*
 * Redefinicion del metodo ocultar
 */
GALILEO.widget.GBasicAsyncDialog.prototype.hide = function() {
	GALILEO.widget.GBasicAsyncDialog.superclass.hide.call(this);
	this.destroy();
}

/*
 * Metodo encargado de permitir el cambio de nombre de los botones para un dialogo
 * @param success Nombre para el boton de aceptar
 * @param cancel Nombre para el boton de cancelar
 * @param hSuccess Metodo a ejecutar cuando se pulsa el boton aceptar
 * @param hCancel Metodo a ejecutar cuando se pulsa el boton cancelar
 * NOTA Si estos manejadores no son asignados, unicamente se establece el estandar enviar y ocultara el dialogo
 */
GALILEO.widget.GBasicDialog.prototype.setButtons = function(success, cancel, hSuccess, hCancel) {
	if (success && cancel) {
		var handleSuccess = function(e, obj) {
			if (hSuccess) {
				hSuccess(e, obj);
			}
			else {
				if (this.submit()) {
					this.destroy();
				}
			}
		}
		
		var handleCancel = function(e, obj) {
			if (hCancel) {
				hCancel(e, obj);
			}
			this.hide();
		}
		
		var buttons = new Array();
		buttons[0] = [{text:success, handler:handleSuccess, isDefault:true},{text:cancel, handler:handleCancel}];
		this.configButtons("botones", buttons);
	}
};

/*
 * Definicion de un metodo encargado de modificar el cuerpo del dialogo
 * @param el Html con el cuerpo a modificar
 */
GALILEO.widget.GBasicAsyncDialog.prototype.changeDialog = function(el) {
	var div = document.createElement('div');
	div.innerHTML = el;

	var form = div.getElementsByTagName('form')[0];
	// Recorremos el formulario
	for (var i = 0; i < form.elements.length; i++) {
		if ((form.elements[i].tagName == 'INPUT') || (form.elements[i].tagName == 'SELECT')) {
			this.form.elements[i].value = form.elements[i].value;	
		}	
	}
	div.innerHTML = "";
};

/**
 * Definicion de un dialogo que se genera sobre un formulario que se carga de manera asincrona
 * Este dialogo envia una peticion asincrona escribiendo el resultado en una capa
 * @param containerId Id de la capa que contiene el formulario
 * @param width Tamano que asociaremos al dialogo con el formulario
 * @param containerSuccessId Id de la capa donde escribir el resultado en caso de que todo
 * sea correcto
 * @param containerFailureId Id de la capa donde escribir el resultado en el caso de un fallo
 * @param buttonsName Nombres que les asociaremos a los botones de envio y cancelacion
 * Estos nombres se encontraran almacenados en un objeto que poseera los siguientes atributos:
 *    - submit: Nombre asociado al boton enviar del formulario 
 *    - cancel: Nombre asociado al boton cancelar del formulario
 * @param calls Posibles llamadas que haya que realizar despues de alguna accion
 * Las posibles llamadas a realizar son la siguientes:
 *    - preShow: Metodo a invocar justo antes de realizar el mostrado del dialogo
 *    - validate: Metodo encargado de validar el formulario 
 *    - handlerManual: Metodo a invocar si decidimos que el envio del formulario se va a realizar
 *                     de forma manual
 *    - callback: Se define de la siguiente manera
 *         - success: Metodo a invocar si el envio del formulario ha sido correcto
 *         - failure: Metodo a invocar si el envio del formulario es erroneo
 * @param showWaitPanel Flag que indica si se debe o no mostrar el panel de espera 
 */
GALILEO.widget.GAsyncDialog = function(url, containerId, width, containerSuccessId, containerFailureId, buttonsName, calls, showWaitPanel) {
	if (containerSuccessId) {
		var success = function(o) {
			var element = YAHOO.util.Dom.get(containerSuccessId);
			element.innerHTML = o.responseText;
			if (calls && calls.callback && calls.callback.success) {
				calls.callback.success();
			}
		};
		var failure = function(o) {
			if (o.status != GALILEO.util.Connect.config.server.response.COD_SECURITY_EXCEPTION) {
			    if (calls && calls.callback && calls.callback.failure) {
					calls.callback.failure();
				}
				if (containerFailureId) {
					var element = YAHOO.util.Dom.get(containerFailureId);
					element.innerHTML = o.statusText;
				}
			}
			else {
		  	    GALILEO.util.Connect.handlerFailure(o);
			}
		};
		var callback = {
			success: success,
			failure: failure,
			scope: this
		};
		
		var preShow = null;
		if (calls && calls.preShow) {
			preShow = calls.preShow;
		}
		var validate = null;
		if (calls && calls.validate) {
			validate = calls.validate;
		}
		var handlerManual = null;
		if (calls && calls.handlerManual) {
			handlerManual = calls.handlerManual;
		}
		
		GALILEO.widget.GAsyncDialog.superclass.constructor.call(this, url, containerId, width, callback, buttonsName, preShow, validate, handlerManual, showWaitPanel);
	}
};

/* 
 * Definicion de la herencia
 */
YAHOO.extend(GALILEO.widget.GAsyncDialog, GALILEO.widget.GBasicAsyncDialog);


/**
 * Definicion de un dialogo que se genera sobre un formulario que se carga de manera asincrona
 * Este dialogo envia una peticion asincrona escribiendo el resultado en una capa
 * @param containerId Id de la capa que contiene el formulario
 * @param width Tamano que asociaremos al dialogo con el formulario
 * @param buttonsName Nombres que les asociaremos a los botones de envio y cancelacion
 * Estos nombres se encontraran almacenados en un objeto que poseera los siguientes atributos:
 *    - submit: Nombre asociado al boton enviar del formulario 
 *    - cancel: Nombre asociado al boton cancelar del formulario
 * @param calls Posibles llamadas que haya que realizar despues de alguna accion
 * Las posibles llamadas a realizar son la siguientes:
 *    - preShow: Metodo a invocar justo antes de realizar el mostrado del dialogo
 *    - handlerManual: Metodo a invocar si decidimos que el envio del formulario se va a realizar
 *                     de forma manual
 *    - callback: Se define de la siguiente manera
 *         - success: Metodo a invocar si el envio del formulario ha sido correcto
 *         - failure: Metodo a invocar si el envio del formulario es erroneo
 *		   - scope: Ambito
 * @param showWaitPanel Flag que indica si se debe o no mostrar el panel de espera 
 */
GALILEO.widget.GCAsyncDialog = function(url, containerId, width, buttonsName, calls, showWaitPanel) {
	if (calls && calls.callback) {
		var preShow = null;
		if (calls && calls.preShow) {
			preShow = calls.preShow;
		}
		var validate = null;
		if (calls && calls.validate) {
			validate = calls.validate;
		}
		var handlerManual = null;
		if (calls && calls.handlerManual) {
			handlerManual = calls.handlerManual;
		}
		
		GALILEO.widget.GCAsyncDialog.superclass.constructor.call(this, url, containerId, width, calls.callback, buttonsName, preShow, validate, handlerManual, showWaitPanel);
	}
};

/*
 * Definicion de la herencia
 */
YAHOO.extend(GALILEO.widget.GCAsyncDialog, GALILEO.widget.GBasicAsyncDialog);