#include <utility.h>
#include <ansi_c.h>
#include <cvirte.h>
#include <userint.h>
#include "HistoCreator.h"
#include "processor.h"
#include "memoryPartitions.h"
#include "primParams.h"
#include "primFunc_startTask.h"
#if defined(SCT_ROD)
	#include "ABCDChip.h"
	#include "ABCDScans.h"
#elif defined(PIXEL_ROD)

#endif

#define PATHNAME_LENGTH 300

#define FILE_ERROR      -8


/******************************************************************************
 *								 Macros      								  *
 ******************************************************************************/


#define FILL_ITEM(itemId)\
            status = InsertListItem (panel, control, -1, #itemId, itemId);
//			UIR_STATUS_CHECK(status, InsertListItem());


#define FILL_ITEM_NAME(itemName, itemId) \
	status = InsertListItem (panel, control, -1, #itemName, itemId);
//	UIR_STATUS_CHECK(status, InsertListItem());

#define SET_BIT(variable, bitNumber) ((variable)|=(1<<(bitNumber)))
#define CLEAR_BIT(variable, bitNumber) ((variable)&=(~(1<<(bitNumber))))
#define READ_BIT(variable, bitNumber) (((variable)>>(bitNumber)) & 1)

#define TEMPORARY_DATA_SUBDIR "Data\\Temporary\\"
#define TMP_FILE "tmp_histofile.bin"
#define BIN_VIEWER "Witched\\Witched.exe " /* binary viewer */
#define HC_SUBDIR "Rcc\\HistoCreator\\"
#define DEFAULT_FILE_DIR "Data\\Testing\\calibration\\"

static int panelHandle;
int status;
static char mainDir[PATHNAME_LENGTH];
static char saveDir[PATHNAME_LENGTH];
char fileName[PATHNAME_LENGTH];
UINT32 fileSize;
struct  HISTOGRAM_CTRL_TASK_IN_PARAMS histoInParams;

void fillABCDcommandTypeRing(int panel, int control, int maskCommandOption);
int readFromBinFile(const char *pathAndFileName, void *buffer, size_t numberOfBytes);
int writeToBinFile(const char *pathAndFileName, int appendNotWrite, const void *buffer, size_t numberOfBytes);
int getFileSize (char fileName[], unsigned int *fileSize);
int setUIR(	struct HISTOGRAM_CTRL_TASK_IN_PARAMS  *histoInParams);
int getUIR(	struct HISTOGRAM_CTRL_TASK_IN_PARAMS  *histoInParams);




int main (int argc, char *argv[])
{
//	if (InitCVIRTE (0, argv, 0) == 0)
//		return -1;	/* out of memory */
	if ((panelHandle = LoadPanel (0, "HistoCreator.uir", PANEL)) < 0)
		return -1;

	status=GetProjectDir(mainDir);
	mainDir[strlen(mainDir)-strlen(HC_SUBDIR)+1]=0;

	strcpy(saveDir, mainDir);
	strcat(saveDir, DEFAULT_FILE_DIR);

	fillABCDcommandTypeRing (panelHandle, PANEL_CMD0_0, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD0_1, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD0_2, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD0_3, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD0_4, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD0_5, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD1_0, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD1_1, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD1_2, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD1_3, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD1_4, 0);
	fillABCDcommandTypeRing (panelHandle, PANEL_CMD1_5, 0);
	
	fillABCDcommandTypeRing (panelHandle, PANEL_CONFIG_REGISTER, 1);
	fillABCDcommandTypeRing (panelHandle, PANEL_CONFIG_REGISTER_2, 1);

	DisplayPanel (panelHandle);
	SetCtrlVal(panelHandle, PANEL_HISTO_BASE, HISTOGRAM_DEFAULT_BASE);

	if ( argc == 2 )
	{

		getFileSize( argv[1], &fileSize);
		if(fileSize != sizeof(struct HISTOGRAM_CTRL_TASK_IN_PARAMS)) {
			MessagePopup("File Size", "File size doesn't match\nusing smaller one");
			fileSize = (fileSize < sizeof(struct HISTOGRAM_CTRL_TASK_IN_PARAMS)) ?  fileSize :  sizeof(struct HISTOGRAM_CTRL_TASK_IN_PARAMS);
		}
		readFromBinFile ( argv[1], &histoInParams, fileSize );
		setUIR(&histoInParams);
	}

	RunUserInterface ();
	DiscardPanel (panelHandle);
	return 0;
}


void fillABCDcommandTypeRing(int panel, int control, int ST){
	char message[100];
	int status;
    if(!ST) {
	    FILL_ITEM(NO_CMD);
		FILL_ITEM(L1_TRIGGER);
		FILL_ITEM(SOFT_RESET);
		FILL_ITEM(BC_RESET);
		FILL_ITEM(PULSE_INPUT_REG);
		FILL_ITEM(ENABLE_DATA_TAKING);
		FILL_ITEM(CALIBRATION_PULSE);
	    FILL_ITEM(CONFIG_REG);
		FILL_ITEM(STROBE_DELAY_REG);
		FILL_ITEM(THRESHOLD_REG);
		FILL_ITEM(BIAS_DAC_REG);
		FILL_ITEM(TRIM_DAC_REG);
		FILL_ITEM(DELAY);
	} else

/*	if(maskCommandOption){
		FILL_ITEM(MASK);
	}
    InsertListItem (panel, control, -1, "\033m-", 0);  /*separator
*/


	{
		FILL_ITEM_NAME(ST_ELAPSED     , 0x1000+ST_ELAPSED);
		FILL_ITEM_NAME(ST_VTHR        , 0x1000+ST_VTHR   );
		FILL_ITEM_NAME(ST_VCAL        , 0x1000+ST_VCAL);
		FILL_ITEM_NAME(ST_STROBE_DELAY, 0x1000+ST_STROBE_DELAY);
		FILL_ITEM_NAME(ST_PREAMP      , 0x1000+ST_PREAMP );
		FILL_ITEM_NAME(ST_SHAPER      , 0x1000+ST_SHAPER );
		FILL_ITEM_NAME(ST_TRIM        , 0x1000+ST_TRIM   );
		FILL_ITEM_NAME(ST_MASK        , 0x1000+ST_MASK   );
		FILL_ITEM_NAME(ST_ROLE        , 0x1000+ST_ROLE   );
		FILL_ITEM_NAME(ST_NMASK       , 0x1000+ST_NMASK  );
		FILL_ITEM_NAME(ST_CAL_MODE    , 0x1000+ST_CAL_MODE );
		FILL_ITEM_NAME(ST_COMPRESSION , 0x1000+ST_COMPRESSION);
		FILL_ITEM_NAME(ST_TRIM_RANGE  , 0x1000+ST_TRIM_RANGE);
		FILL_ITEM_NAME(ST_EDGE_DETECT , 0x1000+ST_EDGE_DETECT);
		FILL_ITEM_NAME(ST_SEND_MASK   , 0x1000+ST_SEND_MASK);
		FILL_ITEM_NAME(ST_ACCUMULATE  , 0x1000+ST_ACCUMULATE);
		FILL_ITEM_NAME(ST_BYPASS      , 0x1000+ST_BYPASS );
		FILL_ITEM_NAME(ST_ACTIVE      , 0x1000+ST_ACTIVE );
		FILL_ITEM_NAME(ST_TOKEN       , 0x1000+ST_TOKEN  );
		FILL_ITEM_NAME(ST_QTHR        , 0x1000+ST_QTHR   );
		FILL_ITEM_NAME(ST_QCAL        , 0x1000+ST_QCAL   );
		FILL_ITEM_NAME(ST_TARGET      , 0x1000+ST_TARGET   );
		FILL_ITEM_NAME(ST_TTHR        , 0x1000+ST_TTHR   );
		
	}
	
	return;
}


void CVICALLBACK menu (int menuBar, int menuItem, void *callbackData,
		int panel)
{
	QuitUserInterface (0);
}

int CVICALLBACK load (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	struct  HISTOGRAM_CTRL_TASK_IN_PARAMS histoInParams;
	switch (event)
		{
		case EVENT_COMMIT:

			sprintf(fileName, "");
			status=FileSelectPopup(saveDir, "*.hst","*.hst","Pick file", VAL_SELECT_BUTTON,0,0,1,1, fileName);
			if (status == VAL_NO_FILE_SELECTED) return 0;
			getFileSize(fileName, &fileSize);
			if(fileSize != sizeof(struct HISTOGRAM_CTRL_TASK_IN_PARAMS)) {
				MessagePopup("File Size", "File size doesn't match\nusing smaller one");
				fileSize = (fileSize < sizeof(struct HISTOGRAM_CTRL_TASK_IN_PARAMS)) ?  fileSize :  sizeof(struct HISTOGRAM_CTRL_TASK_IN_PARAMS);
			}
			readFromBinFile(fileName, &histoInParams, fileSize);


			setUIR(&histoInParams);


			break;
		}
	return 0;
}

int CVICALLBACK save (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	struct  HISTOGRAM_CTRL_TASK_IN_PARAMS histoInParams;

	switch (event)
		{
		case EVENT_COMMIT:

			
			getUIR(&histoInParams);
			if( (histoInParams.primParams.useRangeList == 0) && (histoInParams.default1 == 1) )
			{
				getFileSize(histoInParams.inputFile1, &fileSize);
				if (fileSize/sizeof(UINT32) != histoInParams.primParams.nBins ) 
				{
				 	MessagePopup("nBins", "Length of file1 is not equal to nBins!!");   
				 	printf("file: %d, nbins: %d\n", fileSize, histoInParams.primParams.nBins);
				}

				getFileSize(histoInParams.inputFile2, &fileSize);
				if (fileSize/sizeof(UINT32) != histoInParams.primParams.nBins ) 
				{
				 	MessagePopup("nBins", "Length of file2 is not equal to nBins!!");   
				 	printf("file: %d, nbins: %d\n", fileSize, histoInParams.primParams.nBins);
				}
			
			}
			
			
			sprintf(fileName, "");
			
			status=FileSelectPopup(saveDir, "*.hst","*.hst","Pick file", VAL_SAVE_BUTTON,0,0,1,1, fileName);
			if (status == VAL_NO_FILE_SELECTED) return 0;
			

			
			writeToBinFile(fileName, 0, &histoInParams, sizeof(struct  HISTOGRAM_CTRL_TASK_IN_PARAMS));

			break;
		}
	return 0;
}


int CVICALLBACK extView (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	struct  HISTOGRAM_CTRL_TASK_IN_PARAMS histoInParams;
	static char viewFile[PATHNAME_LENGTH];

	switch (event)
		{
		case EVENT_COMMIT:

			strcpy(fileName, mainDir);
			strcat(fileName, TEMPORARY_DATA_SUBDIR);
			strcat(fileName, TMP_FILE);
			getUIR(&histoInParams);
			writeToBinFile(fileName, 0, &histoInParams, sizeof(struct  HISTOGRAM_CTRL_TASK_IN_PARAMS));

			strcpy(viewFile, mainDir);
			strcat(viewFile, BIN_VIEWER);
			strcat(viewFile, fileName);
			status = LaunchExecutable(viewFile);

			break;
		}
	return 0;
}







int getFileSize (char fileName[], unsigned int *fileSize){

	int errorId=0;
	int status;
	char errorMessage[200];
	long fileSize_long;

	status=GetFileSize(fileName, &fileSize_long);  /* LabWindows function - not WIN32! */
	*fileSize=(unsigned int)fileSize_long;
	if(status!=0){
		errorId=FILE_ERROR;
		MessagePopup("Error!","Can't determine file size!");
	}
	return(errorId);
}



int readFromBinFile(const char *pathAndFileName, void *buffer, UINT32 numberOfBytes){

	FILE *fileHandle;
	UINT32 bytesRead;
	char errorMessage[200];
	int errorId=0;
	int status;

	errno=0;

	fileHandle = fopen (pathAndFileName, "rb"); /* open binary file for read */
	if(fileHandle==NULL){
		errorId=FILE_ERROR;
		MessagePopup("Error!","Can't open file!");
		return(errorId);
	}

	/* read file block and store it in the buffer */
	bytesRead=fread(buffer, sizeof(char), numberOfBytes, fileHandle);
	if((bytesRead!=numberOfBytes)||(bytesRead==0)){
		errorId=FILE_ERROR;
		MessagePopup("Error!","Can't read from file!");
		return(errorId);
	}

	status=fclose(fileHandle);
	if(status!=0){
		errorId=FILE_ERROR;
		MessagePopup("Error!","Can't close file!");
	}

	return(errorId);
}

int writeToBinFile(const char *pathAndFileName, int appendNotWrite, const void *buffer, UINT32 numberOfBytes){

	FILE *fileHandle;
	UINT32 bytesWritten;
	char errorMessage[200];
	int errorId=0;
	int status;



	if(appendNotWrite==0){
		fileHandle = fopen (pathAndFileName, "wb"); /* open/create binary file for write */
	} else { /* APPEND */
		fileHandle = fopen (pathAndFileName, "ab"); /* open/create binary file for append */
	}

	if(fileHandle==NULL){

		MessagePopup("Error!","Can't open file!");
		return(errorId);
	}

	/* write to file */
	bytesWritten=fwrite(buffer, sizeof(char), numberOfBytes, fileHandle);
	if(bytesWritten!=numberOfBytes){
			MessagePopup("Error!","Can't write to file!");
	}

	status=fclose(fileHandle);
	if(status!=0){
			MessagePopup("Error!","Can't close file!");
	}

	return(errorId);
}


int getUIR(	struct  HISTOGRAM_CTRL_TASK_IN_PARAMS *histoInParams)
{
	int slave, number;
	UINT16 unsignedShort;

	memset(histoInParams, 0, sizeof(struct HISTOGRAM_CTRL_TASK_IN_PARAMS));

	histoInParams->primParams.slvBits=0;
	GetCtrlVal(panelHandle, PANEL_SLV0, &slave);
	if(slave) SET_BIT(histoInParams->primParams.slvBits, 0);
	GetCtrlVal(panelHandle, PANEL_SLV1, &slave);
	if(slave) SET_BIT(histoInParams->primParams.slvBits, 1);
	GetCtrlVal(panelHandle, PANEL_SLV2, &slave);
	if(slave) SET_BIT(histoInParams->primParams.slvBits, 2);
	GetCtrlVal(panelHandle, PANEL_SLV3, &slave);
	if(slave) SET_BIT(histoInParams->primParams.slvBits, 3);

	GetCtrlVal(panelHandle, PANEL_CONFIG_SCT_SET, &histoInParams->primParams.configSctSet);
	GetCtrlVal(panelHandle, PANEL_CONFIG_REGISTER, &histoInParams->primParams.configRegister[0]);
	GetCtrlVal(panelHandle, PANEL_CONFIG_REGISTER_2, &histoInParams->primParams.configRegister[1]);
	GetCtrlVal(panelHandle, PANEL_DATA_SET, &histoInParams->primParams.dataSet);

	GetCtrlVal(panelHandle, PANEL_USE_RANGE_LIST, &histoInParams->primParams.useRangeList);
	GetTableCellRangeVals (panelHandle, PANEL_MODULE_GROUP, MakeRect(1, 1, 2, 1), histoInParams->primParams.groupRangeMap, VAL_COLUMN_MAJOR);

	if(histoInParams->primParams.useRangeList) {
		

		GetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(1, 1), &histoInParams->primParams.rangeList[0].xPair[0].x0);
		GetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(1, 2), &histoInParams->primParams.rangeList[0].xPair[1].x0);
		GetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(1, 3), &histoInParams->primParams.rangeList[0].xPair[2].x0);
		GetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(1, 4), &histoInParams->primParams.rangeList[0].xPair[3].x0);
		GetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(1, 5), &histoInParams->primParams.rangeList[0].xPair[4].x0);
		
		GetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(2, 1), &histoInParams->primParams.rangeList[0].xPair[0].delta_x);
		GetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(2, 2), &histoInParams->primParams.rangeList[0].xPair[1].delta_x);
		GetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(2, 3), &histoInParams->primParams.rangeList[0].xPair[2].delta_x);
		GetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(2, 4), &histoInParams->primParams.rangeList[0].xPair[3].delta_x);
		GetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(2, 5), &histoInParams->primParams.rangeList[0].xPair[4].delta_x);

		GetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(1, 1), &histoInParams->primParams.rangeList[1].xPair[0].x0);
		GetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(1, 2), &histoInParams->primParams.rangeList[1].xPair[1].x0);
		GetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(1, 3), &histoInParams->primParams.rangeList[1].xPair[2].x0);
		GetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(1, 4), &histoInParams->primParams.rangeList[1].xPair[3].x0);
		GetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(1, 5), &histoInParams->primParams.rangeList[1].xPair[4].x0);
		
		GetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(2, 1), &histoInParams->primParams.rangeList[1].xPair[0].delta_x);
		GetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(2, 2), &histoInParams->primParams.rangeList[1].xPair[1].delta_x);
		GetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(2, 3), &histoInParams->primParams.rangeList[1].xPair[2].delta_x);
		GetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(2, 4), &histoInParams->primParams.rangeList[1].xPair[3].delta_x);
		GetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(2, 5), &histoInParams->primParams.rangeList[1].xPair[4].delta_x);
		
		
		histoInParams->primParams.dataPtr[0] = 0;
		histoInParams->primParams.dataPtr[1] = 0;
		
		histoInParams->inputFile1[0] = 0;
		histoInParams->inputFile2[0] = 0;
		
		histoInParams->default1 = 0;
//		histoInParams->default2 = 0;		
		
		
	} else {

		GetCtrlVal(panelHandle, PANEL_DATA_PTR_1, (UINT32 *) &histoInParams->primParams.dataPtr[0]);
		GetCtrlVal(panelHandle, PANEL_DATA_PTR_2, (UINT32 *) &histoInParams->primParams.dataPtr[1]);

		GetCtrlVal(panelHandle, PANEL_DEFAULT_1, &histoInParams->default1);
//		GetCtrlVal(panelHandle, PANEL_DEFAULT_2, &histoInParams->default2);
		
		GetCtrlVal(panelHandle, PANEL_INP_FILE_1, histoInParams->inputFile1);
		GetCtrlVal(panelHandle, PANEL_INP_FILE_2, histoInParams->inputFile2);

		memset(histoInParams->primParams.rangeList, 0, 20*sizeof(FLOAT32));
	}


	GetCtrlVal(panelHandle, PANEL_CMD0_0, &histoInParams->primParams.triggerSequence[0].cmd[0]);
	GetCtrlVal(panelHandle, PANEL_CMD0_1, &histoInParams->primParams.triggerSequence[0].cmd[1]);
	GetCtrlVal(panelHandle, PANEL_CMD0_2, &histoInParams->primParams.triggerSequence[0].cmd[2]);
	GetCtrlVal(panelHandle, PANEL_CMD0_3, &histoInParams->primParams.triggerSequence[0].cmd[3]);
	GetCtrlVal(panelHandle, PANEL_CMD0_4, &histoInParams->primParams.triggerSequence[0].cmd[4]);
	GetCtrlVal(panelHandle, PANEL_CMD0_5, &histoInParams->primParams.triggerSequence[0].cmd[5]);
	GetCtrlVal(panelHandle, PANEL_DATA0_0, &histoInParams->primParams.triggerSequence[0].data[0]);
	GetCtrlVal(panelHandle, PANEL_DATA0_1, &histoInParams->primParams.triggerSequence[0].data[1]);
	GetCtrlVal(panelHandle, PANEL_DATA0_2, &histoInParams->primParams.triggerSequence[0].data[2]);
	GetCtrlVal(panelHandle, PANEL_DATA0_3, &histoInParams->primParams.triggerSequence[0].data[3]);
	GetCtrlVal(panelHandle, PANEL_DATA0_4, &histoInParams->primParams.triggerSequence[0].data[4]);
	GetCtrlVal(panelHandle, PANEL_DATA0_5, &histoInParams->primParams.triggerSequence[0].data[5]);
	GetCtrlVal(panelHandle, PANEL_CMD1_0, &histoInParams->primParams.triggerSequence[1].cmd[0]);
	GetCtrlVal(panelHandle, PANEL_CMD1_1, &histoInParams->primParams.triggerSequence[1].cmd[1]);
	GetCtrlVal(panelHandle, PANEL_CMD1_2, &histoInParams->primParams.triggerSequence[1].cmd[2]);
	GetCtrlVal(panelHandle, PANEL_CMD1_3, &histoInParams->primParams.triggerSequence[1].cmd[3]);
	GetCtrlVal(panelHandle, PANEL_CMD1_4, &histoInParams->primParams.triggerSequence[1].cmd[4]);
	GetCtrlVal(panelHandle, PANEL_CMD1_5, &histoInParams->primParams.triggerSequence[1].cmd[5]);
	GetCtrlVal(panelHandle, PANEL_DATA1_0, &histoInParams->primParams.triggerSequence[1].data[0]);
	GetCtrlVal(panelHandle, PANEL_DATA1_1, &histoInParams->primParams.triggerSequence[1].data[1]);
	GetCtrlVal(panelHandle, PANEL_DATA1_2, &histoInParams->primParams.triggerSequence[1].data[2]);
	GetCtrlVal(panelHandle, PANEL_DATA1_3, &histoInParams->primParams.triggerSequence[1].data[3]);
	GetCtrlVal(panelHandle, PANEL_DATA1_4, &histoInParams->primParams.triggerSequence[1].data[4]);
	GetCtrlVal(panelHandle, PANEL_DATA1_5, &histoInParams->primParams.triggerSequence[1].data[5]);

	GetCtrlVal(panelHandle, PANEL_PORT, &unsignedShort);
	histoInParams->primParams.port = unsignedShort;

	GetCtrlVal(panelHandle, PANEL_REP, &histoInParams->primParams.repetitions);
	GetCtrlVal(panelHandle, PANEL_NBINS, &histoInParams->primParams.nBins);
	GetCtrlVal(panelHandle, PANEL_BIN0, &histoInParams->primParams.bin0);

	GetCtrlVal(panelHandle, PANEL_CINCR0, &histoInParams->primParams.incCmd[0]);
	GetCtrlVal(panelHandle, PANEL_CINCR1, &histoInParams->primParams.incCmd[1]);
	GetCtrlVal(panelHandle, PANEL_DINCR0, &histoInParams->primParams.incData[0]);
	GetCtrlVal(panelHandle, PANEL_DINCR1, &histoInParams->primParams.incData[1]);

	GetCtrlVal(panelHandle, PANEL_CALL_LINE_LOOP, &number);
	histoInParams->primParams.calLineLoop = number;

/*	GetTableCellRangeVals (panelHandle, PANEL_GROUP_SERIAL_PORT, MakeRect(1, 1, 1, 2), histoInParams->primParams.groupSerialPort[0], VAL_ROW_MAJOR);
	GetTableCellRangeVals (panelHandle, PANEL_GROUP_SERIAL_PORT, MakeRect(2, 1, 1, 2), histoInParams->primParams.groupSerialPort[1], VAL_ROW_MAJOR);
	GetTableCellRangeVals (panelHandle, PANEL_GROUP_SERIAL_PORT, MakeRect(3, 1, 1, 2), histoInParams->primParams.groupSerialPort[2], VAL_ROW_MAJOR);
	GetTableCellRangeVals (panelHandle, PANEL_GROUP_SERIAL_PORT, MakeRect(4, 1, 1, 2), histoInParams->primParams.groupSerialPort[3], VAL_ROW_MAJOR);
*/

	GetTableCellRangeVals (panelHandle, PANEL_MODULE_GROUP_2, MakeRect(1, 1, 2, 1), histoInParams->primParams.groupSPMap, VAL_COLUMN_MAJOR);
	GetTableCellRangeVals (panelHandle, PANEL_MODULE_GROUP_3, MakeRect(1, 1, 4, 1), histoInParams->primParams.groupDSPMap, VAL_COLUMN_MAJOR);




	GetCtrlVal(panelHandle, PANEL_DISTR_TOGGLE, &histoInParams->primParams.distributionToggle);
	

	//GetTableCellRangeVals (panelHandle, PANEL_GEN_DATA, MakeRect(1, 1, 10, 10), histoInParams->primParams.genData, VAL_COLUMN_MAJOR);

	GetCtrlVal(panelHandle, PANEL_GLBL_CTRL, &histoInParams->primParams.globalCtrl);
	GetCtrlVal(panelHandle, PANEL_SYNC_LVL, &histoInParams->primParams.syncLevel);
	
	GetCtrlVal(panelHandle, PANEL_HISTO_BASE, (UINT32 *) &histoInParams->primParams.histoBase);
	GetCtrlVal(panelHandle, PANEL_EXT_SETUP, &histoInParams->primParams.extSetup);	
	GetCtrlVal(panelHandle, PANEL_DATA_PATH, &histoInParams->primParams.dataPath);	
	GetCtrlVal(panelHandle, PANEL_CAPTURE, &number);	
	histoInParams->primParams.capture = number;     
	GetCtrlVal(panelHandle, PANEL_ARRANGEMENT, &histoInParams->primParams.arrangement);		
	GetCtrlVal(panelHandle, PANEL_DATA_FORMAT, &histoInParams->primParams.dataFormat);		
	GetCtrlVal(panelHandle, PANEL_BIN_SIZE, &histoInParams->primParams.binSize);		
	
	GetTableCellRangeVals (panelHandle, PANEL_GEN_DATA, MakeRect(1, 1, 1, 10), histoInParams->primParams.genData, VAL_ROW_MAJOR);	

	return 0;
}


int setUIR(	struct  HISTOGRAM_CTRL_TASK_IN_PARAMS *histoInParams)
{
	SetCtrlVal(panelHandle, PANEL_SLV0, READ_BIT(histoInParams->primParams.slvBits, 0));
	SetCtrlVal(panelHandle, PANEL_SLV1, READ_BIT(histoInParams->primParams.slvBits, 1));
	SetCtrlVal(panelHandle, PANEL_SLV2, READ_BIT(histoInParams->primParams.slvBits, 2));
	SetCtrlVal(panelHandle, PANEL_SLV3, READ_BIT(histoInParams->primParams.slvBits, 3));



	SetCtrlVal(panelHandle, PANEL_CONFIG_SCT_SET, histoInParams->primParams.configSctSet);
	SetCtrlVal(panelHandle, PANEL_CONFIG_REGISTER, histoInParams->primParams.configRegister[0]);
	SetCtrlVal(panelHandle, PANEL_CONFIG_REGISTER_2, histoInParams->primParams.configRegister[1]);
	SetCtrlVal(panelHandle, PANEL_DATA_SET, histoInParams->primParams.dataSet);

	SetCtrlVal(panelHandle, PANEL_USE_RANGE_LIST, histoInParams->primParams.useRangeList);


	SetInputMode(panelHandle, PANEL_TABLE_1, histoInParams->primParams.useRangeList);
	SetInputMode(panelHandle, PANEL_TABLE_2, histoInParams->primParams.useRangeList);

	SetInputMode(panelHandle, PANEL_TEXTMSG, !histoInParams->primParams.useRangeList);

	SetInputMode(panelHandle, PANEL_DATA_PTR_1, !histoInParams->primParams.useRangeList);
	SetInputMode(panelHandle, PANEL_DATA_PTR_2, !histoInParams->primParams.useRangeList);
	
	SetInputMode(panelHandle, PANEL_DEFAULT_1, !histoInParams->primParams.useRangeList);
//	SetInputMode(panelHandle, PANEL_DEFAULT_2, !histoInParams->primParams.useRangeList);
	
	SetInputMode(panelHandle, PANEL_INP_FILE_1, !histoInParams->primParams.useRangeList);
	SetInputMode(panelHandle, PANEL_INP_FILE_2, !histoInParams->primParams.useRangeList);

	if(histoInParams->primParams.useRangeList) {

		SetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(1, 1), histoInParams->primParams.rangeList[0].xPair[0].x0);
		SetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(1, 2), histoInParams->primParams.rangeList[0].xPair[1].x0);
		SetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(1, 3), histoInParams->primParams.rangeList[0].xPair[2].x0);
		SetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(1, 4), histoInParams->primParams.rangeList[0].xPair[3].x0);
		SetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(1, 5), histoInParams->primParams.rangeList[0].xPair[4].x0);
		
		SetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(2, 1), histoInParams->primParams.rangeList[0].xPair[0].delta_x);
		SetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(2, 2), histoInParams->primParams.rangeList[0].xPair[1].delta_x);
		SetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(2, 3), histoInParams->primParams.rangeList[0].xPair[2].delta_x);
		SetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(2, 4), histoInParams->primParams.rangeList[0].xPair[3].delta_x);
		SetTableCellVal (panelHandle, PANEL_TABLE_1, MakePoint(2, 5), histoInParams->primParams.rangeList[0].xPair[4].delta_x);

		SetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(1, 1), histoInParams->primParams.rangeList[1].xPair[0].x0);
		SetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(1, 2), histoInParams->primParams.rangeList[1].xPair[1].x0);
		SetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(1, 3), histoInParams->primParams.rangeList[1].xPair[2].x0);
		SetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(1, 4), histoInParams->primParams.rangeList[1].xPair[3].x0);
		SetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(1, 5), histoInParams->primParams.rangeList[1].xPair[4].x0);
		
		SetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(2, 1), histoInParams->primParams.rangeList[1].xPair[0].delta_x);
		SetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(2, 2), histoInParams->primParams.rangeList[1].xPair[1].delta_x);
		SetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(2, 3), histoInParams->primParams.rangeList[1].xPair[2].delta_x);
		SetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(2, 4), histoInParams->primParams.rangeList[1].xPair[3].delta_x);
		SetTableCellVal (panelHandle, PANEL_TABLE_2, MakePoint(2, 5), histoInParams->primParams.rangeList[1].xPair[4].delta_x);
		
		
	} else {

		if(histoInParams->default1)
		{
		 	SetInputMode(panelHandle, PANEL_INP_FILE_1, 1);
		 	SetCtrlVal(panelHandle, PANEL_INP_FILE_1, histoInParams->inputFile1);

		 	SetInputMode(panelHandle, PANEL_INP_FILE_2, 1);
		 	SetCtrlVal(panelHandle, PANEL_INP_FILE_2, histoInParams->inputFile2);

			SetCtrlVal(panelHandle, PANEL_DEFAULT_1, 1);
			
			SetCtrlVal(panelHandle, PANEL_DATA_PTR_1, DEFAULT);
			SetCtrlAttribute(panelHandle, PANEL_DATA_PTR_1, ATTR_CTRL_MODE, VAL_INDICATOR);	

			SetCtrlVal(panelHandle, PANEL_DATA_PTR_2, DEFAULT);
			SetCtrlAttribute(panelHandle, PANEL_DATA_PTR_2, ATTR_CTRL_MODE, VAL_INDICATOR);	

		
		}
		else
		{
			SetInputMode(panelHandle, PANEL_INP_FILE_1, 0);
			SetInputMode(panelHandle, PANEL_INP_FILE_2, 0);
			SetCtrlAttribute(panelHandle, PANEL_DATA_PTR_1, ATTR_CTRL_MODE, VAL_HOT);	
			SetCtrlAttribute(panelHandle, PANEL_DATA_PTR_2, ATTR_CTRL_MODE, VAL_HOT);	
			SetCtrlVal(panelHandle, PANEL_DATA_PTR_1, (unsigned int) histoInParams->primParams.dataPtr[0]);
			SetCtrlVal(panelHandle, PANEL_DATA_PTR_2, (unsigned int) histoInParams->primParams.dataPtr[1]);
			
			SetCtrlVal(panelHandle, PANEL_DEFAULT_1, 0);
		}

	}

	SetTableCellRangeVals (panelHandle, PANEL_MODULE_GROUP, MakeRect(1, 1, 2, 1), histoInParams->primParams.groupRangeMap, VAL_COLUMN_MAJOR);

	SetCtrlVal(panelHandle, PANEL_CMD0_0, histoInParams->primParams.triggerSequence[0].cmd[0]);
	SetCtrlVal(panelHandle, PANEL_CMD0_1, histoInParams->primParams.triggerSequence[0].cmd[1]);
	SetCtrlVal(panelHandle, PANEL_CMD0_2, histoInParams->primParams.triggerSequence[0].cmd[2]);
	SetCtrlVal(panelHandle, PANEL_CMD0_3, histoInParams->primParams.triggerSequence[0].cmd[3]);
	SetCtrlVal(panelHandle, PANEL_CMD0_4, histoInParams->primParams.triggerSequence[0].cmd[4]);
	SetCtrlVal(panelHandle, PANEL_CMD0_5, histoInParams->primParams.triggerSequence[0].cmd[5]);
	SetCtrlVal(panelHandle, PANEL_DATA0_0, histoInParams->primParams.triggerSequence[0].data[0]);
	SetCtrlVal(panelHandle, PANEL_DATA0_1, histoInParams->primParams.triggerSequence[0].data[1]);
	SetCtrlVal(panelHandle, PANEL_DATA0_2, histoInParams->primParams.triggerSequence[0].data[2]);
	SetCtrlVal(panelHandle, PANEL_DATA0_3, histoInParams->primParams.triggerSequence[0].data[3]);
	SetCtrlVal(panelHandle, PANEL_DATA0_4, histoInParams->primParams.triggerSequence[0].data[4]);
	SetCtrlVal(panelHandle, PANEL_DATA0_5, histoInParams->primParams.triggerSequence[0].data[5]);
	SetCtrlVal(panelHandle, PANEL_CMD1_0, histoInParams->primParams.triggerSequence[1].cmd[0]);
	SetCtrlVal(panelHandle, PANEL_CMD1_1, histoInParams->primParams.triggerSequence[1].cmd[1]);
	SetCtrlVal(panelHandle, PANEL_CMD1_2, histoInParams->primParams.triggerSequence[1].cmd[2]);
	SetCtrlVal(panelHandle, PANEL_CMD1_3, histoInParams->primParams.triggerSequence[1].cmd[3]);
	SetCtrlVal(panelHandle, PANEL_CMD1_4, histoInParams->primParams.triggerSequence[1].cmd[4]);
	SetCtrlVal(panelHandle, PANEL_CMD1_5, histoInParams->primParams.triggerSequence[1].cmd[5]);
	SetCtrlVal(panelHandle, PANEL_DATA1_0, histoInParams->primParams.triggerSequence[1].data[0]);
	SetCtrlVal(panelHandle, PANEL_DATA1_1, histoInParams->primParams.triggerSequence[1].data[1]);
	SetCtrlVal(panelHandle, PANEL_DATA1_2, histoInParams->primParams.triggerSequence[1].data[2]);
	SetCtrlVal(panelHandle, PANEL_DATA1_3, histoInParams->primParams.triggerSequence[1].data[3]);
	SetCtrlVal(panelHandle, PANEL_DATA1_4, histoInParams->primParams.triggerSequence[1].data[4]);
	SetCtrlVal(panelHandle, PANEL_DATA1_5, histoInParams->primParams.triggerSequence[1].data[5]);

	SetCtrlVal(panelHandle, PANEL_PORT, histoInParams->primParams.port);

	SetCtrlVal(panelHandle, PANEL_REP, histoInParams->primParams.repetitions);
	SetCtrlVal(panelHandle, PANEL_NBINS, histoInParams->primParams.nBins);
	SetCtrlVal(panelHandle, PANEL_BIN0, histoInParams->primParams.bin0);

	SetCtrlVal(panelHandle, PANEL_CINCR0, histoInParams->primParams.incCmd[0]);
	SetCtrlVal(panelHandle, PANEL_CINCR1, histoInParams->primParams.incCmd[1]);
	SetCtrlVal(panelHandle, PANEL_DINCR0, histoInParams->primParams.incData[0]);
	SetCtrlVal(panelHandle, PANEL_DINCR1, histoInParams->primParams.incData[1]);

	SetCtrlVal(panelHandle, PANEL_CALL_LINE_LOOP, (int) histoInParams->primParams.calLineLoop);

/*	SetTableCellRangeVals (panelHandle, PANEL_GROUP_SERIAL_PORT, MakeRect(1, 1, 1, 2), histoInParams->primParams.groupSerialPort[0], VAL_ROW_MAJOR);
	SetTableCellRangeVals (panelHandle, PANEL_GROUP_SERIAL_PORT, MakeRect(2, 1, 1, 2), histoInParams->primParams.groupSerialPort[1], VAL_ROW_MAJOR);
	SetTableCellRangeVals (panelHandle, PANEL_GROUP_SERIAL_PORT, MakeRect(3, 1, 1, 2), histoInParams->primParams.groupSerialPort[2], VAL_ROW_MAJOR);
	SetTableCellRangeVals (panelHandle, PANEL_GROUP_SERIAL_PORT, MakeRect(4, 1, 1, 2), histoInParams->primParams.groupSerialPort[3], VAL_ROW_MAJOR);
*/
	SetTableCellRangeVals (panelHandle, PANEL_MODULE_GROUP_2, MakeRect(1, 1, 2, 1), histoInParams->primParams.groupSPMap, VAL_COLUMN_MAJOR);
	SetTableCellRangeVals (panelHandle, PANEL_MODULE_GROUP_3, MakeRect(1, 1, 4, 1), histoInParams->primParams.groupDSPMap, VAL_COLUMN_MAJOR);

	
	SetCtrlVal(panelHandle, PANEL_DISTR_TOGGLE, histoInParams->primParams.distributionToggle);

//	SetTableCellRangeVals (panelHandle, PANEL_GEN_DATA, MakeRect(1, 1, 10, 10), histoInParams->primParams.genData, VAL_COLUMN_MAJOR);

	SetCtrlVal(panelHandle, PANEL_GLBL_CTRL, histoInParams->primParams.globalCtrl);
	SetCtrlVal(panelHandle, PANEL_SYNC_LVL, histoInParams->primParams.syncLevel);

	SetCtrlVal(panelHandle, PANEL_HISTO_BASE, (UINT32) histoInParams->primParams.histoBase);
	SetCtrlVal(panelHandle, PANEL_EXT_SETUP, histoInParams->primParams.extSetup);	
	SetCtrlVal(panelHandle, PANEL_DATA_PATH, histoInParams->primParams.dataPath);	
	SetCtrlVal(panelHandle, PANEL_CAPTURE, histoInParams->primParams.capture);	

	SetCtrlVal(panelHandle, PANEL_ARRANGEMENT, histoInParams->primParams.arrangement);		
	SetCtrlVal(panelHandle, PANEL_DATA_FORMAT, histoInParams->primParams.dataFormat);		
	SetCtrlVal(panelHandle, PANEL_BIN_SIZE, histoInParams->primParams.binSize);		

	SetTableCellRangeVals (panelHandle, PANEL_GEN_DATA, MakeRect(1, 1, 1, 10), histoInParams->primParams.genData, VAL_ROW_MAJOR);	

	return 0;
}

int CVICALLBACK histoCreate (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	UINT8 rangeList;
	UINT32 value, value2, status;
	char fileName1[PATHNAME_LENGTH], fileName2[PATHNAME_LENGTH];
	switch (event)
		{
		case EVENT_VAL_CHANGED:
			switch (control)
				{
				case PANEL_USE_RANGE_LIST:
					GetCtrlVal(panel, control, &rangeList);

					SetInputMode(panel, PANEL_TABLE_1, rangeList);
					SetInputMode(panel, PANEL_TABLE_2, rangeList);
		//			SetInputMode(panel, PANEL_MODULE_GROUP, rangeList);
					SetInputMode(panel, PANEL_TEXTMSG, !rangeList);
					SetInputMode(panel, PANEL_DATA_PTR_1, !rangeList);
					SetInputMode(panel, PANEL_DATA_PTR_2, !rangeList);

					SetInputMode(panel, PANEL_DEFAULT_1, !rangeList);
//					SetInputMode(panel, PANEL_DEFAULT_2, !rangeList);

					if (rangeList)
					{
			
						SetInputMode(panel, PANEL_INP_FILE_1, 0);
						SetInputMode(panel, PANEL_INP_FILE_2, 0);
					}
					else
					{
						GetCtrlVal(panel, PANEL_DEFAULT_1, &value);
						SetInputMode(panel, PANEL_INP_FILE_1, value);
						SetInputMode(panel, PANEL_INP_FILE_2, value);
					}
					break;
				case PANEL_DEFAULT_1:
					GetCtrlVal (panel, control, &value);
					if(value)
					{
						status = SetCtrlAttribute(panel, PANEL_DATA_PTR_1, ATTR_CTRL_MODE, VAL_INDICATOR);
						status = SetCtrlAttribute(panel, PANEL_DATA_PTR_2, ATTR_CTRL_MODE, VAL_INDICATOR);  
						
						status = SetCtrlVal(panel, PANEL_DATA_PTR_1, DEFAULT);
						status = SetCtrlVal(panel, PANEL_DATA_PTR_2, DEFAULT);
						
						status = SetInputMode(panel, PANEL_INP_FILE_1, 1);
						status = SetInputMode(panel, PANEL_INP_FILE_2, 1);

						status = GetCtrlVal(panel, PANEL_INP_FILE_1, fileName1);						
						
						status=FileSelectPopup(saveDir, "*.bin","*.bin","Pick file 1", VAL_SELECT_BUTTON,0,0,1,1, fileName1);
						if( (status != VAL_EXISTING_FILE_SELECTED) && (fileName1[0] == 0x0 ) )
						{
							return(1);
						}
						SetCtrlVal(panel, PANEL_INP_FILE_1, fileName1);

						status = GetCtrlVal(panel, PANEL_INP_FILE_2, fileName2);						
						
						status=FileSelectPopup(saveDir, "*.bin","*.bin","Pick file 2", VAL_SELECT_BUTTON,0,0,1,1, fileName2);

						if( (status != VAL_EXISTING_FILE_SELECTED) && (fileName2[0] == 0x0 )  )
						{
							return(1);
						}
						SetCtrlVal(panel, PANEL_INP_FILE_2, fileName2);

					} else {
						status = SetCtrlAttribute(panel, PANEL_DATA_PTR_1, ATTR_CTRL_MODE, VAL_HOT);
						status = SetCtrlAttribute(panel, PANEL_DATA_PTR_2, ATTR_CTRL_MODE, VAL_HOT);
						status = SetInputMode(panel, PANEL_DATA_PTR_1, 1);
						status = SetInputMode(panel, PANEL_DATA_PTR_2, 1);
						status = SetCtrlVal(panel, PANEL_DATA_PTR_1, 0);
						status = SetCtrlVal(panel, PANEL_DATA_PTR_2, 0);
						status = SetInputMode(panel, PANEL_INP_FILE_1, 0);
						status = SetInputMode(panel, PANEL_INP_FILE_2, 0);
					}
					break;
				default:
					break;
				}
			
			break;
		case EVENT_LEFT_CLICK:
			switch (control)
			{
				case PANEL_INP_FILE_1:
					status=FileSelectPopup(saveDir, "*.bin","*.bin","Pick file", VAL_SELECT_BUTTON,0,0,1,1, fileName1);

					if(status != VAL_EXISTING_FILE_SELECTED)
					{
						return(1);
					}
					SetCtrlVal(panel, PANEL_INP_FILE_1, fileName1);
				
				
				break;
				case PANEL_INP_FILE_2:
					status=FileSelectPopup(saveDir, "*.bin","*.bin","Pick file", VAL_SELECT_BUTTON,0,0,1,1, fileName2);
					if(status != VAL_EXISTING_FILE_SELECTED)
					{
						return(1);
					}
					SetCtrlVal(panel, PANEL_INP_FILE_2, fileName2);
				
					break;
				
				default:
					break;
			}
		default:
			break;
		}
	return 0;
}