/******************************************************************************
 * 
 *  Title  : primListEditUir.c 
 *  Version 0.0
 *   
 *  Description: Primitive list editor user interface callback functions.    
 *  Related files:primListEditUir.uir
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

#include <stdio.h>
#include <stdlib.h>

#include "primListEditUir.h"
#include "hostDefinitions.h"
#include "fileUtility.h"    
#include "globalDefinitions.h"     
#include "uirUtility.h"      
#include "mainUir.h"
#include "hostUtility.h"  
#include "primParamsUir.h"
#include "primFunctionInit.h"
#include "RWlists.h"
#include "primListRevisionUpdate.h"

#define I_AM_MASTER_DSP
#undef  IDREGS_BASE
#include "memoryPartitions.h"  //dspf: MDSP_PRM_BFR_SZ, MDSP_REP_BFR_SZ => use memory map.
#undef  I_AM_MASTER_DSP

/******************************************************************************
 *                        Static Function Declarations                        *
 ******************************************************************************/
 
static void preprocessMasterList(struct LIST_TABLE *listTable);
static void preprocessSlaveList(struct PRIM_TABLE *firstSlavePrimTable, struct MSG_LIST_HEAD *inSlaveListHeader, UINT32 *slvReplyLength, UINT32 *slvReplyCount);
static int listSizeLimitCheck(struct LIST_TABLE *listTable);

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

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

	unsigned char hostIndex;
	int status;
	struct HOST *host;
	ERROR_ID errorId;
	static UINT32 masterRepPrimCountMem;
	static UINT32 masterPrimListLengthMem;
	static UINT32 masterRepListLengthMem;
	
	static struct MSG_LIST_HEAD *inSlaveListHeader;
	static UINT32 *slvReplyLength;
	static UINT32 *slvReplyCount; 
	//static struct MSG_LIST_HEAD *outSlaveListHeader; 
	static struct PRIM_TABLE *firstSlavePrimTable;
	static UINT32 firstSlavePrimTableIndex;         
	
	struct PRIM_TABLE *primTable;

	unsigned int tableLength;
	char primitiveText[200];
	char primitiveName[200];
	static int masterRowIndex, slaveRowIndex;
	static int masterPrimIndex, slavePrimIndex;
	static int tablePrimIndex; 
	unsigned int arrayIndex;
	int index;
	void *listPtr;  /* void */
	char file[PATHNAME_LENGTH];
	void *filePtr;
	UINT32 length, length2;
	
	static struct LIST_TABLE listEdit;	    /* list currently opened in ListEditWindow */  

	struct LIST_TABLE *listLoad;
	struct PRIM_TABLE *newPrim, *primLoad;
	UINT32 maxLength;
	int itemIndex;
	int numRows;
	int value;
	
	
	Point tablePoint;
	unsigned char slotNumber;
	unsigned int primitiveId;         
	Rect tableRect;
	UINT32 primitiveIndex;
	UINT32 *buffer; 
	unsigned int fileSize;
	char text[300];
	UINT32 sendSlaveListPrimCount;
	struct MSG_LIST_HEAD *primListHeaderPtr;
	struct MSG_LIST_HEAD *repListHeaderPtr;
	int option;
	static fakekey=0;
	const int sendSlListIntId=getPrimArrayId(SEND_SLAVE_LIST);
	
	UINT32 slaveListLength;
	int buildOrExec;
	unsigned int repetitions;
	unsigned char slaveDsp;

	char lastList[300];
	char directory[300];
	
	
if(panel==global.panel.primListEdit){ 

	if((control==LIST_EDIT_LIST_TABLE)&&(event==EVENT_LEFT_CLICK)){
		if(global.editPrimitiveId!=SEND_SLAVE_LIST) return 0;
		
		status = SetInputMode(global.panel.primEdit[sendSlListIntId], SEND_SLIST_EDIT_SLAVE_LIST, 0);
		UIR_STATUS_CHECK(status, SetInputMode());		
		SetCtrlVal(global.panel.primEdit[sendSlListIntId], SEND_SLIST_LIST_LENGTH, 0); 
	
		return 0;
	}
	
	if((event==EVENT_COMMIT)||(event==EVENT_LEFT_DOUBLE_CLICK)||(event==EVENT_KEYPRESS)){						                          
		
		switch(control){
		
		case LIST_EDIT_CLEAR_LCOMM:
			ResetTextBox(panel, LIST_EDIT_LIST_COMMENT, 0);
			break;
		case LIST_EDIT_CLEAR_PCOMM:
			ResetTextBox(panel, LIST_EDIT_PRIM_COMMENT, 0); 
			break;
		
		case LIST_EDIT_SEND_LIST:
		
			GetCtrlVal(panel, LIST_EDIT_SLOT_NUMBER, &slotNumber);
			if(slotNumber!=ALL_RODS){
				host=global.host[HOST_INDEX(slotNumber)];
		
				if(host==NULL){
					sprintf(text, "ROD in slot#%d not loaded!!", slotNumber);
					status = MessagePopup ("WARNING", text);
					UIR_STATUS_CHECK(status, MessagePopup());
					break;
				}
			}
		
			if(listEdit.allPrimCount==0){
				status=MessagePopup ("Warning", "Primitive list is empty!");
				UIR_STATUS_CHECK(status, MessagePopup());
				break;
			}
			
			/* check limits */
			status=listSizeLimitCheck(&listEdit);
			if(status!=0){
				break;
			}
			GetCtrlVal(panel, LIST_EDIT_PLIST_REP, &repetitions);
			//GetCtrlVal(global.panel.main, MAIN_REPEAT_BUILD_EXEC, &buildOrExec);
			buildOrExec=1; /* repeat execution */
			
			if(slotNumber==ALL_RODS) hostIndex=0; //all rods 
			else hostIndex=HOST_INDEX(slotNumber); //only one rod
	
			for( ; hostIndex<MAXRODS; ++hostIndex){
		
				host=global.host[hostIndex];
				if(host==NULL){
					if(slotNumber!=ALL_RODS){ //only one rod
						break;
					}else continue; // all rods
				}
		
				errorId=executePrimList(host, &listEdit, repetitions, !buildOrExec, 0);
				ERROR_CHECK(errorId, executePrimList());
		
				if(slotNumber!=0) break; //only one rod
			}
			
			break;
		
		case LIST_EDIT_ADD_BEFORE:				/* add primitive to list */
				/* NO BREAK */
		case LIST_EDIT_REPLACE:
				/* NO BREAK */
		case LIST_EDIT_ADD_AFTER:
				/* NO BREAK */
			//GetCtrlVal(global.panel.listEdit, LIST_EDIT_PRIM_RING_SLAVE, &primitiveId); 
			
		   	status=GetActiveTableCell (panel, LIST_EDIT_LIST_TABLE, &tablePoint);
			UIR_STATUS_CHECK(status, GetActiveTableCell());  
			masterRowIndex=tablePoint.y;
			
			if((control!=LIST_EDIT_REPLACE)&&(listEdit.allPrimCount>=MAXPRIMS_IN_LIST)){
				status = MessagePopup ("WARNING", "PrimCount>MAXPRIMS_IN_LIST!!");
				UIR_STATUS_CHECK(status, MessagePopup());
				break;
			}
			
			if((masterRowIndex>0)&&(control!=LIST_EDIT_ADD_AFTER)){  /* *numMsgs==0  ie. rowIndex==0 */
				masterPrimIndex=masterRowIndex-1;
			} else {
				masterPrimIndex=masterRowIndex;
			}
			if(masterPrimIndex>0){
				tablePrimIndex=listEdit.masterToTablePrimIndex[masterPrimIndex-1];
				primTable=&listEdit.primTable[tablePrimIndex];
				if(primTable->inPrimHeader.id==SEND_SLAVE_LIST){
					tablePrimIndex+=primTable->params.sendSlaveList.inSlaveListHeader.numMsgs;
				}
				++tablePrimIndex;
			}else{
				tablePrimIndex=0;
			}
			
			primTable=&listEdit.primTable[tablePrimIndex];

			if(listEdit.allPrimCount>0){
				if(control!=LIST_EDIT_REPLACE){
					memmove(&listEdit.primTable[tablePrimIndex+1], primTable, (listEdit.allPrimCount-tablePrimIndex)*sizeof(struct PRIM_TABLE));
				}
			}
			
			listEdit.masterToTablePrimIndex[masterPrimIndex]=tablePrimIndex;
			
			if((control!=LIST_EDIT_REPLACE)||(listEdit.allPrimCount==0)){      
				++(listEdit.allPrimCount);
				++(listEdit.inListHeader.numMsgs);
			}
			
			if(global.editPrimitiveId==SEND_SLAVE_LIST){
			
				GetCtrlVal(global.panel.primEdit[sendSlListIntId], SEND_SLIST_LIST_LENGTH, &slaveListLength); 
				if((slaveListLength==0)||(control!=LIST_EDIT_REPLACE)){
				
					status = SetInputMode(global.panel.primEdit[sendSlListIntId], SEND_SLIST_EDIT_SLAVE_LIST, 1);
					UIR_STATUS_CHECK(status, SetInputMode());

			   		masterRepPrimCountMem=listEdit.inListHeader.numMsgs;     			  
			    	masterPrimListLengthMem=listEdit.inListHeader.length; 			        
			    	masterRepListLengthMem=listEdit.replyLength;   
			
					firstSlavePrimTableIndex=tablePrimIndex+1;
					firstSlavePrimTable=primTable+1;
				
					inSlaveListHeader=&primTable->params.sendSlaveList.inSlaveListHeader;	
					slvReplyLength=&primTable->params.sendSlaveList.replyLength;
					slvReplyCount=&primTable->params.sendSlaveList.replyCount;  
				
					inSlaveListHeader->numMsgs=0; /* !!! */
				
					preprocessSlaveList(firstSlavePrimTable, inSlaveListHeader, slvReplyLength, slvReplyCount);
					SetCtrlVal(global.panel.primEdit[sendSlListIntId], SEND_SLIST_LIST_LENGTH, inSlaveListHeader->length);

					status = GetNumTableRows (global.panel.slaveList, SLAVE_LST_LIST_TABLE, &numRows);
					UIR_STATUS_CHECK(status, DeleteTableRows());
					if(numRows>0){
						status = DeleteTableRows (global.panel.slaveList, SLAVE_LST_LIST_TABLE, 1, -1);
						UIR_STATUS_CHECK(status, SetTableCellVal());
					}	
				}

			}
			
			
			/* add primititive to primitive list */
			maxLength= PRIM_BUFF_SIZE/4-(listEdit.inListHeader.length);   
			errorId=(*global.primFunction[getPrimArrayId(global.editPrimitiveId)])(PRIM_PANEL_TO_TABLE, primTable, NULL, maxLength, 0);  
		    ERROR_CHECK(errorId, primFunction());
		    if(errorId!=SUCCESS) return(errorId);
		    
		    /* get comment */
		    GetCtrlVal(panel, LIST_EDIT_PRIM_COMMENT, primTable->comment);
			
			if((control!=LIST_EDIT_REPLACE)||(masterRowIndex==0)){
				status = InsertTableRows (panel, LIST_EDIT_LIST_TABLE, masterPrimIndex+1, 1, VAL_USE_MASTER_CELL_TYPE);
				UIR_STATUS_CHECK(status, InsertTableRows());   
			}
			status = GetCtrlIndex (panel, LIST_EDIT_PRIM_RING_MASTER, &itemIndex); 
			UIR_STATUS_CHECK(status, GetCtrlIndex()); 
			status = GetLabelFromIndex (panel, LIST_EDIT_PRIM_RING_MASTER, itemIndex, primitiveName);
			UIR_STATUS_CHECK(status, GetLabelFromIndex());
			   
			status=SetTableCellVal (panel, LIST_EDIT_LIST_TABLE, MakePoint(1, masterPrimIndex+1), primitiveName);         
			UIR_STATUS_CHECK(status, SetTableCellVal()); 
			status=SetTableCellVal (panel, LIST_EDIT_LIST_TABLE, MakePoint(2, masterPrimIndex+1), primTable->inPrimHeader.length);         
			UIR_STATUS_CHECK(status, SetTableCellVal());
			status=SetTableCellVal (panel, LIST_EDIT_LIST_TABLE, MakePoint(3, masterPrimIndex+1), primTable->replyLength);         
			UIR_STATUS_CHECK(status, SetTableCellVal()); 

			status = SetTableSelection (panel, LIST_EDIT_LIST_TABLE, MakeRect(masterPrimIndex+1,1,1,3));
			UIR_STATUS_CHECK(status, SetTableSelection()); 
			
			preprocessMasterList(&listEdit); /* !!! */    
			
			break;
		case LIST_EDIT_LIST_TABLE: /* double click */
			GetCtrlVal(panel, LIST_EDIT_DSP, &slaveDsp);
			if(slaveDsp) break;
			/* no break here */
		case LIST_EDIT_EDIT_PRIMITIVE:
			
			status=GetActiveTableCell (panel, LIST_EDIT_LIST_TABLE, &tablePoint);
		   	UIR_STATUS_CHECK(status, SetTableCellVal());
		
			masterRowIndex=tablePoint.y;
			
			if((listEdit.inListHeader.numMsgs==0)){  
				break;
			} else {
				masterPrimIndex=masterRowIndex-1;
			}
			
			tablePrimIndex=listEdit.masterToTablePrimIndex[masterPrimIndex];  
			primTable=&listEdit.primTable[tablePrimIndex];
			primitiveId=primTable->inPrimHeader.id;
			SetCtrlVal(panel, LIST_EDIT_PRIM_RING_MASTER, primitiveId);
			status=HidePanel(global.panel.primEdit[getPrimArrayId(global.editPrimitiveId)]);
			UIR_STATUS_CHECK(status, HidePanel());
			if(global.editPrimitiveId==SEND_SLAVE_LIST){
				status = SetInputMode(global.panel.primEdit[sendSlListIntId], SEND_SLIST_EDIT_SLAVE_LIST, 0);
				UIR_STATUS_CHECK(status, SetInputMode());
				SetCtrlVal(global.panel.primEdit[sendSlListIntId], SEND_SLIST_LIST_LENGTH, 0); 
			}
			
			global.editPrimitiveId=primitiveId;
			status=DisplayPanel(global.panel.primEdit[getPrimArrayId(primitiveId)]);
			UIR_STATUS_CHECK(status, DisplayPanel());
			
			errorId=(*global.primFunction[getPrimArrayId(primitiveId)])(PRIM_TABLE_TO_PANEL, primTable, NULL, 0, 0);  
		    ERROR_CHECK(errorId, primFunction());
		    if(errorId!=SUCCESS) return(errorId);
		    
		    /* set comment */
		    ResetTextBox(panel, LIST_EDIT_PRIM_COMMENT, primTable->comment);
		    
		    /* if send slave list -> update slave list window */ 
			if(global.editPrimitiveId==SEND_SLAVE_LIST){
				status = SetInputMode(global.panel.primEdit[sendSlListIntId], SEND_SLIST_EDIT_SLAVE_LIST, 1);
				UIR_STATUS_CHECK(status, SetInputMode());
				
			   	masterRepPrimCountMem=listEdit.inListHeader.numMsgs;     			  
			    masterPrimListLengthMem=listEdit.inListHeader.length; 			        
			    masterRepListLengthMem=listEdit.replyLength;   
				
				firstSlavePrimTableIndex=tablePrimIndex+1;      
				firstSlavePrimTable=primTable+1;
				
				inSlaveListHeader=&primTable->params.sendSlaveList.inSlaveListHeader;	
				slvReplyLength=&primTable->params.sendSlaveList.replyLength;
				slvReplyCount=&primTable->params.sendSlaveList.replyCount; 
				
				preprocessSlaveList(firstSlavePrimTable, inSlaveListHeader, slvReplyLength, slvReplyCount);
				
		  	  	/* clear slave primList window */
				status = GetNumTableRows (global.panel.slaveList, SLAVE_LST_LIST_TABLE, &numRows);
				UIR_STATUS_CHECK(status, DeleteTableRows());
				if(numRows>0){
					status = DeleteTableRows (global.panel.slaveList, SLAVE_LST_LIST_TABLE, 1, -1);
					UIR_STATUS_CHECK(status, SetTableCellVal());
				}	
			
				for(index=0; index<(inSlaveListHeader->numMsgs); ++index){
				
					UIR_STATUS_CHECK(status, InsertTableRows());
					primTable=firstSlavePrimTable+index;
				
					status = GetIndexFromValue (panel, LIST_EDIT_PRIM_RING_SLAVE, &itemIndex, primTable->inPrimHeader.id);
					UIR_STATUS_CHECK(status, GetLabelFromIndex());
					status = GetLabelFromIndex (panel, LIST_EDIT_PRIM_RING_SLAVE, itemIndex, primitiveName);
					UIR_STATUS_CHECK(status, GetLabelFromIndex());
				
					status = InsertTableRows (global.panel.slaveList, SLAVE_LST_LIST_TABLE, index+1, 1, VAL_USE_MASTER_CELL_TYPE);
					status=SetTableCellVal (global.panel.slaveList, SLAVE_LST_LIST_TABLE, MakePoint(1, index+1), primitiveName);         
					UIR_STATUS_CHECK(status, SetTableCellVal()); 
					status=SetTableCellVal (global.panel.slaveList, SLAVE_LST_LIST_TABLE, MakePoint(2, index+1), primTable->inPrimHeader.length);         
					UIR_STATUS_CHECK(status, SetTableCellVal());
					status=SetTableCellVal (global.panel.slaveList, SLAVE_LST_LIST_TABLE, MakePoint(3, index+1), primTable->replyLength);         
					UIR_STATUS_CHECK(status, SetTableCellVal()); 
				}	
				
			}	
		    
		    if((global.option.programExit==FALSE)&&(event==EVENT_KEYPRESS)){
		
				status=SetActivePanel(global.panel.primListEdit);
		    	UIR_STATUS_CHECK(status, SetActiveCtrl());
				//status=SetActiveCtrl (global.panel.slaveList, SLAVE_LST_LIST_TABLE);
				//UIR_STATUS_CHECK(status, SetActiveCtrl());
				status=SetActiveCtrl (global.panel.primListEdit, LIST_EDIT_LIST_TABLE);
		    	UIR_STATUS_CHECK(status, SetActiveCtrl());
		    	fakekey=!fakekey;
				if(fakekey){
					FakeKeystroke (VAL_BACKSPACE_VKEY); 
				}
		    
			}	
			preprocessMasterList(&listEdit); /* !!! */    
			break;
			
		case LIST_EDIT_DELETE_PRIMITIVE:
		
		   	if(global.editPrimitiveId==SEND_SLAVE_LIST){
				status = SetInputMode(global.panel.primEdit[sendSlListIntId], SEND_SLIST_EDIT_SLAVE_LIST, 0);
				UIR_STATUS_CHECK(status, SetInputMode());
				SetCtrlVal(global.panel.primEdit[sendSlListIntId], SEND_SLIST_LIST_LENGTH, 0); 
			}
					
		   	status=GetActiveTableCell (panel, LIST_EDIT_LIST_TABLE, &tablePoint);
		   	UIR_STATUS_CHECK(status, SetTableCellVal());
			masterRowIndex=tablePoint.y;

			if((listEdit.inListHeader.numMsgs==0)){  
				break;
			} else {
				masterPrimIndex=masterRowIndex-1;
				--(listEdit.inListHeader.numMsgs);
				--listEdit.allPrimCount;
			}
			tablePrimIndex=listEdit.masterToTablePrimIndex[masterPrimIndex];   
			primTable=&listEdit.primTable[tablePrimIndex];
			 
			/* slave list */ 
			if(primTable->inPrimHeader.id==SEND_SLAVE_LIST){
				sendSlaveListPrimCount=primTable->params.sendSlaveList.inSlaveListHeader.numMsgs;
				listEdit.allPrimCount-=sendSlaveListPrimCount;	
			}else{
				sendSlaveListPrimCount=0;
			}
			 
			if(listEdit.inListHeader.numMsgs>0){
				/* move one step up */
				memmove(primTable, &listEdit.primTable[tablePrimIndex+1+sendSlaveListPrimCount], (listEdit.allPrimCount-tablePrimIndex)*sizeof(struct PRIM_TABLE));
			}

			status = DeleteTableRows (panel, LIST_EDIT_LIST_TABLE, masterRowIndex, 1);
			UIR_STATUS_CHECK(status, SetTableCellVal());
				
			if(masterRowIndex>listEdit.inListHeader.numMsgs){
				masterRowIndex=listEdit.inListHeader.numMsgs;
			}

			status = SetTableSelection (panel, LIST_EDIT_LIST_TABLE, MakeRect(masterRowIndex,1,1,3));
			UIR_STATUS_CHECK(status, SetTableSelection());
			
			preprocessMasterList(&listEdit); /* !!! */ 

			break;

		case LIST_EDIT_LOAD_LIST:
			(void) listEditWindowButtons(global.panel.primListEdit, LIST_EDIT_CLEAR_LIST, EVENT_COMMIT, 0, 0, 0);
			(void) listEditWindowButtons(global.panel.primListEdit, LIST_EDIT_INSERT_LIST, EVENT_COMMIT, 0, 0, 0); 
			break;
	
		case LIST_EDIT_INSERT_LIST:
			//if(listEdit.inListHeader.MSG_LIST_TAIL!=PRIM_LIST_REVISION) error!!;     
			//listEdit.outListHeader.MSG_LIST_TAIL;  
			if(eventData1!=1){ 
				GetCtrlVal(panel, LIST_EDIT_LAST_FILE, directory);
				if(directory[0]==0) { 
					strcpy(directory, global.testingDataDir); 
					strcpy(lastList, "*.pl");
				}else{
					GetFirstFile (directory, 1, 0, 0, 0, 0, 0, lastList);
					directory[strlen(directory)-strlen(lastList)]=0;
				}
				status = FileSelectPopup (directory, lastList, "*.pl", "",VAL_SELECT_BUTTON, 0, 1, 1, 1, file);
				if(status==VAL_NO_FILE_SELECTED){
					break;
				}
				filePtr=file;
			}else{
				filePtr=callbackData;
			}
		
			listLoad=(struct LIST_TABLE*)calloc(1, sizeof(struct LIST_TABLE));    /* allocate and clear memory for data buffer */
			if(listLoad==NULL){
				ERROR_CHECK(PROGRAM_ERROR, calloc()); 
				return(0);
			}
			
			errorId=readPrimListFile(filePtr, listLoad); 	
			ERROR_CHECK(errorId, readPrimListFile());
			if(errorId!=SUCCESS){
				free(listLoad);
				return(0);
			}	
			
			if((listEdit.allPrimCount+listLoad->allPrimCount)>MAXPRIMS_IN_LIST){
 				status = MessagePopup ("WARNING", "PrimCount>MAXPRIMS_IN_LIST!!");
				UIR_STATUS_CHECK(status, MessagePopup());
				free(listLoad); /* !!! */          
				break;
			}
			status=GetActiveTableCell (panel, LIST_EDIT_LIST_TABLE, &tablePoint);
			UIR_STATUS_CHECK(status, GetActiveTableCell());
			masterRowIndex=tablePoint.y;
			
			if(listEdit.inListHeader.numMsgs==0){  
				masterPrimIndex=0;
				tablePrimIndex=0;
			} else {
				masterPrimIndex=masterRowIndex-1;
				tablePrimIndex=listEdit.masterToTablePrimIndex[masterPrimIndex];  
				primTable=&listEdit.primTable[tablePrimIndex];
				primitiveId=primTable->inPrimHeader.id;	
				if(primitiveId==SEND_SLAVE_LIST){
					tablePrimIndex+=(primTable->params.sendSlaveList.inSlaveListHeader.numMsgs);
				}
				tablePrimIndex++;
			}
			
			//tablePrimIndex=listEdit.masterToTablePrimIndex[masterPrimIndex];  
			primTable=&listEdit.primTable[tablePrimIndex];
			
			memmove((primTable+listLoad->allPrimCount), primTable, (listEdit.allPrimCount-tablePrimIndex)*sizeof(struct PRIM_TABLE));
			memcpy(primTable, (UINT32*)&listLoad->primTable, listLoad->allPrimCount*sizeof(struct PRIM_TABLE));	
	

			if (listEdit.allPrimCount==0) ResetTextBox(panel, LIST_EDIT_LIST_COMMENT, listLoad->comment);   
			
			listEdit.allPrimCount+=listLoad->allPrimCount;
			listEdit.inListHeader.numMsgs+=listLoad->inListHeader.numMsgs;
			
			preprocessMasterList(&listEdit); /* !!! */
			
			/* delete table */
			status = GetNumTableRows (panel, LIST_EDIT_LIST_TABLE, &numRows);
			UIR_STATUS_CHECK(status, DeleteTableRows());
			if(numRows>0){
				status = DeleteTableRows (panel, LIST_EDIT_LIST_TABLE, 1, -1);
				UIR_STATUS_CHECK(status, GetNumTableRows());
			}
		
			/* add to table */
			for(index=0; index<listEdit.inListHeader.numMsgs; ++index){
				
				tablePrimIndex=listEdit.masterToTablePrimIndex[index];
				primTable=&listEdit.primTable[tablePrimIndex];
				
				status = GetIndexFromValue (panel, LIST_EDIT_PRIM_RING_MASTER, &itemIndex, primTable->inPrimHeader.id);
				UIR_STATUS_CHECK(status, GetIndexFromValue());
				status = GetLabelFromIndex (panel, LIST_EDIT_PRIM_RING_MASTER, itemIndex, primitiveName);
				UIR_STATUS_CHECK(status, GetLabelFromIndex());
				
				masterPrimIndex=index+1;
				
				status = InsertTableRows (panel, LIST_EDIT_LIST_TABLE, masterPrimIndex, 1, VAL_USE_MASTER_CELL_TYPE);
				UIR_STATUS_CHECK(status, InsertTableRows());   
				status=SetTableCellVal (panel, LIST_EDIT_LIST_TABLE, MakePoint(1, masterPrimIndex), primitiveName);         
				UIR_STATUS_CHECK(status, SetTableCellVal()); 
				status=SetTableCellVal (panel, LIST_EDIT_LIST_TABLE, MakePoint(2, masterPrimIndex), primTable->inPrimHeader.length);         
				UIR_STATUS_CHECK(status, SetTableCellVal());
				status=SetTableCellVal (panel, LIST_EDIT_LIST_TABLE, MakePoint(3, masterPrimIndex), primTable->replyLength);         
				UIR_STATUS_CHECK(status, SetTableCellVal()); 
				
			}		
			
			free(listLoad); /* !!! */
			SetCtrlVal(panel, LIST_EDIT_LAST_FILE, filePtr);
			
			break;
		case LIST_EDIT_SAVE_LIST:

			if(global.editPrimitiveId==SEND_SLAVE_LIST){
				status = SetInputMode(global.panel.primEdit[sendSlListIntId], SEND_SLIST_EDIT_SLAVE_LIST, 0);
				UIR_STATUS_CHECK(status, SetInputMode());
				SetCtrlVal(global.panel.primEdit[sendSlListIntId], SEND_SLIST_LIST_LENGTH, 0); 
			}
			
			/* check limits */
			status=listSizeLimitCheck(&listEdit);
			if(status!=0){
				break;
			}
			
			GetCtrlVal(panel, LIST_EDIT_LAST_FILE, directory);
			if(directory[0]==0) { 
				strcpy(directory, global.testingDataDir); 
				strcpy(lastList, "*.pl");
			}else{
				GetFirstFile (directory, 1, 0, 0, 0, 0, 0, lastList);
				directory[strlen(directory)-strlen(lastList)]=0;
			}
			status = FileSelectPopup (directory, lastList, "*.pl", "",VAL_SAVE_BUTTON, 0, 1, 1, 1, file);
			switch(status){
				case 0: /* no file selected */
					break;
				case 1: /* existing file selected */
					/* no break here */
				case 2: /* new file selected */
					//length=sizeof(UINT32)+MAXPRIMS_IN_LIST*sizeof(UINT32)+2*sizeof(struct MSG_LIST_HEAD)+listEdit.allPrimCount*sizeof(struct PRIM_TABLE);
				
					/* get comment */
		    		GetCtrlVal(panel, LIST_EDIT_LIST_COMMENT, listEdit.comment);
					errorId=writePrimListFile(file, &listEdit); 	
					ERROR_CHECK(errorId, writePrimListFile());
					if(errorId!=SUCCESS){
						return(0);
					}	
					
					SetCtrlVal(panel, LIST_EDIT_LAST_FILE, file);
					
					break;
				default:
					// error
					break;
			}
		
			break;
		case LIST_EDIT_CLEAR_LIST:
		
			if(eventData1!=1){
				GetCtrlVal(panel, LIST_EDIT_ALL_PRIM_COUNT, &value);
				if(value>0){
					status = ConfirmPopup ("Confirm popup", "Delete current list?");
					UIR_STATUS_CHECK(status, ConfirmPopup());   
					if(status==0){
						break;
					}
				}	
			}	
			
			status = SetInputMode(global.panel.primEdit[sendSlListIntId], SEND_SLIST_EDIT_SLAVE_LIST, 0);
			UIR_STATUS_CHECK(status, SetInputMode());
			SetCtrlVal(global.panel.primEdit[sendSlListIntId], SEND_SLIST_LIST_LENGTH, 0); 
			
			status = GetNumTableRows (panel, LIST_EDIT_LIST_TABLE, &numRows);
			UIR_STATUS_CHECK(status, DeleteTableRows());
			if(numRows>0){
				status = DeleteTableRows (panel, LIST_EDIT_LIST_TABLE, 1, -1);
				UIR_STATUS_CHECK(status, GetNumTableRows());
			}	
			
			listEdit.allPrimCount=0;
			listEdit.inListHeader.numMsgs=0;
			ResetTextBox(panel, LIST_EDIT_LIST_COMMENT, 0);
			
			preprocessMasterList(&listEdit); /* !!! */  
			break;
	
			default: ;
				//programError(__FILE__, __LINE__, PROGRAM_ERROR, "primTableReadyFunc()", 0,"-non known control.");	
		}	
	}
	if(global.option.programExit==FALSE){
		
		status=SetActiveCtrl (panel, LIST_EDIT_LIST_TABLE);
		UIR_STATUS_CHECK(status, SetActiveCtrl());
			
			
	}	
		
		
}else{
	if(panel==global.panel.slaveList){
	
		if((event==EVENT_COMMIT)||(event==EVENT_LEFT_DOUBLE_CLICK)){						                          
                             
		switch(control){
		
			case SLAVE_LST_ADD_BEFORE:				/* add primitive to list */
					/* NO BREAK */
			case SLAVE_LST_REPLACE:
					/* NO BREAK */
			case SLAVE_LST_ADD_AFTER:
					/* NO BREAK */
				
			   	status=GetActiveTableCell (panel, SLAVE_LST_LIST_TABLE, &tablePoint);
				UIR_STATUS_CHECK(status, GetActiveTableCell());  
				slaveRowIndex=tablePoint.y;
				
				if((control!=SLAVE_LST_REPLACE)&&(listEdit.allPrimCount>=MAXPRIMS_IN_LIST)){
	 				status = MessagePopup ("WARNING", "PrimCount>MAXPRIMS_IN_LIST!!");
					UIR_STATUS_CHECK(status, MessagePopup());
					break;
				}

				if((slaveRowIndex>0)&&(control!=SLAVE_LST_ADD_AFTER)){  /* *numMsgs==0  ie. rowIndex==0 */
					slavePrimIndex=slaveRowIndex-1;
				} else {
					slavePrimIndex=slaveRowIndex;
				}
				
				primTable=firstSlavePrimTable+slavePrimIndex;
				tablePrimIndex=firstSlavePrimTableIndex+slavePrimIndex;
					
				
				if((control!=SLAVE_LST_REPLACE)||(inSlaveListHeader->numMsgs==0)){
					/* move one step down */ 
					memmove(primTable+1, primTable, (listEdit.allPrimCount-tablePrimIndex)*sizeof(struct PRIM_TABLE));
				}
			
				if((control!=SLAVE_LST_REPLACE)||(inSlaveListHeader->numMsgs==0)){      
					++(inSlaveListHeader->numMsgs);
					++listEdit.allPrimCount;
				}
			
				/* add primititive to primitive list */
				maxLength= PRIM_BUFF_SIZE/4-listEdit.inListHeader.length;   
				errorId=(*global.primFunction[getPrimArrayId(global.editPrimitiveId)])(PRIM_PANEL_TO_TABLE, primTable, NULL, maxLength, 0);  
			    ERROR_CHECK(errorId, primFunction());
			    if(errorId!=SUCCESS) return(errorId); 
			
				/* get comment */
		    	GetCtrlVal(global.panel.primListEdit, LIST_EDIT_PRIM_COMMENT, primTable->comment);

				if((control!=SLAVE_LST_REPLACE)||(slaveRowIndex==0)){
					status = InsertTableRows (panel, SLAVE_LST_LIST_TABLE, slavePrimIndex+1, 1, VAL_USE_MASTER_CELL_TYPE);
					UIR_STATUS_CHECK(status, InsertTableRows());   
				}
				status = GetCtrlIndex (global.panel.primListEdit, LIST_EDIT_PRIM_RING_SLAVE, &itemIndex); 
				UIR_STATUS_CHECK(status, GetCtrlIndex()); 
				status = GetLabelFromIndex (global.panel.primListEdit, LIST_EDIT_PRIM_RING_SLAVE, itemIndex, primitiveName);
				UIR_STATUS_CHECK(status, GetLabelFromIndex());
			   
				status=SetTableCellVal (panel, SLAVE_LST_LIST_TABLE, MakePoint(1, slavePrimIndex+1), primitiveName);         
				UIR_STATUS_CHECK(status, SetTableCellVal()); 
				status=SetTableCellVal (panel, SLAVE_LST_LIST_TABLE, MakePoint(2, slavePrimIndex+1), primTable->inPrimHeader.length);         
				UIR_STATUS_CHECK(status, SetTableCellVal());
				status=SetTableCellVal (panel, SLAVE_LST_LIST_TABLE, MakePoint(3, slavePrimIndex+1), primTable->replyLength);         
				UIR_STATUS_CHECK(status, SetTableCellVal()); 

				status = SetTableSelection (panel, SLAVE_LST_LIST_TABLE, MakeRect(slavePrimIndex+1,1,1,3));
				UIR_STATUS_CHECK(status, SetTableSelection());  
			    
			    preprocessSlaveList(firstSlavePrimTable, inSlaveListHeader, slvReplyLength, slvReplyCount);  
		        preprocessMasterList(&listEdit); /* !!! */      
			
				break;
			case SLAVE_LST_LIST_TABLE: /* double click */
				/* no break here */
			case SLAVE_LST_EDIT_PRIMITIVE:
			
				status=GetActiveTableCell (panel, SLAVE_LST_LIST_TABLE, &tablePoint);
			   	UIR_STATUS_CHECK(status, SetTableCellVal());
		
				slaveRowIndex=tablePoint.y;
			
				if(inSlaveListHeader->numMsgs==0){  
					break;
				} else {
					slavePrimIndex=slaveRowIndex-1;
				}
				
				primTable=firstSlavePrimTable+slavePrimIndex;
				tablePrimIndex=firstSlavePrimTableIndex+slavePrimIndex;
				
				primitiveId=primTable->inPrimHeader.id;
				SetCtrlVal(global.panel.primListEdit, LIST_EDIT_PRIM_RING_SLAVE, primitiveId);
				status=HidePanel(global.panel.primEdit[getPrimArrayId(global.editPrimitiveId)]);
				UIR_STATUS_CHECK(status, HidePanel());
			
				global.editPrimitiveId=primitiveId;
				status=DisplayPanel(global.panel.primEdit[getPrimArrayId(primitiveId)]);
				UIR_STATUS_CHECK(status, DisplayPanel());
			
				errorId=(*global.primFunction[getPrimArrayId(primitiveId)])(PRIM_TABLE_TO_PANEL, primTable, NULL, 0, 0);  
			    ERROR_CHECK(errorId, primFunction());
			    if(errorId!=SUCCESS) return(errorId);
			    
			    /* set comment */
		    	ResetTextBox(global.panel.primListEdit, LIST_EDIT_PRIM_COMMENT, primTable->comment);

				break;
			
			case SLAVE_LST_DELETE_PRIMITIVE:
			
			   	status=GetActiveTableCell (panel, SLAVE_LST_LIST_TABLE, &tablePoint);
			   	UIR_STATUS_CHECK(status, SetTableCellVal());
				slaveRowIndex=tablePoint.y;

				if(inSlaveListHeader->numMsgs==0){  
					break;
				} else {
					slavePrimIndex=slaveRowIndex-1;
					--inSlaveListHeader->numMsgs;
					--listEdit.allPrimCount;
				}
				
				primTable=firstSlavePrimTable+slavePrimIndex;
				tablePrimIndex=firstSlavePrimTableIndex+slavePrimIndex;
					
				/* move one step up */ 
				memmove(primTable, primTable+1, (listEdit.allPrimCount-tablePrimIndex)*sizeof(struct PRIM_TABLE));

				status = DeleteTableRows (panel, SLAVE_LST_LIST_TABLE, slaveRowIndex, 1);
				UIR_STATUS_CHECK(status, SetTableCellVal());
				
				if(slaveRowIndex>inSlaveListHeader->numMsgs){
					slaveRowIndex=inSlaveListHeader->numMsgs;
				}

				status = SetTableSelection (panel, SLAVE_LST_LIST_TABLE, MakeRect(slaveRowIndex,1,1,3));
				UIR_STATUS_CHECK(status, SetTableSelection());

			    //listEdit.allPrimCount=allPrimCountMem+inSlaveListHeader->numMsgs;  
				
			    preprocessSlaveList(firstSlavePrimTable, inSlaveListHeader, slvReplyLength, slvReplyCount);     
		        preprocessMasterList(&listEdit); /* !!! */      
				break;
				

			case SLAVE_LST_LOAD_LIST:
				//if(listEdit.inListHeader.MSG_LIST_TAIL!=PRIM_LIST_REVISION) error!!;     
				//listEdit.outListHeader.MSG_LIST_TAIL;  
				status = FileSelectPopup (global.testingDataDir, "*.slist", "*.slist", "",VAL_SELECT_BUTTON, 0, 1, 1, 1, file);
				if(status==VAL_NO_FILE_SELECTED){
					break;
				}
			
				errorId=getFileSize(file, &fileSize);
				ERROR_CHECK(errorId, getFileSize());
				if(errorId!=SUCCESS) return(errorId);
				if(fileSize%4){
					ERROR_CHECK(PROGRAM_ERROR, wrong file size!!);
					return(0); 
				}
				buffer=calloc(fileSize, sizeof(UINT8));    /* allocate and clear memory for data buffer */
				if(buffer==NULL){
					ERROR_CHECK(PROGRAM_ERROR, calloc()); 
					return(0);
				}
				
				errorId=readFromBinFile(file, buffer, fileSize);
				ERROR_CHECK(errorId, readFromBinFile());
				if(errorId!=SUCCESS){
					free(buffer);
					return(0);
				}	
				
				primListHeaderPtr=(struct MSG_LIST_HEAD*)buffer;
				repListHeaderPtr=(struct MSG_LIST_HEAD*)((UINT32)buffer+sizeof(struct MSG_LIST_HEAD)); 
				
				if((listEdit.allPrimCount+primListHeaderPtr->numMsgs)>MAXPRIMS_IN_LIST){
	 				status = MessagePopup ("WARNING", "PrimCount>MAXPRIMS_IN_LIST!!");
					UIR_STATUS_CHECK(status, MessagePopup());
					free(buffer); /* !!! */          
					break;
				}
			
				status=GetActiveTableCell (panel, SLAVE_LST_LIST_TABLE, &tablePoint);
			   	UIR_STATUS_CHECK(status, SetTableCellVal());
		
				slaveRowIndex=tablePoint.y;
				//if(slaveRowIndex>0){  /* *numMsgs==0  ie. rowIndex==0 */
				//	slavePrimIndex=slaveRowIndex-1;
				//} else {
					slavePrimIndex=slaveRowIndex;
				//}
			
				primTable=firstSlavePrimTable+slavePrimIndex;
				tablePrimIndex=firstSlavePrimTableIndex+slavePrimIndex;
				
				/* move down */ 
				memmove((primTable+primListHeaderPtr->numMsgs), primTable, (listEdit.allPrimCount-tablePrimIndex)*sizeof(struct PRIM_TABLE));

				length=2*sizeof(struct MSG_LIST_HEAD);
				memcpy(primTable, buffer+(length/sizeof(UINT32)), fileSize-length);	

				listEdit.allPrimCount+=primListHeaderPtr->numMsgs;
				
				inSlaveListHeader->numMsgs+=primListHeaderPtr->numMsgs;
				
			    preprocessSlaveList(firstSlavePrimTable, inSlaveListHeader, slvReplyLength, slvReplyCount);     
		        preprocessMasterList(&listEdit); /* !!! */      
				
				for(index=slavePrimIndex; index<(primListHeaderPtr->numMsgs+slavePrimIndex); ++index){
				
					primTable=firstSlavePrimTable+index;
				
					status = GetIndexFromValue (global.panel.primListEdit, LIST_EDIT_PRIM_RING_SLAVE, &itemIndex, primTable->inPrimHeader.id);
					UIR_STATUS_CHECK(status, GetLabelFromIndex());
					status = GetLabelFromIndex (global.panel.primListEdit, LIST_EDIT_PRIM_RING_SLAVE, itemIndex, primitiveName);
					UIR_STATUS_CHECK(status, GetLabelFromIndex());
				
					status = InsertTableRows (global.panel.slaveList, SLAVE_LST_LIST_TABLE, index+1, 1, VAL_USE_MASTER_CELL_TYPE);
					UIR_STATUS_CHECK(status, InsertTableRows());   
					status=SetTableCellVal (global.panel.slaveList, SLAVE_LST_LIST_TABLE, MakePoint(1, index+1), primitiveName);         
					UIR_STATUS_CHECK(status, SetTableCellVal()); 
					status=SetTableCellVal (global.panel.slaveList, SLAVE_LST_LIST_TABLE, MakePoint(2, index+1), primTable->inPrimHeader.length);         
					UIR_STATUS_CHECK(status, SetTableCellVal());
					status=SetTableCellVal (global.panel.slaveList, SLAVE_LST_LIST_TABLE, MakePoint(3, index+1), primTable->replyLength);         
					UIR_STATUS_CHECK(status, SetTableCellVal()); 
				}	
				
				free(buffer); /* !!! */     
			
				SetCtrlVal(panel, SLAVE_LST_LAST_FILE, file);  
				
				break;
				
			case SLAVE_LST_SAVE_LIST:
	
				/* check limits */
				status=listSizeLimitCheck(&listEdit);
				if(status!=0){
					break;
				}
			
				status = FileSelectPopup (global.testingDataDir, "*.slist", "*.slist", "",VAL_SAVE_BUTTON, 0, 1, 1, 1, file);
				switch(status){
					case 0: /* no file selected */
						break;
					case 1: /* existing file selected */
						/* no break here */
					case 2: /* new file selected */
						errorId=writeToBinFile(file, 0, inSlaveListHeader, 2*sizeof(struct MSG_LIST_HEAD));
						errorId=writeToBinFile(file, 1, firstSlavePrimTable, inSlaveListHeader->numMsgs*sizeof(struct PRIM_TABLE));
						ERROR_CHECK(errorId, writeToBinFile()); 
						SetCtrlVal(panel, SLAVE_LST_LAST_FILE, file);
						break;
					default:
						// error
						break;
				}
				
				break;
				
			case SLAVE_LST_CLEAR_LIST:

				status = ConfirmPopup ("Confirm popup", "Delete slave list?");
				UIR_STATUS_CHECK(status, ConfirmPopup());   
				if(status==0){
					break;
				}
				
				primTable=firstSlavePrimTable+inSlaveListHeader->numMsgs;
				tablePrimIndex=firstSlavePrimTableIndex+inSlaveListHeader->numMsgs;
				
				
				/* move up */ 
				memmove(firstSlavePrimTable, primTable, (listEdit.allPrimCount-tablePrimIndex)*sizeof(struct PRIM_TABLE));

				listEdit.allPrimCount-=inSlaveListHeader->numMsgs;  
				inSlaveListHeader->numMsgs=0;  
				
				status = GetNumTableRows (panel, SLAVE_LST_LIST_TABLE, &numRows);
				UIR_STATUS_CHECK(status, DeleteTableRows());
				if(numRows>0){
					status = DeleteTableRows (panel, SLAVE_LST_LIST_TABLE, 1, -1);
					UIR_STATUS_CHECK(status, SetTableCellVal());
				}	
			
			    preprocessSlaveList(firstSlavePrimTable, inSlaveListHeader, slvReplyLength, slvReplyCount);     
		        preprocessMasterList(&listEdit); /* !!! */      
			
				break;


			case SLAVE_LST_SLIST_DONE:
		
				status=HidePanel(global.panel.slaveList);
				UIR_STATUS_CHECK(status, HidePanel());
			
				SetCtrlVal(global.panel.primListEdit, LIST_EDIT_DSP, 0);
			
				status=SetCtrlAttribute(global.panel.primListEdit, LIST_EDIT_PRIM_RING_MASTER, ATTR_VISIBLE, 1);
				UIR_STATUS_CHECK(status, SetCtrlAttribute());
				status=SetCtrlAttribute(global.panel.primListEdit, LIST_EDIT_PRIM_RING_SLAVE, ATTR_VISIBLE, 0);
				UIR_STATUS_CHECK(status, SetCtrlAttribute());
			
				status=HidePanel(global.panel.primEdit[getPrimArrayId(global.editPrimitiveId)]);
				UIR_STATUS_CHECK(status, HidePanel());
				GetCtrlVal(global.panel.primListEdit, LIST_EDIT_PRIM_RING_MASTER, &primitiveId);
				global.editPrimitiveId=primitiveId;
				status=DisplayPanel(global.panel.primEdit[getPrimArrayId(primitiveId)]);
				UIR_STATUS_CHECK(status, DisplayPanel()); 
				
				/* master sendSlaveList */
				primTable=firstSlavePrimTable-1;
				SetCtrlVal(global.panel.primEdit[sendSlListIntId], SEND_SLIST_LIST_LENGTH, inSlaveListHeader->length);

				status=SetTableCellVal (global.panel.primListEdit, LIST_EDIT_LIST_TABLE, MakePoint(2, masterPrimIndex+1), primTable->inPrimHeader.length);         
				UIR_STATUS_CHECK(status, SetTableCellVal());																	   
				status=SetTableCellVal (global.panel.primListEdit, LIST_EDIT_LIST_TABLE, MakePoint(3, masterPrimIndex+1), primTable->replyLength);         
				UIR_STATUS_CHECK(status, SetTableCellVal()); 
				status=SetActiveCtrl (global.panel.primListEdit, LIST_EDIT_LIST_TABLE);
				UIR_STATUS_CHECK(status, SetActiveCtrl());
				
				status=SetInputMode(global.panel.primListEdit, LIST_EDIT_SEND_LIST, 1);
				UIR_STATUS_CHECK(status, SetInputMode());
				
				preprocessMasterList(&listEdit); /* !!! */ 
				
				break;
	
			default: 
				programError(__FILE__, __LINE__, PROGRAM_ERROR, "primTableReadyFunc()", 0,"-non known control.");	
		}	
	}

	}

	if(global.option.programExit==FALSE){
	
		status=SetActiveCtrl (global.panel.slaveList, SLAVE_LST_LIST_TABLE);
		UIR_STATUS_CHECK(status, SetActiveCtrl());

	}	

}	

	
	return 0;
}

/*=============================================================================
 *                               primRing()
 *=============================================================================
 *
 *
 *
 */

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

	int status;
	unsigned char hostIndex;
	struct HOST *host;
	unsigned int primitiveId;
	const int sendSlListIntId=getPrimArrayId(SEND_SLAVE_LIST);

	if(event==EVENT_VAL_CHANGED){
		status=HidePanel(global.panel.primEdit[getPrimArrayId(global.editPrimitiveId)]);
		UIR_STATUS_CHECK(status, HidePanel());
		if(global.editPrimitiveId==SEND_SLAVE_LIST){
			status = SetInputMode(global.panel.primEdit[sendSlListIntId], SEND_SLIST_EDIT_SLAVE_LIST, 0);
			UIR_STATUS_CHECK(status, SetInputMode());
			SetCtrlVal(global.panel.primEdit[sendSlListIntId], SEND_SLIST_LIST_LENGTH, 0);
		}	
		
		GetCtrlVal(panel, control, &primitiveId);
		global.editPrimitiveId=primitiveId;
		status=DisplayPanel(global.panel.primEdit[getPrimArrayId(primitiveId)]);
		UIR_STATUS_CHECK(status, DisplayPanel()); 
	}
	
	if(global.option.programExit==FALSE){
		
		status=SetActiveCtrl (global.panel.slaveList, SLAVE_LST_LIST_TABLE);
		UIR_STATUS_CHECK(status, SetActiveCtrl());
		status=SetActiveCtrl (global.panel.primListEdit, LIST_EDIT_LIST_TABLE);
	    UIR_STATUS_CHECK(status, SetActiveCtrl());

	}	
	
	return 0;
}


/*=============================================================================
 *                               listEditMenu()
 *=============================================================================
 *
 *
 *
 */

void CVICALLBACK listEditMenu (int menuBar, int menuprimTable, void *callbackData, int panel){

	int status;
	char string[300];
	char mainDir[300];
	
	switch(menuprimTable){
		
		case LIST_EDITM_REVISION_UPDATE:
			
			status = DirSelectPopup ("C:\\RodTS", "Select subdirectory with *.mlist files for revision update", 1, 0, mainDir);	
			if(status==1){
				status=primListRevisionUpdate(mainDir);
				if(status!=0){
					ERROR_CHECK(PROGRAM_ERROR, primListRevisionUpdate()!!);
				}
			}	
			break;
		case LIST_EDITM_CLOSE:
			status=HidePanel(panel);
			UIR_STATUS_CHECK(status, HidePanel());
			break;
		case LIST_EDITM_GOTO_MAIN: 	
			status=SetActivePanel(global.panel.main);
			UIR_STATUS_CHECK(status, SetActivePanel());
			break;
		case LIST_EDITM_COMM_LIST_EDIT: 	
			status=SetActivePanel(global.panel.commandListEdit);
			UIR_STATUS_CHECK(status, SetActivePanel());
			break;		
	    case LIST_EDITM_DATA_FILE_CREATOR: 	
	    	strcpy(string, global.mainDir);
	    	strcat(string, DATA_FILE_CREATOR);
			status=LaunchExecutable(string);
			UIR_STATUS_CHECK(status, LaunchExecutable());	
			break;			
	
		default: ;
	}
}

/******************************************************************************
 *                              Static functions                              *
 ******************************************************************************/

/*=============================================================================
 *                               preprocessMasterList()
 *=============================================================================
 *
 *
 *
 */
static void preprocessMasterList(struct LIST_TABLE *listTable){
	
	UINT32 index;
	struct PRIM_TABLE *primTable;
	//const UINT32 masterPrimCount=listTable->inListHeader.numMsgs;
	UINT32 primTableIndex;
	int status;
	int slavePrims=0;
	int masterIndex;

	listTable->replyCount=0;
	listTable->replyLength=0;     
	listTable->inListHeader.length=SIZEOF(struct MSG_LIST_HEAD)+SIZEOF(struct MSG_LIST_TAIL);
	listTable->inListHeader.primListRevision=PRIM_LIST_REVISION;     
	listTable->inListHeader.index=0;

	for(index=0, masterIndex=0; index<listTable->allPrimCount; index++){
	
		primTable=&listTable->primTable[index];
		
		if(slavePrims>0) {slavePrims--; continue;} 		
		 
		primTable->inPrimHeader.index=masterIndex;
		listTable->inListHeader.length+=primTable->inPrimHeader.length;
		listTable->replyLength+=primTable->replyLength;  
		if(primTable->replyLength>0){
			++listTable->replyCount;
		}
	     
	    listTable->masterToTablePrimIndex[primTable->inPrimHeader.index]=index;
	     
	    if(primTable->inPrimHeader.id==SEND_SLAVE_LIST){
	    	slavePrims=primTable->params.sendSlaveList.inSlaveListHeader.numMsgs;
	    	
	     }
	     ++masterIndex;
	}


	if(listTable->replyCount>0){
		listTable->replyLength+=SIZEOF(struct MSG_LIST_HEAD)+SIZEOF(struct MSG_LIST_TAIL);	
	}
	
	SetCtrlVal(global.panel.primListEdit, LIST_EDIT_PRIM_COUNT, listTable->inListHeader.numMsgs);
	SetCtrlVal(global.panel.primListEdit, LIST_EDIT_REPPRIM_COUNT, listTable->replyCount);   
	SetCtrlVal(global.panel.primListEdit, LIST_EDIT_PRIMLIST_LENGTH, listTable->inListHeader.length);
	SetCtrlVal(global.panel.primListEdit, LIST_EDIT_REPLIST_LENGTH, listTable->replyLength); 
	SetCtrlVal(global.panel.primListEdit, LIST_EDIT_ALL_PRIM_COUNT, listTable->allPrimCount); 
	
	/* check limits */                     
	(void)listSizeLimitCheck(listTable);   
	
	return;
	
}
/*=============================================================================
 *                               preprocessSlaveList()
 *=============================================================================
 *
 *																						 
 *																						
 */
static void preprocessSlaveList(struct PRIM_TABLE *firstSlavePrimTable, struct MSG_LIST_HEAD *inSlaveListHeader, UINT32 *slvReplyLength, UINT32 *slvReplyCount){
	
	UINT32 index;
	struct PRIM_TABLE *primTable;
	int status;
	UINT32 length;
	
	*slvReplyCount=0;
	*slvReplyLength=0;     
	inSlaveListHeader->length=SIZEOF(struct MSG_LIST_HEAD)+SIZEOF(struct MSG_LIST_TAIL);
	inSlaveListHeader->primListRevision=PRIM_LIST_REVISION;     
	inSlaveListHeader->index=0;
	
	/* add slave indexes */
	for(index=0; index<inSlaveListHeader->numMsgs; ++index){
		
		primTable=firstSlavePrimTable+index;
		
		primTable->inPrimHeader.index=index;

		inSlaveListHeader->length+=primTable->inPrimHeader.length;
		*slvReplyLength+=primTable->replyLength;  
		if(primTable->replyLength>0){
			++(*slvReplyCount);
		}
	}
	
	if((*slvReplyCount)>0){
		*slvReplyLength+=SIZEOF(struct MSG_LIST_HEAD)+SIZEOF(struct MSG_LIST_TAIL);	
	}
	
	SetCtrlVal(global.panel.slaveList, SLAVE_LST_PRIM_COUNT, inSlaveListHeader->numMsgs);
	SetCtrlVal(global.panel.slaveList, SLAVE_LST_REPPRIM_COUNT,*slvReplyCount);   
	SetCtrlVal(global.panel.slaveList, SLAVE_LST_PRIMLIST_LENGTH, inSlaveListHeader->length);
	SetCtrlVal(global.panel.slaveList, SLAVE_LST_REPLIST_LENGTH, *slvReplyLength);
	
	/* master sendSlaveList */
	primTable=firstSlavePrimTable-1;
	primTable->params.sendSlaveList.primParams.listLength=inSlaveListHeader->length;
	
	primTable->inPrimHeader.length=inSlaveListHeader->length+SIZEOF(struct MSG_HEAD)+SIZEOF(struct SEND_SLAVE_LIST_IN); 
							
	if((*slvReplyLength)>0){
		length=(*slvReplyLength)+SIZEOF(struct MSG_HEAD);
	}else{
		length=0;
	}
	primTable->replyLength=length;
	
	return;	
}	
	
/*=============================================================================
 *                              listSizeLimitCheck()
 *=============================================================================
 *
 *
 *
 */
static int listSizeLimitCheck(struct LIST_TABLE *listTable){

	int status;

	if(listTable->replyLength>(REP_BUFF_SIZE/sizeof(UINT32))){
		status=MessagePopup("Warning","ReplyList length > REPLY_BUFFER_SIZE!!\nCut the length!");
		UIR_STATUS_CHECK(status, MessagePopup());
		return(1);
	}
	if(listTable->inListHeader.length>(PRIM_BUFF_SIZE/sizeof(UINT32))){
		status=MessagePopup("Warning","PrimList length > PRIMITIVE_BUFFER_SIZE!!\nCut the length!");
		UIR_STATUS_CHECK(status, MessagePopup());
		return(1);
	}

	return(0);
}

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