int CLogObjectCAN::Der_SetConfigData(xmlNodePtr pNodePtr)
{
int nResult = S_OK;
SFILTERAPPLIED_CAN sFilterApplied;
CStringArray omStrFilters;
if (S_OK == sFilterApplied.nSetXMLConfigData(pNodePtr->doc))
{
while(pNodePtr != NULL) //TODO:Move To Utils
{
if ( pNodePtr->xmlChildrenNode != NULL )
{
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"Filter")))
{
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
omStrFilters.Add((char*)key);
xmlFree(key);
}
}
}
pNodePtr = pNodePtr->next;
}
sFilterApplied.nGetFiltersFromName(m_sFilterApplied, omStrFilters);
}
return nResult;
}
USAGEMODE HRESULT Filter_ShowConfigDlg(void* pExistingFilter, const void* psMsgEntry,
ETYPE_BUS eType, UINT nHardware, CWnd* pParent)
{
//Place this code at the beginning of the export function.
//Save previous resource handle and switch to current one.
HINSTANCE hInst = AfxGetResourceHandle();
AfxSetResourceHandle(FilterDLL.hResource);
HRESULT hResult = S_FALSE;
switch (eType)
{
case CAN:
{
if (pExistingFilter != NULL)
{
SFILTERAPPLIED_CAN* pAppliedFilterCan = (SFILTERAPPLIED_CAN*)pExistingFilter;
SFILTERAPPLIED_CAN sTempObj;
sTempObj.bClone(*pAppliedFilterCan);
CFilterConfigDlg omDlg(&sTempObj, (SMSGENTRY *)psMsgEntry, nHardware, pParent);
if (omDlg.DoModal() == IDOK)
{
pAppliedFilterCan->bClone(sTempObj);
hResult = S_OK;
}
//delete omDlg;
}
}
break;
case LIN:
if (pExistingFilter != NULL)
{
SFILTERAPPLIED_LIN* pAppliedFilterLin = (SFILTERAPPLIED_LIN*)pExistingFilter;
SFILTERAPPLIED_LIN sTempObj;
sTempObj.bClone(*pAppliedFilterLin);
CFilterConfigDlg omDlg(&sTempObj,(ClusterConfig *) psMsgEntry, nHardware, pParent);
if (omDlg.DoModal() == IDOK)
{
pAppliedFilterLin->bClone(sTempObj);
hResult = S_OK;
}
//delete omDlg;
}
break;
default:
{
}
break;
}
//Place this at the end of the export function.
//switch back to previous resource handle.
AfxSetResourceHandle(hInst);
return hResult;
}
HRESULT CMsgContainerCAN::GetFilterScheme(void* pvFilterApplied)
{
HRESULT hResult = S_FALSE;
SFILTERAPPLIED_CAN* psFilterCAN = (SFILTERAPPLIED_CAN*)pvFilterApplied;
if (psFilterCAN != NULL)
{
if (psFilterCAN->bClone(m_sFilterCAN) == TRUE)
{
hResult = TRUE;
}
}
return hResult;
}
HRESULT CMsgContainerCAN::GetFilterScheme(void* pvFilterApplied)
{
HRESULT hResult = S_FALSE;
SFILTERAPPLIED_CAN* psFilterCAN = (SFILTERAPPLIED_CAN*)pvFilterApplied;
if (psFilterCAN != nullptr)
{
// if (psFilterCAN->bClone(m_sFilterCAN) == TRUE)
if (psFilterCAN->bClone(m_sFilterCAN) == true)
{
//hResult = TRUE;
hResult = S_OK;
}
}
return hResult;
}
int CLogObjectCAN::Der_SetConfigData(xmlNodePtr pNodePtr)
{
int nResult = S_OK;
SFILTERAPPLIED_CAN sFilterApplied;
CStringArray omStrFilters;
map<string, int> mapFilters;
if (S_OK == sFilterApplied.nSetXMLConfigData(pNodePtr->doc, CAN))
{
while(pNodePtr != NULL) //TODO:Move To Utils
{
if ( pNodePtr->xmlChildrenNode != NULL )
{
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"Filter")))
{
int nEnabled = 1;
xmlAttrPtr pAttr = pNodePtr->properties;
while (pAttr)
{
// walk through all the attributes and find the required one
if (pAttr->type == XML_ATTRIBUTE_NODE)
{
std::string strAttrName((char*)pAttr->name);
if ((strAttrName == "IsEnabled") )
{
nEnabled = atoi((char*)pAttr->children->content);
break; // found
}
}
pAttr = pAttr->next;
}
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
mapFilters[(char*)key] = nEnabled;
xmlFree(key);
}
}
}
pNodePtr = pNodePtr->next;
}
//sFilterApplied.nGetFiltersFromName(m_sFilterApplied, omStrFilters);
sFilterApplied.nGetFiltersFromName(m_sFilterApplied, mapFilters);
}
return nResult;
}
static void vPopulateFilterApplied(const SFILTERAPPLIED_CAN* psFilterConfigured, SFILTERAPPLIED_CAN& sFilterApplied, CMainEntryList& SrcList)
{
if ( psFilterConfigured == nullptr )
{
return;
}
const SMAINENTRY& sMainEntry = SrcList.GetHead();
int nCount = sMainEntry.m_odSelEntryList.GetCount();
SFILTERAPPLIED_CAN sTempAppliedFilter;
sTempAppliedFilter.bClone(sFilterApplied);
sFilterApplied.vClear();
sFilterApplied.m_psFilters = new SFILTERSET[nCount];
POSITION pos = sMainEntry.m_odSelEntryList.GetHeadPosition();
while (pos)
{
SSUBENTRY sSubEntry = sMainEntry.m_odSelEntryList.GetNext(pos);
const PSFILTERSET psTemp = SFILTERSET::psGetFilterSetPointer(psFilterConfigured->m_psFilters,
psFilterConfigured->m_ushTotal, sSubEntry.m_omSubEntryName.GetBuffer(MAX_PATH));
if (psTemp != nullptr)
{
sFilterApplied.m_psFilters[sFilterApplied.m_ushTotal].bClone(*psTemp);
sFilterApplied.m_ushTotal++;
}
}
//restore the enable flag for all filters
for(int nAppFilterCnt = 0; nAppFilterCnt < sFilterApplied.m_ushTotal; nAppFilterCnt++)
{
for(int nTempFilCnt = 0; nTempFilCnt < sTempAppliedFilter.m_ushTotal; nTempFilCnt++ )
{
if((&sTempAppliedFilter.m_psFilters[nTempFilCnt]) != nullptr)
{
if(sFilterApplied.m_psFilters[nAppFilterCnt].m_sFilterName.m_acFilterName ==
sTempAppliedFilter.m_psFilters[nTempFilCnt].m_sFilterName.m_acFilterName)
{
((sFilterApplied.m_psFilters)+ nAppFilterCnt) ->m_bEnabled
= ((sTempAppliedFilter.m_psFilters)+ nTempFilCnt) ->m_bEnabled;
}
}
}
}
}
BYTE* pbyGetFilterConfig(BYTE* pbyTrgBuffer,
CModuleFilterArray* pouModuleFilterArray,
const SFILTERAPPLIED_CAN* SrcFilter)
{
BYTE* pbyTemp = pbyTrgBuffer;
USHORT ushFilterCount = 0;
if (pouModuleFilterArray != NULL && (SrcFilter != NULL))
{
ushFilterCount = (USHORT)pouModuleFilterArray->GetSize();
}
SFILTERAPPLIED_CAN sFilterApplied;
sFilterApplied.vClear();
sFilterApplied.m_bEnabled = TRUE;
sFilterApplied.m_ushTotal = ushFilterCount;
sFilterApplied.m_psFilters = new SFILTERSET[sFilterApplied.m_ushTotal];
for (INT i = 0; i < ushFilterCount; i++)
{
//update filter applied
SMODULEFILTER sModuleFilter = pouModuleFilterArray->GetAt(i);
SFILTERSET* psFilterSet =
SFILTERSET::psGetFilterSetPointer(SrcFilter->m_psFilters,
SrcFilter->m_ushTotal,
sModuleFilter.m_omFilterName);
if (psFilterSet != NULL)
{
sFilterApplied.m_psFilters[i].bClone(*psFilterSet);
}
}
pbyTemp = sFilterApplied.pbGetConfigData(pbyTemp);
sFilterApplied.vClear();
return pbyTemp;
}
static void vPopulateFilterApplied(const SFILTERAPPLIED_CAN* psFilterConfigured, SFILTERAPPLIED_CAN& sFilterApplied, CMainEntryList& SrcList)
{
const SMAINENTRY& sMainEntry = SrcList.GetHead();
int nCount = (int)sMainEntry.m_odSelEntryList.GetCount();
sFilterApplied.vClear();
sFilterApplied.m_psFilters = new SFILTERSET[nCount];
POSITION pos = sMainEntry.m_odSelEntryList.GetHeadPosition();
while (pos)
{
SSUBENTRY sSubEntry = sMainEntry.m_odSelEntryList.GetNext(pos);
const PSFILTERSET psTemp = SFILTERSET::psGetFilterSetPointer(psFilterConfigured->m_psFilters,
psFilterConfigured->m_ushTotal, sSubEntry.m_omSubEntryName.GetBuffer(MAX_PATH));
ASSERT (psTemp != NULL);
sFilterApplied.m_psFilters[sFilterApplied.m_ushTotal].bClone(*psTemp);
sFilterApplied.m_ushTotal++;
}
}
void CLogObjectCAN::GetFilterInfo(SFILTERAPPLIED_CAN& sFilterInfo) const
{
sFilterInfo.bClone(m_sFilterApplied);
}
int CReplayFile::nLoadXMLConfig(xmlNodePtr pNodePtr)
{
int nRetValue = S_OK;
xmlNodePtr pTempNode = pNodePtr;
CStringArray omStrFilters;
while( NULL != pNodePtr )
{
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"Log_File_Path")))
{
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
if(PathIsRelative((char*)key) == TRUE)
{
std::string omStrConfigFolder;
std::string omPath;
char configPath[MAX_PATH];
AfxGetMainWnd()->SendMessage(MSG_GET_CONFIGPATH, (WPARAM)configPath, 0);
CUtilFunctions::nGetBaseFolder(configPath, omStrConfigFolder );
char chAbsPath[MAX_PATH];
PathCombine(chAbsPath, omStrConfigFolder.c_str(), (char*)key);
m_omStrFileName = chAbsPath;
}
else
{
m_omStrFileName = (char*)key;
}
xmlFree(key);
}
}
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"IsEnabled")))
{
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
m_bEnabled = xmlUtils::getBooleanValue((char*)key);
xmlFree(key);
}
}
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"Retain_Recored_Time")))
{
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
m_nTimeMode = xmlUtils::getBooleanValue((char*)key);
xmlFree(key);
}
}
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"Message_Delay")))
{
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
m_unMsgTimeDelay = atoi((char*)key);
xmlFree(key);
}
}
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"Is_Cyclic_Mode")))
{
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
m_nReplayMode = (int)xmlUtils::getBooleanValue((char*)key);
xmlFree(key);
}
}
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"Cyclic_Delay")))
{
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
m_unCycleTimeDelay = atoi((char*)key);
xmlFree(key);
}
}
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"IsInteractive")))
{
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
m_bInteractive = (int)xmlUtils::getBooleanValue((char*)key);
xmlFree(key);
}
}
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"Replay_Message_Direction")))
{
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
this->m_ouReplayMsgType = xmlUtils::bGetDirection((char*)key);
xmlFree(key);
}
}
if ((!xmlStrcmp(pNodePtr->name, (const xmlChar*)"Filter")))
{
xmlChar* key = xmlNodeListGetString(pNodePtr->doc, pNodePtr->xmlChildrenNode, 1);
if(NULL != key)
{
omStrFilters.Add((char*)key);
xmlFree(key);
}
}
pNodePtr = pNodePtr->next;
}
//Filters
if( omStrFilters.GetSize() > 0 && pTempNode != NULL)
{
SFILTERAPPLIED_CAN sFilterApplied;
if( sFilterApplied.nSetXMLConfigData(pTempNode->doc) == S_OK)
{
sFilterApplied.nGetFiltersFromName(m_sFilterApplied, omStrFilters);
/*
int nRealFilters = 0;
for(int i = 0; i < omStrFilters.GetSize(); i++)
{
int nIndex = GetFilterNameIndex((LPCSTR)omStrFilters.GetAt(i), sFilterApplied);
if(nIndex >= 0)
{
nRealFilters++;
}
else
{
omStrFilters.RemoveAt(i);
}
}
m_sFilterApplied.m_bEnabled = sFilterApplied.m_bEnabled;
m_sFilterApplied.m_ushTotal = omStrFilters.GetSize();
m_sFilterApplied.m_psFilters = new SFILTERSET[m_sFilterApplied.m_ushTotal];
for(int i = 0; i < omStrFilters.GetSize(); i++)
{
int nIndex = GetFilterNameIndex((LPCSTR)omStrFilters.GetAt(i), sFilterApplied);
if(nIndex >= 0)
{
m_sFilterApplied.m_psFilters[i].bClone(sFilterApplied.m_psFilters[nIndex]);
}
}*/
}
}
return nRetValue;
}
BOOL CConfigAdapter::bGetConfigData(BYTE*& lpData, int& nStreamLength, eSECTION_ID eSectionId)
{
BOOL bReturn = TRUE;
switch (eSectionId)
{
case MAINFRAME_SECTION_ID:
{
UINT unSize = 0;
BYTE* pbyConfigData = NULL;
//FIRST CALC SIZE REQUIRED
unSize += sizeof(BYTE); //Configuration version
unSize += (sizeof(char) * MAX_PATH);
unSize += sizeof(STOOLBARINFO);
//ALLOCATE THE MEMORY
pbyConfigData = new BYTE[unSize];
BYTE* pbyTemp = pbyConfigData;
//UPDATE THE DATA
BYTE byVersion = 0x1;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
CString* pomMRU_C_FILE_NAME = NULL;
m_ouConfigDetails.bGetData(MRU_C_FILE_NAME, (void**)(&pomMRU_C_FILE_NAME));
char acName[MAX_PATH] = {_T('0')};
ASSERT(pomMRU_C_FILE_NAME != NULL);
strcpy_s(acName, pomMRU_C_FILE_NAME->GetBuffer(MAX_PATH));
delete pomMRU_C_FILE_NAME;
COPY_DATA(pbyTemp, acName, (sizeof(char) * MAX_PATH));
PSTOOLBARINFO psToolBarInfo = NULL;
m_ouConfigDetails.bGetData(TOOLBAR_DETAILS, (void**)(&psToolBarInfo));
ASSERT(psToolBarInfo != NULL);
COPY_DATA(pbyTemp, psToolBarInfo, sizeof(STOOLBARINFO));
delete psToolBarInfo;
lpData = pbyConfigData;
nStreamLength = unSize;
}
break;
case LOG_SECTION_ID:
{
UINT unSize = 0;
BYTE* pbyConfigData = NULL;
SLOGCONFIGDETS* psLogConfigDets = NULL;
m_ouConfigDetails.bGetData(LOG_CONFIG_DETS, (void**)(&psLogConfigDets));
//FIRST CALCULATE SIZE REQUIRED
unSize += sizeof(BYTE);//Configuration version
if (psLogConfigDets != NULL)
{
//Filter info size
SFILTERAPPLIED_CAN* psFilterConfigured = NULL;
m_ouConfigDetails.bGetData(FILTER_CONFIG_DETS, (void**)(&psFilterConfigured));
unSize += sizeof (USHORT); // Log file count
for (UINT i = 0; i < psLogConfigDets->m_unCount; i++)
{
//log info size
SLOGINFO sLogInfo;
unSize += sLogInfo.unGetSize();
CModuleFilterArray* pModuleFilterArray =
(&(psLogConfigDets->m_asLogFileDets[i].m_omFilter));
unSize += unGetFilterSize(pModuleFilterArray, psFilterConfigured);
}
//CALCULATING SIZE ENDS
//NOW UPDATE THE VALUES
pbyConfigData = new BYTE[unSize];
BYTE* pbyTemp = pbyConfigData;
BYTE byVersion = 0x1;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
memcpy(pbyTemp, &(psLogConfigDets->m_unCount), sizeof (USHORT));
pbyTemp += sizeof (USHORT);
for (UINT i = 0; i < psLogConfigDets->m_unCount; i++)
{
//log info
SLOGINFO sLogInfo;
vPopulateLogInfo(sLogInfo, psLogConfigDets->m_asLogFileDets[i]);
pbyTemp = sLogInfo.pbGetConfigData(pbyTemp);
//Filter info size
CModuleFilterArray* pomFilterArray = &(psLogConfigDets->m_asLogFileDets[i].m_omFilter);
pbyTemp = pbyGetFilterConfig(pbyTemp, pomFilterArray, psFilterConfigured);
}
//Now update the parameter out pointer
lpData = pbyConfigData;
nStreamLength = unSize;
}
}
break;
case SIMSYS_SECTION_ID:
{
PSSIMSYSARRAY psSimSysArray;
UINT unSize = 0;
//FIRST CALCULATE THE SIZE REQUIRED MEANWHILE RETRIEVE THE DATA
unSize += sizeof(BYTE);//Configuration version
WINDOWPLACEMENT WndPlacement;
//retrieve the window placement
m_ouConfigDetails.bGetDefaultValue(SIMSYS_WND_PLACEMENT,WndPlacement);
unSize += sizeof(WINDOWPLACEMENT);
m_ouConfigDetails.bGetData(SIMSYS_LIST, (void**)(&psSimSysArray));
PSSIMSYSARRAY psTemp = psSimSysArray;
UINT nCount = 0;
unSize += sizeof(UINT); // To store count
while (psTemp != NULL)
{
nCount++;
unSize += (sizeof (char) * MAX_PATH);//File Path
psTemp = psTemp->psNextSimsys;
}
unSize += sizeof (WINDOWPLACEMENT);// Window placement for out window
//CALCULATE THE SIZE MEANWHILE RETRIEVE THE DATA ENDS
// ALLOCATE THE MEMORY
BYTE* pbyConfigData = new BYTE[unSize];
BYTE* pbyTemp = pbyConfigData;
//UPDATE THE DATA
BYTE byVersion = 0x1;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
//update window placement
COPY_DATA(pbyTemp, &WndPlacement, sizeof(WINDOWPLACEMENT));
//Update Simsys file path
psTemp = psSimSysArray;
COPY_DATA(pbyTemp, &nCount, sizeof(UINT));
while (psTemp != NULL)
{
char acFilePath[MAX_PATH] = {_T('\0')};
strcpy_s(acFilePath, psTemp->m_omStrSimSysPath.GetBuffer(MAX_PATH));
COPY_DATA(pbyTemp, acFilePath, (sizeof(char) * MAX_PATH));
psTemp = psTemp->psNextSimsys;
}
//update out window placement
WINDOWPLACEMENT* pWndPlacement = &WndPlacement;
m_ouConfigDetails.bGetData(OUT_WND_PLACEMENT, (void**)(&pWndPlacement));
COPY_DATA(pbyTemp, &WndPlacement, sizeof(WINDOWPLACEMENT));
//UPDATE THE DATA ENDS
//FINALLY UPDATE THE OUT PARAM
lpData = pbyConfigData;
nStreamLength = unSize;
}
break;
case REPLAY_SECTION_ID:
{
UINT unSize = 0;
BYTE* pbyConfigData = NULL;
SREPLAYDETS* psRepConfigDets = NULL;
unSize += sizeof(BYTE);//Configuration version
m_ouConfigDetails.bGetData(REPLAY_CONFIG_DETS, (void**)(&psRepConfigDets));
if (psRepConfigDets != NULL)
{
//FIRST CALCULATE SIZE REQUIRED
SFILTERAPPLIED_CAN* psFilterConfigured = NULL;
m_ouConfigDetails.bGetData(FILTER_CONFIG_DETS, (void**)(&psFilterConfigured));
unSize += sizeof (INT); //
for (UINT i = 0; i < psRepConfigDets->m_unCount; i++)
{
unSize += unGetReplayFileSize(psRepConfigDets->m_asReplayFile[i]);
unSize += unGetFilterSize(&(psRepConfigDets->m_asReplayFile[i].m_omFilter),
psFilterConfigured);
}
unSize += sizeof(WINDOWPLACEMENT);
//CALCULATING SIZE ENDS
//NOW UPDATE THE VALUES
pbyConfigData = new BYTE[unSize];
BYTE* pbyTemp = pbyConfigData;
BYTE byVersion = 0x1;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
memcpy(pbyTemp, &(psRepConfigDets->m_unCount), sizeof (INT));
pbyTemp += sizeof (INT);
for (UINT i = 0; i < psRepConfigDets->m_unCount; i++)
{
pbyTemp = pbGetReplayFileConfig(psRepConfigDets->m_asReplayFile[i], pbyTemp);
//Filter info size
pbyTemp = pbyGetFilterConfig(pbyTemp, &(psRepConfigDets->m_asReplayFile[i].m_omFilter),
psFilterConfigured);
}
//Update window placement
WINDOWPLACEMENT WndPlacement;
WINDOWPLACEMENT* pWndPlacement = &WndPlacement;
m_ouConfigDetails.bGetData(REPLAY_WND_PLACEMENT, (void**)(&pWndPlacement));
memcpy(pbyTemp, &WndPlacement, sizeof(WINDOWPLACEMENT));
pbyTemp += sizeof(WINDOWPLACEMENT);
//Now update the parameter out pointer
lpData = pbyConfigData;
nStreamLength = unSize;
}
}
break;
case MSGWND_SECTION_ID:
{
UINT unSize = 0;
BYTE* pbyConfigData = NULL;
//FIRST CALC SIZE
unSize += sizeof(BYTE);//Configuration version
PSMESSAGE_ATTRIB psMsgAttrib = NULL;
m_ouConfigDetails.bGetData(MSG_ATTRIBUTES, (void**)(&psMsgAttrib));
unSize += sizeof (UINT);// To store count of MsgAttribs
if (psMsgAttrib != NULL)
{
UINT nCount = psMsgAttrib->m_usMsgCount;
//Count To store Msg Name MsgId Msg Color
unSize += (nCount * ((sizeof (char) * MAX_PATH) + sizeof(UINT) + sizeof (COLORREF)));
}
INT anMsgBuffSize[defDISPLAY_CONFIG_PARAM] = {0};
m_ouConfigDetails.bGetData(MSG_BUFFER_SIZE, (void**)(&anMsgBuffSize));
unSize += (sizeof (INT) * defDISPLAY_CONFIG_PARAM);
CModuleFilterArray ouModuleFilterArray;
CModuleFilterArray* pouModuleFilterArray = &ouModuleFilterArray;
m_ouConfigDetails.bGetData(MSG_DISPLAY_FILTER_DETAILS, (void**)(&pouModuleFilterArray));
SFILTERAPPLIED_CAN* psFilterConfigured = NULL;
m_ouConfigDetails.bGetData(FILTER_CONFIG_DETS, (void**)(&psFilterConfigured));
//Filter size
unSize += unGetFilterSize(&ouModuleFilterArray, psFilterConfigured);
//MsgFormat window config data
unSize += sizeof(BYTE);//Msg frmt windows version information
unSize += sizeof(UINT);//buffer size
//CALC SIZE ENDS
//ALLOCATE THE MEMORY
pbyConfigData = new BYTE[unSize];
BYTE* pbyTemp = pbyConfigData;
//UPDATE THE DATA
BYTE byVersion = 0x1;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
//Attributes
if (psMsgAttrib != NULL)
{
COPY_DATA(pbyTemp, &(psMsgAttrib->m_usMsgCount), sizeof(UINT));
for (INT i = 0; i < psMsgAttrib->m_usMsgCount; i++)
{
char acName[MAX_PATH] = {_T('\0')};
strcpy_s(acName, psMsgAttrib->m_psMsgAttribDetails[i].omStrMsgname);
COPY_DATA(pbyTemp, acName, (sizeof(char) * MAX_PATH));
COPY_DATA(pbyTemp, &(psMsgAttrib->m_psMsgAttribDetails[i].unMsgID), sizeof(UINT));
COPY_DATA(pbyTemp, &(psMsgAttrib->m_psMsgAttribDetails[i].sColor), sizeof(COLORREF));
}
}
m_ouConfigDetails.vRelease(MSG_ATTRIBUTES, (LPVOID*)(&psMsgAttrib));
//Display buffer size
COPY_DATA(pbyTemp, anMsgBuffSize, (sizeof (INT) * defDISPLAY_CONFIG_PARAM));
//Filters
pbyTemp = pbyGetFilterConfig(pbyTemp, &ouModuleFilterArray, psFilterConfigured);
//Msg format window default values
BYTE byVer = 0x0;//version information
COPY_DATA(pbyTemp, &byVer, sizeof(BYTE));
UINT unMsgWndCfgSize = 0;
COPY_DATA(pbyTemp, &unMsgWndCfgSize, sizeof(UINT));
//Update the out parameters
lpData = pbyConfigData;
nStreamLength = unSize;
}
break;
case SIGWATCH_SECTION_ID:
{
UINT unSize = 0;
BYTE* pbyConfigData = NULL;
PSSIGNALWATCHLIST psSigWatchList = NULL;
m_ouConfigDetails.bGetData(SIGNAL_WATCH_LIST, (void**)(&psSigWatchList));
//Find the Size
unSize += sizeof(BYTE);//Configuration version
UINT unMsgcount = 0;
unSize += sizeof (UINT); // To store Msg Count
PSSIGNALWATCHLIST psTemp = psSigWatchList;
while (psTemp != NULL)
{
unMsgcount++;
unSize += sizeof (UINT); // To store Msg ID
unSize += (sizeof (char) * MAX_PATH);// To store Msg Name
unSize += sizeof (UINT); //To store selected signal count
INT nSelCount = psTemp->omCSASignals.GetSize();
for (INT i = 0; i < nSelCount; i++)
{
unSize += sizeof (UINT); // To store Signal ID
unSize += (sizeof (char) * MAX_PATH);// To store Signal Name
}
psTemp = psTemp->psNextMessageNode;
}
unSize += sizeof (WINDOWPLACEMENT); // window placement size
//ALLOCATE THE MEMORY
pbyConfigData = new BYTE[unSize];
BYTE* pbyTemp = pbyConfigData;
//UPDATE THE DATA
BYTE byVersion = 0x1;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
//Find the Size
COPY_DATA(pbyTemp, &unMsgcount, sizeof (UINT));
psTemp = psSigWatchList;
while (psTemp != NULL)
{
COPY_DATA(pbyTemp, &(psTemp->unMsgID), sizeof (UINT));
char acName[MAX_PATH] = {_T('\0')};
COPY_DATA(pbyTemp, acName, (sizeof (char) * MAX_PATH));
UINT unSelCount = psTemp->omCSASignals.GetSize();
COPY_DATA(pbyTemp, &unSelCount, sizeof (UINT));
for (UINT i = 0; i < unSelCount; i++)
{
CString omSigName = psTemp->omCSASignals.GetAt(i);
UINT unSigId = 0;
COPY_DATA(pbyTemp, &(unSigId), sizeof (UINT));
strcpy_s(acName, omSigName.GetBuffer(MAX_PATH));
COPY_DATA(pbyTemp, acName, (sizeof (char) * MAX_PATH));
}
psTemp = psTemp->psNextMessageNode;
}
//Signal Window placement
WINDOWPLACEMENT wndPlacement;
WINDOWPLACEMENT* pWndPlacement = &wndPlacement;
m_ouConfigDetails.bGetData(SIGWATCH_WND_PLACEMENT, (void**)(&pWndPlacement));
COPY_DATA(pbyTemp, &wndPlacement, sizeof (WINDOWPLACEMENT));
//Update the out parameters
lpData = pbyConfigData;
nStreamLength = unSize;
}
break;
case DIL_SECTION_ID:
{
PSCONTROLLER_DETAILS psContrlDets;
BYTE* pbyConfigData = NULL;
UINT unSize = 0;
unSize += sizeof(BYTE);//Configuration version
unSize += sizeof(DWORD);
unSize += sizeof(BYTE);
unSize += (sizeof(SCONTROLLER_DETAILS) * defNO_OF_CHANNELS);
if (m_ouConfigDetails.bGetData(CONTROLLER_DETAILS, (void**)(&psContrlDets)))
{
pbyConfigData = new BYTE[unSize];
BYTE* pbyTemp = pbyConfigData;
BYTE byVersion = 0x1;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
DWORD dwDriverId = DRIVER_CAN_STUB;
COPY_DATA(pbyTemp, &dwDriverId, sizeof(DWORD));
BYTE byContlrMode = defMODE_SIMULATE;
COPY_DATA(pbyTemp, &byContlrMode, sizeof(BYTE));
COPY_DATA(pbyTemp, psContrlDets, unSize);
m_ouConfigDetails.vRelease(CONTROLLER_DETAILS, (LPVOID*)(&psContrlDets));
}
lpData = pbyConfigData;
nStreamLength = unSize;
}
break;
case GRAPH_SECTION_ID:
{
BYTE byVersion = 0x1;
BYTE* pbyConfigData = NULL;
UINT unSize = 0;
CGraphList* podGraphList;
m_ouConfigDetails.bGetData(SIGNAL_GRAPH_LIST, (void**)(&podGraphList));
//FIRST CALCULATE THE SIZE
unSize += sizeof(BYTE); //Configuration version
if (podGraphList != NULL)
{
unSize += podGraphList->unGetConfigSize(byVersion);
}
unSize += sizeof (WINDOWPLACEMENT);
unSize += sizeof (SGRAPHSPLITTERDATA); //Splitter data
//ALLOCATE THE MEMORY
pbyConfigData = new BYTE[unSize];
BYTE* pbyTemp = pbyConfigData;
//UPDATE THE DATA
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
if (podGraphList != NULL)
{
pbyTemp = podGraphList->pbyGetConfigData(pbyTemp, byVersion);
}
//UPDATE GRAPH WINDOW PLACEMENT
WINDOWPLACEMENT wndPalcement;
WINDOWPLACEMENT* pWndPalcement = &wndPalcement;
m_ouConfigDetails.bGetData(GRAPH_WND_PLACEMENT, (void**)(&pWndPalcement));
COPY_DATA(pbyTemp, &wndPalcement, sizeof (WINDOWPLACEMENT));
SGRAPHSPLITTERDATA sGraphSplitterData;
PSGRAPHSPLITTERDATA psGraphSplitterData = &sGraphSplitterData;
m_ouConfigDetails.bGetData(GRAPH_WND_SPLITTER_DATA, (void**)(&psGraphSplitterData));
COPY_DATA(pbyTemp, &sGraphSplitterData, sizeof (SGRAPHSPLITTERDATA));
//UPDATE OUT PARAMS
lpData = pbyConfigData;
nStreamLength = unSize;
}
break;
case TXWND_SECTION_ID:
{
BYTE* pbyCfgData = NULL;
UINT unSize = 0;
//FIRST CALCULATE THE SIZE
unSize += sizeof(BYTE); //Configuration version
UINT unBlockCount = 0;
UINT* punBlockCount = &unBlockCount;
m_ouConfigDetails.bGetData(MSG_BLOCK_COUNT, (void**)(&punBlockCount));
unSize += sizeof (UINT); //block count
PSMSGBLOCKLIST psMsgBlockList = NULL;
if (m_ouConfigDetails.bGetData(SEND_MULTI_MSGS, (void**)(&psMsgBlockList)))
{
PSMSGBLOCKLIST psTemp = psMsgBlockList;
while (psTemp != NULL)
{
unSize += (sizeof(char) * MAX_PATH); // To store the block name
unSize += sizeof(UCHAR); // To store the trigger
unSize += sizeof(BOOL); // To store active or not
unSize += sizeof(UCHAR); // To store the key value
unSize += sizeof (UINT); // to store the timeinterval
unSize += sizeof (BOOL); // Type
unSize += sizeof (BOOL); // Send All msgs
unSize += sizeof(UINT);// To store no of msgs in each block
unSize += (psTemp->m_unMsgCount) * sizeof (STXCANMSGDETAILS);
psTemp = psTemp->m_psNextMsgBlocksList;
}
}
unSize += sizeof(WINDOWPLACEMENT);
unSize += sizeof(STXMSGSPLITTERDATA);
//ALLOCATE THE MEMORY
pbyCfgData = new BYTE[unSize];
BYTE* pbyTemp = pbyCfgData;
BYTE byVersion = 0x1;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
COPY_DATA(pbyTemp, &unBlockCount, sizeof(UINT));
PSMSGBLOCKLIST psTempBlock = psMsgBlockList;
while (psTempBlock != NULL)
{
CString m_omStrBlockName;
char acName[MAX_PATH] = {_T('\0')};
strcpy_s(acName, psTempBlock->m_omStrBlockName.GetBuffer(MAX_PATH));
COPY_DATA(pbyTemp, acName, (sizeof(char) * MAX_PATH));
COPY_DATA(pbyTemp, &(psTempBlock->m_ucTrigger), sizeof(UCHAR));
COPY_DATA(pbyTemp, &(psTempBlock->m_bActive), sizeof(BOOL));
COPY_DATA(pbyTemp, &(psTempBlock->m_ucKeyValue), sizeof(UCHAR));
COPY_DATA(pbyTemp, &(psTempBlock->m_unTimeInterval), sizeof(UINT));
COPY_DATA(pbyTemp, &(psTempBlock->m_bType), sizeof(BOOL));
COPY_DATA(pbyTemp, &(psTempBlock->m_bTxAllFrame), sizeof(BOOL));
COPY_DATA(pbyTemp, &(psTempBlock->m_unMsgCount), sizeof(UINT));
PSTXCANMSGLIST psTempCanList = psTempBlock->m_psTxCANMsgList;
while (psTempCanList != NULL)
{
COPY_DATA(pbyTemp, &(psTempCanList->m_sTxMsgDetails), sizeof (STXCANMSGDETAILS));
psTempCanList = psTempCanList->m_psNextMsgDetails;
}
psTempBlock = psTempBlock->m_psNextMsgBlocksList;
}
m_ouConfigDetails.vRelease(SEND_MULTI_MSGS, (LPVOID*)&psMsgBlockList);
//Get the Tx window placement
WINDOWPLACEMENT WndPlacement;
WINDOWPLACEMENT* pWndPlacement = &WndPlacement;
m_ouConfigDetails.bGetData(TX_WND_PLACEMENT, (void**)(&pWndPlacement));
COPY_DATA(pbyTemp, &WndPlacement, sizeof(WINDOWPLACEMENT));
//Get the Tx splitter position
STXMSGSPLITTERDATA sTxSpliiterData;
STXMSGSPLITTERDATA* psTxSpliiterData = &sTxSpliiterData;
m_ouConfigDetails.bGetData(TX_MSG_WND_SPLITTER_DATA, (void**)(&psTxSpliiterData));
COPY_DATA(pbyTemp, &sTxSpliiterData, sizeof(STXMSGSPLITTERDATA));
//Update the OUT PARAMETERS
lpData = pbyCfgData;
nStreamLength = unSize;
}
break;
case DATABASE_SECTION_ID:
{
BYTE* pbyCfgData = NULL;
UINT unSize = 0;
CStringArray* pomStrDBArray = NULL;
m_ouConfigDetails.bGetData(DATABASE_FILE_NAME, (void**)(&pomStrDBArray));
//FIRST CALC SIZE
unSize += sizeof(BYTE); //Configuration version
unSize += sizeof (UINT); // To store the count
if (pomStrDBArray != NULL)
{
//To store the stringd
unSize += (pomStrDBArray->GetSize()) * (sizeof(char) * MAX_PATH);
}
//ALLOCATE THE MEMORY
pbyCfgData = new BYTE[unSize];
BYTE* pbyTemp = pbyCfgData;
//UPDATE THE DATA
BYTE byVersion = 0x1;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
UINT unCount = 0;
if (pomStrDBArray != NULL)
{
unCount = pomStrDBArray->GetSize();
}
COPY_DATA(pbyTemp, &unCount, sizeof(UINT));
for (UINT i =0; i < unCount; i++)
{
CString omName = pomStrDBArray->GetAt(i);
char acName[MAX_PATH] = {_T('\0')};
strcpy_s(acName, omName.GetBuffer(MAX_PATH));
COPY_DATA(pbyTemp, acName, (sizeof(char) * MAX_PATH));
}
m_ouConfigDetails.vRelease(DATABASE_FILE_NAME,(LPVOID*)&pomStrDBArray);
//UPDATE THE OUT PARAMETER
lpData = pbyCfgData;
nStreamLength = unSize;
}
break;
case FILTER_SECTION_ID:
{
BYTE* pbyCfgData = NULL;
UINT unSize = 0;
SFILTERAPPLIED_CAN* psFilterConfigured = NULL;
m_ouConfigDetails.bGetData(FILTER_CONFIG_DETS, (void**)(&psFilterConfigured));
if (psFilterConfigured != NULL)
{
unSize += psFilterConfigured->unGetSize();
}
pbyCfgData = new BYTE[unSize];
BYTE* pbyTemp = pbyCfgData;
pbyTemp = psFilterConfigured->pbGetConfigData(pbyTemp);
BYTE byVersion = 0x1;
memcpy(pbyCfgData, &byVersion, sizeof(BYTE));
lpData = pbyCfgData;
nStreamLength = unSize;
}
break;
default:
{
ASSERT(FALSE);
}
break;
}
return bReturn;
}
