HRESULT VerifyCurrentMessage(STCANDATA& sCanData, CTSExecutionCAN* pTSXCan) { AfxTrace("In VERIFY - Before Enter\n"); EnterCriticalSection(&(pTSXCan->m_omCritSecTS)); AfxTrace("In VERIFY - After Enter\n"); if(pTSXCan->m_bTimeOver == TRUE || pTSXCan->m_pCurrentVerify == NULL) { LeaveCriticalSection(&(pTSXCan->m_omCritSecTS)); return S_FALSE; } UINT unCount; pTSXCan->m_pCurrentVerify->GetSubEntryCount(unCount); if(pTSXCan->m_MsgVerifiedList.GetCount() < (INT)unCount) { CVerify_MessageData ouMsgData; if(pTSXCan->m_pCurrentVerify->GetMessageFromId(sCanData.m_uDataInfo.m_sCANMsg.m_unMsgID, &ouMsgData) == S_OK) { if (pTSXCan->m_MsgVerifiedList.Find(sCanData.m_uDataInfo.m_sCANMsg.m_unMsgID) == NULL) { UCHAR pucData[8] = {0}; memcpy(pucData, &sCanData.m_uDataInfo.m_sCANMsg.m_ucData, sCanData.m_uDataInfo.m_sCANMsg.m_ucDataLen); CSignalInfoArray ouSignalInfo; //Interprete The Messages sMESSAGE sMsg; SMSGENTRY *sMsgEntry = new SMSGENTRY; pTSXCan->m_pCurrentVerify->m_ouDataBaseManager.nGetMessageInfo(ouMsgData.m_omMessageName, sMsg); sMsgEntry->m_psMsg = &sMsg; sMsgEntry->m_psNext = NULL; pTSXCan->m_ouMsgInterpret.vSetMessageList(sMsgEntry); pTSXCan->m_ouMsgInterpret.bInterpretMsgs(ouMsgData.m_dwMessageID, pucData, ouSignalInfo); CMessageResult ouMsgResult; if( pTSXCan->bVerifyCanMessage(ouMsgData, ouSignalInfo, ouMsgResult) == TRUE) { //pTSXCan->m_nVerifyCount++; if(pTSXCan->m_ouVerifyResult != NULL && pTSXCan->m_bTimeOver == FALSE) { //pTSXCan->TSX_DisplayMessage(ouMsgData.m_omMessageName); //pTSXCan->TSX_DisplayResult(CString("SUCCESS")); pTSXCan->m_ouVerifyResult->m_MessageResultList.AddTail(ouMsgResult); } pTSXCan->m_MsgVerifiedList.AddTail((UINT&)ouMsgData.m_dwMessageID); } } } } if(pTSXCan->m_MsgVerifiedList.GetCount() == (INT)unCount) { //pTSXCan->m_nVerifyCount = 0; pTSXCan->m_pCurrentVerify = NULL; pTSXCan->m_ouVerifyEvent.SetEvent(); //pTSXCan->m_ouReadThread.m_unActionCode = INVOKE_FUNC; } LeaveCriticalSection(&(pTSXCan->m_omCritSecTS)); return S_OK; }
int ConvertFile(LPCTSTR lpFileNameIn, LPCTSTR lpFileNameOut, int nConvertWay) { CStdioFile fileIn; if(!fileIn.Open(lpFileNameIn, CFile::modeRead)) { AfxTrace(_T("Failed to Open file %s\n"), lpFileNameIn); return 0; } CStdioFile fileOut; if(!fileOut.Open(lpFileNameOut, CFile::modeReadWrite | CFile::modeCreate)) { fileIn.Close(); AfxTrace(_T("Failed to Open file %s\n"), lpFileNameOut); return 0; } int nResult = 0; CString bufRead; while(fileIn.ReadString(bufRead)) { CString bufWrite; Convert(bufRead, bufWrite, nConvertWay); bufWrite += "\n"; fileOut.WriteString(bufWrite); } fileIn.Close(); fileOut.Close(); return nResult; }
int MultiByteToMultByte(LPCSTR lpMultiByteStrSrc, int cbMultiByteSrc, UINT nCPSrc, LPSTR lpMultiByteStrDst, int cbMultiByteDst, UINT nCPDst, DWORD dwFlags) { LPWSTR lpWideCharStr = new WCHAR[cbMultiByteDst]; int nResult = 0; do { nResult = ::MultiByteToWideChar(nCPSrc, dwFlags, lpMultiByteStrSrc, cbMultiByteSrc, lpWideCharStr, cbMultiByteDst); if(nResult == 0) { AfxTrace("MultiByteToWideChar Failed. Error code = %d\n", GetLastError()); break; } BOOL bUsedDefaultChar = TRUE; nResult = ::WideCharToMultiByte(nCPDst, 0, lpWideCharStr, nResult, lpMultiByteStrDst, cbMultiByteDst, "?", &bUsedDefaultChar); if(nResult == 0) { AfxTrace("WideCharToMultiByte Failed. Error code = %d\n", GetLastError()); break; } if(bUsedDefaultChar) { AfxTrace("Used default char when converting [%s]\n", lpMultiByteStrSrc); break; } } while (FALSE); //Clean up delete lpWideCharStr; return nResult; }
void CThreadMonitor::StopMonitor(BOOL bWait, DWORD dwTimeOut) { ::SetEvent(m_hQuitEvent); if(m_hMonitor) { //Should we wait? if(bWait) { DWORD dwResult = ::WaitForSingleObject(m_hMonitor, dwTimeOut); //abnormal case, here try to terminate thread if(dwResult == WAIT_ABANDONED || dwResult == WAIT_TIMEOUT) { BOOL bResult = TerminateThread(m_hMonitor, RC_EXIT_TERMINATED); AfxTrace("TerminateThread result = %d, dwResult = %d\n", bResult, dwResult); } //There's nothing to do with WAIT_OBJECT_0 and WAIT_FAILED } //Finally close the monitor thread ::CloseHandle(m_hMonitor); m_hMonitor = NULL; } }
bool MiscUtils::Val2Str(const _variant_t& var, std::string& str) { bool bDone = true; switch(var.vt) { case VT_BSTR: case VT_LPSTR: case VT_LPWSTR: try { str.assign((LPCSTR)(_bstr_t)var); } catch (...) { bDone = false; AfxTrace(_T("Val2Str failed\n")); } break; case VT_EMPTY: str.erase(); break; default: bDone = false; break; } return bDone; }
DWORD CThreadMonitor::DoMonitor() { DWORD dwResult = 0, dwWaitResult = 0; int nCount = 0; RefreshWaitObjects(&nCount); ASSERT(nCount > 0); while(TRUE) { AfxTrace("WaitForMultipleObjects count = %d\n", nCount); if(nCount == 0) { ASSERT(m_bMonitoring == FALSE); dwResult = RC_EXIT_ALL_MONITEE_EXITED; AfxTrace("Stopped monitorring. Result code=%d\n", dwResult); return dwResult; } dwWaitResult = WaitForMultipleObjects(nCount, m_hWaitObjects, FALSE, INFINITE); //Objects signaled if(dwWaitResult >= WAIT_OBJECT_0 && dwWaitResult < (WAIT_OBJECT_0 + nCount)) { dwResult = ProcessSignaled(dwWaitResult, nCount); if(dwResult != 0) { AfxTrace("Stopped monitorring. Result code=%d\n", dwResult); return dwResult; } RefreshWaitObjects(&nCount); } else { dwResult = ProcessAbnormal(nCount, dwWaitResult); if(dwResult != 0) { return dwResult; } } } return 0; }
void CSListCtrl::OnHeaderClick(NMHDR* pNMHDR, LRESULT* pResult) { HD_NOTIFY *phdn = (HD_NOTIFY *) pNMHDR; AfxTrace("[OnHeaderClick]: iItem=%d, iButton=%d\n", phdn->iItem, phdn->iButton); *pResult = 1; }
void CPreviewCtrl::OnTimer(UINT nIDEvent) { ASSERT(m_nFrame >= 0); m_nFrame++; AfxTrace("OnTimer: %d\n", m_nFrame); InvalidateRect(NULL, TRUE); }
void AfxTraceV(IDispatch *pDisp, const char* fmt, ...) { char line[MAX_LINE_SIZE]; va_list arg; va_start(arg, fmt); vsprintf(line, fmt, arg); va_end(arg); AfxTrace(pDisp, line); }
void CPreviewCtrl::StartPreview() { if(m_nTimer != 0) { AfxTrace("StartPreview: m_nTimer=%d\n", m_nTimer); return; } m_nTimer = SetTimer(1, 40, 0); }
int CTestAction::DoAction() { CString szLog; szLog.Format("The handle is closed now. handle=%08X, name=%s", m_hHandle, m_szName); AfxTrace("%s\n", szLog); if(m_hHandle) { if(!::CloseHandle(m_hHandle)) { AfxTrace("Failed to Close Handle. %d\n", GetLastError()); } } Sleep(2000); return DELETE_BY_EXTERNAL; }
BOOL CToolBarCtrlEx::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID) { if(!CToolBarCtrl::Create(dwStyle, rect, pParentWnd, nID)) { return FALSE; } ASSERT(pParentWnd != NULL && pParentWnd->m_hWnd != NULL); AfxTrace("Add Msg Receiver: %x\n", pParentWnd->m_hWnd); m_msgReceivers.Add(pParentWnd->m_hWnd); return TRUE; }
int GBKToGB2312(LPCSTR lpMultiByteStrSrc, int cbMultiByteSrc, LPSTR lpMultiByteStrDst, int cbMultiByteDst) { DWORD dwLCID = MAKELCID(MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED), SORT_CHINESE_BIG5); int nResult = 0; nResult = ::LCMapString(dwLCID, LCMAP_SIMPLIFIED_CHINESE, lpMultiByteStrSrc, cbMultiByteSrc, lpMultiByteStrDst, cbMultiByteDst); if(nResult == 0) { AfxTrace("LCMapString Failed. Error code = %d\n", GetLastError()); } return nResult; }
BOOL CListCtrlEx::PreTranslateMessage(MSG* pMsg) { // TODO: Add your specialized code here and/or call the base class if(pMsg->message == WM_KEYDOWN) { if(GetKeyState(VK_TAB)<0) { AfxTrace(_T("I got the message\n")); } } return CFFListCtrl::PreTranslateMessage(pMsg); }
void CPreviewCtrl::StopPreview() { if(m_nTimer == 0) { AfxTrace("StopPreview: m_nTimer=0\n"); return; } KillTimer(m_nTimer); m_nTimer = 0; m_nFrame = 0; }
/* bool TestStream::SubmitSamples(LPBYTE pData, UINT nLength) { if ((pData == NULL) || (nLength == 0)) return false; CSingleLock lock(&m_cs, TRUE); if ((m_memBuffer.GetMemoryLength() - m_nBufferLength) < nLength) { AfxTrace(_T("Dropping samples\n")); return true; } UINT nStart = (m_nBufferStart + m_nBufferLength) % m_memBuffer.GetMemoryLength(); UINT n1 = min(nStart + nLength, m_memBuffer.GetMemoryLength()) - nStart; memcpy(m_memBuffer.GetMemoryPointer() + nStart, pData, n1); if (n1 != nLength) { memcpy((m_memBuffer.GetMemoryPointer() + 0), (pData + n1), (nLength - n1)); } m_nBufferLength += nLength; ASSERT(m_nBufferLength <= m_memBuffer.GetMemoryLength()); if (m_nBufferLength >= (GetSamplesPerPacket() * 2 * sizeof(short))) SetEvent(m_hDataEvent); return true; } */ int TestStream::ReadPacket() { UINT nSize = GetSamplesPerPacket() * 2 * sizeof(short); CSingleLock lock(&m_cs, TRUE); retry_read: if (m_bRunning == false) return 0; if (m_nBufferLength < nSize) { lock.Unlock(); HANDLE hHandles[] = { m_hQuitEvent, m_hDataEvent }; DWORD dw = WaitForMultipleObjects(sizeof(hHandles)/sizeof(hHandles[0]), hHandles, FALSE, INFINITE); if (dw == (WAIT_OBJECT_0 + 0)) { return 0; } else if (dw == (WAIT_OBJECT_0 + 1)) { lock.Lock(); if (m_nBufferLength < nSize) { AfxTrace(_T("TestStream::ReadPacket received un-block event, but not yet enough data in buffer\n")); goto retry_read; } } else { ASSERT(FALSE); return 0; } } /* UINT n1 = min(m_nBufferStart + nSize, m_memBuffer.GetMemoryLength()) - m_nBufferStart; memcpy(m_mem.GetMemoryPointer(), (m_memBuffer.GetMemoryPointer() + m_nBufferStart), n1); if (n1 != nSize) { memcpy((m_mem.GetMemoryPointer() + n1), (m_memBuffer.GetMemoryPointer() + 0), (nSize - n1)); } ASSERT(m_nBufferLength >= nSize); m_nBufferLength -= nSize; m_nBufferStart = (m_nBufferStart + nSize) % m_memBuffer.GetMemoryLength(); */ return GetSamplesPerPacket(); }
void CBrowseEditItem::OnKillFocus(CWnd* pNewWnd) { CEdit::OnKillFocus(pNewWnd); // TODO: Add your message handler code here if( pNewWnd // NULL condition && pNewWnd != GetParent()->GetParent() //For Dialog Close using X Button && pNewWnd->GetDlgCtrlID() != IDCANCEL ) // For Cancel condition { AfxTrace("In if Condition\n"); CString str; GetWindowText(str); // Send Notification to parent of ListView ctrl LV_DISPINFO lvDispInfo; lvDispInfo.hdr.hwndFrom = GetParent()->m_hWnd; lvDispInfo.hdr.idFrom = GetDlgCtrlID(); lvDispInfo.hdr.code = LVN_ENDLABELEDIT; lvDispInfo.item.mask = LVIF_TEXT; lvDispInfo.item.iItem = m_nItem; lvDispInfo.item.iSubItem = m_nSubItem; // Restore the old text on press of ESCAPE key lvDispInfo.item.pszText = m_bVK_ESCAPE ? LPTSTR((LPCTSTR)m_sContent) : LPTSTR((LPCTSTR)str); lvDispInfo.item.cchTextMax = str.GetLength(); // Send the notification message to the parent GetParent()->GetParent()->SendMessage( WM_NOTIFY, GetParent()->GetDlgCtrlID(), (LPARAM)&lvDispInfo); } //HWND hNewWnd = 0; if(pNewWnd != NULL) { if(m_pomButton->GetSafeHwnd() == pNewWnd->GetSafeHwnd()) { return; } } if((((CButtonItem*)m_pomButton)->m_bButtonclicked == FALSE) && (m_bKillFocus == TRUE)) { ((CButtonItem*)m_pomButton)->m_bIsEditValid = FALSE; if(m_bIsButtonValid == TRUE) { ((CButtonItem*)m_pomButton)->m_bKillFocus = TRUE; m_pomButton->SendMessage(WM_KILLFOCUS, 0, 0); } DestroyWindow(); } }
BOOL CSListCtrl::IsPtInSubItemCheckBox(int nItem, int nSubItem, POINT pt) { BOOL bResult = FALSE; CRect checkboxRect; if(CalcCheckBoxRect(nItem, nSubItem, checkboxRect)) { bResult = checkboxRect.PtInRect(pt); } AfxTrace("IsPtInSubItemCheckBox: %d\n", bResult); return bResult; }
void CMemLeakDetect::removeMemoryTrace(void* addr, void* realdataptr) { AllocBlockInfo ainfo; // if (m_AllocatedMemoryList.Lookup(addr,(AllocBlockInfo &) ainfo)) { m_AllocatedMemoryList.RemoveKey(addr); } else { //freeing unallocated memory AfxTrace(_T("ERROR!CMemLeakDetect::removeMemoryTrace() didnt find Address(0x%08X) to free\n"), addr); } };
void CToolBarCtrlEx::Refresh() { // Causes a toolbar to be resized. AutoSize(); //Send message to all the receivers. int nMsgReceiverCount = m_msgReceivers.GetSize(); LRESULT lr = 0; for(int i = 0; i < nMsgReceiverCount; i++) { AfxTrace("Send Msg to: %x\n", m_msgReceivers.GetAt(i)); lr = ::SendMessage(m_msgReceivers.GetAt(i), UM_TOOLBARCTRLX_REFRESH, 0, 0); } }
void CYTGetApp::InitLog4cplus() { #ifdef ENABLE_LOG4CPLUS const char* pLogFileSuffixName = "LOG_FILE_SUFFIX"; CString szLogFileSuffix = getenv(pLogFileSuffixName); const char* pAppWorkDirName = "APP_WORK_DIR"; CString szAppWorkDir = getenv(pAppWorkDirName); //Set the env to the current time str CString sTime = CTime::GetCurrentTime().Format("_%Y_%m_%d_%H_%M_%S"); CString szValue; szValue.Format("%s=%s", pLogFileSuffixName, sTime); _putenv(szValue); szValue.Format("%s=%s", pAppWorkDirName, m_szWorkDir); _putenv(szValue); CString szConfigFile; szConfigFile.Format("%s\\log4cplus.properties", m_szWorkDir); try { //This will take effect in the configure process log4cplus::PropertyConfigurator::doConfigure((LPCTSTR)szConfigFile); { CString szLog; szLog.Format("Config File=%s", szConfigFile); LOG4CPLUS_INFO_STR(ROOT_LOGGER, (LPCTSTR)szLog) } } catch(...) { CString sLogInfo; sLogInfo.Format("Exception occured when configure log4cplus, config file = %s", szConfigFile); AfxTrace("%s\n", sLogInfo); LOG4CPLUS_FATAL(ROOT_LOGGER, (LPCTSTR)sLogInfo) } //After configuration, restore the environment variable. szValue.Format("%s=%s", pLogFileSuffixName, szLogFileSuffix); _putenv(szValue); szValue.Format("%s=%s", pAppWorkDirName, szAppWorkDir); _putenv(szValue); #endif }
void CPreviewCtrl::OnTimer(UINT nIDEvent) { if(m_nFrame < 0) { m_nFrame = 0; } else { m_nFrame++; } if(m_nFrame > m_nTotalFrames) { m_nFrame = 0; StopPreview(); } AfxTrace("OnTimer: m_nFrame=%d\n", m_nFrame); InvalidateRect(NULL, TRUE); CStatic::OnTimer(nIDEvent); }
BOOL CSListCtrl::OnColumnClick(NMHDR* pNMHDR, LRESULT* pResult) { NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; *pResult = 0; AfxTrace("[OnColumnClick]: iItem=%d\n", pNMListView->iSubItem); int nSubItem = pNMListView->iSubItem; //1. Check if clicked a check box in header if(!m_HeaderCtrl.IsClickedCheckBox(nSubItem)) { //CTRL key is pressed m_pSortable->SortColumn(nSubItem, ::GetKeyState( VK_CONTROL ) < 0); return FALSE; } //2. Clicked check box in header int nCheckedState = GetHeaderCheckedState(nSubItem); // CHECK_LIST_CTRL_NO_IMAGE = no checkbox if (nCheckedState != SHC_NONE_CHECK_BOX) { nCheckedState = SwitchCheckedState(nCheckedState); SetHeaderCheckedState(nSubItem, nCheckedState); m_HeaderCtrl.UpdateWindow(); for (int nItem = 0; nItem < GetItemCount(); nItem++) { if (GetItemCheckedState(nItem, nSubItem) != SHC_NONE_CHECK_BOX) { SetItemCheckedState(nItem, nSubItem, nCheckedState); } } UpdateWindow(); } return FALSE; }
BOOL CPreviewCtrl::SaveToFile(BITMAPFILEHEADER* pBFH, BITMAPINFOHEADER* pBIH, LPVOID lpDibData, LPCTSTR lpszFileName) { HANDLE hFile = CreateFile(lpszFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if(hFile == INVALID_HANDLE_VALUE) { return FALSE; } BOOL bOK = FALSE; DWORD dwWrite = 0; do { if(!WriteFile(hFile, pBFH, sizeof(BITMAPFILEHEADER), &dwWrite, NULL)) { break; } if(!WriteFile(hFile, pBIH, sizeof(BITMAPINFOHEADER), &dwWrite, NULL)) { break; } if(!WriteFile(hFile, lpDibData, pBIH->biSizeImage, &dwWrite, NULL)) { break; } bOK = TRUE; } while (FALSE); CloseHandle(hFile); if(!bOK) { DWORD dwErrorCode = GetLastError(); AfxTrace("%08X\n", dwErrorCode); } return bOK; }
DWORD CThreadMonitor::ProcessSignaled(DWORD dwRet, int nCount) { ASSERT(dwRet >= WAIT_OBJECT_0 && dwRet < (WAIT_OBJECT_0 + nCount)); int nSingaledCount = 0; int pSingaledIndex[MAX_WAIT_COUNT]; int nFirstMonitee, nControlEventEnd; GetSignaledObjects(dwRet, nCount, pSingaledIndex, &nSingaledCount); ASSERT(nSingaledCount > 0 && nSingaledCount <= nCount); //Debug Code CString szLog, szTemp; szLog.Format("[Signaled Objects]: count=%d, ", nSingaledCount); for(int i = 0; i < nSingaledCount; i++) { szTemp.Format("%d ", pSingaledIndex[i]); szLog += szTemp; } AfxTrace("%s\n", szLog); nFirstMonitee = FindFirstMonitee(pSingaledIndex, nSingaledCount); if(nFirstMonitee >= 0) { ProcessSignaledMonitees(pSingaledIndex, nSingaledCount, nFirstMonitee); nControlEventEnd = nFirstMonitee; } else { ASSERT(nSingaledCount <= MAX_CONTROL_EVENT_COUNT); nControlEventEnd = nSingaledCount; } DWORD dwResult = ProcessSignaledControlEvents(pSingaledIndex, nControlEventEnd); return dwResult; }
void CMemLeakDetect::addMemoryTrace(void* addr, size_t asize, TCHAR *fname, DWORD lnum) { AllocBlockInfo ainfo; // if (m_AllocatedMemoryList.Lookup(addr, ainfo)) { // already allocated AfxTrace(_T("ERROR!CMemLeakDetect::addMemoryTrace() Address(0x%p) already allocated\n"), addr); return; } // ainfo.address = addr; ainfo.lineNumber = lnum; ainfo.size = asize; ainfo.occurance = memoccurance++; MLD_STACKWALKER(&ainfo.traceinfo[0]); // if (fname) _tcsncpy_s(&ainfo.fileName[0], MLD_MAX_NAME_LENGTH, fname, MLD_MAX_NAME_LENGTH); else ainfo.fileName[0] = 0; // m_AllocatedMemoryList.SetAt(addr, ainfo); };
void CMemLeakDetect::redoMemoryTrace(void* addr, void* oldaddr, size_t asize, TCHAR *fname, DWORD lnum) { AllocBlockInfo ainfo; if (m_AllocatedMemoryList.Lookup(oldaddr,(AllocBlockInfo &) ainfo)) { m_AllocatedMemoryList.RemoveKey(oldaddr); } else { AfxTrace(_T("ERROR!CMemLeakDetect::redoMemoryTrace() didnt find Address(0x%08X) to free\n"), oldaddr); } // ainfo.address = addr; ainfo.lineNumber = lnum; ainfo.size = asize; ainfo.occurance = memoccurance++; MLD_STACKWALKER(&ainfo.traceinfo[0]); // if (fname) _tcsncpy_s(&ainfo.fileName[0], MLD_MAX_NAME_LENGTH, fname, MLD_MAX_NAME_LENGTH); else ainfo.fileName[0] = 0; m_AllocatedMemoryList.SetAt(addr, ainfo); };
DWORD CThreadMonitor::ProcessAbnormal(int nCount, DWORD dwResult) { CString szErrorMsg; if(dwResult >= WAIT_ABANDONED_0 && dwResult < (WAIT_ABANDONED_0 + nCount)) { szErrorMsg.Format("WAIT_ABANDONED, index=%d", dwResult - WAIT_ABANDONED_0); } else if(dwResult == WAIT_TIMEOUT) { szErrorMsg.Format("WAIT_TIMEOUT"); } else if(dwResult == WAIT_FAILED) { szErrorMsg.Format("WAIT_FAILED, Last Error=%d", GetLastError()); } else { szErrorMsg.Format("Unkown result (%d)", dwResult); } AfxTrace("WaitForMultipleObjects return abnormal. Details: %s\n", szErrorMsg); return 0; }
static void AFXAPI TraceDDE(LPCTSTR lpszPrefix, const MSG* pMsg) { ENSURE_ARG(pMsg != NULL); if (pMsg->message == WM_DDE_EXECUTE) { UINT_PTR nDummy; HGLOBAL hCommands; if (!UnpackDDElParam(WM_DDE_EXECUTE, pMsg->lParam, &nDummy, (UINT_PTR*)&hCommands)) { TRACE(traceAppMsg, 0, "Warning: Unable to unpack WM_DDE_EXECUTE lParam %08lX.\n", pMsg->lParam); return; } ASSERT(hCommands != NULL); LPCTSTR lpszCommands = (LPCTSTR)::GlobalLock(hCommands); ENSURE_THROW(lpszCommands != NULL, ::AfxThrowMemoryException() ); TRACE(traceAppMsg, 0, _T("%s: Execute '%s'.\n"), lpszPrefix, lpszCommands); ::GlobalUnlock(hCommands); } else if (pMsg->message == WM_DDE_ADVISE) { UINT_PTR nItem; ATOM aItem; HGLOBAL hAdvise; if (!UnpackDDElParam(WM_DDE_ADVISE, pMsg->lParam, (UINT_PTR*)&hAdvise, &nItem)) { TRACE(traceAppMsg, 0, "Warning: Unable to unpack WM_DDE_ADVISE lParam %08lX.\n", pMsg->lParam); return; } aItem = (ATOM)nItem; ASSERT(aItem != NULL); ASSERT(hAdvise != NULL); DDEADVISE* lpAdvise = (DDEADVISE*)::GlobalLock(hAdvise); ENSURE_THROW(lpAdvise != NULL, ::AfxThrowMemoryException() ); TCHAR szItem[80]; szItem[0] = '\0'; if (aItem != 0) ::GlobalGetAtomName(aItem, szItem, _countof(szItem)); TCHAR szFormat[80]; szFormat[0] = '\0'; if (((UINT)0xC000 <= (UINT)lpAdvise->cfFormat) && ((UINT)lpAdvise->cfFormat <= (UINT)0xFFFF)) { ::GetClipboardFormatName(lpAdvise->cfFormat, szFormat, _countof(szFormat)); // User defined clipboard formats have a range of 0xC000->0xFFFF // System clipboard formats have other ranges, but no printable // format names. } AfxTrace( _T("%s: Advise item='%s', Format='%s', Ack=%d, Defer Update= %d\n"), lpszPrefix, szItem, szFormat, lpAdvise->fAckReq, lpAdvise->fDeferUpd); ::GlobalUnlock(hAdvise); } }
void MyTraceMsg(LPCTSTR lpszPrefix, const MSG* pMsg) { ASSERT(lpszPrefix != NULL); ASSERT(pMsg != NULL); if (/*pMsg->message == WM_MOUSEMOVE || */ //pMsg->message == WM_NCMOUSEMOVE || //pMsg->message == WM_NCHITTEST || pMsg->message == WM_SETCURSOR || pMsg->message == WM_CTLCOLORBTN || pMsg->message == WM_CTLCOLORDLG || pMsg->message == WM_CTLCOLOREDIT || pMsg->message == WM_CTLCOLORLISTBOX || pMsg->message == WM_CTLCOLORMSGBOX || pMsg->message == WM_CTLCOLORSCROLLBAR || pMsg->message == WM_CTLCOLORSTATIC || pMsg->message == WM_ENTERIDLE || pMsg->message == WM_CANCELMODE || pMsg->message == 0x0118) // WM_SYSTIMER (caret blink) { // don't report very frequently sent messages return; } LPCSTR lpszMsgName = NULL; char szBuf[80]; // find message name if (pMsg->message >= 0xC000) { // Window message registered with 'RegisterWindowMessage' // (actually a USER atom) if (::GetClipboardFormatNameA(pMsg->message, szBuf, ARRAY_SIZE(szBuf))) lpszMsgName = szBuf; } else if (pMsg->message >= WM_USER) { // User message wsprintfA(szBuf, "WM_USER+0x%04X", pMsg->message - WM_USER); lpszMsgName = szBuf; } else { // a system windows message const TRACE_MAP_MESSAGE* pMapMsg = allMessages; for (/*null*/; pMapMsg->lpszMsg != NULL; pMapMsg++) { if (pMapMsg->nMsg == pMsg->message) { lpszMsgName = pMapMsg->lpszMsg; break; } } } if (lpszMsgName != NULL) { if(pMsg->message==WM_WINDOWPOSCHANGING || pMsg->message==WM_WINDOWPOSCHANGED ) { LPWINDOWPOS pPos = (LPWINDOWPOS)pMsg->lParam; AfxTrace(_T("%s: hwnd=0x%04X, msg = %hs (%ld,%ld)(%ld,%ld)-0x%08lX\n"), lpszPrefix, HWndToUInt(pMsg->hwnd), lpszMsgName, pPos->x,pPos->y,pPos->cx,pPos->cy,pPos->flags); } else if(pMsg->message==WM_STYLECHANGING || pMsg->message==WM_STYLECHANGED ) { LPSTYLESTRUCT pStyle =(LPSTYLESTRUCT)pMsg->lParam; AfxTrace(_T("%s: hwnd=0x%04X, msg = %hs %s New: 0x%08x, Old: 0x%08x\n"), lpszPrefix, HWndToUInt(pMsg->hwnd), lpszMsgName,(LPCTSTR)((GWL_EXSTYLE==pMsg->wParam)?_T("EXSTYLE"):_T("STYLE")), pStyle->styleNew,pStyle->styleOld); } else { AfxTrace(_T("%s: hwnd=0x%04X, msg = %hs (0x%04X, 0x%08lX)\n"), lpszPrefix, HWndToUInt(pMsg->hwnd), lpszMsgName, pMsg->wParam, pMsg->lParam); } } else { AfxTrace(_T("%s: hwnd=0x%04X, msg = 0x%04X (0x%04X, 0x%08lX)\n"), lpszPrefix, HWndToUInt(pMsg->hwnd), pMsg->message, pMsg->wParam, pMsg->lParam); } // if (pMsg->message >= WM_DDE_FIRST && pMsg->message <= WM_DDE_LAST) // TraceDDE(lpszPrefix, pMsg); }