/******************************************************************************
 *
 *  Title  : mainUir.c
 *  Version 0.0
 *
 *  Description: main user iterface callback functions.
 *  Related files: mainUir.uir
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/


/******************************************************************************
 *                              Header files                                  *
 ******************************************************************************/

#include <ansi_c.h>
#include "mainUir.h"
#include "uirUtility.h"
#include "threadUtility.h"
#include "fileUtility.h"
#include "hostUtility.h"
#include "comRegDfns.h"
#include "primListEditUir.h"
#include "loadExitHost.h"
#include "vmeHpiUtility.h"
#include "fillUirControls.h"
#include "commandListEditUir.h"
#include "rodMemoryUir.h"
#include "fpgaUir.h" 
#include <nivxi.h>

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

#define SET_HOST_THREAD_PRIORITY(hostThreadName) \
for(hostNumber=0; hostNumber<MAXRODS; ++hostNumber){\
	host=global.host[hostNumber];\
	if(host==NULL) continue;\
	host->hostThreadName.priority=priorityLevel;\
	errorId=setThreadPriority(host->hostThreadName.handle, priorityLevel);\
	ERROR_CHECK(errorId, setThreadPriority(hostThreadName.handle));\
}

#define LOAD_HOST(slotNumber) \
	if(global.host[HOST_INDEX(slotNumber)]==NULL){\
		GetCtrlVal(panel, NEWROD_PN_SLOT_##slotNumber, &value);\
		if(value){\
			errorId=loadNewHost(&global, slotNumber);\
			ERROR_CHECK(errorId, loadNewHost());\
			status=SetInputMode(panel, NEWROD_PN_SLOT_##slotNumber, 0);\
			UIR_STATUS_CHECK(status, SetInputMode());\
		}\
	}

#define EXIT_HOST(slotNumber) \
	SetCtrlVal(global.panel.loadHost, NEWROD_PN_SLOT_##slotNumber, 0);\
	status=SetInputMode(global.panel.loadHost, NEWROD_PN_SLOT_##slotNumber, 1);\
	UIR_STATUS_CHECK(status, SetInputMode());


/******************************************************************************
 *                        LW_CVI callback functions                           *
 ******************************************************************************/

/*=============================================================================
 *                               runResman()
 *=============================================================================
 *
 *   Run NI VME resource manager.
 *
 */

int CVICALLBACK runResman (int panel, int control, int event, void *callbackData, int eventData1, int eventData2){

	int status;
	int programHandle;
	ERROR_ID errorId;

	if(event==EVENT_COMMIT){

		/* stop Communication loop */
		if(global.option.commLoopRunning){
			errorId=stopCommunicationLoop(&global);
			ERROR_CHECK(errorId, stopCommunicationLoop());
		}
		if(global.option.vme){

			/*
			 *  Close VXI
			 */
			status=CloseVXIlibrary();
			if(status!=0){
				errorId=FATAL_ERROR;
				programError(__FILE__, __LINE__, errorId, "CloseVXIlibrary()", status,"");
			}
		}

		/* run resource manager */
		status=LaunchExecutableEx(VME_RESOURCE_MANAGER, LE_SHOWNORMAL, &programHandle);
		if(status==-3) status=LaunchExecutableEx(VME_RESOURCE_MANAGER_2, LE_SHOWNORMAL, &programHandle); 
		if(status!=0){
			programError(__FILE__, __LINE__, PROGRAM_ERROR, "LaunchExecutable()", status, "");
		}else{
			while(1){
				status=ExecutableHasTerminated(programHandle);
				if(status==1) break;
				Sleep(200);
			}
		}

		/*
		 *  VXI initialization
		 */
		status=InitVXIlibrary();
		if(status!=0){
			errorId=FATAL_ERROR;
			programError(__FILE__, __LINE__, errorId, "InitVXIlibrary()", status,"");
			return(errorId);
		}

		global.option.vme=1; //!!!

	}
	return 0;
}
/*=============================================================================
 *                               resetAllRods()
 *=============================================================================
 *
 *   Resets all rods.
 *
 */

int CVICALLBACK resetAllRods(int panel, int control, int event, void *callbackData, int eventData1, int eventData2){

	int status;
	int programHandle;
	ERROR_ID errorId;
	int hostIndex;
	int commLoopRunningSave;
	struct HOST *host;

	if(event==EVENT_COMMIT){

		status=ConfirmPopup ("", "Reset All Rods?");
		UIR_STATUS_CHECK(status, ConfirmPopup());
		if(status<=0) return 0;

		/* stop Communication loop */
		commLoopRunningSave=global.option.commLoopRunning;
		if(commLoopRunningSave){
			errorId=stopCommunicationLoop(&global);
			ERROR_CHECK(errorId, stopCommunicationLoop());
		}
		for(hostIndex=0; hostIndex<MAXRODS; ++hostIndex){
			host=global.host[hostIndex];
		    if(host==NULL) continue;

			errorId=resetRod(host);
			HOST_ERROR_CHECK(errorId, host, resetRod());
		}

		if(commLoopRunningSave){
			errorId=resumeCommunicationLoop(&global);
			ERROR_CHECK(errorId, resumeCommunicationLoop());
		}
	}
	return 0;
}
/*=============================================================================
 *                               sysReset()
 *=============================================================================
 *
 *   system reset
 *
 */

int CVICALLBACK sysReset(int panel, int control, int event, void *callbackData, int eventData1, int eventData2){

	int status;
	int programHandle;
	ERROR_ID errorId;
	int hostIndex;
	int commLoopRunningSave;
	struct HOST *host;

	if(event==EVENT_COMMIT){

		status=ConfirmPopup ("", "System Reset?");
		UIR_STATUS_CHECK(status, ConfirmPopup());
		if(status<=0) return 0;

		/* stop Communication loop */
		commLoopRunningSave=global.option.commLoopRunning;
		if(commLoopRunningSave){
			errorId=stopCommunicationLoop(&global);
			ERROR_CHECK(errorId, stopCommunicationLoop());
		}

		status = AssertSysreset (-1, 0);
		if(status!=0){
			ERROR_CHECK(errorId, AssertSysreset());
			return(-1);
		}	
		
		/* run RESMAN */
		errorId=runResman (panel, MAIN_RUN_RESMAN, EVENT_COMMIT, 0, 0, 0);
		ERROR_CHECK(errorId, runResman()); 
	}
	return 0;
}

/*=============================================================================
 *                               hostMenu()
 *=============================================================================
 *
 *  Host menu.
 *
 */
void CVICALLBACK hostMenu(int menubar, int menuItem, void *callbackData, int panel){

	unsigned char hostIndex;
	int panelHandle, line;
	ERROR_ID errorId;
	unsigned long i;
	int status;
	struct HOST *host;
	int commLoopRunningSave;
	char subdir[300];
	int refreshOn;

	GetCtrlVal(panel, ROD_HOST_INDEX, &hostIndex);
	host=global.host[hostIndex];

	switch (menuItem) {
		case RODN_MENU_GO_TO_MAIN:
			status=SetActivePanel(global.panel.main);
			UIR_STATUS_CHECK(status, SetActivePanel());
			return;
		case RODN_MENU_SHOW_TXT_WIND_ERROR:
			panelHandle=host->panel.txtBuff[ERR_BUFF];
			break;
		case RODN_MENU_SHOW_TXT_WIND_INFO:
			panelHandle=host->panel.txtBuff[INFO_BUFF];
			break;
		case RODN_MENU_SHOW_TXT_WIND_DIAG:
			panelHandle=host->panel.txtBuff[DIAG_BUFF];
			break;
		case RODN_MENU_SHOW_TXT_WIND_XFER:
			panelHandle=host->panel.txtBuff[XFER_BUFF];
			break;
	
		case RODN_MENU_DSP_MON:
			panelHandle=host->panel.dspMonitor;
			break;
		case RODN_MENU_LIST_EDIT_PRIM:
			panelHandle=global.panel.primListEdit;
			break;
		case RODN_MENU_LIST_EDIT_COMMAND:
			panelHandle=global.panel.commandListEdit;
			break;
		case RODN_MENU_COMMAND_WINDOW:
			panelHandle=host->panel.commandListStatus;
			break;
		case RODN_MENU_ROD_DATA:
			strcpy(subdir, "Explorer.exe ");
			strcat(subdir, host->dataDir);
			status = LaunchExecutable (subdir);
			UIR_STATUS_CHECK(status, LaunchExecutable());
			return;
		case RODN_MENU_RESET_ROD:

			status=ConfirmPopup ("", "Reset Rod?");
			UIR_STATUS_CHECK(status, ConfirmPopup());
			if(status<=0) return;

			errorId=resetRod(host);
			HOST_ERROR_CHECK(errorId, host, resetRod());

			return;
		case RODN_MENU_EXIT_ROD:
			if(ConfirmPopup ("RCC PROGRAM", "Exit this ROD?")==0){
				return;
			}

			//refreshOn=global.option.displayRefresh;
			//global.option.displayRefresh=FALSE;
			//SetCtrlVal(global.panel.main, MAIN_REFRESH_DISP, global.option.displayRefresh);

			host->option.rodEnabled=FALSE;
			host->option.hostExit=TRUE;
			commLoopRunningSave=global.option.commLoopRunning;
			if(commLoopRunningSave){
				errorId=stopCommunicationLoop(&global);
				ERROR_CHECK(errorId, stopCommunicationLoop());
			}

			errorId=exitHost(&global.host[hostIndex], &global);  /* Pass real pointer NOT exitHost(&host, &global)!!! */
			ERROR_CHECK(errorId, exitHost());

			switch(hostIndex){
				case 0: EXIT_HOST(5);
					break;
				case 1: EXIT_HOST(6);
					break;
				case 2: EXIT_HOST(7);
					break;
				case 3: EXIT_HOST(8);
					break;
				case 4: EXIT_HOST(9);
					break;
				case 5: EXIT_HOST(10);
					break;
				case 6: EXIT_HOST(11);
					break;
				case 7: EXIT_HOST(12);
					break;
					//case 8 -TIM slot!!!
				case 9: EXIT_HOST(14);
					break;
				case 10: EXIT_HOST(15);
					break;
				case 11: EXIT_HOST(16);
					break;
				case 12: EXIT_HOST(17);
					break;
				case 13: EXIT_HOST(18);
					break;
				case 14: EXIT_HOST(19);
					break;
				case 15: EXIT_HOST(20);
					break;
				case 16: EXIT_HOST(21);
					break;
			}

			if(commLoopRunningSave&&(global.hostCount>=1)){
				errorId=resumeCommunicationLoop(&global);
				ERROR_CHECK(errorId, resumeCommunicationLoop());
			}
			//global.option.displayRefresh=refreshOn;
			//SetCtrlVal(global.panel.main, MAIN_REFRESH_DISP, global.option.displayRefresh);

			return;
		default:
			programError(__FILE__, __LINE__, PROGRAM_ERROR, "showTextWindow()", 0,"-non known control.");

	}

	status=DisplayPanel(panelHandle);
	UIR_STATUS_CHECK(status, DisplayPanel());
	return;
}

/*=============================================================================
 *                               dspMonMenu()
 *=============================================================================
 *
 *  dspMonMenu menu.
 *
 */
void CVICALLBACK dspMonMenu(int menubar, int menuItem, void *callbackData, int panel){

	unsigned char hostIndex;
	int panelHandle, line;
	ERROR_ID errorId;
	unsigned long i;
	int status;
	struct HOST *host;
	char subdir[300];

	GetCtrlVal(panel, DSPMONP_HOST_INDEX, &hostIndex);
	host=global.host[hostIndex];

	switch (menuItem) {
		case DSPMON_HIDE:
			status=HidePanel(host->panel.dspMonitor);
			UIR_STATUS_CHECK(status, HidePanel());
			break;
		default:
			programError(__FILE__, __LINE__, PROGRAM_ERROR, "dspMonMenu()", 0,"-non known control.");

	}

	return;
}

/*=============================================================================
 *                               dspMonitor()
 *=============================================================================
 *
 *  dspMonitor.
 *
 */
#define READ_BUTTON(controlBase, index) \
	case controlBase##index: GetCtrlVal(panel, controlBase##index, &bit);\
		GetCtrlVal(panel, DSPMONP_EDIT_FIELD, &value);\
		if(bit){ SET_BIT(value, index);}else{ CLEAR_BIT(value, index);}\
		SetCtrlVal(panel, DSPMONP_EDIT_FIELD, value);\
		break;

#define	REG_CLICK(reg) \
case DSPMONP_##reg:\
	SetCtrlVal(panel, DSPMONP_REGISTERS_RING_READ, reg);\
	updateBitField(panel);\
	break;
	



int  CVICALLBACK dspMonitor(int panel, int control, int event, void *callbackData, int eventData1, int eventData2){

	unsigned char hostIndex;
	char commandLineString[300]=EXTERNAL_EDITOR;
	int panelHandle, line;
	ERROR_ID errorId;
	unsigned long i;
	int status;
	struct HOST *host;
	char subdir[300];
	unsigned int value, bit, reg;
	int master;
	int dspType;
	char string[300];
	unsigned int revision;

	switch(event){
	case EVENT_COMMIT:

		GetCtrlVal(panel, DSPMONP_HOST_INDEX, &hostIndex);
		host=global.host[hostIndex];

		switch (control) {
			case DSPMONP_COPY:
				GetCtrlVal(panel, DSPMONP_REGISTERS_RING_READ, &value); 
				SetCtrlVal(panel, DSPMONP_REGISTERS_RING_WRITE, value);  
				GetCtrlVal(panel, DSPMONP_CURR_VAL, &value);
				SetCtrlVal(panel, DSPMONP_EDIT_FIELD, value);
				(void)dspMonitor(panel, DSPMONP_EDIT_FIELD, EVENT_VAL_CHANGED, callbackData, eventData1, eventData2);
				break;
			case DSPMONP_READ_REGS:
				
				errorId=refreshDspRegs(host);
				HOST_ERROR_CHECK(errorId, host, refreshDspRegs());

				break;
			case DSPMONP_WRITE:
				GetCtrlVal(panel, DSPMONP_EDIT_FIELD, &value);
				GetCtrlVal(panel, DSPMONP_REGISTERS_RING_WRITE, &reg);
				
				GetCtrlVal(panel, DSPMONP_DSP_TYPE, &dspType);
	
				if(dspType==-1){ /* MDSP */
		
					errorId=RWmaster(WRITE, host->slotNumber, reg, &value, 1, NO_HPIA_AUTOINCREMENT, 0);
					ERROR_CHECK(errorId, RWmaster());
	
				}else{ /* slave */
	
					GetCtrlVal(host->panel.parent, ROD_ROD_REV, &revision);
					if(revision==0xE){
						reg=(reg|0x00010000)&0x1FFFF;
					}	
					errorId=RWslave(WRITE, host->slotNumber, dspType, reg, &value, 1, 0);
					ERROR_CHECK(errorId, RWmaster());
		
				}

				errorId=refreshDspRegs(host);
				HOST_ERROR_CHECK(errorId, host, refreshDspRegs());
				
				break;
			case DSPMONP_VIEW_CRDH:
				
				strcpy(string, commandLineString);
				strcat(string, " ");
				strcat(string, global.mainDir);
				strcat(string, "Rcc\\CommonWithDspCode\\comRegDfns.h");

				status=LaunchExecutable (string);
				if(status!=0){
					programError(__FILE__, __LINE__, PROGRAM_ERROR, "LaunchExecutable()", status, "");
				}



				break;
		default: break;
		}
		break;
	case EVENT_VAL_CHANGED: 

		switch (control) {
			case DSPMONP_EDIT_FIELD:
				GetCtrlVal(panel, control, &value);
				SetCtrlVal(panel, DSPMONP_BIT_0, READ_BIT(value, 0));
				SetCtrlVal(panel, DSPMONP_BIT_1, READ_BIT(value, 1));
				SetCtrlVal(panel, DSPMONP_BIT_2, READ_BIT(value, 2));
				SetCtrlVal(panel, DSPMONP_BIT_3, READ_BIT(value, 3));
				SetCtrlVal(panel, DSPMONP_BIT_4, READ_BIT(value, 4));
				SetCtrlVal(panel, DSPMONP_BIT_5, READ_BIT(value, 5));
				SetCtrlVal(panel, DSPMONP_BIT_6, READ_BIT(value, 6));
				SetCtrlVal(panel, DSPMONP_BIT_7, READ_BIT(value, 7));
				SetCtrlVal(panel, DSPMONP_BIT_8, READ_BIT(value, 8));
				SetCtrlVal(panel, DSPMONP_BIT_9, READ_BIT(value, 9));
				SetCtrlVal(panel, DSPMONP_BIT_10, READ_BIT(value, 10));
				SetCtrlVal(panel, DSPMONP_BIT_11, READ_BIT(value, 11));
				SetCtrlVal(panel, DSPMONP_BIT_12, READ_BIT(value, 12));
				SetCtrlVal(panel, DSPMONP_BIT_13, READ_BIT(value, 13));
				SetCtrlVal(panel, DSPMONP_BIT_14, READ_BIT(value, 14));
				SetCtrlVal(panel, DSPMONP_BIT_15, READ_BIT(value, 15));
				SetCtrlVal(panel, DSPMONP_BIT_16, READ_BIT(value, 16));
				SetCtrlVal(panel, DSPMONP_BIT_17, READ_BIT(value, 17));
				SetCtrlVal(panel, DSPMONP_BIT_18, READ_BIT(value, 18));
				SetCtrlVal(panel, DSPMONP_BIT_19, READ_BIT(value, 19));
				SetCtrlVal(panel, DSPMONP_BIT_20, READ_BIT(value, 20));
				SetCtrlVal(panel, DSPMONP_BIT_21, READ_BIT(value, 21));
				SetCtrlVal(panel, DSPMONP_BIT_22, READ_BIT(value, 22));
				SetCtrlVal(panel, DSPMONP_BIT_23, READ_BIT(value, 23));
				SetCtrlVal(panel, DSPMONP_BIT_24, READ_BIT(value, 24));
				SetCtrlVal(panel, DSPMONP_BIT_25, READ_BIT(value, 25));
				SetCtrlVal(panel, DSPMONP_BIT_26, READ_BIT(value, 26));
				SetCtrlVal(panel, DSPMONP_BIT_27, READ_BIT(value, 27));
				SetCtrlVal(panel, DSPMONP_BIT_28, READ_BIT(value, 28));
				SetCtrlVal(panel, DSPMONP_BIT_29, READ_BIT(value, 29));
				SetCtrlVal(panel, DSPMONP_BIT_30, READ_BIT(value, 30));
				SetCtrlVal(panel, DSPMONP_BIT_31, READ_BIT(value, 31));
				break;

			READ_BUTTON(DSPMONP_BIT_, 0);
			READ_BUTTON(DSPMONP_BIT_, 1);
			READ_BUTTON(DSPMONP_BIT_, 2);
			READ_BUTTON(DSPMONP_BIT_, 3);
			READ_BUTTON(DSPMONP_BIT_, 4);
			READ_BUTTON(DSPMONP_BIT_, 5);
			READ_BUTTON(DSPMONP_BIT_, 6);
			READ_BUTTON(DSPMONP_BIT_, 7);
			READ_BUTTON(DSPMONP_BIT_, 8);
			READ_BUTTON(DSPMONP_BIT_, 9);
			READ_BUTTON(DSPMONP_BIT_, 10);
			READ_BUTTON(DSPMONP_BIT_, 11);
			READ_BUTTON(DSPMONP_BIT_, 12);
			READ_BUTTON(DSPMONP_BIT_, 13);
			READ_BUTTON(DSPMONP_BIT_, 14);
			READ_BUTTON(DSPMONP_BIT_, 15);
			READ_BUTTON(DSPMONP_BIT_, 16);
			READ_BUTTON(DSPMONP_BIT_, 17);
			READ_BUTTON(DSPMONP_BIT_, 18);
			READ_BUTTON(DSPMONP_BIT_, 19);
			READ_BUTTON(DSPMONP_BIT_, 20);
			READ_BUTTON(DSPMONP_BIT_, 21);
			READ_BUTTON(DSPMONP_BIT_, 22);
			READ_BUTTON(DSPMONP_BIT_, 23);
			READ_BUTTON(DSPMONP_BIT_, 24);
			READ_BUTTON(DSPMONP_BIT_, 25);
			READ_BUTTON(DSPMONP_BIT_, 26);
			READ_BUTTON(DSPMONP_BIT_, 27);
			READ_BUTTON(DSPMONP_BIT_, 28);
			READ_BUTTON(DSPMONP_BIT_, 29);
			READ_BUTTON(DSPMONP_BIT_, 30);
			READ_BUTTON(DSPMONP_BIT_, 31);
			
			case DSPMONP_REGISTERS_RING_READ:
				updateBitField(panel);
				break;	
				

		default: break;
		}
		break;
		
	case EVENT_LEFT_CLICK:
	
		switch (control){
			REG_CLICK(STATUS_REG_0);
			REG_CLICK(STATUS_REG_1);
			REG_CLICK(STATUS_REG_2);
			REG_CLICK(COMMAND_REG_0);
			REG_CLICK(DIAGNOSTIC_REG);
			REG_CLICK(TRAPSTAT_REG_0);
			REG_CLICK(TRAPSTAT_REG_1);
			REG_CLICK(LOOP_REG);
			REG_CLICK(HCMD_STAT_REG_0);
			REG_CLICK(HCMD_STAT_REG_1);
			REG_CLICK(HSTAT_REG_0);
			REG_CLICK(HSTAT_REG_1);
			REG_CLICK(RESERVED_REG_0);
			REG_CLICK(RESERVED_REG_1);
			REG_CLICK(RESERVED_REG_2);
			REG_CLICK(RESERVED_REG_3);
			REG_CLICK(RESERVED_REG_4);
			REG_CLICK(RESERVED_REG_5);
			//dpsf REG_CLICK(RESERVED_REG_6);
			REG_CLICK(TASK_STATE_REG);
			REG_CLICK(HCMD_REG);
			REG_CLICK(TRAP_CMD_STAT);
			//dpsf: REG_CLICK(PRIVATE_DSP_0);
			//dpsf: REG_CLICK(PRIVATE_DSP_1);

			default: break;
		}
		
		
	default: break;
	
	}

	return 0;
}



/*=============================================================================
 *                               mainMenu()
 *=============================================================================
 *
 *  Main panel menu.
 *
 */
 void CVICALLBACK mainMenu(int menuBar, int menuItem, void *callbackData, int panel){

	ERROR_ID errorId;
	int status, panelHandle;
	char commandLineString[300]=EXTERNAL_EDITOR;
	char fileName[PATHNAME_LENGTH];
	char userGuideString[300]="explorer ";

	switch (menuItem) {
		case MAIN_MENU_LOAD_ROD:

			status=InstallPopup(global.panel.loadHost);
			if(status!=0){
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "InstallPopup()", status, "");
			}
			break;
		case MAIN_MENU_PARAMS_SAVE_RINGS:

				status = FileSelectPopup (global.listRingsDir, "*.cfg",
										  "*.cfg", "Save to file", VAL_SAVE_BUTTON, 0,
										  0, 1, 0, fileName);
				switch(status){
					case 0: /* no file selected */
						break;
					case 1: /* existing file selected */
						// no break here
					case 2: /* new file selected */
						errorId = saveListRings(global.panel.main, fileName);
						ERROR_CHECK(errorId, saveListRings());
						break;
					default:
						UIR_STATUS_CHECK(status, FileSelectPopup);
						break;

				}
			break;

		case MAIN_MENU_PARAMS_LOAD_RINGS:
			status = FileSelectPopup (global.listRingsDir, "*.cfg",
									  "*.cfg", "Pick file", VAL_SELECT_BUTTON, 0,
									  0, 1, 1, fileName);
			if(status==VAL_NO_FILE_SELECTED){
				break;
			}
			errorId = loadListRings(global.panel.main, fileName);
			ERROR_CHECK(errorId, loadListRings());
			break;
		case MAIN_MENU_PARAMS_SET: /* load default global params */
			/* jusp place holder - not implemented yet */
			break;
		case MAIN_MENU_PARAMS_LOAD:/* save current global params */
			/* jusp place holder - not implemented yet */
			break;
		case MAIN_MENU_SHOW_ERROR_FILE:
			strcat(commandLineString," ");
			status=LaunchExecutable (strcat(commandLineString, global.errorFileName));
			if(status!=0){
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "LaunchExecutable()", status, "");
			}
			break;
		case MAIN_MENU_LIST_EDIT_PRIM:
			status=DisplayPanel(global.panel.primListEdit);
			UIR_STATUS_CHECK(status, DisplayPanel());
			break;
		case MAIN_MENU_LIST_EDIT_COMMAND:
			status=DisplayPanel(global.panel.commandListEdit);
			UIR_STATUS_CHECK(status, DisplayPanel());
			break;
		case MAIN_MENU_MEM_ACCESS_TIM:
			status=DisplayPanel(global.panel.tim);
			UIR_STATUS_CHECK(status, DisplayPanel());
			break;
		case MAIN_MENU_MEM_ACCESS_VME:
			status=DisplayPanel(global.panel.vmeMemory);
			UIR_STATUS_CHECK(status, DisplayPanel());
			break;
		case MAIN_MENU_MEM_ACCESS_MASTER_DSP:
			status=DisplayPanel(global.panel.masterDspMemory);
			UIR_STATUS_CHECK(status, DisplayPanel());
			break;
		case MAIN_MENU_MEM_ACCESS_SLAVE_DSP:
			status=DisplayPanel(global.panel.slaveDspMemory);
			UIR_STATUS_CHECK(status, DisplayPanel());
			break;
		case MAIN_MENU_MEM_ACCESS_FPGA:
			status=DisplayPanel(global.panel.fpga);
			UIR_STATUS_CHECK(status, DisplayPanel());
			break;
		case MAIN_MENU_MEM_ACCESS_FLASH:
			status=DisplayPanel(global.panel.flash);
			UIR_STATUS_CHECK(status, DisplayPanel());
			updateFlashPanelState(global.panel.flash);
			break;
		case MAIN_MENU_MEM_ACCESS_VIEW_BIN_FI: /* view binary file */

			status=FileSelectPopup(global.commonDataDir, "*.bin","*.bin","Pick file", VAL_SELECT_BUTTON,0,0,1,1,fileName);
			if(status==VAL_NO_FILE_SELECTED){
				break;
			}
			errorId=viewBinFile(fileName);
			ERROR_CHECK(errorId, viewBinFile());
			break;
		case MAIN_MENU_HELP:
			strcat(userGuideString, global.mainDir);
			strcat(userGuideString, HELP_DIR);
			status=LaunchExecutable (userGuideString);
			if(status!=0){
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "LaunchExecutable()", status, "");
			}
			
			break;
		case MAIN_MENU_QUIT:
			if(ConfirmPopup ("RCC PROGRAM", "Exit program?")){
				global.option.displayRefresh=FALSE;
				global.option.programExit=TRUE;
				QuitUserInterface(global.uirReturnCode);
			}
			break;
		default:
			programError(__FILE__, __LINE__, PROGRAM_ERROR, "mainMenu()", 0,"-non known menu item.");

	}

}

#ifdef PIXEL_ROD
/*=============================================================================
 *                             changeRodBandwidth()
 *=============================================================================
 *
 *  Changes the ROD's default input bandwidth.
 *
 */
int CVICALLBACK changeRodBandwidth(int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	unsigned char hostIndex;
	int status;
	struct HOST *host;


	if(event==EVENT_VAL_CHANGED){
		GetCtrlVal(panel, ROD_HOST_INDEX, &hostIndex);
		host=global.host[hostIndex];
		GetCtrlVal(panel, control, &host->bandwidth);

		printf("index, bandwidth, ptr: %d   %d    0x%x\n", hostIndex, host->bandwidth, &host);
	}
	return 0;

}
#endif

/*=============================================================================
 *                             changeNumberOfListRep()
 *=============================================================================
 *
 *  Changes number of primList repetitions.
 *
 */
int CVICALLBACK changeNumberOfListRep(int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	unsigned char hostIndex;
	int status;
	struct HOST *host;


	if(event==EVENT_VAL_CHANGED){
		GetCtrlVal(panel, ROD_HOST_INDEX, &hostIndex);
		host=global.host[hostIndex];
		GetCtrlVal(panel, control, &host->option.primListRepetitions);
	}
	return 0;

}

/*=============================================================================
 *                               setThreadPriorityOpt()
 *=============================================================================
 *
 *  Changes thread priorities.
 *
 */
int CVICALLBACK setThreadPriorityOpt (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int status;
	ERROR_ID errorId;
	struct HOST *host;
	int index;
	unsigned char hostNumber;
	int priorityLevel;
	int priority[5]={
		THREAD_PRIORITY_LOWEST,
		THREAD_PRIORITY_BELOW_NORMAL,
		THREAD_PRIORITY_NORMAL,
		THREAD_PRIORITY_ABOVE_NORMAL,
		THREAD_PRIORITY_HIGHEST
	};

	if(event==EVENT_VAL_CHANGED){
		GetCtrlVal(panel, control, &index);
		priorityLevel=priority[index];

		switch(control){
			case MAIN_UIR_PRIORITY:
				global.mainThread.priority=priorityLevel;
				errorId=setThreadPriority(global.mainThread.handle, priorityLevel);
    			ERROR_CHECK(errorId, setThreadPriority(mainThread));
				break;
			case MAIN_COMM_LOOP_PRIOR:
				global.communLoopThread.priority=priorityLevel;
				errorId=setThreadPriority(global.communLoopThread.handle, priorityLevel);
    			ERROR_CHECK(errorId, setThreadPriority(communLoopThread));
				break;
			case MAIN_CONTROL_PRIOR:
				global.cmdListExecThreadPriority=priorityLevel;
				SET_HOST_THREAD_PRIORITY(cmdListExecThread);
				break;

			default:
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "setThreadPriority()", 0,"-non known control.");
		}

	}
	return 0;

}

/*=============================================================================
 *                             hostEnabledAndInit()
 *=============================================================================
 *
 *  Host enable/diable button.
 *
 */
int CVICALLBACK hostEnabledAndInit (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int status;
	struct HOST *host;
	char errorMessage[200];
	ERROR_ID errorId;
	unsigned char hostIndex;

	if((event==EVENT_VAL_CHANGED)||(event==EVENT_KEYPRESS)||(event==EVENT_COMMIT)){
		GetCtrlVal(panel, ROD_HOST_INDEX, &hostIndex);
		host=global.host[hostIndex];
		GetCtrlVal(panel, control, (unsigned int*)&host->option.rodEnabled);

	}
	return(SUCCESS);
}

/*=============================================================================
 *                               hostOptions()
 *=============================================================================
 *
 *  Host options.
 *
 */
int CVICALLBACK hostOptions(int panel, int control, int event,
		void *callbackDataX, int eventData1, int eventData2)
{
	int status;
	struct HOST *host;
	char errorMessage[200];
	ERROR_ID errorId=SUCCESS;
	unsigned char hostIndex;
	unsigned int value;
	UINT32 data;
	struct LIST_FIFO *fifo;

    if((event==EVENT_VAL_CHANGED)||(event==EVENT_KEYPRESS)||(event==EVENT_COMMIT)){
		GetCtrlVal(panel, ROD_HOST_INDEX, &hostIndex);
		GetCtrlVal(panel, control, &value);
		host=global.host[hostIndex];

		switch (control){
			case ROD_ABORT_BUTTON:
				if(value){
					if(!ConfirmPopup("ABORT?", "Set ABORT bit?")){
						SetCtrlVal(panel, control, FALSE);
						break;
					}
					errorId=setVmeCommandRegBit(host->slotNumber, &host->vmeCommandReg[0],  CR_ABORT);
					HOST_ERROR_CHECK(errorId, host, setVmeCommandRegBit(vmeCommandReg[0], CR_ABORT));
				} else {
					errorId=clearVmeCommandRegBit(host->slotNumber, &host->vmeCommandReg[0],  CR_ABORT);
					HOST_ERROR_CHECK(errorId, host, clearVmeCommandRegBit(vmeCommandReg[0], CR_ABORT));
				}
				displayVmeCommandReg0(host);
				break;
			case ROD_PAUSE_BUTTON:
				if(value){
					errorId=setVmeCommandRegBit(host->slotNumber, &host->vmeCommandReg[0],  CR_PAUSE);
					HOST_ERROR_CHECK(errorId, host, setVmeCommandRegBit(vmeCommandReg[0], CR_PAUSE));
				} else {
					errorId=clearVmeCommandRegBit(host->slotNumber, &host->vmeCommandReg[0],  CR_PAUSE);
					HOST_ERROR_CHECK(errorId, host, clearVmeCommandRegBit(vmeCommandReg[0], CR_PAUSE));
				}
				displayVmeCommandReg0(host);
				break;
			case ROD_DMA_REQ_BUTTON:
				if(value){
					errorId=setVmeCommandRegBit(host->slotNumber, &host->vmeCommandReg[0],  CR_DMA_ACCESS_REQ);
					HOST_ERROR_CHECK(errorId, host, setVmeCommandRegBit(vmeCommandReg[0], CR_DMA_ACCESS_REQ));
				} else {
					errorId=clearVmeCommandRegBit(host->slotNumber, &host->vmeCommandReg[0],  CR_DMA_ACCESS_REQ);
					HOST_ERROR_CHECK(errorId, host, clearVmeCommandRegBit(vmeCommandReg[0], CR_DMA_ACCESS_REQ));
				}
				displayVmeCommandReg0(host);
				break;
			case ROD_RESUME_BUTTON:
				if(READ_BIT(host->rodStatusReg[0], SR_PAUSED)==0){
					SetCtrlVal(panel, control, !value);
					status=MessagePopup ("WARNING", "ROD NOT paused (SR_PAUSED=0)!\n Cannot toggle resume bit.");
					UIR_STATUS_CHECK(status, MessagePopup());
					break;
				}

				if(value){
					errorId=setVmeCommandRegBit(host->slotNumber, &host->vmeCommandReg[0],  CR_RESUME);
					HOST_ERROR_CHECK(errorId, host, setVmeCommandRegBit(vmeCommandReg[0], CR_RESUME));
				} else {
					errorId=clearVmeCommandRegBit(host->slotNumber, &host->vmeCommandReg[0],  CR_RESUME);
					HOST_ERROR_CHECK(errorId, host, clearVmeCommandRegBit(vmeCommandReg[0], CR_RESUME));
				}
				displayVmeCommandReg0(host);
				break;

			case ROD_REPEAT_BUILD_EXEC:
				host->option.repeatExecNotBuild=value;
				break;
			case ROD_ERRBUFF_READRQ_OPT:
				host->option.textBuffReadRq[ERR_BUFF]=(int)value;
				if(value){
					status=DisplayPanel(host->panel.txtBuff[ERR_BUFF]);
					UIR_STATUS_CHECK(status, DisplayPanel());
				}
				break;
			case ROD_INFOBUFF_READRQ_OPT:
				host->option.textBuffReadRq[INFO_BUFF]=(int)value;
				if(value){
					status=DisplayPanel(host->panel.txtBuff[INFO_BUFF]);
					UIR_STATUS_CHECK(status, DisplayPanel());
				}
				break;
			case ROD_DIAGBUFF_READRQ_OPT:
				host->option.textBuffReadRq[DIAG_BUFF]=(int)value;
				if(value){
					status=DisplayPanel(host->panel.txtBuff[DIAG_BUFF]);
					UIR_STATUS_CHECK(status, DisplayPanel());
				}
				break;
			case ROD_XFERBUFF_READRQ_OPT:
				host->option.textBuffReadRq[XFER_BUFF]=(int)value;
				if(value){
					status=DisplayPanel(host->panel.txtBuff[XFER_BUFF]);
					UIR_STATUS_CHECK(status, DisplayPanel());
				}
				break;
			case ROD_WIN_SIZE:
				if(value) SetPanelSize (panel, 600, 800);
				else SetPanelSize (panel, 960, 1260);
				break;

				case ROD_RESET_REP_NUM:
					host->option.primListRepetitions=0;
					SetCtrlVal(panel, ROD_NUMBER_OF_LIST_REP,host->option.primListRepetitions);

					break;
				case ROD_READ_STATUS:

					/* HPI INITIALIZATION - little endian */
					errorId=setHpicMaster(host->slotNumber);
					ERROR_CHECK(errorId, setHpicMaster());
					if(errorId!=SUCCESS) break;

					/* read RodStatusReg0and1 and save to local variables */
					errorId=readRodStatusRegs(host->slotNumber, host->rodStatusReg);
					if(errorId!=SUCCESS){
						hostError(__FILE__,__LINE__, VME_ERROR, host, "readRodStatusRegs(rodStatusReg)");
						break;
					}

					displayRodStatusReg0(host);
					SetCtrlVal(host->panel.parent, ROD_ROD_STAT_REG1, host->rodStatusReg[1]);

					// get ROD serial number
					errorId=vmeReadElement(BASE_ADDRESS(host->slotNumber)+FPGA_STATUS_6_REL_ADDR, &value, sizeof(UINT32));
					HOST_ERROR_CHECK(errorId, host, vmeReadBlock(ROD serial number));
					SetCtrlVal(panel, ROD_ROD_SN, value&0x1FF);  // only 9b.
					SetCtrlVal(panel, ROD_ROD_REV, (value&0xFF0000)/0x10000);  //ROD revision
					SetCtrlVal(panel, ROD_MEMORY, (value&0x200)/0x200); /* 10th bit */

					errorId=refreshFpgaStatus(host); // refresh ROD status
					HOST_ERROR_CHECK(errorId, host, refreshFpgaStatus());
					break;

				default:
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "hostOptions()", 0,"-non known control.");
		}
//	}else{
//		if(event==EVENT_COMMIT){
//  		GetCtrlVal(panel, ROD_HOST_INDEX, &hostIndex);
//  		host=global.host[hostIndex];
//  		switch(control){
//
//  			case ROD_RESET_REP_NUM:
//  				host->option.primListRepetitions=0;
//  				SetCtrlVal(panel, ROD_NUMBER_OF_LIST_REP,host->option.primListRepetitions);
//
//  				break;
//  			case ROD_READ_STATUS:
//
//  				/* HPI INITIALIZATION - little endian */
//  				errorId=setHpicMaster(host->slotNumber);
//  				ERROR_CHECK(errorId, setHpicMaster());
//  				if(errorId!=SUCCESS) break;
//
//  				/* read RodStatusReg0and1 and save to local variables */
//  				errorId=readRodStatusRegs(host->slotNumber, host->rodStatusReg);
//  				if(errorId!=SUCCESS){
//  					hostError(__FILE__,__LINE__, VME_ERROR, host, "readRodStatusRegs(rodStatusReg)");
//  					break;
//  				}
//
//  				displayRodStatusReg0(host);
//  				SetCtrlVal(host->panel.parent, ROD_ROD_STAT_REG1, host->rodStatusReg[1]);
//
//  				// get ROD serial number
//  				errorId=vmeReadElement(BASE_ADDRESS(host->slotNumber)+FPGA_STATUS_6_REL_ADDR, &value, sizeof(UINT32));
//  				HOST_ERROR_CHECK(errorId, host, vmeReadBlock(ROD serial number));
//  				SetCtrlVal(panel, ROD_ROD_SN, value&0x1FF);  // only 9b.
//  				SetCtrlVal(panel, ROD_ROD_REV, (value&0xFF0000)/0x10000);  //ROD revision
//  				SetCtrlVal(panel, ROD_MEMORY, (value&0x200)/0x200); /* 10th bit */
//
//  				errorId=refreshFpgaStatus(host); // refresh ROD status
//  				HOST_ERROR_CHECK(errorId, host, refreshFpgaStatus());
//  				break;
//
//  			default:
//  				break;
//			}
//		}

	}
	return 0;
}


/*=============================================================================
 *                               globalOptions()
 *=============================================================================
 *
 *  Global options.
 *
 */
int CVICALLBACK globalOptions(int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int status;
	struct HOST *host;
	int hostIndex;
	char errorMessage[200];
	ERROR_ID errorId=SUCCESS;
	int value;


	if((event==EVENT_VAL_CHANGED)||(event==EVENT_KEYPRESS)||(event==EVENT_COMMIT)){
		GetCtrlVal(panel, control, &value);
		switch(control){

			case MAIN_DEFAULT_SLOT:
				SetCtrlVal(global.panel.vmeMemory, VME_MEM_SLOT_NUMBER, (unsigned char)value);
				SetCtrlVal(global.panel.slaveDspMemory, SLAVE_MEM_SLOT_NUMBER, (unsigned char)value);
				SetCtrlVal(global.panel.masterDspMemory, MASTER_MEM_SLOT_NUMBER, (unsigned char)value);
				SetCtrlVal(global.panel.flash, PAN_FLASH_SLOT_NUMBER, (unsigned char)value);     
				SetCtrlVal(global.panel.fpga, PANEL_FPGA_SLOT_NUMBER, (unsigned char)value);
				//SetCtrlVal(global.panel.primListEdit, LIST_EDIT_SLOT_NUMBER, value);
				//SetCtrlVal(global.panel.commandListEdit, CLIST_EDIT_SLOT_NUMBER, value);
				
				break;
		
			case MAIN_VME_BYTE_ORDER:
				global.option.intelNotMotorola=value;
				break;
			case MAIN_DSP_SET_TIMEOUT:
				global.option.dspAckSetTimeoutOn=value;
				//status=SetInputMode(panel, MAIN_DSP_ACK_SET_TIMEOUT, value);
				//UIR_STATUS_CHECK(status, SetInputMode());
				break;

			case MAIN_REFRESH_DISP:
				global.option.displayRefresh=value;
				//status=SetInputMode(panel, MAIN_REFRESH_PERIOD, value);
				//UIR_STATUS_CHECK(status, SetInputMode());
				break;
			case MAIN_FPGA_MONITOR_REFRESH:
				global.option.fpgaMonitorOn=value;	
				break;
			case MAIN_DSP_MONITOR_REFRESH:
				global.option.dspMonitorOn=value;	
				break;	
			case MAIN_COMM_LOOP_RUNNING:
				SetCtrlVal(panel, control, !value);
				global.option.stopCommLoop=!value;
				if(value==TRUE){
					errorId=resumeThread(global.communLoopThread.handle);
			    	ERROR_CHECK(errorId,resumeThread(communLoopThread));
			    }
				break;

			case MAIN_CHECKSUM_MASTER:
				global.option.masterChecksum=(int)value;
				break;
			case MAIN_CHECKSUM_SLAVE:
				global.option.slaveChecksum=(int)value;
				break;
			case MAIN_SAVE_LISTS_OPTION:
				global.option.saveLists=(int)value;
				break;

			case MAIN_HOSTS_RUNNING:

			    for(hostIndex=0; hostIndex<MAXRODS; ++hostIndex){
			    	host=global.host[hostIndex];
			     	if(host==NULL) continue;
			     	host->option.rodEnabled=value;
				 	SetCtrlVal(host->panel.parent, ROD_HOST_RUNNING, value);
				}

				break;

			default:
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "globalOptions()", 0,"-non known control.");

		}
	}
	return 0;
}

/*=============================================================================
 *                               setTimeout()
 *=============================================================================
 *
 *  Timeout settings.
 *
 */
int CVICALLBACK setTimeout(int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int status;
	double value;

	if(event==EVENT_VAL_CHANGED){
		GetCtrlVal(panel, control, &value);
		switch(control){
			case MAIN_ROD_INIT_TIMEOUT:
				global.rodInitTimeout=value;
			    break;
			case MAIN_DSP_ACK_CLEAR_TIMEOUT:
				global.dspAckClearTimeout=value;
			    break;
			case MAIN_DSP_ACK_SET_TIMEOUT:
				global.dspAckSetTimeout=value;
			    break;
			case MAIN_TEXTBUFF_TIMEOUT:
				global.textBuffTimeout=value;
			    break;
			case MAIN_REFRESH_PERIOD:
				global.option.displayRefreshPeriodInSec=value;
			    break;
			case MAIN_DSP_MONITOR_PERIOD:
				global.option.dspMonitorPeriodInSec=value;
			    break;
			case MAIN_FPGA_MONITOR_PERIOD:
				global.option.fpgaMonitorPeriodInSec=value;
			    break;    

			default:
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "setTimeout()", 0,"-non known control.");

		}
	}
	return 0;
}

/*=============================================================================
 *                               slotNumberWindow()
 *=============================================================================
 *
 *  Load new rod window.
 *
 */
int CVICALLBACK slotNumberWindow (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	ERROR_ID errorId;
	int status;
	int value;
	unsigned char slotNumber;
	int index;

	if(event==EVENT_COMMIT){

		switch (control){
			case NEWROD_PN_OK:

				status=RemovePopup(0);
				if(status!=0){
					programError(__FILE__, __LINE__, PROGRAM_ERROR, "RemovePopup()", status, "");
				}

				LOAD_HOST(5);
				LOAD_HOST(6);
				LOAD_HOST(7);
				LOAD_HOST(8);
				LOAD_HOST(9);
				LOAD_HOST(10);
				LOAD_HOST(11);
				LOAD_HOST(12);
				LOAD_HOST(14);
				LOAD_HOST(15);
				LOAD_HOST(16);
				LOAD_HOST(17);
				LOAD_HOST(18);
				LOAD_HOST(19);
				LOAD_HOST(20);
				LOAD_HOST(21);

				break;
			case NEWROD_PN_CANCEL:
				status=RemovePopup(0);
				if(status!=0){
					programError(__FILE__, __LINE__, PROGRAM_ERROR, "InstallPopup()", status, "");
				}
				break;
		}
	}
	return 0;
}

/*=============================================================================
 *                               selectAll()
 *=============================================================================
 *
 *  
 *
 */
 
#define SELECT_ROD(slotNumber) \
if(global.host[HOST_INDEX(slotNumber)]==NULL) { SetCtrlVal(panel, NEWROD_PN_SLOT_##slotNumber, value);} 

 
int CVICALLBACK selectAll (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	ERROR_ID errorId;
	int status;
	int value;
	unsigned char slotNumber;

	if(event==EVENT_VAL_CHANGED){
		GetCtrlVal(panel, control, &value);
		
		SELECT_ROD(5);
		SELECT_ROD(6); 
		SELECT_ROD(7); 
		SELECT_ROD(8); 
		SELECT_ROD(9); 
		SELECT_ROD(10); 
		SELECT_ROD(11); 
		SELECT_ROD(12); 
		SELECT_ROD(14);
		SELECT_ROD(15); 
		SELECT_ROD(16); 
		SELECT_ROD(17); 
		SELECT_ROD(18); 
		SELECT_ROD(19); 
		SELECT_ROD(20); 
		SELECT_ROD(21); 
	
	}	
	return 0;
}


/*=============================================================================
 *                               shutErrorPanel()
 *=============================================================================
 *
 * Error panel buttons (OK/Cancel).
 *
 */

int CVICALLBACK shutErrorPanel (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int status;
	char commandLineString[300]=EXTERNAL_EDITOR;
	int  showErrWindow;

	switch (event)
		{
		case EVENT_COMMIT:
			GetCtrlVal(panel, ERROR_PAN_SHOW_ERROR_WINDOW, &showErrWindow);
			SetCtrlVal(global.panel.main, MAIN_SHOW_ERROR_WINDOW, showErrWindow);
			SetCtrlVal(panel, ERROR_PAN_SHOW_ERROR_WINDOW, 1);
			status=RemovePopup(0);
			global.errPanelInstalled=0;
			if(control==ERROR_PAN_OK){
				strcat(commandLineString," ");
				status=LaunchExecutable (strcat(commandLineString, global.errorFileName));
				UIR_STATUS_CHECK(status, LaunchExecutable());			}
			break;
		}
	return 0;
}
/*=============================================================================
 *                               errorTimer()
 *=============================================================================
 *
 *  Error timer - installs the error panel if detected error (and error panel enabled).
 *
 */

int CVICALLBACK errorTimer (int panel, int control, int event,void *callbackData, int eventData1, int eventData2){

	int status;
	int showErrWindow;

	if(event==EVENT_TIMER_TICK){
		GetCtrlVal(global.panel.main, MAIN_SHOW_ERROR_WINDOW, &showErrWindow);
		if((global.errPanelInstalled==0)&&(showErrWindow)){
			/* show error window */
			status=InstallPopup (global.panel.error);
			UIR_STATUS_CHECK(status, InstallPopup());
			global.errPanelInstalled=1;
		}
		status = SetCtrlAttribute (panel, control, ATTR_ENABLED, 0);
		UIR_STATUS_CHECK(status, SetCtrlAttribute());
	}
	return 0;
}

/*=============================================================================
 *                               sendList()
 *=============================================================================
 *
 *  Send primList to rod.
 *
 */

int CVICALLBACK sendList (int panel, int control, int event,  void *callbackData, int eventData1, int eventData2){

	char file[PATHNAME_LENGTH];
	int status;
	ERROR_ID errorId;
	unsigned int fileSize;
	UINT8 hostIndex;
	struct HOST *host;
	char text[300];

	if(event==EVENT_LEFT_CLICK){

		switch(control){

			case ROD_LIST_FILE:
				/* select primList file */
				status = FileSelectPopup (global.testingDataDir, "*.pl", "*.pl", "",VAL_SELECT_BUTTON, 0, 1, 1, 1, file);
				if(status==VAL_NO_FILE_SELECTED){
					file[0]=0;
					break;
				}
				SetCtrlVal(panel, control, file);
				break;

			default: break;
		}

	}else{
		if(event==EVENT_COMMIT){
			switch(control){
				case ROD_SEND_LIST: /* send prim list to rod */

					GetCtrlVal(panel, ROD_LIST_FILE, file);

					GetCtrlVal(panel, ROD_HOST_INDEX, &hostIndex);
					host=global.host[hostIndex];

					if((host->cmdListExecState!=CMDLISTEXEC_IDLE)||(host->primListReady)){
						sprintf(text, "Cannot execute PrimList(slot#%d) - CmdListExecution is busy!!", host->slotNumber);
						status = MessagePopup ("WARNING", text);
						UIR_STATUS_CHECK(status, MessagePopup());
						break;
					}

					errorId=executePrimListFile(host->slotNumber, file, host->option.primListRepetitions, !host->option.repeatExecNotBuild, 0);
					HOST_ERROR_CHECK(errorId, host, executePrimListFile());

					break;
			case ROD_EDIT_PLIST:
				/* open prim list in PrimListEdit Window */
				GetCtrlVal(panel, ROD_LIST_FILE, file);
				if(file[0]==0) break;
				(void) listEditWindowButtons(global.panel.primListEdit, LIST_EDIT_CLEAR_LIST, EVENT_COMMIT, 0, 1, 0);
				(void) listEditWindowButtons(global.panel.primListEdit, LIST_EDIT_INSERT_LIST, EVENT_COMMIT, file, 1, 0);
				SetActivePanel(global.panel.primListEdit);
				break;

				default: break;
			}
		}
	}
	return 0;
}

/*=============================================================================
 *                               sendList()
 *=============================================================================
 *
 *  Send primList or commandList to all currently loaded rods.
 *
 */
int CVICALLBACK sendListToAll (int panel, int control, int event, void *callbackData, int eventData1, int eventData2){

	char file[PATHNAME_LENGTH];
	int status;
	ERROR_ID errorId;
	unsigned int fileSize;
	UINT8 hostIndex;
	struct HOST *host= NULL;
	char text[300];
	UINT32 repetitions;
	int buildOrExec, updateStatus, ifError;
	unsigned char slotNumber;

	if(event==EVENT_LEFT_CLICK){

		switch(control){

			case MAIN_PLIST_FILE:
				/* select primList file */
				status = FileSelectPopup (global.testingDataDir, "*.pl", "*.pl", "",VAL_SELECT_BUTTON, 0, 1, 1, 1, file);
				if(status==VAL_NO_FILE_SELECTED){
					file[0]=0;
					break;
				}
				SetCtrlVal(panel, control, file);
				break;
			case MAIN_CLIST_FILE:
				/* select commandList file */
				status = FileSelectPopup (global.testingDataDir, "*.cl", "*.cl", "",VAL_SELECT_BUTTON, 0, 1, 1, 1, file);
				if(status==VAL_NO_FILE_SELECTED){
					file[0]=0;
					break;
				}
				SetCtrlVal(panel, control, file);
				break;

			default: break;
		}

	}else{
		if(event==EVENT_COMMIT){
			switch(control){
				case MAIN_SEND_LIST:  /* send primList */

					GetCtrlVal(panel, MAIN_PLIST_FILE, file);

					GetCtrlVal(panel, MAIN_PLIST_REP, &repetitions);
					GetCtrlVal(panel, MAIN_REPEAT_BUILD_EXEC, &buildOrExec);
					GetCtrlVal(panel, MAIN_SLOT_NUMBER, &slotNumber);

					errorId=executePrimListFile(slotNumber, file, repetitions, !buildOrExec, 0);
					HOST_ERROR_CHECK(errorId, host, executePrimListFile());
					if(errorId!=SUCCESS) return(-1);

					break;

				case MAIN_SEND_COMMAND_LIST:  /* send commandList */

					GetCtrlVal(panel, MAIN_CLIST_FILE, file);

					GetCtrlVal(panel, MAIN_CLIST_REP, &repetitions);
					GetCtrlVal(panel, MAIN_IF_ERROR, &ifError);
					GetCtrlVal(panel, MAIN_SLOT_NUMBER, &slotNumber);

					errorId=executeCommandListFile(slotNumber, file, repetitions, ifError);
					HOST_ERROR_CHECK(errorId, host, executeCommandListFile());
					if(errorId!=SUCCESS) return(-1);
					
					break;

			case MAIN_EDIT_PLIST:
				/* open prim list in PrimListEdit Window */
				GetCtrlVal(panel, MAIN_PLIST_FILE, file);
				if(file[0]==0) break;
				(void) listEditWindowButtons(global.panel.primListEdit, LIST_EDIT_CLEAR_LIST, EVENT_COMMIT, 0, 1, 0);
				(void) listEditWindowButtons(global.panel.primListEdit, LIST_EDIT_INSERT_LIST, EVENT_COMMIT, file, 1, 0);
				SetActivePanel(global.panel.primListEdit);
				break;

			case MAIN_EDIT_CLIST:
				/* open command list in CommandListEdit Window */
				GetCtrlVal(panel, MAIN_CLIST_FILE, file);
				if(file[0]==0) break;
				(void) clistEditButtons(global.panel.commandListEdit, CLIST_EDIT_CLEAR_LIST, EVENT_COMMIT, 0, 1, 0);
				(void) clistEditButtons(global.panel.commandListEdit, CLIST_EDIT_INSERT_LIST, EVENT_COMMIT, file, 1, 0);
				SetActivePanel(global.panel.commandListEdit);
				break;

				default: break;
			}
		}
	}
	return 0;
}

/*=============================================================================
 *                               resetAllControlThreads()
 *=============================================================================
 *
 *  Resets all currently running control threads.
 *
 */
int CVICALLBACK resetAllControlThreads (int panel, int control, int event, void *callbackData, int eventData1, int eventData2){

	struct HOST *host;
	char text[300];
	UINT8 hostIndex;
	ERROR_ID errorId;
	int status;

	if(event==EVENT_COMMIT){

		for(hostIndex=0; hostIndex<MAXRODS; ++hostIndex){

			host=global.host[hostIndex];
			if(host==NULL) continue;

 			if(host->cmdListExecState!=CMDLISTEXEC_IDLE){
 				host->cmdListExecState=CMDLISTEXEC_ABORT;
	     		errorId=setEvent(host->commandDone_event);
				ERROR_CHECK(errorId, waitForEvent());
			}

			errorId=resumeThread(host->cmdListExecThread.handle);
			HOST_ERROR_CHECK(errorId, host, resumeThread());

		 }

	}
	return(0);
}
/*=============================================================================
 *                               ringFunc()
 *=============================================================================
 *
 *
 *
 */

int CVICALLBACK primRingFunc (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	ERROR_ID errorId;
	int status;
	char fileName[PATHNAME_LENGTH];
	char ringFile[PATHNAME_LENGTH];
	int labelIndex;
	int i, itemCount;
	int stringLength;
	struct HOST *host;
	unsigned char hostIndex;

	if(event==EVENT_COMMIT){

		if(panel!=global.panel.main){ // called from host panels

			GetCtrlVal(panel, ROD_HOST_INDEX, &hostIndex);
			host=global.host[hostIndex];

			if(control==host->controlId.primRing){ // primRing
				GetCtrlVal(panel, control, fileName);
				SetCtrlVal(panel, ROD_LIST_FILE, fileName);
			}
			return 0;
		}

		switch(control){
			case MAIN_PLIST_RING:
				GetCtrlVal(panel, MAIN_PLIST_RING, fileName);
				SetCtrlVal(panel, MAIN_PLIST_FILE, fileName);
				break;
			case MAIN_ADD_PLIST_TO_RING:
				GetCtrlVal(panel, MAIN_PLIST_FILE, fileName);
				stringLength=strlen(fileName)+1;
				if(stringLength<LIST_STRING_LENGTH) labelIndex=0; else labelIndex=stringLength-LIST_STRING_LENGTH;
				status = InsertListItem (panel, MAIN_PLIST_RING, -1, &fileName[labelIndex], fileName);
				UIR_STATUS_CHECK(status, InsertListItem());

				break;
			case MAIN_DEL_PLIST_FROM_RING:
				GetCtrlVal(panel, MAIN_PLIST_FILE, fileName);
				GetNumListItems (panel, MAIN_PLIST_RING, &itemCount);
				for(i=0; i<itemCount; ++i){
					status = GetValueFromIndex (panel, MAIN_PLIST_RING, i, ringFile);
					UIR_STATUS_CHECK(status, GetValueFromIndex());
					if(strcmp(fileName, ringFile)==0){ //file found in ring
						DeleteListItem (panel, MAIN_PLIST_RING, i, 1);
						--i;
						--itemCount;
						//no break
					}
				}

				break;

			default:
				break;

		}

		if((control==MAIN_ADD_PLIST_TO_RING)||(control==MAIN_DEL_PLIST_FROM_RING)){
			/* copy ring to host panels */
			for(hostIndex=0; hostIndex<MAXRODS; ++hostIndex){
				host=global.host[hostIndex];
				if(host==NULL) continue;
				status = DiscardCtrl (host->panel.parent, host->controlId.primRing);
				UIR_STATUS_CHECK(status, DiscardCtrl());
				/* duplicate prim list ring from Main panel */
				host->controlId.primRing = DuplicateCtrl (global.panel.main, MAIN_PLIST_RING, host->panel.parent, "", 470, 6);
			}
		}

	}
	return 0;
}

/*=============================================================================
 *                               ringFunc()
 *=============================================================================
 *
 *
 *
 */

int CVICALLBACK commandRingFunc (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	ERROR_ID errorId;
	int status;
	char fileName[PATHNAME_LENGTH];
	char ringFile[PATHNAME_LENGTH];
	int labelIndex;
	int i, itemCount;
	int stringLength;
	struct HOST *host;
	unsigned char hostIndex;

	if(event==EVENT_COMMIT){

		if(panel!=global.panel.main){ // called from host panels

			GetCtrlVal(panel, CLISTP_HOST_INDEX, &hostIndex);
			host=global.host[hostIndex];

			if(control==host->controlId.commandRing){ // commandRing
				GetCtrlVal(panel, control, fileName);
				SetCtrlVal(panel, CLISTP_LIST_FILE, fileName);
			}
			return 0;
		}

		switch(control){
			case MAIN_CLIST_RING:
				GetCtrlVal(panel, MAIN_CLIST_RING, fileName);
				SetCtrlVal(panel, MAIN_CLIST_FILE, fileName);
				break;
			case MAIN_ADD_CLIST_TO_RING:
				GetCtrlVal(panel, MAIN_CLIST_FILE, fileName);
				stringLength=strlen(fileName)+1;
				if(stringLength<LIST_STRING_LENGTH) labelIndex=0; else labelIndex=stringLength-LIST_STRING_LENGTH;
				status = InsertListItem (panel, MAIN_CLIST_RING, -1, &fileName[labelIndex], fileName);
				UIR_STATUS_CHECK(status, InsertListItem());
				break;
			case MAIN_DEL_CLIST_FROM_RING:
				GetCtrlVal(panel, MAIN_CLIST_FILE, fileName);
				GetNumListItems (panel, MAIN_CLIST_RING, &itemCount);
				for(i=0; i<itemCount; ++i){
					status = GetValueFromIndex (panel, MAIN_CLIST_RING, i, ringFile);
					UIR_STATUS_CHECK(status, GetValueFromIndex());
					if(strcmp(fileName, ringFile)==0){ //file found in ring
						DeleteListItem (panel, MAIN_CLIST_RING, i, 1);
						--i;
						--itemCount;
						//no break
					}
				}

				break;

			default:
				break;

		}

		if((control==MAIN_ADD_CLIST_TO_RING)||(control==MAIN_DEL_CLIST_FROM_RING)){
			/* copy ring to host panels */
			for(hostIndex=0; hostIndex<MAXRODS; ++hostIndex){
			    host=global.host[hostIndex];
			    if(host==NULL) continue;
				status = DiscardCtrl (host->panel.commandListStatus, host->controlId.commandRing);
			    UIR_STATUS_CHECK(status, DiscardCtrl());
				/* duplicate command list ring from Main panel */
				host->controlId.commandRing = DuplicateCtrl (global.panel.main, MAIN_CLIST_RING, host->panel.commandListStatus, "", 162, 7);
			}
		}

	}
	return 0;
}
/*=============================================================================
 *                               closeGraph()
 *=============================================================================
 *
 *
 *
 */

int CVICALLBACK closeGraph (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{   int status;
	if(event==EVENT_COMMIT){
		status=HidePanel(global.panel.distributionPlot);
		UIR_STATUS_CHECK(status, DisplayPanel());
	}
	return 0;
}

/*=============================================================================
 *                               commandStatusMenu()
 *=============================================================================
 *
 *
 *
 */
void CVICALLBACK commandStatusMenu (int menuBar, int menuItem, void *callbackData, int panel){

	int status;
	UINT8 hostIndex;
	char string[300];
	char commandLineString[MAX_PATHNAME_LEN]=EXTERNAL_EDITOR;
	char fileName[MAX_PATHNAME_LEN];
	struct HOST *host;

 	switch(menuItem){
 	    case CSTAT_MENU_CLEAR_STATUS_WINDOW:
   			status=ResetTextBox (panel, CLISTP_STATUS_BOX, "");
 			UIR_STATUS_CHECK(status, ResetTextBox());
   			break;

   		case CSTAT_MENU_OPEN_STATUS_FILE:
   			GetCtrlVal(panel, CLISTP_HOST_INDEX, &hostIndex);
   			host=global.host[hostIndex];
   			strcpy(fileName, host->dataDir);
   			strcat(fileName, COMMAND_STATUS_FILE_NAME);
	        sprintf(string,"%d.TXT", host->slotNumber);
	        strcat(fileName, string);
			strcat(commandLineString," ");
			status=LaunchExecutable (strcat(commandLineString, fileName));
			if(status!=0){
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "LaunchExecutable()", status, "");
			}
			break;
 		case CSTAT_MENU_CMD_LIST_EDITOR:
			status=DisplayPanel(global.panel.commandListEdit);
			UIR_STATUS_CHECK(status, DisplayPanel());
 			break;
 		case CSTAT_MENU_CLOSE_WINDOW:
			status=HidePanel(panel);
			UIR_STATUS_CHECK(status, HidePanel());
			break;
		default: ;

	}


}

/*=============================================================================
 *                               commandButtons()
 *=============================================================================
 *
 *
 *
 */
int CVICALLBACK commandButtons(int panel, int control, int event, void *callbackData, int eventData1, int eventData2){

	unsigned char hostIndex;
	ERROR_ID errorId;
	int status;
	struct HOST *host;
	char file[PATHNAME_LENGTH];
	char text[300];
	unsigned int fileSize;
	struct COMMAND_LIST *commandList;
	int option;
	int ifError;

	GetCtrlVal(panel, CLISTP_HOST_INDEX, &hostIndex);
	host=global.host[hostIndex];

	switch(event){
		case EVENT_COMMIT:
			switch(control){
				case CLISTP_RESET_REP_LIST_NUM:
					host->option.commandListRepetitions=0;
					SetCtrlVal(host->panel.commandListStatus, CLISTP_NUM_OF_LIST_REP, host->option.commandListRepetitions);
					break;
				case CLISTP_RESET_CMDREP:
					host->option.commandRepetitions=0;
					SetCtrlVal(host->panel.commandListStatus, CLISTP_CMDREP, host->option.commandRepetitions);
					break;
				case CLISTP_SEND_LIST:
					GetCtrlVal(panel, CLISTP_LIST_FILE, file);

					if((host->cmdListExecState!=CMDLISTEXEC_IDLE)||(host->primListReady)){
						sprintf(text, "Cannot execute CommandList(slot#%d) - CmdListExecution is busy!!", host->slotNumber);
						status = MessagePopup ("WARNING", text);
						UIR_STATUS_CHECK(status, MessagePopup());
						break;
					}

					GetCtrlVal(panel, CLISTP_IF_ERROR, &ifError);
					errorId=executeCommandListFile(host->slotNumber, file, host->option.commandListRepetitions, ifError);
					HOST_ERROR_CHECK(errorId, host, executePrimListFile());
					break;
				case CLISTP_EDIT_CLIST:
					/* open command list in CommandListEdit Window */
					GetCtrlVal(panel, CLISTP_LIST_FILE, file);
					if(file[0]==0) break;
					(void) clistEditButtons(global.panel.commandListEdit, CLIST_EDIT_CLEAR_LIST, EVENT_COMMIT, 0, 1, 0);
					(void) clistEditButtons(global.panel.commandListEdit, CLIST_EDIT_INSERT_LIST, EVENT_COMMIT, file, 1, 0);
					SetActivePanel(global.panel.commandListEdit);
					break;
				case CLISTP_RESET_CTRL_THREAD:   /* reset control thread */
 			   		if(host->cmdListExecState!=CMDLISTEXEC_IDLE){
 			   			host->cmdListExecState=CMDLISTEXEC_ABORT;
	     				errorId=setEvent(host->commandDone_event);
						ERROR_CHECK(errorId, waitForEvent());
					}

					/* no break */
				case CLISTP_RESUME_CTRL_THREAD:  /* resume control thread */
 			   		if(host->cmdListExecState==CMDLISTEXEC_BUSY){
	     				errorId=setEvent(host->commandDone_event);
						ERROR_CHECK(errorId, waitForEvent());
					}
					errorId=resumeThread(host->cmdListExecThread.handle);
					HOST_ERROR_CHECK(errorId, host, resumeThread());
					break;

				default: break;
			}
			break;
		case EVENT_VAL_CHANGED:
			switch(control){
				case CLISTP_NUM_OF_LIST_REP:
					GetCtrlVal(panel, control, &host->option.commandListRepetitions);
					break;
				default: break;
			}
		case EVENT_LEFT_CLICK:
			switch(control){
				case CLISTP_LIST_FILE:
					status = FileSelectPopup (global.testingDataDir, "*.cl", "*.cl", "",VAL_SELECT_BUTTON, 0, 1, 1, 1, file);
					if(status==VAL_NO_FILE_SELECTED){
						file[0]=0;
						break;
					}
					SetCtrlVal(panel, control, file);

					break;

				default: break;
			}
			break;
	}

	return 0;
}
/*=============================================================================
 *                               txtBuffWindowMenu()
 *=============================================================================
 *
 *
 *
 */
void CVICALLBACK txtBuffWindowMenu(int menuBar, int menuItem, void *callbackData, int panel){

	int status;
	const struct HOST *host;
	char commandLineString[MAX_PATHNAME_LEN]=EXTERNAL_EDITOR;
	char fileName[MAX_PATHNAME_LEN];
	char string[100];
	unsigned char hostIndex;


	switch(menuItem){

   		case TXT_BUFF_CLEAR_WINDOW:
   			status=ResetTextBox (panel, TEXT_PANEL_TEXTBOX, "");
 			if(status!=0){
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "ResetTextBox()", status, "");
			}
   			break;

   		case TXT_BUFF_OPEN_TXT_FILE:
   			GetCtrlVal(panel, TEXT_PANEL_HOST_INDEX, &hostIndex);
   			host=global.host[hostIndex];
   			strcpy(fileName, host->dataDir);

   			if(panel==host->panel.txtBuff[ERR_BUFF]){
   				strcat(fileName, ERROR_BUFFER_FILE_NAME);
   			} else {
   				if(panel==host->panel.txtBuff[INFO_BUFF]){
   				strcat(fileName, INFO_BUFFER_FILE_NAME);
   				} else {
   					if(panel==host->panel.txtBuff[DIAG_BUFF]){
   						strcat(fileName, DIAG_BUFFER_FILE_NAME);
   					} else {
   						if(panel==host->panel.txtBuff[XFER_BUFF]){
   							strcat(fileName, XFER_BUFFER_FILE_NAME);
   						} else {
   							ERROR_CHECK(PROGRAM_WARNING, strange panelHandle!);
   						}
   					}
   				}
   			}

	        sprintf(string,"%d.TXT", host->slotNumber);
	        strcat(fileName, string);
			strcat(commandLineString," ");
			status=LaunchExecutable (strcat(commandLineString, fileName));
			if(status!=0){
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "LaunchExecutable()", status, "");
			}
			break;

		case TXT_BUFF_CLOSE_WINDOW:
			status=HidePanel(panel);
			UIR_STATUS_CHECK(status, HidePanel());
			break;
		default: ;

	}
}

/******************************************************************************/