NS_IMETHODIMP
nsDogbertProfileMigrator::Migrate(PRUint16 aItems, nsIProfileStartup* aStartup,
const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
PRBool aReplace = aStartup ? PR_TRUE : PR_FALSE;
if (!mTargetProfile) {
GetProfilePath(aStartup, mTargetProfile);
if (!mTargetProfile) return NS_ERROR_FAILURE;
}
if (!mSourceProfile) {
GetSourceProfile(aProfile);
if (!mSourceProfile)
return NS_ERROR_FAILURE;
}
NOTIFY_OBSERVERS(MIGRATION_STARTED, nsnull);
COPY_DATA(CopyPreferences, aReplace, nsIBrowserProfileMigrator::SETTINGS);
COPY_DATA(CopyCookies, aReplace, nsIBrowserProfileMigrator::COOKIES);
COPY_DATA(CopyBookmarks, aReplace, nsIBrowserProfileMigrator::BOOKMARKS);
NOTIFY_OBSERVERS(MIGRATION_ENDED, nsnull);
return rv;
}
void CReplayManager::vGetReplayConfigData(BYTE*& pDesBuffer, int& nBuffSize)
{
UINT unToatalDataSize = sizeof(BYTE);//configuration version;
int nSize = (int)m_omReplayFiles.GetSize();
//For storing nSize value
unToatalDataSize += sizeof(nSize);
CReplayFile ouFile;
for( int nIndex = 0; nIndex < nSize; nIndex++ )
{
ouFile = m_omReplayFiles.ElementAt( nIndex );
unToatalDataSize += ouFile.unGetConfigSize();
}
unToatalDataSize += sizeof (WINDOWPLACEMENT);
pDesBuffer = new BYTE[unToatalDataSize];
nBuffSize = unToatalDataSize;
BYTE* pbyTemp = pDesBuffer;
//BYTE byVersion = REPLAY_MANAGER_INITIAL_VERSION;
BYTE byVersion = REPLAY_MANAGER_REPLAY_MSG_ADD;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
COPY_DATA(pbyTemp, &nSize, sizeof(nSize));
for( int nIndex = 0; nIndex < nSize; nIndex++ )
{
ouFile = m_omReplayFiles.ElementAt( nIndex );
pbyTemp = ouFile.pbySaveConfig(pbyTemp);
}
if (m_pomActiveWindow != nullptr)
{
m_pomActiveWindow->GetWindowPlacement(&m_sWndPlacement);
}
COPY_DATA(pbyTemp, &m_sWndPlacement, sizeof (WINDOWPLACEMENT));
}
/******************************************************************************
Function Name : GetConfigurationData
Input(s) : BYTE* pSrcBuffer, UINT unBuffSize
Output : HRESULT
Functionality : Loads the configuration data
Member of : CTSExecutorChildFrame
Friend of : -
Author(s) : Venkatanarayana Makam
Date Created : 07/04/2011
Modifications :
Code Tag : CS039
******************************************************************************/
HRESULT CTSExecutorChildFrame::GetConfigurationData(BYTE*& pDesBuffer, UINT& unBuffSize)
{
//TestSuite Buffer
UINT unTSBuffSize = 0;
BYTE* pTSBuffer;
m_ouTSExecutor.GetConfigurationData(pTSBuffer, unTSBuffSize);
//Window position
WINDOWPLACEMENT wndPlacement;
GetWindowPlacement(&wndPlacement);
//TreeView Window Position
INT nCxCur, nCxMin;
m_omSplitterWnd.GetColumnInfo(0, nCxCur, nCxMin);
//TestSuite Buffer + Window position
unBuffSize = sizeof(WINDOWPLACEMENT) + unTSBuffSize + (2*sizeof(INT));
pDesBuffer = new BYTE[unBuffSize];
BYTE* pTemp = pDesBuffer;
COPY_DATA(pTemp, &wndPlacement, sizeof(WINDOWPLACEMENT));
COPY_DATA(pTemp, &nCxCur, sizeof(INT));
COPY_DATA(pTemp, &nCxMin, sizeof(INT));
COPY_DATA(pTemp, pTSBuffer, unTSBuffSize);
//Delete The Temporary Info
delete []pTSBuffer;
return S_OK;
}
void CSimSysManager::SaveSIMDataIntoBuffer(BYTE* DesBuffer)
{
BYTE* tempBuffAddress = DesBuffer;
BYTE byVersion = 0x1;
COPY_DATA(tempBuffAddress, &byVersion, sizeof(BYTE));
WINDOWPLACEMENT WndPlacement;
CGlobalObj::ouGetObj(m_eBus).m_pomSimSysWnd->GetWindowPlacement(&WndPlacement);
COPY_DATA(tempBuffAddress, &WndPlacement, sizeof(WINDOWPLACEMENT));
UINT unCount = m_ouSimSysNodeInfo.unGetNumberOfSimSys();
COPY_DATA(tempBuffAddress, &unCount, sizeof (UINT));
PSSIMSYSINFO pSimSysInfo = m_ouSimSysNodeInfo.psReturnSimsysInfoListPtr();
for (UINT i = 0; (i < unCount) && (pSimSysInfo != NULL); i++)
{
UINT unSize = 0;
CString omTmp = pSimSysInfo->m_omStrSimSysName;
char acFilename[MAX_PATH];
_tcscpy(acFilename, omTmp.GetBuffer(MAX_PATH));
COPY_DATA(tempBuffAddress, acFilename, sizeof(char) * MAX_PATH);
pSimSysInfo = pSimSysInfo->m_psSimsysNext;
}
}
NS_IMETHODIMP
nsOperaProfileMigrator::Migrate(PRUint16 aItems, nsIProfileStartup* aStartup, const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
PRBool aReplace = aStartup ? PR_TRUE : PR_FALSE;
if (aStartup) {
rv = aStartup->DoStartup();
NS_ENSURE_SUCCESS(rv, rv);
}
if (!mOperaProfile)
GetOperaProfile(aProfile, getter_AddRefs(mOperaProfile));
NOTIFY_OBSERVERS(MIGRATION_STARTED, nsnull);
COPY_DATA(CopyPreferences, aReplace, nsIBrowserProfileMigrator::SETTINGS);
COPY_DATA(CopyCookies, aReplace, nsIBrowserProfileMigrator::COOKIES);
COPY_DATA(CopyHistory, aReplace, nsIBrowserProfileMigrator::HISTORY);
COPY_DATA(CopyBookmarks, aReplace, nsIBrowserProfileMigrator::BOOKMARKS);
NOTIFY_OBSERVERS(MIGRATION_ENDED, nsnull);
return rv;
}
// Getter for the logging configuration data
HRESULT CFrameProcessor_Common::GetConfigData(BYTE** ppvConfigData, UINT& unLength)
{
BYTE* pbBuff = new BYTE[unGetBufSize()];
*ppvConfigData = pbBuff;
CLogObjArray* pomCurrArray = GetActiveLogObjArray();
BYTE bVersion = VERSION_CURR;
COPY_DATA(pbBuff, &bVersion, sizeof(bVersion));
USHORT ushLogBlks = (USHORT) (pomCurrArray->GetSize());
COPY_DATA(pbBuff, &ushLogBlks, sizeof(ushLogBlks));
for (USHORT i = 0; i < ushLogBlks; i++)
{
CBaseLogObject* pouLogObj = pomCurrArray->GetAt(i);
if (NULL != pouLogObj)
{
pbBuff = pouLogObj->GetConfigData(pbBuff);
}
else
{
ASSERT(FALSE);
}
}
unLength = unGetBufSize();
return S_OK;
}
BYTE* CGraphList::pbyGetConfigData(BYTE* pbyTrgtData)
{
BYTE* pbyTemp = pbyTrgtData;
pbyTemp = m_odGraphParameters.pbyGetConfigData(pbyTemp);
// Save the list element count
// Get list size
int nElementCount = (int)m_omElementList.GetSize();
// Save the size
COPY_DATA(pbyTemp, &nElementCount, sizeof (int));
// Save list of elements
if( nElementCount > 0 )
{
CGraphElement odTemp;
for( int nIndex = 0; nIndex < nElementCount;
nIndex++ )
{
// Get the object from the list
odTemp = m_omElementList.GetAt( nIndex );
// Save the element
pbyTemp = odTemp.pbyGetConfigData( pbyTemp );
}
}
return pbyTemp;
}
NS_IMETHODIMP
nsMacIEProfileMigrator::Migrate(PRUint16 aItems, nsIProfileStartup* aStartup, const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
PRBool replace = aStartup ? PR_TRUE : PR_FALSE;
if (!mTargetProfile) {
GetProfilePath(aStartup, mTargetProfile);
if (!mTargetProfile) return NS_ERROR_FAILURE;
}
if (!mSourceProfile) {
nsCOMPtr<nsIProperties> fileLocator =
do_GetService("@mozilla.org/file/directory_service;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
fileLocator->Get(NS_OSX_USER_PREFERENCES_DIR,
NS_GET_IID(nsILocalFile),
getter_AddRefs(mSourceProfile));
mSourceProfile->Append(MACIE_PREFERENCES_FOLDER_NAME);
}
NOTIFY_OBSERVERS(MIGRATION_STARTED, nsnull);
COPY_DATA(CopyBookmarks, replace, nsIBrowserProfileMigrator::BOOKMARKS);
NOTIFY_OBSERVERS(MIGRATION_ENDED, nsnull);
return rv;
}
void send_ok_response(spidermonkey_drv_t *dd, js_call *call_data,
const char *call_id) {
ErlDrvTermData terms[] = {ERL_DRV_BUF2BINARY,
(ErlDrvTermData) call_data->return_call_id,strlen(call_id),
ERL_DRV_ATOM, dd->atom_ok,
ERL_DRV_TUPLE, 2};
COPY_DATA(call_data, call_id, terms);
}
HRESULT CSignalWatch_CAN::SW_GetConfigData(void* pbyConfigData)
{
WINDOWPLACEMENT WndPlace;
UINT nDebugSize = 0;
BYTE* pbyTemp = (BYTE*)pbyConfigData;
if ((m_pouSigWnd != NULL) && (pbyTemp != NULL))
{
m_pouSigWnd->GetWindowPlacement(&WndPlace);
COPY_DATA(pbyTemp, &WndPlace, sizeof (WINDOWPLACEMENT));
for (UINT i = 0; i < defSW_LIST_COLUMN_COUNT; i++)
{
INT nWidth = m_pouSigWnd->m_omSignalList.GetColumnWidth(i);
COPY_DATA(pbyTemp, &nWidth, sizeof (INT));
}
}
return S_OK;
}
/******************************************************************************
Function Name : pbGetConfigData
Input(s) : pbTarget - The target buffer to save logging data.
It assumes that pbTarget is currently pointing to a loca-
tion having sufficient space.
Output : BYTE * - Location of the next available buffer.
Functionality : Saves logging block information of the current object into
the target buffer. Advances the writing pointer to the
next byte occurring after the written block.
Member of : tagLogInfo
Friend of : -
Author(s) : Ratnadip Choudhury
Date Created : 1.12.2009
Modification date:
Modification By :
******************************************************************************/
BYTE* tagLogInfo::pbGetConfigData(BYTE* pbTarget) const
{
BYTE* pbTStream = pbTarget;
COPY_DATA(pbTStream, &m_bIsUpdated, sizeof(m_bIsUpdated ));
COPY_DATA(pbTStream, &m_bEnabled, sizeof(m_bEnabled ));
COPY_DATA(pbTStream, &m_eLogTimerMode, sizeof(m_eLogTimerMode ));
COPY_DATA(pbTStream, &m_eNumFormat, sizeof(m_eNumFormat ));
COPY_DATA(pbTStream, &m_eFileMode, sizeof(m_eFileMode ));
COPY_DATA(pbTStream, &m_bResetAbsTimeStamp, sizeof(m_bResetAbsTimeStamp));
COPY_DATA(pbTStream, &m_ChannelSelected, sizeof(m_ChannelSelected ));
COPY_DATA(pbTStream, m_sLogFileName, sizeof(m_sLogFileName ));
COPY_DATA(pbTStream, &m_sLogTrigger, sizeof(m_sLogTrigger ));
return pbTStream;
}
void unknown_command(spidermonkey_drv_t *dd, js_call *call_data,
const char *call_id) {
ErlDrvTermData terms[] = {ERL_DRV_BUF2BINARY,
(ErlDrvTermData) call_data->return_call_id,strlen(call_id),
ERL_DRV_ATOM, dd->atom_error,
ERL_DRV_ATOM, dd->atom_unknown_cmd,
ERL_DRV_TUPLE, 3};
COPY_DATA(call_data, call_id, terms);
}
NS_IMETHODIMP
nsSeamonkeyProfileMigrator::Migrate(PRUint16 aItems, nsIProfileStartup* aStartup, const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
PRBool aReplace = aStartup ? PR_TRUE : PR_FALSE;
if (!mTargetProfile) {
GetProfilePath(aStartup, mTargetProfile);
if (!mTargetProfile) return NS_ERROR_FAILURE;
}
if (!mSourceProfile)
GetSourceProfile(aProfile);
NOTIFY_OBSERVERS(MIGRATION_STARTED, nsnull);
COPY_DATA(CopyPreferences, aReplace, nsIBrowserProfileMigrator::SETTINGS);
COPY_DATA(CopyCookies, aReplace, nsIBrowserProfileMigrator::COOKIES);
COPY_DATA(CopyPasswords, aReplace, nsIBrowserProfileMigrator::PASSWORDS);
COPY_DATA(CopyOtherData, aReplace, nsIBrowserProfileMigrator::OTHERDATA);
// Need to do startup before trying to copy bookmarks, since bookmarks
// import requires a profile. Can't do it earlier because services might
// end up creating the files we try to copy above.
if (aStartup) {
rv = aStartup->DoStartup();
NS_ENSURE_SUCCESS(rv, rv);
}
COPY_DATA(CopyBookmarks, aReplace, nsIBrowserProfileMigrator::BOOKMARKS);
if (aReplace &&
(aItems & nsIBrowserProfileMigrator::SETTINGS ||
aItems & nsIBrowserProfileMigrator::COOKIES ||
aItems & nsIBrowserProfileMigrator::PASSWORDS ||
!aItems)) {
// Permissions (Images, Cookies, Popups)
rv |= CopyFile(FILE_NAME_SITEPERM_NEW, FILE_NAME_SITEPERM_NEW);
rv |= CopyFile(FILE_NAME_SITEPERM_OLD, FILE_NAME_SITEPERM_OLD);
}
NOTIFY_OBSERVERS(MIGRATION_ENDED, nsnull);
return rv;
}
void send_error_string_response(spidermonkey_drv_t *dd, js_call *call_data,
const char *call_id, const char *msg) {
ErlDrvTermData terms[] = {ERL_DRV_BUF2BINARY,
(ErlDrvTermData) call_data->return_call_id,strlen(call_id),
ERL_DRV_ATOM, dd->atom_error,
ERL_DRV_BUF2BINARY, (ErlDrvTermData) msg, strlen(msg),
ERL_DRV_TUPLE, 3};
COPY_DATA(call_data, call_id, terms);
call_data->return_string = msg;
}
HRESULT CWaveFormDataHandler::GetConfigData(BYTE** ppvDataStream, UINT& unLength)
{
UINT nSize = 0;
nSize += sizeof(BYTE); // 1 Byte for Version
nSize += sizeof(UINT); // Bytes for Buffer Size
nSize += nGetWaveInfoListSize();
BYTE* pByteTrgt = new BYTE[nSize];
*ppvDataStream = pByteTrgt;
BYTE byVer = WAVEFORM_DATA_HANDLER_VERSION;
COPY_DATA(pByteTrgt, &byVer , sizeof(BYTE)); //Setting Version.
COPY_DATA(pByteTrgt, &nSize, sizeof(UINT)); //Setting Buffer Size.
pByteTrgt = pbyGetListConfigData(pByteTrgt, nSize);
unLength = nSize;
return S_OK;
}
NS_IMETHODIMP
nsThunderbirdProfileMigrator::Migrate(uint16_t aItems,
nsIProfileStartup* aStartup,
const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
bool aReplace = aStartup ? true : false;
if (!mTargetProfile) {
GetProfilePath(aStartup, getter_AddRefs(mTargetProfile));
if (!mTargetProfile)
return NS_ERROR_FILE_NOT_FOUND;
}
if (!mSourceProfile) {
GetSourceProfile(aProfile);
if (!mSourceProfile)
return NS_ERROR_FILE_NOT_FOUND;
}
NOTIFY_OBSERVERS(MIGRATION_STARTED, nullptr);
COPY_DATA(CopyPreferences, aReplace, nsISuiteProfileMigrator::SETTINGS);
COPY_DATA(CopyCookies, aReplace, nsISuiteProfileMigrator::COOKIES);
COPY_DATA(CopyHistory, aReplace, nsISuiteProfileMigrator::HISTORY);
COPY_DATA(CopyPasswords, aReplace, nsISuiteProfileMigrator::PASSWORDS);
COPY_DATA(CopyOtherData, aReplace, nsISuiteProfileMigrator::OTHERDATA);
// fake notifications for things we've already imported as part of
// CopyPreferences
nsAutoString index;
index.AppendInt(nsISuiteProfileMigrator::ACCOUNT_SETTINGS);
NOTIFY_OBSERVERS(MIGRATION_ITEMBEFOREMIGRATE, index.get());
NOTIFY_OBSERVERS(MIGRATION_ITEMAFTERMIGRATE, index.get());
index.Truncate();
index.AppendInt(nsISuiteProfileMigrator::NEWSDATA);
NOTIFY_OBSERVERS(MIGRATION_ITEMBEFOREMIGRATE, index.get());
NOTIFY_OBSERVERS(MIGRATION_ITEMAFTERMIGRATE, index.get());
// copy junk mail training file
COPY_DATA(CopyJunkTraining, aReplace, nsISuiteProfileMigrator::JUNKTRAINING);
if (aReplace &&
(aItems & nsISuiteProfileMigrator::SETTINGS ||
aItems & nsISuiteProfileMigrator::COOKIES ||
aItems & nsISuiteProfileMigrator::PASSWORDS ||
!aItems)) {
// Permissions (Images, Cookies, Popups)
rv |= CopyFile(FILE_NAME_SITEPERM_NEW, FILE_NAME_SITEPERM_NEW);
rv |= CopyFile(FILE_NAME_SITEPERM_OLD, FILE_NAME_SITEPERM_OLD);
}
// the last thing to do is to actually copy over any mail folders
// we have marked for copying we want to do this last and it will be
// asynchronous so the UI doesn't freeze up while we perform
// this potentially very long operation.
CopyMailFolders();
return rv;
}
NS_IMETHODIMP
nsSafariProfileMigrator::Migrate(PRUint16 aItems, nsIProfileStartup* aStartup,
const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
bool replace = false;
if (aStartup) {
replace = true;
rv = aStartup->DoStartup();
NS_ENSURE_SUCCESS(rv, rv);
}
NOTIFY_OBSERVERS(MIGRATION_STARTED, nsnull);
COPY_DATA(CopyPreferences, replace, nsIBrowserProfileMigrator::SETTINGS);
COPY_DATA(CopyCookies, replace, nsIBrowserProfileMigrator::COOKIES);
COPY_DATA(CopyHistory, replace, nsIBrowserProfileMigrator::HISTORY);
COPY_DATA(CopyBookmarks, replace, nsIBrowserProfileMigrator::BOOKMARKS);
COPY_DATA(CopyFormData, replace, nsIBrowserProfileMigrator::FORMDATA);
COPY_DATA(CopyOtherData, replace, nsIBrowserProfileMigrator::OTHERDATA);
NOTIFY_OBSERVERS(MIGRATION_ENDED, nsnull);
return rv;
}
void CSimSysManager::vSaveSimSysWndConfig()
{
if (CGlobalObj::ouGetObj(m_eBus).m_pomSimSysWnd != NULL)
{
CGlobalObj::ouGetObj(m_eBus).m_nSimSysDataSize = unGetStoreSIMFBufferSize(); //Get the required size
if (CGlobalObj::ouGetObj(m_eBus).m_pSimSysDataPtr != NULL)
{
delete[] CGlobalObj::ouGetObj(m_eBus).m_pSimSysDataPtr;
}
CGlobalObj::ouGetObj(m_eBus).m_pSimSysDataPtr = new BYTE[CGlobalObj::ouGetObj(m_eBus).m_nSimSysDataSize];
if (CGlobalObj::ouGetObj(m_eBus).m_pSimSysDataPtr != NULL)
{
SaveSIMDataIntoBuffer(CGlobalObj::ouGetObj(m_eBus).m_pSimSysDataPtr);// save the config into buffer
/* Add into a different section SIM_WND_CONFIG_SECTION_NAME*/
/*CConfigDetails::ouGetConfigDetailsObject().bSetData((LPVOID)SectionBuffer,
unBufferSize, SIM_WND_CONFIG_SECTION_NAME);
delete [] SectionBuffer;*/
}
}
else
{
if (CGlobalObj::ouGetObj(m_eBus).m_pSimSysDataPtr == NULL)
{
//New configuration. So get default values
int nCount = 0;//Total number of simsys
int nTotalSize = sizeof(BYTE);
nTotalSize += sizeof(WINDOWPLACEMENT) + sizeof(UINT);
CGlobalObj::ouGetObj(m_eBus).m_nSimSysDataSize = nTotalSize;
CGlobalObj::ouGetObj(m_eBus).m_pSimSysDataPtr = new BYTE[nTotalSize];
BYTE* byTempData = CGlobalObj::ouGetObj(m_eBus).m_pSimSysDataPtr;
BYTE byVersion = 0x1;
COPY_DATA(byTempData, &byVersion, sizeof(BYTE));
CGlobalObj::ouGetObj(m_eBus).bGetDefaultValue(SIMSYS_WND_PLACEMENT, CGlobalObj::ouGetObj(m_eBus).m_wWindowPlacement);
COPY_DATA(byTempData, &(CGlobalObj::ouGetObj(m_eBus).m_wWindowPlacement), sizeof(WINDOWPLACEMENT));
COPY_DATA(byTempData, &nCount, sizeof(UINT));
}
}
}
static BYTE* pbGetReplayFileConfig(SREPLAYFILE& sReplayFile, BYTE* pbTarget)
{
BYTE* pbTemp = pbTarget;
COPY_DATA(pbTemp, &(sReplayFile.m_bEnabled), sizeof(sReplayFile.m_bEnabled));
COPY_DATA(pbTemp, &(sReplayFile.m_bInteractive), sizeof(sReplayFile.m_bInteractive));
COPY_DATA(pbTemp, &(sReplayFile.m_nReplayMode), sizeof(sReplayFile.m_nReplayMode));
COPY_DATA(pbTemp, &(sReplayFile.m_nTimeMode), sizeof(sReplayFile.m_nTimeMode));
COPY_DATA(pbTemp, &(sReplayFile.m_unCycleTimeDelay), sizeof(sReplayFile.m_unCycleTimeDelay));
COPY_DATA(pbTemp, &(sReplayFile.m_unMsgTimeDelay), sizeof(sReplayFile.m_unMsgTimeDelay));
char acName[MAX_PATH] = {_T('\0')};
strcpy_s(acName, sReplayFile.m_omStrFileName.GetBuffer(MAX_PATH));
COPY_DATA(pbTemp, acName, sizeof(char) * MAX_PATH);
return pbTemp;
}
/*******************************************************************************
Function Name : vGetDataFromStore
Input(s) : -
Output : -
Functionality : Gets the data from store for comparision.
Member of : CBusStatisticsDlg
Author(s) : Arunkumar K
Date Created : 06-04-2011
Modifications :
*******************************************************************************/
void CBusStatisticsDlg::vGetDataFromStore(BYTE** pvDataStream, UINT& nSize)
{
if(sm_sBusSerializationData.m_bIsDirty == true)
{
nSize += sizeof(BYTE); // 1 Byte for Version
nSize += sizeof(UINT); // Bytes for Buffer Size
//Bytes for column Header Positions.
nSize += sizeof(UINT); //to store the column count
UINT unColCount = sm_sBusSerializationData.m_nColumnCount;
nSize += (sizeof(int) * unColCount); //Column order
nSize += (sizeof(bool) * unColCount);//Column visibility
nSize += (sizeof(int) * unColCount); //Column width
nSize += sizeof(WINDOWPLACEMENT);//sizeof Bus Statistics dialog placement
*pvDataStream = new BYTE[nSize];
BYTE* pByteTrgt = NULL;
pByteTrgt = *pvDataStream;
if (pByteTrgt != NULL)
{
BYTE byVer = BUS_STATS_DLG_VERSION;
COPY_DATA(pByteTrgt, &byVer , sizeof(BYTE)); //Setting Version.
COPY_DATA(pByteTrgt, &nSize, sizeof(UINT)); //Setting Buffer Size.
COPY_DATA(pByteTrgt, &unColCount, sizeof(UINT)); //Storing column count.
for (UINT i = 0 ; i < unColCount; i++)
{
//Storing Column Header Positions.
COPY_DATA(pByteTrgt, &sm_sBusSerializationData.m_arrnOrder[i], sizeof(int));
//Storing Column Header show/Hide.
COPY_DATA(pByteTrgt, &sm_sBusSerializationData.m_arrbColumnVisible[i], sizeof(bool));
//Storing Column width.
COPY_DATA(pByteTrgt, &sm_sBusSerializationData.m_arrnColWidth[i], sizeof(int));
}
COPY_DATA(pByteTrgt, &sm_sBusSerializationData.m_sBusStatsDlgCoOrd, sizeof(WINDOWPLACEMENT));
}
}
}
/*******************************************************************************
Function Name : GetConfigData
Input(s) : ppvDataStream, unLength
Output : -
Functionality : Returns the Bus stats dialog Configuration in Byte Array.
Member of : CBusStatisticsDlg
Author(s) : Arunkumar K
Date Created : 06-04-2011
Modifications :
*******************************************************************************/
HRESULT CBusStatisticsDlg::GetConfigData(BYTE* pvDataStream)
{
BYTE* pByteTrgt = NULL;
pByteTrgt = pvDataStream;
BYTE byVer = BUS_STATS_DLG_VERSION;
COPY_DATA(pByteTrgt, &byVer , sizeof(BYTE)); //Setting Version.
UINT nSize= nGetBusStatsDlgConfigSize();
COPY_DATA(pByteTrgt, &nSize, sizeof(UINT)); //Setting Buffer Size.
CHeaderCtrl* pHeaderCtrl = m_omStatList.GetHeaderCtrl();
if (pHeaderCtrl != NULL)
{
int nColumnCount = pHeaderCtrl->GetItemCount();
COPY_DATA(pByteTrgt, &nColumnCount, sizeof(UINT)); //Storing column count.
LPINT pnOrder = (LPINT) malloc(nColumnCount*sizeof(int));
ASSERT(pnOrder != NULL);
m_omStatList.GetColumnOrderArray(pnOrder, nColumnCount);
for (int i = 0 ; i < nColumnCount; i++)
{
//Storing Column Header Positions.
COPY_DATA(pByteTrgt, &pnOrder[i], sizeof(int));
//Storing Column Header show/Hide.
bool bColumnVisible = m_omStatList.IsColumnShown(i);
COPY_DATA(pByteTrgt, &bColumnVisible, sizeof(bool));
//Storing Column width.
INT nColWidth = m_omStatList.GetColumnWidth(i);
COPY_DATA(pByteTrgt, &nColWidth, sizeof(int));
}
free(pnOrder);
}
GetWindowPlacement(&sm_sBusSerializationData.m_sBusStatsDlgCoOrd);
COPY_DATA(pByteTrgt, &sm_sBusSerializationData.m_sBusStatsDlgCoOrd, sizeof(WINDOWPLACEMENT));
return S_OK;
}
NS_IMETHODIMP
nsSeamonkeyProfileMigrator::Migrate(PRUint16 aItems, nsIProfileStartup* aStartup, const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
PRBool aReplace = aStartup ? PR_TRUE : PR_FALSE;
if (!mTargetProfile) {
GetProfilePath(aStartup, mTargetProfile);
if (!mTargetProfile) return NS_ERROR_FAILURE;
}
if (!mSourceProfile)
GetSourceProfile(aProfile);
NOTIFY_OBSERVERS(MIGRATION_STARTED, nsnull);
COPY_DATA(CopyPreferences, aReplace, nsIBrowserProfileMigrator::SETTINGS);
COPY_DATA(CopyCookies, aReplace, nsIBrowserProfileMigrator::COOKIES);
COPY_DATA(CopyHistory, aReplace, nsIBrowserProfileMigrator::HISTORY);
COPY_DATA(CopyPasswords, aReplace, nsIBrowserProfileMigrator::PASSWORDS);
COPY_DATA(CopyOtherData, aReplace, nsIBrowserProfileMigrator::OTHERDATA);
COPY_DATA(CopyBookmarks, aReplace, nsIBrowserProfileMigrator::BOOKMARKS);
if (aReplace &&
(aItems & nsIBrowserProfileMigrator::SETTINGS ||
aItems & nsIBrowserProfileMigrator::COOKIES ||
aItems & nsIBrowserProfileMigrator::PASSWORDS ||
!aItems)) {
// Permissions (Images, Cookies, Popups)
rv |= CopyFile(FILE_NAME_SITEPERM_NEW, FILE_NAME_SITEPERM_NEW);
rv |= CopyFile(FILE_NAME_SITEPERM_OLD, FILE_NAME_SITEPERM_OLD);
}
NOTIFY_OBSERVERS(MIGRATION_ENDED, nsnull);
return rv;
}
BYTE* CGraphParameters::pbyGetConfigData(BYTE* pbyTrgtData, BYTE byVersion)
{
BYTE* pbyTemp = pbyTrgtData;
if (pbyTemp != NULL)
{
// Set the def
COPY_DATA(pbyTemp, &m_nBufferSize, sizeof(int));
// Display ref
COPY_DATA(pbyTemp, &m_nRefreshRate, sizeof(int));
// View Style
// Frame Color
COPY_DATA(pbyTemp, &m_nFrameColor, sizeof(int));
// Frame Style
COPY_DATA(pbyTemp, &m_nFrameStyle, sizeof(int));
// Plot Area C
COPY_DATA(pbyTemp, &m_nPlotAreaColor, sizeof(int));
// Grid Color
COPY_DATA(pbyTemp, &m_nGridColor, sizeof(int));
// Axis Color
COPY_DATA(pbyTemp, &m_nAxisColor, sizeof(int));
// X Grid Line
COPY_DATA(pbyTemp, &m_nXGridLines, sizeof(int));
// Y Grid Line
COPY_DATA(pbyTemp, &m_nYGridLines, sizeof(int));
// User Select
COPY_DATA(pbyTemp, &m_nActiveAxis, sizeof(int));
// User Select
COPY_DATA(pbyTemp, &m_nAction, sizeof(int));
// Grid Settin
COPY_DATA(pbyTemp, &m_bShowGrid, sizeof(BOOL));
if(byVersion == 2)
{
//Line Display type
COPY_DATA(pbyTemp, &m_eDisplayType, sizeof(eDISPLAY_TYPE));
}
}
return pbyTemp;
}
BYTE* CTxWndDataStore::pbyGetConfigData(BYTE*& pbyConfigData, INT& nConfigSize)
{
BYTE* pbyCfgData = NULL;
UINT unSize = 0;
//FIRST CALCULATE THE SIZE
unSize += sizeof(BYTE);// configuration version
UINT unBlockCount = m_unNumberOfMsgBlockCount;
unSize += sizeof (UINT); //block count
PSMSGBLOCKLIST psTemp = m_psMsgBlockList;
while (psTemp != NULL && unBlockCount > 0)
{
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);
unSize += sizeof(bool); //allocation for auto update
//ALLOCATE THE MEMORY
pbyCfgData = new BYTE[unSize];
BYTE* pbyTemp = pbyCfgData;
BYTE byVersion = defTX_MSG_WND_VERSION;
COPY_DATA(pbyTemp, &byVersion, sizeof(BYTE));
COPY_DATA(pbyTemp, &unBlockCount, sizeof(UINT));
PSMSGBLOCKLIST psTempBlock = m_psMsgBlockList;
while (psTempBlock != NULL && unBlockCount > 0)
{
CString m_omStrBlockName;
char acName[MAX_PATH] = {_T('\0')};
strcpy_s(acName, MAX_PATH, psTempBlock->m_acStrBlockName);
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;
}
//Get the Tx window placement
COPY_DATA(pbyTemp, &m_sTxWndPlacement, sizeof(WINDOWPLACEMENT));
//Get the Tx splitter position
COPY_DATA(pbyTemp, &m_sTxMsgWndSplitterPos, sizeof(STXMSGSPLITTERDATA));
//Get the Auto save option
COPY_DATA(pbyTemp, &m_bAutoSavedEnabled, sizeof(bool));
//Update the OUT PARAMETERS
pbyConfigData = pbyCfgData;
nConfigSize = unSize;
return pbyTemp;//return the latest pointer
}
BYTE* CWaveFormDataHandler::pbyGetListConfigData(BYTE* pbyTrgtStream, const UINT /*nSize*/)
{
BYTE* pByteTrgt = pbyTrgtStream;
POSITION pos = m_lstSignalWaveformInfo.GetHeadPosition();
//Storing Messages Count.
UINT nMsgCount = m_lstSignalWaveformInfo.GetCount();
COPY_DATA(pByteTrgt, &(nMsgCount), sizeof(UINT));
while(pos)
{
SSigGeneration& objSigGen = m_lstSignalWaveformInfo.GetNext(pos);
//Storing Message ID.
COPY_DATA(pByteTrgt, &(objSigGen.m_nMsgID), sizeof(objSigGen.m_nMsgID));
//Storing Default Amplitude.
COPY_DATA(pByteTrgt, &(objSigGen.m_fDefaultAmplitude), sizeof(objSigGen.m_fDefaultAmplitude));
//Storing Signal Count.
UINT nSigCount = objSigGen.m_omSigWaveMapList.GetCount();
COPY_DATA(pByteTrgt, &(nSigCount), sizeof(UINT));
POSITION posSig = objSigGen.m_omSigWaveMapList.GetHeadPosition();
while(posSig)
{
sSigWaveMap& objSigMap = objSigGen.m_omSigWaveMapList.GetNext(posSig);
//Storing Signal Name Size.
BYTE bytSignalSize = (BYTE)objSigMap.m_omSigName.GetLength();
COPY_DATA(pByteTrgt, &(bytSignalSize), sizeof(bytSignalSize));
//Storing Signal Name String.
for(int i = 0 ;i<bytSignalSize; i++)
{
BYTE bytTemp = objSigMap.m_omSigName.GetAt(i);
COPY_DATA(pByteTrgt, &(bytTemp), sizeof(BYTE));
}
//Storing sWaveformInfo structure.
COPY_DATA(pByteTrgt, &(objSigMap.sWaveInfo.m_eSignalWaveType),
sizeof(objSigMap.sWaveInfo.m_eSignalWaveType));
COPY_DATA(pByteTrgt, &(objSigMap.sWaveInfo.m_fAmplitude),
sizeof(objSigMap.sWaveInfo.m_fAmplitude));
COPY_DATA(pByteTrgt, &(objSigMap.sWaveInfo.m_fFrequency),
sizeof(objSigMap.sWaveInfo.m_fFrequency));
COPY_DATA(pByteTrgt, &(objSigMap.sWaveInfo.m_fGranularity),
sizeof(objSigMap.sWaveInfo.m_fGranularity));
}
}
//Storing Sampling Time period.
COPY_DATA(pByteTrgt, &m_shSamplingTP, sizeof(m_shSamplingTP));
return pByteTrgt;
}
/******************************************************************************
Function Name : GetConfigurationData
Input(s) : BYTE*& pDesBuffer, UINT& unBuffSize
Output : HRESULT
Functionality :
Member of : CTSExecutorLIB
Friend of : -
Author(s) : Venkatanarayana Makam
Date Created : 07/04/2011
Modifications :
Code Tag :
******************************************************************************/
HRESULT CTSExecutorLIB::GetConfigurationData(BYTE*& pDesBuffer, UINT& unBuffSize)
{
INT nFileCount = (INT)m_ouTestSetupEntityList.GetCount();
unBuffSize = sizeof(UINT) + sizeof(BOOL)+sizeof(char)*MAX_PATH; //Number of TestSetupFiles + Status of TestSuite+TestSuite Name
for(INT i = 0; i < nFileCount; i++)
{
UINT unCount;
GetTestcaseCount(i, unCount);
//TestSuite Name + File Path + Selection Status + Number of TestCases + Testcases Status
unBuffSize += (sizeof(char)*MAX_PATH + sizeof(char)*MAX_PATH) + sizeof(BOOL) + sizeof(UINT) + (unCount*sizeof(BOOL));
}
pDesBuffer = new BYTE[unBuffSize];
if (pDesBuffer != NULL)
{
BYTE* pbyTemp = pDesBuffer;
//TestSuite name
char acTestSuiteName[MAX_PATH] = {_T('\0')};
strcpy_s(acTestSuiteName, MAX_PATH, m_omstrTestSuiteName);
COPY_DATA(pbyTemp, acTestSuiteName, (sizeof (char) * MAX_PATH));
//TestSuite Status
COPY_DATA(pbyTemp, &m_bTestSuiteStatus, sizeof(BOOL));
//File Count
COPY_DATA(pbyTemp, &nFileCount, sizeof(INT));
for(INT i = 0; i < nFileCount; i++)
{
UINT unCount;
POSITION pos = m_ouTestSetupEntityList.FindIndex(i);
CTestSetupEntity& ouTestSetupEntity = m_ouTestSetupEntityList.GetAt(pos);
//File Path
char acName[MAX_PATH] = {_T('\0')};
strcpy_s(acName, MAX_PATH, ouTestSetupEntity.m_omstrCurrentTSFile.GetBuffer(MAX_PATH));
COPY_DATA(pbyTemp, acName, (sizeof (char) * MAX_PATH));
//Selection Status
BOOL bStatus = ouTestSetupEntity.bGetEnableStatus();
COPY_DATA(pbyTemp, &bStatus, sizeof(BOOL));
//TestCase Count
ouTestSetupEntity.GetSubEntryCount(unCount);
COPY_DATA(pbyTemp, &unCount, sizeof(UINT));
//TestCase Selection Status
for(UINT j=0; j<unCount; j++)
{
CBaseEntityTA* pTCEntity;
ouTestSetupEntity.GetSubEntityObj(j, &pTCEntity);
bStatus = FALSE;
if(pTCEntity != NULL)
{
bStatus = pTCEntity->bGetEnableStatus();
}
COPY_DATA(pbyTemp, &bStatus, sizeof(BOOL));
}
//File Path + Selection Status + Number of TestCases + Testcases Status
}
}
return S_OK;
}
/**
* \brief initialises user selection
* \return TRUE or FALSE
*
* This method will initialise user selection from
* a configuration module to respective module.
*/
BOOL CCANMonitorApp::bInitialiseConfiguration(BOOL bFromCom)
{
BOOL bReturn = TRUE;
CMainFrame* pMainFrame = static_cast<CMainFrame*> (m_pMainWnd);
if(pMainFrame != nullptr )
{
BOOL bIsDatabaseFoundInConfigFile = FALSE;
if(m_pouMsgSignal != nullptr)
{
m_pouMsgSignal->bDeAllocateMemory("");
}
else
{
m_pouMsgSignal = new CMsgSignal(sg_asDbParams[CAN], m_bFromAutomation);
}
if ( m_pouMsgSignal != nullptr )
{
//Get the Database names
CStringArray aomOldDatabases;
//To keep all the files which are successfully imported
CStringArray aomNewDatabases;
aomNewDatabases.RemoveAll();
m_pouMsgSignal->vGetDataBaseNames(&aomOldDatabases);
int nFileCount = aomOldDatabases.GetSize();
if(nFileCount == 0)
{
bIsDatabaseFoundInConfigFile = FALSE;
// Reset corresponding flag
m_pouFlags->vSetFlagStatus( SELECTDATABASEFILE, FALSE );
}
else
{
CString omStrDatabase;
int nDatabaseNotFound = 0;
for(int nCount = 0; nCount < nFileCount; nCount++)
{
omStrDatabase = aomOldDatabases.GetAt(nCount);
if (omStrDatabase.IsEmpty())
{
nDatabaseNotFound++;
aomOldDatabases.RemoveAt(nCount);
--nCount;
--nFileCount;
}
else
{
bIsDatabaseFoundInConfigFile = TRUE;
// Check if the file really exists
struct _finddata_t fileinfo;
if (_findfirst(omStrDatabase.GetBuffer(MAX_PATH) ,&fileinfo) == -1L)
{
CString omStrMsg = _("Database File: ");
omStrMsg += omStrDatabase;
omStrMsg += _(" not found!");
if(bFromCom==FALSE)
{
MessageBox(nullptr,omStrMsg,"BUSMASTER",MB_OK|MB_ICONERROR);
}
// Remove the file name from configuration file.
nDatabaseNotFound++;
aomOldDatabases.RemoveAt(nCount);
--nCount;
--nFileCount;
}
else
{
// Reset corresponding flag
m_pouFlags->vSetFlagStatus( SELECTDATABASEFILE, TRUE );
m_pouMsgSignal->
bFillDataStructureFromDatabaseFile(omStrDatabase, PROTOCOL_UNKNOWN);
pMainFrame->vPopulateJ1939PGNList();
aomNewDatabases.Add(omStrDatabase);
}
}
}
if(nDatabaseNotFound > 0)
{
BYTE* pbyConfigData = nullptr;
UINT unSize = 0;
unSize += (sizeof (UINT) + ((sizeof(char) *MAX_PATH) * aomNewDatabases.GetSize()));
pbyConfigData = new BYTE[unSize];
BYTE* pbyTemp = pbyConfigData;
UINT nCount = 0;
COPY_DATA(pbyTemp, &nCount, sizeof(UINT));
for (UINT i = 0; i < nCount; i++)
{
char acName[MAX_PATH] = { '\0' };
CString omDBName = aomNewDatabases.GetAt(i);
strcpy_s(acName, MAX_PATH, omDBName.GetBuffer(MAX_PATH));
COPY_DATA(pbyTemp, acName, sizeof(char) * MAX_PATH);
}
CConfigData::ouGetConfigDetailsObject().bSetData(pbyTemp, unSize, SectionName[DATABASE_SECTION_ID]);
delete[] pbyConfigData;
pbyConfigData = nullptr;
}
if(aomNewDatabases.GetSize()== 0)
{
// Reset the flag and prompt user of file not in disk.
m_pouFlags->vSetFlagStatus( SELECTDATABASEFILE, FALSE );
}
}
}
else
{
if(bFromCom==FALSE)
// Display a message and quit the application
MessageBox(nullptr,
_(MSG_MEMORY_CONSTRAINT),
"BUSMASTER",
MB_OK|MB_ICONINFORMATION);
bReturn = FALSE;
}
//Finally load the default configuration
pMainFrame->nLoadConfigFile("");
}
return bReturn;
}
/* Renders the BYTE stream of the total message. */
void tagSTJ1939_MSG::vGetDataStream(BYTE* pbyData) const
{
COPY_DATA(pbyData, &m_sMsgProperties, sizeof(STJ1939_MSG_PROPERTIES));
COPY_DATA(pbyData, &m_unDLC, sizeof (UINT));
COPY_DATA(pbyData, m_pbyData, (sizeof (BYTE) * m_unDLC));
}
BYTE* CGraphElement::pbyGetConfigData(BYTE* pbyTrgData, BYTE byVersion)
{
BYTE* pbyTemp = pbyTrgData;
if (pbyTemp != NULL)
{
// Save properties one after another
// Message ID
COPY_DATA(pbyTemp, &m_nMsgID, sizeof(int));
// Frame Format - Standard
COPY_DATA(pbyTemp, &m_nFrameFormat, sizeof(short));
// Element Name String
char acName[MAX_PATH] = {_T('\0')};
strcpy_s(acName, m_omStrElementName.GetBuffer(MAX_PATH));
COPY_DATA(pbyTemp, acName, (sizeof(char) * MAX_PATH));
// Type of the element val
COPY_DATA(pbyTemp, &m_nValueType, sizeof(int));
// Line type of the elemen
COPY_DATA(pbyTemp, &m_nLineType, sizeof(int));
// Line Color of the eleme
COPY_DATA(pbyTemp, &m_nLineColor, sizeof(int));
// Sample point symbol typ
COPY_DATA(pbyTemp, &m_nPointType, sizeof(int));
// Sample point symbol col
COPY_DATA(pbyTemp, &m_nPointColor, sizeof(int));
// Visible or Not
COPY_DATA(pbyTemp, &m_bVisible, sizeof(BOOL));
// Enabled or not
COPY_DATA(pbyTemp, &m_bEnabled, sizeof(BOOL));
if(byVersion == 2)
{
// Message Name
char MsgName[MAX_PATH] = {_T('\0')};
strcpy_s(MsgName, m_strMsgName.GetBuffer(MAX_PATH));
COPY_DATA(pbyTemp, MsgName, (sizeof(char) * MAX_PATH));
//Line Display type
COPY_DATA(pbyTemp, &m_eDisplayType, sizeof(eDISPLAY_TYPE));
}
}
return pbyTemp;
}
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;
}
