1589 lines
39 KiB
C++
1589 lines
39 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (c) 2002 Microsoft Corporation. All rights reserved.
|
|
// Copyright (c) 2002 OSR Open Systems Resources, Inc.
|
|
//
|
|
// LogSessionDialog.cpp : implementation file
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h"
|
|
#include <tchar.h>
|
|
#include <wmistr.h>
|
|
#include <initguid.h>
|
|
extern "C" {
|
|
#include <evntrace.h>
|
|
}
|
|
#include <traceprt.h>
|
|
#include "TraceView.h"
|
|
#include "DockDialogBar.h"
|
|
#include "LogSession.h"
|
|
#include "DisplayDlg.h"
|
|
#include "ListCtrlEx.h"
|
|
#include "Utils.h"
|
|
#include "LogSessionDlg.h"
|
|
|
|
// CLogSessionDlg dialog
|
|
|
|
IMPLEMENT_DYNAMIC(CLogSessionDlg, CDialog)
|
|
CLogSessionDlg::CLogSessionDlg(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CLogSessionDlg::IDD, pParent)
|
|
{
|
|
//
|
|
// Set the column titles
|
|
//
|
|
m_columnName.Add("State ");
|
|
m_columnName.Add("Event Count");
|
|
m_columnName.Add("Lost Events");
|
|
m_columnName.Add("Buffers Read");
|
|
m_columnName.Add("Flags");
|
|
m_columnName.Add("Flush Time");
|
|
m_columnName.Add("Max Buf");
|
|
m_columnName.Add("Min Buf");
|
|
m_columnName.Add("Buf Size");
|
|
m_columnName.Add("Age");
|
|
m_columnName.Add("Circular");
|
|
m_columnName.Add("Sequential");
|
|
m_columnName.Add("New File");
|
|
m_columnName.Add("Global Seq");
|
|
m_columnName.Add("Local Seq");
|
|
m_columnName.Add("Level");
|
|
|
|
//
|
|
// Set the initial column widths
|
|
//
|
|
for(LONG ii = 0; ii < MaxLogSessionOptions; ii++) {
|
|
m_columnWidth[ii] = 100;
|
|
}
|
|
|
|
//
|
|
// Initialize the ID arrays
|
|
//
|
|
memset(m_logSessionIDList, 0, sizeof(BOOL) * MAX_LOG_SESSIONS);
|
|
memset(m_displayWndIDList, 0, sizeof(BOOL) * MAX_LOG_SESSIONS);
|
|
|
|
m_displayFlags = 0;
|
|
m_logSessionDisplayFlags = 0x00000000;
|
|
|
|
//
|
|
// Create the parameter change signalling event
|
|
//
|
|
m_hParameterChangeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
}
|
|
|
|
CLogSessionDlg::~CLogSessionDlg()
|
|
{
|
|
CLogSession *pLogSession;
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
//
|
|
// cleanup our display bar list
|
|
//
|
|
while(m_logSessionArray.GetSize() > 0) {
|
|
pLogSession = (CLogSession *)m_logSessionArray.GetAt(0);
|
|
m_logSessionArray.RemoveAt(0);
|
|
if(pLogSession != NULL) {
|
|
if((pLogSession->m_bTraceActive) && (!pLogSession->m_bStoppingTrace)) {
|
|
pLogSession->EndTrace();
|
|
}
|
|
|
|
//
|
|
// Disengage the display window from this log session
|
|
//
|
|
ReleaseDisplayWnd(pLogSession);
|
|
|
|
ReleaseLogSessionID(pLogSession);
|
|
|
|
delete pLogSession;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
ASSERT(m_traceDisplayWndArray.GetSize() == 0);
|
|
|
|
//
|
|
// close our event handle
|
|
//
|
|
CloseHandle(m_hParameterChangeEvent);
|
|
|
|
//
|
|
// Close the mutex handles
|
|
//
|
|
CloseHandle(m_traceDisplayWndMutex);
|
|
CloseHandle(m_logSessionArrayMutex);
|
|
}
|
|
|
|
BOOL CLogSessionDlg::OnInitDialog()
|
|
{
|
|
RECT rc;
|
|
RECT parentRC;
|
|
CString str;
|
|
|
|
CDialog::OnInitDialog();
|
|
|
|
//
|
|
// Create the trace window pointer array protection mutex
|
|
//
|
|
m_traceDisplayWndMutex = CreateMutex(NULL,TRUE,NULL);
|
|
|
|
if(m_traceDisplayWndMutex == NULL) {
|
|
|
|
DWORD error = GetLastError();
|
|
|
|
str.Format(_T("CreateMutex Error error %d %x"),error,error);
|
|
|
|
AfxMessageBox(str);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
ReleaseMutex(m_traceDisplayWndMutex);
|
|
|
|
//
|
|
// Create the log session array protection mutex
|
|
//
|
|
m_logSessionArrayMutex = CreateMutex(NULL, TRUE, NULL);
|
|
|
|
if(m_logSessionArrayMutex == NULL) {
|
|
|
|
DWORD error = GetLastError();
|
|
|
|
str.Format(_T("CreateMutex Error error %d %x"),error,error);
|
|
|
|
AfxMessageBox(str);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
//
|
|
// get the parent dimensions
|
|
//
|
|
GetParent()->GetParent()->GetClientRect(&parentRC);
|
|
|
|
//
|
|
// get the dialog dimensions
|
|
//
|
|
GetWindowRect(&rc);
|
|
|
|
//
|
|
// adjust the list control dimensions
|
|
//
|
|
rc.right = parentRC.right - parentRC.left - 24;
|
|
rc.bottom = rc.bottom - rc.top;
|
|
rc.left = 0;
|
|
rc.top = 0;
|
|
|
|
if(!m_displayCtrl.Create(WS_CHILD|WS_VISIBLE|WS_BORDER|LVS_REPORT,
|
|
rc,
|
|
this,
|
|
IDC_DISPLAY_LIST))
|
|
{
|
|
TRACE(_T("Failed to create logger list control\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
for(LONG ii = 0; ii < MaxLogSessionOptions; ii++) {
|
|
//
|
|
// This lookup table allows a retrieval of the current
|
|
// position of a given column like m_retrievalArray[State]
|
|
// will return the correct column value for the State
|
|
// column
|
|
//
|
|
m_retrievalArray[ii] = ii;
|
|
|
|
//
|
|
// This lookup table allows correct placement of
|
|
// a column being added. So, if the State column
|
|
// needed to be inserted, then m_insertionArray[State]
|
|
// would give the correct insertion column value.
|
|
// It is also used in SetItemText to update the correct
|
|
// column.
|
|
//
|
|
m_insertionArray[ii] = ii;
|
|
}
|
|
|
|
//
|
|
// We have to return zero here to get the focus set correctly
|
|
// for the app.
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
void CLogSessionDlg::OnNcPaint()
|
|
{
|
|
CRect pRect;
|
|
|
|
GetClientRect(&pRect);
|
|
InvalidateRect(&pRect, TRUE);
|
|
}
|
|
|
|
void CLogSessionDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
}
|
|
|
|
VOID CLogSessionDlg::SetDisplayFlags(LONG DisplayFlags)
|
|
{
|
|
LONG addDisplayFlags = ~m_displayFlags & DisplayFlags;
|
|
LONG removeDisplayFlags = m_displayFlags & ~DisplayFlags;
|
|
LONG updateDisplayFlags = m_displayFlags & DisplayFlags;
|
|
LONG ii;
|
|
LONG jj;
|
|
LONG kk;
|
|
LONG ll;
|
|
CString str;
|
|
CLogSession *pLog;
|
|
LONG limit;
|
|
|
|
//
|
|
// Now insert any new columns and remove any uneeded
|
|
//
|
|
for(ii = 0, jj = 1; ii < MaxLogSessionOptions; ii++, jj <<= 1) {
|
|
//
|
|
// add the columns
|
|
//
|
|
if(addDisplayFlags & jj) {
|
|
|
|
//
|
|
// insert the column
|
|
//
|
|
m_displayCtrl.InsertColumn(m_insertionArray[ii + 1],
|
|
m_columnName[ii],
|
|
LVCFMT_LEFT,
|
|
m_columnWidth[ii]);
|
|
|
|
//
|
|
// update the column positions
|
|
//
|
|
for(kk = 0, ll = 1; kk < MaxLogSessionOptions; kk++) {
|
|
m_insertionArray[kk + 1] = ll;
|
|
if(DisplayFlags & (1 << kk)) {
|
|
m_retrievalArray[ll] = kk;
|
|
ll++;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// remove the columns
|
|
//
|
|
if(removeDisplayFlags & jj) {
|
|
//
|
|
// Get the width of the column to be removed
|
|
//
|
|
m_columnWidth[ii] =
|
|
m_displayCtrl.GetColumnWidth(m_insertionArray[ii + 1]);
|
|
|
|
//
|
|
// remove the column
|
|
//
|
|
m_displayCtrl.DeleteColumn(m_insertionArray[ii + 1]);
|
|
|
|
//
|
|
// update the column positions
|
|
//
|
|
for(kk = 0, ll = 1; kk < MaxLogSessionOptions; kk++) {
|
|
m_insertionArray[kk + 1] = ll;
|
|
if(DisplayFlags & (1 << kk)) {
|
|
m_retrievalArray[ll] = kk;
|
|
ll++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Save our new flags
|
|
//
|
|
m_displayFlags = DisplayFlags;
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
//
|
|
// Now display the log session properties that
|
|
// have been selected
|
|
//
|
|
for(ii = 0; ii < m_logSessionArray.GetSize(); ii++) {
|
|
pLog = (CLogSession *)m_logSessionArray[ii];
|
|
|
|
if(NULL == pLog) {
|
|
continue;
|
|
}
|
|
|
|
limit = MaxLogSessionOptions;
|
|
|
|
if(pLog->m_bDisplayExistingLogFileOnly) {
|
|
limit = 1;
|
|
}
|
|
for(jj = 0; jj < limit; jj++) {
|
|
SetItemText(ii,
|
|
jj + 1,
|
|
pLog->m_logSessionValues[jj]);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
}
|
|
|
|
BOOL CLogSessionDlg::SetItemText(int nItem, int nSubItem, LPCTSTR lpszText)
|
|
{
|
|
//
|
|
// Adjust the subitem value for the correct column and insert
|
|
//
|
|
if(m_displayFlags & (1 << (nSubItem - 1))) {
|
|
return m_displayCtrl.SetItemText(nItem,
|
|
m_insertionArray[nSubItem],
|
|
lpszText);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CLogSessionDlg::AddSession(CLogSession *pLogSession)
|
|
{
|
|
CLogSession *pLog;
|
|
CString text;
|
|
LONG numberOfEntries;
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
//
|
|
// add the element to the array
|
|
//
|
|
m_logSessionArray.Add(pLogSession);
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
//
|
|
// Get a trace display window for the session
|
|
//
|
|
if(!AssignDisplayWnd(pLogSession)) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
numberOfEntries = (LONG)m_logSessionArray.GetSize();
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
for(LONG ii = 0; ii < numberOfEntries; ii++) {
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
pLog = (CLogSession *)m_logSessionArray[ii];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
if(pLog == pLogSession) {
|
|
text.Format(_T("%d "), pLogSession->GetGroupID());
|
|
|
|
text += pLogSession->GetDisplayName();
|
|
|
|
//
|
|
// Display the name
|
|
//
|
|
m_displayCtrl.InsertItem(ii,
|
|
text,
|
|
pLogSession);
|
|
|
|
UpdateSession(pLogSession);
|
|
|
|
if(numberOfEntries <= 1) {
|
|
AutoSizeColumns();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
VOID CLogSessionDlg::UpdateSession(CLogSession *pLogSession)
|
|
{
|
|
LONG logSessionDisplayFlags;
|
|
CLogSession *pLog;
|
|
BOOL bActiveSession = FALSE;
|
|
LONG traceDisplayFlags;
|
|
LONG numberOfEntries;
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
numberOfEntries = (LONG)m_logSessionArray.GetSize();
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
//
|
|
// recalculate the display flags
|
|
//
|
|
for(LONG ii = 0; ii < numberOfEntries; ii++) {
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
pLog = (CLogSession *)m_logSessionArray[ii];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
if((NULL != pLog) && !pLog->m_bDisplayExistingLogFileOnly) {
|
|
bActiveSession = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Figure out if we need to stop displaying columns
|
|
//
|
|
logSessionDisplayFlags = GetDisplayFlags();
|
|
|
|
SetDisplayFlags(logSessionDisplayFlags ? logSessionDisplayFlags : 0xFFFFFFFF);
|
|
|
|
//
|
|
// Force an update of the display window as well
|
|
//
|
|
traceDisplayFlags = pLogSession->GetDisplayWnd()->GetDisplayFlags();
|
|
|
|
pLogSession->GetDisplayWnd()->SetDisplayFlags(traceDisplayFlags);
|
|
}
|
|
|
|
VOID CLogSessionDlg::RemoveSession(CLogSession *pLogSession)
|
|
{
|
|
CDisplayDlg *pDisplayDlg;
|
|
CDockDialogBar *pDialogBar;
|
|
CLogSession *pLog;
|
|
|
|
if(pLogSession == NULL) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Disengage the display window from this log session
|
|
//
|
|
ReleaseDisplayWnd(pLogSession);
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
//
|
|
// remove the session from display
|
|
//
|
|
for(LONG ii = (LONG)m_logSessionArray.GetSize() - 1; ii >= 0; ii--) {
|
|
pLog = (CLogSession *)m_logSessionArray[ii];
|
|
|
|
if(pLog == pLogSession) {
|
|
m_displayCtrl.DeleteItem(ii);
|
|
|
|
//
|
|
// delete the log session from the array
|
|
//
|
|
m_logSessionArray.RemoveAt(ii);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
//
|
|
// Return the log session ID
|
|
//
|
|
ReleaseLogSessionID(pLogSession);
|
|
|
|
if(m_logSessionArray.GetSize() == 0) {
|
|
SetDisplayFlags(0);
|
|
}
|
|
}
|
|
|
|
VOID CLogSessionDlg::RemoveSelectedLogSessions()
|
|
{
|
|
POSITION pos;
|
|
LONG index;
|
|
CLogSession *pLogSession;
|
|
CDisplayDlg *pDisplayDlg;
|
|
|
|
pos = m_displayCtrl.GetFirstSelectedItemPosition();
|
|
|
|
while(pos != NULL) {
|
|
//
|
|
// Find any selected sessions
|
|
//
|
|
index = m_displayCtrl.GetNextSelectedItem(pos);
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
pLogSession = (CLogSession *)m_logSessionArray[index];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
pDisplayDlg = pLogSession->GetDisplayWnd();
|
|
|
|
if(pDisplayDlg->m_sessionArray.GetSize() > 1) {
|
|
//
|
|
// Don't allow grouped sessions to get removed
|
|
//
|
|
continue;
|
|
}
|
|
|
|
RemoveSession(pLogSession);
|
|
|
|
//
|
|
// delete the log session
|
|
//
|
|
delete pLogSession;
|
|
}
|
|
}
|
|
|
|
VOID CLogSessionDlg::GroupSessions(CPtrArray *pLogSessionArray)
|
|
{
|
|
CLogSession *pLogSession = NULL;
|
|
LONG groupID = -1;
|
|
CString str;
|
|
|
|
//
|
|
// Disconnect sessions from group display windows
|
|
//
|
|
for(LONG ii = 0; ii < pLogSessionArray->GetSize(); ii++) {
|
|
pLogSession = (CLogSession *)pLogSessionArray->GetAt(ii);
|
|
|
|
if(NULL == pLogSession) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Disconnect the display window and possibly remove it
|
|
//
|
|
ReleaseDisplayWnd(pLogSession);
|
|
}
|
|
|
|
//
|
|
// Attach the first log session to a group window
|
|
// then use this for all subsequent log sessions
|
|
//
|
|
for(LONG ii = 0; ii < pLogSessionArray->GetSize(); ii++) {
|
|
pLogSession = (CLogSession *)pLogSessionArray->GetAt(ii);
|
|
|
|
if(NULL == pLogSession) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Set the group ID
|
|
//
|
|
pLogSession->SetGroupID(groupID);
|
|
|
|
//
|
|
// Hook up the group window
|
|
//
|
|
AssignDisplayWnd(pLogSession);
|
|
|
|
//
|
|
// Update the session group ID in the display
|
|
//
|
|
str.Format(_T("%d %ls"), pLogSession->GetGroupID(), pLogSession->GetDisplayName());
|
|
|
|
for(LONG jj = 0; jj < m_displayCtrl.GetItemCount(); jj++) {
|
|
if(pLogSession == (CLogSession *)m_displayCtrl.GetItemData(jj)) {
|
|
m_displayCtrl.SetItemText(jj, 0, str);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Get the new group ID
|
|
//
|
|
groupID = pLogSession->GetGroupID();
|
|
}
|
|
|
|
//
|
|
// Now start the new group
|
|
//
|
|
pLogSession->GetDisplayWnd()->BeginTrace();
|
|
}
|
|
|
|
VOID CLogSessionDlg::UnGroupSessions(CPtrArray *pLogSessionArray)
|
|
{
|
|
CLogSession *pLogSession = NULL;
|
|
LONG groupID = -1;
|
|
CString str;
|
|
LONG ii;
|
|
|
|
//
|
|
// Disconnect all sessions from their groups
|
|
//
|
|
for(ii = 0; ii < pLogSessionArray->GetSize(); ii++) {
|
|
pLogSession = (CLogSession *)pLogSessionArray->GetAt(ii);
|
|
|
|
if(NULL == pLogSession) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Disconnect the display window and possibly remove it
|
|
//
|
|
ReleaseDisplayWnd(pLogSession);
|
|
}
|
|
|
|
//
|
|
// Create a unique group for each
|
|
//
|
|
for(ii = 0; ii < pLogSessionArray->GetSize(); ii++) {
|
|
pLogSession = (CLogSession *)pLogSessionArray->GetAt(ii);
|
|
|
|
if(NULL == pLogSession) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Hook up the group window
|
|
//
|
|
AssignDisplayWnd(pLogSession);
|
|
|
|
//
|
|
// Update the session group ID in the display
|
|
//
|
|
str.Format(_T("%d %ls"), pLogSession->GetGroupID(), pLogSession->GetDisplayName());
|
|
|
|
for(LONG jj = 0; jj < m_displayCtrl.GetItemCount(); jj++) {
|
|
if(pLogSession == (CLogSession *)m_displayCtrl.GetItemData(jj)) {
|
|
m_displayCtrl.SetItemText(jj, 0, str);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now start the new group
|
|
//
|
|
pLogSession->GetDisplayWnd()->BeginTrace();
|
|
}
|
|
}
|
|
|
|
BOOL CLogSessionDlg::AssignDisplayWnd(CLogSession *pLogSession)
|
|
{
|
|
CDisplayDlg *pDisplayDlg;
|
|
CString str;
|
|
DWORD extendedStyles;
|
|
LONG numberOfEntries;
|
|
|
|
//
|
|
// If we have a valid group number see if there is an
|
|
// existing group window
|
|
//
|
|
if(pLogSession->GetGroupID() != -1) {
|
|
|
|
//
|
|
// Get the trace display window array protection
|
|
//
|
|
WaitForSingleObject(m_traceDisplayWndMutex, INFINITE);
|
|
|
|
numberOfEntries = (LONG)m_traceDisplayWndArray.GetSize();
|
|
|
|
//
|
|
// Release the trace display window array protection
|
|
//
|
|
ReleaseMutex(m_traceDisplayWndMutex);
|
|
|
|
//
|
|
// Use the group window if there is one
|
|
//
|
|
for(LONG ii = 0; ii < numberOfEntries; ii++) {
|
|
//
|
|
// Get the trace display window array protection
|
|
//
|
|
WaitForSingleObject(m_traceDisplayWndMutex, INFINITE);
|
|
|
|
pDisplayDlg = (CDisplayDlg *)m_traceDisplayWndArray[ii];
|
|
if(pDisplayDlg == NULL) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Release the trace display window array protection
|
|
//
|
|
ReleaseMutex(m_traceDisplayWndMutex);
|
|
|
|
if(pDisplayDlg->GetDisplayID() == pLogSession->GetGroupID()) {
|
|
pLogSession->SetDisplayWnd(pDisplayDlg);
|
|
|
|
//
|
|
// add the element to the display wnd
|
|
//
|
|
pDisplayDlg->AddSession(pLogSession);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Otherwise create a new group display window
|
|
//
|
|
CDockDialogBar *pDialogBar = new CDockDialogBar();
|
|
if(NULL == pDialogBar) {
|
|
AfxMessageBox(_T("Failed To Create Display Window\nMemory Allocation Failure"));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
pDisplayDlg = new CDisplayDlg(GetParentFrame(),
|
|
GetDisplayWndID());
|
|
if(NULL == pDisplayDlg) {
|
|
AfxMessageBox(_T("Failed To Create Display Window\nMemory Allocation Failure"));
|
|
|
|
delete pDialogBar;
|
|
return FALSE;
|
|
}
|
|
|
|
str.Format(_T("Group %d"), pDisplayDlg->GetDisplayID());
|
|
|
|
//
|
|
// create our dockable dialog bar with list control
|
|
//
|
|
if(!pDialogBar->Create(GetParentFrame(),
|
|
pDisplayDlg,
|
|
str,
|
|
IDD_DISPLAY_DIALOG,
|
|
WS_CHILD|WS_VISIBLE|CBRS_BOTTOM|CBRS_TOOLTIPS|CBRS_SIZE_DYNAMIC,
|
|
TRUE))
|
|
{
|
|
AfxMessageBox(_T("Failed To Create Display Window"));
|
|
|
|
delete pDisplayDlg;
|
|
delete pDialogBar;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Store the dock dialog pointer in the display dialog instance
|
|
//
|
|
pDisplayDlg->SetDockDialogBar((PVOID)pDialogBar);
|
|
|
|
//
|
|
// set our preferred extended styles
|
|
//
|
|
extendedStyles = LVS_EX_HEADERDRAGDROP | LVS_EX_FULLROWSELECT;
|
|
|
|
//
|
|
// Set the extended styles for the list control
|
|
//
|
|
pDisplayDlg->m_displayCtrl.SetExtendedStyle(extendedStyles);
|
|
|
|
//
|
|
// make the dialog dockable and dock it to the top
|
|
//
|
|
pDialogBar->EnableDocking(CBRS_ALIGN_TOP);
|
|
|
|
//
|
|
// dock the bar to the top
|
|
//
|
|
GetParentFrame()->DockControlBar(pDialogBar, AFX_IDW_DOCKBAR_TOP);
|
|
|
|
//
|
|
// Get the trace display window array protection
|
|
//
|
|
WaitForSingleObject(m_traceDisplayWndMutex, INFINITE);
|
|
|
|
//
|
|
// Add the bar to our array
|
|
//
|
|
m_traceDisplayWndArray.Add(pDisplayDlg);
|
|
|
|
//
|
|
// Release the trace display window array protection
|
|
//
|
|
ReleaseMutex(m_traceDisplayWndMutex);
|
|
|
|
//
|
|
// Set the log session group ID
|
|
//
|
|
pLogSession->SetGroupID(pDisplayDlg->GetDisplayID());
|
|
|
|
//
|
|
// Set the log session display pointer
|
|
//
|
|
pLogSession->SetDisplayWnd(pDisplayDlg);
|
|
|
|
//
|
|
// add the element to the display wnd
|
|
//
|
|
pDisplayDlg->AddSession(pLogSession);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VOID CLogSessionDlg::ReleaseDisplayWnd(CLogSession *pLogSession)
|
|
{
|
|
CString str;
|
|
CDisplayDlg *pDisplayDlg;
|
|
CDockDialogBar *pDialogBar = NULL;
|
|
CLogSession *pLog;
|
|
|
|
if(pLogSession == NULL) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// get the session's display window
|
|
//
|
|
pDisplayDlg = pLogSession->GetDisplayWnd();
|
|
|
|
//
|
|
// Clear the display window pointer from the log session
|
|
//
|
|
pLogSession->SetDisplayWnd(NULL);
|
|
|
|
//
|
|
// Set the group ID to an invalid ID
|
|
//
|
|
pLogSession->SetGroupID(-1);
|
|
|
|
if(NULL == pDisplayDlg) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Pull the log session from the displayDlg's array
|
|
//
|
|
pDisplayDlg->RemoveSession(pLogSession);
|
|
|
|
//
|
|
// Get the array protection
|
|
//
|
|
WaitForSingleObject(pDisplayDlg->m_hSessionArrayMutex, INFINITE);
|
|
|
|
//
|
|
// If there are still log sessions attached to this window
|
|
// just return
|
|
//
|
|
if(pDisplayDlg->m_sessionArray.GetSize() > 0) {
|
|
//
|
|
// Release the array protection
|
|
//
|
|
ReleaseMutex(pDisplayDlg->m_hSessionArrayMutex);
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Release the array protection
|
|
//
|
|
ReleaseMutex(pDisplayDlg->m_hSessionArrayMutex);
|
|
|
|
//
|
|
// Get the trace display window array protection
|
|
//
|
|
WaitForSingleObject(m_traceDisplayWndMutex, INFINITE);
|
|
|
|
//
|
|
// Remove this window from the list of display windows
|
|
//
|
|
for (LONG ii = (LONG)m_traceDisplayWndArray.GetSize() - 1; ii >=0 ; ii--) {
|
|
if(m_traceDisplayWndArray[ii] == pDisplayDlg) {
|
|
m_traceDisplayWndArray.RemoveAt(ii);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release the trace display window array protection
|
|
//
|
|
ReleaseMutex(m_traceDisplayWndMutex);
|
|
|
|
//
|
|
// Get the dock dialog bar so it can be deleted
|
|
//
|
|
pDialogBar = (CDockDialogBar *)pDisplayDlg->GetDockDialogBar();
|
|
|
|
//
|
|
// Clear the pointer in the class
|
|
//
|
|
pDisplayDlg->SetDockDialogBar(NULL);
|
|
|
|
//
|
|
// Release the window ID
|
|
//
|
|
ReleaseDisplayWndID(pDisplayDlg);
|
|
|
|
//
|
|
// delete the display window
|
|
//
|
|
delete pDisplayDlg;
|
|
|
|
//
|
|
// Delete the dock dialog bar
|
|
//
|
|
if(NULL != pDialogBar) {
|
|
delete pDialogBar;
|
|
}
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(CLogSessionDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CLogSessionDlg)
|
|
ON_WM_WINDOWPOSCHANGED()
|
|
ON_WM_NCCALCSIZE()
|
|
ON_WM_SIZE()
|
|
ON_MESSAGE(WM_PARAMETER_CHANGED, OnParameterChanged)
|
|
ON_NOTIFY(NM_CLICK, IDC_DISPLAY_LIST, OnNMClickDisplayList)
|
|
ON_NOTIFY(NM_RCLICK, IDC_DISPLAY_LIST, OnNMRclickDisplayList)
|
|
ON_NOTIFY(HDN_ITEMRCLICK, IDC_DISPLAY_LIST, OnHDNRclickDisplayList)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
// CLogSessionDlg message handlers
|
|
|
|
void CLogSessionDlg::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos)
|
|
{
|
|
CDialog::OnWindowPosChanged(lpwndpos);
|
|
}
|
|
|
|
void CLogSessionDlg::OnSize(UINT nType, int cx,int cy)
|
|
{
|
|
CRect rc;
|
|
|
|
if(!IsWindow(m_displayCtrl.GetSafeHwnd()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
GetParent()->GetClientRect(&rc);
|
|
|
|
//
|
|
// reset the size of the dialog
|
|
//
|
|
SetWindowPos(NULL,
|
|
0,
|
|
0,
|
|
rc.right - rc.left,
|
|
rc.bottom - rc.top,
|
|
SWP_NOMOVE|SWP_SHOWWINDOW|SWP_NOZORDER);
|
|
|
|
GetClientRect(&rc);
|
|
|
|
m_displayCtrl.MoveWindow(rc);
|
|
}
|
|
|
|
|
|
BOOL CLogSessionDlg::PreTranslateMessage(MSG* pMsg)
|
|
{
|
|
if(pMsg->message == WM_KEYDOWN)
|
|
{
|
|
if((pMsg->wParam == VK_ESCAPE) || (pMsg->wParam == VK_RETURN))
|
|
{
|
|
//
|
|
// Ignore the escape and return keys, otherwise
|
|
// the client area grays out on escape
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Fix for key accelerators, otherwise they are never
|
|
// processed
|
|
//
|
|
if (AfxGetMainWnd()->PreTranslateMessage(pMsg))
|
|
return TRUE;
|
|
return CDialog::PreTranslateMessage(pMsg);
|
|
}
|
|
|
|
return CDialog::PreTranslateMessage(pMsg);
|
|
}
|
|
|
|
LRESULT CLogSessionDlg::OnParameterChanged(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CLogSession *pLogSession;
|
|
CString str;
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
pLogSession = (CLogSession *)m_logSessionArray[wParam];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
if(NULL == pLogSession) {
|
|
return 0;
|
|
}
|
|
|
|
pLogSession->m_logSessionValues[m_retrievalArray[(int)lParam]] =
|
|
m_displayCtrl.GetItemText((int)wParam, (int)lParam);
|
|
|
|
if((m_retrievalArray[lParam] == Circular) &&
|
|
!pLogSession->m_logSessionValues[m_retrievalArray[lParam]].IsEmpty()) {
|
|
pLogSession->m_logSessionValues[Sequential].Empty();
|
|
pLogSession->m_logSessionValues[NewFile].Empty();
|
|
}
|
|
|
|
if((m_retrievalArray[lParam] == Sequential) &&
|
|
!pLogSession->m_logSessionValues[m_retrievalArray[lParam]].IsEmpty()) {
|
|
pLogSession->m_logSessionValues[Circular].Empty();
|
|
pLogSession->m_logSessionValues[NewFile].Empty();
|
|
}
|
|
|
|
if((m_retrievalArray[lParam] == NewFile) &&
|
|
!pLogSession->m_logSessionValues[m_retrievalArray[lParam]].IsEmpty()) {
|
|
pLogSession->m_logSessionValues[Circular].Empty();
|
|
pLogSession->m_logSessionValues[Sequential].Empty();
|
|
}
|
|
|
|
if((m_retrievalArray[lParam] == GlobalSequence) &&
|
|
!pLogSession->m_logSessionValues[m_retrievalArray[lParam]].Compare(_T("TRUE"))) {
|
|
pLogSession->m_logSessionValues[LocalSequence] = _T("FALSE");
|
|
}
|
|
|
|
if((m_retrievalArray[lParam] == LocalSequence) &&
|
|
!pLogSession->m_logSessionValues[m_retrievalArray[lParam]].Compare(_T("TRUE"))) {
|
|
pLogSession->m_logSessionValues[GlobalSequence] = _T("FALSE");
|
|
}
|
|
|
|
if(pLogSession->m_bTraceActive) {
|
|
pLogSession->GetDisplayWnd()->UpdateSession(pLogSession);
|
|
}
|
|
|
|
//
|
|
// Restart updating the log session list control
|
|
//
|
|
m_displayCtrl.SuspendUpdates(FALSE);
|
|
|
|
UpdateSession(pLogSession);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CLogSessionDlg::OnNMClickDisplayList(NMHDR *pNMHDR, LRESULT *pResult)
|
|
{
|
|
CString str;
|
|
DWORD position;
|
|
int listIndex;
|
|
LVHITTESTINFO lvhti;
|
|
CRect itemRect;
|
|
CRect parentRect;
|
|
CLogSession *pLogSession;
|
|
|
|
// BUGBUG -- clean out uneeded str formats
|
|
|
|
*pResult = 0;
|
|
|
|
//
|
|
// Get the position of the mouse when this
|
|
// message posted
|
|
//
|
|
position = ::GetMessagePos();
|
|
|
|
//
|
|
// Get the position in an easy to use format
|
|
//
|
|
CPoint point((int) LOWORD (position), (int)HIWORD(position));
|
|
|
|
//
|
|
// Convert to client coordinates
|
|
//
|
|
ScreenToClient(&point);
|
|
|
|
lvhti.pt = point;
|
|
|
|
listIndex = m_displayCtrl.SubItemHitTest(&lvhti);
|
|
|
|
if(0 == lvhti.iSubItem) {
|
|
if(-1 == lvhti.iItem) {
|
|
//str.Format(_T("NM Click: Item = %d, Flags = 0x%X\n"), lvhti.iItem, lvhti.flags);
|
|
//TRACE(str);
|
|
} else {
|
|
//str.Format(_T("NM Click: Item = %d\n"), lvhti.iItem);
|
|
//TRACE(str);
|
|
}
|
|
} else if(-1 == lvhti.iItem) {
|
|
//str.Format(_T("NM Click: Item = %d, Flags = 0x%X\n"), lvhti.iItem, lvhti.flags);
|
|
//TRACE(str);
|
|
} else {
|
|
//str.Format(_T("NM Click: Item = %d, "), lvhti.iItem);
|
|
//TRACE(str);
|
|
//str.Format(_T("SubItem = %d\n"), lvhti.iSubItem);
|
|
//TRACE(str);
|
|
|
|
GetClientRect(&parentRect);
|
|
|
|
m_displayCtrl.GetSubItemRect(lvhti.iItem, lvhti.iSubItem, LVIR_BOUNDS, itemRect);
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
//
|
|
// Get the log session for this row
|
|
//
|
|
pLogSession = (CLogSession *)m_logSessionArray[lvhti.iItem];
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
if(pLogSession == NULL) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// State, EventCount, LostEvents, BuffersRead
|
|
//
|
|
if((m_retrievalArray[lvhti.iSubItem] == State) ||
|
|
(m_retrievalArray[lvhti.iSubItem] == EventCount) ||
|
|
(m_retrievalArray[lvhti.iSubItem] == LostEvents) ||
|
|
(m_retrievalArray[lvhti.iSubItem] == BuffersRead)) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Flags - special handling for Kernel Logger
|
|
//
|
|
if((m_retrievalArray[lvhti.iSubItem] == Flags) &&
|
|
!_tcscmp(pLogSession->GetDisplayName(), _T("NT Kernel Logger"))) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// MaxBuffers
|
|
//
|
|
if((m_retrievalArray[lvhti.iSubItem] == MaximumBuffers) &&
|
|
!pLogSession->m_bDisplayExistingLogFileOnly){
|
|
|
|
//
|
|
// Stop updating the log session list control until
|
|
// this control goes away. Otherwise, this control
|
|
// is disrupted. Updating is turned back on in the
|
|
// OnParameterChanged callback.
|
|
//
|
|
m_displayCtrl.SuspendUpdates(TRUE);
|
|
|
|
CEdit *pEdit = new CSubItemEdit(lvhti.iItem,
|
|
lvhti.iSubItem,
|
|
&m_displayCtrl);
|
|
|
|
pEdit->Create(WS_CHILD | WS_VISIBLE | WS_TABSTOP,
|
|
itemRect,
|
|
this,
|
|
IDC_CUSTOM_EDIT);
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// FlushTime
|
|
//
|
|
if((m_retrievalArray[lvhti.iSubItem] == FlushTime) &&
|
|
!pLogSession->m_bDisplayExistingLogFileOnly){
|
|
|
|
//
|
|
// Stop updating the log session list control until
|
|
// this control goes away. Otherwise, this control
|
|
// is disrupted. Updating is turned back on in the
|
|
// OnParameterChanged callback.
|
|
//
|
|
m_displayCtrl.SuspendUpdates(TRUE);
|
|
|
|
CEdit *pEdit = new CSubItemEdit(lvhti.iItem,
|
|
lvhti.iSubItem,
|
|
&m_displayCtrl);
|
|
|
|
pEdit->Create(WS_CHILD | WS_VISIBLE | WS_TABSTOP,
|
|
itemRect,
|
|
this,
|
|
IDC_CUSTOM_EDIT);
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Flags
|
|
//
|
|
if((m_retrievalArray[lvhti.iSubItem] == Flags) &&
|
|
!pLogSession->m_bDisplayExistingLogFileOnly){
|
|
|
|
//
|
|
// Stop updating the log session list control until
|
|
// this control goes away. Otherwise, this control
|
|
// is disrupted. Updating is turned back on in the
|
|
// OnParameterChanged callback.
|
|
//
|
|
m_displayCtrl.SuspendUpdates(TRUE);
|
|
|
|
CEdit *pEdit = new CSubItemEdit(lvhti.iItem,
|
|
lvhti.iSubItem,
|
|
&m_displayCtrl);
|
|
|
|
pEdit->Create(WS_CHILD | WS_VISIBLE | WS_TABSTOP,
|
|
itemRect,
|
|
this,
|
|
IDC_CUSTOM_EDIT);
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Global Sequence
|
|
//
|
|
if((m_retrievalArray[lvhti.iSubItem] == GlobalSequence) &&
|
|
!pLogSession->m_bTraceActive &&
|
|
!pLogSession->m_bDisplayExistingLogFileOnly) {
|
|
CComboBox *pCombo = new CSubItemCombo(lvhti.iItem,
|
|
lvhti.iSubItem,
|
|
&m_displayCtrl);
|
|
|
|
//
|
|
// Stop updating the log session list control until
|
|
// this control goes away. Otherwise, this control
|
|
// is disrupted. Updating is turned back on in the
|
|
// OnParameterChanged callback.
|
|
//
|
|
m_displayCtrl.SuspendUpdates(TRUE);
|
|
|
|
pCombo->Create(WS_BORDER|WS_CHILD|WS_VISIBLE|CBS_DROPDOWNLIST,
|
|
itemRect,
|
|
&m_displayCtrl,
|
|
IDC_CUSTOM_COMBO);
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Local Sequence
|
|
//
|
|
if((m_retrievalArray[lvhti.iSubItem] == LocalSequence) &&
|
|
!pLogSession->m_bTraceActive &&
|
|
!pLogSession->m_bDisplayExistingLogFileOnly) {
|
|
CComboBox *pCombo = new CSubItemCombo(lvhti.iItem,
|
|
lvhti.iSubItem,
|
|
&m_displayCtrl);
|
|
|
|
//
|
|
// Stop updating the log session list control until
|
|
// this control goes away. Otherwise, this control
|
|
// is disrupted. Updating is turned back on in the
|
|
// OnParameterChanged callback.
|
|
//
|
|
m_displayCtrl.SuspendUpdates(TRUE);
|
|
|
|
pCombo->Create(WS_BORDER|WS_CHILD|WS_VISIBLE|CBS_DROPDOWNLIST,
|
|
itemRect,
|
|
&m_displayCtrl,
|
|
IDC_CUSTOM_COMBO);
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// The Rest
|
|
//
|
|
if(!pLogSession->m_bTraceActive &&
|
|
!pLogSession->m_bDisplayExistingLogFileOnly) {
|
|
|
|
//
|
|
// Stop updating the log session list control until
|
|
// this control goes away. Otherwise, this control
|
|
// is disrupted. Updating is turned back on in the
|
|
// OnParameterChanged callback.
|
|
//
|
|
m_displayCtrl.SuspendUpdates(TRUE);
|
|
|
|
CEdit *pEdit = new CSubItemEdit(lvhti.iItem,
|
|
lvhti.iSubItem,
|
|
&m_displayCtrl);
|
|
|
|
pEdit->Create(WS_CHILD | WS_VISIBLE | WS_TABSTOP,
|
|
itemRect,
|
|
this,
|
|
IDC_CUSTOM_EDIT);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CLogSessionDlg::OnNMRclickDisplayList(NMHDR *pNMHDR, LRESULT *pResult)
|
|
{
|
|
CString str;
|
|
DWORD position;
|
|
int listIndex;
|
|
LVHITTESTINFO lvhti;
|
|
|
|
*pResult = 0;
|
|
|
|
//
|
|
// Get the position of the mouse when this
|
|
// message posted
|
|
//
|
|
position = ::GetMessagePos();
|
|
|
|
//
|
|
// Get the position in an easy to use format
|
|
//
|
|
CPoint point((int) LOWORD (position), (int)HIWORD(position));
|
|
|
|
CPoint screenPoint(point);
|
|
|
|
//
|
|
// Convert to client coordinates
|
|
//
|
|
ScreenToClient(&point);
|
|
|
|
lvhti.pt = point;
|
|
|
|
listIndex = m_displayCtrl.SubItemHitTest(&lvhti);
|
|
|
|
//
|
|
// Pop-up menu for log session creation
|
|
//
|
|
if(-1 == lvhti.iItem) {
|
|
CMenu menu;
|
|
menu.LoadMenu(IDR_LOG_SESSION_POPUP_MENU);
|
|
CMenu* pPopup = menu.GetSubMenu(0);
|
|
ASSERT(pPopup != NULL);
|
|
|
|
pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, screenPoint.x, screenPoint.y, AfxGetMainWnd());
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Pop-up menu for existing log session options
|
|
//
|
|
CMenu menu;
|
|
menu.LoadMenu(IDR_LOG_OPTIONS_POPUP_MENU);
|
|
|
|
CMenu* pPopup = menu.GetSubMenu(0);
|
|
ASSERT(pPopup != NULL);
|
|
|
|
pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, screenPoint.x, screenPoint.y, AfxGetMainWnd());
|
|
return;
|
|
}
|
|
|
|
void CLogSessionDlg::OnHDNRclickDisplayList(NMHDR *pNMHDR, LRESULT *pResult)
|
|
{
|
|
int index;
|
|
CRect rcCol;
|
|
BOOL bActiveSession = FALSE;
|
|
CLogSession *pLogSession;
|
|
LONG numberOfEntries;
|
|
|
|
//
|
|
// Get the log session array protection
|
|
//
|
|
WaitForSingleObject(m_logSessionArrayMutex, INFINITE);
|
|
|
|
if(m_logSessionArray.GetSize() == 0) {
|
|
*pResult = 0;
|
|
}
|
|
|
|
for(LONG ii = 0; ii < m_logSessionArray.GetSize(); ii++) {
|
|
pLogSession = (CLogSession *)m_logSessionArray[ii];
|
|
|
|
if(NULL != pLogSession) {
|
|
bActiveSession = TRUE;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Release the log session array protection
|
|
//
|
|
ReleaseMutex(m_logSessionArrayMutex);
|
|
|
|
if(!bActiveSession) {
|
|
*pResult = 0;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Right button was clicked on header
|
|
//
|
|
CPoint pt(GetMessagePos());
|
|
CPoint screenPt(GetMessagePos());
|
|
|
|
CHeaderCtrl *pHeader = m_displayCtrl.GetHeaderCtrl();
|
|
|
|
pHeader->ScreenToClient(&pt);
|
|
|
|
//
|
|
// Determine the column index
|
|
//
|
|
for(int i=0; Header_GetItemRect(pHeader->m_hWnd, i, &rcCol); i++) {
|
|
if(rcCol.PtInRect(pt)) {
|
|
//
|
|
// Column index if its ever needed
|
|
//
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
CMenu menu;
|
|
|
|
menu.LoadMenu(IDR_LOG_DISPLAY_OPTIONS_POPUP_MENU);
|
|
|
|
CMenu *pPopup = menu.GetSubMenu(0);
|
|
ASSERT(pPopup != NULL);
|
|
|
|
pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, screenPt.x, screenPt.y, AfxGetMainWnd());
|
|
|
|
*pResult = 0;
|
|
}
|
|
|
|
void CLogSessionDlg::AutoSizeColumns()
|
|
{
|
|
LONG colWidth1;
|
|
LONG colWidth2;
|
|
LONG columnCount;
|
|
CHeaderCtrl *pHeaderCtrl;
|
|
|
|
//
|
|
// Call this after the list control is filled
|
|
//
|
|
pHeaderCtrl = m_displayCtrl.GetHeaderCtrl();
|
|
|
|
if (pHeaderCtrl != NULL)
|
|
{
|
|
columnCount = pHeaderCtrl->GetItemCount();
|
|
|
|
//
|
|
// Add a bogus column to the end, or the end column will
|
|
// get resized to fit the remaining screen width
|
|
//
|
|
m_displayCtrl.InsertColumn(columnCount,_T(""));
|
|
|
|
for(LONG ii = 0; ii < columnCount; ii++) {
|
|
//
|
|
// Get the max width of the column entries
|
|
//
|
|
m_displayCtrl.SetColumnWidth(ii, LVSCW_AUTOSIZE);
|
|
colWidth1 = m_displayCtrl.GetColumnWidth(ii);
|
|
|
|
//
|
|
// Get the width of the column header
|
|
//
|
|
m_displayCtrl.SetColumnWidth(ii, LVSCW_AUTOSIZE_USEHEADER);
|
|
colWidth2 = m_displayCtrl.GetColumnWidth(ii);
|
|
|
|
//
|
|
// Set the column width to the max of the two
|
|
//
|
|
m_displayCtrl.SetColumnWidth(ii, max(colWidth1,colWidth2));
|
|
}
|
|
|
|
//
|
|
// Remove the bogus column
|
|
//
|
|
m_displayCtrl.DeleteColumn(columnCount);
|
|
}
|
|
}
|
|
|
|
LONG CLogSessionDlg::GetDisplayWndID()
|
|
{
|
|
for(LONG ii = 0; ii < MAX_LOG_SESSIONS; ii++) {
|
|
if(FALSE == m_displayWndIDList[ii]) {
|
|
m_displayWndIDList[ii] = TRUE;
|
|
return ii;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
VOID CLogSessionDlg::ReleaseDisplayWndID(CDisplayDlg *pDisplayDlg)
|
|
{
|
|
LONG displayID;
|
|
|
|
displayID = pDisplayDlg->GetDisplayID();
|
|
|
|
ASSERT(displayID < MAX_LOG_SESSIONS);
|
|
|
|
//
|
|
// Free the ID to be reused
|
|
//
|
|
m_displayWndIDList[displayID] = FALSE;
|
|
}
|
|
|
|
LONG CLogSessionDlg::GetLogSessionID()
|
|
{
|
|
for(LONG ii = 0; ii < MAX_LOG_SESSIONS; ii++) {
|
|
if(FALSE == m_logSessionIDList[ii]) {
|
|
m_logSessionIDList[ii] = TRUE;
|
|
return ii;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
VOID CLogSessionDlg::ReleaseLogSessionID(CLogSession *pLogSession)
|
|
{
|
|
LONG sessionID;
|
|
|
|
sessionID = pLogSession->GetLogSessionID();
|
|
|
|
ASSERT(sessionID < MAX_LOG_SESSIONS);
|
|
|
|
//
|
|
// Free the ID to be reused
|
|
//
|
|
m_logSessionIDList[sessionID] = FALSE;
|
|
}
|