/*
 * Constructor utilizado para la construccion de un nuevo dialogo de firma
 */
GALILEO.cylog.widget.GResultadoDialog = function(containerId, formName) {
	if (containerId && formName) {
		this.handleSubmit = function() {
			var form = YAHOO.util.Dom.get(formName);
			form.submit();
			this.hide();
			this.destroy();
		}
	
		var dialogButtons = [ { text:GALILEO.text.ACEPTAR, handler:this.handleSubmit, isDefault:true } ];
	
		var defaultConf = {iframe:true, fixedcenter: true, constraintoviewport: true, visible:true, draggable:true, modal:true, buttons:dialogButtons};
	
		GALILEO.cylog.widget.GResultadoDialog.superclass.constructor.call(this, containerId, defaultConf);
		
		this.render();
		this.show();
	}
};

YAHOO.extend(GALILEO.cylog.widget.GResultadoDialog, YAHOO.widget.Dialog);

/* Definicion de los manejadores */
GALILEO.cylog.widget.GResultadoDialog.handleSubmit = null;

/*** Creación del dialogo de firma ***/
GALILEO.cylog.widget.CFirmaDialog = function () {

	var validarFirma = function () {
		var form = YAHOO.util.Dom.get("formValidacion");
		if (form.firma.value != "") {
			return true;
		} else {
			var dlg = new GALILEO.cylog.widget.GSimpleDialog('dlgError', '22em', true, false, null, null, "Error", "Debe introducir una firma");
	  	 	dlg.show();
			return false;
		}
	}
	
	var calls = 
	{
		validate: validarFirma,
		callback: {
			success: function(o) {
				new GALILEO.cylog.widget.GResultadoDialog ("dialogoResultadoOk", "formResultadoOk");
			},
			failure: function(o) {
				GALILEO.util.Connect.handlerFailure(o);
			}
		}
	};

	var buttonsName = {submit: "Aceptar", cancel: "Cancelar"};
	dialogValidacion = new GALILEO.widget.GCDialog('dialogoValidacion', '20em', buttonsName, calls, false, true);
}

/*
 * 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
 * @param cabecera Texto que debe aparecer en la cabecera
 * @param texto Texto que debe aparecer en el cuerpo
 */
GALILEO.cylog.widget.GSimpleDialog = function(containerId, width, modal, draggable, hSuccess, hCancel, cabecera, texto) {
	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.cylog.widget.GSimpleDialog.handleSuccess = function() {
			if (hSuccess) {
				hSuccess();
			}
			this.hide();
		}

		GALILEO.cylog.widget.GSimpleDialog.handleCancel = function() {
			if (hCancel) {
				hCancel();
			}
			this.hide();
		}

		var isModal = false;
		var isDraggable = false;
		if (modal) {
			isModal = modal;
		} 
		
		if (draggable) {
			isDraggable = draggable;
		}

		var defaultConf = {width:width, iframe:true, fixedcenter: true, constraintoviewport: true, close:true, visible:false, draggable: isDraggable, modal:isModal};

		GALILEO.cylog.widget.GSimpleDialog.superclass.constructor.call(this, containerId, defaultConf);

		if (hCancel) {
			this.cfg.queueProperty("buttons", [{text:"Aceptar", handler:GALILEO.cylog.widget.GSimpleDialog.handleSuccess, isDefault:true},
											   {text:"Cancelar", handler:GALILEO.cylog.widget.GSimpleDialog.handleCancel}]);
		} else {
			this.cfg.queueProperty("buttons", [{text:"Aceptar", handler:GALILEO.cylog.widget.GSimpleDialog.handleSuccess, isDefault:true}]);
		}

		this.setHeader(cabecera);
  	 	this.setBody(texto);

		this.imageRoot = "";										   
	}
};

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

/* Definicion de los manejadores */
GALILEO.cylog.widget.GSimpleDialog.handleSuccess = null;
GALILEO.cylog.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.cylog.widget.GSimpleDialog.prototype.setButtons = function(success, cancel, hSuccess, hCancel) {
	if (success && cancel) {
		GALILEO.cylog.widget.GSimpleDialog.handleSuccess = function(e, obj) {
			if (hSuccess) {
				hSuccess(e, obj);
			}
			this.hide();
		}
		
		GALILEO.cylog.widget.GSimpleDialog.handleCancel = function(e, obj) {
			if (hCancel) {
				hCancel(e, obj);
			}
			this.hide();
		}
		
		this.cfg.queueProperty("buttons", [{text:success, handler:GALILEO.cylog.widget.GSimpleDialog.handleSuccess, isDefault:true},
										   {text:cancel, handler:GALILEO.cylog.widget.GSimpleDialog.handleCancel}]);	}
};

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

/*
 * Metodo encargado de cambiar la cabecera del dialogo
 * @param titulo Titulo a utilizar en la cabecera
 */
GALILEO.cylog.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.cylog.widget.GSimpleDialog.superclass.setHeader.call(this, header);
};

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

/*
 * Constructor utilizado para la construccion de un nuevo dialogo de firma
 */
GALILEO.cylog.widget.GErrorDialog = function(o, action, accion, formName) {
	if (o && action && accion && formName) {
		var elemento = GALILEO.util.Dom.createElement('div');
		elemento.innerHTML = o.responseText;
		YAHOO.util.Dom.get("bd").appendChild(elemento);
		GALILEO.util.Event.modifyDOM.fire();

		this.handleSubmit = function() {
			var form = YAHOO.util.Dom.get("formError");
			form.action = action;
			form.name = formName;
			form.accion.value = accion;
			form.submit();
			this.hide();
			this.destroy();
		}

		this.handleCancel = function() {
			this.hide();
			this.destroy();
		}

		var dialogButtons = [ { text:"Aceptar", handler:this.handleSubmit, isDefault:true },
							  { text:"Cancelar", handler:this.handleCancel } ];

		var defaultConf = {iframe:true, fixedcenter: true, constraintoviewport: true, visible:true, draggable:true, modal:true, buttons:dialogButtons};

		GALILEO.cylog.widget.GErrorDialog.superclass.constructor.call(this, "dialogoError", defaultConf);

		this.render();
		this.show();
	}
};

YAHOO.extend(GALILEO.cylog.widget.GErrorDialog, YAHOO.widget.Dialog);


/*
 * 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
 * @param isModal Flag que indica si el panel es modal o no
 */
GALILEO.cylog.widget.GBasicAsyncDialog = function(url, containerId, width, callback, buttonsName, preShow, validate, handlerManual, showWaitPanel , isModal) {
	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,
			modal: isModal
		};
		
		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.cylog.widget.GBasicAsyncDialog, GALILEO.widget.GBasicDialog);

/*
 * Definicion de un metodo encargado de modificar el cuerpo del dialogo
 * @param el Html con el cuerpo a modificar
 */
GALILEO.cylog.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 = "";
};

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

/**
 * 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
 * @param isModal Flag que indica si el panel es modal o no
 */
GALILEO.cylog.widget.GCAsyncDialog = function(url, containerId, width, buttonsName, calls, showWaitPanel, isModal) {
	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.cylog.widget.GCAsyncDialog.superclass.constructor.call(this, url, containerId, width, calls.callback, buttonsName, preShow, validate, handlerManual, showWaitPanel, isModal);
	}
};

/*
 * Definicion de la herencia
 */
YAHOO.extend(GALILEO.cylog.widget.GCAsyncDialog, GALILEO.cylog.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 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 
 * @param isMdoal Flag que indica si el panel es modal o no
 */
GALILEO.cylog.widget.GAsyncDialog = function(url, containerId, width, containerSuccessId, containerFailureId, buttonsName, calls, showWaitPanel, isModal) {
	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.cylog.widget.GAsyncDialog.superclass.constructor.call(this, url, containerId, width, callback, buttonsName, preShow, validate, handlerManual, showWaitPanel, isModal);
	}
};

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