2359 lines
65 KiB
C++
2359 lines
65 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (c) 2002 Microsoft Corporation. All rights reserved.
|
|
// Copyright (c) 2002 OSR Open Systems Resources, Inc.
|
|
//
|
|
// MainFrm.cpp : implementation of the CMainFrame class
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h"
|
|
#include <tchar.h>
|
|
#include <wmistr.h>
|
|
#include <initguid.h>
|
|
extern "C" {
|
|
#include <evntrace.h>
|
|
}
|
|
#include <traceprt.h>
|
|
#include "TraceView.h"
|
|
#include "LogSession.h"
|
|
#include "DisplayDlg.h"
|
|
#include "ProviderFormatInfo.h"
|
|
#include "ProviderFormatSelectionDlg.h"
|
|
#include "ListCtrlEx.h"
|
|
#include "LogSessionDlg.h"
|
|
#include "LogDisplayOptionDlg.h"
|
|
#include "LogSessionInformationDlg.h"
|
|
#include "ProviderSetupDlg.h"
|
|
#include "LogSessionPropSht.h"
|
|
#include "LogSessionOutputOptionDlg.h"
|
|
#include "DockDialogBar.h"
|
|
#include "LogFileDlg.h"
|
|
#include "Utils.h"
|
|
#include "MainFrm.h"
|
|
#include "ProviderControlGUIDDlg.h"
|
|
#include "MaxTraceDlg.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#endif
|
|
|
|
extern LONG MaxTraceEntries;
|
|
|
|
typedef struct _GROUP_SESSION_PARAMS {
|
|
CPtrArray *pGroupArray;
|
|
CPtrArray *pSessionArray;
|
|
HANDLE SessionDoneEventArray[MAX_LOG_SESSIONS];
|
|
} GROUP_SESSION_PARAMS, *PGROUP_SESSION_PARAMS;
|
|
|
|
// CGroupSession
|
|
|
|
IMPLEMENT_DYNCREATE(CGroupSession, CWinThread)
|
|
|
|
BEGIN_MESSAGE_MAP(CGroupSession, CWinThread)
|
|
ON_MESSAGE(WM_USER_START_GROUP, OnGroupSession)
|
|
ON_MESSAGE(WM_USER_START_UNGROUP, OnUnGroupSession)
|
|
END_MESSAGE_MAP()
|
|
|
|
BOOL CGroupSession::InitInstance()
|
|
{
|
|
//
|
|
// Create the event handles
|
|
//
|
|
for(LONG ii = 0; ii < MAX_LOG_SESSIONS; ii++) {
|
|
m_hEventArray[ii] = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int CGroupSession::ExitInstance()
|
|
{
|
|
//
|
|
// Release the handles
|
|
//
|
|
for(LONG ii = 0; ii < MAX_LOG_SESSIONS; ii++) {
|
|
CloseHandle(m_hEventArray[ii]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CGroupSession::OnGroupSession(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
PGROUP_SESSION_PARAMS pSessionParams = (PGROUP_SESSION_PARAMS)wParam;
|
|
CDisplayDlg *pDisplayDlg = NULL;
|
|
CString str;
|
|
LONG numberOfEvents = (LONG)pSessionParams->pGroupArray->GetSize();
|
|
|
|
//
|
|
// Wait on all sessions to end
|
|
//
|
|
DWORD status = WaitForMultipleObjects(numberOfEvents,
|
|
pSessionParams->SessionDoneEventArray,
|
|
TRUE,
|
|
INFINITE);
|
|
|
|
for(LONG ii = (LONG)pSessionParams->pGroupArray->GetSize() - 1; ii >= 0 ; ii--) {
|
|
pDisplayDlg = (CDisplayDlg *)pSessionParams->pGroupArray->GetAt(ii);
|
|
|
|
if(pDisplayDlg == NULL) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// If the group has only one member, we don't need to save it, it
|
|
// won't get restarted
|
|
//
|
|
if(pDisplayDlg->m_sessionArray.GetSize() <= 1) {
|
|
pSessionParams->pGroupArray->RemoveAt(ii);
|
|
}
|
|
|
|
}
|
|
|
|
::PostMessage(m_hMainWnd, WM_USER_COMPLETE_GROUP, (WPARAM)pSessionParams, 0);
|
|
}
|
|
|
|
void CGroupSession::OnUnGroupSession(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
PGROUP_SESSION_PARAMS pSessionParams = (PGROUP_SESSION_PARAMS)wParam;
|
|
CLogSession *pLogSession;
|
|
BOOL bWasActive = FALSE;
|
|
CString str;
|
|
CDisplayDlg *pDisplayDlg;
|
|
LONG numberOfEvents = (LONG)pSessionParams->pGroupArray->GetSize();
|
|
|
|
//
|
|
// Wait on all sessions to end
|
|
//
|
|
DWORD status = WaitForMultipleObjects(numberOfEvents,
|
|
pSessionParams->SessionDoneEventArray,
|
|
TRUE,
|
|
INFINITE);
|
|
|
|
::PostMessage(m_hMainWnd, WM_USER_COMPLETE_UNGROUP, (WPARAM)pSessionParams, 0);
|
|
}
|
|
|
|
// CMainFrame
|
|
|
|
IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd)
|
|
|
|
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
|
|
ON_MESSAGE(WM_USER_UPDATE_LOGSESSION_LIST, OnUpdateLogSessionList)
|
|
ON_MESSAGE(WM_USER_COMPLETE_GROUP, OnCompleteGroup)
|
|
ON_MESSAGE(WM_USER_COMPLETE_UNGROUP, OnCompleteUnGroup)
|
|
ON_WM_CREATE()
|
|
ON_WM_SETFOCUS()
|
|
ON_COMMAND(ID_FILE_NEWLOGSESSION, OnFileNewLogSession)
|
|
ON_COMMAND(ID_CREATENEWLOGSESSION, OnCreateNewLogSession)
|
|
ON_COMMAND(ID_SET_TMAX, OnSetTmax)
|
|
ON_COMMAND(ID_PROPERTIES, OnProperties)
|
|
ON_UPDATE_COMMAND_UI(ID_PROPERTIES, OnUpdateProperties)
|
|
ON_COMMAND(ID_START_TRACE_BUTTON, OnStartTrace)
|
|
ON_COMMAND(ID__STARTTRACE, OnStartTrace)
|
|
ON_COMMAND(ID_STOP_TRACE_BUTTON, OnStopTrace)
|
|
ON_COMMAND(ID__STOPTRACE, OnStopTrace)
|
|
#if 0
|
|
ON_UPDATE_COMMAND_UI(ID_START_TRACE_BUTTON, OnUpdateStartTraceButton)
|
|
ON_UPDATE_COMMAND_UI(ID_STOP_TRACE_BUTTON, OnUpdateStopTraceButton)
|
|
ON_UPDATE_COMMAND_UI(ID_VIEW_TRACETOOLBAR, OnUpdateViewTraceToolBar)
|
|
ON_COMMAND(ID_VIEW_TRACETOOLBAR, OnViewTraceToolBar)
|
|
#endif
|
|
|
|
ON_COMMAND(ID_GROUPSESSIONS, OnGroupSessions)
|
|
ON_COMMAND(ID_UNGROUPSESSIONS, OnUngroupSessions)
|
|
ON_COMMAND(ID_REMOVETRACE, OnRemoveLogSession)
|
|
ON_UPDATE_COMMAND_UI(ID_GROUPSESSIONS, OnUpdateUIGroupSessions)
|
|
ON_UPDATE_COMMAND_UI(ID_UNGROUPSESSIONS, OnUpdateUngroupSessions)
|
|
ON_UPDATE_COMMAND_UI(ID__STARTTRACE, OnUpdateUIStartTrace)
|
|
ON_UPDATE_COMMAND_UI(ID__STOPTRACE, OnUpdateUIStopTrace)
|
|
ON_UPDATE_COMMAND_UI(147, OnUpdateUIOpenExisting)
|
|
ON_COMMAND(ID__OPENEXISTINGLOGFILE, OnOpenExisting)
|
|
ON_COMMAND(ID_FILE_OPENEXISTINGLOGFILE, OnOpenExisting)
|
|
ON_COMMAND(ID__FLAGS, OnFlagsColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__FLAGS, OnUpdateFlagsColumnDisplay)
|
|
ON_COMMAND(ID__FLUSHTIME, OnFlushTimeColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__FLUSHTIME, OnUpdateFlushTimeColumnDisplayCheck)
|
|
ON_COMMAND(ID__MAXBUFFERS, OnMaxBuffersColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__MAXBUFFERS, OnUpdateMaxBuffersColumnDisplayCheck)
|
|
ON_COMMAND(ID__MINBUFFERS, OnMinBuffersColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__MINBUFFERS, OnUpdateMinBuffersColumnDisplayCheck)
|
|
ON_COMMAND(ID__BUFFERSIZE, OnBufferSizeColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__BUFFERSIZE, OnUpdateBufferSizeColumnDisplayCheck)
|
|
ON_COMMAND(ID__AGE, OnDecayTimeColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__AGE, OnUpdateDecayTimeColumnDisplayCheck)
|
|
ON_COMMAND(ID__CIRCULAR, OnCircularColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__CIRCULAR, OnUpdateCircularColumnDisplayCheck)
|
|
ON_COMMAND(ID__SEQUENTIAL, OnSequentialColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__SEQUENTIAL, OnUpdateSequentialColumnDisplayCheck)
|
|
ON_COMMAND(ID__NEWFILE, OnNewFileColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__NEWFILE, OnUpdateNewFileColumnDisplayCheck)
|
|
ON_COMMAND(ID__GLOBALSEQUENCE, OnGlobalSeqColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__GLOBALSEQUENCE, OnUpdateGlobalSeqColumnDisplayCheck)
|
|
ON_COMMAND(ID__LOCALSEQUENCE, OnLocalSeqColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__LOCALSEQUENCE, OnUpdateLocalSeqColumnDisplayCheck)
|
|
ON_COMMAND(ID__LEVEL, OnLevelColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__LEVEL, OnUpdateLevelColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID_REMOVETRACE, OnUpdateRemoveTrace)
|
|
ON_COMMAND(ID__STATE, OnStateColumnDisplayCheck)
|
|
ON_COMMAND(ID__EVENTCOUNT, OnEventCountColumnDisplayCheck)
|
|
ON_COMMAND(ID__LOSTEVENTS, OnLostEventsColumnDisplayCheck)
|
|
ON_COMMAND(ID__BUFFERSREAD, OnBuffersReadColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__STATE, OnUpdateStateColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__EVENTCOUNT, OnUpdateEventCountColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__LOSTEVENTS, OnUpdateLostEventsColumnDisplayCheck)
|
|
ON_UPDATE_COMMAND_UI(ID__BUFFERSREAD, OnUpdateBuffersReadColumnDisplayCheck)
|
|
ON_COMMAND(ID__LOGSESSIONDISPLAYOPTIONS, OnLogSessionDisplayOptions)
|
|
ON_COMMAND(ID__CHANGETEXTCOLOR, OnChangeTextColor)
|
|
ON_COMMAND(ID__CHANGEBACKGROUNDCOLOR, OnChangeBackgroundColor)
|
|
ON_UPDATE_COMMAND_UI(ID__CHANGETEXTCOLOR, OnUpdateChangeTextColor)
|
|
ON_UPDATE_COMMAND_UI(ID__CHANGEBACKGROUNDCOLOR, OnUpdateChangeBackgroundColor)
|
|
ON_UPDATE_COMMAND_UI(ID_SET_TMAX, OnUpdateSetTmax)
|
|
END_MESSAGE_MAP()
|
|
|
|
static UINT indicators[] =
|
|
{
|
|
ID_SEPARATOR, // status line indicator
|
|
ID_INDICATOR_CAPS,
|
|
ID_INDICATOR_NUM,
|
|
ID_INDICATOR_SCRL,
|
|
};
|
|
|
|
|
|
// CMainFrame construction/destruction
|
|
|
|
CMainFrame::CMainFrame()
|
|
{
|
|
m_hEndTraceEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
}
|
|
|
|
CMainFrame::~CMainFrame()
|
|
{
|
|
delete []m_pGroupSessionsThread;
|
|
}
|
|
|
|
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
|
|
{
|
|
DWORD extendedStyles;
|
|
CString str;
|
|
RECT rc;
|
|
int height;
|
|
HMODULE hTestHandle;
|
|
|
|
|
|
if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
|
|
return -1;
|
|
|
|
//
|
|
// Make sure that the msvcr70.dll is available, and if not error out
|
|
//
|
|
hTestHandle = LoadLibraryEx(_T("msvcr70.dll"), NULL, 0);
|
|
|
|
if(hTestHandle == NULL) {
|
|
AfxMessageBox(_T("MISSING NECESSARY DLL: MSVCR70.DLL"));
|
|
return -1;
|
|
}
|
|
|
|
FreeLibrary(hTestHandle);
|
|
|
|
//
|
|
// Make sure that the msvcr70.dll is available, and if not error out
|
|
//
|
|
hTestHandle = LoadLibraryEx(_T("mspdb70.dll"), NULL, 0);
|
|
|
|
if(hTestHandle == NULL) {
|
|
AfxMessageBox(_T("MISSING NECESSARY DLL: MSPDB70.DLL"));
|
|
return -1;
|
|
}
|
|
|
|
FreeLibrary(hTestHandle);
|
|
|
|
//
|
|
// Spawn a thread to handle grouping and ungrouping sessions
|
|
//
|
|
m_pGroupSessionsThread = (CGroupSession *)AfxBeginThread(RUNTIME_CLASS(CGroupSession));
|
|
|
|
m_pGroupSessionsThread->m_hMainWnd = GetSafeHwnd();
|
|
|
|
//
|
|
// create a view to occupy the client area of the frame
|
|
//
|
|
|
|
if (!m_wndView.Create(NULL, NULL, AFX_WS_DEFAULT_VIEW,
|
|
CRect(0, 0, 0, 0), this, AFX_IDW_PANE_FIRST, NULL))
|
|
{
|
|
TRACE(_T("Failed to create view window\n"));
|
|
return -1;
|
|
}
|
|
|
|
#if 0
|
|
if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
|
|
| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
|
|
!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
|
|
{
|
|
TRACE(_T("Failed to create toolbar\n"));
|
|
//
|
|
// fail to create
|
|
//
|
|
return -1;
|
|
}
|
|
|
|
if (!m_wndTraceToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
|
|
| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
|
|
!m_wndTraceToolBar.LoadToolBar(IDR_TRACE_TOOLBAR))
|
|
{
|
|
TRACE(_T("Failed to create toolbar\n"));
|
|
//
|
|
// fail to create
|
|
//
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
if (!m_wndStatusBar.Create(this) ||
|
|
!m_wndStatusBar.SetIndicators(indicators,
|
|
sizeof(indicators)/sizeof(UINT)))
|
|
{
|
|
TRACE(_T("Failed to create status bar\n"));
|
|
//
|
|
// fail to create
|
|
//
|
|
return -1;
|
|
}
|
|
|
|
#if 0
|
|
//
|
|
// toolbars are dockable
|
|
//
|
|
m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
|
|
EnableDocking(CBRS_ALIGN_ANY);
|
|
DockControlBar(&m_wndToolBar);
|
|
|
|
m_wndTraceToolBar.EnableDocking(CBRS_ALIGN_ANY);
|
|
EnableDocking(CBRS_ALIGN_ANY);
|
|
DockControlBarLeftOf(&m_wndTraceToolBar, &m_wndToolBar);
|
|
#endif
|
|
|
|
EnableDocking(CBRS_ALIGN_ANY);
|
|
|
|
str.Format(_T("Log Session List"));
|
|
|
|
//
|
|
// create our dockable dialog bar with list control
|
|
// We always create one, which is our log session list display
|
|
//
|
|
if (!m_wndLogSessionListBar.Create(this, &m_logSessionDlg, str, IDD_DISPLAY_DIALOG,
|
|
WS_CHILD|WS_VISIBLE|CBRS_TOP|CBRS_TOOLTIPS|CBRS_SIZE_DYNAMIC))
|
|
{
|
|
TRACE(_T("Failed to create log session list DockDialogBar\n"));
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// make the dialog dockable and dock it to the bottom originally.
|
|
//
|
|
m_wndLogSessionListBar.EnableDocking(CBRS_ALIGN_TOP);
|
|
|
|
//
|
|
//EnableDocking(CBRS_ALIGN_ANY);
|
|
//
|
|
DockControlBar(&m_wndLogSessionListBar, AFX_IDW_DOCKBAR_TOP);
|
|
|
|
//
|
|
// Go ahead and create the first column header
|
|
//
|
|
str.Format(_T("Group ID / Session Name"));
|
|
|
|
m_logSessionDlg.m_displayCtrl.InsertColumn(0,
|
|
str,
|
|
LVCFMT_LEFT,
|
|
180);
|
|
|
|
//
|
|
// set our preferred extended styles
|
|
//
|
|
extendedStyles = LVS_EX_GRIDLINES |
|
|
LVS_EX_HEADERDRAGDROP |
|
|
LVS_EX_FULLROWSELECT;
|
|
|
|
//
|
|
// Set the extended styles for the list control
|
|
//
|
|
m_logSessionDlg.m_displayCtrl.SetExtendedStyle(extendedStyles);
|
|
|
|
//
|
|
// resize our main window
|
|
//
|
|
GetWindowRect(&rc);
|
|
|
|
height = rc.bottom - rc.top;
|
|
|
|
GetClientRect(&rc);
|
|
|
|
height -= rc.bottom - rc.top;
|
|
|
|
#if 0
|
|
m_wndToolBar.GetWindowRect(&rc);
|
|
|
|
height += rc.bottom - rc.top;
|
|
#endif
|
|
|
|
m_logSessionDlg.m_displayCtrl.GetWindowRect(&rc);
|
|
|
|
height += rc.bottom - rc.top + 432;
|
|
|
|
GetWindowRect(&rc);
|
|
|
|
SetWindowPos(&wndBottom, 0, 0, rc.right - rc.left + 76, height, SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_SHOWWINDOW);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CMainFrame::DockControlBarLeftOf(CToolBar* Bar, CToolBar* LeftOf)
|
|
{
|
|
CRect rect;
|
|
DWORD dw;
|
|
UINT n;
|
|
|
|
//
|
|
// get MFC to adjust the dimensions of all docked ToolBars
|
|
// so that GetWindowRect will be accurate
|
|
//
|
|
RecalcLayout(TRUE);
|
|
|
|
LeftOf->GetWindowRect(&rect);
|
|
rect.OffsetRect(1,0);
|
|
dw=LeftOf->GetBarStyle();
|
|
n = 0;
|
|
n = (dw&CBRS_ALIGN_TOP) ? AFX_IDW_DOCKBAR_TOP : n;
|
|
n = (dw&CBRS_ALIGN_BOTTOM && n==0) ? AFX_IDW_DOCKBAR_BOTTOM : n;
|
|
n = (dw&CBRS_ALIGN_LEFT && n==0) ? AFX_IDW_DOCKBAR_LEFT : n;
|
|
n = (dw&CBRS_ALIGN_RIGHT && n==0) ? AFX_IDW_DOCKBAR_RIGHT : n;
|
|
|
|
//
|
|
// When we take the default parameters on rect, DockControlBar will dock
|
|
// each Toolbar on a seperate line. By calculating a rectangle, we
|
|
// are simulating a Toolbar being dragged to that location and docked.
|
|
//
|
|
DockControlBar(Bar,n,&rect);
|
|
|
|
RecalcLayout(TRUE);
|
|
}
|
|
|
|
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
|
|
{
|
|
if( !CFrameWnd::PreCreateWindow(cs) )
|
|
return FALSE;
|
|
|
|
cs.dwExStyle &= ~WS_EX_CLIENTEDGE;
|
|
cs.lpszClass = AfxRegisterWndClass(0);
|
|
return TRUE;
|
|
}
|
|
|
|
// CMainFrame diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CMainFrame::AssertValid() const
|
|
{
|
|
CFrameWnd::AssertValid();
|
|
}
|
|
|
|
void CMainFrame::Dump(CDumpContext& dc) const
|
|
{
|
|
CFrameWnd::Dump(dc);
|
|
}
|
|
|
|
#endif //_DEBUG
|
|
|
|
|
|
// CMainFrame message handlers
|
|
|
|
void CMainFrame::OnSetFocus(CWnd* /*pOldWnd*/)
|
|
{
|
|
// forward focus to the view window
|
|
//m_wndView.SetFocus();
|
|
}
|
|
|
|
BOOL CMainFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
|
|
{
|
|
//
|
|
//
|
|
//
|
|
return CFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
|
|
}
|
|
|
|
void CMainFrame::OnFileNewLogSession()
|
|
{
|
|
AddModifyLogSession();
|
|
}
|
|
|
|
void CMainFrame::OnCreateNewLogSession()
|
|
{
|
|
AddModifyLogSession();
|
|
}
|
|
|
|
void CMainFrame::AddModifyLogSession(CLogSession *pLogSession)
|
|
{
|
|
BOOL bAddingSession = FALSE;
|
|
CString str;
|
|
DWORD extendedStyles;
|
|
INT_PTR retVal;
|
|
CLogSession *pLog;
|
|
BOOL bNoID = FALSE;
|
|
LONG logSessionID = 0;
|
|
CDisplayDlg *pDisplayDlg;
|
|
|
|
//
|
|
// if this is a new session, create the instance
|
|
//
|
|
if(NULL == pLogSession) {
|
|
//
|
|
// Get a unique log session ID
|
|
//
|
|
logSessionID = m_logSessionDlg.GetLogSessionID();
|
|
|
|
pLogSession = new CLogSession(logSessionID, &m_logSessionDlg);
|
|
if(NULL == pLogSession) {
|
|
AfxMessageBox(_T("Unable To Create Log Session"));
|
|
return;
|
|
}
|
|
|
|
bAddingSession = TRUE;
|
|
}
|
|
|
|
//
|
|
// pop-up our wizard/tab dialog to show/get properties
|
|
//
|
|
CLogSessionPropSht *pLogSessionPropertySheet =
|
|
new CLogSessionPropSht(this, pLogSession);
|
|
|
|
if(NULL == pLogSessionPropertySheet) {
|
|
if(bAddingSession) {
|
|
AfxMessageBox(_T("Failed To Create Log Session, Resource Error"));
|
|
|
|
m_logSessionDlg.ReleaseLogSessionID(pLogSession);
|
|
delete pLogSession;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if(bAddingSession) {
|
|
pLogSessionPropertySheet->SetWizardMode();
|
|
}
|
|
|
|
retVal = pLogSessionPropertySheet->DoModal();
|
|
|
|
if(IDOK != retVal) {
|
|
if(bAddingSession) {
|
|
if(IDCANCEL != retVal) {
|
|
AfxMessageBox(_T("Failed To Get Log Session Properties"));
|
|
}
|
|
m_logSessionDlg.ReleaseLogSessionID(pLogSession);
|
|
delete pLogSession;
|
|
}
|
|
delete pLogSessionPropertySheet;
|
|
|
|
return;
|
|
}
|
|
|
|
if(!pLogSession->m_bTraceActive) {
|
|
|
|
if(bAddingSession) {
|
|
//
|
|
// Check that we have at least one provider
|
|
//
|
|
if(0 == pLogSession->m_traceSessionArray.GetSize()) {
|
|
AfxMessageBox(_T("No Providers Registered\nLog Session Initialization Failed"));
|
|
m_logSessionDlg.ReleaseLogSessionID(pLogSession);
|
|
delete pLogSession;
|
|
delete pLogSessionPropertySheet;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Add the session to the list of log sessions
|
|
//
|
|
m_logSessionDlg.AddSession(pLogSession);
|
|
|
|
//
|
|
// Get the display window for the log session
|
|
//
|
|
pDisplayDlg = pLogSession->GetDisplayWnd();
|
|
|
|
ASSERT(pDisplayDlg != NULL);
|
|
|
|
//
|
|
// Set the output file info for the display dialog
|
|
//
|
|
pDisplayDlg->m_bWriteListingFile =
|
|
pLogSessionPropertySheet->m_bWriteListingFile;
|
|
|
|
if(pDisplayDlg->m_bWriteListingFile) {
|
|
pDisplayDlg->m_listingFileName =
|
|
pLogSessionPropertySheet->m_listingFileName;
|
|
}
|
|
|
|
pDisplayDlg->m_bWriteSummaryFile =
|
|
pLogSessionPropertySheet->m_bWriteSummaryFile;
|
|
|
|
if(pDisplayDlg->m_bWriteSummaryFile) {
|
|
pDisplayDlg->m_summaryFileName =
|
|
pLogSessionPropertySheet->m_summaryFileName;
|
|
}
|
|
|
|
//
|
|
// Start the log session tracing
|
|
//
|
|
pDisplayDlg->BeginTrace();
|
|
|
|
//
|
|
// Force a redraw of the list control
|
|
//
|
|
m_logSessionDlg.m_displayCtrl.RedrawItems(
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex(),
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex() +
|
|
m_logSessionDlg.m_displayCtrl.GetCountPerPage());
|
|
|
|
m_logSessionDlg.m_displayCtrl.UpdateWindow();
|
|
|
|
} else {
|
|
m_logSessionDlg.UpdateSession(pLogSession);
|
|
}
|
|
} else {
|
|
m_logSessionDlg.UpdateSession(pLogSession);
|
|
}
|
|
|
|
delete pLogSessionPropertySheet;
|
|
}
|
|
|
|
void CMainFrame::OnProperties()
|
|
{
|
|
POSITION pos;
|
|
LONG index;
|
|
CLogSession *pLogSession;
|
|
INT_PTR retVal;
|
|
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
if((index < 0) || (index >= m_logSessionDlg.m_logSessionArray.GetSize())) {
|
|
AfxMessageBox(_T("Error Log Session Not Found!"));
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
return;
|
|
}
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
if(NULL == pLogSession) {
|
|
return;
|
|
}
|
|
|
|
if(pLogSession->m_bDisplayExistingLogFileOnly) {
|
|
//
|
|
// pop-up our wizard/tab dialog to show/get properties
|
|
//
|
|
CLogFileDlg *pDialog = new CLogFileDlg(this, pLogSession);
|
|
if(NULL == pDialog) {
|
|
return;
|
|
}
|
|
|
|
retVal = pDialog->DoModal();
|
|
|
|
delete pDialog;
|
|
|
|
if(IDOK != retVal) {
|
|
if(IDCANCEL != retVal) {
|
|
AfxMessageBox(_T("Failed To Get Log File Properties"));
|
|
}
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Now update the session
|
|
//
|
|
m_logSessionDlg.UpdateSession(pLogSession);
|
|
return;
|
|
}
|
|
|
|
AddModifyLogSession(pLogSession);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateProperties(CCmdUI *pCmdUI)
|
|
{
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
|
|
|
|
//
|
|
// Taking this out altogether for now, but leaving it in
|
|
// the code in case it needs to be put back
|
|
//
|
|
pCmdUI->Enable(FALSE);
|
|
|
|
return;
|
|
|
|
//
|
|
// disable the properties option if there is more
|
|
// than one selected log session
|
|
//
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() > 1) {
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
//
|
|
// If the session is in process of stopping, don't allow the
|
|
// properties dialog to be viewed
|
|
//
|
|
if((NULL == pLogSession) ||
|
|
(pLogSession->m_bStoppingTrace)) {
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnStartTrace()
|
|
{
|
|
POSITION pos;
|
|
LONG index;
|
|
CLogSession *pLogSession;
|
|
CDisplayDlg *pDisplayDlg;
|
|
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
|
|
while(pos != NULL) {
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
if(NULL == pLogSession) {
|
|
continue;
|
|
}
|
|
|
|
pDisplayDlg = pLogSession->GetDisplayWnd();
|
|
|
|
ASSERT(pDisplayDlg != NULL);
|
|
|
|
pDisplayDlg->BeginTrace();
|
|
}
|
|
|
|
//
|
|
// Force a redraw of the list control
|
|
//
|
|
m_logSessionDlg.m_displayCtrl.RedrawItems(
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex(),
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex() +
|
|
m_logSessionDlg.m_displayCtrl.GetCountPerPage());
|
|
|
|
m_logSessionDlg.m_displayCtrl.UpdateWindow();
|
|
}
|
|
|
|
#if 0
|
|
void CMainFrame::OnUpdateStartTraceButton(CCmdUI *pCmdUI)
|
|
{
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
BOOL bFound = FALSE;
|
|
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() == 0) {
|
|
pCmdUI->Enable(FALSE);
|
|
return;
|
|
}
|
|
|
|
pCmdUI->Enable(TRUE);
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
while(pos != NULL) {
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
if(index >= m_logSessionDlg.m_logSessionArray.GetSize()) {
|
|
break;
|
|
}
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
if(pLogSession != NULL) {
|
|
bFound = TRUE;
|
|
if(pLogSession->m_bTraceActive) {
|
|
pCmdUI->Enable(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
if(!bFound) {
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateStopTraceButton(CCmdUI *pCmdUI)
|
|
{
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
|
|
pCmdUI->Enable(FALSE);
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() > 0) {
|
|
pCmdUI->Enable(TRUE);
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
while(pos != NULL) {
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
if(index >= m_logSessionDlg.m_logSessionArray.GetSize()) {
|
|
pCmdUI->Enable(FALSE);
|
|
break;
|
|
}
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
if((pLogSession == NULL) ||
|
|
(!pLogSession->m_bTraceActive) ||
|
|
(pLogSession->m_bStoppingTrace)) {
|
|
pCmdUI->Enable(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
}
|
|
|
|
void CMainFrame::OnUpdateViewTraceToolBar(CCmdUI *pCmdUI)
|
|
{
|
|
pCmdUI->SetCheck((m_wndTraceToolBar.IsWindowVisible()) != 0);
|
|
}
|
|
|
|
void CMainFrame::OnViewTraceToolBar()
|
|
{
|
|
//
|
|
// toggle visible state
|
|
//
|
|
m_wndTraceToolBar.ShowWindow((m_wndTraceToolBar.IsWindowVisible()) == 0);
|
|
RecalcLayout();
|
|
}
|
|
#endif
|
|
|
|
void CMainFrame::OnStopTrace()
|
|
{
|
|
POSITION pos;
|
|
LONG index;
|
|
CLogSession *pLogSession;
|
|
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
|
|
while(pos != NULL) {
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
if((pLogSession != NULL) &&
|
|
(pLogSession->m_bTraceActive)) {
|
|
//
|
|
// Stop tracing
|
|
//
|
|
pLogSession->GetDisplayWnd()->EndTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnGroupSessions()
|
|
{
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
BOOL bFound = FALSE;
|
|
CLogSession *pLog = NULL;
|
|
BOOL bWasActive = FALSE;
|
|
COLORREF textColor;
|
|
COLORREF backgroundColor;
|
|
CString str;
|
|
CDisplayDlg *pDisplayDlg;
|
|
CPtrArray *pLogSessionArray;
|
|
CPtrArray *pGroupArray;
|
|
PGROUP_SESSION_PARAMS pSessionParams;
|
|
|
|
//
|
|
// Can't group one session
|
|
//
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() == 1) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Allocate arrays
|
|
//
|
|
pLogSessionArray = new CPtrArray();
|
|
|
|
//
|
|
// Make sure allocation succeeded
|
|
//
|
|
if(NULL == pLogSessionArray) {
|
|
AfxMessageBox(_T("Unable To Group Sessions, Memory Allocation Failure"));
|
|
return;
|
|
}
|
|
|
|
pGroupArray = new CPtrArray();
|
|
|
|
//
|
|
// Make sure allocation succeeded
|
|
//
|
|
if(NULL == pGroupArray) {
|
|
AfxMessageBox(_T("Unable To Group Sessions, Memory Allocation Failure"));
|
|
|
|
delete pLogSessionArray;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Allocate our structure
|
|
//
|
|
pSessionParams = (PGROUP_SESSION_PARAMS)new CHAR[sizeof(GROUP_SESSION_PARAMS)];
|
|
|
|
//
|
|
// Make sure allocation succeeded
|
|
//
|
|
if(NULL == pSessionParams) {
|
|
AfxMessageBox(_T("Unable To Group Sessions, Memory Allocation Failure"));
|
|
|
|
delete pLogSessionArray;
|
|
delete pGroupArray;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Setup the params struct
|
|
//
|
|
pSessionParams->pGroupArray = pGroupArray;
|
|
pSessionParams->pSessionArray = pLogSessionArray;
|
|
|
|
for(LONG ii = 0; ii < MAX_LOG_SESSIONS; ii++) {
|
|
pSessionParams->SessionDoneEventArray[ii] =
|
|
CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
}
|
|
|
|
//
|
|
// Now walk through the selected sessions and put them in an array
|
|
//
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
|
|
while(pos != NULL) {
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
//
|
|
// Get the index of the next selected item
|
|
//
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
//
|
|
// Get the next log session
|
|
//
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
if(pLogSession == NULL) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Add the session to the array
|
|
//
|
|
pLogSessionArray->Add(pLogSession);
|
|
|
|
//
|
|
// Get the group display dialog for the session
|
|
//
|
|
pDisplayDlg = pLogSession->GetDisplayWnd();
|
|
|
|
//
|
|
// Set the state of the groups
|
|
//
|
|
pDisplayDlg->SetState(Grouping);
|
|
|
|
//
|
|
// Attempt to Stop the group
|
|
//
|
|
if(pDisplayDlg->EndTrace(pSessionParams->SessionDoneEventArray[pGroupArray->GetSize()])) {
|
|
//
|
|
// If stopped save the pointer to possibly start later
|
|
//
|
|
pGroupArray->Add(pDisplayDlg);
|
|
}
|
|
}
|
|
|
|
if(pLogSessionArray->GetSize() > 1) {
|
|
m_pGroupSessionsThread->PostThreadMessage(WM_USER_START_GROUP, (WPARAM)pSessionParams, 0);
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Cleanup our allocations
|
|
//
|
|
delete pLogSessionArray;
|
|
delete pGroupArray;
|
|
|
|
for(LONG ii = 0; ii < MAX_LOG_SESSIONS; ii++) {
|
|
CloseHandle(pSessionParams->SessionDoneEventArray[ii]);
|
|
}
|
|
|
|
delete [] pSessionParams;
|
|
}
|
|
|
|
void CMainFrame::OnCompleteGroup(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
PGROUP_SESSION_PARAMS pSessionParams = (PGROUP_SESSION_PARAMS)wParam;
|
|
CPtrArray *pGroupArray = pSessionParams->pGroupArray;
|
|
CPtrArray *pLogSessionArray = pSessionParams->pSessionArray;
|
|
CDisplayDlg *pDisplayDlg = NULL;
|
|
|
|
//
|
|
// Group the log sessions in a new group
|
|
//
|
|
m_logSessionDlg.GroupSessions(pLogSessionArray);
|
|
|
|
//
|
|
// Now restart any of the groups that we stopped previously
|
|
// that are still around
|
|
//
|
|
while(pGroupArray->GetSize()) {
|
|
//
|
|
// Get the first entry in the array
|
|
//
|
|
pDisplayDlg = (CDisplayDlg *)pGroupArray->GetAt(0);
|
|
pGroupArray->RemoveAt(0);
|
|
|
|
//
|
|
// Get the trace display window array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_traceDisplayWndMutex, INFINITE);
|
|
|
|
//
|
|
// See if the group still exists and start it back up if so
|
|
//
|
|
for(LONG ii = 0; ii < m_logSessionDlg.m_traceDisplayWndArray.GetSize(); ii++) {
|
|
if(pDisplayDlg == m_logSessionDlg.m_traceDisplayWndArray[ii]) {
|
|
pDisplayDlg->BeginTrace();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the trace display window array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_traceDisplayWndMutex);
|
|
}
|
|
|
|
//
|
|
// Cleanup our allocations
|
|
//
|
|
delete pLogSessionArray;
|
|
delete pGroupArray;
|
|
|
|
for(LONG ii = 0; ii < MAX_LOG_SESSIONS; ii++) {
|
|
CloseHandle(pSessionParams->SessionDoneEventArray[ii]);
|
|
}
|
|
|
|
delete [] pSessionParams;
|
|
}
|
|
|
|
void CMainFrame::OnUngroupSessions()
|
|
{
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
CString str;
|
|
CDisplayDlg *pDisplayDlg;
|
|
BOOL bWasActive = FALSE;
|
|
CPtrArray *pLogSessionArray;
|
|
CPtrArray *pGroupArray;
|
|
PGROUP_SESSION_PARAMS pSessionParams;
|
|
|
|
//
|
|
// Allocate arrays
|
|
//
|
|
pLogSessionArray = new CPtrArray();
|
|
|
|
//
|
|
// Make sure allocation succeeded
|
|
//
|
|
if(NULL == pLogSessionArray) {
|
|
AfxMessageBox(_T("Unable To Group Sessions, Memory Allocation Failure"));
|
|
return;
|
|
}
|
|
|
|
pGroupArray = new CPtrArray();
|
|
|
|
//
|
|
// Make sure allocation succeeded
|
|
//
|
|
if(NULL == pGroupArray) {
|
|
AfxMessageBox(_T("Unable To Group Sessions, Memory Allocation Failure"));
|
|
|
|
delete pLogSessionArray;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Allocate our structure
|
|
//
|
|
pSessionParams = (PGROUP_SESSION_PARAMS)new CHAR[sizeof(GROUP_SESSION_PARAMS)];
|
|
|
|
//
|
|
// Make sure allocation succeeded
|
|
//
|
|
if(NULL == pSessionParams) {
|
|
AfxMessageBox(_T("Unable To Group Sessions, Memory Allocation Failure"));
|
|
|
|
delete pLogSessionArray;
|
|
delete pGroupArray;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Setup the params struct
|
|
//
|
|
pSessionParams->pGroupArray = pGroupArray;
|
|
pSessionParams->pSessionArray = pLogSessionArray;
|
|
|
|
for(LONG ii = 0; ii < MAX_LOG_SESSIONS; ii++) {
|
|
pSessionParams->SessionDoneEventArray[ii] =
|
|
CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
}
|
|
|
|
//
|
|
// Walk selected sessions and check if they are grouped
|
|
//
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
while(pos != NULL) {
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
if(pLogSession == NULL) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Get the display wnd for the session
|
|
//
|
|
pDisplayDlg = pLogSession->GetDisplayWnd();
|
|
|
|
if(NULL == pDisplayDlg) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Set the state of the groups
|
|
//
|
|
pDisplayDlg->SetState(UnGrouping);
|
|
|
|
//
|
|
// Store each log session in the array
|
|
//
|
|
pLogSessionArray->Add(pLogSession);
|
|
|
|
//
|
|
// Stop the group, and if stopped store it to possibly be
|
|
// started again later
|
|
//
|
|
if(pDisplayDlg->EndTrace(pSessionParams->SessionDoneEventArray[pGroupArray->GetSize()])) {
|
|
pGroupArray->Add(pDisplayDlg);
|
|
}
|
|
}
|
|
|
|
m_pGroupSessionsThread->PostThreadMessage(WM_USER_START_UNGROUP, (WPARAM)pSessionParams, 0);
|
|
|
|
return;
|
|
}
|
|
|
|
void CMainFrame::OnCompleteUnGroup(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
PGROUP_SESSION_PARAMS pSessionParams = (PGROUP_SESSION_PARAMS)wParam;
|
|
CPtrArray *pGroupArray = pSessionParams->pGroupArray;
|
|
CPtrArray *pLogSessionArray = pSessionParams->pSessionArray;
|
|
CDisplayDlg *pDisplayDlg = NULL;
|
|
|
|
|
|
//
|
|
// Group the log sessions in a new group
|
|
//
|
|
m_logSessionDlg.UnGroupSessions(pLogSessionArray);
|
|
|
|
//
|
|
// Now restart any of the groups that we stopped previously
|
|
// that are still around
|
|
//
|
|
while(pGroupArray->GetSize()) {
|
|
//
|
|
// Get the first entry in the array
|
|
//
|
|
pDisplayDlg = (CDisplayDlg *)pGroupArray->GetAt(0);
|
|
pGroupArray->RemoveAt(0);
|
|
|
|
//
|
|
// Get the trace display window array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_traceDisplayWndMutex, INFINITE);
|
|
|
|
//
|
|
// See if the group still exists and start it back up if so
|
|
//
|
|
for(LONG ii = 0; ii < m_logSessionDlg.m_traceDisplayWndArray.GetSize(); ii++) {
|
|
if(pDisplayDlg == m_logSessionDlg.m_traceDisplayWndArray[ii]) {
|
|
pDisplayDlg->BeginTrace();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the trace display window array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_traceDisplayWndMutex);
|
|
}
|
|
|
|
//
|
|
// Cleanup our allocations
|
|
//
|
|
delete pLogSessionArray;
|
|
delete pGroupArray;
|
|
|
|
for(LONG ii = 0; ii < MAX_LOG_SESSIONS; ii++) {
|
|
CloseHandle(pSessionParams->SessionDoneEventArray[ii]);
|
|
}
|
|
|
|
delete [] pSessionParams;
|
|
}
|
|
|
|
void CMainFrame::OnRemoveLogSession()
|
|
{
|
|
m_logSessionDlg.RemoveSelectedLogSessions();
|
|
}
|
|
|
|
void CMainFrame::OnUpdateUIGroupSessions(CCmdUI *pCmdUI)
|
|
{
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
CString str;
|
|
OSVERSIONINFO osVersion;
|
|
BOOL bOpenExisting = FALSE;
|
|
BOOL bActiveTracing = FALSE;
|
|
BOOL bDifferentGroups = FALSE;
|
|
LONG groupNumber = -1;
|
|
|
|
//
|
|
// Default to enabled
|
|
//
|
|
pCmdUI->Enable(TRUE);
|
|
|
|
//
|
|
// disable the group option if there are not multiple groups
|
|
//
|
|
if(m_logSessionDlg.m_traceDisplayWndArray.GetSize() == 1) {
|
|
pCmdUI->Enable(FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// disable the group option if multiple sessions are not
|
|
// selected
|
|
//
|
|
if(0 == m_logSessionDlg.m_displayCtrl.GetSelectedCount()) {
|
|
pCmdUI->Enable(FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Make sure all selected sessions are of the same
|
|
// type, that is active tracing or open exisiting logfile.
|
|
//
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
while(pos != NULL) {
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
if(pLogSession != NULL) {
|
|
//
|
|
// If any session is not grouped, in the process of stopping,
|
|
// or in the process of grouping or ungrouping already,
|
|
// don't allow ungrouping
|
|
//
|
|
if((pLogSession->m_bStoppingTrace) ||
|
|
(pLogSession->m_bGroupingTrace)) {
|
|
pCmdUI->Enable(FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Check the group numbers
|
|
//
|
|
if(groupNumber == -1) {
|
|
groupNumber = pLogSession->GetGroupID();
|
|
}
|
|
|
|
if(groupNumber != pLogSession->GetGroupID()) {
|
|
bDifferentGroups = TRUE;
|
|
}
|
|
|
|
if(pLogSession->m_bDisplayExistingLogFileOnly) {
|
|
//
|
|
// Opened an existing log file
|
|
//
|
|
bOpenExisting = TRUE;
|
|
} else {
|
|
//
|
|
// Active tracing sessions can only be
|
|
// grouped on .Net and later, so we need to check
|
|
// the OS version. .Net: Major = 5 Minor = 2.
|
|
//
|
|
|
|
//
|
|
// call GetVersionEx using the OSVERSIONINFO structure,
|
|
//
|
|
ZeroMemory(&osVersion, sizeof(OSVERSIONINFO));
|
|
osVersion.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
|
|
|
|
if(GetVersionEx((OSVERSIONINFO *)&osVersion)) {
|
|
//
|
|
// Make sure we are on .NET or later to group
|
|
// real-time sessions
|
|
//
|
|
if(osVersion.dwMajorVersion < 5) {
|
|
pCmdUI->Enable(FALSE);
|
|
return;
|
|
}
|
|
if(osVersion.dwMinorVersion < 2) {
|
|
pCmdUI->Enable(FALSE);
|
|
return;
|
|
}
|
|
}
|
|
|
|
bActiveTracing = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Make sure there are multiple groups represented
|
|
//
|
|
if(!bDifferentGroups) {
|
|
pCmdUI->Enable(FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Make sure that the log session types aren't mixed
|
|
//
|
|
if(bActiveTracing && bOpenExisting) {
|
|
pCmdUI->Enable(FALSE);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
void CMainFrame::OnUpdateUngroupSessions(CCmdUI *pCmdUI)
|
|
{
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
CString str;
|
|
|
|
//
|
|
// Default to enabled
|
|
//
|
|
pCmdUI->Enable(TRUE);
|
|
|
|
//
|
|
// Walk selected sessions and check if they are grouped
|
|
//
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
while(pos != NULL) {
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
if(pLogSession == NULL) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// If any session is not grouped, in the process of stopping,
|
|
// or in the process of grouping or ungrouping already,
|
|
// don't allow ungrouping
|
|
//
|
|
if((pLogSession->GetDisplayWnd()->m_sessionArray.GetSize() == 1) ||
|
|
(pLogSession->m_bStoppingTrace) ||
|
|
(pLogSession->m_bGroupingTrace)) {
|
|
pCmdUI->Enable(FALSE);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateUIStartTrace(CCmdUI *pCmdUI)
|
|
{
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
BOOL bFound = FALSE;
|
|
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() != 1) {
|
|
pCmdUI->Enable(FALSE);
|
|
return;
|
|
}
|
|
|
|
pCmdUI->Enable(TRUE);
|
|
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
while(pos != NULL) {
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
if(pLogSession != NULL) {
|
|
bFound = TRUE;
|
|
if((pLogSession->m_bTraceActive) || (pLogSession->m_bDisplayExistingLogFileOnly)) {
|
|
pCmdUI->Enable(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(!bFound) {
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateUIStopTrace(CCmdUI *pCmdUI)
|
|
{
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
|
|
pCmdUI->Enable(FALSE);
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
//
|
|
// Don't allow stop if more than one session is selected
|
|
//
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() > 1) {
|
|
pCmdUI->Enable(FALSE);
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() > 0) {
|
|
|
|
//
|
|
// Default to enabling the stop option
|
|
//
|
|
pCmdUI->Enable(TRUE);
|
|
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
if(index >= m_logSessionDlg.m_logSessionArray.GetSize()) {
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
pCmdUI->Enable(FALSE);
|
|
|
|
return;
|
|
}
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
|
|
//
|
|
// If no session is found, disable the stop option
|
|
//
|
|
// If the session is not active, is already being stopped,
|
|
// or is for an existing logfile then disable the
|
|
// stop option.
|
|
//
|
|
// Don't allow stop if the session was started outside of
|
|
// traceview. We determine this by whether a valid handle
|
|
// was obtained for the session.
|
|
//
|
|
if((pLogSession == NULL) ||
|
|
(!pLogSession->m_bTraceActive) ||
|
|
(pLogSession->m_bStoppingTrace) ||
|
|
(pLogSession->m_bDisplayExistingLogFileOnly) ||
|
|
(pLogSession->GetSessionHandle() == (TRACEHANDLE)INVALID_HANDLE_VALUE)) {
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateUIOpenExisting(CCmdUI *pCmdUI)
|
|
{
|
|
//
|
|
// placeholder
|
|
//
|
|
}
|
|
|
|
void CMainFrame::OnOpenExisting()
|
|
{
|
|
CLogSession *pLogSession = NULL;
|
|
CString str;
|
|
LONG newDisplayFlags = 0;
|
|
LONG newColumnDisplayFlags;
|
|
LONG logSessionDisplayFlags;
|
|
CDisplayDlg *pDisplayDlg;
|
|
DWORD extendedStyles;
|
|
INT_PTR retVal;
|
|
CLogSession *pLog;
|
|
BOOL bNoID;
|
|
LONG logSessionID = 0;
|
|
CString extension;
|
|
CString traceDirectory;
|
|
LONG traceSessionID = 0;
|
|
|
|
|
|
|
|
//
|
|
// Get a unique ID for the session
|
|
//
|
|
logSessionID = m_logSessionDlg.GetLogSessionID();
|
|
|
|
//
|
|
// Create an instance of the logsession class
|
|
//
|
|
pLogSession = new CLogSession(logSessionID, &m_logSessionDlg);
|
|
if(NULL == pLogSession) {
|
|
AfxMessageBox(_T("Unable To Create Log Session"));
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Indicate the log session is not tracing real time
|
|
//
|
|
pLogSession->m_bRealTime = FALSE;
|
|
|
|
//
|
|
// Indicate the log session is only displaying an existing log session
|
|
//
|
|
pLogSession->m_bDisplayExistingLogFileOnly = TRUE;
|
|
|
|
//
|
|
// Clear the log file name so the user has to select
|
|
//
|
|
pLogSession->m_logFileName.Empty();
|
|
|
|
//
|
|
// pop-up our wizard/tab dialog to show/get properties
|
|
//
|
|
CLogFileDlg *pDialog = new CLogFileDlg(this, pLogSession);
|
|
if(NULL == pDialog) {
|
|
AfxMessageBox(_T("Failed To Create Log File Session, Resource Error"));
|
|
|
|
m_logSessionDlg.RemoveSession(pLogSession);
|
|
|
|
delete pLogSession;
|
|
|
|
return;
|
|
}
|
|
|
|
retVal = pDialog->DoModal();
|
|
|
|
if(IDOK != retVal) {
|
|
if(IDCANCEL != retVal) {
|
|
AfxMessageBox(_T("Failed To Get Log File Properties"));
|
|
}
|
|
m_logSessionDlg.RemoveSession(pLogSession);
|
|
|
|
delete pDialog;
|
|
|
|
delete pLogSession;
|
|
|
|
return;
|
|
}
|
|
|
|
CTraceSession *pTraceSession = new CTraceSession(0);
|
|
if(NULL == pTraceSession) {
|
|
AfxMessageBox(_T("Failed To Process Log File"));
|
|
m_logSessionDlg.RemoveSession(pLogSession);
|
|
|
|
delete pDialog;
|
|
|
|
delete pLogSession;
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// put the default trace session in the list
|
|
//
|
|
pLogSession->m_traceSessionArray.Add(pTraceSession);
|
|
|
|
//
|
|
// Now get the format info, prompt user for PDB or TMF
|
|
//
|
|
CProviderFormatSelectionDlg *pFormatDialog = new CProviderFormatSelectionDlg(this, pTraceSession);
|
|
|
|
if(NULL == pFormatDialog) {
|
|
AfxMessageBox(_T("Failed To Process Log File"));
|
|
m_logSessionDlg.RemoveSession(pLogSession);
|
|
|
|
delete pDialog;
|
|
|
|
delete pLogSession;
|
|
|
|
return;
|
|
}
|
|
|
|
if(IDOK != pFormatDialog->DoModal()) {
|
|
delete pFormatDialog;
|
|
m_logSessionDlg.RemoveSession(pLogSession);
|
|
|
|
delete pDialog;
|
|
|
|
delete pLogSession;
|
|
|
|
return;
|
|
}
|
|
|
|
delete pFormatDialog;
|
|
|
|
//
|
|
// Now add the log session to the log session list
|
|
//
|
|
m_logSessionDlg.AddSession(pLogSession);
|
|
|
|
//
|
|
// Get the display dialog
|
|
//
|
|
pDisplayDlg = pLogSession->GetDisplayWnd();
|
|
|
|
//
|
|
// Get the listing file name if selected from dialog
|
|
//
|
|
if(pDisplayDlg->m_bWriteListingFile = pDialog->m_bWriteListingFile) {
|
|
pDisplayDlg->m_listingFileName = pDialog->m_listingFileName;
|
|
}
|
|
|
|
//
|
|
// Get the summary file name if selected from dialog
|
|
//
|
|
if(pDisplayDlg->m_bWriteSummaryFile = pDialog->m_bWriteSummaryFile) {
|
|
pDisplayDlg->m_summaryFileName = pDialog->m_summaryFileName;
|
|
}
|
|
|
|
delete pDialog;
|
|
|
|
|
|
//
|
|
// Now trace the contents of the logfile
|
|
//
|
|
pDisplayDlg->BeginTrace();
|
|
|
|
//
|
|
// Force a redraw of the list control
|
|
//
|
|
m_logSessionDlg.m_displayCtrl.RedrawItems(
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex(),
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex() +
|
|
m_logSessionDlg.m_displayCtrl.GetCountPerPage());
|
|
|
|
m_logSessionDlg.m_displayCtrl.UpdateWindow();
|
|
}
|
|
|
|
void CMainFrame::OnStateColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_STATE) {
|
|
flags &= ~LOGSESSION_DISPLAY_STATE;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_STATE;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnEventCountColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_EVENTCOUNT) {
|
|
flags &= ~LOGSESSION_DISPLAY_EVENTCOUNT;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_EVENTCOUNT;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnLostEventsColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_LOSTEVENTS) {
|
|
flags &= ~LOGSESSION_DISPLAY_LOSTEVENTS;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_LOSTEVENTS;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnBuffersReadColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_BUFFERSREAD) {
|
|
flags &= ~LOGSESSION_DISPLAY_BUFFERSREAD;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_BUFFERSREAD;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateStateColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_STATE) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateEventCountColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_EVENTCOUNT) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateLostEventsColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_LOSTEVENTS) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateBuffersReadColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_BUFFERSREAD) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnFlagsColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_FLAGS) {
|
|
flags &= ~LOGSESSION_DISPLAY_FLAGS;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_FLAGS;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateFlagsColumnDisplay(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_FLAGS) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnFlushTimeColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_FLUSHTIME) {
|
|
flags &= ~LOGSESSION_DISPLAY_FLUSHTIME;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_FLUSHTIME;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateFlushTimeColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_FLUSHTIME) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnMaxBuffersColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_MAXBUF) {
|
|
flags &= ~LOGSESSION_DISPLAY_MAXBUF;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_MAXBUF;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateMaxBuffersColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_MAXBUF) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnMinBuffersColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_MINBUF) {
|
|
flags &= ~LOGSESSION_DISPLAY_MINBUF;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_MINBUF;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateMinBuffersColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_MINBUF) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnBufferSizeColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_BUFFERSIZE) {
|
|
flags &= ~LOGSESSION_DISPLAY_BUFFERSIZE;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_BUFFERSIZE;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateBufferSizeColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_BUFFERSIZE) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnDecayTimeColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_DECAYTIME) {
|
|
flags &= ~LOGSESSION_DISPLAY_DECAYTIME;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_DECAYTIME;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateDecayTimeColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_DECAYTIME) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnCircularColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_CIR) {
|
|
flags &= ~LOGSESSION_DISPLAY_CIR;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_CIR;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateCircularColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_CIR) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnSequentialColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_SEQ) {
|
|
flags &= ~LOGSESSION_DISPLAY_SEQ;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_SEQ;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateSequentialColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_SEQ) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnNewFileColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_NEWFILE) {
|
|
flags &= ~LOGSESSION_DISPLAY_NEWFILE;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_NEWFILE;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateNewFileColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_NEWFILE) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnGlobalSeqColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_GLOBALSEQ) {
|
|
flags &= ~LOGSESSION_DISPLAY_GLOBALSEQ;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_GLOBALSEQ;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateGlobalSeqColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_GLOBALSEQ) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnLocalSeqColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_LOCALSEQ) {
|
|
flags &= ~LOGSESSION_DISPLAY_LOCALSEQ;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_LOCALSEQ;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateLocalSeqColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_LOCALSEQ) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnLevelColumnDisplayCheck()
|
|
{
|
|
LONG flags;
|
|
|
|
flags = m_logSessionDlg.GetDisplayFlags();
|
|
|
|
if(flags & LOGSESSION_DISPLAY_LEVEL) {
|
|
flags &= ~LOGSESSION_DISPLAY_LEVEL;
|
|
} else {
|
|
flags |= LOGSESSION_DISPLAY_LEVEL;
|
|
}
|
|
|
|
m_logSessionDlg.SetDisplayFlags(flags);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateLevelColumnDisplayCheck(CCmdUI *pCmdUI)
|
|
{
|
|
if(m_logSessionDlg.GetDisplayFlags() & LOGSESSION_DISPLAY_LEVEL) {
|
|
pCmdUI->SetCheck(TRUE);
|
|
} else {
|
|
pCmdUI->SetCheck(FALSE);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateRemoveTrace(CCmdUI *pCmdUI)
|
|
{
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
|
|
pCmdUI->Enable(FALSE);
|
|
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() > 1) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() > 0) {
|
|
pCmdUI->Enable(TRUE);
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
while(pos != NULL) {
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
if(index >= m_logSessionDlg.m_logSessionArray.GetSize()) {
|
|
pCmdUI->Enable(FALSE);
|
|
break;
|
|
}
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
if((pLogSession == NULL) ||
|
|
pLogSession->m_bTraceActive ||
|
|
pLogSession->m_bStoppingTrace ||
|
|
pLogSession->m_bGroupingTrace ||
|
|
(pLogSession->GetDisplayWnd()->m_sessionArray.GetSize() > 1)) {
|
|
pCmdUI->Enable(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
}
|
|
|
|
void CMainFrame::OnLogSessionDisplayOptions()
|
|
{
|
|
//
|
|
// Just here to enable the menu item, nothing to do
|
|
//
|
|
}
|
|
|
|
void CMainFrame::OnChangeTextColor()
|
|
{
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() > 0) {
|
|
|
|
CColorDialog colorDlg(0, 0, this);
|
|
COLORREF color;
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
|
|
if(IDOK == colorDlg.DoModal()) {
|
|
color = colorDlg.GetColor();
|
|
}
|
|
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
while(pos != NULL) {
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
if(index >= m_logSessionDlg.m_logSessionArray.GetSize()) {
|
|
break;
|
|
}
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
if(pLogSession != NULL) {
|
|
pLogSession->m_titleTextColor = color;
|
|
|
|
m_logSessionDlg.m_displayCtrl.RedrawItems(
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex(),
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex() +
|
|
m_logSessionDlg.m_displayCtrl.GetCountPerPage());
|
|
|
|
m_logSessionDlg.m_displayCtrl.UpdateWindow();
|
|
}
|
|
}
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnChangeBackgroundColor()
|
|
{
|
|
if(m_logSessionDlg.m_displayCtrl.GetSelectedCount() > 0) {
|
|
|
|
CColorDialog colorDlg(0, 0, this);
|
|
COLORREF color;
|
|
POSITION pos;
|
|
int index;
|
|
CLogSession *pLogSession;
|
|
|
|
if(IDOK == colorDlg.DoModal()) {
|
|
color = colorDlg.GetColor();
|
|
}
|
|
|
|
pos = m_logSessionDlg.m_displayCtrl.GetFirstSelectedItemPosition();
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionDlg.m_logSessionArrayMutex, INFINITE);
|
|
|
|
while(pos != NULL) {
|
|
|
|
index = m_logSessionDlg.m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
if(index >= m_logSessionDlg.m_logSessionArray.GetSize()) {
|
|
break;
|
|
}
|
|
|
|
pLogSession = (CLogSession *)m_logSessionDlg.m_logSessionArray[index];
|
|
if(pLogSession != NULL) {
|
|
pLogSession->m_titleBackgroundColor = color;
|
|
|
|
m_logSessionDlg.m_displayCtrl.RedrawItems(
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex(),
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex() +
|
|
m_logSessionDlg.m_displayCtrl.GetCountPerPage());
|
|
|
|
m_logSessionDlg.m_displayCtrl.UpdateWindow();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionDlg.m_logSessionArrayMutex);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateChangeTextColor(CCmdUI *pCmdUI)
|
|
{
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateChangeBackgroundColor(CCmdUI *pCmdUI)
|
|
{
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateLogSessionList(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
m_logSessionDlg.m_displayCtrl.RedrawItems(
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex(),
|
|
m_logSessionDlg.m_displayCtrl.GetTopIndex() +
|
|
m_logSessionDlg.m_displayCtrl.GetCountPerPage());
|
|
|
|
m_logSessionDlg.m_displayCtrl.UpdateWindow();
|
|
}
|
|
|
|
void CMainFrame::OnSetTmax()
|
|
{
|
|
// TODO: Add your command handler code here
|
|
CMaxTraceDlg dlg;
|
|
|
|
dlg.DoModal();
|
|
|
|
MaxTraceEntries = dlg.m_MaxTraceEntries;
|
|
}
|
|
|
|
void CMainFrame::OnUpdateSetTmax(CCmdUI *pCmdUI)
|
|
{
|
|
// TODO: Add your command update UI handler code here
|
|
pCmdUI->Enable();
|
|
|
|
if( m_logSessionDlg.m_logSessionArray.GetSize() ) {
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
}
|