开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 文件操作 > 查看源码
FILEMON.C
资源名称：filesrc.zip　[点击查看]
上传用户：hmgghm
上传日期：2007-01-07
资源大小：335k
文件大小：88k
源码类别：

文件操作

开发平台：

Visual C++

FILEMON.C：源码内容
  1. /******************************************************************************
  2. *
  3. *       FileMon - File System Monitor for Windows NT/9x
  4. *
  5. * Copyright (c) 1996-1998 Mark Russinovich and Bryce Cogswell
  6. *
  7. * See readme.txt for terms and conditions.
  8. *
  9. *     PROGRAM: FileMon.c
  10. *
  11. *     PURPOSE: Communicates with the FileMon driver to display 
  12. * file system activity information.
  13. *
  14. ******************************************************************************/
  15. #include <windows.h>    // includes basic windows functionality
  16. #include <windowsx.h>
  17. #include <tchar.h>
  18. #include <commctrl.h>   // includes the common control header
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <winioctl.h>
  22. #include "resource.h"
  23. #include "ioctlcmd.h"
  24. #include "filemon.h"
  25. #include "instdrv.h"
  27. HRESULT (CALLBACK *pDllGetVersionProc)( PDLLVERSIONINFO_ pdvi );
  29. // Handle to device driver
  30. static HANDLE SysHandle = INVALID_HANDLE_VALUE;
  32. // Drive name strings
  33. TCHAR DrvNames[][32] = {
  34. _T("UNKNOWN"),
  35. _T("FIXED"),
  36. _T("REMOTE"),
  37. _T("RAM"),
  38. _T("CD"),
  39. _T("REMOVEABLE"),
  40. };
  42. // drives that are hooked
  43. DWORD CurDriveSet;
  45. // The variable that holds the position settings
  46. POSITION_SETTINGS PositionInfo;
  48. // button definitions
  50. // for installations that support flat style
  51. TBBUTTON tbButtons[] = {
  52. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  53. { 0, IDM_SAVE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  54. { 8, 0, 0, TBSTYLE_BUTTON, 0L, 0},
  55. { 2, IDM_CAPTURE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  56. { 4, IDM_AUTOSCROLL, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  57. { 6, IDM_CLEAR, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  58. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  59. { 9, IDM_TIME, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0 },
  60. { 8, 0, 0, TBSTYLE_BUTTON, 0L, 0},
  61. { 5, IDM_FILTER, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  62. { 12, IDM_HISTORY, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  63. { 8, 0, 0, TBSTYLE_BUTTON, 0L, 0},
  64. { 7, IDM_FIND, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  65. { 11, IDM_JUMP, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  66. { 8, 0, 0, TBSTYLE_BUTTON, 0L, 0},
  67. };
  68. #define NUMBUTTONS 15
  70. // for older installations
  71. TBBUTTON tbButtonsOld[] = {
  72. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  73. { 0, IDM_SAVE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  74. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  75. { 2, IDM_CAPTURE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  76. { 4, IDM_AUTOSCROLL, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  77. { 6, IDM_CLEAR, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  78. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  79. { 9, IDM_TIME, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0 },
  80. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  81. { 5, IDM_FILTER, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  82. { 12, IDM_HISTORY, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  83. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  84. { 7, IDM_FIND, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  85. { 11, IDM_JUMP, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  86. };
  88. #define NUMBUTTONSOLD 14
  91. // Buffer into which driver can copy statistics
  92. char Stats[ MAX_STORE ];
  93. // Current fraction of buffer filled
  94. DWORD StatsLen;
  96. // Search string
  97. TCHAR FindString[256];
  98. FINDREPLACE FindTextInfo;
  99. DWORD FindFlags = FR_DOWN;
  100. BOOLEAN PrevMatch;
  101. TCHAR PrevMatchString[256];
  103. // Application instance handle
  104. HINSTANCE hInst;
  106. // Are we running on NT or 9x?
  107. BOOLEAN IsNT;
  109. // Misc globals
  110. HWND hWndMain;
  111. HWND hWndFind = NULL;
  112. UINT findMessageID;
  113. HWND hWndList;
  114. WNDPROC  ListViewWinMain;
  115. HWND hBalloon = NULL;
  116. BOOLEAN Capture = TRUE;
  117. BOOLEAN Autoscroll = TRUE;
  118. BOOLEAN Deleting = TRUE;
  119. BOOLEAN OnTop = FALSE;
  120. BOOLEAN ShowToolbar = TRUE;
  121. BOOLEAN HookPipes = FALSE;
  122. BOOLEAN HookSlots = FALSE;
  124. // Highlight colors
  125. DWORD HighlightFg;
  126. DWORD HighlightBg;
  128. // listview size limiting
  129. DWORD MaxLines = 0;
  130. DWORD LastRow = 0;
  132. // is time absolute or duration?
  133. BOOLEAN TimeIsDuration;
  135. // Filter strings
  136. TCHAR FilterString[MAXFILTERLEN];
  137. TCHAR ExcludeString[MAXFILTERLEN];
  138. TCHAR HighlightString[MAXFILTERLEN];
  140. // Recent filters
  141. char RecentInFilters[NUMRECENTFILTERS][MAXFILTERLEN];
  142. char RecentExFilters[NUMRECENTFILTERS][MAXFILTERLEN];
  143. char RecentHiFilters[NUMRECENTFILTERS][MAXFILTERLEN];
  145. // Filter-related
  146. FILTER FilterDefinition;
  148. // For info saving
  149. TCHAR szFileName[MAX_PATH];
  150. BOOLEAN FileChosen = FALSE;
  152. // font
  153. HFONT hFont;
  154. LOGFONT LogFont;
  156. // General buffer for storing temporary strings
  157. static TCHAR msgbuf[MAX_PATH];
  159. // General cursor manipulation
  160. HCURSOR  hSaveCursor;
  161. HCURSOR  hHourGlass;
  163. // performance counter frequency
  164. LARGE_INTEGER PerfFrequency;
  167. /******************************************************************************
  168. *
  169. * FUNCTION: Abort:
  170. *
  171. * PURPOSE: Handles emergency exit conditions.
  172. *
  173. *****************************************************************************/
  174. DWORD Abort( HWND hWnd, TCHAR * Msg )
  175. {
  176. LPVOID lpMsgBuf;
  177. TCHAR errmsg[MAX_PATH];
  178. DWORD error = GetLastError();
  179.  
  180. FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  181. NULL, GetLastError(), 
  182. MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  183. (LPTSTR) &lpMsgBuf, 0, NULL );
  184. if( IsNT ) UnloadDeviceDriver( SYS_NAME );
  185. _stprintf(errmsg, _T("%s: %s"), Msg, lpMsgBuf );
  186. if( error == ERROR_INVALID_HANDLE && IsNT ) 
  187. _stprintf(errmsg, _T("%snMake sure that you are an administrator and that ")
  188. _T("Filemon is located on a local drive."), errmsg  );
  189. MessageBox( hWnd, errmsg, _T("Filemon"), MB_OK|MB_ICONERROR );
  190. PostQuitMessage( 1 );
  191. LocalFree( lpMsgBuf );
  192. return -1;
  193. }
  196. /******************************************************************************
  197. *
  198. * FUNCTION: ExplorerJump
  199. *
  200. * PURPOSE: Opens Explorer and navigates the desired file/folder
  201. *
  202. *****************************************************************************/
  203. void ExplorerJump( HWND hWnd )
  204. {
  205. int currentItem;
  206. char path[MAX_PATH], msg[MAX_PATH*2];
  207. char *lastslash = NULL;
  208. char *ptr;
  210. // See if we can get a Registry path out of the listview
  211. // find the item with the focus
  212. currentItem = ListView_GetNextItem( hWndList, -1, LVNI_SELECTED );
  214. if( currentItem == -1 ) {
  216. MessageBox( hWnd, "No item selected.", APPNAME, MB_OK|MB_ICONWARNING );
  217. return;
  218. }
  219. memset( path, 0, MAX_PATH );
  220. ListView_GetItemText( hWndList, currentItem, 4, path, MAX_PATH );
  222. // If the file is a handle reference, tell the user we're sorry
  223. if( path[0] == '0' ) {
  225. MessageBox( hWnd, "The full name of the selected directory or file is not available.",
  226. APPNAME, MB_OK|MB_ICONWARNING );
  227. return;
  228. }
  230. // Always explore the parent folder, if there is one
  231. ptr = path;
  232. while( *ptr ) {
  233. if( *ptr == '\' ) lastslash = ptr;
  234. ptr++;
  235. }
  236. if( lastslash ) *lastslash = 0;
  238. if( ShellExecute( hWnd, "explore", path, NULL, NULL, SW_SHOWNORMAL ) < (HINSTANCE) 32 ) {
  240. sprintf( msg, "Explorer could not open %s.", path );
  241. MessageBox( hWnd, msg, APPNAME, MB_OK|MB_ICONWARNING );
  242. return;
  243. }
  244. }
  247. /******************************************************************************
  248. *
  249. * FUNCTION: BalloonDialog
  250. *
  251. * PURPOSE: Dialog function for home-brewed balloon help.
  252. *
  253. ******************************************************************************/
  254. LONG APIENTRY BalloonDialog( HWND hDlg, UINT message, UINT wParam, LONG lParam )
  255. {
  256. static ITEM_CLICK ctx;
  257. static RECT rect;
  258. static HFONT hfont;
  259. LPCREATESTRUCT lpcs;
  260. HDC hdc;
  261. POINTS pts;
  262. POINT pt;
  263. DWORD newclicktime;
  264. static POINT lastclickpt = {0,0};
  265. static DWORD lastclicktime = 0;
  267. switch (message) {
  268. case WM_CREATE:
  270. lpcs = (void *)lParam;
  271. ctx = *(PITEM_CLICK) lpcs->lpCreateParams;
  272. hdc = GetDC( hDlg );
  274. // is the app the focus?
  275. if( !GetFocus()) return -1;
  277. // Compute size of required rectangle
  278. rect.left = 0;
  279. rect.top = 1;
  280. rect.right = lpcs->cx;
  281. rect.bottom = lpcs->cy;
  282. SelectObject( hdc, hFont );
  283. DrawText( hdc, ctx.itemText, -1, &rect, 
  284. DT_NOCLIP|DT_LEFT|DT_NOPREFIX|DT_CALCRECT );
  286. // if the bounding rectangle of the subitem is big enough to display
  287. // the text then don't pop the balloon
  288. if( ctx.itemPosition.right > rect.right + 3 ) {
  290. return -1;
  291. }
  293. // Move and resize window
  294. if( ctx.itemPosition.left - 5 + rect.right + 10 >
  295.  GetSystemMetrics(SM_CXFULLSCREEN) ) {
  297.  ctx.itemPosition.left = GetSystemMetrics(SM_CXFULLSCREEN) -
  298. (rect.right+10);
  299. }
  300. MoveWindow( hDlg, 
  301. ctx.itemPosition.left-1, ctx.itemPosition.top, 
  302. rect.right + 6, 
  303. rect.bottom + 1,
  304. TRUE );
  306. // Adjust rectangle so text is centered
  307. rect.left += 2;
  308. rect.right += 2;
  309. rect.top -= 1; 
  310. rect.bottom += 0;
  312. // make it so this window doesn't get the focus
  313. ShowWindow( hDlg, SW_SHOWNOACTIVATE );
  314. break;
  316. case WM_LBUTTONDBLCLK:
  317. case WM_RBUTTONDBLCLK:
  318. case WM_MBUTTONDBLCLK:
  319. case WM_LBUTTONDOWN:
  320. case WM_RBUTTONDOWN:
  321. case WM_MBUTTONDOWN:
  322. case WM_LBUTTONUP:
  323. case WM_RBUTTONUP:
  324. case WM_MBUTTONUP:
  326. pts = MAKEPOINTS( lParam );
  327. pt.x = (LONG) pts.x;
  328. pt.y = (LONG) pts.y;
  329. ClientToScreen( hDlg, &pt );
  331. // pass this through to the listview
  332. if( ScreenToClient( hWndList, &pt )) {
  334. if( message == WM_LBUTTONDOWN ) {
  336. // see if its a double click
  337. newclicktime = GetTickCount();
  338. if( pt.x == lastclickpt.x && pt.y == lastclickpt.y && 
  339. newclicktime - lastclicktime < 300 ) {
  341. message = WM_LBUTTONDBLCLK;
  342. }
  343. lastclicktime = newclicktime;
  344. lastclickpt = pt;
  345. }
  347. PostMessage( hWndList, message, wParam, (SHORT) pt.y<<16 | (SHORT) pt.x );
  348. }
  349. break;
  351. case WM_PAINT:
  352. hdc = GetDC( hDlg );
  354. // Set colors
  355. SetTextColor( hdc, 0x00000000 );
  356. SetBkMode( hdc, TRANSPARENT );
  357. SelectObject( hdc, hFont );
  358. DrawText( hdc, ctx.itemText, -1, &rect, 
  359. DT_NOCLIP|DT_LEFT|DT_NOPREFIX|DT_WORDBREAK );
  360. break;
  362. case WM_DESTROY:
  363. hBalloon = NULL;
  364. break;
  366. case WM_CLOSE:
  367. DestroyWindow( hDlg );
  368. break;
  369. }
  371.     return DefWindowProc( hDlg, message, wParam, lParam );
  372. }
  375. /******************************************************************************
  376. *
  377. * FUNCTION: CopySelection
  378. *
  379. * PURPOSE: Copies the currently selected line in the output to the clip
  380. * board.
  381. *
  382. *****************************************************************************/
  383. void CopySelection( HWND hWnd )
  384. {
  385.     LPTSTR  lptstrCopy; 
  386.     HGLOBAL hglbCopy; 
  387. DWORD size = 0, newSize;
  388. int currentItem, iColumn;
  389. TCHAR curText[MAXITEMLENGTH];
  390. TCHAR selectedText[NUMCOLUMNS * MAXITEMLENGTH];
  392. // Get the currently selected item and construct
  393. // the message to go to the clipboard
  394. currentItem = ListView_GetNextItem( hWndList, -1, LVNI_SELECTED );
  395. if( currentItem == -1 ) {
  397. return;
  398. }
  399. selectedText[0] = 0;
  400. for( iColumn = 1; iColumn < NUMCOLUMNS; iColumn++ ) {
  402. curText[0] = 0;
  403. ListView_GetItemText( hWndList, currentItem, iColumn, 
  404. curText, MAXITEMLENGTH );
  405. strcat( selectedText, curText );
  406. strcat( selectedText, "t");
  407. }
  408. strcat( selectedText, "rn");
  410. // Empty the clipboard
  411.     if (!OpenClipboard( hWnd )) return; 
  412.     EmptyClipboard(); 
  414. size = strlen( selectedText )+1;
  415.     hglbCopy = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, size ); 
  416.     lptstrCopy = GlobalLock(hglbCopy); 
  417.     strcpy(lptstrCopy, selectedText );
  418.     GlobalUnlock(hglbCopy); 
  420. while( (currentItem = ListView_GetNextItem( hWndList, currentItem, 
  421. LVNI_SELECTED )) != -1) {
  422. selectedText[0] = 0;
  423. for( iColumn = 1; iColumn < NUMCOLUMNS; iColumn++ ) {
  425. curText[0] = 0;
  426. ListView_GetItemText( hWndList, currentItem, iColumn, 
  427. curText, MAXITEMLENGTH );
  428. strcat( selectedText, curText );
  429. strcat( selectedText, "t");
  430. }
  431. strcat( selectedText, "rn");
  433. newSize = size + strlen( selectedText );
  434. hglbCopy = GlobalReAlloc( hglbCopy, newSize, 0 );
  435. lptstrCopy = GlobalLock(hglbCopy); 
  436. strcpy( &lptstrCopy[size-1], selectedText );
  437. GlobalUnlock(hglbCopy); 
  439. size = newSize;
  440. }
  442. // Place it in the clipboard
  443. SetClipboardData(CF_TEXT, hglbCopy); 
  444.     CloseClipboard(); 
  445. }
  448. /******************************************************************************
  449. *
  450. * FUNCTION: CCHookProc
  451. *
  452. * PURPOSE: We use a hook procedure to force the stupid color
  453. * selection dialog to do what we want, including preview
  454. * the highlight text.
  455. *
  456. *****************************************************************************/
  457. UINT CALLBACK CCHookProc( HWND hDlg, 
  458.   UINT uiMsg, WPARAM wParam,  
  459.   LPARAM lParam )
  460. {
  461. static HWND  sample;
  462. static DWORD  newFg, newBg;
  463. static UINT colorOkString, setRgbString;
  465. switch( uiMsg ) {
  466. case WM_INITDIALOG:
  467. sample = GetDlgItem( hDlg, IDC_SAMPLE );
  468. newFg = HighlightFg;
  469. newBg = HighlightBg;
  470. colorOkString = RegisterWindowMessage( COLOROKSTRING );
  471. setRgbString  = RegisterWindowMessage( SETRGBSTRING ); 
  472. CheckRadioButton( hDlg, IDC_RADIOFG, IDC_RADIOBG, IDC_RADIOFG );
  473. SendMessage(hDlg, setRgbString, 0, newFg); 
  474. SetFocus( GetDlgItem( hDlg, IDC_DONE ));
  475. break;
  476. case WM_CTLCOLORSTATIC:
  477. if( (HWND) lParam == sample ) {
  478. SetBkColor(GET_WM_CTLCOLOR_HDC(wParam, lParam, msg), 
  479.                     newBg); 
  480. SetTextColor(GET_WM_CTLCOLOR_HDC(wParam, lParam, msg), 
  481.                     newFg); 
  482.             return (BOOL)GetStockObject(WHITE_BRUSH); 
  483. }
  484. break;
  485. case WM_COMMAND:
  486. if( wParam == IDC_DONE ) {
  487. HighlightFg = newFg;
  488. HighlightBg = newBg;
  489. PostMessage( hDlg, WM_COMMAND, IDABORT, 0 );
  490. return FALSE;
  491. }
  492. break;
  493. default:
  494. if( uiMsg == colorOkString ) {
  495. if( !IsDlgButtonChecked( hDlg, IDC_RADIOBG )) {
  496. newFg = ((LPCHOOSECOLOR) lParam)->rgbResult;
  497. InvalidateRect( sample, NULL, TRUE );
  498. SendMessage(hDlg, setRgbString, 0, newBg); 
  499. return TRUE;
  500. } else {
  501. newBg = ((LPCHOOSECOLOR) lParam)->rgbResult;
  502. InvalidateRect( sample, NULL, TRUE );
  503. SendMessage(hDlg, setRgbString, 0, newFg); 
  504. return TRUE;
  505. }
  506. }
  507. break;
  508. }
  509. return 0;
  510. }
  513. /******************************************************************************
  514. *
  515. * FUNCTION: SelectHighlightColors
  516. *
  517. * PURPOSE: Let's the user pick the highlight foreground and background
  518. * colors.
  519. *
  520. *****************************************************************************/
  521. VOID SelectHighlightColors( HWND hWnd )
  522. {
  523. DWORD dwColor;
  524. DWORD dwCustClrs [16];
  525. BOOL fSetColor = FALSE;
  526. int i;
  527. CHOOSECOLOR chsclr;
  529. for (i = 0; i < 15; i++)
  530. dwCustClrs [i] = RGB (255, 255, 255);
  531. dwColor = RGB (0, 0, 0);
  532. chsclr.lStructSize = sizeof (CHOOSECOLOR);
  533. chsclr.hwndOwner = hWnd;
  534. chsclr.hInstance = (HANDLE) hInst;
  535. chsclr.rgbResult = dwColor;
  536. chsclr.lpCustColors = (LPDWORD)dwCustClrs;
  537. chsclr.lCustData = 0L;
  538. chsclr.rgbResult = HighlightFg;
  539. chsclr.lpTemplateName = "CHOOSECOLORFG";
  540. chsclr.lpfnHook = (LPCCHOOKPROC)(FARPROC)CCHookProc;
  541. chsclr.Flags = CC_RGBINIT|CC_PREVENTFULLOPEN|
  542. CC_ENABLEHOOK|CC_ENABLETEMPLATE;
  543. ChooseColor (&chsclr);
  544. // Redraw to apply
  545. InvalidateRect( hWndList, NULL, TRUE );
  546. } 
  549. /******************************************************************************
  550. *
  551. * FUNCTION: FindInListview:
  552. *
  553. * PURPOSE: Searches for a string in the listview. Note: its okay if
  554. * items are being added to the list view or the list view
  555. * is cleared while this search is in progress - the effect
  556. * is harmless.
  557. *
  558. *****************************************************************************/
  559. BOOLEAN FindInListview(HWND hWnd, LPFINDREPLACE FindInfo )
  560. {
  561. int currentItem, clearItem;
  562. DWORD i;
  563. int subitem, numItems;
  564. TCHAR fieldtext[MAXITEMLENGTH];
  565. BOOLEAN match = FALSE;
  566. TCHAR errmsg[MAX_PATH];
  567. BOOLEAN goUp;
  569. // get the search direction
  570. goUp = ((FindInfo->Flags & FR_DOWN) == FR_DOWN);
  572. // initialize stuff
  573. if( !(numItems = ListView_GetItemCount( hWndList ))) {
  575. MessageBox( hWnd, TEXT("No items to search"), TEXT(APPNAME), 
  576. MB_OK|MB_ICONWARNING );
  577. if( hWndFind ) SetForegroundWindow( hWndFind );
  578. return FALSE;
  579. }
  581. // find the item with the focus
  582. currentItem = ListView_GetNextItem( hWndList, -1, LVNI_SELECTED );
  584. // if no current item, start at the top or the bottom
  585. if( currentItem == -1 ) {
  586. if( goUp )
  587. currentItem = 0;
  588. else {
  589. if( PrevMatch ) {
  590. sprintf(errmsg, TEXT("Cannot find string "%s""), FindInfo->lpstrFindWhat );
  591. MessageBox( hWnd, errmsg, TEXT(APPNAME), MB_OK|MB_ICONWARNING );
  592. if( hWndFind ) SetForegroundWindow( hWndFind );
  593. else SetFocus( hWndList );
  594. return FALSE;
  595. }
  596. currentItem = numItems;
  597. }
  598. }
  600. // if we're continuing a search, start with the next item
  601. if( PrevMatch && !strcmp( FindString, PrevMatchString ) ) {
  602. if( goUp ) currentItem++;
  603. else currentItem--;
  605. if( (!goUp && currentItem < 0) ||
  606. (goUp && currentItem >= numItems )) {
  608. sprintf(errmsg, TEXT("Cannot find string "%s""), FindInfo->lpstrFindWhat );
  609. MessageBox( hWnd, errmsg, TEXT(APPNAME), MB_OK|MB_ICONWARNING );
  610. if( hWndFind ) SetForegroundWindow( hWndFind );
  611. else SetFocus( hWndList );
  612. return FALSE;
  613. }
  614. }
  616. // loop through each item looking for the string
  617. while( 1 ) {
  619. // get the item text
  620. for( subitem = 0; subitem < NUMCOLUMNS; subitem++ ) {
  621. fieldtext[0] = 0;
  622. ListView_GetItemText( hWndList, currentItem, subitem, fieldtext, 256 );
  624. // make sure enought string for a match
  625. if( strlen( fieldtext ) < strlen( FindInfo->lpstrFindWhat ))
  626. continue;
  628. // do a scan all the way through for the substring
  629. if( FindInfo->Flags & FR_WHOLEWORD ) {
  631. i = 0;
  632. while( fieldtext[i] ) {
  633. while( fieldtext[i] && fieldtext[i] != ' ' ) i++;
  634. if( FindInfo->Flags & FR_MATCHCASE ) 
  635. match = !strcmp( fieldtext, FindInfo->lpstrFindWhat );
  636. else
  637. match = !stricmp( fieldtext, FindInfo->lpstrFindWhat );
  638. if( match) break;
  639. i++;
  640. }
  641. } else {
  642. for( i = 0; i < strlen( fieldtext ) - strlen(FindInfo->lpstrFindWhat)+1; i++ ) {
  643. if( FindInfo->Flags & FR_MATCHCASE ) 
  644. match = !strncmp( &fieldtext[i], FindInfo->lpstrFindWhat, 
  645. strlen(FindInfo->lpstrFindWhat) );
  646. else
  647. match = !strnicmp( &fieldtext[i], FindInfo->lpstrFindWhat,
  648. strlen(FindInfo->lpstrFindWhat) );
  649. if( match ) break;
  650. }
  651. }
  653. if( match ) {
  655. strcpy( PrevMatchString, FindInfo->lpstrFindWhat );
  656. PrevMatch = TRUE;
  657. // Clear all previously-selected items
  658. while( (clearItem = ListView_GetNextItem( hWndList, -1, LVNI_SELECTED )) != -1 ) {
  659. ListView_SetItemState( hWndList, clearItem, 0, LVIS_SELECTED|LVIS_FOCUSED );
  660. }
  661. ListView_SetItemState( hWndList, currentItem, 
  662. LVIS_SELECTED|LVIS_FOCUSED,
  663. LVIS_SELECTED|LVIS_FOCUSED );
  664. ListView_EnsureVisible( hWndList, currentItem, FALSE ); 
  665. SetFocus( hWndList );
  666. return TRUE;
  667. }
  668. }
  669. currentItem = currentItem + (goUp ? 1:-1);
  670. if( !currentItem || currentItem == numItems+1 ) {
  671. // end of the road
  672. break;
  673. }
  674. }
  675. sprintf(errmsg, TEXT("Cannot find string "%s""), FindInfo->lpstrFindWhat );
  676. MessageBox( hWnd, errmsg, TEXT(APPNAME), MB_OK|MB_ICONWARNING );
  677. if( hWndFind ) SetForegroundWindow( hWndFind );
  678. else SetFocus( hWndList );
  679. return FALSE;
  680. }
  683. /******************************************************************************
  684. *
  685. * FUNCTION: PopFindDialog:
  686. *
  687. * PURPOSE: Calls the find message dialog box.
  688. *
  689. *****************************************************************************/
  690. void PopFindDialog(HWND hWnd)
  691. {
  692. _tcscpy( FindString, PrevMatchString );
  693.     FindTextInfo.lStructSize = sizeof( FindTextInfo );
  694.     FindTextInfo.hwndOwner = hWnd;
  695.     FindTextInfo.hInstance = (HANDLE)hInst;
  696.     FindTextInfo.lpstrFindWhat = FindString;
  697.     FindTextInfo.lpstrReplaceWith = NULL;
  698.     FindTextInfo.wFindWhatLen = sizeof(FindString);
  699.     FindTextInfo.wReplaceWithLen = 0;
  700.     FindTextInfo.lCustData = 0;
  701.     FindTextInfo.Flags =  FindFlags;
  702.     FindTextInfo.lpfnHook = (LPFRHOOKPROC)(FARPROC)NULL;
  703.     FindTextInfo.lpTemplateName = NULL;
  705.     if ((hWndFind = FindText(&FindTextInfo)) == NULL)
  706. MessageBox( hWnd, _T("Unable to create Find dialog"), APPNAME, MB_OK|MB_ICONERROR );      
  707. }
  709. /****************************************************************************
  710. *
  711. * FUNCTION: MatchOkay
  712. *
  713. * PURPOSE: Only thing left after compare is more mask. This routine makes
  714. * sure that its a valid wild card ending so that its really a match.
  715. *
  716. ****************************************************************************/
  717. BOOLEAN MatchOkay( PCHAR Pattern )
  718. {
  719.     // If pattern isn't empty, it must be a wildcard
  720.     if( *Pattern && *Pattern != '*' ) {
  721.  
  722.        return FALSE;
  723.     }
  725.     // Matched
  726.     return TRUE;
  727. }
  730. /****************************************************************************
  731. *
  732. * FUNCTION: MatchWithPatternCore
  733. *
  734. * PURPOSE: Performs nifty wildcard comparison.
  735. *
  736. ****************************************************************************/
  737. BOOLEAN MatchWithPatternCore( PCHAR Pattern, PCHAR Name )
  738. {
  739. char matchchar;
  741.     // End of pattern?
  742.     if( !*Pattern ) {
  743.         return FALSE;
  744.     }
  746.     // If we hit a wild card, do recursion
  747.     if( *Pattern == '*' ) {
  749.         Pattern++;
  750.         while( *Name && *Pattern ) {
  752. matchchar = *Name;
  753. if( matchchar >= 'a' && 
  754. matchchar <= 'z' ) {
  756. matchchar -= 'a' - 'A';
  757. }
  759.             // See if this substring matches
  760.     if( *Pattern == matchchar ) {
  762.            if( MatchWithPatternCore( Pattern+1, Name+1 )) {
  764.                     return TRUE;
  765.                 }
  766.             }
  768.             // Try the next substring
  769.             Name++;
  770.         }
  772.         // See if match condition was met
  773.         return MatchOkay( Pattern );
  774.     } 
  776.     // Do straight compare until we hit a wild card
  777.     while( *Name && *Pattern != '*' ) {
  779. matchchar = *Name;
  780. if( matchchar >= 'a' && 
  781. matchchar <= 'z' ) {
  783. matchchar -= 'a' - 'A';
  784. }
  786.         if( *Pattern == matchchar ) {
  787.             Pattern++;
  788.             Name++;
  790.         } else {
  792.             return FALSE;
  793. }
  794.     }
  796.     // If not done, recurse
  797.     if( *Name ) {
  799.         return MatchWithPatternCore( Pattern, Name );
  800.     }
  802.     // Make sure its a match
  803.     return MatchOkay( Pattern );
  804. }
  807. /****************************************************************************
  808. *
  809. * FUNCTION: MatchWithHighlightPattern
  810. *
  811. * PURPOSE: Converts strings to upper-case before calling core 
  812. * comparison routine.
  813. *
  814. ****************************************************************************/
  815. BOOLEAN MatchWithHighlightPattern( PCHAR String )
  816. {
  817. char    *filterPtr;
  818. char    curFilterBuf[MAXFILTERLEN];
  819. char    *curFilter, *endFilter;
  821. // Is there a highlight filter?
  822. if( HighlightString[0] == ' ' &&
  823. !HighlightString[1] ) return FALSE;
  825. // see if its in an highlight
  826. filterPtr = HighlightString;
  827. curFilter = curFilterBuf;
  828. while( 1 ) {
  830. endFilter = strchr( filterPtr, ';' );
  831. if( !endFilter )
  832. curFilter = filterPtr;
  833. else {
  834. strncpy( curFilter, filterPtr, (int) (endFilter - filterPtr ) );
  835. curFilter[ (int) (endFilter - filterPtr ) ] = 0;
  836. }
  838. // Now do the comparison
  839. if( MatchWithPatternCore( curFilter, String ) ) {
  841. return TRUE;
  842. }
  844. if( endFilter ) filterPtr = endFilter+1;
  845. else break;
  846. }
  847. return FALSE;
  848. }
  851. /****************************************************************************
  852. *
  853. * FUNCTION: FilterProc
  854. *
  855. * PURPOSE: Processes messages for "Filter" dialog box
  856. *
  857. ****************************************************************************/
  858. BOOL APIENTRY FilterProc( HWND hDlg, UINT message, UINT wParam, LONG lParam )
  859. {
  860. char newFilter[MAXFILTERLEN];
  861. char newExFilter[MAXFILTERLEN];
  862. char newHiFilter[MAXFILTERLEN], oldHighlight[MAXFILTERLEN];
  863. int i, j, nb;
  864. static HWND hInFilter;
  865. static HWND hExFilter;
  866. static HWND hHiFilter;
  868. switch ( message )  {
  869. case WM_INITDIALOG:
  871. // initialize the controls to reflect the current filter
  872. // We use a ' ' as a placeholder in the filter strings to represent no filter ("")
  873. hInFilter = GetDlgItem( hDlg, IDC_FILTERSTRING );
  874. for( i = 0; i < NUMRECENTFILTERS; i++ ) {
  875. if( RecentInFilters[i][0] ) {
  876. SendMessage( hInFilter, CB_ADDSTRING, 0, 
  877. (LPARAM ) (strcmp( RecentInFilters[i], " ") ? 
  878. RecentInFilters[i] : ""));
  879. }
  880. }
  881. hExFilter = GetDlgItem( hDlg, IDC_EXFILTERSTRING );
  882. for( i = 0; i < NUMRECENTFILTERS; i++ ) {
  883. if( RecentExFilters[i][0] ) {
  884. SendMessage( hExFilter, CB_ADDSTRING, 0, 
  885. (LPARAM ) (strcmp( RecentExFilters[i], " ") ? 
  886. RecentExFilters[i] : ""));
  887. }
  888. }
  889. hHiFilter = GetDlgItem( hDlg, IDC_HIFILTERSTRING );
  890. for( i = 0; i < NUMRECENTFILTERS; i++ ) {
  891. if( RecentHiFilters[i][0] ) {
  892. SendMessage( hHiFilter, CB_ADDSTRING, 0, 
  893. (LPARAM ) (strcmp( RecentHiFilters[i], " ") ? 
  894. RecentHiFilters[i] : ""));
  895. }
  896. }
  897. SendMessage( hInFilter, CB_SETCURSEL, 0, 0);
  898. SendMessage( hExFilter, CB_SETCURSEL, 0, 0);
  899. SendMessage( hHiFilter, CB_SETCURSEL, 0, 0);
  901. // Set the check box stats
  902. CheckDlgButton( hDlg, IDC_READ, 
  903. FilterDefinition.logreads ? BST_CHECKED : BST_UNCHECKED );
  904. CheckDlgButton( hDlg, IDC_WRITE, 
  905. FilterDefinition.logwrites ? BST_CHECKED : BST_UNCHECKED );
  906. return TRUE;
  908. case WM_COMMAND:              
  909. strcpy( oldHighlight, HighlightString );
  910. if ( LOWORD( wParam ) == IDOK )  {
  912. // make sure that max lines is legal
  913. GetDlgItemTextA( hDlg, IDC_FILTERSTRING, newFilter, MAXFILTERLEN );
  914. GetDlgItemTextA( hDlg, IDC_EXFILTERSTRING, newExFilter, MAXFILTERLEN );
  915. GetDlgItemTextA( hDlg, IDC_HIFILTERSTRING, newHiFilter, MAXFILTERLEN );
  916. if( !newFilter[0] ) strcpy( newFilter, " " );
  917. if( !newExFilter[0] ) strcpy( newExFilter, " " );
  918. if( !newHiFilter[0] ) strcpy( newHiFilter, " " );
  920. strcpy( FilterString, newFilter );
  921. strupr( FilterString );
  922. for( i = 0; i < NUMRECENTFILTERS; i++ ) {
  923. if( !stricmp( RecentInFilters[i], newFilter )) {
  924. i++;
  925. break;
  926. }
  927. }
  928. for( j = i-2; j != (DWORD) -1; j-- ) {
  929. strcpy( RecentInFilters[j+1], RecentInFilters[j] );
  930. }
  931. strcpy( RecentInFilters[0], newFilter );
  933. strcpy( ExcludeString, newExFilter );
  934. strupr( ExcludeString );
  935. for( i = 0; i < NUMRECENTFILTERS; i++ ) {
  936. if( !stricmp( RecentExFilters[i], newExFilter )) {
  937. i++;
  938. break;
  939. }
  940. }
  941. for( j = i-2; j != (DWORD) -1; j-- ) {
  942. strcpy( RecentExFilters[j+1], RecentExFilters[j] );
  943. }
  944. strcpy( RecentExFilters[0], newExFilter );
  946. strcpy( HighlightString, newHiFilter );
  947. strupr( HighlightString );
  948. for( i = 0; i < NUMRECENTFILTERS; i++ ) {
  949. if( !stricmp( RecentHiFilters[i], newHiFilter )) {
  950. i++;
  951. break;
  952. }
  953. }
  954. for( j = i-2; j != (DWORD) -1; j-- ) {
  955. strcpy( RecentHiFilters[j+1], RecentHiFilters[j] );
  956. }
  957. strcpy( RecentHiFilters[0], newHiFilter );
  959. if( stricmp( oldHighlight, HighlightString )) {
  960. InvalidateRgn( hWndList, NULL, TRUE );
  961. }
  963. // Get the button states
  964. FilterDefinition.logreads = 
  965. (IsDlgButtonChecked( hDlg, IDC_READ ) == BST_CHECKED);
  966. FilterDefinition.logwrites = 
  967. (IsDlgButtonChecked( hDlg, IDC_WRITE ) == BST_CHECKED);
  969. EndDialog( hDlg, TRUE );
  971. // Apply the new filter
  972. FilterDefinition.excludefilter[0] = 0;
  973. FilterDefinition.includefilter[0] = 0;
  974. if( strcmp( ExcludeString, " " ) )
  975. strcpy( FilterDefinition.excludefilter, ExcludeString );
  976. if( strcmp( FilterString, " " ) )
  977. strcpy( FilterDefinition.includefilter, FilterString );
  978. if ( ! DeviceIoControl( SysHandle, IOCTL_FILEMON_SETFILTER,
  979. (PVOID) &FilterDefinition, sizeof(FilterDefinition), 
  980. NULL, 0, &nb, NULL ) ) {
  982. MessageBox( hDlg, TEXT("Couldn't access device driver"), APPNAME, MB_ICONERROR );
  983. return FALSE;
  984. }
  985. return TRUE;
  987. } else if( LOWORD( wParam ) == IDCANCEL ) {
  989. EndDialog( hDlg, TRUE );
  991. } else if( LOWORD( wParam ) == IDRESET ) {
  993. // initialize the controls to reflect the current filter
  994. SetDlgItemText( hDlg, IDC_FILTERSTRING, "*" );
  995. SetDlgItemText( hDlg, IDC_EXFILTERSTRING, "" );
  996. SetDlgItemText( hDlg, IDC_HIFILTERSTRING, "" );
  997. CheckDlgButton( hDlg, IDC_READ, BST_CHECKED );
  998. CheckDlgButton( hDlg, IDC_WRITE, BST_CHECKED );
  1000. if( stricmp( oldHighlight, HighlightString )) {
  1001. InvalidateRgn( hWndList, NULL, TRUE );
  1002. }
  1003. }
  1004. break;
  1006. case WM_CLOSE:
  1007. EndDialog( hDlg, TRUE );
  1008. return TRUE;
  1009. }
  1010. return FALSE;   
  1011. }
  1013. /******************************************************************************
  1014. *
  1015. * FUNCTION: GetPositionSettings
  1016. *
  1017. * PURPOSE: Reads the Registry to get the last-set window position.
  1018. *
  1019. ******************************************************************************/
  1020. VOID GetPositionSettings()
  1021. {
  1022. HKEY hKey;
  1023. DWORD ParamSize, newPosSize, i;
  1024. POSITION_SETTINGS newPositionInfo;
  1025. LOGFONT lf;
  1026. char *nextString;
  1027. char recentExList[(MAXFILTERLEN+1) * NUMRECENTFILTERS + 1];
  1028. char recentInList[(MAXFILTERLEN+1) * NUMRECENTFILTERS + 1];
  1029. char recentHiList[(MAXFILTERLEN+1) * NUMRECENTFILTERS + 1];
  1031. // Default font
  1032. GetObject( GetStockObject(SYSTEM_FONT), sizeof lf, &lf ); 
  1033. lf.lfWeight = FW_NORMAL;
  1034. lf.lfHeight = 8;
  1035. lf.lfWidth  = 0;
  1036. strcpy( lf.lfFaceName, TEXT("MS Sans Serif") );
  1037. PositionInfo.font = lf;
  1039. // Fist, set the default settings
  1040. PositionInfo.top = CW_USEDEFAULT;
  1041. PositionInfo.left = CW_USEDEFAULT;
  1042. PositionInfo.width = CW_USEDEFAULT;
  1043. PositionInfo.height = CW_USEDEFAULT;
  1044. PositionInfo.maximized = FALSE;
  1045. PositionInfo.ontop = FALSE;
  1046. PositionInfo.hookpipes = FALSE;
  1047. PositionInfo.hookslots = FALSE;
  1048. PositionInfo.highlightfg = 0x00FFFFFF;
  1049. PositionInfo.highlightbg = 0x000000FF;
  1051. // set the default listview widths
  1052. PositionInfo.column[0] = 35;  // seq 
  1053. PositionInfo.column[1] = 90;  // time
  1054. PositionInfo.column[2] = 90;  // process
  1055. PositionInfo.column[3] = 130; // irp
  1056. PositionInfo.column[4] = 200; // path
  1057. PositionInfo.column[5] = 70;  // result
  1058. PositionInfo.column[6] = 150; // other
  1060. // intialize the hooked drives
  1061. PositionInfo.curdriveset = (DWORD) -1;
  1063. // duration is default
  1064. PositionInfo.timeduration = FALSE;
  1066. // initialize history depth
  1067. PositionInfo.historydepth = 0;
  1069. // initialize filter
  1070. recentInList[0] = '*';
  1071. recentInList[1] = 0;
  1072. recentInList[2] = 0;
  1073. recentExList[0] = 0;
  1074. recentHiList[0] = 0;
  1075. memset( RecentExFilters,   0, sizeof( RecentExFilters ));
  1076. memset( RecentInFilters,   0, sizeof( RecentInFilters ));
  1077. memset( RecentHiFilters,   0, sizeof( RecentHiFilters ));
  1078. PositionInfo.logreads = TRUE;
  1079. PositionInfo.logwrites = TRUE;
  1081. // first, get the last-entered params from the registry
  1082. RegCreateKey(HKEY_CURRENT_USER, FILEMON_SETTINGS_KEY, &hKey );
  1084. // get the params and ignore errors
  1085. newPosSize = sizeof( PositionInfo );
  1086. newPositionInfo.posversion = 0;
  1087. RegQueryValueEx( hKey,FILEMON_SETTINGS_VALUE, NULL, NULL, (LPBYTE) &newPositionInfo,
  1088. &newPosSize );
  1089. ParamSize = sizeof( recentInList );
  1090. RegQueryValueEx( hKey,FILEMON_RECENT_INFILTER_VALUE, NULL, NULL, (LPBYTE) &recentInList,
  1091. &ParamSize );
  1092. ParamSize = sizeof( recentExList );
  1093. RegQueryValueEx( hKey,FILEMON_RECENT_EXFILTER_VALUE, NULL, NULL, (LPBYTE) &recentExList,
  1094. &ParamSize );
  1095. ParamSize = sizeof( recentHiList );
  1096. RegQueryValueEx( hKey,FILEMON_RECENT_HIFILTER_VALUE, NULL, NULL, (LPBYTE) &recentHiList,
  1097. &ParamSize );
  1098. RegCloseKey( hKey );
  1100. // only use the registry settings if the version matches
  1101. if( newPositionInfo.posversion == POSITION_VERSION ) PositionInfo = newPositionInfo;
  1103. // extract global settings from the value returned from the Registry (or the default)
  1104. CurDriveSet = PositionInfo.curdriveset;
  1105. MaxLines = PositionInfo.historydepth;
  1106. TimeIsDuration = PositionInfo.timeduration;
  1107. OnTop = PositionInfo.ontop;
  1108. HookPipes = PositionInfo.hookpipes;
  1109. HookSlots = PositionInfo.hookslots;
  1111. // get misc device filter
  1112. FilterDefinition.logreads = PositionInfo.logreads;
  1113. FilterDefinition.logwrites = PositionInfo.logwrites;
  1115. // Set up the recent filter arrays
  1116. nextString = recentInList;
  1117. i = 0;
  1118. while( *nextString ) {
  1119. strcpy( RecentInFilters[i++], nextString );
  1120. nextString = &nextString[strlen(nextString)+1];
  1121. }
  1122. nextString = recentExList;
  1123. i = 0;
  1124. while( *nextString ) {
  1125. strcpy( RecentExFilters[i++], nextString );
  1126. nextString = &nextString[strlen(nextString)+1];
  1127. }
  1128. nextString = recentHiList;
  1129. i = 0;
  1130. while( *nextString ) {
  1131. strcpy( RecentHiFilters[i++], nextString );
  1132. nextString = &nextString[strlen(nextString)+1];
  1133. }
  1135. strcpy( FilterString, RecentInFilters[0] );
  1136. strupr( FilterString );
  1137. strcpy( ExcludeString, RecentExFilters[0] );
  1138. strupr( ExcludeString );
  1139. strcpy( HighlightString, RecentHiFilters[0] );
  1140. strupr( HighlightString );
  1142.     // Get font
  1143. LogFont     = PositionInfo.font;
  1144.   hFont       = CreateFontIndirect( &LogFont ); 
  1146. // set highlight colors
  1147. HighlightFg = PositionInfo.highlightfg;
  1148. HighlightBg = PositionInfo.highlightbg;
  1149. }
  1152. /******************************************************************************
  1153. *
  1154. * FUNCTION: SavePositionSettings
  1155. *
  1156. * PURPOSE: Saves the current window settings to the Registry.
  1157. *
  1158. ******************************************************************************/
  1159. VOID SavePositionSettings( HWND hWnd )
  1160. {
  1161. RECT rc;
  1162. int i;
  1163. char *nextInString, *nextExString, *nextHiString;
  1164. char recentExList[(MAXFILTERLEN+1) * NUMRECENTFILTERS + 1];
  1165. char recentInList[(MAXFILTERLEN+1) * NUMRECENTFILTERS + 1];
  1166. char recentHiList[(MAXFILTERLEN+1) * NUMRECENTFILTERS + 1];
  1167. HKEY hKey;
  1169. // set version #
  1170. PositionInfo.posversion = POSITION_VERSION;
  1172. // get the position of the main window
  1173. GetWindowRect( hWnd, &rc );
  1174. if( !IsIconic( hWnd )) {
  1176. PositionInfo.left = rc.left;
  1177. PositionInfo.top = rc.top;
  1178. PositionInfo.width = rc.right - rc.left;
  1179. PositionInfo.height = rc.bottom - rc.top;
  1180. } 
  1181. PositionInfo.showtoolbar = ShowToolbar;
  1182. PositionInfo.maximized = IsZoomed( hWnd );
  1183. PositionInfo.ontop = OnTop;
  1184. PositionInfo.hookpipes = HookPipes;
  1185. PositionInfo.hookslots = HookSlots;
  1187. // get the history depth
  1188. PositionInfo.historydepth = MaxLines;
  1190. // get time format
  1191. PositionInfo.timeduration = TimeIsDuration;
  1193. // get the widths of the listview columns
  1194. for( i = 0; i < NUMCOLUMNS; i++ ) {
  1195. PositionInfo.column[i] = ListView_GetColumnWidth( hWndList, i );
  1196. }
  1198. // save font
  1199. PositionInfo.font = LogFont;
  1201. // get misc device filters
  1202. PositionInfo.logreads = FilterDefinition.logreads;
  1203. PositionInfo.logwrites = FilterDefinition.logwrites;
  1205. // save highlight colors
  1206. PositionInfo.highlightfg = HighlightFg;
  1207. PositionInfo.highlightbg = HighlightBg;
  1209. // get the current drive set
  1210. PositionInfo.curdriveset = CurDriveSet;
  1212. // Save recent filters
  1213. recentInList[0] = 0;
  1214. nextInString = recentInList;
  1215. for( i = 0; i < NUMRECENTFILTERS; i++ ) {
  1216. if( !RecentInFilters[i][0] ) {
  1217. break;
  1218. }
  1219. strcpy( nextInString, RecentInFilters[i] );
  1220. nextInString = &nextInString[ strlen( nextInString ) + 1];
  1221. }
  1222. *nextInString = 0;
  1224. recentExList[0] = 0;
  1225. nextExString = recentExList;
  1226. for( i = 0; i < NUMRECENTFILTERS; i++ ) {
  1227. if( !RecentExFilters[i][0] ) {
  1228. break;
  1229. }
  1230. strcpy( nextExString, RecentExFilters[i] );
  1231. nextExString = &nextExString[ strlen( nextExString ) + 1];
  1232. }
  1233. *nextExString = 0;
  1235. recentHiList[0] = 0;
  1236. nextHiString = recentHiList;
  1237. for( i = 0; i < NUMRECENTFILTERS; i++ ) {
  1238. if( !RecentHiFilters[i][0] ) {
  1239. break;
  1240. }
  1241. strcpy( nextHiString, RecentHiFilters[i] );
  1242. nextHiString = &nextHiString[ strlen( nextHiString ) + 1];
  1243. }
  1244. *nextHiString = 0;
  1246. // save connection info to registry
  1247. RegOpenKey(HKEY_CURRENT_USER, FILEMON_SETTINGS_KEY, &hKey );
  1248. RegSetValueEx( hKey, FILEMON_SETTINGS_VALUE, 0, REG_BINARY, (LPBYTE) &PositionInfo,
  1249. sizeof( PositionInfo ) );
  1250. RegSetValueEx( hKey, FILEMON_RECENT_INFILTER_VALUE, 0, REG_BINARY, (LPBYTE) &recentInList,
  1251. nextInString - recentInList + 1 );
  1252. RegSetValueEx( hKey, FILEMON_RECENT_EXFILTER_VALUE, 0, REG_BINARY, (LPBYTE) &recentExList,
  1253. nextExString - recentExList + 1 );
  1254. RegSetValueEx( hKey, FILEMON_RECENT_HIFILTER_VALUE, 0, REG_BINARY, (LPBYTE) &recentHiList,
  1255. nextHiString - recentHiList + 1 );
  1256. CloseHandle( hKey );
  1257. }
  1260. /******************************************************************************
  1261. *
  1262. * FUNCTION: HookDrives
  1263. *
  1264. * PURPOSE: Hook the currently selected drives, updating menu checks
  1265. *
  1266. ******************************************************************************/
  1267. DWORD HookDrives( HMENU DriveMenu, DWORD MaxDriveSet, DWORD CurDriveSet ) 
  1268. {
  1269. DWORD nb;
  1270. DWORD drive;
  1272. // Tell device driver which drives to monitor
  1273. if ( ! DeviceIoControl( SysHandle, IOCTL_FILEMON_SETDRIVES,
  1274. &CurDriveSet, sizeof CurDriveSet,
  1275. &CurDriveSet, sizeof CurDriveSet,
  1276. &nb, NULL ) )
  1277. return 0;
  1279. // Update menu items
  1280. for ( drive = 0; drive < 32; ++drive )
  1281. if ( MaxDriveSet & (1<<drive) )  {
  1282. if ( CurDriveSet & (1<<drive) )
  1283. CheckMenuItem( DriveMenu, IDC_DRIVE+drive, MF_BYCOMMAND|MF_CHECKED );
  1284. else
  1285. CheckMenuItem( DriveMenu, IDC_DRIVE+drive, MF_BYCOMMAND|MF_UNCHECKED );
  1286. }
  1287. return CurDriveSet;
  1288. }
  1291. /******************************************************************************
  1292. *
  1293. * FUNCTION: Split
  1294. *
  1295. * PURPOSE: Split a delimited line into components
  1296. *
  1297. ******************************************************************************/
  1298. int Split( char * line, char delimiter, char * items[] )
  1299. {
  1300. int cnt = 0;
  1302. for (;;)  {
  1303. // Add prefix to list of components
  1304. items[cnt++] = line;
  1306. // Check for more components
  1307. line = strchr( line, delimiter );
  1308. if ( line == NULL )
  1309. return cnt;
  1311. // Terminate previous component and move to next
  1312. *line++ = '';
  1313. }
  1314. }
  1317. /******************************************************************************
  1318. *
  1319. * FUNCTION: ListAppend
  1320. *
  1321. * PURPOSE: Add a new line to List window
  1322. *
  1323. ******************************************************************************/
  1324. BOOL List_Append( HWND hWndList, DWORD seq, LONGLONG time, char * line )
  1325. {
  1326. LV_ITEM lvI; // list view item structure
  1327. int row;
  1328. char * items[NUMCOLUMNS];
  1329. int itemcnt = 0;
  1330. FILETIME localTime;
  1331. SYSTEMTIME systemTime;
  1333. // Split line into columns
  1334. itemcnt = Split( line, 't', items );
  1335. if ( itemcnt == 0 )
  1336. return FALSE;
  1338. // Determine row number for request
  1339. if ( *items[0] )  {
  1340. // Its a new request.  Put at end.
  1341. row = 0x7FFFFFFF;
  1342. } else {
  1343. // Its a status.  Locate its associated request.
  1344. lvI.mask = LVIF_PARAM;
  1345. lvI.iSubItem = 0;
  1346. for ( row = ListView_GetItemCount(hWndList) - 1; row >= 0; --row )  {
  1347. lvI.iItem = row;
  1348. if ( ListView_GetItem( hWndList, &lvI )  &&  (DWORD)lvI.lParam == seq )
  1349. break;
  1350. }
  1351. if ( row == -1 )
  1352. // No request associated with status.
  1353. return FALSE;
  1354. }
  1356. // Sequence number if a new item
  1357. if ( *items[0] )  {
  1358. _stprintf( msgbuf, _T("%d"), seq );
  1359. lvI.mask = LVIF_TEXT | LVIF_PARAM;
  1360. lvI.iItem = row;
  1361. lvI.iSubItem = 0;
  1362. lvI.pszText = msgbuf;
  1363. lvI.cchTextMax = lstrlen( lvI.pszText ) + 1;
  1364. lvI.lParam = seq;
  1365. row = ListView_InsertItem( hWndList, &lvI );
  1366. if ( row == -1 )  {
  1367. _stprintf( msgbuf, _T("Error adding item %d to list view"), seq );
  1368. MessageBox( hWndList, msgbuf, APPNAME, MB_OK|MB_ICONERROR );
  1369. return FALSE;
  1370. }
  1371.         LastRow = row;
  1372. }
  1374. if( IsNT ) {
  1376. // Time - note: in order to save space in the log records
  1377. // I convert all times read to date/times and, based on whether
  1378. // the year is reasonable, chose to interpret the time as 
  1379. // a timestamp or a duration.
  1380. FileTimeToLocalFileTime( (PFILETIME) &time, &localTime );
  1381. FileTimeToSystemTime( &localTime, &systemTime );
  1383. if( systemTime.wYear < 1998 || systemTime.wYear > 2100 ) {
  1385. _stprintf( msgbuf, _T("%10.8f"), (((float) time) /
  1386.   ((float) PerfFrequency.QuadPart)) );
  1387. } else {
  1389. GetTimeFormat( LOCALE_USER_DEFAULT, 0,
  1390. &systemTime, NULL, msgbuf, 64 );
  1391. }
  1392. } else {
  1394. if( TimeIsDuration ) {
  1396. _stprintf( msgbuf, _T("%10.8f"), (float) time * 0.8 / 1e6 );
  1398. } else {
  1400. DosDateTimeToFileTime( (WORD) (time >> 16), (WORD) time, &localTime );
  1401. FileTimeToSystemTime( &localTime, &systemTime );
  1402. GetTimeFormat( LOCALE_USER_DEFAULT, 0,
  1403. &systemTime, NULL, msgbuf, 64 );
  1404. }
  1405. }
  1406. ListView_SetItemText( hWndList, row, 1, msgbuf );
  1408. // Process name
  1409. if ( itemcnt>0 && *items[0] ) {
  1410. OemToChar( items[0], msgbuf );
  1411. ListView_SetItemText( hWndList, row, 2, msgbuf );
  1412. }
  1414. // Request type
  1415. if ( itemcnt>1 && *items[1] )  {
  1416. OemToChar( items[1], msgbuf );
  1417. ListView_SetItemText( hWndList, row, 3, msgbuf );
  1418. }
  1420. // Path
  1421. if ( itemcnt>2 && *items[2] )  {
  1422. OemToChar( items[2], msgbuf );
  1423. ListView_SetItemText( hWndList, row, 4, msgbuf );
  1424. }
  1426. // Result
  1427. if ( itemcnt>4 && *items[4] )  {
  1428. OemToChar( items[4], msgbuf );
  1429. ListView_SetItemText( hWndList, row, 5, msgbuf );
  1430. }
  1432. // Additional
  1433. if ( itemcnt>3 && *items[3] )  {
  1434. OemToChar( items[3], msgbuf );
  1435. ListView_SetItemText( hWndList, row, 6, msgbuf );
  1436. }
  1438. return TRUE;
  1439. }
  1442. /******************************************************************************
  1443. *
  1444. * FUNCTION: UpdateStatistics
  1445. *
  1446. * PURPOSE: Clear the statistics window and refill it with the current 
  1447. * contents of the statistics buffer.  Does not refresh the 
  1448. * buffer from the device driver.
  1449. *
  1450. ******************************************************************************/
  1451. void UpdateStatistics( HWND hWnd, HWND hWndList, BOOL Clear )
  1452. {
  1453. PENTRY ptr;
  1454. BOOLEAN itemsAdded = FALSE;
  1455. int totitems, i;
  1457. // Just return if nothing to do
  1458. if ( !Clear  &&  StatsLen < sizeof(int)+2 )
  1459. return;
  1461. // post hourglass icon
  1462. if( !IsNT ) {
  1464. hSaveCursor = SetCursor(hHourGlass);
  1465. SendMessage(hWndList, WM_SETREDRAW, FALSE, 0);
  1466. }
  1468. // Start with empty list
  1469. if ( Clear ) {
  1471. if( IsNT ) {
  1473. ListView_DeleteAllItems( hWndList );
  1474. } else {
  1476. totitems = ListView_GetItemCount( hWndList );
  1477. Deleting = TRUE;
  1478. for(i = 0; i < totitems; i++)
  1479. ListView_DeleteItem( hWndList, 0 );
  1480. Deleting = FALSE;
  1481. }
  1482. LastRow = 0;
  1483. }
  1485. // Add all List items from Stats[] data
  1486. for ( ptr = (void *)Stats; (char *)ptr < min(Stats+StatsLen,Stats + sizeof (Stats)); )  {
  1487.   // Add to list
  1488. ULONG len = strlen(ptr->text);
  1489.         
  1490. itemsAdded |= List_Append( hWndList, ptr->seq, ptr->time.QuadPart, ptr->text );
  1492. if( IsNT ) {
  1494. len += 4; len &= 0xFFFFFFFC; // +1 for null-terminator +3 for 32bit alignment
  1495. ptr = (void *)(ptr->text + len);
  1496. } else 
  1497. ptr = (void *)(ptr->text + len + 1);
  1498. }
  1500. // Empty the buffer
  1501. StatsLen = 0;
  1503. // only do stuff if we added stuff
  1504. if( itemsAdded ) {
  1506. // limit number of lines saved
  1507. if (MaxLines) {
  1508. SendMessage(hWndList, WM_SETREDRAW, FALSE, 0);
  1509. while ( LastRow > MaxLines ) {
  1510. ListView_DeleteItem ( hWndList, 0 );
  1511. LastRow--;
  1512. }
  1513. SendMessage(hWndList, WM_SETREDRAW, TRUE, 0);
  1514. }
  1516. // Scroll so newly added items are visible
  1517. if ( Autoscroll ) {
  1518. if( hBalloon ) DestroyWindow( hBalloon );
  1519. ListView_EnsureVisible( hWndList, ListView_GetItemCount(hWndList)-1, FALSE ); 
  1520. }
  1521. }
  1523. if( !IsNT) {
  1524. SendMessage(hWndList, WM_SETREDRAW, TRUE, 0);
  1525. InvalidateRect( hWndList, NULL, FALSE );
  1526. SetCursor( hSaveCursor );
  1527. }
  1528. }
  1530. /****************************************************************************
  1531. *
  1532. *    FUNCTION: CalcStringEllipsis
  1533. *
  1534. *    PURPOSE:  Determines if an item will fit in a listview row, and if
  1535. *    not, attaches the appropriate number of '.' to a truncated 
  1536. *    version.
  1537. *
  1538. ****************************************************************************/
  1539. BOOL WINAPI CalcStringEllipsis (HDC     hdc, 
  1540.                                 LPTSTR  szString, 
  1541.                                 int     cchMax, 
  1542.                                 UINT    uColWidth) 
  1543. { 
  1544.     static TCHAR szEllipsis3[] = TEXT("..."); 
  1545.     static TCHAR szEllipsis2[] = TEXT(".."); 
  1546.     static TCHAR szEllipsis1[] = TEXT("."); 
  1547.     SIZE sizeString; 
  1548.     SIZE sizeEllipsis3, sizeEllipsis2, sizeEllipsis1; 
  1549.     int cbString; 
  1550.     LPTSTR lpszTemp; 
  1551.      
  1552.     // Adjust the column width to take into account the edges 
  1553.     uColWidth -= 4; 
  1555. // Allocate a string for us to work with.  This way we can mangle the 
  1556.     // string and still preserve the return value 
  1557.     lpszTemp = (LPTSTR)HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, cchMax); 
  1558.     if (!lpszTemp) return FALSE;
  1559.     lstrcpy (lpszTemp, szString); 
  1560.  
  1561.     // Get the width of the string in pixels 
  1562.     cbString = lstrlen(lpszTemp); 
  1563.     if (!GetTextExtentPoint32 (hdc, lpszTemp, cbString, &sizeString)) {
  1564.         HeapFree (GetProcessHeap(), 0, (LPVOID)lpszTemp); 
  1565. return FALSE;
  1566.     } 
  1567.  
  1568.     // If the width of the string is greater than the column width shave 
  1569.     // the string and add the ellipsis 
  1570.     if ((ULONG)sizeString.cx > uColWidth) {
  1572.         if (!GetTextExtentPoint32 (hdc, 
  1573.                                    szEllipsis3, 
  1574.                                    lstrlen(szEllipsis3), 
  1575.                                    &sizeEllipsis3)) {
  1576. HeapFree (GetProcessHeap(), 0, (LPVOID)lpszTemp); 
  1577. return FALSE;
  1578.         } 
  1579.         if (!GetTextExtentPoint32 (hdc, 
  1580.                                    szEllipsis2, 
  1581.                                    lstrlen(szEllipsis2), 
  1582.                                    &sizeEllipsis2)) {
  1583. HeapFree (GetProcessHeap(), 0, (LPVOID)lpszTemp); 
  1584. return FALSE;
  1585.         } 
  1586.         if (!GetTextExtentPoint32 (hdc, 
  1587.                                    szEllipsis1, 
  1588.                                    lstrlen(szEllipsis1), 
  1589.                                    &sizeEllipsis1)) {
  1590. HeapFree (GetProcessHeap(), 0, (LPVOID)lpszTemp); 
  1591. return FALSE;
  1592.         } 
  1593.  
  1594.         while (cbString > 0) { 
  1596. lpszTemp[--cbString] = 0; 
  1597. if (!GetTextExtentPoint32 (hdc, lpszTemp, cbString, &sizeString)) {
  1598.   HeapFree (GetProcessHeap(), 0, (LPVOID)lpszTemp); 
  1599. return FALSE;
  1600. } 
  1601. if ((ULONG)(sizeString.cx + DOTOFFSET + sizeEllipsis3.cx) <= uColWidth) { 
  1602. break;
  1603. } 
  1604.         } 
  1605. lpszTemp[0] = szString[0];
  1606.   if((ULONG)(sizeString.cx + DOTOFFSET + sizeEllipsis3.cx) <= uColWidth) { 
  1607. lstrcat (lpszTemp, szEllipsis3); 
  1608. } else if((ULONG)(sizeString.cx + DOTOFFSET + sizeEllipsis2.cx) <= uColWidth) { 
  1609. lstrcat (lpszTemp, szEllipsis2); 
  1610. } else if((ULONG)(sizeString.cx + DOTOFFSET + sizeEllipsis1.cx) <= uColWidth) { 
  1611. lstrcat (lpszTemp, szEllipsis1); 
  1612. } else {
  1613. lpszTemp[0] = szString[0];
  1614. }
  1615.         lstrcpy (szString, lpszTemp); 
  1616.   HeapFree (GetProcessHeap(), 0, (LPVOID)lpszTemp); 
  1617. return TRUE;
  1619.     } else {
  1621. HeapFree (GetProcessHeap(), 0, (LPVOID)lpszTemp); 
  1622. return TRUE;
  1623. }
  1625. HeapFree (GetProcessHeap(), 0, (LPVOID)lpszTemp); 
  1626. return FALSE;
  1627. } 
  1630. /****************************************************************************
  1631. *
  1632. *    FUNCTION: DrawItemColumn
  1633. *
  1634. *    PURPOSE:  Draws text to the listview.
  1635. *
  1636. ****************************************************************************/
  1637. void WINAPI DrawItemColumn (HDC hdc, LPTSTR szText, LPRECT prcClip) 
  1638. { 
  1639.     TCHAR szString[MAXITEMLENGTH]; 
  1641.     // Check to see if the string fits in the clip rect.  If not, truncate 
  1642.     // the string and add "...". 
  1643.     lstrcpy(szString, szText); 
  1644.     CalcStringEllipsis (hdc, szString, sizeof( szString ), prcClip->right - prcClip->left); 
  1645.     ExtTextOut (hdc, 
  1646.                 prcClip->left + 2, 
  1647.                 prcClip->top + 1, 
  1648.                 ETO_CLIPPED | ETO_OPAQUE, 
  1649.                 prcClip, 
  1650.                 szString, 
  1651.                 lstrlen(szString), 
  1652.                 NULL); 
  1653. } 
  1656. /****************************************************************************
  1657. *
  1658. *    FUNCTION: DrawListViewItem
  1659. *
  1660. *    PURPOSE:  Handles a request from Windows to draw one of the lines
  1661. * in the listview window.
  1662. *
  1663. ****************************************************************************/
  1664. void DrawListViewItem(LPDRAWITEMSTRUCT lpDrawItem)
  1665. {
  1666. TCHAR  colString[NUMCOLUMNS][MAXITEMLENGTH];
  1667. BOOLEAN highlight = FALSE;
  1668.     LV_ITEM lvi;
  1669.     RECT rcClip;
  1670.     int iColumn;
  1671. DWORD width, leftOffset;
  1672. UINT uiFlags = ILD_TRANSPARENT;
  1674.     // Get the item image to be displayed
  1675.     lvi.mask = LVIF_IMAGE | LVIF_STATE;
  1676.     lvi.iItem = lpDrawItem->itemID;
  1677.     lvi.iSubItem = 0;
  1678.     ListView_GetItem(lpDrawItem->hwndItem, &lvi);
  1680. // Get the column text and see if there is a highlight
  1681. for( iColumn = 0; iColumn < NUMCOLUMNS; iColumn++ ) {
  1682. colString[iColumn][0] = 0;
  1683. ListView_GetItemText( hWndList, lpDrawItem->itemID,
  1684.   iColumn, colString[iColumn], 
  1685.   MAXITEMLENGTH);
  1686. if( !highlight && iColumn != 0) {
  1688. highlight = MatchWithHighlightPattern( colString[iColumn] );
  1689. }
  1690. }
  1692.     // Check to see if this item is selected
  1693. if (lpDrawItem->itemState & ODS_SELECTED) {
  1695.         // Set the text background and foreground colors
  1696. SetTextColor(lpDrawItem->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
  1697.         SetBkColor(lpDrawItem->hDC, GetSysColor(COLOR_HIGHLIGHT));
  1699. // Also add the ILD_BLEND50 so the images come out selected
  1700. uiFlags |= ILD_BLEND50;
  1701.     } else {
  1702.         // Set the text background and foreground colors to the standard window
  1703.         // colors
  1704. if( highlight ) {
  1705. SetTextColor(lpDrawItem->hDC, HighlightFg ); 
  1706.         SetBkColor(lpDrawItem->hDC, HighlightBg );
  1707. } else {
  1708. SetTextColor(lpDrawItem->hDC, GetSysColor(COLOR_WINDOWTEXT));
  1709. SetBkColor(lpDrawItem->hDC, GetSysColor(COLOR_WINDOW));
  1710. }
  1711.     }
  1713.     // Set up the new clipping rect for the first column text and draw it
  1714. leftOffset = 0;
  1715. for( iColumn = 0; iColumn< NUMCOLUMNS; iColumn++ ) {
  1717. width = ListView_GetColumnWidth( hWndList, iColumn );
  1718. rcClip.left = lpDrawItem->rcItem.left + leftOffset;
  1719. rcClip.right = lpDrawItem->rcItem.left + leftOffset + width;
  1720. rcClip.top = lpDrawItem->rcItem.top;
  1721. rcClip.bottom = lpDrawItem->rcItem.bottom;
  1723. DrawItemColumn(lpDrawItem->hDC, colString[iColumn], &rcClip);
  1724. leftOffset += width;
  1725. }
  1727.     // If we changed the colors for the selected item, undo it
  1728.     if (lpDrawItem->itemState & ODS_SELECTED) {
  1729.         // Set the text background and foreground colors
  1730.         SetTextColor(lpDrawItem->hDC, GetSysColor(COLOR_WINDOWTEXT));
  1731.         SetBkColor(lpDrawItem->hDC, GetSysColor(COLOR_WINDOW));
  1732.     }
  1734.     // If the item is focused, now draw a focus rect around the entire row
  1735.     if (lpDrawItem->itemState & ODS_FOCUS)
  1736.     {
  1737.         // Adjust the left edge to exclude the image
  1738.         rcClip = lpDrawItem->rcItem;
  1740.         // Draw the focus rect
  1741.         DrawFocusRect(lpDrawItem->hDC, &rcClip);
  1742.     }
  1743. }
  1746. /****************************************************************************
  1747. * 
  1748. *    FUNCTION: ListViewSubclass(HWND,UINT,WPARAM)
  1749. *
  1750. *    PURPOSE:  Subclasses the listview so that we can do tooltips
  1751. *
  1752. ****************************************************************************/
  1753. LRESULT CALLBACK ListViewSubclass(HWND hWnd, UINT uMsg, WPARAM wParam,
  1754.         LPARAM lParam)
  1755. {
  1756. ITEM_CLICK itemClick;
  1757. LVHITTESTINFO hitItem;
  1758. static initTrack = FALSE;
  1759. POINT           hitPoint, topleftPoint, bottomrightPoint;
  1760. RECT listRect;
  1761. static POINTS  mousePosition;
  1763. if( !initTrack ) {
  1765. SetTimer( hWnd, 2, BALLOONDELAY, NULL );
  1766. initTrack = TRUE;
  1767. }
  1769.     switch (uMsg) {
  1771. case WM_LBUTTONDBLCLK:
  1772. case WM_RBUTTONDBLCLK:
  1773. case WM_MBUTTONDBLCLK:
  1774. case WM_LBUTTONUP:
  1775. case WM_RBUTTONUP:
  1776. case WM_MBUTTONUP:
  1777. case WM_LBUTTONDOWN:
  1778. case WM_MBUTTONDOWN:
  1779. case WM_MOUSEMOVE:
  1781. // delete any existing balloon
  1782. if( hBalloon ) DestroyWindow( hBalloon );
  1784. // save mouse position and reset the timer
  1785. mousePosition = MAKEPOINTS( lParam );
  1786. SetTimer( hWnd, 2, BALLOONDELAY, NULL );
  1787. break;
  1789. case WM_VSCROLL:
  1790. case WM_HSCROLL:
  1791. case WM_KEYDOWN:
  1792. if( hBalloon ) DestroyWindow( hBalloon );
  1794. if( uMsg == WM_KEYDOWN && 
  1795. wParam == VK_ESCAPE &&
  1796. hWndFind ) {
  1798. DestroyWindow( hWndFind );
  1799. hWndFind = NULL;
  1800. }
  1801. break;
  1803. case WM_RBUTTONDOWN:
  1804. mousePosition = MAKEPOINTS( lParam );
  1805. SetTimer( hWnd, 2, BALLOONDELAY, NULL );
  1806. // fall-through
  1808. case WM_TIMER:
  1810. // are we currently in the listview?
  1811. GetCursorPos( &hitPoint );
  1812. GetClientRect( hWnd, &listRect );
  1813. topleftPoint.x = listRect.left;
  1814. topleftPoint.y = listRect.top;
  1815. ClientToScreen( hWnd, &topleftPoint );
  1816. bottomrightPoint.x = listRect.right;
  1817. bottomrightPoint.y = listRect.bottom;
  1818. ClientToScreen( hWnd, &bottomrightPoint );
  1819. if( hitPoint.x < topleftPoint.x ||
  1820. hitPoint.x > bottomrightPoint.x ||
  1821. hitPoint.y < topleftPoint.y ||
  1822. hitPoint.y > bottomrightPoint.y ||
  1823. (hWndFind && GetFocus() != hWndList) ) {
  1825. // delete any existing balloon
  1826. if( hBalloon ) DestroyWindow( hBalloon );
  1827. break;
  1828. }
  1830. hitItem.pt.x = mousePosition.x;
  1831. hitItem.pt.y =  mousePosition.y;
  1832. if( ListView_SubItemHitTest( hWndList, &hitItem ) != -1 ) {
  1834. itemClick.itemText[0] = 0;
  1835. ListView_GetItemText( hWndList, hitItem.iItem,
  1836. hitItem.iSubItem, itemClick.itemText, 1024 );
  1838. // delete any existing balloon
  1839. if( hBalloon ) DestroyWindow( hBalloon );
  1841. if( strlen( itemClick.itemText ) ) {
  1843. if( hitItem.iSubItem ) {
  1845. ListView_GetSubItemRect( hWndList, hitItem.iItem, hitItem.iSubItem,
  1846. LVIR_BOUNDS, &itemClick.itemPosition);
  1848. itemClick.itemPosition.bottom -= itemClick.itemPosition.top;
  1849. itemClick.itemPosition.right  -= itemClick.itemPosition.left;
  1851. } else {
  1853. ListView_GetSubItemRect( hWndList, hitItem.iItem, 0,
  1854. LVIR_BOUNDS, &itemClick.itemPosition);
  1856. itemClick.itemPosition.bottom -= itemClick.itemPosition.top;
  1857. itemClick.itemPosition.right  = ListView_GetColumnWidth( hWndList, 0 );
  1858. itemClick.itemPosition.left   = 0;
  1859. }
  1861. hitPoint.y = itemClick.itemPosition.top;
  1862. hitPoint.x = itemClick.itemPosition.left;
  1864. ClientToScreen( hWnd, &hitPoint );
  1866. itemClick.itemPosition.left = hitPoint.x;
  1867. itemClick.itemPosition.top  = hitPoint.y;
  1869. // pop-up a balloon (tool-tip like window)
  1870. hBalloon = CreateWindowEx( 0, "BALLOON", 
  1871. "balloon", 
  1872. WS_POPUP|WS_BORDER,
  1873. 100, 100,
  1874. 200, 200,
  1875. hWndMain, NULL, hInst, 
  1876. &itemClick );
  1877. if( hBalloon) SetFocus( hWnd );
  1878. }
  1879. }
  1880. break;
  1881.     }
  1883. // pass-through to real listview handler
  1884.     return CallWindowProc(ListViewWinMain, hWnd, uMsg, wParam, 
  1885.             lParam);
  1886. }
  1889. /****************************************************************************
  1890. * 
  1891. *    FUNCTION: CreateListView(HWND)
  1892. *
  1893. *    PURPOSE:  Creates the statistics list view window and initializes it
  1894. *
  1895. ****************************************************************************/
  1896. HWND CreateList( HWND hWndParent )                                     
  1897. {
  1898. HWND hWndList;        // handle to list view window
  1899. RECT rc;             // rectangle for setting size of window
  1900. LV_COLUMN lvC; // list view column structure
  1901. DWORD j;
  1902. static char process9xLabel[] = {"Process"};
  1903. static struct {
  1904. TCHAR * Label; // title of column
  1905. DWORD Fmt;
  1906. DWORD Width;
  1907. } column[] = {
  1908. { "#" , 35 },
  1909. { "Time" , 40 },
  1910. { "Process" , 90 },
  1911. { "Request" , 90 },
  1912. { "Path" , 225 },
  1913. { "Result" , 90 },
  1914. { "Other" , 150 },
  1915. };
  1917. // Ensure that the common control DLL is loaded.
  1918. InitCommonControls();
  1920. // Set the column widths according to the user-settings
  1921. for( j = 0; j < NUMCOLUMNS; j++ ) {
  1922. column[j].Width = PositionInfo.column[j];
  1923. }
  1925. // Get the size and position of the parent window.
  1926. GetClientRect( hWndParent, &rc );
  1928. // Create the list view window
  1929. hWndList = CreateWindowEx(  0L, WC_LISTVIEW, TEXT(""), 
  1930. WS_VISIBLE | WS_CHILD | WS_BORDER | LVS_REPORT |
  1931. LVS_OWNERDRAWFIXED,
  1932. 0, ShowToolbar ? TOOLBARHEIGHT : 0, 
  1933. rc.right - rc.left, 
  1934. rc.bottom - rc.top - (ShowToolbar ? TOOLBARHEIGHT : 0),
  1935. hWndParent, (HMENU)ID_LIST, hInst, NULL );
  1936. if ( hWndList == NULL )
  1937. return NULL;
  1939. // Make it a nice fix-width font for easy reading
  1940. SendMessage( hWndList, WM_SETFONT, (WPARAM) hFont, (LPARAM) 0 );
  1942. // Initialize columns
  1943. lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  1944. lvC.fmt = LVCFMT_LEFT; // left-align column
  1946. // Add the columns.
  1947. for ( j = 0; j < sizeof column/sizeof column[0]; ++j )  {
  1948. lvC.iSubItem = j;
  1949. lvC.cx = column[j].Width;
  1950. if( j == 2 && !IsNT ) 
  1951. lvC.pszText = process9xLabel;
  1952. else 
  1953. lvC.pszText = column[j].Label;
  1954. if ( ListView_InsertColumn( hWndList, j, &lvC ) == -1 )
  1955. return NULL;
  1956. }
  1958. // Set full-row selection
  1959. SendMessage( hWndList, LVM_SETEXTENDEDLISTVIEWSTYLE,
  1960. LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT );
  1962. // Sub-class
  1963. ListViewWinMain = (WNDPROC) SetWindowLong(hWndList, 
  1964.                                               GWL_WNDPROC, 
  1965.                                               (DWORD)ListViewSubclass); 
  1966. return hWndList;
  1967. }
  1971. /****************************************************************************
  1972. * 
  1973. *    FUNCTION: SaveFile()
  1974. *
  1975. *    PURPOSE:  Lets the user go select a file.
  1976. *
  1977. ****************************************************************************/
  1978. void SaveFile( HWND hWnd, HWND ListBox, BOOLEAN SaveAs )
  1979. {
  1980. OPENFILENAME SaveFileName;
  1981. TCHAR szFile[MAX_PATH] = _T(""), fieldtext[MAXITEMLENGTH];
  1982. TCHAR output[MAXITEMLENGTH*NUMCOLUMNS];
  1983. FILE *hFile;
  1984. int numitems;
  1985. int row, subitem;
  1987. if( SaveAs || !FileChosen ) {
  1988. SaveFileName.lStructSize       = sizeof (SaveFileName);
  1989. SaveFileName.hwndOwner         = hWnd;
  1990. SaveFileName.hInstance         = (HANDLE) hInst;
  1991. SaveFileName.lpstrFilter       = _T("File Info (*.LOG)*.LOGAll (*.*)*.*");
  1992. SaveFileName.lpstrCustomFilter = (LPTSTR)NULL;
  1993. SaveFileName.nMaxCustFilter    = 0L;
  1994. SaveFileName.nFilterIndex      = 1L;
  1995. SaveFileName.lpstrFile         = szFile;
  1996. SaveFileName.nMaxFile          = 256;
  1997. SaveFileName.lpstrFileTitle    = NULL;
  1998. SaveFileName.nMaxFileTitle     = 0;
  1999. SaveFileName.lpstrInitialDir   = NULL;
  2000. SaveFileName.lpstrTitle        = _T("Save File Info...");
  2001. SaveFileName.nFileOffset       = 0;
  2002. SaveFileName.nFileExtension    = 0;
  2003. SaveFileName.lpstrDefExt       = _T("*.log");
  2004. SaveFileName.lpfnHook    = NULL;
  2005.   SaveFileName.Flags = OFN_LONGNAMES|OFN_HIDEREADONLY;
  2007. if( !GetSaveFileName( &SaveFileName )) 
  2008. return;
  2009. } else 
  2010. // open previous szFile
  2011. _tcscpy( szFile, szFileName );
  2013. // open the file
  2014. hFile = _tfopen( szFile, _T("w") );
  2015. if( !hFile ) {
  2016. MessageBox( NULL, _T("Create File Failed."),
  2017. _T("Save Error"), MB_OK|MB_ICONSTOP );
  2018. return;
  2019. }
  2021. // post hourglass icon
  2022. SetCapture(hWnd);
  2023. hSaveCursor = SetCursor(hHourGlass);
  2025. numitems = ListView_GetItemCount(ListBox);
  2026. for ( row = 0; row < numitems; row++ )  {
  2027. output[0] = 0;
  2028. for( subitem = 0; subitem < NUMCOLUMNS; subitem++ ) {
  2029. fieldtext[0] = 0;
  2030. ListView_GetItemText( ListBox, row, subitem, fieldtext, 256 );
  2031. _tcscat( output, fieldtext );
  2032. _tcscat( output, _T("t") );
  2033. }
  2034. _ftprintf( hFile, _T("%sn"), output );
  2035. }
  2036. fclose( hFile );
  2037. _tcscpy( szFileName, szFile );
  2038. FileChosen = TRUE;
  2039. SetCursor( hSaveCursor );
  2040. ReleaseCapture(); 
  2041. }
  2044. /****************************************************************************
  2045. *
  2046. * FUNCTION: HistoryProc
  2047. *
  2048. * PURPOSE: Processes messages for "Filter" dialog box
  2049. *
  2050. ****************************************************************************/
  2051. BOOL APIENTRY HistoryProc( HWND hDlg, UINT message, UINT wParam, LONG lParam )
  2052. {
  2053. DWORD newMaxLines, numRows;
  2054. char history[64];
  2056. switch ( message )  {
  2057. case WM_INITDIALOG:
  2059. // initialize the controls to reflect the current filter
  2060. sprintf( history, "%d", MaxLines );
  2061. SetDlgItemTextA( hDlg, IDC_HISTORY, history );
  2062. SendMessage (GetDlgItem( hDlg, IDC_SPIN), UDM_SETRANGE, 0L, 
  2063. MAKELONG (9999, 0));
  2064. return TRUE;
  2066. case WM_COMMAND:              
  2067. if ( LOWORD( wParam ) == IDOK )  {
  2069. // make sure that max lines is legal
  2070. GetDlgItemTextA( hDlg, IDC_HISTORY, history, 64 );
  2071. if( !sscanf( history, "%d", &newMaxLines )) {
  2073. MessageBox( NULL, TEXT("Invalid History Depth."),
  2074. TEXT("Filter Error"), MB_OK|MB_ICONWARNING );
  2075. return TRUE;
  2076. } 
  2077. MaxLines = newMaxLines;
  2079. EndDialog( hDlg, TRUE );
  2080. if (MaxLines ) {
  2081. numRows = ListView_GetItemCount( hWndList );
  2082. SendMessage(hWndList, WM_SETREDRAW, FALSE, 0);
  2083. while ( numRows >= MaxLines ) {
  2084. ListView_DeleteItem ( hWndList, 0 );
  2085. numRows--;
  2086. }
  2087. SendMessage(hWndList, WM_SETREDRAW, TRUE, 0);
  2088. }
  2089. return TRUE;
  2091. } else if( LOWORD( wParam ) == IDCANCEL ) {
  2093. EndDialog( hDlg, TRUE );
  2094. } else if( LOWORD( wParam ) == IDRESET ) {
  2096. // reset filter to default of none
  2097. SetDlgItemTextA( hDlg, IDC_HISTORY, "0" );
  2098. }
  2099. break;
  2100. case WM_CLOSE:
  2101. EndDialog( hDlg, TRUE );
  2102. return TRUE;
  2103. }
  2104. return FALSE;   
  2105. }
  2108. /****************************************************************************
  2109. *
  2110. * FUNCTION: About
  2111. *
  2112. * PURPOSE: Processes messages for "About" dialog box
  2113. *
  2114. ****************************************************************************/
  2115. BOOL APIENTRY About( HWND hDlg, UINT message, UINT wParam, LONG lParam )
  2116. {
  2117. switch ( message )  {
  2118. case WM_INITDIALOG:
  2119. return TRUE;
  2121. case WM_COMMAND:              
  2122. if ( LOWORD( wParam ) == IDOK )  {
  2123.   EndDialog( hDlg, TRUE );
  2124.   return TRUE;
  2125. }
  2126. break;
  2128. case WM_CLOSE:
  2130. EndDialog( hDlg, TRUE );
  2131. return TRUE;
  2132. }
  2133. return FALSE;   
  2134. }
  2137. /******************************************************************************
  2138. *
  2139. * FUNCTION: GetDLLVersion
  2140. *
  2141. * PURPOSE: Gets the version number of the specified DLL.
  2142. *
  2143. ******************************************************************************/
  2144. HRESULT GetDLLVersion( PTCHAR DllName, LPDWORD pdwMajor, LPDWORD pdwMinor)
  2145. {
  2146. HINSTANCE hDll;
  2147. HRESULT hr = S_OK;
  2148. DLLVERSIONINFO_ dvi;
  2150. *pdwMajor = 0;
  2151. *pdwMinor = 0;
  2153. //Load the DLL.
  2154. hDll = LoadLibrary(DllName);
  2156. if( hDll ) {
  2158.    pDllGetVersionProc = (PVOID)GetProcAddress(hDll, "DllGetVersion");
  2160.    if(pDllGetVersionProc) {
  2161.   
  2162.   ZeroMemory(&dvi, sizeof(dvi));
  2163.   dvi.cbSize = sizeof(dvi);
  2165.   hr = (*pDllGetVersionProc)(&dvi);
  2166.   
  2167.   if(SUCCEEDED(hr)) {
  2169.  *pdwMajor = dvi.dwMajorVersion;
  2170.  *pdwMinor = dvi.dwMinorVersion;
  2171.   }
  2172.     } else {
  2174.   // If GetProcAddress failed, the DLL is a version previous to the one 
  2175.   // shipped with IE 3.x.
  2176.   *pdwMajor = 4;
  2177.   *pdwMinor = 0;
  2178.       }
  2179.    
  2180.   FreeLibrary(hDll);
  2181.   return hr;
  2182. }
  2184. return E_FAIL;
  2185. }
  2188. /****************************************************************************
  2189. *
  2190. *    FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
  2191. *
  2192. *    PURPOSE:  Processes messages for the statistics window.
  2193. *
  2194. ****************************************************************************/
  2195. LONG APIENTRY MainWndProc( HWND hWnd, UINT message, UINT wParam, LONG lParam) 
  2196. {
  2197. static DWORD MaxDriveSet = 0;
  2198. static HMENU DriveMenu;
  2199.     static HWND hWndTT;
  2200. static HWND hWndToolbar;
  2201. static POINTS   hoverPoints;
  2202. DWORD newDriveSet;
  2203. LPTOOLTIPTEXT lpToolTipText;
  2204. LPFINDREPLACE findMessageInfo;
  2205. #if _DEBUG
  2206. ULONG irpcount;
  2207. #endif
  2208. POINT hitPoint;
  2209. LOGFONT lf;
  2210. CHOOSEFONT chf;
  2211. RECT listRect;
  2212. DWORD nb, versionNumber;
  2213. TEXTMETRIC textMetrics;
  2214. DWORD drive, drivetype;
  2215. TCHAR Path[ MAX_PATH ];
  2216. static TCHAR szBuf[MAX_PATH];
  2217. TCHAR  name[ MAX_PATH ];
  2218. TCHAR *File;
  2219. RECT rc;  
  2220. DWORD majorver, minorver;
  2221. WIN32_FIND_DATA findData;
  2222. HANDLE findHandle;
  2223. DWORD startTime;
  2224. HDC hDC;
  2225. FILE_SYSTEM_TYPE fsType;
  2226. PAINTSTRUCT Paint;
  2228. switch ( message ) {
  2230. case WM_CREATE:
  2232. // get hourglass icon ready
  2233. hHourGlass = LoadCursor( NULL, IDC_WAIT );
  2235. // post hourglass icon
  2236. SetCapture(hWnd);
  2237. hSaveCursor = SetCursor(hHourGlass);
  2239. // determine performance counter frequency
  2240. QueryPerformanceFrequency( &PerfFrequency );
  2242. // Create the toolbar control - use modern style if available.
  2243. GetDLLVersion( _T("comctl32.dll"), &majorver, &minorver );
  2244. if( majorver > 4 || (majorver == 4 && minorver >= 70) ) {
  2245. hWndToolbar = CreateToolbarEx( 
  2246. hWnd, TOOLBAR_FLAT | WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS,  
  2247. ID_TOOLBAR, NUMTOOLBARBUTTONS, hInst, IDB_TOOLBAR, (LPCTBBUTTON)&tbButtons,
  2248. NUMBUTTONS, 16,16,16,15, sizeof(TBBUTTON)); 
  2249. } else {
  2250. hWndToolbar = CreateToolbarEx( 
  2251. hWnd, WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS,  
  2252. ID_TOOLBAR, NUMTOOLBARBUTTONS, hInst, IDB_TOOLBAR, (LPCTBBUTTON)&tbButtonsOld,
  2253. NUMBUTTONSOLD, 16,16,16,15, sizeof(TBBUTTON)); 
  2254. }
  2255. if (hWndToolbar == NULL ) MessageBox (NULL, _T("Toolbar not created!"), NULL, MB_OK );
  2257. // Create the ListBox within the main window
  2258. hWndList = CreateList( hWnd );
  2259. if ( hWndList == NULL )   MessageBox( NULL, _T("List not created!"), NULL, MB_OK );
  2261.     // open the handle to the device
  2262. if( IsNT ) {
  2264. GetCurrentDirectory( sizeof Path, Path );
  2265. _stprintf( Path+lstrlen(Path), _T("\%s"), SYS_FILE );
  2267. findHandle = FindFirstFile( Path, &findData );
  2268. if( findHandle == INVALID_HANDLE_VALUE ) {
  2270. if( !SearchPath( NULL, SYS_FILE, NULL, sizeof(Path), Path, &File ) ) {
  2272. _stprintf( msgbuf, _T("%s was not found."), SYS_NAME );
  2273. return Abort( hWnd, msgbuf );
  2274. }
  2276. } else FindClose( findHandle );
  2278. UnloadDeviceDriver( SYS_NAME );
  2279. if ( ! LoadDeviceDriver( SYS_NAME, Path, &SysHandle ) )  {
  2281. _stprintf( msgbuf, _T("Opening %s (%s): error %d"), SYS_NAME, Path,
  2282. GetLastError( ) );
  2283. return Abort( hWnd, msgbuf );
  2284. }
  2286. // Correct driver version?
  2287. if ( ! DeviceIoControl( SysHandle, IOCTL_FILEMON_VERSION,
  2288. NULL, 0, &versionNumber, sizeof(DWORD), &nb, NULL ) ||
  2289. versionNumber != FILEMONVERSION ) {
  2291. MessageBox( hWnd, _T("Filemon located a driver with the wrong version.n")
  2292. _T("If you just installed a new version you must reboot before you aren")
  2293. _T("able to use it."), _T("Filemon"), MB_ICONERROR);
  2294. PostQuitMessage( 1 );
  2295. return 0;
  2296. }
  2297. } else {
  2299. // connect with VxD
  2300. SysHandle = CreateFile( VXD_FILE, 0, 0, NULL,
  2301. 0, FILE_FLAG_OVERLAPPED|
  2302. FILE_FLAG_DELETE_ON_CLOSE,
  2303. NULL );
  2304. if ( SysHandle == INVALID_HANDLE_VALUE )  {
  2305. _stprintf( msgbuf, "%s is not loaded properly.", VXD_NAME );
  2306. return Abort( hWnd, msgbuf );
  2307. }
  2308. }
  2310. // Have driver zero information
  2311. if ( ! DeviceIoControl( SysHandle, IOCTL_FILEMON_ZEROSTATS,
  2312. NULL, 0, NULL, 0, &nb, NULL ) ) {
  2314. Abort( hWnd, _T("Couldn't access device driver") );
  2315. return 0;
  2316. }
  2318. // Set up the filter
  2319. FilterDefinition.excludefilter[0] = 0;
  2320. FilterDefinition.includefilter[0] = 0;
  2321. if( strcmp( ExcludeString, " " ) )
  2322. strcpy( FilterDefinition.excludefilter, ExcludeString );
  2323. if( strcmp( FilterString, " " ) )
  2324. strcpy( FilterDefinition.includefilter, FilterString );
  2326. // Give the user to change initial filter
  2327. if( strcmp( FilterString, "*" ) ||
  2328. (*ExcludeString && strcmp( ExcludeString, " "))) {
  2330. DialogBox( hInst, TEXT("InitFilter"), hWnd, (DLGPROC) FilterProc );
  2332. } else {
  2334. // tell the driver the initial filter
  2335. if ( ! DeviceIoControl( SysHandle, IOCTL_FILEMON_SETFILTER,
  2336. &FilterDefinition, sizeof(FILTER), NULL, 
  2337. 0, &nb, NULL ) ) {
  2339. return Abort( hWnd, _T("Couldn't access device driver") );
  2340. }
  2341. }
  2343. // tell the driver the timing type
  2344. if ( !DeviceIoControl( SysHandle, IOCTL_FILEMON_TIMETYPE,
  2345. (PVOID) &TimeIsDuration, sizeof(BOOLEAN), 
  2346. NULL, 0, &nb, NULL ) )
  2347. {
  2348. return Abort( hWnd, _T("Couldn't access device driver") );
  2349. }
  2350. CheckMenuItem( GetMenu(hWnd), IDM_TIME,
  2351. MF_BYCOMMAND|(TimeIsDuration?MF_CHECKED:MF_UNCHECKED) ); 
  2353. // Tell driver to start filtering
  2354. if ( ! DeviceIoControl( SysHandle, IOCTL_FILEMON_STARTFILTER,
  2355. NULL, 0, NULL, 0, &nb, NULL ) )
  2356. {
  2357. return Abort( hWnd, _T("Couldn't access device driver") );
  2358. }
  2360. // Create a pop-up menu item with the drives
  2361. if( IsNT ) {
  2363. DriveMenu = CreateMenu();
  2365. // Add the special file systems menu items
  2366. InsertMenu( DriveMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_STRING,
  2367. IDC_DRIVE+PIPE_DRIVE, _T("Named Pipes") );
  2368. InsertMenu( DriveMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_STRING,
  2369. IDC_DRIVE+SLOT_DRIVE, _T("Mail Slots") );
  2370. InsertMenu( DriveMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_SEPARATOR,
  2371. 0, NULL );
  2373. // Get available drives we can monitor
  2374. MaxDriveSet = GetLogicalDrives();
  2375. if( PositionInfo.curdriveset != (DWORD) -1 )
  2376. CurDriveSet = PositionInfo.curdriveset;
  2377. else
  2378. CurDriveSet = MaxDriveSet;
  2379. for ( drive = 0; drive < 32; ++drive )  {
  2380. if ( MaxDriveSet & (1 << drive) )  {
  2381. _stprintf( name, _T("%c:\"), 'A'+drive );
  2382. switch ( GetDriveType( name ) )  {
  2383. // We don't like these: remove them
  2384. case 0: // The drive type cannot be determined.
  2385. case 1: // The root directory does not exist.
  2386. drivetype = DRVUNKNOWN;
  2387. CurDriveSet &= ~(1 << drive);
  2388. break;
  2389. case DRIVE_REMOVABLE: // The drive can be removed from the drive.
  2390. drivetype = DRVREMOVE;
  2391. CurDriveSet &= ~(1 << drive);
  2392. break;
  2393. case DRIVE_CDROM: // The drive is a CD-ROM drive.
  2394. drivetype = DRVCD;
  2395. CurDriveSet &= ~(1 << drive);
  2396. break;
  2398. // We like these types
  2399. case DRIVE_FIXED: // The disk cannot be removed from the drive.
  2400. drivetype = DRVFIXED;
  2401. break;
  2402. case DRIVE_REMOTE: // The drive is a remote (network) drive.
  2403. drivetype = DRVREMOTE;
  2404. break;
  2405. case DRIVE_RAMDISK: // The drive is a RAM disk.
  2406. drivetype = DRVRAM;
  2407. break;
  2408. }
  2409. _stprintf( name, _T("Drive &%c: (%s)"), 'A'+drive, DrvNames[drivetype] );
  2410. InsertMenu( DriveMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_STRING,
  2411. IDC_DRIVE+drive, name );
  2412. }
  2413. }
  2415. // Add "all drives"/"no drives"
  2416. InsertMenu( DriveMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_SEPARATOR,
  2417. 0, NULL );
  2418. InsertMenu( DriveMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_STRING,
  2419. IDC_DRIVE+ALLDRIVES, "All Drives" );
  2420. InsertMenu( DriveMenu, 0xFFFFFFFF, MF_BYPOSITION|MF_STRING,
  2421. IDC_DRIVE+NODRIVES, "No Drives" );
  2423. // Insert into top-level menu
  2424. InsertMenu( GetMenu( hWnd ), 3, MF_BYPOSITION|MF_POPUP|MF_STRING,
  2425. (UINT)DriveMenu, _T("&Drives") );
  2427. // Have driver hook the selected drives
  2428. CurDriveSet = HookDrives( DriveMenu, MaxDriveSet, CurDriveSet );
  2430. if( HookPipes ) {
  2431. fsType = NPFS;
  2432. if( !DeviceIoControl( SysHandle, HookPipes ? IOCTL_FILEMON_HOOKSPECIAL :
  2433. IOCTL_FILEMON_UNHOOKSPECIAL,
  2434. &fsType, sizeof(fsType), NULL, 0, &nb, NULL )) {
  2436. MessageBox( hWnd, _T("Filemon could not attach to Named Pipe File System"), 
  2437. APPNAME, MB_ICONWARNING|MB_OK );
  2438. HookPipes = FALSE;
  2439. }
  2440. }
  2441. if( HookSlots ) {
  2442. fsType = MSFS;
  2443. if( !DeviceIoControl( SysHandle, HookSlots ? IOCTL_FILEMON_HOOKSPECIAL :
  2444. IOCTL_FILEMON_UNHOOKSPECIAL,
  2445. &fsType, sizeof(fsType), NULL, 0, &nb, NULL )) {
  2447. MessageBox( hWnd, _T("Filemon could not attach to Mail Slot File System"), 
  2448. APPNAME, MB_ICONWARNING|MB_OK );
  2449. HookSlots = FALSE;
  2450. }
  2451. }
  2453. CheckMenuItem( DriveMenu, IDC_DRIVE+PIPE_DRIVE, MF_BYCOMMAND|
  2454. (HookPipes ? MF_CHECKED:MF_UNCHECKED ));
  2455. CheckMenuItem( DriveMenu, IDC_DRIVE+SLOT_DRIVE, MF_BYCOMMAND|
  2456. (HookSlots ? MF_CHECKED:MF_UNCHECKED ));
  2457. }
  2459. // set the time type bitmap
  2460. SendMessage( hWndToolbar, TB_CHANGEBITMAP, IDM_TIME, (TimeIsDuration?10:9) );
  2462. // Start up timer to periodically update screen
  2463. SetTimer( hWnd, 1, 500/*ms*/, NULL );
  2465. // Initialization done
  2466. SetCursor( hSaveCursor );
  2467. ReleaseCapture();
  2468. return 0;
  2470. case WM_NOTIFY:
  2472. // Make sure its intended for us
  2473. if ( wParam == ID_LIST )  {
  2474. NM_LISTVIEW * pNm = (NM_LISTVIEW *)lParam;
  2475. switch ( pNm->hdr.code )  {
  2477.         case LVN_BEGINLABELEDIT:
  2478. // Don't allow editing of information
  2479. return TRUE;
  2481. case NM_DBLCLK:
  2482. case NM_RETURN:
  2484. // open the specified file/folder in Explorer, if we can
  2485. ExplorerJump( hWnd );
  2486. return TRUE;
  2488. case HDN_ENDTRACK:
  2489. // Listview header sizes changed
  2490. InvalidateRect( hWndList, NULL, TRUE );
  2491. return FALSE;
  2492. }
  2493. } else {
  2495. switch (((LPNMHDR) lParam)->code) 
  2496. {
  2497. case TTN_NEEDTEXT:    
  2498. // Display the ToolTip text.
  2499. lpToolTipText = (LPTOOLTIPTEXT)lParam;
  2500.      LoadString (hInst, lpToolTipText->hdr.idFrom, szBuf, sizeof(szBuf));
  2501.      lpToolTipText->lpszText = szBuf;
  2502. break;
  2504. default:
  2505. return FALSE;
  2506. }
  2507. }
  2508. return FALSE;
  2510. case WM_COMMAND:
  2512. switch ( LOWORD( wParam ) )  {
  2514. // stats related commands to send to driver
  2515. case IDM_CLEAR:
  2516. // Have driver zero information
  2517. if ( ! DeviceIoControl( SysHandle, IOCTL_FILEMON_ZEROSTATS,
  2518. NULL, 0, NULL, 0, &nb, NULL ) )
  2519. {
  2520. Abort( hWnd, _T("Couldn't access device driver") );
  2521. return 0;
  2522. }
  2523. // Update statistics windows
  2524. UpdateStatistics( hWnd, hWndList, TRUE );
  2525. return 0;
  2527. case IDM_HELP:
  2528. WinHelp(hWnd, _T("filemon.hlp"), HELP_CONTENTS, 0L);
  2529. return 0;
  2531. case IDM_CAPTURE:
  2532. // Disable filtering
  2533. Capture = !Capture;
  2534. if ( ! DeviceIoControl( SysHandle, 
  2535. Capture ? IOCTL_FILEMON_STARTFILTER: IOCTL_FILEMON_STOPFILTER,
  2536. NULL, 0, NULL, 0, &nb, NULL ) )
  2537. {
  2538. Abort( hWnd, _T("Couldn't access device driver") );
  2539. return 0;
  2540. }
  2541. CheckMenuItem( GetMenu(hWnd), IDM_CAPTURE,
  2542. MF_BYCOMMAND|(Capture?MF_CHECKED:MF_UNCHECKED) );
  2543. SendMessage( hWndToolbar, TB_CHANGEBITMAP, IDM_CAPTURE, (Capture?2:1) );
  2544. InvalidateRect( hWndToolbar, NULL, TRUE );
  2545. return 0;
  2547. case IDM_AUTOSCROLL:
  2548. Autoscroll = !Autoscroll;
  2549. CheckMenuItem( GetMenu(hWnd), IDM_AUTOSCROLL,
  2550. MF_BYCOMMAND|(Autoscroll?MF_CHECKED:MF_UNCHECKED) ); 
  2551. SendMessage( hWndToolbar, TB_CHANGEBITMAP, IDM_AUTOSCROLL, (Autoscroll?4:3) );
  2552. InvalidateRect( hWndToolbar, NULL, TRUE );
  2553. return 0;
  2555. case IDM_TIME:
  2556. TimeIsDuration = !TimeIsDuration;
  2557. CheckMenuItem( GetMenu(hWnd), IDM_TIME,
  2558. MF_BYCOMMAND|(TimeIsDuration?MF_CHECKED:MF_UNCHECKED) ); 
  2559. // tell the driver
  2560. if ( !DeviceIoControl( SysHandle, IOCTL_FILEMON_TIMETYPE,
  2561. (PVOID) &TimeIsDuration, sizeof(BOOLEAN), 
  2562. NULL, 0, &nb, NULL ) )
  2563. {
  2564. Abort( hWnd, _T("Couldn't access device driver") );
  2565. return 0;
  2566. }
  2567. SendMessage( hWndToolbar, TB_CHANGEBITMAP, IDM_TIME, (TimeIsDuration?10:9) );
  2568. InvalidateRect( hWndToolbar, NULL, TRUE );
  2569. return 0;
  2571. case IDM_COPY:
  2572. CopySelection( hWnd );
  2573. return FALSE;
  2575. case IDM_JUMP:
  2576. // open the folder in regedit if we can
  2577. ExplorerJump( hWnd );
  2578. return FALSE;
  2580. case IDM_HISTORY:
  2581. DialogBox( hInst, TEXT("History"), hWnd, (DLGPROC) HistoryProc );
  2582. return 0;
  2584. case IDM_FILTER:
  2585. DialogBox( hInst, _T("Filter"), hWnd, (DLGPROC) FilterProc );
  2586. return 0;
  2588. case IDM_EXIT:
  2589. // Close ourself
  2590. SendMessage( hWnd, WM_CLOSE, 0, 0 );
  2591. return 0;
  2593. case IDM_FIND:
  2594. // search the listview
  2595. if( !hWndFind ) {
  2596. PrevMatch = FALSE;
  2597. PopFindDialog( hWnd );
  2598. } else if( PrevMatch ) {
  2600. // treat this like a find-next
  2601. SetCapture(hWndFind);
  2602. hSaveCursor = SetCursor(hHourGlass);
  2603. EnableWindow( hWndFind, FALSE );
  2604. if (FindInListview( hWnd, &FindTextInfo ) ) {
  2605. Autoscroll = FALSE;
  2606. CheckMenuItem( GetMenu(hWnd), IDM_AUTOSCROLL,
  2607. MF_BYCOMMAND|MF_UNCHECKED ); 
  2608. SendMessage( hWndToolbar, TB_CHANGEBITMAP, IDM_AUTOSCROLL, 3 );
  2609. }
  2610. EnableWindow( hWndFind, TRUE );
  2611. SetCursor( hSaveCursor );
  2612. ReleaseCapture(); 
  2613. }
  2614. return 0;
  2616. case IDM_HIGHLIGHT:
  2617. SelectHighlightColors( hWnd );
  2618. break;
  2620. case IDM_FONT:
  2622. hDC = GetDC (hWndList );
  2623. lf = LogFont;
  2624. chf.hDC = CreateCompatibleDC (hDC);
  2625. ReleaseDC (hWnd, hDC);
  2626. chf.lStructSize = sizeof (CHOOSEFONT);
  2627. chf.hwndOwner = hWndList;
  2628. chf.lpLogFont = &lf;
  2629. chf.Flags     = CF_SCREENFONTS|CF_ENABLETEMPLATE|
  2630. CF_INITTOLOGFONTSTRUCT| CF_LIMITSIZE; 
  2631. chf.rgbColors = RGB (0, 0, 0);
  2632. chf.lCustData = 0;
  2633. chf.hInstance = (HANDLE)hInst;
  2634. chf.lpszStyle = (LPTSTR)NULL;
  2635. chf.nFontType = SCREEN_FONTTYPE;
  2636. chf.nSizeMin  = 0;
  2637. chf.nSizeMax  = 20;
  2638. chf.lpfnHook  = (LPCFHOOKPROC)(FARPROC)NULL;
  2639. chf.lpTemplateName = (LPTSTR)MAKEINTRESOURCE (FORMATDLGORD31);
  2640. if( ChooseFont( &chf ) ) {
  2641. LogFont = lf;
  2643. // Update listview font
  2644. DeleteObject( hFont );
  2645.   hFont = CreateFontIndirect( &LogFont ); 
  2646. SendMessage( hWndList, WM_SETFONT, 
  2647. (WPARAM) hFont, 0);
  2648. InvalidateRgn( hWndList, NULL, TRUE );
  2650. // Trick the listview into updating
  2651. GetWindowRect( hWndMain, &rc );
  2652. SetWindowPos( hWndMain, NULL,
  2653. rc.left, rc.top, 
  2654. rc.right - rc.left -1 , 
  2655. rc.bottom - rc.top,
  2656. SWP_NOZORDER );
  2657. SetWindowPos( hWndMain, NULL,
  2658. rc.left, rc.top, 
  2659. rc.right - rc.left, 
  2660. rc.bottom - rc.top,
  2661. SWP_NOZORDER );
  2662. }
  2663. return FALSE;
  2665. case IDM_ABOUT:
  2666. // Show the names of the authors
  2667. DialogBox( hInst, _T("AboutBox"), hWnd, (DLGPROC)About );
  2668. return 0;
  2670. case IDM_SAVE:
  2671. SaveFile( hWnd, hWndList, FALSE );
  2672. return 0;
  2674. case IDM_SAVEAS:
  2675. SaveFile( hWnd, hWndList, TRUE );
  2676. return 0;
  2678. default:
  2680. // selection in drive menu?
  2681. if( IsNT ) {
  2683. drive = LOWORD( wParam ) - IDC_DRIVE;
  2684. if ( drive < 32 )  {
  2685. if( drive == ALLDRIVES ) {
  2686. newDriveSet = MaxDriveSet;
  2687. } else if( drive == NODRIVES ) {
  2688. newDriveSet = 0;
  2689. } else {
  2690. // Toggle status
  2691. newDriveSet = CurDriveSet ^ (1 << drive);
  2692. }
  2693. // Have driver hook the selected drives
  2694. CurDriveSet = HookDrives( DriveMenu, MaxDriveSet, newDriveSet );
  2695. if( newDriveSet != CurDriveSet ) {
  2697. for( drive = 0; drive < 26; drive++ ) {
  2699. if( newDriveSet & (1 << drive ) && 
  2700. !(CurDriveSet & (1 << drive))) {
  2701. sprintf( szBuf, "Filemon could not attach to drive %C:",
  2702. drive + L'A' );
  2703. MessageBox( hWnd, szBuf, 
  2704. APPNAME, MB_ICONWARNING|MB_OK );
  2705. }
  2706. }
  2707. }
  2708. return FALSE;
  2710. } else if( drive == PIPE_DRIVE ) {
  2712. HookPipes = !HookPipes;
  2713. fsType = NPFS;
  2714. if( !DeviceIoControl( SysHandle, HookPipes ? IOCTL_FILEMON_HOOKSPECIAL :
  2715. IOCTL_FILEMON_UNHOOKSPECIAL,
  2716. &fsType, sizeof(fsType), NULL, 0, &nb, NULL )) {
  2718. _stprintf( msgbuf, _T("Filemon could not attach to Named Pipe File System"));
  2719. MessageBox( hWnd, msgbuf, 
  2720. APPNAME, MB_ICONWARNING|MB_OK );
  2721. HookPipes = FALSE;
  2722. }
  2723. CheckMenuItem( DriveMenu, IDC_DRIVE+PIPE_DRIVE, MF_BYCOMMAND|
  2724. (HookPipes ? MF_CHECKED:MF_UNCHECKED ));
  2726. } else if( drive == SLOT_DRIVE ) {
  2728. HookSlots = !HookSlots;
  2729. fsType = MSFS;
  2730. if( !DeviceIoControl( SysHandle, HookSlots ? IOCTL_FILEMON_HOOKSPECIAL :
  2731. IOCTL_FILEMON_UNHOOKSPECIAL,
  2732. &fsType, sizeof(fsType), NULL, 0, &nb, NULL )) {
  2734. _stprintf( msgbuf, _T("Filemon could not attach to Mail Slot File System"));
  2735. MessageBox( hWnd, msgbuf, 
  2736. APPNAME, MB_ICONWARNING|MB_OK );
  2737. HookSlots = FALSE;
  2738. }
  2739. CheckMenuItem( DriveMenu, IDC_DRIVE+SLOT_DRIVE, MF_BYCOMMAND|
  2740. (HookSlots ? MF_CHECKED:MF_UNCHECKED ));
  2741. } else {
  2743. // Default behavior
  2744. return DefWindowProc( hWnd, message, wParam, lParam );
  2745. }
  2746. }
  2747. }
  2748. break;
  2750. case WM_TIMER:
  2751. // Time to query the device driver for more data
  2752. if ( Capture )  {
  2754. // don't process for more than a second without pausing
  2755. startTime = GetTickCount();
  2756. for (;;)  {
  2757. // Have driver fill Stats buffer with information
  2758. if ( ! DeviceIoControl( SysHandle, IOCTL_FILEMON_GETSTATS,
  2759. NULL, 0, &Stats, sizeof Stats,
  2760. &StatsLen, NULL ) )
  2761. {
  2762. Abort( hWnd, _T("Couldn't access device driver") );
  2763. return TRUE;
  2764. }
  2765. if ( StatsLen == 0 )
  2766. break;
  2767. // Update statistics windows
  2768. UpdateStatistics( hWnd, hWndList, FALSE );
  2770. if( GetTickCount() - startTime > 1000 ) break;
  2771. }
  2772. }
  2774. // delete balloon if necessary
  2775. if( hBalloon ) {
  2776. GetCursorPos( &hitPoint );
  2777. GetWindowRect( hWndList, &listRect );
  2778. if( hitPoint.x < listRect.left ||
  2779. hitPoint.x > listRect.right ||
  2780. hitPoint.y < listRect.top ||
  2781. hitPoint.y > listRect.bottom ) {
  2783. DestroyWindow( hBalloon );
  2784. }
  2785. }
  2786. return 0;
  2788. case WM_SIZE:
  2789. // Move or resize the List
  2790.             MoveWindow( hWndList, 0, TOOLBARHEIGHT, LOWORD(lParam), HIWORD(lParam)-TOOLBARHEIGHT, TRUE );
  2791. MoveWindow( hWndToolbar, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE );
  2792. if( hBalloon ) DestroyWindow( hBalloon );
  2793.             return 0;
  2795. case WM_MEASUREITEM:
  2796. // If its the listview that's being queried, return the height of the
  2797. // font
  2798. if( ((MEASUREITEMSTRUCT *) lParam)->CtlType == ODT_LISTVIEW ) {
  2799. hDC = GetDC( hWndList );
  2800. SelectObject( hDC, hFont );
  2801. if( !GetTextMetrics( hDC, &textMetrics)) return FALSE;
  2802. ((MEASUREITEMSTRUCT *) lParam)->itemHeight = textMetrics.tmHeight + 1;
  2803. ReleaseDC( hWndList, hDC );
  2804. }
  2805. return DefWindowProc( hWnd, message, wParam, lParam );
  2807. case WM_DRAWITEM:
  2808. DrawListViewItem( (LPDRAWITEMSTRUCT) lParam );
  2809. break;
  2811. case WM_ACTIVATE:
  2812. case WM_SETFOCUS:
  2813. SetFocus( hWndList );
  2814. break;
  2816. case WM_MOUSEMOVE:
  2817. case WM_MOVE:
  2818. if( hBalloon ) DestroyWindow( hBalloon );
  2819. return 0;
  2821. case WM_CLOSE:
  2823. #if _DEBUG
  2824. if( IsNT ) {
  2825. // see if the driver can unload
  2826. if ( ! DeviceIoControl( SysHandle, IOCTL_FILEMON_UNLOADQUERY,
  2827. NULL, 0, NULL, 0,
  2828. &irpcount, NULL ) ) {
  2829. Abort( hWnd, _T("Couldn't access device driver") );
  2830. return 0;
  2831. }
  2832. if( irpcount ) {
  2834. _stprintf( msgbuf,  _T("The Filemon device driver cannot unloadn")
  2835. _T("at this time due to oustanding requests.nn")
  2836. _T("Do you wish to exit the GUI now?"));
  2837. if( MessageBox( hWnd, msgbuf, APPNAME, MB_ICONSTOP|MB_YESNO ) == IDNO )
  2838. return 0;
  2839. } else {
  2840. if ( ! UnloadDeviceDriver( SYS_NAME ) )  {
  2841. _stprintf( msgbuf, _T("Error unloading "%s""), SYS_NAME );
  2842. MessageBox( hWnd, msgbuf, APPNAME, MB_OK );
  2843. }
  2844. }
  2845. } 
  2846. #endif
  2847. CloseHandle( SysHandle );
  2848. SavePositionSettings( hWnd );
  2849. return DefWindowProc( hWnd, message, wParam, lParam );
  2851. case WM_PAINT:
  2852. if( !IsNT && Deleting ) {
  2853. hDC = BeginPaint( hWnd, &Paint );
  2854. EndPaint( hWnd, &Paint );
  2855. return TRUE;
  2856. }
  2857. return DefWindowProc( hWnd, message, wParam, lParam );
  2859. case WM_DESTROY:
  2860. PostQuitMessage(0);
  2861. return 0;
  2863. default:
  2865. // is it a find-string message?
  2866. if (message == findMessageID ){ 
  2868. // get a pointer to the find structure
  2869. findMessageInfo = (LPFINDREPLACE)lParam;
  2871. // If the FR_DIALOGTERM flag is set, invalidate the find window handle
  2872. if( findMessageInfo->Flags & FR_DIALOGTERM) {
  2873. hWndFind = NULL;
  2874. PrevMatch = FALSE;
  2875.     FindFlags = FindTextInfo.Flags & (FR_DOWN|FR_MATCHCASE|FR_WHOLEWORD);
  2876. return 0;
  2877. }
  2879. // if the FR_FINDNEXT flag is set, go do the search
  2880. if( findMessageInfo->Flags & FR_FINDNEXT ) {
  2881. SetCapture(hWndFind);
  2882. hSaveCursor = SetCursor(hHourGlass);
  2883. EnableWindow( hWndFind, FALSE );
  2884. if( FindInListview( hWnd, findMessageInfo ) ) {
  2885. Autoscroll = FALSE;
  2886. CheckMenuItem( GetMenu(hWnd), IDM_AUTOSCROLL,
  2887. MF_BYCOMMAND|MF_UNCHECKED ); 
  2888. SendMessage( hWndToolbar, TB_CHANGEBITMAP, IDM_AUTOSCROLL, 3 );
  2889. }
  2890. EnableWindow( hWndFind, TRUE );
  2891. ReleaseCapture(); 
  2892. return 0;
  2893. }
  2894. return 0;
  2895. }
  2897. // Default behavior
  2898. return DefWindowProc( hWnd, message, wParam, lParam );
  2899. }
  2900. return 0;
  2901. }
  2904. /****************************************************************************
  2905. *
  2906. *    FUNCTION: InitApplication(HANDLE)
  2907. *
  2908. *    PURPOSE: Initializes window data and registers window class
  2909. *
  2910. ****************************************************************************/
  2911. BOOL InitApplication( HANDLE hInstance )
  2912. {
  2913. WNDCLASS  wc;
  2915. // Fill in window class structure with parameters that describe the
  2916. // main (statistics) window. 
  2917. wc.style = 0;                     
  2918. wc.lpfnWndProc = (WNDPROC)MainWndProc; 
  2919. wc.cbClsExtra = 0;              
  2920. wc.cbWndExtra = 0;              
  2921. wc.hInstance = hInstance;       
  2922. wc.hIcon = LoadIcon( hInstance, _T("APPICON") );
  2923. wc.hCursor = LoadCursor( NULL, IDC_ARROW );
  2924. wc.hbrBackground = (HBRUSH)(COLOR_INACTIVEBORDER + 1); // Default color
  2925. wc.lpszMenuName = _T("LISTMENU");  
  2926. wc.lpszClassName = _T("FileMonClass");
  2927. if ( ! RegisterClass( &wc ) )
  2928. return FALSE;
  2930. wc.lpszMenuName   = NULL;
  2931.   wc.lpfnWndProc    = (WNDPROC) BalloonDialog;
  2932. wc.hbrBackground  = CreateSolidBrush( 0x00E0FFFF );
  2933. wc.lpszClassName  = _T("BALLOON");
  2934. RegisterClass( &wc );
  2936. return TRUE;
  2937. }
  2940. /****************************************************************************
  2941. *
  2942. *    FUNCTION:  InitInstance(HANDLE, int)
  2943. *
  2944. *    PURPOSE:  Saves instance handle and creates main window
  2945. *
  2946. ****************************************************************************/
  2947. HWND InitInstance( HANDLE hInstance, int nCmdShow )
  2948. {
  2949. // get the window position settings from the registry
  2950. GetPositionSettings();
  2952. // create the main window
  2953. hInst = hInstance;
  2954. hWndMain = CreateWindow( _T("FileMonClass"), 
  2955. _T("File Monitor - Systems Internals: http://www.sysinternals.com"), 
  2956. WS_OVERLAPPEDWINDOW,
  2957. PositionInfo.left, PositionInfo.top, 
  2958. PositionInfo.width, PositionInfo.height,
  2959. NULL, NULL, hInstance, NULL );
  2961. // if window could not be created, return "failure" 
  2962. if ( ! hWndMain )
  2963. return NULL;
  2965. // make the window visible; update its client area; and return "success"
  2966. ShowWindow( hWndMain, nCmdShow );
  2968. // maximize it if necessary
  2969. if( PositionInfo.maximized ) {
  2971. ShowWindow( hWndMain, SW_SHOWMAXIMIZED );
  2972. }
  2974. UpdateWindow( hWndMain ); 
  2975. if( OnTop ) {
  2977. SetWindowPos( hWndMain, HWND_TOPMOST, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE );
  2978. CheckMenuItem( GetMenu(hWndMain), IDM_ONTOP,
  2979. MF_BYCOMMAND|(OnTop?MF_CHECKED:MF_UNCHECKED) );
  2980. }
  2981. return hWndMain;      
  2982. }
  2985. /****************************************************************************
  2986. *
  2987. * FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
  2988. *
  2989. * PURPOSE: calls initialization function, processes message loop
  2990. *
  2991. ****************************************************************************/
  2992. int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
  2993. LPSTR lpCmdLine, int nCmdShow )
  2994. {
  2995. MSG  msg;      
  2996. HWND hWnd;
  2997. HACCEL hAccel;
  2998.   DWORD NTVersion;
  2999.         
  3000. if ( ! InitApplication( hInstance ) )
  3001. return FALSE;   
  3003. // get NT version
  3004. NTVersion = GetVersion();
  3005. if( NTVersion >= 0x80000000 ) {
  3007. IsNT = FALSE;
  3008. } else {
  3010. IsNT = TRUE;
  3011. }
  3013. // initializations that apply to a specific instance 
  3014. if ( (hWnd = InitInstance( hInstance, nCmdShow )) == NULL )
  3015. return FALSE;
  3017. // load accelerators
  3018. hAccel = LoadAccelerators( hInstance, _T("ACCELERATORS"));
  3020. // register for the find window message
  3021.     findMessageID = RegisterWindowMessage( FINDMSGSTRING );
  3023. // acquire and dispatch messages until a WM_QUIT message is received.
  3024. while ( GetMessage( &msg, NULL, 0, 0 ) )  {
  3025. if( !TranslateAccelerator( hWnd, hAccel, &msg ) &&
  3026. (!hWndFind || !IsWindow(hWndFind) || !IsDialogMessage( hWndFind, &msg ))) {
  3027. TranslateMessage( &msg );
  3028. DispatchMessage( &msg ); 
  3029. }
  3030. }
  3031. return msg.wParam;  
  3032. }