/**   LIBRERÍA: gvh_dataJSON  **/
/*******************************/
/* 
 * Codificación UTF-8
 * Métodos para obtener y modificar información del JSON que se envía a negocio con la información a tratar.
 * 
 * FUNCIONES:
 *  getRoot(claseM,panel)
 *  
 *  //*** MÉTODOS CAMPOS
 *  getFieldsJSON(rootJSON)
 *  getExistField(rootJSON,field,nReg,external)
 *  ! setEnableTrigger(rootJSON,field,nReg,value,external) // deprecated
 *  ! getEnableTrigger(rootJSON,field,nReg,external) // deprecated
 *  getValue(rootJSON,field,nReg,external)
 * 	getValueOld(rootJSON,field,nReg,external)
 *  setValue(rootJSON,field,nReg,value,external)
 *  setValueOld(rootJSON,field,nReg,value,external)
 *  setFilesUp(rootJSON,field,nReg,value)
 *  setValueCheckbox(rootJSON,field,nReg,value,check,external)
 * 	getValueCheckbox(rootJSON,field,nReg,check,external)
 *  getIdField(rootJSON,field,nReg,external)
 *  getTextField(rootJSON,field,nReg,external)  
 * 	getPlugin(rootJSON,field,nReg,external)
 *  getDependPanelField(rootJSON,field,nReg,external)
 *  getStateField(rootJSON,field,nReg,external)
 *  setStateField(rootJSON,field,nReg,state,external)
 * 	getClassField(rootJSON,field,nReg,external)
 *  setClassField(rootJSON,field,nReg,css,external)
 *  getVisibleField(rootJSON,field,nReg,external)
 *  setVisibleField(rootJSON,field,nReg,visible,external)
 *  getFieldList(rootJSON,field,external)
 *  isDependenceList(rootJSON,field,nReg,external)
 *  isHidden(rootJSON,field,nReg,external)
 *  isVisible(rootJSON,field,nReg,external)
 *  getTypeField(rootJSON,field,nReg,external)
 *  
 *  
 *  //*** MÉTODOS PANEL Y REGISTRO
 *   
 *  indexDataJSON(rootJSON,row, modoPanel)
 *  getClassRow(rootJSON,nReg)
 *  setClassRow(rootJSON,nReg,class)
 *  getRowsPag(rootJSON)
 *  getRegIns(rootJSON)
 *  getRegVisibles(rootJSON)
 *  setAllSelected(rootJSON,selected)
 *  
 *  getExistReg(rootJSON,nReg)
 *  getStateReg(rootJSON,nReg,state)
 *  setStateReg(rootJSON,state,nReg,operation)
 *  getSelectedReg(rootJSON,nReg)
 *  setSelectedReg(rootJSON,nReg,operation)
 *  getNumReg(rootJSON)
 *  getPagActive(rootJSON)
 *  setPagActive(rootJSON,pag)
 *  getFieldsRow(rootJSON, row)
 *  getDataRequired(rootJSON)
 *  getPagIns(rootJSON)
 *  getRegAlter(rootJSON)
 *  getRegSelected(rootJSON)
 *  getFieldExternal(rootJSON, field)
 */

// TODO : Refactorizar las funciones del fichero


/**
 * getRoot: Obtiene el gvh.datosJSON correspondiente a la clase manejadora y panel correspondiente 
 * @access	private
 * @param	claseM: clase del panel sobre el que queremos calcular el índice
 * @param	panel: tipo de panel (indice del objeto JSON) sobre el que se está trabajando ['lis','edi']
 */
gvh.getRoot = function( claseM, panel )
{
	gvh.showConsoleMsg('log','  *** gvh_dataJSON.js - getRoot() - '+claseM+' '+panel);
	gvh.showConsoleMsg('log',gvh.datosJSON[claseM][panel]);
	return gvh.datosJSON[claseM][panel];
};


/* *************************
 * MÉTODOS CAMPOS
 */

/**
 * getFieldsJSON: Obtiene el array de los campos correspondientes a un panel 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	nReg: registro seleccionado 
 * @return	array
 */
gvh.getFieldsJSON = function(rootJSON,nReg)
{
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getFieldsJSON() '+nReg); 
	var vFields = rootJSON['data'][nReg]['gvhJS_fields'];
	return vFields;
};

/**
 * getExistField: Devuelve si existe o no el registro en ['data'] del gvh.datosJSON 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	nReg: fila seleccionada del panel
 * @param	field: identificador del campo
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	boolean
 */
gvh.getExistField = function( rootJSON, field, nReg, external )
{
	external = external || false;
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getExistField() field '+field+' '+nReg+' external? '+external);
	//gvh.showConsoleMsg('log',rootJSON);
	if ((external == false)) // || (external == 0) || (external == ''))
	{
		if ((rootJSON['data'][nReg] == undefined) || (rootJSON['data'][nReg]['gvhJS_fields'][field] == undefined)) {
			gvh.showConsoleMsg('error','El campo '+field+' no existe en el datosJSON.');
			return false;
		}
		else {
			return true; //rootJSON['data'][nReg]['gvhJS_fields'][field];
		}
	}
	else {
		if (rootJSON['external'] != undefined )
		{
			if (rootJSON['external'][field] == undefined)
			{
				gvh.showConsoleMsg('error','El campo '+field+' no existe.');
				return false;
			}
			else {
				return true; //rootJSON['external'][field];
			}
		}
		else {
			gvh.showConsoleMsg('error','No hay campos external.');
			return false;
		}
	}
};


/**
 * setEnableTrigger: Si el campo tiene una acción de interfaz, habilitarla/deshabilitarla
 * @deprecated 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	nReg: número de registro al que pertenece el campo
 * @param	value: valor a asignar
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return boolean
 */
gvh.setEnableTrigger = function( rootJSON, field, nReg, value, external )
{
	external = external || false;
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - setEnableTrigger() => '+value);
	
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - setEnableTrigger() '+field+' no existe el campo');
		return false;
	}
	
	if( (external == false) ) // || (external == 0) || (external == '') || (external == undefined ))
	{
		rootJSON['data'][nReg]['gvhJS_fields'][field]['onTrigger'] = value;
		rootJSON['dataPerform']['data'][nReg]['gvhJS_fields'][field]['onTrigger'] = value;
	}
	else {
		rootJSON['external'][field]['onTrigger'] = value;
		rootJSON['dataPerform']['external'][field]['onTrigger'] = value;		
	}
	return true;
}


/**
 * getEnableTrigger: Si el campo tiene una acción de interfaz, habilitarla/deshabilitarla
 * @deprecated 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	nReg: número de registro al que pertenece el campo
 * @param	value: valor a asignar
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	boolean
 */
gvh.getEnableTrigger = function( rootJSON, field, nReg, external )
{
	external = external || false;
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getEnableTrigger() => '+field);
	
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - setEnableTrigger() '+field+' no existe el campo');
		return false;
	}
	
	if ((external == false)) // || (external == 0) || (external == '') || (external == undefined ))
	{
		return rootJSON['data'][nReg]['gvhJS_fields'][field]['onTrigger'];
	}
	else {
		return rootJSON['external'][field]['onTrigger'];
	}
	return true;
}

/**
 * getValue: Obtiene el valor del campo indicado 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	nReg: número de registro al que pertenece el campo
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	mixed
 */
gvh.getValue = function( rootJSON, field, nReg, external )
{
	external = external || false;
	
	var value;
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getValue() '+field+' no existe el campo.');
		return value;
	}
	
	if ((external == false)) // || (external == 0) || (external == ''))
	{
		value = rootJSON['data'][nReg]['gvhJS_fields'][field]['value'];	
	}
	else {
		value = rootJSON['external'][field]['value'];
	}
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getValue() => '+value);
	return value;
}

/**
 * getValueOld: Obtiene el valor anterior del campo indicado 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	nReg: número de registro al que pertenece el campo
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	mixed
 */
gvh.getValueOld = function( rootJSON, field, nReg, external )
{
	external = external || false;
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getValueOld()');

	var valueOld;
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getValueOld() '+field+' no existe el campo.');
		return valueOld;
	}
	
	if ((external == false)) // || (external == 0) || (external == ''))
	{
		valueOld = rootJSON['data'][nReg]['gvhJS_fields'][field]['valueOld'];	
	}
	else {
		valueOld = rootJSON['external'][field]['valueOld'];
	}
	return valueOld;
}

/**
 * setValue: Asigna un valor al campo indicado 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	nReg: número de registro al que pertenece el campo
 * @param	value: valor a asignar
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	boolean
 */
gvh.setValue = function( rootJSON, field, nReg, value, external )
{
	external = external || false;
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - setValue() => '+field+' valor '+value+' // '+nReg);
	
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - setValue() '+field+' no existe el campo');
		return false;
	}
	
	if( (external == false) ) // || (external == 0) || (external == '') || (external == undefined ))
	{
		rootJSON['data'][nReg]['gvhJS_fields'][field]['value'] = value;
		rootJSON['dataPerform']['data'][nReg]['gvhJS_fields'][field]['value'] = value;
	}
	else
	{
		rootJSON['external'][field]['value'] = value;
		rootJSON['dataPerform']['external'][field]['value'] = value;
	}
	return true;
}

/**
 * setValueOld: Asigna un valor anterior al campo indicado 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	nReg: número de registro al que pertenece el campo
 * @param	value: valor a asignar
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	boolean
 */
gvh.setValueOld = function( rootJSON, field, nReg, value, external )
{
	external = external || false;
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - setValueOld()');

	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - setValueOld() '+field+' no existe el campo.');
		return false;
	}
	
	if( (external == false) ) // || (external == 0) || (external == ''))
	{
		rootJSON['data'][nReg]['gvhJS_fields'][field]['valueOld'] = value;
		rootJSON['dataPerform']['data'][nReg]['gvhJS_fields'][field]['valueOld'] = value;	
	}
	else {
		rootJSON['external'][field]['valueOld'] = value;
		rootJSON['dataPerform']['external'][field]['valueOld'] = value;
	}
	return true;
}


/**
 * setFilesUp: Asigna los ficheros anexados al campo correspondiente 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	nReg: número de registro al que pertenece el campo
 * @param	value: valor a asignar
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	boolean
 */
gvh.setFilesUp = function( rootJSON, field, nReg, value )
{
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - setFilesUp()'); 
	if( !gvh.getExistField(rootJSON,field,nReg) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - setFilesUp() no existe el campo '+field);
		return false;
	}
	rootJSON['data'][nReg]['gvhJS_fields'][field]['files'] = value;
	rootJSON['dataPerform']['data'][nReg]['gvhJS_fields'][field]['files'] = value;
	return true;
}


/**
 * getValueCheckbox: Devuelve el valor de un checkbox (chequeado o no) 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	nReg: número de registro al que pertenece el campo
 * @param	check: Booleano. True, corresponderá al valor del checkbox chequeado. False, corresponderá al valor del checkbox no chequeado.
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	mixed
 */
gvh.getValueCheckbox = function( rootJSON, field, nReg, check, external )
{
	external = external || false;
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getValueCheckbox()'); 
	 
	var value;
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getValueCheckbox() no existe el campo '+field);
		return value;
	}
	
	var valueField = ( check ? 'valueCheck' : 'valueUnCheck' );
	if ((external == false)) // || (external == 0) || (external == ''))
	{
		value = rootJSON['data'][nReg]['gvhJS_fields'][field][valueField];
	}
	else {
		value = rootJSON['external'][field][valueField];
	}
	return value;
}


/**
 * setValueCheckbox: Devuelve el valor de un checkbox (chequeado o no) 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	value: valor a asigna al checkbox
 * @param	nReg: número de registro al que pertenece el campo
 * @param	check: Booleano. True, corresponderá al valor del checkbox chequeado. False, corresponderá al valor del checkbox no chequeado.
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 */
/*gvh.setValueCheckbox = function( rootJSON, field, value, nReg, check, external )
{
	external = external || false;
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - setValueCheckbox()'); 
	if ((external == false)) // || (external == 0) || (external == ''))
	{
		if (check)
			rootJSON['data'][nReg]['gvhJS_fields'][field]['valueCheck'] = value;
		else
			rootJSON['data'][nReg]['gvhJS_fields'][field]['valueUnCheck'] = value;
	}
	else {
		if (check)
			rootJSON['external'][field]['valueCheck'] = value;
		else
			rootJSON['external'][field]['valueUnCheck'] = value;
	}
}*/



/**
 * getId: Obtiene el valor anterior del campo indicado 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	nReg: número de registro al que pertenece el campo
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	string
 */
gvh.getIdField = function( rootJSON, field, nReg, external )
{
	external = external || false;
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getIdField() -> '+field+' no existe el campo en el objeto gvh.datosJSON.');
		return '';
	}
	
	var id;
	if( (external == false) ) // || (external == 0) || (external == ''))
	{
		id = rootJSON['data'][nReg]['gvhJS_fields'][field]['id'];	
	}
	else {
		id = rootJSON['external'][field]['id'];
	}
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getIdField() -> '+field+' id '+id);
	return id;
}

/**
 * getTextField: Obtiene el texto asociado al campo 
 * @access	private
 * @param	rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param	field: campo a modificar
 * @param	nReg: número de registro al que pertenece el campo
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	string
 */
gvh.getTextField = function( rootJSON, field, nReg, external )
{
	external = external || false;
	if( !gvh.getExistField(rootJSON,field,nReg,external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getTextField() no existe el campo '+field); 
		return '';
	}
	
	var id;
	if( (external == false) ) // || (external == 0) || (external == ''))
	{
		id = rootJSON['data'][nReg]['gvhJS_fields'][field]['text'];	
	}
	else {
		id = rootJSON['external'][field]['text'];
	}
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getTextField() -> '+id); 
	return id;
}

/**
 * getPlugin: Devuelve el tipo de plugin del campo 
 * @access	private
 * @param	field: campo 
 * @param	nReg: número de registro al que pertenece el campo
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	mixed
 */
gvh.getPlugin = function( rootJSON, field, nReg, external )
{
	external = external || false;
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getPlugin() no existe el campo '+field); 
		return '';
	}
	
	var plugin;
	if ((external == false) || (external == 0) || (external == '') || (external == undefined ) )
	{
		plugin = rootJSON['data'][nReg]['gvhJS_fields'][field]['CWPlugin'];	
	}
	else {
		plugin = rootJSON['external'][field]['CWPlugin'];
	}
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getPlugin() -> '+plugin); 
	return plugin;
}

/**
 * getClassField: Devuelve el atributo class que corresponde al campo 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	field: campo 
 * @param	nReg: número de registro al que pertenece el campo
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	string
 */
gvh.getClassField = function( rootJSON, field, nReg, external )
{
	external = external || false;
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getClassField() no existe el campo '+field); 
		return '';
	}
	
	var cssClass;
	if( (external == false) ) // || (external == 0) || (external == ''))
	{
		cssClass = rootJSON['data'][nReg]['gvhJS_fields'][field]['class'];	
	}
	else {
		cssClass = rootJSON['external'][field]['class'];
	}
	gvh.showConsoleMsg( 'log','   *** gvh_dataJSON.js - getClassField() -> '+cssClass ); 
	return cssClass; 
}

/**
 * setClassField: Devuelve el atributo class que corresponde al campo 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	field: campo 
 * @param	nReg: número de registro al que pertenece el campo
 * @param	css: nuevo estilo
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	string
 */
gvh.setClassField = function( rootJSON, field, nReg, css, external )
{
	external = external || false;
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - setClassField() no existe el campo '+field); 
		return '';
	}
	
	if( (external == false) ) // || (external == 0) || (external == ''))
	{
		rootJSON['data'][nReg]['gvhJS_fields'][field]['class'] = css;	
	}
	else {
		rootJSON['external'][field]['class'] = css;
	}
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - setClassField() -> '+css); 
	return css;
}

/**
 * getVisibleField: Devuelve si el campo es visible o no 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	field: campo 
 * @param	nReg: número de registro al que pertenece el campo
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	mixed
 */
gvh.getVisibleField = function( rootJSON, field, nReg, external )
{
	external = external || false;
	if( !gvh.getExistField( rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getVisibleField() no existe el campo '+field); 
		return '';
	}
	
	if( (external == false) ) // || (external == 0) || (external == ''))
	{
		var visible = rootJSON['data'][nReg]['gvhJS_fields'][field]['visible'];	
	}
	else {
		var visible = rootJSON['external'][field]['visible'];
	}
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getVisibleField() -> '+visible); 
	return visible;
}

/**
 * setVisibleField: Devuelve si el campo es visible o no 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	field: campo 
 * @param	nReg: número de registro al que pertenece el campo
 * @param	visible: booleano
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @return	mixed
 */
gvh.setVisibleField = function( rootJSON, field, nReg, visible, external )
{
	external = external || false;
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - setVisibleField() no existe el campo '+field); 
		return '';
	}
	
	if ((external == false)) // || (external == 0) || (external == ''))
	{
		rootJSON['data'][nReg]['gvhJS_fields'][field]['visible'] = visible;	
	}
	else {
		rootJSON['external'][field]['visible'] = visible;
	}
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - setVisibleField() -> '+visible); 
	return visible;
}


/**
 * getDependPanelField: Devuelve si el estado del elemento (boton tooltip) es dependiente del panel 
 * @access	public
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param field: campo 
 * @param nReg: número de registro al que pertenece el campo
 * @param external: booleano Solo en paneles tabulares, campo externo a la tabla
 */
gvh.getDependPanelField = function( rootJSON, field, nReg, external )
{
	external = external || false;
	var depend = false;
	if (gvh.getExistField(rootJSON,field,nReg,external))
	{
		var fields = undefined;
		if ((external == false)) // || (external == 0) || (external == ''))
		{
			fields = rootJSON['data'][nReg]['gvhJS_fields'];
		}
		else {
			fields = rootJSON['external'];
		}
		
		if( fields != undefined && fields[field]['dependPanel'] != undefined )
		{
			depend = fields[field]['dependPanel'];
		}
		gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getDependPanelField() -> '+depend); 
		return depend;
	}
	else {
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getDependPanelField() no existe el campo '+field); 
		return '';
	}
}

/**
 * setDependPanelField: Devuelve si el estado del elemento (boton tooltip) es dependiente del panel 
 * @access	private
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param field: campo 
 * @param nReg: número de registro al que pertenece el campo
 * @param external: booleano Solo en paneles tabulares, campo externo a la tabla
 */
gvh.setDependPanelField = function( rootJSON, field, nReg, depend, external )
{
	external = external || false;
	if (gvh.getExistField(rootJSON,field,nReg,external))
	{
		if ((external == false)) // || (external == 0) || (external == ''))
		{
			rootJSON['data'][nReg]['gvhJS_fields'][field]['dependPanel'] = depend;
		}
		else {
			rootJSON['external'][field]['dependPanel'] = depend;
		}
		gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - setDependPanelField() -> '+depend); 
	}
	else {
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - setDependPanelField() no existe el campo '+field);
	}
}

/**
 * getStateField: Devuelve el estado correspondiente al campo 
 * @access	private
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param field: campo 
 * @param nReg: número de registro al que pertenece el campo
 * @param external: booleano Solo en paneles tabulares, campo externo a la tabla
 */
gvh.getStateField = function( rootJSON, field, nReg, external )
{
	external = external || false;
	if (gvh.getExistField(rootJSON,field,nReg,external))
	{
		if ((external == false)) // || (external == 0) || (external == ''))
		{
			var state = rootJSON['data'][nReg]['gvhJS_fields'][field]['state'];
		}
		else {
			var state = rootJSON['external'][field]['state'];
		}
		gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getStateField() -> '+field+' '+state); 
		return state;
	}
	else {
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getStateField() no existe el campo '+field); 
		return '';
	}
}

/**
 * setStateField: Asigna el estado a un campo 
 * @access	private
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param field: campo 
 * @param nReg: número de registro al que pertenece el campo
 * @param value: true/false/new
 * @param external: booleano Solo en paneles tabulares, campo externo a la tabla
 */
gvh.setStateField = function( rootJSON, field, nReg, state, external )
{
	external = external || false;
	if (gvh.getExistField(rootJSON,field,nReg,external))
	{
		if ((external == false)) // || (external == 0) || (external == ''))
		{
			rootJSON['data'][nReg]['gvhJS_fields'][field]['state'] = state;
		}
		else {
			rootJSON['external'][field]['state'] = state;
		}
		gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - setStateField() -> '+state); 
		return state;
	}
	else {
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - setStateField() no existe el campo '+field); 
		return '';
	}
}

/**
 * getFieldList: Devuelve los valores de una lista correspondiente a un campo 
 * @access	private
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param field: campo
 * @param dependence: booleano si la lista es dependiente o no
 * @param nReg: número de registro al que pertenece el campo
 * @param external: booleano Solo en paneles tabulares, campo externo a la tabla 
 */
gvh.getFieldList = function( rootJSON, field, dependence, nReg, external )
{
	external = external || false;
	gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getFieldList() '+field+' nReg '+nReg);
	if (nReg != undefined)
	{
		if (gvh.getExistField(rootJSON,field,nReg,external))
		{
			gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getFieldList() '+field+' nReg '+nReg); 
			if (dependence == false)
				return rootJSON['components']['gvh_list'][field];
			else {		
				if ((external == false)) // || (external == 0) || (external == ''))
				{
					return rootJSON['data'][nReg]['gvhJS_fields'][field]['lista'];	
				}
				else {
					return rootJSON['external'][field]['lista'];			
				}
			}
		}
		else {
			gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getFieldList() no existe el campo '+field); 
			return '';
		}
	}
	else {
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getFieldList() no se ha especificado el número de registro (nReg)'); 
		return '';
	}
}

/**
 * isDependenceList: Devuelve si es una lista dependiente o no 
 * @access	private
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param field: campo 
 * @param nReg: número de registro al que pertenece el campo
 * @param external: booleano Solo en paneles tabulares, campo externo a la tabla
 */
gvh.isDependenceList = function( rootJSON, field, nReg, external )
{ 
	external = external || false;
	if (gvh.getExistField(rootJSON,field,nReg,external))
	{
		gvh.showConsoleMsg('log','   		*** gvh_dataJSON.js - isDependenceList() field '+field+' nReg '+nReg);
		if ((external == false)) // || (external == 0) || (external == ''))
		{
			return rootJSON['data'][nReg]['gvhJS_fields'][field]['dependence'];	
		}
		else {
			return rootJSON['external'][field]['dependence'];
		}
	}
	else {
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - isDependenceList() no existe el campo '+field);
		return '';
	}
};

/**
 * isHidden: Devuelve true/false si el campo es un campo oculto 
 * @access	private
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param field: campo
 * @param nReg: número de registro al que pertenece el campo
 * @param external: booleano Solo en paneles tabulares, campo externo a la tabla
 */
gvh.isHidden = function( rootJSON, field, nReg, external )
{ 	 
	external = external || false;
	if (gvh.getExistField(rootJSON,field,nReg,external))
	{
		if ((external == false)) // || (external == 0) || (external == ''))
		{
			var hidden = rootJSON['data'][nReg]['gvhJS_fields'][field]['hidden'];	
		}
		else {
			var hidden = rootJSON['external'][field]['hidden'];
		}
		gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - isHidden() => '+hidden );
		return hidden;
	}
	else {
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - isHidden() no existe el campo '+field);
		return '';
	}
};

/**
 * isVisible: Devuelve true/false si el campo es visible 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	field: campo
 * @param	nReg: número de registro al que pertenece el campo
 * @param	external: booleano Solo en paneles tabulares, campo externo a la tabla
 * @param	isInnerCall: booleano Usado para llamadas internas de métodos
 * @return	mixed
 */
gvh.isVisible = function( rootJSON, field, nReg, external, innerCall )
{
	external  = external || false;
	innerCall = innerCall || false;
	if( !gvh.getExistField(rootJSON, field, nReg, external) )
	{
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - isVisible() no existe el campo '+field);
		return '';
	}
	
	var visible;
	if( (external == false) ) 
	{
		visible = rootJSON['data'][nReg]['gvhJS_fields'][field]['visible'];	
	}
	else {
		visible = rootJSON['external'][field]['visible'];
	}
	if( !innerCall ) gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - isVisible() ? ' + visible);
	return visible;
};

/**
 * getTypeField: Obtiene el tipo del campo 
 * @access	private
 * @param rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param field: campo a modificar
 * @param nReg: número de registro al que pertenece el campo
 * @param external: booleano Solo en paneles tabulares, campo externo a la tabla
 */
gvh.getTypeField = function(rootJSON,field,nReg,external)
{
	external = external || false;
	if (gvh.getExistField(rootJSON,field,nReg,external))
	{
		gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - getTypeField()'); 
		if ((external == false)) // || (external == 0) || (external == ''))
		{
			return rootJSON['data'][nReg]['gvhJS_fields'][field]['type'];	
		}
		else {
			return rootJSON['external'][field]['type'];
		}
	}
	else {
		gvh.showConsoleMsg('error','   *** gvh_dataJSON.js - getTypeField() no existe el campo '+field );
		return '';
	}
}



/* *************************
 * MÉTODOS PANEL Y REGISTRO
 */

/**
 * indexDataJSON: Calcula el índice del array gvh.datosJSON sobre el que queremos trabajar. 
 * Útil para calcularlo cuando se trabaja con paneles lis.
 * @access	private
 * @param rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param row: fila seleccionada del panel
 * @param modoPanel: 'I' solo en el caso de estar en modo inserción para calcular el índice correspondiente
 */
gvh.indexDataJSON = function( rootJSON, row, modoPanel )
{
	if( modoPanel === undefined )
	{
		modoPanel = rootJSON['panel']['state'];
	}
	
	//gvh.showConsoleMsg('log','   *** gvh_dataJSON.js - indexDataJSON()');
	var idPanel = rootJSON['panel']['id'];
	var panelJSON = idPanel.substr( 2, 3 );
	var indice;
	if (panelJSON == 'fil') // Panel filtro siempre es posición 0 de datosJSON
	{
		indice = 0;
	}
	else {
		if (modoPanel == 'I')
		{
			if (panelJSON == 'edi') // panel edi en modo inserción
			{
				indice = gvh.getPagIns( rootJSON );
			}
			else { // panel lis en modo inserción
				if (row == 0)
				{
					indice = parseInt(rootJSON['panel']['rowIniInsercion']);    
				}
				else {
					indice = parseInt(row);	     
				}           				
			}
		}
		else {
			if (panelJSON == 'edi') // panel edi en modo edición
			{
				indice = gvh.getPagActive( rootJSON );
			}
			else { // panel lis en modo edición
				var rowsPag = parseInt(rootJSON['panel']['rowsPag']);
				var pagAct 	= parseInt(rootJSON['panel']['pagActive']);
				
				indice = parseInt(pagAct*rowsPag) + parseInt(row);
				//gvh.showConsoleMsg( 'log', ' *** indexDataJSON() pagAct ' + pagAct );
				//gvh.showConsoleMsg( 'log', ' *** indexDataJSON() rowsPag ' + rowsPag );
				//gvh.showConsoleMsg( 'log', ' *** indexDataJSON() row ' + row );					
			}
		}
	}

	gvh.showConsoleMsg( 'log', ' *** gvh_dataJSON.js - indexDataJSON() ' + indice );
	return indice;
};

/**
 * getClassRow: actualización del array correspondiente a la operación con el número de registro afectado
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	state: ['selected' | 'insert' | 'updated' | 'deleted']
 * @param	nReg: indice del array gvh.datosJSON[claseM][panel][data], número de registro/fila sobre el que se aplica el estado
 * @param	operation: add,sub
 * @retur	mixed
*/
gvh.getClassRow = function( rootJSON, nReg )
{
	return rootJSON['data'][nReg]['gvhJS_rowColor'];
}


/**
 * getClassRow: actualización del array correspondiente a la operación con el número de registro afectado
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	state: ['selected' | 'insert' | 'updated' | 'deleted']
 * @param	nReg: indice del array gvh.datosJSON[claseM][panel][data], número de registro/fila sobre el que se aplica el estado
 * @param	operation: add,sub
*/
gvh.setClassRow = function( rootJSON, nReg, css )
{
	rootJSON['data'][nReg]['gvhJS_rowColor'] = css;
}

/**
 * getRowsPag: Devuelve el número de filas de una página de una tabla 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @return	integer 
 */
gvh.getRowsPag = function( rootJSON )
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getRowsPag()'); 
	return parseInt( rootJSON['panel']['rowsPag'] );
}

/**
 * getRegInsert: Devuelve los registros donde se insertarán valores  
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @return	array		Registros seleccionados 
 */
gvh.getRegInsert = function( rootJSON )
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getRegInsert()'); 
	var vReg 	= [];
	var numReg  = rootJSON['panel']['pagInsercion'];
	var rowsPag = rootJSON['panel']['rowsPag'];
	for(var i=0;i<rowsPag;i++)
	{
		vReg.push(numReg);
		numReg++;
	}
	return vReg;
}

/**
 * isRowVisibles: Devuelve si la fila está en la página activa  
 * @access	private
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param row: fila 
 */
gvh.isRowVisibles = function(rootJSON,row)
{
	var visible	= false; 
	var pagActiva = rootJSON['panel']['pagActive'];
	var rowsPag	= rootJSON['panel']['rowsPag'];
	if (rowsPag == undefined)
	{
		var pagRow = row;
	}
	else {
		var pagRow = Math.trunc(row/rowsPag);
	}
	if (pagActiva == pagRow)
		visible = true;
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - isRowVisibles() '+visible); 
	return visible;
}

/**
 * setAllSelected: Devuelve los registros que han sido modificados (insertar, modificar) 
 * @access	private
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param vReg: array registros modificados 
 */
gvh.setAllSelected = function(rootJSON,selected)
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - setAllSelected() '+selected); 
	var operacion = 'sub';
	if (selected == 'selected')
	{
		var operacion = 'add';
	}
	var numReg = gvh.getNumReg(rootJSON);
	for (var i=0;i<numReg;i++)
	{
		gvh.setStateReg(rootJSON,'selected',i,operacion);
	}
}





/**
 * getExistReg: Devuelve si existe o no el registro en ['data'] del gvh.datosJSON 
 * @access	private
 * @param rootJSON: raiz del gvh.datosJSON, clase manejadora y panel
 * @param row: fila seleccionada del panel
 */
gvh.getExistReg = function( rootJSON, row, innerCall )
{
	innerCall = innerCall || false;
	
	if( !innerCall ) gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getExistReg()');
	var indices = row;
	if( !Array.isArray(row) )
	{
		indices = [indices];
	}
	
	for(var i=0; i<indices.length; i++)
	{
		if( !rootJSON['data'][indices[i]] ) return false;
	}	
	return true;	
};

/**
 * getSelectedReg: devuelve si el registro está seleccionado
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	nReg: indice del array gvh.datosJSON[claseM][panel][data], número de registro/fila sobre el que se aplica el estado
*/
gvh.getSelectedReg = function(rootJSON,nReg)
{ 
	if( !gvh.getExistReg(rootJSON,nReg) )
	{
		gvh.showConsoleMsg('error','	*** gvh_dataJSON.js - getSelectedReg() el registro '+nReg+' no existe');
		return '';
	}
	
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getSelectedReg() '+nReg);
	return rootJSON['data'][nReg]['gvhJS_selected'];
}


/**
 * setSelectedReg: actualización del array correspondiente a la operación con el número de registro afectado
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	state: ['selected' | 'insert' | 'updated' | 'deleted']
 * @param	nReg: array con el intervalo [ini..fin] ó integer con el índice del array gvh.datosJSON[claseM][panel][data], número de registro/fila sobre el que se aplica el estado
 * @param	operation: add,sub
 * @param	innerCall: boolean	Indica si es una llamada interna al método
 * @return	boolean
 */
gvh.setSelectedReg = function( rootJSON, nReg, operation, innerCall )
{
	innerCall = true; // innerCall || false;
	
	if( !gvh.getExistReg(rootJSON, nReg, innerCall) )
	{
		gvh.showConsoleMsg('log', '	*** gvh_dataJSON.js - setSelectedReg() el registro '+nReg+' no existe.' );
		return false;
	} else if( rootJSON == '' || operation == '' )
	{
		gvh.showConsoleMsg('log', "setSelectedReg() - error en los parámetros. nReg: "+nReg+"  operation: "+operation );
		//gvh.showConsoleMsg('log',rootJSON);
		return false;
	}
	
	if( !innerCall ) gvh.showConsoleMsg('log', '	*** gvh_dataJSON.js - setSelectedReg() ->'+operation );
	
	var ini = nReg;
	var fin = nReg+1;
	if( Array.isArray(nReg) )
	{
		ini = nReg[0];
		fin = nReg[1];
	}
	if( operation == 'add' )
	{
		for(var i=ini; i<fin; i++ )
		{
			rootJSON['data'][i]['gvhJS_selected'] = 'selected';
			rootJSON['dataPerform']['data'][i]['gvhJS_selected'] = 'selected';
			var vSelected = rootJSON['dataPerform']['gvhJS_selected'];
			if ( vSelected.indexOf( i ) == -1 ) { // Si el registro ya está añadido como seleccionado, no se vuelve a añadir
				rootJSON['dataPerform']['gvhJS_selected'].push( i );
			}
		}
	}
	else if( operation == 'sub' )
	{
		for(var i=ini; i<fin; i++ )
		{
			rootJSON['data'][i]['gvhJS_selected'] = 'false';
			rootJSON['dataPerform']['data'][i]['gvhJS_selected'] = 'false';
			rootJSON['dataPerform']['gvhJS_selected'].splice( $.inArray(i, rootJSON['dataPerform']['gvhJS_selected']), 1 );
		}
	}
	return true;
}

/**
 * getStateReg: devuelve el estado del registro
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	state: ['selected' | 'insert' | 'updated' | 'deleted']
 * @param	nReg: indice del array gvh.datosJSON[claseM][panel][data], número de registro/fila sobre el que se aplica el estado
 * @param	operation: add,sub
*/
gvh.getStateReg = function(rootJSON,nReg,state)
{ 
	if( !gvh.getExistReg(rootJSON,nReg) )
	{
		gvh.showConsoleMsg('error','	*** gvh_dataJSON.js - getStateReg() el registro '+nReg+' no existe. ');
		return '';
	}
	
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getStateReg() '+nReg+' '+state);
	return rootJSON['data'][nReg]['gvhJS_state'];
}

/**
 * setStateReg: actualización del array correspondiente a la operación con el número de registro afectado
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	state: ['selected' | 'insert' | 'updated' | 'deleted']
 * @param	nReg: indice del array gvh.datosJSON[claseM][panel][data], número de registro/fila sobre el que se aplica el estado
 * @param	operation: add,sub
*/
gvh.setStateReg = function( rootJSON, state, nReg )
{ 
	if( (state == '') || (rootJSON == '') )
	{
		gvh.showConsoleMsg('error', "setStateReg() - error en los parámetros. state: "+state );
		//gvh.showConsoleMsg('log',rootJSON);
		return;
	}

	if( !gvh.getExistReg(rootJSON,nReg) )
	{
		gvh.showConsoleMsg('error', '	*** gvh_dataJSON.js - setStateReg() el registro '+nReg+' no existe. ');
		return;
	}
	
	gvh.showConsoleMsg('log', '	*** gvh_dataJSON.js - setStateReg() ->'+state);
	var jsonOp = []; 
	if( state != 'nada' )
	{
		jsonOp = rootJSON['dataPerform']['gvhJS_'+state];	
	}
	var operacion = '';
	switch( state )
	{
		case 'find':
			operacion = 'buscar'; 
		break;
		case 'inserted':
			operacion = 'insertada';
			rootJSON['dataPerform']['gvhJS_inserted'].push(nReg); 
		break;
		case 'deleted':
			operacion = 'borrada'; 
			rootJSON['dataPerform']['gvhJS_deleted'].push(nReg);
		break;
		case 'updated':
			operacion = 'modificada'; 
			rootJSON['dataPerform']['gvhJS_updated'].push(nReg);
		break;
		default:
			operacion = 'nada';
			if (rootJSON['dataPerform']['gvhJS_inserted'].indexOf(nReg) != -1)
			{
				rootJSON['dataPerform']['gvhJS_inserted'].splice( $.inArray(nReg, rootJSON['dataPerform']['gvhJS_inserted']), 1 );
			}
			else if (rootJSON['dataPerform']['gvhJS_updated'].indexOf(nReg) != -1)
			{
				rootJSON['dataPerform']['gvhJS_updated'].splice( $.inArray(nReg, rootJSON['dataPerform']['gvhJS_updated']), 1 );
			}
			else if (rootJSON['dataPerform']['gvhJS_deleted'].indexOf(nReg) != -1)
			{
				rootJSON['dataPerform']['gvhJS_deleted'].splice( $.inArray(nReg, rootJSON['dataPerform']['gvhJS_deleted']), 1 );
			}
		break;
	}

	rootJSON['data'][nReg]['gvhJS_state'] = operacion;
	if (rootJSON['panel']['patron'] == 'tabular')
	{
		rootJSON['panel']['rowActive'] = nReg;
	}
	rootJSON['dataPerform']['data'][nReg]['gvhJS_state'] = operacion;
}

/**
 * getNumReg: Devuelve el número de registros de un panel 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON] 
 */
gvh.getNumReg = function(rootJSON)
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getNumReg()'); 
	return rootJSON['panel']['numReg'];
}

/**
 * getPagActive: Devuelve la página activa del panel 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON] 
 */
gvh.getPagActive = function(rootJSON)
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getPagActive()'); 
	return parseInt( rootJSON['panel']['pagActive'] );
}

/**
 * setPagActive: Devuelve la página activa del panel 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	pag: número de página 
 */
gvh.setPagActive = function(rootJSON,pag)
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - setPagActive()');
	//gvh.showConsoleMsg('log',rootJSON);
	rootJSON['panel']['pagActive'] = parseInt( pag );
}

/**
 * getFieldsRow: Devuelve los campos de una fila 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	nReg: fila 
 */
gvh.getFieldsRow = function(rootJSON,nReg)
{
	if( !gvh.getExistReg(rootJSON,nReg) )
	{
		gvh.showConsoleMsg('error','	*** gvh_dataJSON.js - getFieldsRow() el registro '+nReg+' no existe.'); 
		return '';
	}
	
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getFieldsRow()'); 
	return rootJSON['data'][nReg]['gvhJS_fields'];
}

/**
 * getFieldsRow: Devuelve los campos de una fila 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param	nReg: fila 
 */
gvh.getDataRequired = function(rootJSON)
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getDataRequired()'); 
	return rootJSON['dataRequired'];
}

/**
 * getPagIns: Devuelve los campos de una fila 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @return	nReg: fila 
 */
gvh.getPagIns = function(rootJSON)
{
	var pagIns = rootJSON['panel']['pagInsercion'];
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getPagIns() => '+pagIns); 
	return pagIns;
}

/**
 * getRegAlter: Devuelve los registros que han sido modificados (insertar, modificar) 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @return	vReg: array registros modificados 
 */
gvh.getRegAlter = function(rootJSON)
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getRegAlter()'); 
	var vReg = [];
	var numReg = rootJSON['panel']['numReg'];
	for(var i=0;i<numReg;i++)
	{
		var state = rootJSON['data'][i]['gvhJS_state'];
		if (state != 'nada')
		{
			vReg.push(i);
		}
	}
	return vReg;
}

/**
 * getRegSelected: Devuelve los registros que han sido seleccionados 
 * @access	private
 * @param	rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @return	nReg: array registros seleccionados 
 */
gvh.getRegSelected = function(rootJSON)
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getRegSelected()');
	return rootJSON['dataPerform']['gvhJS_selected'];
	/*var vReg = [];
	var numReg = rootJSON['panel']['numReg'];
	for(var i=0;i<numReg;i++)
	{
		var selected = rootJSON['data'][i]['gvhJS_selected'];
		if (selected == 'selected')
		{
			vReg.push(i);
		}
	}	
	return vReg;*/
}

/**
 * setAllState: Devuelve los registros que han sido modificados (insertar, modificar) 
 * @access	private
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param vReg: array registros modificados 
 */
gvh.setAllState = function(rootJSON,state)
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - setAllState()'); 
	var operacion = 'add';
	if (state == 'nada')
	{
		var operacion = 'sub';
	}
	var numReg = gvh.getNumReg(rootJSON);
	for (i=0;i<numReg;i++)
	{
		gvh.setStateReg(rootJSON,state,i,operacion);
	}
}

/**
 * getIsFieldExternal: Devuelve si el campo es un external o no 
 * @access	private
 * @param rootJSON: gvh.datosJSON[claseM][panelJSON]
 * @param field: campo a comprobar
 */
gvh.getIsFieldExternal = function(rootJSON,field)
{
	gvh.showConsoleMsg('log','	*** gvh_dataJSON.js - getIsFieldExternal() '+field);
	return (rootJSON['external'][field] !== undefined);
}