tracetooldlg.cpp

To use the ATLTrace tool: Debug an MFC or ATL project select Start from the Debug menu. Selec

static void GetProcessIds( CArray< DWORD >& aid )
{
	OSVERSIONINFO ver;
	HINSTANCE hInst;
	ver.dwOSVersionInfoSize = sizeof(ver);
	GetVersionEx(&ver);

	if( ver.dwPlatformId == VER_PLATFORM_WIN32_NT )
	{
		// NT and Windows 2000 (although ToolHelp32 will work for W2K)
		TCHAR  infoBuf[MAX_PATH+1];
		UINT nChars=GetSystemDirectory(infoBuf, _countof(infoBuf));
		ATLENSURE(nChars<_countof(infoBuf));
		infoBuf[_countof(infoBuf)-1]=_T('\0');
		strcat_s(infoBuf, sizeof(infoBuf) / sizeof(TCHAR), _T("\\PSAPI.DLL"));
		hInst = LoadLibrary(infoBuf);
		if( hInst != NULL )
		{
			BOOL (WINAPI* pfnEnumProcesses)(DWORD*, DWORD, DWORD*) =
				(BOOL (WINAPI*)(DWORD*, DWORD, DWORD*))GetProcAddress( hInst, "EnumProcesses" );
			if( pfnEnumProcesses != NULL )
			{
				aid.SetSize( 256 );
				ULONG nBytes = 256*sizeof( DWORD );
				ULONG nActualBytes = 0;

				bool bDone = false;
				while( !bDone )
				{
					pfnEnumProcesses( aid.GetData(), nBytes, &nActualBytes );
					if( nActualBytes < nBytes )
					{
						// Got all of them
						aid.SetSize( nActualBytes/sizeof( DWORD ) );
						bDone = true;
					}
					else
					{
						nBytes *= 2;
						aid.SetSize( aid.GetSize()*2 );
						nActualBytes = 0;
					}
				}
			}
			FreeLibrary( hInst );
		}
	}
	else
	{
		// Win95/98
		hInst = GetModuleHandle( _T( "Kernel32.dll" ) );
		ASSERT( hInst != NULL );
		if( hInst != NULL )
		{
			HANDLE (WINAPI *pfnCreateSnapshot)(DWORD, DWORD) =
				(HANDLE (WINAPI *)(DWORD, DWORD)) 
				GetProcAddress( hInst, "CreateToolhelp32Snapshot" );

			BOOL (WINAPI *pfnProcessFirst)(HANDLE, LPPROCESSENTRY32) =
				(BOOL (WINAPI *)(HANDLE, LPPROCESSENTRY32))
				GetProcAddress( hInst, "Process32First" );

			BOOL (WINAPI *pfnProcessNext)(HANDLE, LPPROCESSENTRY32) =
				(BOOL (WINAPI *)(HANDLE, LPPROCESSENTRY32))
				GetProcAddress( hInst, "Process32Next" );

			if( (pfnCreateSnapshot != NULL) &&
				(pfnProcessFirst != NULL) &&
				(pfnProcessNext != NULL) )
			{
				PROCESSENTRY32 pe;
				HANDLE hSnapShot = pfnCreateSnapshot( TH32CS_SNAPPROCESS, 0 );

				if( hSnapShot != INVALID_HANDLE_VALUE)
				{
					if( pfnProcessFirst( hSnapShot, &pe ) )
					{
						do
						{
							aid.Add( pe.th32ProcessID );
						}
						while( pfnProcessNext( hSnapShot, &pe ) );
					}
					CloseHandle( hSnapShot );
				}
			}
		}
	}
}

void CTraceToolDlg::OnBnClickedSave()
{
	HTREEITEM hItem = m_tree.GetSelectedItem();
	if(hItem)
	{
		OnClickedApply();
				
		HTREEITEM hItemCheck = m_tree.GetParentItem(hItem);
		while(hItemCheck)
		{
			hItem = hItemCheck;
			hItemCheck = m_tree.GetParentItem(hItem);
		}

		if (!hItem)
			return;

		PROCESSSETTINGS *pPS = reinterpret_cast<PROCESSSETTINGS*>(m_tree.GetItemData(hItem));
		ATLTRACEPROCESSINFO	pi;
		if (!AtlTraceGetProcessInfo(pPS->dwProcess, &pi))
			return;

		CString strFileName = pi.szName;
		int nDot = strFileName.ReverseFind('.');
		if (nDot != -1)
		{
			strFileName = strFileName.Left(nDot + 1);
			strFileName += _T("trc");
		}
		else
			strFileName += _T(".trc");

		CFileDialog dlg(FALSE, _T("trc"), strFileName, OFN_HIDEREADONLY | 
			OFN_NOREADONLYRETURN | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT, 
			_T("ATL Trace Files (*.trc)|*.trc||"), this);

		CString strPath = pi.szPath;
		int nSlash = strPath.ReverseFind('\\');
		if (nSlash != -1)
			strPath = strPath.Left(nSlash);

		dlg.m_ofn.lpstrInitialDir = strPath;

		if (IDOK == dlg.DoModal())
		{
			BOOL bOK=AtlTraceSaveSettings(dlg.GetPathName(), pPS->dwProcess);
			if (bOK==FALSE)
			{
				AfxMessageBox(IDS_INVALIDFILENAME);
			}
		}
	}
}

void CTraceToolDlg::OnBnClickedLoad()
{
	HTREEITEM hItem = m_tree.GetSelectedItem();
	if(hItem)
	{
		OnClickedApply();
				
		HTREEITEM hItemCheck = m_tree.GetParentItem(hItem);
		while(hItemCheck)
		{
			hItem = hItemCheck;
			hItemCheck = m_tree.GetParentItem(hItem);
		}

		if (!hItem)
			return;

		PROCESSSETTINGS *pPS = reinterpret_cast<PROCESSSETTINGS*>(m_tree.GetItemData(hItem));
		ATLTRACEPROCESSINFO	pi;
		if (!AtlTraceGetProcessInfo(pPS->dwProcess, &pi))
			return;

		CFileDialog dlg(TRUE, _T("trc"), NULL, OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST, 
			_T("ATL Trace Files (*.trc)|*.trc||"), this);

		CString strPath = pi.szPath;
		int nSlash = strPath.ReverseFind('\\');
		if (nSlash != -1)
			strPath = strPath.Left(nSlash);

		dlg.m_ofn.lpstrInitialDir = strPath;

		if (IDOK == dlg.DoModal())
		{
			AtlTraceLoadSettings(dlg.GetPathName(), pPS->dwProcess);
			RefreshProcess(pPS->dwProcess);
		}
	}
}

void CTraceToolDlg::OnBnClickedRefresh()
{
	Cleanup();
	m_bDeleting = TRUE;
	m_tree.DeleteAllItems();
	m_bDeleting = FALSE;
	InitVariables();
	UpdateData(FALSE);
	PopulateTree();
}

void CTraceToolDlg::Cleanup()
{
	for( HTREEITEM hProcess = m_tree.GetChildItem( TVI_ROOT ); hProcess != NULL; hProcess = m_tree.GetNextSiblingItem( hProcess ) )
	{
		for (HTREEITEM hModule = m_tree.GetChildItem( hProcess ); hModule != NULL; hModule = m_tree.GetNextSiblingItem( hModule ) )
		{
			for (HTREEITEM hCategory = m_tree.GetChildItem( hModule ); hCategory != NULL; hCategory = m_tree.GetNextSiblingItem( hCategory ) )
			{
				TRACESETTINGS *pTSCategory = reinterpret_cast<TRACESETTINGS*>(m_tree.GetItemData( hCategory ));
				delete pTSCategory;
			}

			TRACESETTINGS *pTSModule = reinterpret_cast<TRACESETTINGS*>(m_tree.GetItemData( hModule ));
			delete pTSModule;
		}

		PROCESSSETTINGS *pPS = reinterpret_cast<PROCESSSETTINGS*>(m_tree.GetItemData( hProcess ));
		AtlTraceCloseProcess( pPS->dwProcess );
		delete pPS;
	}
}

void CTraceToolDlg::InitVariables()
{
	m_nProcessLevel = 0;
	m_nModuleLevel = 0;
	m_nCategoryLevel = 0;
	m_pPS = NULL;	
	m_pTSModule = NULL;	
	m_pTSCategory = NULL;	
	m_bFuncAndCategory = FALSE;
	m_bFileAndLine = FALSE;
	m_bProcessEnabled = TRUE;
	m_iModuleStatus = 0;
	m_iCategoryStatus = 0;
	m_bDeleting = FALSE;
	m_bDirty = FALSE;
}

void CTraceToolDlg::OnHScroll( UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	CSliderCtrl *pSlider = reinterpret_cast<CSliderCtrl*>(pScrollBar);
	ENSURE(pSlider);

	int nID = pSlider->GetDlgCtrlID();
	switch (nID)
	{
		case ID_PROCESS_SLIDER_LEVEL:
			OnProcessChanged();
			break;
		case ID_MODULE_SLIDER_LEVEL:
			OnModuleChanged();
			break;
		case ID_CATEGORY_SLIDER_LEVEL:
			OnCategoryChanged();
			break;
	}

	return CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
}

void CTraceToolDlg::OnProcessChanged()
{
	if (!m_pPS)
		return;

	UpdateData(TRUE);

	m_pPS->bModified = TRUE;
	m_pPS->ps.bEnabled = m_bProcessEnabled;
	m_pPS->ps.bFileNameAndLineNo = m_bFileAndLine;
	m_pPS->ps.bFuncAndCategoryNames = m_bFuncAndCategory;
	m_pPS->ps.nLevel = m_nProcessLevel;

	m_bDirty = TRUE;
	UpdateControls();
}

void CTraceToolDlg::OnModuleChanged()
{
	if (!m_pTSModule)
		return;

	UpdateData(TRUE);

	m_pTSModule->bModified = TRUE;
	m_pTSModule->ts.eStatus = IntToStatus(m_iModuleStatus);
	m_pTSModule->ts.nLevel = m_nModuleLevel;

	if (m_pPS)
		m_pPS->bModified = TRUE;

	m_bDirty = TRUE;
	UpdateControls();
}

void CTraceToolDlg::OnCategoryChanged()
{
	if (!m_pTSCategory)
		return;

	UpdateData(TRUE);

	m_pTSCategory->bModified = TRUE;
	m_pTSCategory->ts.eStatus = IntToStatus(m_iCategoryStatus);
	m_pTSCategory->ts.nLevel = m_nCategoryLevel;

	if (m_pTSModule)
		m_pTSModule->bModified = TRUE;

	if (m_pPS)
		m_pPS->bModified = TRUE;

	m_bDirty = TRUE;
	UpdateControls();
}

BOOL CTraceToolDlg::OnWndMsg( UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult )
{
	if (WM_CLOSE == message)
	{
		if (m_bDirty)
		{
			if (IDNO == AfxMessageBox(IDS_CLOSEWITHOUTAPPLY, MB_YESNO))
				return TRUE;
		}
	}
	return CDialog::OnWndMsg( message, wParam, lParam, pResult );
}

void CTraceToolDlg::OnCancel()
{
	if (m_bDirty)
	{
		if (IDNO == AfxMessageBox(IDS_CLOSEWITHOUTAPPLY, MB_YESNO))
			return;
	}
	CDialog::OnCancel();
}

void CTraceToolDlg::RefreshProcess(DWORD_PTR dwProcess)
{
	HTREEITEM hProcess = m_tree.GetSelectedItem();
	if (hProcess)
	{
		HTREEITEM hItemCheck = m_tree.GetParentItem(hProcess);
		while(hItemCheck)
		{
			hProcess = hItemCheck;
			hItemCheck = m_tree.GetParentItem(hProcess);
		}
		if (!hProcess)
			return;

		PROCESSSETTINGS *pPS = reinterpret_cast<PROCESSSETTINGS*>(m_tree.GetItemData(hProcess));
		pPS->bModified = FALSE;
		AtlTraceGetProcess(dwProcess, &pPS->ps.nLevel, &pPS->ps.bEnabled, &pPS->ps.bFuncAndCategoryNames, &pPS->ps.bFileNameAndLineNo);

		for (HTREEITEM hModule = m_tree.GetChildItem( hProcess ); hModule != NULL; hModule = m_tree.GetNextSiblingItem( hModule ) )
		{
			TRACESETTINGS *pTSModule = reinterpret_cast<TRACESETTINGS*>(m_tree.GetItemData( hModule ));
			pTSModule->bModified = FALSE;
			AtlTraceGetModule( dwProcess, pTSModule->dwHandle, &pTSModule->ts.nLevel, &pTSModule->ts.eStatus );

			for (HTREEITEM hCategory = m_tree.GetChildItem( hModule ); hCategory != NULL; hCategory = m_tree.GetNextSiblingItem( hCategory ) )
			{
				TRACESETTINGS *pTSCategory = reinterpret_cast<TRACESETTINGS*>(m_tree.GetItemData( hCategory ));
				pTSCategory->bModified = FALSE;
				AtlTraceGetCategory( dwProcess, pTSCategory->dwHandle, &pTSCategory->ts.nLevel, &pTSCategory->ts.eStatus );
			}
		}
		UpdateSelectedItem(m_tree.GetSelectedItem());
	}
}

void CTraceToolDlg::UpdateSelectedItem(HTREEITEM hSelection)
{
	HTREEITEM hParent = NULL;
	HTREEITEM hGrandparent = NULL;
	if( hSelection != NULL )
	{
		hParent = m_tree.GetParentItem( hSelection );
	}
	if( hParent != NULL )
	{
		hGrandparent = m_tree.GetParentItem( hParent );
	}

	HTREEITEM hProcessItem = NULL;
	HTREEITEM hModuleItem = NULL;
	HTREEITEM hCategoryItem = NULL;
	if( hGrandparent != NULL )
	{
		// hSelection is a category
		hCategoryItem = hSelection;
		hModuleItem = hParent;
		hProcessItem = hGrandparent;
	}
	else if( hParent != NULL )
	{
		// hSelection is a module
		hModuleItem = hSelection;
		hProcessItem = hParent;
	}
	else if( hSelection != NULL )
	{
		// hSelection is a process
		hProcessItem = hSelection;
	}

	m_pPS = 0;
	m_pTSModule = 0;
	m_pTSCategory = 0;
	if( hProcessItem != NULL )
	{
		m_pPS = reinterpret_cast<PROCESSSETTINGS*>(m_tree.GetItemData( hProcessItem ));
		m_nProcessLevel = m_pPS->ps.nLevel;
		m_bProcessEnabled = m_pPS->ps.bEnabled;
		m_bFuncAndCategory = m_pPS->ps.bFuncAndCategoryNames;
		m_bFileAndLine = m_pPS->ps.bFileNameAndLineNo;
	}
	else
	{
		m_nProcessLevel = 0;
		m_bProcessEnabled = FALSE;
		m_bFuncAndCategory = FALSE;
		m_bFileAndLine = FALSE;
	}
	if( hModuleItem != NULL )
	{
		m_pTSModule = reinterpret_cast<TRACESETTINGS*>(m_tree.GetItemData( hModuleItem ));
		m_nModuleLevel = m_pTSModule->ts.nLevel;
		ATLTRACESTATUS eModuleStatus = m_pTSModule->ts.eStatus;
		m_iModuleStatus = StatusToInt( eModuleStatus );
	}
	else
	{
		m_nModuleLevel = 0;
		m_iModuleStatus = -1;
	}
	if( hCategoryItem != NULL )
	{
		m_pTSCategory = reinterpret_cast<TRACESETTINGS*>(m_tree.GetItemData( hCategoryItem ));
		m_nCategoryLevel = m_pTSCategory->ts.nLevel;
		ATLTRACESTATUS eCategoryStatus = m_pTSCategory->ts.eStatus;
		m_iCategoryStatus = StatusToInt( eCategoryStatus );
	}
	else
	{
		m_nCategoryLevel = 0;
		m_iCategoryStatus = -1;
	}

	UpdateData( false );

	UpdateControls();
}