tracetooldlg.cpp

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

// TraceToolDlg.cpp : implementation file
//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Classes Reference and related electronic
// documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft C++ Libraries products.

#include "stdafx.h"
#include "TraceTool.h"
#include "TraceToolDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#if _SECURE_ATL
#pragma warning(disable:4127)
#endif

// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	enum { IDD = IDD_ABOUTBOX };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

// Implementation
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()


// CTraceToolDlg dialog



CTraceToolDlg::CTraceToolDlg(CWnd* pParent /*=NULL*/) : 
	CDialog(CTraceToolDlg::IDD, pParent)
{
	InitVariables();
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CTraceToolDlg::DoDataExchange(CDataExchange* pDX)
{
	DDX_Check(pDX, ID_PROCESS_CHECKBOX_FILENAMEANDLINENO, m_bFileAndLine);
	DDX_Check(pDX, ID_PROCESS_CHECKBOX_FUNCANDCATNAMES, m_bFuncAndCategory);
	DDX_Check(pDX, ID_PROCESS_CHECKBOX_ENABLED, m_bProcessEnabled);
	DDX_Slider(pDX, ID_CATEGORY_SLIDER_LEVEL, m_nCategoryLevel);
	DDX_Slider(pDX, ID_MODULE_SLIDER_LEVEL, m_nModuleLevel);
	DDX_Slider(pDX, ID_PROCESS_SLIDER_LEVEL, m_nProcessLevel);
	DDX_Control(pDX, ID_TRACE_TREE, m_tree);
	DDX_Radio(pDX, ID_MODULE_RADIO_INHERIT, m_iModuleStatus);
	DDX_Radio(pDX, ID_CATEGORY_RADIO_INHERIT, m_iCategoryStatus);
	DDX_Control(pDX, ID_PROCESS_SLIDER_LEVEL, m_sliderProcessLevel);
	DDX_Control(pDX, ID_MODULE_SLIDER_LEVEL, m_sliderModuleLevel);
	DDX_Control(pDX, ID_CATEGORY_SLIDER_LEVEL, m_sliderCategoryLevel);

	CDialog::DoDataExchange(pDX);
}

static ATLTRACESTATUS IntToStatus( int iStatus ) throw()
{
	switch( iStatus )
	{
	case 0:
		return( ATLTRACESTATUS_INHERIT );
		break;

	case 1:
		return( ATLTRACESTATUS_ENABLED );
		break;

	case 2:
		return( ATLTRACESTATUS_DISABLED );
		break;

	default:
		ASSERT( false );
		__assume( 0 );
		break;
	}
}

static int StatusToInt( ATLTRACESTATUS eStatus ) throw()
{
	switch( eStatus )
	{
	case ATLTRACESTATUS_INHERIT:
		return( 0 );
		break;

	case ATLTRACESTATUS_ENABLED:
		return( 1 );
		break;

	case ATLTRACESTATUS_DISABLED:
		return( 2 );
		break;

	default:
		ASSERT( false );
		__assume( 0 );
		break;
	}
}

BEGIN_MESSAGE_MAP(CTraceToolDlg, CDialog)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
	ON_NOTIFY(TVN_SELCHANGED, ID_TRACE_TREE, OnSelchangedTraceTree)
	ON_BN_CLICKED(ID_APPLY, OnClickedApply)
	ON_BN_CLICKED(ID_CLOSE, OnClickedClose)
	ON_BN_CLICKED(ID_CATEGORY_RADIO_DISABLED, OnCategoryChanged)
	ON_BN_CLICKED(ID_CATEGORY_RADIO_ENABLED, OnCategoryChanged)
	ON_BN_CLICKED(ID_CATEGORY_RADIO_INHERIT, OnCategoryChanged)
	ON_BN_CLICKED(ID_MODULE_RADIO_DISABLED, OnModuleChanged)
	ON_BN_CLICKED(ID_MODULE_RADIO_ENABLED, OnModuleChanged)
	ON_BN_CLICKED(ID_MODULE_RADIO_INHERIT, OnModuleChanged)
	ON_BN_CLICKED(ID_PROCESS_CHECKBOX_ENABLED, OnProcessChanged)
	ON_BN_CLICKED(ID_PROCESS_CHECKBOX_FUNCANDCATNAMES, OnProcessChanged)
	ON_BN_CLICKED(ID_PROCESS_CHECKBOX_FILENAMEANDLINENO, OnProcessChanged)
	ON_BN_CLICKED(ID_SAVE, OnBnClickedSave)
	ON_BN_CLICKED(ID_REFRESH, OnBnClickedRefresh)
	ON_BN_CLICKED(ID_LOAD, OnBnClickedLoad)
	ON_WM_HSCROLL()
END_MESSAGE_MAP()


// CTraceToolDlg message handlers

BOOL CTraceToolDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Add "About..." menu item to system menu.

	// IDM_ABOUTBOX must be in the system command range.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon

	m_sliderProcessLevel.SetRange( 0, 4 );
	m_sliderModuleLevel.SetRange( 0, 4 );
	m_sliderCategoryLevel.SetRange( 0, 4 );

	m_hShutdownEvent.Create( NULL, TRUE, FALSE, NULL );

	PopulateTree();

	m_hNotifyThread.Attach( ::CreateThread( NULL, 0, NotifyThread, this, 0, NULL ) );

	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CTraceToolDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CTraceToolDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CTraceToolDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

static void GetProcessIds( CArray< DWORD >& aid );

DWORD CTraceToolDlg::NotifyThread( void* pContext )
{
	CTraceToolDlg* pThis = static_cast< CTraceToolDlg* >( pContext );

	bool bDone = false;
	while( !bDone )
	{
		HANDLE ahProcesses[32];
		ahProcesses[0] = pThis->m_hShutdownEvent;
		ahProcesses[1] = theApp.m_hSingleInstanceEvent;
		for( UINT iProcess = 0; iProcess < pThis->m_ahProcesses.GetCount(); iProcess++ )
		{
			ahProcesses[iProcess+2] = pThis->m_ahProcesses[iProcess];
		}

		DWORD dwResult = ::WaitForMultipleObjects( ULONG( pThis->m_ahProcesses.GetCount()+2 ), &ahProcesses[0], FALSE, INFINITE );
		if( dwResult == WAIT_OBJECT_0 )
		{
			bDone = true;
		}
		else if( dwResult == (WAIT_OBJECT_0+1) )
		{
			pThis->SetForegroundWindow();
		}
	}

	return( 0 );
}

void CTraceToolDlg::PopulateTree()
{
	CArray< DWORD > aidProcesses;

	GetProcessIds( aidProcesses );

	for( int iProcess = 0; iProcess < aidProcesses.GetSize(); iProcess++ )
	{
		DWORD idProcess = aidProcesses[iProcess];

		DWORD_PTR dwProcess = AtlTraceOpenProcess( idProcess );
		if( dwProcess != 0 )
		{
			AtlTraceSnapshotProcess( dwProcess );

			ATLTRACEPROCESSINFO info;
			AtlTraceGetProcessInfo( dwProcess, &info );
			
			const int MAX_TEXT_SIZE = 256;
			TCHAR szText[MAX_TEXT_SIZE];
			USES_CONVERSION_EX;
							
			CW2T pszName(info.szName);
			LPTSTR lpszName = pszName;
			_sntprintf_s(szText, MAX_TEXT_SIZE, _TRUNCATE, _T( "%s:0x%08x" ), lpszName, idProcess );
			szText[MAX_TEXT_SIZE - 1] = 0;
			

			HTREEITEM hProcessItem = m_tree.InsertItem( szText );

			PROCESSSETTINGS *pPS = NULL;
			pPS = new PROCESSSETTINGS;			
			pPS->bModified = FALSE;
			pPS->dwProcess = dwProcess;
			pPS->ps.nLevel = info.settings.nLevel;
			pPS->ps.bEnabled = info.settings.bEnabled;
			pPS->ps.bFuncAndCategoryNames = info.settings.bFuncAndCategoryNames;
			pPS->ps.bFileNameAndLineNo = info.settings.bFileNameAndLineNo;
			m_tree.SetItemData( hProcessItem, reinterpret_cast<DWORD_PTR>(pPS) );

			for( int iModule = 0; iModule < info.nModules; iModule++ )
			{
				ATLTRACEMODULEINFO module;
				AtlTraceGetModuleInfo( dwProcess, iModule, &module );

				CW2T pszModuleName(module.szName);
				LPTSTR lpszModuleName = pszModuleName; 
#ifndef _UNICODE
				if(lpszModuleName == NULL)
					lpszModuleName = _T("");
#endif
				HTREEITEM hModuleItem = m_tree.InsertItem( lpszModuleName, hProcessItem );
				DWORD_PTR dwModule = module.dwModule;

				TRACESETTINGS *pTS = NULL;
				pTS = new TRACESETTINGS;
				ENSURE(pTS); /* prefast noise */
				pTS->bModified = FALSE;
				pTS->dwHandle = dwModule;
				pTS->ts.nLevel = module.settings.nLevel;
				pTS->ts.eStatus = module.settings.eStatus;
				m_tree.SetItemData( hModuleItem, reinterpret_cast<DWORD_PTR>(pTS) );

				for( int iCategory = 0; iCategory < module.nCategories; iCategory++ )
				{
					ATLTRACECATEGORYINFO category;
					AtlTraceGetCategoryInfo( dwProcess, dwModule, iCategory, &category );
					DWORD_PTR dwCategory = category.dwCategory;
					
					CW2T pszCategoryName(category.szName);
					LPTSTR lpszCategoryName = pszCategoryName;
#ifndef _UNICODE
					if(lpszCategoryName == NULL)
						lpszCategoryName = _T("");
#endif
					HTREEITEM hCategoryItem = m_tree.InsertItem( lpszCategoryName, hModuleItem );

					TRACESETTINGS *pTS2 = NULL;
					pTS2 = new TRACESETTINGS;
					ENSURE(pTS2); /* prefast noise */
					pTS2->bModified = FALSE;
					pTS2->dwHandle = dwCategory;
					pTS2->ts.nLevel = category.settings.nLevel;
					pTS2->ts.eStatus = category.settings.eStatus;
					m_tree.SetItemData( hCategoryItem, reinterpret_cast<DWORD_PTR>(pTS2) );
				}
			}
		}
	}
}

void CTraceToolDlg::UpdateControls()
{
	GetDlgItem( ID_APPLY )->EnableWindow( m_bDirty );
	GetDlgItem( ID_MODULE_RADIO_INHERIT )->EnableWindow( m_pTSModule != NULL );
	GetDlgItem( ID_MODULE_RADIO_ENABLED )->EnableWindow( m_pTSModule != NULL );
	GetDlgItem( ID_MODULE_RADIO_DISABLED )->EnableWindow( m_pTSModule != NULL );
	GetDlgItem( ID_MODULE_GROUPBOX )->EnableWindow( m_pTSModule != NULL );
	GetDlgItem( ID_MODULE_SLIDER_LEVEL )->EnableWindow( (m_pTSModule != NULL) && (m_iModuleStatus == 1)  );
	GetDlgItem( ID_MODULE_STATIC1 )->EnableWindow( (m_pTSModule != NULL) && (m_iModuleStatus == 1)  );
	GetDlgItem( ID_MODULE_STATIC2 )->EnableWindow( (m_pTSModule != NULL) && (m_iModuleStatus == 1)  );
	GetDlgItem( ID_MODULE_STATIC3 )->EnableWindow( (m_pTSModule != NULL) && (m_iModuleStatus == 1)  );
	GetDlgItem( ID_CATEGORY_RADIO_INHERIT )->EnableWindow( m_pTSCategory != NULL );
	GetDlgItem( ID_CATEGORY_RADIO_ENABLED )->EnableWindow( m_pTSCategory != NULL );
	GetDlgItem( ID_CATEGORY_RADIO_DISABLED )->EnableWindow( m_pTSCategory != NULL );
	GetDlgItem( ID_CATEGORY_GROUPBOX )->EnableWindow( m_pTSCategory != NULL );
	GetDlgItem( ID_CATEGORY_SLIDER_LEVEL )->EnableWindow( (m_pTSCategory != NULL) && (m_iCategoryStatus == 1) );
	GetDlgItem( ID_CATEGORY_STATIC1 )->EnableWindow( (m_pTSCategory != NULL) && (m_iCategoryStatus == 1) );
	GetDlgItem( ID_CATEGORY_STATIC2 )->EnableWindow( (m_pTSCategory != NULL) && (m_iCategoryStatus == 1) );
	GetDlgItem( ID_CATEGORY_STATIC3 )->EnableWindow( (m_pTSCategory != NULL) && (m_iCategoryStatus == 1) );
}

void CTraceToolDlg::OnSelchangedTraceTree(NMHDR *pNMHDR, LRESULT *pResult)
{
	if (m_bDeleting)
		return;

	NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
	*pResult = 0;

	UpdateSelectedItem(pNMTreeView->itemNew.hItem);
}

void CTraceToolDlg::OnClickedApply(void)
{
	for( HTREEITEM hProcess = m_tree.GetChildItem( TVI_ROOT ); hProcess != NULL; hProcess = m_tree.GetNextSiblingItem( hProcess ) )
	{
		PROCESSSETTINGS *pPS = reinterpret_cast<PROCESSSETTINGS*>(m_tree.GetItemData( hProcess ));	
		if (pPS->bModified == FALSE)
			continue;

		AtlTraceModifyProcess( pPS->dwProcess, pPS->ps.nLevel, pPS->ps.bEnabled, pPS->ps.bFuncAndCategoryNames, pPS->ps.bFileNameAndLineNo );
		pPS->bModified = FALSE;

		for (HTREEITEM hModule = m_tree.GetChildItem( hProcess ); hModule != NULL; hModule = m_tree.GetNextSiblingItem( hModule ) )
		{
			TRACESETTINGS *pTSModule = reinterpret_cast<TRACESETTINGS*>(m_tree.GetItemData( hModule ));
			if (pTSModule->bModified == FALSE)
				continue;

			AtlTraceModifyModule( pPS->dwProcess, pTSModule->dwHandle, pTSModule->ts.nLevel, pTSModule->ts.eStatus );
			pTSModule->bModified = FALSE;

			for (HTREEITEM hCategory = m_tree.GetChildItem( hModule ); hCategory != NULL; hCategory = m_tree.GetNextSiblingItem( hCategory ) )
			{
				TRACESETTINGS *pTSCategory = reinterpret_cast<TRACESETTINGS*>(m_tree.GetItemData( hCategory ));
				if (pTSCategory->bModified == TRUE)
				{
					AtlTraceModifyCategory( pPS->dwProcess, pTSCategory->dwHandle, pTSCategory->ts.nLevel, pTSCategory->ts.eStatus );
					pTSCategory->bModified = FALSE;
				}
			}
		}
	}
	m_bDirty = FALSE;
	UpdateControls();
}

void CTraceToolDlg::OnClickedClose(void)
{
	OnCancel();
}

void CTraceToolDlg::OnDestroy()
{
	Cleanup();

	if( m_hNotifyThread != NULL )
	{
		m_hShutdownEvent.Set();
		::WaitForSingleObject( m_hNotifyThread, INFINITE );
		m_hShutdownEvent.Close();
		m_hNotifyThread.Close();
	}

	CDialog::OnDestroy();
}