mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3154 lines
81 KiB
3154 lines
81 KiB
//
|
|
// CApplicationWindow.CPP
|
|
//
|
|
// Application Window Class
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include <commctrl.h>
|
|
#include <shellapi.h>
|
|
#include "commdlg.h"
|
|
#include "resource.h"
|
|
#include "CApplicationWindow.h"
|
|
#include "CFindDialog.h"
|
|
|
|
#define CAPPLICATIONWINDOWCLASS TEXT("CApplicationWindowClass")
|
|
#define WINDOWMENU 1
|
|
|
|
BOOL g_fCApplicationWindowClassRegistered = FALSE;
|
|
BOOL g_fCApplicationWindowDestroyed = FALSE;
|
|
|
|
// these are used to track the next occurrence of the phrases
|
|
LPTSTR g_pszDispatch;
|
|
LPTSTR g_pszDispatch2;
|
|
LPTSTR g_pszCompleted;
|
|
|
|
//
|
|
// Constructor
|
|
//
|
|
CApplicationWindow::CApplicationWindow( )
|
|
{
|
|
BOOL b;
|
|
LPTSTR psz;
|
|
LONG sx = GetSystemMetrics( SM_CXFULLSCREEN );
|
|
LPTSTR lpCmdLine;
|
|
|
|
Cleanup( TRUE );
|
|
|
|
if ( !g_fCApplicationWindowClassRegistered )
|
|
{
|
|
WNDCLASSEX wcex;
|
|
|
|
wcex.cbSize = sizeof(WNDCLASSEX);
|
|
wcex.style = CS_HREDRAW | CS_VREDRAW;
|
|
wcex.lpfnWndProc = (WNDPROC)CApplicationWindow::WndProc;
|
|
wcex.cbClsExtra = 0;
|
|
wcex.cbWndExtra = 0;
|
|
wcex.hInstance = g_hInstance;
|
|
wcex.hIcon = LoadIcon(g_hInstance, (LPCTSTR) IDI_CLUSLOG );
|
|
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wcex.hbrBackground = (HBRUSH) COLOR_GRAYTEXT; //NULL;
|
|
wcex.lpszMenuName = (LPCSTR)IDC_SOL;
|
|
wcex.lpszClassName = CAPPLICATIONWINDOWCLASS;
|
|
wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR) IDI_SMALL );
|
|
|
|
RegisterClassEx(&wcex);
|
|
}
|
|
|
|
HANDLE hFile;
|
|
|
|
hFile = CreateFile( "filter.txt",
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL );
|
|
if ( hFile != INVALID_HANDLE_VALUE )
|
|
{
|
|
LONG nLength = GetFileSize( hFile, NULL );
|
|
|
|
nLength++; // one for NULL
|
|
|
|
g_pszFilters = (LPTSTR) LocalAlloc( LPTR, nLength );
|
|
if ( g_pszFilters )
|
|
{
|
|
DWORD dwRead; // dummy
|
|
ReadFile( hFile, g_pszFilters, nLength, &dwRead, NULL );
|
|
|
|
g_pszFilters[nLength-1] = 0;
|
|
|
|
CloseHandle( hFile );
|
|
|
|
g_nComponentFilters = 0;
|
|
psz = g_pszFilters;
|
|
while ( psz < &g_pszFilters[nLength-1] )
|
|
{
|
|
LPTSTR pszStart = psz;
|
|
while ( *psz && *psz != 13 )
|
|
{
|
|
psz++;
|
|
}
|
|
|
|
psz += 2;
|
|
|
|
g_nComponentFilters++;
|
|
}
|
|
|
|
g_pfSelectedComponent = (BOOL*) LocalAlloc( LPTR, g_nComponentFilters * sizeof(BOOL) );
|
|
}
|
|
}
|
|
|
|
_hWnd = CreateWindowEx( WS_EX_ACCEPTFILES,
|
|
CAPPLICATIONWINDOWCLASS,
|
|
TEXT("Cluster Log Analyzer"),
|
|
WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS,
|
|
CW_USEDEFAULT,
|
|
CW_USEDEFAULT,
|
|
CW_USEDEFAULT,
|
|
CW_USEDEFAULT,
|
|
NULL,
|
|
NULL,
|
|
g_hInstance,
|
|
(LPVOID) this);
|
|
if (!_hWnd)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_hMenu = CreatePopupMenu( );
|
|
|
|
MENUITEMINFO mii;
|
|
ZeroMemory( &mii, sizeof(mii) );
|
|
mii.cbSize = sizeof(mii);
|
|
mii.fMask = MIIM_STRING | MIIM_STATE | MIIM_ID;
|
|
mii.fState = MFS_CHECKED;
|
|
mii.wID = IDM_FIRST_CS_FILTER ;
|
|
|
|
psz = g_pszFilters;
|
|
if ( psz )
|
|
{
|
|
while ( *psz && mii.wID < IDM_LAST_CS_FILTER )
|
|
{
|
|
mii.dwTypeData = psz;
|
|
while ( *psz && *psz != 13 )
|
|
{
|
|
psz++;
|
|
}
|
|
if ( *psz == 13 )
|
|
{
|
|
*psz = 0;
|
|
psz++;
|
|
if ( *psz )
|
|
{
|
|
psz++;
|
|
}
|
|
}
|
|
mii.wID++;
|
|
mii.cch = (UINT)(psz - mii.dwTypeData);
|
|
b = InsertMenuItem( _hMenu, -1, TRUE, &mii );
|
|
}
|
|
}
|
|
|
|
HMENU hMenu = GetSubMenu( GetMenu( _hWnd ), 2 );
|
|
b = AppendMenu( hMenu, MF_POPUP, (UINT_PTR) _hMenu, "&Cluster Service" );
|
|
|
|
DrawMenuBar( _hWnd );
|
|
|
|
ShowWindow( _hWnd, SW_SHOW );
|
|
UpdateWindow( _hWnd );
|
|
|
|
lpCmdLine = GetCommandLine( );
|
|
if ( lpCmdLine )
|
|
{
|
|
if ( lpCmdLine[0] == '\"' )
|
|
{
|
|
lpCmdLine++;
|
|
while ( *lpCmdLine && *lpCmdLine != '\"' )
|
|
{
|
|
lpCmdLine++;
|
|
}
|
|
if ( *lpCmdLine )
|
|
{
|
|
lpCmdLine++;
|
|
}
|
|
if ( *lpCmdLine )
|
|
{
|
|
lpCmdLine++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while ( *lpCmdLine && *lpCmdLine != 32 )
|
|
{
|
|
lpCmdLine++;
|
|
}
|
|
if ( *lpCmdLine )
|
|
{
|
|
lpCmdLine++;
|
|
}
|
|
}
|
|
while ( lpCmdLine[0] )
|
|
{
|
|
LPSTR psz = strchr( lpCmdLine, 32 );
|
|
if ( psz )
|
|
{
|
|
*psz = 0;
|
|
}
|
|
|
|
if ( lpCmdLine[1] != ':'
|
|
&& lpCmdLine[1] != '\\' )
|
|
{
|
|
LPTSTR pszFilename = (LPTSTR)
|
|
LocalAlloc( LMEM_FIXED, MAX_PATH * sizeof(TCHAR) );
|
|
if ( pszFilename )
|
|
{
|
|
DWORD dwRead;
|
|
|
|
dwRead = GetCurrentDirectory( MAX_PATH, pszFilename );
|
|
if ( dwRead >= MAX_PATH )
|
|
{
|
|
LocalFree( pszFilename );
|
|
|
|
pszFilename = (LPTSTR)
|
|
LocalAlloc( LMEM_FIXED,
|
|
( dwRead + MAX_PATH ) * sizeof(TCHAR) );
|
|
if ( pszFilename )
|
|
{
|
|
dwRead = GetCurrentDirectory( MAX_PATH, pszFilename );
|
|
}
|
|
}
|
|
|
|
if ( pszFilename
|
|
&& dwRead != 0 )
|
|
{
|
|
strcat( pszFilename, TEXT("\\") );
|
|
strcat( pszFilename, lpCmdLine );
|
|
_LoadFile( pszFilename );
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( *lpCmdLine )
|
|
{
|
|
_LoadFile( lpCmdLine );
|
|
}
|
|
|
|
lpCmdLine += lstrlen( lpCmdLine );
|
|
if ( psz )
|
|
{
|
|
lpCmdLine++;
|
|
*psz = 32;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Destructor
|
|
//
|
|
CApplicationWindow::~CApplicationWindow( )
|
|
{
|
|
Cleanup( );
|
|
ShowWindow( _hWnd, SW_HIDE );
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
HRESULT
|
|
CApplicationWindow::Cleanup(
|
|
BOOL fInitializing // = FALSE
|
|
)
|
|
{
|
|
if ( !fInitializing )
|
|
{
|
|
for( ULONG nFile = 0; nFile < _nFiles; nFile++ )
|
|
{
|
|
LocalFree( _pFiles[ nFile ] );
|
|
LocalFree( _pszFilenames[ nFile ] );
|
|
LocalFree( _pNodes[ nFile ] );
|
|
}
|
|
}
|
|
|
|
_nFiles = 0;
|
|
_cTotalLineCount = 0;
|
|
_fVertSBVisible = FALSE;
|
|
_uStartSelection = 0;
|
|
_uEndSelection = 0;
|
|
_uPointer = 0;
|
|
_pLines = 0;
|
|
|
|
ZeroMemory( &_LineFinder, sizeof(_LineFinder) );
|
|
_uFinderLength = 0;
|
|
|
|
ShowScrollBar( _hWnd, SB_VERT, FALSE );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// _CalculateOffset( )
|
|
//
|
|
HRESULT
|
|
CApplicationWindow::_CalculateOffset(
|
|
FILETIME * pftOper1,
|
|
FILETIME * pftOper2,
|
|
INT * pnDir,
|
|
FILETIME * pftOffset
|
|
)
|
|
{
|
|
*pnDir = CompareFileTime( pftOper1, pftOper2 );
|
|
if ( *pnDir > 0 )
|
|
{
|
|
pftOffset->dwHighDateTime = pftOper1->dwHighDateTime - pftOper2->dwHighDateTime;
|
|
pftOffset->dwLowDateTime = pftOper1->dwLowDateTime - pftOper2->dwLowDateTime;
|
|
if ( pftOper1->dwLowDateTime < pftOper2->dwLowDateTime )
|
|
{
|
|
pftOffset->dwHighDateTime++;
|
|
}
|
|
}
|
|
else if ( *pnDir < 0 )
|
|
{
|
|
pftOffset->dwHighDateTime = pftOper2->dwHighDateTime - pftOper1->dwHighDateTime;
|
|
pftOffset->dwLowDateTime = pftOper2->dwLowDateTime - pftOper1->dwLowDateTime;
|
|
if ( pftOper1->dwLowDateTime > pftOper2->dwLowDateTime )
|
|
{
|
|
pftOffset->dwHighDateTime--;
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// _FindSequencePoint( )
|
|
//
|
|
BOOL
|
|
CApplicationWindow::_FindSequencePoint(
|
|
LPTSTR * ppszSequence,
|
|
ULONG * pnSequence
|
|
)
|
|
{
|
|
|
|
while( *ppszSequence )
|
|
{
|
|
if ( *ppszSequence > g_pszDispatch )
|
|
{
|
|
g_pszDispatch = strstr( *ppszSequence, "dispatching seq " ) - 1;
|
|
}
|
|
if ( *ppszSequence > g_pszCompleted )
|
|
{
|
|
g_pszCompleted = strstr( *ppszSequence, "completed update seq " ) - 1;
|
|
}
|
|
if ( *ppszSequence > g_pszDispatch2 )
|
|
{
|
|
g_pszDispatch2 = strstr( *ppszSequence, "Dispatching seq " ) - 1;
|
|
}
|
|
|
|
if ( g_pszDispatch < g_pszCompleted )
|
|
{
|
|
(*ppszSequence) = g_pszDispatch + sizeof("dispatching seq ") - 1;
|
|
if ( pnSequence )
|
|
{
|
|
*pnSequence = atol ( *ppszSequence );
|
|
(*pnSequence) *= 3;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( g_pszDispatch2 < g_pszCompleted )
|
|
{
|
|
(*ppszSequence) = g_pszDispatch2 + sizeof("Dispatching seq ") - 1;
|
|
if ( pnSequence )
|
|
{
|
|
*pnSequence = atol ( *ppszSequence );
|
|
(*pnSequence) *= 3;
|
|
(*pnSequence)++;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( g_pszCompleted + 1 != NULL )
|
|
{
|
|
(*ppszSequence) = g_pszCompleted + sizeof("completed update seq ") - 1;
|
|
if ( pnSequence )
|
|
{
|
|
*pnSequence = atol ( *ppszSequence );
|
|
(*pnSequence) *= 3;
|
|
(*pnSequence)++;
|
|
(*pnSequence)++;
|
|
}
|
|
break;
|
|
}
|
|
|
|
*ppszSequence = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// _RetrieveTimeDate( )
|
|
//
|
|
HRESULT
|
|
CApplicationWindow::_RetrieveTimeDate(
|
|
LPTSTR pszCurrent,
|
|
SYSTEMTIME * pst,
|
|
LPTSTR * ppszFinal
|
|
)
|
|
{
|
|
if ( ppszFinal )
|
|
{
|
|
*ppszFinal = pszCurrent;
|
|
}
|
|
|
|
// Find the thread and process IDs
|
|
while ( *pszCurrent && *pszCurrent != ':' && *pszCurrent != 10 )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent != ':' )
|
|
return S_FALSE;
|
|
|
|
pszCurrent++;
|
|
if ( *pszCurrent != ':' )
|
|
return S_FALSE;
|
|
|
|
pszCurrent++;
|
|
|
|
// Find Time/Date stamp which is:
|
|
// ####/##/##-##:##:##.###<space>
|
|
pst->wYear = (WORD) atol( pszCurrent );
|
|
|
|
while ( *pszCurrent >= '0' && *pszCurrent <= '9' )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent == '-' )
|
|
{
|
|
//
|
|
// The "year" we got above should really be the day.
|
|
// We'll replace the year with zero and the month with one.
|
|
//
|
|
pst->wDay = pst->wYear;
|
|
pst->wYear = 0;
|
|
pst->wMonth = 1;
|
|
goto SkipDate;
|
|
}
|
|
if ( *pszCurrent != '/' )
|
|
return S_FALSE;
|
|
|
|
pszCurrent++;
|
|
|
|
pst->wMonth = (WORD) atol( pszCurrent );
|
|
|
|
while ( *pszCurrent >= '0' && *pszCurrent <= '9' )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent != '/' )
|
|
return S_FALSE;
|
|
|
|
pszCurrent++;
|
|
|
|
pst->wDay = (WORD) atol( pszCurrent );
|
|
|
|
while ( *pszCurrent >= '0' && *pszCurrent <= '9' )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent != '-' )
|
|
return S_FALSE;
|
|
|
|
SkipDate:
|
|
pszCurrent++;
|
|
|
|
pst->wHour = (WORD) atol( pszCurrent );
|
|
|
|
while ( *pszCurrent >= '0' && *pszCurrent <= '9' )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent != ':' )
|
|
return S_FALSE;
|
|
|
|
pszCurrent++;
|
|
|
|
pst->wMinute = (WORD) atol( pszCurrent );
|
|
|
|
while ( *pszCurrent >= '0' && *pszCurrent <= '9' )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent != ':' )
|
|
return S_FALSE;
|
|
|
|
pszCurrent++;
|
|
|
|
pst->wSecond = (WORD) atol( pszCurrent );
|
|
|
|
while ( *pszCurrent >= '0' && *pszCurrent <= '9' )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent != '.' )
|
|
return S_FALSE;
|
|
|
|
pszCurrent++;
|
|
|
|
pst->wMilliseconds = (WORD) atol( pszCurrent );
|
|
|
|
while ( *pszCurrent >= '0' && *pszCurrent <= '9' )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
|
|
if ( ppszFinal )
|
|
{
|
|
*ppszFinal = pszCurrent;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// _GetFilename( )
|
|
//
|
|
HRESULT
|
|
CApplicationWindow::_GetFilename(
|
|
LPTSTR pszFilename,
|
|
LPTSTR pszFilenameOut,
|
|
LONG * pcch
|
|
)
|
|
{
|
|
LONG cch = 0;
|
|
|
|
if ( g_fShowServerNames && pszFilename[ 0 ] == '\\' && pszFilename[ 1 ] == '\\' )
|
|
{
|
|
LPTSTR psz = &pszFilename[ 2 ];
|
|
while ( *psz && *psz != '\\' )
|
|
{
|
|
psz++;
|
|
cch++;
|
|
}
|
|
psz--;
|
|
cch += 2;
|
|
}
|
|
else if ( strchr( pszFilename, '\\' ) )
|
|
{
|
|
pszFilename = pszFilename + lstrlen( pszFilename );
|
|
while ( *pszFilename != '\\' )
|
|
{
|
|
pszFilename--;
|
|
cch++;
|
|
}
|
|
pszFilename++;
|
|
cch--;
|
|
}
|
|
else
|
|
{
|
|
cch = lstrlen( pszFilename );
|
|
}
|
|
|
|
if ( pszFilenameOut )
|
|
{
|
|
if ( !pcch )
|
|
return E_POINTER;
|
|
|
|
if ( cch >= *pcch )
|
|
{
|
|
cch = *pcch - 1;
|
|
}
|
|
strncpy( pszFilenameOut, pszFilename, cch );
|
|
pszFilenameOut[ cch ] = 0;
|
|
}
|
|
if ( pcch )
|
|
{
|
|
*pcch = cch;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// _StatusWndProc( )
|
|
//
|
|
LRESULT CALLBACK
|
|
CApplicationWindow::_StatusWndProc(
|
|
HWND hWnd,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
//
|
|
// _CombineFiles( )
|
|
//
|
|
HRESULT
|
|
CApplicationWindow::_CombineFiles( )
|
|
{
|
|
HRESULT hr; // general purpose HRESULT and return code
|
|
BOOL b; // general purpose return BOOL
|
|
ULONG nFileLineCount; // counter of the lines in the file
|
|
ULONG nSequence; // ID of current sequence
|
|
ULONG nNextSequence; // ID of the next squence
|
|
LPTSTR pszSequence; // next sequence location
|
|
LPTSTR pszCurrent; // current parse location within file
|
|
BOOL fSyncPoint; // flag indicating a sync point was encountered
|
|
SYSTEMTIME st; // used to convert "line time" to a filetime.
|
|
FILETIME ft; // current lines filetime
|
|
FILETIME ftOffset; // current filetime offset
|
|
INT nDir; // offset direction
|
|
|
|
MSG msg; // message pumping
|
|
HWND hwndProcessing; // processing window handle
|
|
HWND hwndStatus; // progress bar window handle
|
|
|
|
SCROLLINFO si; // verticle scroll bar
|
|
|
|
LINEPOINTER * pLastSyncPoint; // last place a sync point in other files was encountered
|
|
LINEPOINTER * pInsertionPoint; // next place a node will be inserted
|
|
LINEPOINTER * pNewLine; // next structure to be used as a node
|
|
|
|
CWaitCursor Wait; // show the hour glass
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_RANGE | SIF_PAGE;
|
|
GetScrollInfo( _hWnd, SB_VERT, &si );
|
|
si.fMask = SIF_RANGE;
|
|
|
|
ZeroMemory( &ftOffset, sizeof(ftOffset) );
|
|
nDir = 0;
|
|
g_pszDispatch = NULL;
|
|
g_pszDispatch2 = NULL;
|
|
g_pszCompleted = NULL;
|
|
|
|
// scan to figure out the line count of the new file
|
|
nFileLineCount = 0;
|
|
pszCurrent = _pFiles[ _nFiles ];
|
|
while ( *pszCurrent )
|
|
{
|
|
if ( *pszCurrent == 10 )
|
|
{
|
|
nFileLineCount++;
|
|
}
|
|
|
|
pszCurrent++;
|
|
}
|
|
|
|
if ( !_pLines )
|
|
{
|
|
// add one more for the root node
|
|
nFileLineCount++;
|
|
}
|
|
|
|
// allocate all the memory up front to avoid fragmenting memory as well as
|
|
// descreasing the number of heap calls
|
|
_pNodes[ _nFiles ] = (LINEPOINTER *) LocalAlloc( LMEM_FIXED, nFileLineCount * sizeof(LINEPOINTER) );
|
|
if ( !_pNodes[ _nFiles ] )
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
pNewLine = _pNodes[ _nFiles ];
|
|
|
|
if ( !_pLines )
|
|
{
|
|
_pLines = pNewLine;
|
|
ZeroMemory( _pLines, sizeof(LINEPOINTER) );
|
|
pNewLine++;
|
|
}
|
|
|
|
// Create wait modeless dialog
|
|
hwndProcessing = CreateDialog( g_hInstance,
|
|
MAKEINTRESOURCE(IDD_PROCESSING),
|
|
_hWnd,
|
|
(DLGPROC) CApplicationWindow::_StatusWndProc );
|
|
|
|
hwndStatus = GetDlgItem( hwndProcessing, IDC_P_STATUS );
|
|
SendMessage( hwndStatus, PBM_SETRANGE32, 0, nFileLineCount );
|
|
SendMessage( hwndStatus, PBM_SETPOS, 0, 0 );
|
|
SendMessage( hwndStatus, PBM_SETSTEP, 1, 0 );
|
|
SetWindowText( GetDlgItem( hwndProcessing, IDC_S_FILENAME ), _pszFilenames[ _nFiles ] );
|
|
|
|
// Find the first sync point
|
|
nNextSequence = nSequence = 0;
|
|
pszSequence = _pFiles[ _nFiles ];
|
|
if ( _FindSequencePoint( &pszSequence, &nNextSequence ) )
|
|
{
|
|
RetrySequencing:
|
|
if ( _nFiles )
|
|
{
|
|
LINEPOINTER * lp = _pLines;
|
|
while ( lp->pNext
|
|
&& nNextSequence != lp->uSequenceNumber )
|
|
{
|
|
lp = lp->pNext;
|
|
// pump some messages....
|
|
if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
|
|
{
|
|
if ( !IsDialogMessage( g_hwndFind, &msg ) )
|
|
{
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
if ( g_fCApplicationWindowDestroyed )
|
|
{
|
|
return E_FAIL; // not break!
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( nNextSequence == lp->uSequenceNumber )
|
|
{
|
|
pszCurrent = pszSequence;
|
|
while( pszCurrent >= _pFiles[ _nFiles ] && *pszCurrent != 10 )
|
|
{
|
|
pszCurrent--;
|
|
}
|
|
|
|
pszCurrent++;
|
|
|
|
hr = _RetrieveTimeDate( pszCurrent, &st, NULL );
|
|
b = SystemTimeToFileTime( &st, &ft );
|
|
_CalculateOffset( &ft, &lp->Time, &nDir, &ftOffset );
|
|
|
|
nSequence = nNextSequence - 1;
|
|
}
|
|
else
|
|
{
|
|
if ( _FindSequencePoint( &pszSequence, &nNextSequence ) )
|
|
goto RetrySequencing;
|
|
|
|
nNextSequence = nSequence = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nSequence = nNextSequence - 1;
|
|
}
|
|
}
|
|
|
|
nFileLineCount = 1;
|
|
pszCurrent = _pFiles[ _nFiles ];
|
|
pInsertionPoint = _pLines;
|
|
|
|
while ( *pszCurrent )
|
|
{
|
|
LPTSTR pszStart = pszCurrent;
|
|
|
|
// this will parse past the PID.TID and Time/Date
|
|
hr = _RetrieveTimeDate( pszCurrent, &st, &pszCurrent );
|
|
|
|
b = SystemTimeToFileTime( &st, &ft );
|
|
|
|
// skip spaces
|
|
while ( *pszCurrent == 32)
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
|
|
// fill in preliminary info
|
|
pNewLine->fFiltered = FALSE;
|
|
pNewLine->nFile = _nFiles;
|
|
pNewLine->nLine = nFileLineCount;
|
|
pNewLine->psLine = pszStart;
|
|
|
|
// note warning level of line
|
|
//
|
|
if ( _stricmp( "INFO", pszCurrent ))
|
|
{
|
|
pNewLine->WarnLevel = WarnLevelInfo;
|
|
}
|
|
else if ( _stricmp( "WARN", pszCurrent ))
|
|
{
|
|
pNewLine->WarnLevel = WarnLevelWarn;
|
|
}
|
|
else if ( _stricmp( "ERR ", pszCurrent ))
|
|
{
|
|
pNewLine->WarnLevel = WarnLevelError;
|
|
}
|
|
else
|
|
{
|
|
pNewLine->WarnLevel = WarnLevelUnknown;
|
|
}
|
|
|
|
if ( pNewLine->WarnLevel != WarnLevelUnknown )
|
|
{
|
|
// skip chars, then spaces only if we found the tag
|
|
while ( *pszCurrent != 32)
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
while ( *pszCurrent == 32)
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
}
|
|
|
|
// [OPTIONAL] Cluster component which looks like:
|
|
// [<id...>]
|
|
if ( *pszCurrent == '[' )
|
|
{
|
|
LPTSTR pszComponentTag = pszCurrent;
|
|
|
|
while ( *pszCurrent && *pszCurrent != ']' && *pszCurrent >= 32 )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent < 32 )
|
|
{
|
|
pszCurrent = pszComponentTag;
|
|
goto NoComponentTryResouce;
|
|
}
|
|
|
|
pszCurrent++;
|
|
|
|
// found component
|
|
USHORT nFilterId = 0;
|
|
LONG nLen = (LONG)(pszCurrent - pszComponentTag - 2);
|
|
LPTSTR psz = g_pszFilters;
|
|
while ( nFilterId < g_nComponentFilters )
|
|
{
|
|
if ( nLen == lstrlen( psz )
|
|
&& _strnicmp( pszComponentTag + 1, psz, nLen ) == 0 )
|
|
{
|
|
pNewLine->nFilterId = nFilterId + 1;
|
|
if ( g_pfSelectedComponent[ nFilterId ] )
|
|
{
|
|
pNewLine->fFiltered = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
while ( *psz )
|
|
{
|
|
psz++;
|
|
}
|
|
psz += 2;
|
|
|
|
nFilterId++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// [OPTIONAL] If not a component, see if there is a res type
|
|
NoComponentTryResouce:
|
|
LPTSTR pszResType = pszCurrent;
|
|
|
|
while ( *pszCurrent && *pszCurrent != ':' && *pszCurrent >= 32 )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
|
|
if ( *pszCurrent >= 32 )
|
|
{
|
|
pszCurrent++;
|
|
|
|
// found a restype
|
|
pNewLine->nFilterId = g_nComponentFilters + 1; // TODO: make more dynamic
|
|
if ( g_fResourceNoise )
|
|
{
|
|
pNewLine->fFiltered = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find the beggining of the next line
|
|
while ( *pszCurrent && *pszCurrent != 10 )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
|
|
// See if we just past a sync point
|
|
if ( pszSequence && pszCurrent > pszSequence )
|
|
{
|
|
fSyncPoint = TRUE;
|
|
nSequence = nNextSequence;
|
|
|
|
// find the next sync point
|
|
_FindSequencePoint( &pszSequence, &nNextSequence );
|
|
if ( _nFiles )
|
|
{
|
|
// if we are out of sync, move the insertion point ahead
|
|
if ( pInsertionPoint->pNext != NULL
|
|
&& nSequence >= pInsertionPoint->uSequenceNumber )
|
|
{
|
|
for( pLastSyncPoint = pInsertionPoint; pLastSyncPoint->pNext; pLastSyncPoint = pLastSyncPoint->pNext )
|
|
{
|
|
if ( pLastSyncPoint->nFile != _nFiles
|
|
&& ( nSequence < pLastSyncPoint->uSequenceNumber
|
|
|| ( pLastSyncPoint->fSyncPoint
|
|
&& nSequence == pLastSyncPoint->uSequenceNumber ) ) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( pLastSyncPoint
|
|
&& pLastSyncPoint->pNext
|
|
&& nSequence == pLastSyncPoint->uSequenceNumber )
|
|
{
|
|
pInsertionPoint = pLastSyncPoint;
|
|
_CalculateOffset( &ft, &pInsertionPoint->Time, &nDir, &ftOffset );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fSyncPoint = FALSE;
|
|
}
|
|
|
|
// adjust time to compensate for time deviations
|
|
if ( nDir > 0 )
|
|
{ // if we are ahead, subtract
|
|
if ( ft.dwLowDateTime - ftOffset.dwLowDateTime > ft.dwLowDateTime )
|
|
{
|
|
ft.dwHighDateTime--;
|
|
}
|
|
ft.dwLowDateTime -= ftOffset.dwLowDateTime;
|
|
ft.dwHighDateTime -= ftOffset.dwHighDateTime;
|
|
}
|
|
else if ( nDir < 0 )
|
|
{ // if we are behind, add
|
|
if ( ft.dwLowDateTime + ftOffset.dwLowDateTime < ft.dwLowDateTime )
|
|
{
|
|
ft.dwHighDateTime++;
|
|
}
|
|
ft.dwLowDateTime += ftOffset.dwLowDateTime;
|
|
ft.dwHighDateTime += ftOffset.dwHighDateTime;
|
|
}
|
|
// else if nDir == 0, nothing to do
|
|
|
|
#if defined(_DEBUG) && defined(VERIFY_SYNC_POINTS)
|
|
if ( fSyncPoint && _nFiles != 0 )
|
|
{
|
|
INT n = CompareFileTime( &ft, &pInsertionPoint->Time );
|
|
if ( n != 0 )
|
|
{
|
|
DebugBreak( );
|
|
}
|
|
}
|
|
#endif // defined(_DEBUG) && defined(VERIFY_SYNC_POINTS)
|
|
|
|
// Find the place to insert it
|
|
while( pInsertionPoint->pNext )
|
|
{
|
|
if ( nSequence < pInsertionPoint->pNext->uSequenceNumber
|
|
&& pInsertionPoint->pNext->nFile != _nFiles )
|
|
{
|
|
break;
|
|
}
|
|
INT n = CompareFileTime( &ft, &pInsertionPoint->pNext->Time );
|
|
if ( n < 0 )
|
|
break;
|
|
pInsertionPoint = pInsertionPoint->pNext;
|
|
}
|
|
|
|
// fill-in rest of the LINEPOINTER structure
|
|
pNewLine->Time = ft;
|
|
pNewLine->fSyncPoint = fSyncPoint;
|
|
pNewLine->uSequenceNumber = nSequence;
|
|
|
|
// insert node into line list
|
|
pNewLine->pNext = pInsertionPoint->pNext;
|
|
pNewLine->pPrev = pInsertionPoint;
|
|
if ( pInsertionPoint->pNext != NULL )
|
|
{
|
|
pInsertionPoint->pNext->pPrev = pNewLine;
|
|
}
|
|
pInsertionPoint->pNext = pNewLine;
|
|
pInsertionPoint = pNewLine;
|
|
pNewLine++;
|
|
|
|
// dump line counts
|
|
nFileLineCount++;
|
|
_cTotalLineCount++;
|
|
|
|
// synchonize the scroll bar, don't redraw it
|
|
if ( _cTotalLineCount > 100 && _cTotalLineCount > si.nPage )
|
|
{
|
|
si.nMax = _cTotalLineCount;
|
|
SetScrollInfo( _hWnd, SB_VERT, &si, FALSE );
|
|
}
|
|
|
|
SendMessage( hwndStatus, PBM_STEPIT, 0, 0 );
|
|
|
|
#if defined(_DEBUG) && defined(SLOW_FILL)
|
|
if ( _nFiles )
|
|
{
|
|
InvalidateRect( _hWnd, NULL, TRUE );
|
|
for( ULONG a = 0; a < 999999 ; a++ )
|
|
{
|
|
#endif // defined(_DEBUG) && defined(SLOW_FILL)
|
|
// pump some messages....
|
|
if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
|
|
{
|
|
if ( !IsDialogMessage( g_hwndFind, &msg ) )
|
|
{
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
if ( g_fCApplicationWindowDestroyed )
|
|
{
|
|
return E_FAIL; // not break!
|
|
}
|
|
}
|
|
#if defined(_DEBUG) && defined(SLOW_FILL)
|
|
}
|
|
}
|
|
#endif // defined(_DEBUG) && defined(SLOW_FILL)
|
|
}
|
|
|
|
DestroyWindow( hwndProcessing );
|
|
|
|
_nFiles++;
|
|
|
|
if ( !_fVertSBVisible
|
|
&& _yWindow < (LONG)(_cTotalLineCount * _tm.tmHeight) )
|
|
{
|
|
_fVertSBVisible = TRUE;
|
|
EnableScrollBar( _hWnd, SB_VERT, ESB_ENABLE_BOTH );
|
|
ShowScrollBar( _hWnd, SB_VERT, TRUE );
|
|
}
|
|
else if ( _fVertSBVisible
|
|
&& _yWindow >= (LONG)(_cTotalLineCount * _tm.tmHeight) )
|
|
{
|
|
_fVertSBVisible = FALSE;
|
|
//EnableScrollBar( _hWnd, SB_VERT, ESB_ENABLE_BOTH );
|
|
ShowScrollBar( _hWnd, SB_VERT, FALSE );
|
|
}
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_RANGE;
|
|
si.nMin = 0;
|
|
si.nMax = _cTotalLineCount;
|
|
SetScrollInfo( _hWnd, SB_VERT, &si, TRUE );
|
|
|
|
InvalidateRect( _hWnd, NULL, TRUE );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// _LoadFile( )
|
|
//
|
|
HRESULT
|
|
CApplicationWindow::_LoadFile(
|
|
LPTSTR pszFilename )
|
|
{
|
|
HRESULT hr;
|
|
DWORD dwRead;
|
|
HANDLE hFile;
|
|
ULONG nLength;
|
|
LONG xMargin;
|
|
|
|
_pszFilenames[ _nFiles ] = (LPTSTR) LocalAlloc( LMEM_FIXED, ( lstrlen( pszFilename ) + 1 ) * sizeof(TCHAR) );
|
|
if ( !_pszFilenames[ _nFiles ] )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto Error;
|
|
}
|
|
|
|
strcpy( _pszFilenames[ _nFiles ], pszFilename );
|
|
|
|
_GetFilename( _pszFilenames[ _nFiles ], NULL, &xMargin );
|
|
xMargin += 7 + 2; // line number and file number
|
|
xMargin *= _xSpace;
|
|
|
|
if ( xMargin > _xMargin )
|
|
{
|
|
_xMargin = xMargin;
|
|
}
|
|
|
|
hFile = CreateFile( _pszFilenames[ _nFiles ],
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL );
|
|
if ( hFile == INVALID_HANDLE_VALUE )
|
|
{
|
|
hr = HRESULT_FROM_WIN32( GetLastError( ) );
|
|
goto Error;
|
|
}
|
|
|
|
nLength = GetFileSize( hFile, NULL );
|
|
if ( nLength == 0xFFFFffff && GetLastError( ) != NO_ERROR )
|
|
{
|
|
hr = HRESULT_FROM_WIN32( GetLastError( ) );
|
|
goto Error;
|
|
}
|
|
|
|
nLength++; // one for NULL
|
|
|
|
#if defined(_DEBUG)
|
|
_pFiles[ _nFiles ] = (LPTSTR) LocalAlloc( LPTR, nLength );
|
|
#else
|
|
_pFiles[ _nFiles ] = (LPTSTR) LocalAlloc( LMEM_FIXED, nLength );
|
|
#endif
|
|
if ( !_pFiles[ _nFiles ] )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto Error;
|
|
}
|
|
|
|
if ( !ReadFile( hFile, _pFiles[ _nFiles ], nLength, &dwRead, NULL ) )
|
|
{
|
|
hr = HRESULT_FROM_WIN32( GetLastError( ) );
|
|
goto Error;
|
|
}
|
|
|
|
hr = _CombineFiles( );
|
|
|
|
Cleanup:
|
|
if ( hFile != INVALID_HANDLE_VALUE )
|
|
CloseHandle( hFile );
|
|
|
|
return hr;
|
|
|
|
Error:
|
|
if ( _pFiles[ _nFiles ] )
|
|
{
|
|
LocalFree( _pFiles[ _nFiles ] );
|
|
_pFiles[ _nFiles ] = NULL;
|
|
}
|
|
|
|
MessageBox( _hWnd, pszFilename, TEXT("File Error"), MB_ICONEXCLAMATION | MB_OK );
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// _PaintLine( )
|
|
//
|
|
HRESULT
|
|
CApplicationWindow::_PaintLine(
|
|
PAINTSTRUCT * pps,
|
|
LINEPOINTER * pCurrent,
|
|
LONG wxStart,
|
|
LONG wy,
|
|
COLORREF crText,
|
|
COLORREF crDark,
|
|
COLORREF crNormal,
|
|
COLORREF crHightlite
|
|
)
|
|
{
|
|
LPTSTR pszStartLine; // beginning of line (PID/TID)
|
|
LPTSTR pszStartTimeDate; // beginning of time/data stamp
|
|
LPTSTR pszStartComponent; // beginning of component name
|
|
LPTSTR pszStartResType; // beginning of a resource component
|
|
LPTSTR pszStartText; // beginning of text
|
|
LPTSTR pszCurrent; // current position and beginning of text
|
|
TCHAR szFilename[ 40 ];
|
|
LONG cchFilename;
|
|
|
|
SIZE size;
|
|
RECT rect;
|
|
RECT rectResult;
|
|
|
|
LONG wx = wxStart;
|
|
LONG wxTextStart;
|
|
|
|
if ( pCurrent->psLine )
|
|
{
|
|
pszCurrent = pCurrent->psLine;
|
|
|
|
// draw node number
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + _xSpace * 2,
|
|
wy + _tm.tmHeight );
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
TCHAR szBuf[ 2 ];
|
|
|
|
SetBkColor( pps->hdc, GetSysColor( COLOR_WINDOW ) );
|
|
SetTextColor( pps->hdc, GetSysColor( COLOR_WINDOWTEXT ) );
|
|
|
|
DrawText( pps->hdc,
|
|
szBuf,
|
|
wsprintf( szBuf, TEXT("%1u "), pCurrent->nFile ),
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += 2 * _xSpace;
|
|
|
|
// Draw Filename
|
|
cchFilename = sizeof(szFilename)/sizeof(szFilename[0]);
|
|
_GetFilename( _pszFilenames[ pCurrent->nFile ], szFilename, &cchFilename );
|
|
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
_xMargin,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crNormal );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
HBRUSH hBrush;
|
|
hBrush = CreateSolidBrush( crNormal );
|
|
FillRect( pps->hdc, &rect, hBrush );
|
|
DeleteObject( hBrush );
|
|
|
|
DrawText( pps->hdc,
|
|
szFilename,
|
|
cchFilename,
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += _xMargin - ( 7 * _xSpace - 2 * _xSpace );
|
|
|
|
// draw line number
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + 7 * _xSpace,
|
|
wy + _tm.tmHeight );
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
TCHAR szBuf[ 8 ];
|
|
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
SetBkColor( pps->hdc, crDark );
|
|
DrawText( pps->hdc,
|
|
szBuf,
|
|
wsprintf( szBuf, TEXT("%07.7u"), pCurrent->nLine ),
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += 7 * _xSpace;
|
|
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + _xSpace,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crNormal );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
DrawText( pps->hdc,
|
|
" ",
|
|
1,
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += _xSpace;
|
|
|
|
//
|
|
// KB: This is what a typical cluster log line looks like.
|
|
// 000003fc.00000268::1999/07/19-19:14:45.548 [EVT] Node up: 2, new UpNodeSet: 0002
|
|
// 000003fc.00000268::1999/07/19-19:14:45.548 [EVT] EvOnline : calling ElfRegisterClusterSvc
|
|
// 000003fc.00000268::1999/07/19-19:14:45.548 [GUM] GumSendUpdate: queuing update type 2 context 19
|
|
// 000003fc.00000268::1999/07/19-19:14:45.548 [GUM] GumSendUpdate: Dispatching seq 2585 type 2 context 19 to node 1
|
|
// 000003fc.00000268::1999/07/19-19:14:45.548 [NM] Received update to set extended state for node 1 to 0
|
|
// 000003fc.00000268::1999/07/19-19:14:45.548 [NM] Issuing event 0.
|
|
// 000003fc.00000268::1999/07/19-19:14:45.548 [GUM] GumSendUpdate: completed update seq 2585 type 2 context 19
|
|
// 0000037c.000003a0::1999/07/19-19:14:45.548 Physical Disk: AddVolume : \\?\Volume{99d8d508-39fa-11d3-a200-806d6172696f}\ 'C', 7 (11041600)
|
|
// 0000037c.000003a0::1999/07/19-19:14:45.558 Physical Disk: AddVolume: GetPartitionInfo(\??\Volume{99d8d503-39fa-11d3-a200-806d6172696f}), error 170
|
|
// 0000037c.000003a0::1999/07/19-19:14:45.568 Physical Disk: AddVolume: GetPartitionInfo(\??\Volume{99d8d504-39fa-11d3-a200-806d6172696f}), error 170
|
|
// 0000037c.000003a0::1999/07/19-19:14:45.568 Physical Disk: AddVolume: GetPartitionInfo(\??\Volume{99d8d505-39fa-11d3-a200-806d6172696f}), error 170
|
|
// 0000037c.000003a0::1999/07/19-19:14:45.578 Physical Disk: AddVolume: GetPartitionInfo(\??\Volume{99d8d506-39fa-11d3-a200-806d6172696f}), error 170
|
|
// 0000037c.000003a0::1999/07/19-19:14:45.578 Physical Disk: AddVolume: GetPartitionInfo(\??\Volume{99d8d501-39fa-11d3-a200-806d6172696f}), error 1
|
|
//
|
|
|
|
pszStartResType =
|
|
pszStartComponent = NULL;
|
|
pszStartLine =
|
|
pszStartText =
|
|
pszStartTimeDate =
|
|
pszCurrent = pCurrent->psLine;
|
|
|
|
// Find the thread and process IDs
|
|
while ( *pszCurrent && *pszCurrent != ':' && *pszCurrent >= 32 )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent < 32 )
|
|
{
|
|
goto DrawRestOfLine;
|
|
}
|
|
|
|
pszCurrent++;
|
|
if ( *pszCurrent != ':' )
|
|
{
|
|
goto DrawRestOfLine;
|
|
}
|
|
|
|
pszCurrent++;
|
|
|
|
// Find Time/Date stamp which is:
|
|
// ####/##/##-##:##:##.###<space>
|
|
pszStartTimeDate = pszCurrent;
|
|
|
|
while ( *pszCurrent && *pszCurrent != ' ' && *pszCurrent >= 32 )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent < 32 )
|
|
{
|
|
goto DrawRestOfLine;
|
|
}
|
|
|
|
pszCurrent++;
|
|
|
|
if ( pCurrent->WarnLevel != WarnLevelUnknown )
|
|
{
|
|
// skip warn/info/err tag
|
|
//
|
|
while ( *pszCurrent != 32)
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
while ( *pszCurrent == 32)
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
}
|
|
|
|
pszStartText = pszCurrent;
|
|
|
|
// [OPTIONAL] Cluster component which looks like:
|
|
// [<id...>]
|
|
if ( *pszCurrent == '[' )
|
|
{
|
|
while ( *pszCurrent && *pszCurrent != ']' && *pszCurrent >= 32 )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
if ( *pszCurrent < 32 )
|
|
{
|
|
goto NoComponentTryResouce;
|
|
}
|
|
|
|
pszCurrent++;
|
|
|
|
pszStartComponent = pszStartText;
|
|
pszStartText = pszCurrent;
|
|
}
|
|
else
|
|
{
|
|
// [OPTIONAL] If not a component, see if there is a res type
|
|
NoComponentTryResouce:
|
|
pszCurrent = pszStartText;
|
|
|
|
while ( *pszCurrent && *pszCurrent != ':' && *pszCurrent >= 32 )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
|
|
if ( *pszCurrent >= 32 )
|
|
{
|
|
pszCurrent++;
|
|
|
|
pszStartResType = pszStartText;
|
|
pszStartText = pszCurrent;
|
|
}
|
|
}
|
|
|
|
// Draw PID and TID
|
|
GetTextExtentPoint32( pps->hdc,
|
|
pszStartLine,
|
|
(int)(pszStartTimeDate - pszStartLine - 2),
|
|
&size );
|
|
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + size.cx,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crNormal );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
DrawText( pps->hdc,
|
|
pszStartLine,
|
|
(int)(pszStartTimeDate - pszStartLine - 2),
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += size.cx;
|
|
|
|
GetTextExtentPoint32( pps->hdc,
|
|
"::",
|
|
2,
|
|
&size );
|
|
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + size.cx,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crNormal );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
DrawText( pps->hdc,
|
|
"::",
|
|
2,
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += size.cx;
|
|
|
|
// Draw Time/Date
|
|
pszCurrent = ( pszStartComponent ?
|
|
pszStartComponent :
|
|
( pszStartResType ?
|
|
pszStartResType :
|
|
pszStartText )
|
|
) - 1;
|
|
GetTextExtentPoint32( pps->hdc,
|
|
pszStartTimeDate,
|
|
(int)(pszCurrent - pszStartTimeDate),
|
|
&size );
|
|
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + size.cx,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crDark );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
DrawText( pps->hdc,
|
|
pszStartTimeDate,
|
|
(int)(pszCurrent - pszStartTimeDate),
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += size.cx;
|
|
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + _xSpace,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crNormal );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
DrawText( pps->hdc,
|
|
" ",
|
|
1,
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += _xSpace;
|
|
|
|
#ifdef _DEBUG
|
|
// draw sequence number
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + 7 * _xSpace,
|
|
wy + _tm.tmHeight );
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
TCHAR szBuf[ 8 ];
|
|
|
|
SetTextColor( pps->hdc, crText );
|
|
SetBkColor( pps->hdc, crNormal );
|
|
|
|
DrawText( pps->hdc,
|
|
szBuf,
|
|
wsprintf( szBuf, TEXT("#%7u%s"),
|
|
pCurrent->uSequenceNumber,// / 2,
|
|
pCurrent->fSyncPoint ? "*" : " " ),
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += 9 * _xSpace;
|
|
#endif
|
|
|
|
// Draw component
|
|
if ( pszStartComponent )
|
|
{
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + 10 * _xSpace,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crNormal );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
DrawText( pps->hdc,
|
|
" ",
|
|
10,
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
GetTextExtentPoint32( pps->hdc,
|
|
pszStartComponent,
|
|
(int)(pszStartText - pszStartComponent),
|
|
&size );
|
|
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + size.cx,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crNormal );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
DrawText( pps->hdc,
|
|
pszStartComponent,
|
|
(int)(pszStartText - pszStartComponent),
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += 10 * _xSpace;
|
|
}
|
|
|
|
if ( pszStartResType )
|
|
{
|
|
GetTextExtentPoint32( pps->hdc,
|
|
pszStartResType,
|
|
(int)(pszStartText - pszStartResType),
|
|
&size );
|
|
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + size.cx,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crNormal );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
DrawText( pps->hdc,
|
|
pszStartResType,
|
|
(int)(pszStartText - pszStartResType),
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
wx += size.cx;
|
|
}
|
|
|
|
DrawRestOfLine:
|
|
pszCurrent = pszStartText;
|
|
wxTextStart = wx;
|
|
|
|
while ( *pszCurrent && *pszCurrent != 13 )
|
|
{
|
|
pszCurrent++;
|
|
}
|
|
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
_xWindow,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crNormal );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
HBRUSH hBrush;
|
|
hBrush = CreateSolidBrush( crNormal );
|
|
FillRect( pps->hdc, &rect, hBrush );
|
|
DeleteObject( hBrush );
|
|
|
|
DrawText( pps->hdc,
|
|
pszStartText,
|
|
(int)(pszCurrent - pszStartText),
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE | DT_EXPANDTABS );
|
|
}
|
|
|
|
// See if "Finder" needs to paint on this line
|
|
if ( pCurrent->nFile == _LineFinder.nFile
|
|
&& pCurrent->nLine == _LineFinder.nLine )
|
|
{
|
|
wx = wxTextStart;
|
|
|
|
if ( pszStartResType )
|
|
{
|
|
GetTextExtentPoint32( pps->hdc,
|
|
pszStartResType,
|
|
(int)(_LineFinder.psLine - pszStartResType),
|
|
&size );
|
|
wx += size.cx;
|
|
}
|
|
else
|
|
{
|
|
GetTextExtentPoint32( pps->hdc,
|
|
pszStartText,
|
|
(int)(_LineFinder.psLine - pszStartText),
|
|
&size );
|
|
wx += size.cx;
|
|
}
|
|
|
|
GetTextExtentPoint32( pps->hdc,
|
|
_LineFinder.psLine,
|
|
_uFinderLength,
|
|
&size
|
|
);
|
|
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
wx + size.cx,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crHightlite );
|
|
SetTextColor( pps->hdc, ~crHightlite );
|
|
|
|
DrawText( pps->hdc,
|
|
_LineFinder.psLine,
|
|
_uFinderLength,
|
|
&rect,
|
|
DT_NOCLIP | DT_NOPREFIX | DT_SINGLELINE );
|
|
}
|
|
|
|
}
|
|
|
|
wx = _xWindow;
|
|
}
|
|
|
|
// fill in the rest of the line
|
|
SetRect( &rect,
|
|
wx,
|
|
wy,
|
|
_xWindow,
|
|
wy + _tm.tmHeight );
|
|
|
|
if ( IntersectRect( &rectResult, &pps->rcPaint, &rect ) )
|
|
{
|
|
SetBkColor( pps->hdc, crNormal );
|
|
SetTextColor( pps->hdc, crText );
|
|
|
|
HBRUSH hBrush;
|
|
hBrush = CreateSolidBrush( crNormal );
|
|
FillRect( pps->hdc, &rect, hBrush );
|
|
DeleteObject( hBrush );
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// _OnPaint( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_OnPaint(
|
|
WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
HDC hdc;
|
|
LONG wxStart;
|
|
LONG wy;
|
|
RECT rect;
|
|
RECT rectResult;
|
|
|
|
ULONG nLineCount;
|
|
LINEPOINTER * pCurrent;
|
|
|
|
SCROLLINFO si;
|
|
PAINTSTRUCT ps;
|
|
|
|
static COLORREF crBkColor[ MAX_OPEN_FILES ] = {
|
|
0xFFE0E0,
|
|
0xE0FFE0,
|
|
0xE0E0FF,
|
|
0xFFFFE0,
|
|
0xE0FFFF,
|
|
0xFFE0FF,
|
|
0xE0E0E0,
|
|
0xC0C0C0,
|
|
0x909090,
|
|
0x000000
|
|
};
|
|
|
|
static COLORREF crBkColorDarker[ MAX_OPEN_FILES ] = {
|
|
0xFFC0C0,
|
|
0xC0FFC0,
|
|
0xC0C0FF,
|
|
0xFFFFC0,
|
|
0xC0FFFF,
|
|
0xFFC0FF,
|
|
0xC0C0C0,
|
|
0xA0A0A0,
|
|
0x707070,
|
|
0x101010
|
|
};
|
|
|
|
static COLORREF crBkColorHighlite[ MAX_OPEN_FILES ] = {
|
|
0xFF0000,
|
|
0x00FF00,
|
|
0x0000FF,
|
|
0xFFFF00,
|
|
0x00FFFF,
|
|
0xFF00FF,
|
|
0x101010,
|
|
0x404040,
|
|
0x606060,
|
|
0xFFFFFF
|
|
};
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_POS;
|
|
GetScrollInfo( _hWnd, SB_HORZ, &si );
|
|
|
|
wxStart = si.nPos;
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_POS | SIF_PAGE;
|
|
GetScrollInfo( _hWnd, SB_VERT, &si );
|
|
|
|
hdc = BeginPaint( _hWnd, &ps);
|
|
|
|
if ( !_pLines )
|
|
goto EndPaint;
|
|
|
|
SetBkMode( hdc, OPAQUE );
|
|
SelectObject( hdc, g_hFont );
|
|
|
|
nLineCount = 0;
|
|
pCurrent = _pLines;
|
|
while ( pCurrent && nLineCount < (ULONG) si.nPos )
|
|
{
|
|
if ( !pCurrent->fFiltered )
|
|
{
|
|
nLineCount++;
|
|
}
|
|
pCurrent = pCurrent->pNext;
|
|
}
|
|
|
|
wy = 0;
|
|
while ( pCurrent
|
|
&& nLineCount <= si.nPos + si.nPage + 1 )
|
|
{
|
|
// ignore filtered lines
|
|
if ( pCurrent->fFiltered )
|
|
{
|
|
pCurrent = pCurrent->pNext;
|
|
continue;
|
|
}
|
|
|
|
if ( nLineCount >= _uStartSelection
|
|
&& nLineCount <= _uEndSelection )
|
|
{
|
|
_PaintLine( &ps,
|
|
pCurrent,
|
|
-wxStart,
|
|
wy,
|
|
GetSysColor( COLOR_WINDOWTEXT ),
|
|
crBkColorHighlite[ pCurrent->nFile ],
|
|
crBkColorHighlite[ pCurrent->nFile ],
|
|
crBkColorDarker[ pCurrent->nFile ]
|
|
);
|
|
}
|
|
else
|
|
{
|
|
_PaintLine( &ps,
|
|
pCurrent,
|
|
-wxStart,
|
|
wy,
|
|
GetSysColor( COLOR_WINDOWTEXT ),
|
|
crBkColorDarker[ pCurrent->nFile ],
|
|
crBkColor[ pCurrent->nFile ],
|
|
crBkColorHighlite[ pCurrent->nFile ]
|
|
);
|
|
}
|
|
|
|
wy += _tm.tmHeight;
|
|
nLineCount++;
|
|
pCurrent = pCurrent->pNext;
|
|
}
|
|
|
|
// Fill the rest with normal background color
|
|
SetRect( &rect,
|
|
0,
|
|
wy,
|
|
_xWindow,
|
|
_yWindow );
|
|
if ( IntersectRect( &rectResult, &ps.rcPaint, &rect ) )
|
|
{
|
|
HBRUSH hBrush;
|
|
hBrush = CreateSolidBrush( GetSysColor( COLOR_WINDOW ) );
|
|
FillRect( hdc, &rect, hBrush );
|
|
DeleteObject( hBrush );
|
|
}
|
|
|
|
EndPaint:
|
|
EndPaint(_hWnd, &ps);
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// _FindNext( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_FindNext(
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
SCROLLINFO si;
|
|
LPTSTR pszSearch;
|
|
LPTSTR psz;
|
|
ULONG n; // general counter
|
|
|
|
LPTSTR pszSearchString = (LPTSTR) lParam; // NEEDS TO BE FREEd!!!
|
|
WPARAM wFlags = wParam;
|
|
|
|
CWaitCursor Wait;
|
|
|
|
_uFinderLength = lstrlen( pszSearchString );
|
|
|
|
if( wFlags & FIND_UP )
|
|
{
|
|
//
|
|
// TODO: Make a better "up" search
|
|
//
|
|
if ( _LineFinder.pPrev )
|
|
{
|
|
CopyMemory( &_LineFinder, _LineFinder.pPrev, sizeof(LINEPOINTER) );
|
|
}
|
|
else
|
|
{
|
|
LINEPOINTER * lpLast;
|
|
LINEPOINTER * lp = _pLines;
|
|
while( lp )
|
|
{
|
|
lpLast = lp;
|
|
lp = lp->pNext;
|
|
}
|
|
|
|
CopyMemory( &_LineFinder, lpLast, sizeof(LINEPOINTER) );
|
|
}
|
|
}
|
|
else // find down
|
|
{
|
|
if ( _LineFinder.psLine )
|
|
{
|
|
// see if there is another instance on the same line
|
|
psz = _LineFinder.psLine;
|
|
for( n = 0; n < _uFinderLength; n++ )
|
|
{
|
|
if ( !*psz || *psz == 10 )
|
|
break;
|
|
|
|
psz++;
|
|
}
|
|
|
|
if ( *psz && *psz != 10 )
|
|
goto ResumeSearch;
|
|
}
|
|
}
|
|
|
|
if ( _LineFinder.psLine == NULL )
|
|
{
|
|
CopyMemory( &_LineFinder, _pLines->pNext, sizeof(LINEPOINTER) );
|
|
}
|
|
|
|
for(;;)
|
|
{
|
|
psz = _LineFinder.psLine;
|
|
if ( !psz )
|
|
break;
|
|
|
|
// skip PID/TID and time/date
|
|
while ( *psz && *psz != 10 )
|
|
{
|
|
if ( *psz == ':' )
|
|
{
|
|
psz++;
|
|
if ( *psz == ':' )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
psz++;
|
|
}
|
|
|
|
while ( *psz && *psz != 10 )
|
|
{
|
|
if ( *psz == 32 )
|
|
{
|
|
psz++;
|
|
break;
|
|
}
|
|
psz++;
|
|
}
|
|
|
|
if ( _LineFinder.WarnLevel != WarnLevelUnknown )
|
|
{
|
|
// skip info/warn/err tag
|
|
while ( *psz != 32)
|
|
{
|
|
psz++;
|
|
}
|
|
while ( *psz == 32)
|
|
{
|
|
psz++;
|
|
}
|
|
}
|
|
|
|
// skip components
|
|
if ( *psz == '[' )
|
|
{
|
|
while ( *psz && *psz != ']' )
|
|
{
|
|
psz++;
|
|
}
|
|
}
|
|
|
|
if ( *psz == 10 )
|
|
goto NextLine;
|
|
|
|
if ( !*psz )
|
|
break;
|
|
|
|
ResumeSearch:
|
|
pszSearch = pszSearchString;
|
|
while ( *psz != 10 )
|
|
{
|
|
if ( ( wFlags & FIND_MATCHCASE )
|
|
&& *psz != *pszSearch )
|
|
{
|
|
goto ResetMatch;
|
|
}
|
|
|
|
if ( toupper( *psz ) == toupper( *pszSearch ) )
|
|
{
|
|
pszSearch++;
|
|
if ( !*pszSearch )
|
|
{
|
|
ULONG cLine;
|
|
LINEPOINTER * lp;
|
|
|
|
if ( wFlags & FIND_WHOLE_WORD
|
|
&& isalnum( psz[ 1 ] ) )
|
|
{
|
|
psz++; // need to bump
|
|
goto ResetMatch;
|
|
}
|
|
|
|
_LineFinder.psLine = psz - _uFinderLength + 1;
|
|
|
|
// find the line
|
|
lp = _pLines;
|
|
cLine = 0;
|
|
while( lp )
|
|
{
|
|
if ( lp->nFile == _LineFinder.nFile
|
|
&& lp->nLine == _LineFinder.nLine )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ( !lp->fFiltered )
|
|
{
|
|
cLine++;
|
|
}
|
|
|
|
lp = lp->pNext;
|
|
}
|
|
|
|
_uPointer = _uStartSelection = _uEndSelection = cLine;
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_PAGE;
|
|
GetScrollInfo( _hWnd, SB_VERT, &si );
|
|
|
|
si.fMask = SIF_POS;
|
|
si.nPos = cLine - si.nPage / 2;
|
|
SetScrollInfo( _hWnd, SB_VERT, &si, TRUE );
|
|
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
|
|
LocalFree( pszSearchString );
|
|
return 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ResetMatch:
|
|
psz -= ( pszSearch - pszSearchString );
|
|
pszSearch = pszSearchString;
|
|
}
|
|
|
|
if ( !*psz )
|
|
break;
|
|
|
|
psz++;
|
|
}
|
|
|
|
NextLine:
|
|
if ( wFlags & FIND_UP )
|
|
{
|
|
if ( _LineFinder.pPrev != NULL )
|
|
{
|
|
CopyMemory( &_LineFinder, _LineFinder.pPrev, sizeof(LINEPOINTER) );
|
|
}
|
|
else
|
|
{
|
|
break; // end of search
|
|
}
|
|
}
|
|
else // find down
|
|
{
|
|
if ( _LineFinder.pNext != NULL )
|
|
{
|
|
CopyMemory( &_LineFinder, _LineFinder.pNext, sizeof(LINEPOINTER) );
|
|
}
|
|
else
|
|
{
|
|
break; // end of search
|
|
}
|
|
}
|
|
}
|
|
|
|
// not found
|
|
ZeroMemory( &_LineFinder, sizeof(LINEPOINTER) );
|
|
if ( wFlags & FIND_UP )
|
|
{
|
|
_LineFinder.nLine = 0;
|
|
}
|
|
else
|
|
{
|
|
_LineFinder.nLine = _cTotalLineCount;
|
|
}
|
|
LocalFree( pszSearchString );
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// _MarkAll( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_MarkAll(
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
WPARAM wFlags = wParam;
|
|
LPTSTR pszSearchString = (LPTSTR) lParam;
|
|
LocalFree( pszSearchString );
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// _OnSize( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_OnSize(
|
|
LPARAM lParam )
|
|
{
|
|
HDC hdc;
|
|
SIZE size;
|
|
HGDIOBJ hObj;
|
|
TCHAR szSpace[ 1 ] = { TEXT(' ') };
|
|
|
|
SCROLLINFO si;
|
|
|
|
_xWindow = LOWORD( lParam );
|
|
_yWindow = HIWORD( lParam );
|
|
|
|
hdc = GetDC( _hWnd );
|
|
hObj = SelectObject( hdc, g_hFont );
|
|
GetTextMetrics( hdc, &_tm );
|
|
|
|
GetTextExtentPoint32( hdc, szSpace, 1, &size );
|
|
_xSpace = size.cx;
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_RANGE | SIF_PAGE;
|
|
si.nMin = 0;
|
|
si.nMax = _cTotalLineCount;
|
|
si.nPage = _yWindow / _tm.tmHeight;
|
|
|
|
SetScrollInfo( _hWnd, SB_VERT, &si, FALSE );
|
|
|
|
si.fMask = SIF_RANGE | SIF_PAGE;
|
|
si.nMin = 0;
|
|
si.nMax = 1000;
|
|
si.nPage = _xWindow / _tm.tmHeight;
|
|
SetScrollInfo( _hWnd, SB_HORZ, &si, FALSE );
|
|
|
|
// cleanup the HDC
|
|
SelectObject( hdc, hObj );
|
|
ReleaseDC( _hWnd, hdc );
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// _OnMouseWheel( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_OnMouseWheel( SHORT iDelta )
|
|
{
|
|
if ( iDelta > 0 )
|
|
{
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_LINEUP, 0 );
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_LINEUP, 0 );
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_LINEUP, 0 );
|
|
}
|
|
else if ( iDelta < 0 )
|
|
{
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_LINEDOWN, 0 );
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_LINEDOWN, 0 );
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_LINEDOWN, 0 );
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// _OnVerticalScroll( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_OnVerticalScroll(
|
|
WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
SCROLLINFO si;
|
|
RECT rect;
|
|
|
|
INT nScrollCode = LOWORD(wParam); // scroll bar value
|
|
INT nPos;
|
|
//INT nPos = HIWORD(wParam); // scroll box position
|
|
//HWND hwndScrollBar = (HWND) lParam; // handle to scroll bar
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_ALL;
|
|
GetScrollInfo( _hWnd, SB_VERT, &si );
|
|
|
|
nPos = si.nPos;
|
|
|
|
|
|
switch( nScrollCode )
|
|
{
|
|
case SB_BOTTOM:
|
|
si.nPos = si.nMax;
|
|
break;
|
|
|
|
case SB_THUMBPOSITION:
|
|
si.nPos = nPos;
|
|
break;
|
|
|
|
case SB_THUMBTRACK:
|
|
si.nPos = si.nTrackPos;
|
|
break;
|
|
|
|
case SB_TOP:
|
|
si.nPos = si.nMin;
|
|
break;
|
|
|
|
case SB_LINEDOWN:
|
|
si.nPos += 1;
|
|
break;
|
|
|
|
case SB_LINEUP:
|
|
si.nPos -= 1;
|
|
break;
|
|
|
|
case SB_PAGEDOWN:
|
|
si.nPos += si.nPage;
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
break;
|
|
|
|
case SB_PAGEUP:
|
|
si.nPos -= si.nPage;
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
break;
|
|
}
|
|
|
|
si.fMask = SIF_POS;
|
|
SetScrollInfo( _hWnd, SB_VERT, &si, TRUE );
|
|
GetScrollInfo( _hWnd, SB_VERT, &si );
|
|
|
|
if ( si.nPos != nPos )
|
|
{
|
|
ScrollWindowEx( _hWnd,
|
|
0,
|
|
(nPos - si.nPos) * _tm.tmHeight,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
SW_INVALIDATE );
|
|
|
|
SetRect( &rect, 0, ( _uPointer - si.nPos - 1 ) * _tm.tmHeight, _xWindow, ( _uPointer - si.nPos + 2 ) * _tm.tmHeight );
|
|
InvalidateRect( _hWnd, &rect, FALSE );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
//
|
|
// _OnHorizontalScroll( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_OnHorizontalScroll(
|
|
WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
SCROLLINFO si;
|
|
|
|
INT nScrollCode = LOWORD(wParam); // scroll bar value
|
|
INT nPos;
|
|
//INT nPos = HIWORD(wParam); // scroll box position
|
|
//HWND hwndScrollBar = (HWND) lParam; // handle to scroll bar
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_ALL;
|
|
GetScrollInfo( _hWnd, SB_HORZ, &si );
|
|
|
|
nPos = si.nPos;
|
|
|
|
switch( nScrollCode )
|
|
{
|
|
case SB_BOTTOM:
|
|
si.nPos = si.nMax;
|
|
break;
|
|
|
|
case SB_THUMBPOSITION:
|
|
si.nPos = nPos;
|
|
break;
|
|
|
|
case SB_THUMBTRACK:
|
|
si.nPos = si.nTrackPos;
|
|
break;
|
|
|
|
case SB_TOP:
|
|
si.nPos = si.nMin;
|
|
break;
|
|
|
|
case SB_LINEDOWN:
|
|
si.nPos += 1;
|
|
break;
|
|
|
|
case SB_LINEUP:
|
|
si.nPos -= 1;
|
|
break;
|
|
|
|
case SB_PAGEDOWN:
|
|
si.nPos += si.nPage;
|
|
break;
|
|
|
|
case SB_PAGEUP:
|
|
si.nPos -= si.nPage;
|
|
break;
|
|
}
|
|
|
|
si.fMask = SIF_POS;
|
|
SetScrollInfo( _hWnd, SB_HORZ, &si, TRUE );
|
|
GetScrollInfo( _hWnd, SB_HORZ, &si );
|
|
|
|
if ( si.nPos != nPos )
|
|
{
|
|
ScrollWindowEx( _hWnd,
|
|
(nPos - si.nPos),
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
SW_INVALIDATE );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// _FillClipboard( )
|
|
//
|
|
HRESULT
|
|
CApplicationWindow::_FillClipboard( )
|
|
{
|
|
HANDLE hClip;
|
|
LPTSTR pszClip;
|
|
LPTSTR psz;
|
|
ULONG dwSize;
|
|
ULONG nLine;
|
|
TCHAR szFilename[ 40 ];
|
|
LONG cchFilename;
|
|
LINEPOINTER * pCurLine;
|
|
LINEPOINTER * pSelectionStart;
|
|
|
|
LONG cchMargin = ( _xMargin / _xSpace ) + 2;
|
|
|
|
//0 cluster1.log 0000006 5c4.57c::1999/07/26-21:56:24.682 [EP] Initialization...
|
|
static TCHAR szHeader[] = " Log/Nodename";
|
|
static TCHAR szHeader2[] = "Line### PIDxxxxx.TIDxxxxx Year/MM/DD-HH-MM-SS.HsS Log Entry\n\n";
|
|
|
|
if ( cchMargin < sizeof(szHeader) + 8 )
|
|
{
|
|
cchMargin = sizeof(szHeader) + 8;
|
|
}
|
|
|
|
//
|
|
// Find the start of the line
|
|
//
|
|
pSelectionStart = _pLines;
|
|
for( nLine = 0; nLine < _uStartSelection; nLine++ )
|
|
{
|
|
pSelectionStart = pSelectionStart->pNext;
|
|
}
|
|
|
|
//
|
|
// Tally up the line sizes
|
|
//
|
|
dwSize = cchMargin - 8;
|
|
dwSize += sizeof(szHeader2) - 1;
|
|
pCurLine = pSelectionStart;
|
|
for( ; nLine <= _uEndSelection; nLine++ )
|
|
{
|
|
psz = pCurLine->psLine;
|
|
if ( psz == NULL )
|
|
break;
|
|
|
|
while( *psz && *psz != 10 )
|
|
{
|
|
psz++;
|
|
}
|
|
if ( *psz )
|
|
{
|
|
psz++; // inlude LF
|
|
}
|
|
|
|
dwSize += (ULONG)(psz - pCurLine->psLine);
|
|
pCurLine = pCurLine->pNext;
|
|
}
|
|
|
|
// Add file and line number for every line
|
|
dwSize += ( _uEndSelection - _uStartSelection + 1 ) * cchMargin;
|
|
|
|
dwSize++; // add one for NULL terminator
|
|
|
|
hClip = (LPTSTR) GlobalAlloc( LMEM_MOVEABLE | GMEM_DDESHARE, dwSize * sizeof(*pszClip) );
|
|
if ( !hClip )
|
|
return E_OUTOFMEMORY;
|
|
|
|
pszClip = (LPTSTR) GlobalLock( hClip );
|
|
|
|
for ( LONG n = 0; n < cchMargin; n++ )
|
|
{
|
|
pszClip[ n ] = 32;
|
|
}
|
|
CopyMemory( pszClip, szHeader, sizeof(szHeader) - 1 );
|
|
pszClip += cchMargin - 8;
|
|
CopyMemory( pszClip, szHeader2, sizeof(szHeader2) - 1 );
|
|
pszClip += sizeof(szHeader2) - 1;
|
|
|
|
pCurLine = pSelectionStart;
|
|
for( nLine = _uStartSelection; nLine <= _uEndSelection; nLine++ )
|
|
{
|
|
for ( LONG n = 0; n < cchMargin; n++ )
|
|
{
|
|
pszClip[ n ] = 32;
|
|
}
|
|
|
|
// file number
|
|
_snprintf( pszClip, 1, "%1u", pCurLine->nFile );
|
|
pszClip += 2;
|
|
|
|
// filename
|
|
cchFilename = cchMargin - 10;
|
|
_GetFilename( _pszFilenames[ pCurLine->nFile ], szFilename, &cchFilename );
|
|
_snprintf( pszClip, cchFilename, "%s", szFilename );
|
|
pszClip += cchMargin - 10;
|
|
|
|
// line number
|
|
_snprintf( pszClip, 7, "%07.7u", pCurLine->nLine );
|
|
pszClip += 7;
|
|
|
|
pszClip++;
|
|
|
|
psz = pCurLine->psLine;
|
|
if ( psz == NULL )
|
|
break;
|
|
while( *psz && *psz != 10 )
|
|
{
|
|
psz++;
|
|
}
|
|
if ( *psz )
|
|
{
|
|
psz++; // inlude LF
|
|
}
|
|
|
|
CopyMemory( pszClip, pCurLine->psLine, psz - pCurLine->psLine );
|
|
pszClip += psz - pCurLine->psLine;
|
|
|
|
pCurLine = pCurLine->pNext;
|
|
}
|
|
|
|
*pszClip = 0; // terminate
|
|
|
|
GlobalUnlock( hClip );
|
|
|
|
if ( OpenClipboard( _hWnd ) )
|
|
{
|
|
SetClipboardData( CF_TEXT, hClip );
|
|
CloseClipboard( );
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// _ApplyFilters( )
|
|
//
|
|
HRESULT
|
|
CApplicationWindow::_ApplyFilters( )
|
|
{
|
|
SCROLLINFO si;
|
|
|
|
ULONG nLineCount = 0;
|
|
LINEPOINTER * lp = _pLines;
|
|
|
|
while( lp )
|
|
{
|
|
lp->fFiltered = FALSE;
|
|
|
|
if ( lp->nFilterId == g_nComponentFilters + 1 )
|
|
{
|
|
if ( g_fResourceNoise )
|
|
{
|
|
lp->fFiltered = TRUE;
|
|
}
|
|
}
|
|
else if ( lp->nFilterId !=0
|
|
&& lp->nFilterId <= g_nComponentFilters )
|
|
{
|
|
if ( g_pfSelectedComponent[ lp->nFilterId - 1 ] )
|
|
{
|
|
lp->fFiltered = TRUE;
|
|
}
|
|
}
|
|
|
|
if ( ! lp->fFiltered )
|
|
{
|
|
nLineCount++;
|
|
}
|
|
|
|
lp = lp->pNext;
|
|
}
|
|
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
|
|
// Update scroll bar
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_RANGE;
|
|
GetScrollInfo( _hWnd, SB_VERT, &si );
|
|
si.nMax = nLineCount;
|
|
SetScrollInfo( _hWnd, SB_VERT, &si, TRUE );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// _OnCommand( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_OnCommand(
|
|
WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
INT wmId = LOWORD(wParam);
|
|
INT wmEvent = HIWORD(wParam);
|
|
// Parse the menu selections:
|
|
switch (wmId)
|
|
{
|
|
case IDM_ABOUT:
|
|
DialogBox( g_hInstance, (LPCTSTR)IDD_ABOUTBOX, _hWnd, (DLGPROC)About);
|
|
break;
|
|
|
|
case IDM_EXIT:
|
|
{
|
|
DestroyWindow( _hWnd );
|
|
}
|
|
break;
|
|
|
|
case IDM_FILE_REFRESH:
|
|
{
|
|
ULONG n;
|
|
ULONG nFiles = _nFiles;
|
|
LPTSTR pszFilenames[ MAX_OPEN_FILES ];
|
|
|
|
for( n = 0; n < nFiles; n++ )
|
|
{
|
|
pszFilenames[ n ] = _pszFilenames[ n ];
|
|
_pszFilenames[ n ] = NULL;
|
|
}
|
|
|
|
Cleanup( );
|
|
|
|
for( n = 0; n < nFiles; n++ )
|
|
{
|
|
_LoadFile( pszFilenames[ n ] );
|
|
LocalFree( pszFilenames[ n ] );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDM_NEW_FILE:
|
|
{
|
|
Cleanup( );
|
|
InvalidateRect( _hWnd, NULL, TRUE );
|
|
}
|
|
break;
|
|
|
|
case IDM_OPEN_FILE:
|
|
{
|
|
LPTSTR psz;
|
|
TCHAR szFilters[ MAX_PATH ];
|
|
TCHAR szFilename[ MAX_PATH ];
|
|
LPTSTR pszFilenameBuffer
|
|
= (LPTSTR) LocalAlloc( LPTR, 8 * MAX_PATH );
|
|
|
|
ZeroMemory( szFilters, sizeof(szFilters) );
|
|
ZeroMemory( _szOpenFileNameFilter, sizeof(_szOpenFileNameFilter) );
|
|
LoadString( g_hInstance, IDS_OPEN_FILE_FILTERS, szFilters, MAX_PATH );
|
|
for ( psz = szFilters; *psz; psz++ )
|
|
{
|
|
if ( *psz == TEXT(',') )
|
|
{
|
|
*psz = TEXT('\0');
|
|
}
|
|
}
|
|
|
|
OPENFILENAME ofn;
|
|
ZeroMemory( &ofn, sizeof(ofn) );
|
|
ofn.lStructSize = sizeof(ofn);
|
|
ofn.hwndOwner = _hWnd;
|
|
ofn.hInstance = g_hInstance;
|
|
ofn.lpstrFilter = szFilters;
|
|
// ofn.lpfnHook = NULL;
|
|
ofn.Flags = OFN_ENABLESIZING
|
|
| OFN_FILEMUSTEXIST
|
|
| OFN_EXPLORER
|
|
| OFN_ALLOWMULTISELECT;
|
|
// ofn.lCustData = 0;
|
|
ofn.lpstrCustomFilter = _szOpenFileNameFilter;
|
|
// ofn.lpstrDefExt = NULL;
|
|
ofn.lpstrFile = pszFilenameBuffer;
|
|
// ofn.lpstrFileTitle = NULL;
|
|
// ofn.lpstrInitialDir = NULL;
|
|
// ofn.lpstrTitle = NULL;
|
|
// ofn.lpTemplateName = NULL;
|
|
// ofn.nFileExtension = 0;
|
|
// ofn.nFileOffset = 0;
|
|
// ofn.nFilterIndex = 1;
|
|
ofn.nMaxCustFilter = MAX_PATH;
|
|
ofn.nMaxFile = 8 * MAX_PATH;
|
|
// ofn.nMaxFileTitle = 0;
|
|
|
|
if ( GetOpenFileName( &ofn ) )
|
|
{
|
|
LPTSTR pszFilename = pszFilenameBuffer + ofn.nFileOffset;
|
|
strcpy( szFilename, pszFilenameBuffer );
|
|
szFilename[ ofn.nFileOffset - 1] = '\\';
|
|
while ( *pszFilename )
|
|
{
|
|
strcpy( &szFilename[ ofn.nFileOffset ], pszFilename );
|
|
_LoadFile( szFilename );
|
|
pszFilename += lstrlen( pszFilename ) + 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWORD dwErr = GetLastError( );
|
|
}
|
|
|
|
LocalFree( pszFilenameBuffer );
|
|
}
|
|
break;
|
|
|
|
case IDM_ALL_ON:
|
|
{
|
|
ULONG nItems = GetMenuItemCount( _hMenu );
|
|
for( ULONG n = 0; n < nItems; n++ )
|
|
{
|
|
MENUITEMINFO mii;
|
|
ZeroMemory( &mii, sizeof(mii) );
|
|
mii.cbSize = sizeof(mii);
|
|
mii.fMask = MIIM_STATE;
|
|
mii.fState = MFS_CHECKED;
|
|
SetMenuItemInfo( _hMenu, n, TRUE, &mii );
|
|
g_pfSelectedComponent[ n ] = FALSE;
|
|
}
|
|
|
|
LINEPOINTER * lp = _pLines;
|
|
while( lp )
|
|
{
|
|
lp->fFiltered = FALSE;
|
|
lp = lp->pNext;
|
|
}
|
|
|
|
_ApplyFilters( );
|
|
}
|
|
break;
|
|
|
|
case IDM_EDIT_COPY:
|
|
{
|
|
_FillClipboard( );
|
|
}
|
|
break;
|
|
|
|
case IDM_FILTER_SHOWSERVERNAME:
|
|
{
|
|
HMENU hMenu = GetSubMenu( GetMenu( _hWnd ), 2 );
|
|
MENUITEMINFO mii;
|
|
ZeroMemory( &mii, sizeof(mii) );
|
|
mii.cbSize = sizeof(mii);
|
|
mii.fMask = MIIM_STATE;
|
|
GetMenuItemInfo( hMenu, IDM_FILTER_SHOWSERVERNAME, FALSE, &mii );
|
|
g_fShowServerNames = ( ( mii.fState & MFS_CHECKED ) == MFS_CHECKED );
|
|
mii.fState = g_fShowServerNames ? 0 : MFS_CHECKED;
|
|
SetMenuItemInfo( hMenu, IDM_FILTER_SHOWSERVERNAME, FALSE, &mii );
|
|
}
|
|
break;
|
|
|
|
case IDM_FILTER_RESOURCENOISE:
|
|
{
|
|
HMENU hMenu = GetSubMenu( GetMenu( _hWnd ), 2 );
|
|
MENUITEMINFO mii;
|
|
ZeroMemory( &mii, sizeof(mii) );
|
|
mii.cbSize = sizeof(mii);
|
|
mii.fMask = MIIM_STATE;
|
|
GetMenuItemInfo( hMenu, IDM_FILTER_RESOURCENOISE, FALSE, &mii );
|
|
g_fResourceNoise = ( ( mii.fState & MFS_CHECKED ) == MFS_CHECKED );
|
|
mii.fState = g_fResourceNoise ? 0 : MFS_CHECKED;
|
|
SetMenuItemInfo( hMenu, IDM_FILTER_RESOURCENOISE, FALSE, &mii );
|
|
_ApplyFilters( );
|
|
}
|
|
break;
|
|
|
|
case IDM_EDIT_FIND:
|
|
if ( !g_hwndFind )
|
|
{
|
|
new CFindDialog( _hWnd );
|
|
}
|
|
else
|
|
{
|
|
ShowWindow( g_hwndFind, SW_SHOW );
|
|
}
|
|
break;
|
|
|
|
case IDM_ALL_OFF:
|
|
{
|
|
ULONG nItems = GetMenuItemCount( _hMenu );
|
|
for( ULONG n = 0; n < nItems; n++ )
|
|
{
|
|
MENUITEMINFO mii;
|
|
ZeroMemory( &mii, sizeof(mii) );
|
|
mii.cbSize = sizeof(mii);
|
|
mii.fMask = MIIM_STATE;
|
|
mii.fState = 0;
|
|
SetMenuItemInfo( _hMenu, n, TRUE, &mii );
|
|
g_pfSelectedComponent[ n ] = TRUE;
|
|
}
|
|
_ApplyFilters( );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if ( wmId >= IDM_FIRST_CS_FILTER && wmId <= IDM_LAST_CS_FILTER )
|
|
{
|
|
MENUITEMINFO mii;
|
|
ZeroMemory( &mii, sizeof(mii) );
|
|
mii.cbSize = sizeof(mii);
|
|
mii.fMask = MIIM_STATE;
|
|
GetMenuItemInfo( _hMenu, wmId, FALSE, &mii );
|
|
g_pfSelectedComponent[ wmId - IDM_FIRST_CS_FILTER - 1 ] = ( ( mii.fState & MFS_CHECKED ) == MFS_CHECKED );
|
|
mii.fState = g_pfSelectedComponent[ wmId - IDM_FIRST_CS_FILTER - 1 ] ? 0 : MFS_CHECKED;
|
|
SetMenuItemInfo( _hMenu, wmId, FALSE, &mii );
|
|
_ApplyFilters( );
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// _OnDestroyWindow( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_OnDestroyWindow( )
|
|
{
|
|
g_fCApplicationWindowDestroyed = TRUE;
|
|
PostQuitMessage(0);
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// _OnCreate( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_OnCreate(
|
|
HWND hwnd,
|
|
LPCREATESTRUCT pcs )
|
|
{
|
|
_hWnd = hwnd;
|
|
|
|
SetWindowLongPtr( _hWnd, GWLP_USERDATA, (LONG_PTR)this );
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// _OnKeyDown( )
|
|
//
|
|
// Returns FALSE is the default window proc should also
|
|
// take a crack at it.
|
|
//
|
|
// Returns TRUE to stop processing the message.
|
|
//
|
|
BOOL
|
|
CApplicationWindow::_OnKeyDown( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
RECT rect;
|
|
SCROLLINFO si;
|
|
ULONG uOldPointer = _uPointer;
|
|
BOOL lResult = FALSE;
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_POS | SIF_PAGE;
|
|
GetScrollInfo( _hWnd, SB_VERT, &si );
|
|
|
|
SetRect( &rect, 0, ( _uPointer - si.nPos ) * _tm.tmHeight, _xWindow, ( _uPointer - si.nPos + 1 ) * _tm.tmHeight );
|
|
|
|
if ( wParam == VK_PRIOR
|
|
|| wParam == VK_UP
|
|
|| wParam == VK_HOME
|
|
|| wParam == VK_END
|
|
|| wParam == VK_NEXT
|
|
|| wParam == VK_DOWN )
|
|
{
|
|
if ( _fSelection )
|
|
{
|
|
if ( GetKeyState( VK_SHIFT ) >= 0 )
|
|
{
|
|
_fSelection = FALSE;
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( GetKeyState( VK_SHIFT ) < 0 )
|
|
{
|
|
_fSelection = TRUE;
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
}
|
|
}
|
|
}
|
|
|
|
switch ( wParam )
|
|
{
|
|
case VK_PRIOR:
|
|
_uPointer -= si.nPage - 1;
|
|
case VK_UP:
|
|
_uPointer--;
|
|
if ( _uPointer >= _cTotalLineCount )
|
|
{
|
|
_uPointer = _cTotalLineCount - 1;
|
|
}
|
|
if ( GetKeyState( VK_SHIFT ) < 0 )
|
|
{
|
|
if ( uOldPointer == _uStartSelection )
|
|
{
|
|
_uStartSelection = _uPointer;
|
|
}
|
|
else
|
|
{
|
|
_uEndSelection = _uPointer;
|
|
}
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
}
|
|
else
|
|
{
|
|
_uStartSelection = _uEndSelection = _uPointer;
|
|
if ( _uPointer < (ULONG) si.nPos )
|
|
{
|
|
if ( wParam == VK_UP )
|
|
{
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_LINEUP, 0 );
|
|
GetScrollInfo( _hWnd, SB_VERT, &si );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rect.top -= _tm.tmHeight;
|
|
InvalidateRect( _hWnd, &rect, FALSE );
|
|
}
|
|
}
|
|
if ( wParam == VK_PRIOR )
|
|
{
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_PAGEUP, 0 );
|
|
}
|
|
else if ( _uPointer < (ULONG) si.nPos )
|
|
{
|
|
si.fMask = SIF_POS;
|
|
si.nPos = _uPointer;
|
|
SetScrollInfo( _hWnd, SB_VERT, &si, TRUE );
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
}
|
|
lResult = TRUE;
|
|
break;
|
|
|
|
case VK_NEXT:
|
|
_uPointer += si.nPage - 1;
|
|
case VK_DOWN:
|
|
_uPointer++;
|
|
if ( _uPointer >= _cTotalLineCount )
|
|
{
|
|
_uPointer = _cTotalLineCount - 1;
|
|
}
|
|
if ( GetKeyState( VK_SHIFT ) < 0 )
|
|
{
|
|
if ( uOldPointer == _uEndSelection )
|
|
{
|
|
_uEndSelection = _uPointer;
|
|
}
|
|
else
|
|
{
|
|
_uStartSelection = _uPointer;
|
|
}
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
}
|
|
else
|
|
{
|
|
_uStartSelection = _uEndSelection = _uPointer;
|
|
if ( _uPointer > si.nPos + si.nPage )
|
|
{
|
|
if ( wParam == VK_DOWN )
|
|
{
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_LINEDOWN, 0 );
|
|
GetScrollInfo( _hWnd, SB_VERT, &si );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rect.bottom += _tm.tmHeight;
|
|
InvalidateRect( _hWnd, &rect, FALSE );
|
|
}
|
|
}
|
|
if ( wParam == VK_NEXT )
|
|
{
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_PAGEDOWN, 0 );
|
|
}
|
|
else if ( _uPointer > si.nPos + si.nPage )
|
|
{
|
|
si.fMask = SIF_POS;
|
|
si.nPos = _uPointer;
|
|
SetScrollInfo( _hWnd, SB_VERT, &si, TRUE );
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
}
|
|
lResult = TRUE;
|
|
break;
|
|
|
|
case VK_HOME:
|
|
_LineFinder.nLine = 0;
|
|
_LineFinder.psLine = NULL;
|
|
_uPointer = 0;
|
|
if ( GetKeyState( VK_SHIFT ) < 0 )
|
|
{
|
|
if ( uOldPointer == _uEndSelection )
|
|
{
|
|
_uEndSelection = _uStartSelection;
|
|
}
|
|
_uStartSelection = 0;
|
|
}
|
|
else
|
|
{
|
|
_uEndSelection = _uStartSelection = _uPointer;
|
|
}
|
|
if ( uOldPointer < si.nPage )
|
|
{
|
|
InvalidateRect( _hWnd, &rect, FALSE );
|
|
SetRect( &rect, 0, ( _uPointer - si.nPos ) * _tm.tmHeight, _xWindow, ( _uPointer - si.nPos + 1 ) * _tm.tmHeight );
|
|
InvalidateRect( _hWnd, &rect, FALSE );
|
|
}
|
|
else
|
|
{
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_TOP, 0 );
|
|
}
|
|
lResult = TRUE;
|
|
break;
|
|
|
|
case VK_END:
|
|
_LineFinder.nLine = _cTotalLineCount;
|
|
_LineFinder.psLine = NULL;
|
|
_uPointer = _cTotalLineCount - 1;
|
|
if ( GetKeyState( VK_SHIFT ) < 0 )
|
|
{
|
|
if ( uOldPointer == _uStartSelection )
|
|
{
|
|
_uStartSelection = _uEndSelection;
|
|
}
|
|
_uEndSelection = 0;
|
|
}
|
|
else
|
|
{
|
|
_uEndSelection = _uStartSelection = _uPointer;
|
|
}
|
|
if ( uOldPointer > _cTotalLineCount - si.nPage )
|
|
{
|
|
InvalidateRect( _hWnd, &rect, FALSE );
|
|
SetRect( &rect, 0, ( _uPointer - si.nPos ) * _tm.tmHeight, _xWindow, ( _uPointer - si.nPos + 1 ) * _tm.tmHeight );
|
|
InvalidateRect( _hWnd, &rect, FALSE );
|
|
}
|
|
else
|
|
{
|
|
SendMessage( _hWnd, WM_VSCROLL, SB_BOTTOM, 0 );
|
|
}
|
|
lResult = TRUE;
|
|
break;
|
|
|
|
case VK_LEFT:
|
|
SendMessage( _hWnd, WM_HSCROLL, SB_PAGEUP, 0 );
|
|
break;
|
|
|
|
case VK_RIGHT:
|
|
SendMessage( _hWnd, WM_HSCROLL, SB_PAGEDOWN, 0 );
|
|
break;
|
|
|
|
case VK_F5: // refresh
|
|
PostMessage( _hWnd, WM_COMMAND, IDM_FILE_REFRESH, 0 );
|
|
break;
|
|
|
|
case 'F':
|
|
if ( GetKeyState( VK_CONTROL ) < 0 )
|
|
{
|
|
PostMessage( _hWnd, WM_COMMAND, IDM_EDIT_FIND, 0 );
|
|
}
|
|
break;
|
|
|
|
case 'A':
|
|
if ( GetKeyState( VK_CONTROL ) < 0 )
|
|
{
|
|
PostMessage( _hWnd, WM_COMMAND, IDM_OPEN_FILE, 0 );
|
|
}
|
|
break;
|
|
|
|
case 'C':
|
|
if ( GetKeyState( VK_CONTROL ) < 0 )
|
|
{
|
|
PostMessage( _hWnd, WM_COMMAND, IDM_EDIT_COPY, 0 );
|
|
}
|
|
break;
|
|
}
|
|
|
|
return lResult;
|
|
}
|
|
|
|
//
|
|
// _OnLeftButtonDown( )
|
|
//
|
|
LRESULT
|
|
CApplicationWindow::_OnLeftButtonDown(
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
SCROLLINFO si;
|
|
|
|
DWORD fwKeys = (DWORD) wParam;
|
|
DWORD x = GET_X_LPARAM( lParam );
|
|
DWORD y = GET_Y_LPARAM( lParam );
|
|
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_POS;
|
|
GetScrollInfo( _hWnd, SB_VERT, &si );
|
|
|
|
_uPointer = si.nPos + y / _tm.tmHeight;
|
|
InvalidateRect( _hWnd, NULL, FALSE );
|
|
|
|
if ( fwKeys & MK_SHIFT )
|
|
{
|
|
if ( _uPointer < _uStartSelection )
|
|
{
|
|
_uStartSelection = _uPointer;
|
|
}
|
|
else if ( _uPointer > _uEndSelection )
|
|
{
|
|
_uEndSelection = _uPointer;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_uStartSelection = _uEndSelection = _uPointer;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// WndProc( )
|
|
//
|
|
LRESULT CALLBACK
|
|
CApplicationWindow::WndProc(
|
|
HWND hWnd,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
CApplicationWindow * paw = (CApplicationWindow *) GetWindowLongPtr( hWnd, GWLP_USERDATA );
|
|
|
|
if ( paw != NULL )
|
|
{
|
|
switch( uMsg )
|
|
{
|
|
case WM_COMMAND:
|
|
return paw->_OnCommand( wParam, lParam );
|
|
|
|
case WM_PAINT:
|
|
return paw->_OnPaint( wParam, lParam );
|
|
|
|
case WM_DESTROY:
|
|
SetWindowLongPtr( hWnd, GWLP_USERDATA, (LONG_PTR)NULL );
|
|
return paw->_OnDestroyWindow( );
|
|
|
|
case WM_SIZE:
|
|
return paw->_OnSize( lParam );
|
|
|
|
case WM_KEYDOWN:
|
|
case WM_SYSKEYDOWN:
|
|
if ( paw->_OnKeyDown( wParam, lParam ) )
|
|
return 0;
|
|
break; // do default as well
|
|
|
|
case WM_VSCROLL:
|
|
return paw->_OnVerticalScroll( wParam, lParam );
|
|
|
|
case WM_HSCROLL:
|
|
return paw->_OnHorizontalScroll( wParam, lParam );
|
|
|
|
case WM_MOUSEWHEEL:
|
|
return paw->_OnMouseWheel( HIWORD(wParam) );
|
|
|
|
case WM_FIND_NEXT:
|
|
return paw->_FindNext( wParam, lParam );
|
|
|
|
case WM_MARK_ALL:
|
|
return paw->_MarkAll( wParam, lParam );
|
|
|
|
case WM_ERASEBKGND:
|
|
goto EraseBackground;
|
|
|
|
case WM_LBUTTONDOWN:
|
|
return paw->_OnLeftButtonDown( wParam, lParam );
|
|
}
|
|
|
|
return DefWindowProc( hWnd, uMsg, wParam, lParam );
|
|
}
|
|
|
|
if ( uMsg == WM_CREATE )
|
|
{
|
|
LPCREATESTRUCT pcs = (LPCREATESTRUCT) lParam;
|
|
paw = (CApplicationWindow *) pcs->lpCreateParams;
|
|
return paw->_OnCreate( hWnd, pcs );
|
|
}
|
|
|
|
if ( uMsg == WM_ERASEBKGND )
|
|
{
|
|
EraseBackground:
|
|
RECT rectWnd;
|
|
HBRUSH hBrush;
|
|
HDC hdc = (HDC) wParam;
|
|
|
|
GetClientRect( hWnd, &rectWnd );
|
|
|
|
#if defined(DEBUG_PAINT)
|
|
hBrush = CreateSolidBrush( 0xFF00FF );
|
|
#else
|
|
hBrush = CreateSolidBrush( GetSysColor( COLOR_WINDOW ) );
|
|
#endif
|
|
FillRect( hdc, &rectWnd, hBrush );
|
|
DeleteObject( hBrush );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return DefWindowProc( hWnd, uMsg, wParam, lParam );
|
|
}
|
|
|
|
// Mesage handler for about box.
|
|
LRESULT CALLBACK
|
|
CApplicationWindow::About(
|
|
HWND hDlg,
|
|
UINT message,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
switch (message)
|
|
{
|
|
case WM_INITDIALOG:
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
|
|
{
|
|
EndDialog(hDlg, LOWORD(wParam));
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
}
|
|
return FALSE;
|
|
}
|