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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
FILER.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：49k
源码类别：

Windows编程

开发平台：

Visual C++

FILER.C：源码内容
  2. /******************************************************************************
  3. *       This is a part of the Microsoft Source Code Samples. 
  4. *       Copyright (C) 1993-1997 Microsoft Corporation.
  5. *       All rights reserved. 
  6. *       This source code is only intended as a supplement to 
  7. *       Microsoft Development Tools and/or WinHelp documentation.
  8. *       See these sources for detailed information regarding the 
  9. *       Microsoft samples programs.
  10. ******************************************************************************/
  12. /******************************Module*Header*******************************
  13. *
  14. * Module Name:  Filer.c
  15. *
  16. *
  17. * Filer: SDK sample
  18. *   +   Simple File Management program with GUI front end.
  19. *       Demonstrates Win32 File I/O API and various User algorithms.
  20. *
  21. * Dependencies:
  22. *
  23. *   (#defines)
  24. *   (#includes)
  25. *         -Enumdrv.h
  26. *         -Walk.h
  27. *         -Drvproc.h
  28. *         -Filer.h
  29. *
  30. **************************************************************************/
  31. #define  STRICT
  32. #include <windows.h>
  33. #include <stdlib.h>
  34. #include <stdarg.h>
  35. #include "globals.h"
  36. #include "enumdrv.h"
  37. #include "drvproc.h"
  38. #include "filer.h"
  40. //
  41. // Global Handles
  42. //
  43. HANDLE  ghModule;                     // Process Instance handle
  45. HWND    ghwndMain;                       // Main window handle
  46. HWND    ghwndDrives;                     // Drives Toolbar window handle
  47. HWND    ghwndFunction;                   // Function Toolbar window handle
  48. HWND    ghwndCommand;                    // Command Line window handle
  49. HWND    ghwndDrv1,
  50.         ghwndDrv2;
  51. HWND    ghActiveChild = NULL;            // Handle to active drive child window
  52. HWND    ghFocusWnd;                      // Handle to last listbox with focus
  55. HANDLE  ghHeap;                          // Application heap handle
  56. HFONT   ghFont;
  57. HANDLE  ghDrvThread = NULL;
  59. HMENU   ghMenu;                          // App Menu variables
  61. //
  62. //   Global Data Items
  63. //
  64. BOOL                gfDrvWndOrient = SIDE_BY_SIDE, // relative Drv child pos.
  65.                     gfKeepCommandWin = FALSE;
  67. DRVCHILDINFO        gDrvChild1Info,
  68.                     gDrvChild2Info;
  70. LPDINFO             glpDrives = NULL;    // Root of Available Drives linked list
  72. CRITICAL_SECTION    gDrvCS;              // Drive list critical section var.
  73. CRITICAL_SECTION    gHeapCS;             // Global heap critical section.
  75. TCHAR    gszCommandLine[DIRECTORY_STRING_SIZE * 2];
  76. TCHAR    gszExtensions[NUM_EXTENSION_STRINGS][EXTENSION_LENGTH];
  78. VKINFO  gVKArray[NUM_VERSION_INFO_KEYS];     // .EXE version info array.
  79.                                              // See GetVersion() in DRVPROC.C
  81. /***************************************************************************
  82. * WinMain
  83. *
  84. *
  85. * History:
  86. * 04-17-91
  87. *   Created.
  88. ***************************************************************************/
  89. int WINAPI WinMain(
  90.     HINSTANCE hInstance,
  91.     HINSTANCE hPrevInstance,
  92.     LPSTR lpCmdLine,
  93.     int nCmdShow)
  94. {
  95.     MSG    msg;
  96.     HANDLE hAccel;
  98.     //-- check to make sure we are running on Windows NT
  99.     if( GetVersion() & 0x80000000 ) {            // 0x80000000 == Windows 3.1
  100.         MessageBox( NULL,
  101.         TEXT("Sorry, Filer must run under Windows NT.  Filer will now terminate."),
  102.         TEXT("Error: Windows NT Required"),  MB_OK );
  103.         return( 0 );
  104.     }
  106.     ghModule = hInstance;
  108.     if (!InitializeApp()) {
  109.         ErrorMsg(TEXT("Filer: InitializeApp failure!"));
  110.         return 0;
  111.     }
  112.     ShowWindow(ghwndMain, nCmdShow);
  114.     if (!(hAccel = LoadAccelerators (ghModule, MAKEINTRESOURCE(ACCEL_ID))))
  115.         ErrorMsg(TEXT("Filer: Load Accel failure!"));
  118.     while (GetMessage(&msg, NULL, 0, 0)) {
  119.         if( !TranslateAccelerator(ghwndMain, hAccel, &msg) ) {
  120.             TranslateMessage(&msg);
  121.             DispatchMessage(&msg);
  122.         }
  123.     }
  125.     return 1;
  127.     UNREFERENCED_PARAMETER(lpCmdLine);
  128.     UNREFERENCED_PARAMETER(hPrevInstance);
  129. }
  132. /***************************************************************************
  133. * InitializeApp
  134. *
  135. * History:
  136. * 5/5/92
  137. *   Created
  138. ***************************************************************************/
  140. BOOL InitializeApp(void)
  141. {
  142.     WNDCLASS wc;
  144.     wc.style            = 0;
  145.     wc.lpfnWndProc      = (WNDPROC)MainWndProc;
  146.     wc.cbClsExtra       = 0;
  147.     wc.cbWndExtra   = 0;
  148.     wc.hInstance        = ghModule;
  149.     wc.hIcon            = LoadIcon(ghModule, MAKEINTRESOURCE(UI_FILERICON));
  150.     wc.hCursor          = LoadCursor(ghModule, IDC_ARROW);
  151.     wc.hbrBackground    = (HBRUSH)(COLOR_APPWORKSPACE);
  152.     wc.lpszMenuName     = TEXT("FilerMenu");
  153.     wc.lpszClassName    = TEXT("FilerClass");
  155.     if (!RegisterClass(&wc))
  156.     return(FALSE);
  158.     wc.lpfnWndProc  = DrvWndProc;
  159.     wc.hIcon        = NULL;
  160.     wc.lpszMenuName = NULL;
  161.     wc.lpszClassName    = TEXT("DrvClass");
  163.     if (!RegisterClass(&wc))
  164.         return(FALSE);
  166.     wc.style        = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
  167.     wc.lpfnWndProc  = DriveBarProc;
  168.     wc.hbrBackground    = (HBRUSH)(COLOR_BTNSHADOW);
  169.     wc.lpszClassName    = TEXT("DriveBarClass");
  171.     if (!RegisterClass(&wc))
  172.             return(FALSE);
  174.     wc.style        = CS_HREDRAW | CS_VREDRAW;
  175.     wc.lpfnWndProc  = TextWndProc;
  176.     wc.hbrBackground    = (HBRUSH)(COLOR_INACTIVECAPTION);
  177.     wc.lpszClassName    = TEXT("TextClass");
  179.     if (!RegisterClass(&wc))
  180.             return(FALSE);
  182.     ghMenu = LoadMenu(ghModule, TEXT("FilerMenu"));
  184.     ghwndMain = CreateWindow(TEXT("FilerClass"),
  185.                              TEXT("Filer"),
  186.                              WS_OVERLAPPEDWINDOW,
  187.                              CW_USEDEFAULT,
  188.                              CW_USEDEFAULT,
  189.                              MAIN_WIDTH,
  190.                              MAIN_HEIGHT,
  191.                              HWND_DESKTOP,
  192.                              ghMenu,
  193.                              ghModule,
  194.                              NULL);
  196.     if (ghwndMain == NULL)
  197.     return(FALSE);
  199.     return(TRUE);
  200. }
  203. /***************************************************************************
  204. * MainWndProc
  205. *
  206. * History:
  207. * 05-01-92  Created.
  208. ***************************************************************************/
  210. LRESULT WINAPI MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  211. {
  212.     switch (message) {
  214.       case WM_CREATE:{
  215.         LOGFONT    lf;
  216.         HDC        hDC;
  217.         HGDIOBJ    hOldFont;
  218.         TEXTMETRIC tm;
  220.         DWORD dwThreadID;
  222.         //
  223.         // Initialize drive list and Set Directory critical sections.
  224.         //
  225.         InitializeCriticalSection(&gDrvCS);
  226.         InitializeCriticalSection(&gHeapCS);
  228.         ghDrvThread = CreateThread(NULL, 0,
  229.                                    (LPTHREAD_START_ROUTINE)EnumDrives,
  230.                                    (LPVOID)&glpDrives,
  231.                                    0, &dwThreadID);
  233.         //
  234.         // Create the application's heap
  235.         //
  236.         ghHeap = HeapCreate( 0, (DWORD)sizeof(DRVCHILDINFO), 0);
  237.         if( ghHeap == NULL )
  238.             ErrorMsg(TEXT("Main Create: Failed in Creating Heap"));
  240.         //
  241.         // Compute default application font by creating a bold version
  242.         //   of the system default icon font.
  243.         //
  244.         SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lf),
  245.                              (PVOID) &lf, FALSE);
  247.         hDC = GetDC(hwnd);
  249.         // this is the height for 8 point size font in pixels.
  250.         //  (1 point = 1/72 in.)
  251.         //  Japanese fonts have different characteristics and don't look good in bold
  252.         if (PRIMARYLANGID(GetUserDefaultLangID()) == LANG_JAPANESE)
  253.             lf.lfHeight = 10 * GetDeviceCaps(hDC, LOGPIXELSY) / 72;
  254.         else {
  255.             lf.lfHeight = 8 * GetDeviceCaps(hDC, LOGPIXELSY) / 72;
  256.             lf.lfWeight = BOLD_FONT;
  257.         }
  259.         ghFont = CreateFontIndirect(&lf);
  260.         hOldFont = SelectObject(hDC, ghFont);
  261.         GetTextMetrics(hDC, &tm);
  263.         if(hOldFont)
  264.             SelectObject(hDC, hOldFont);
  266.         ReleaseDC(hwnd, hDC);
  268.         //
  269.         // Create Drive windows
  270.         //
  271.         gDrvChild1Info.hParent = hwnd;
  272.         gDrvChild2Info.hParent = hwnd;
  274.         ghwndDrv1 = CreateWindow(TEXT("DrvClass"), NULL,
  275.                                  WS_CHILD |
  276.                                  WS_CLIPSIBLINGS | WS_VISIBLE,
  277.                                  0, 0, 0, 0,
  278.                                  hwnd, (HMENU) 1, ghModule,
  279.                                  (LPVOID)&gDrvChild1Info);
  281.         ghActiveChild = ghwndDrv1;
  283.         //
  284.         // Set initial focus to Drive Child 1's Directory listbox.
  285.         //
  286.         ghFocusWnd = ((LPCINFO)GetWindowLong(ghwndDrv1, GWL_USERDATA))->hDirLB;
  288.         ghwndDrv2 = CreateWindow(TEXT("DrvClass"), NULL,
  289.                                  WS_CHILD |
  290.                                  WS_CLIPSIBLINGS | WS_VISIBLE,
  291.                                  0, 0, 0, 0,
  292.                                  hwnd, (HMENU) 2, ghModule,
  293.                                  (LPVOID)&gDrvChild2Info);
  295.         //
  296.         // Create DriveBar, FunctionBar and Command windows
  297.         //
  298.         ghwndDrives = CreateWindow(TEXT("DriveBarClass"), NULL,
  299.                                    WS_CHILD | WS_VISIBLE | WS_BORDER,
  300.                                    0, 0, 0, 0,
  301.                                    hwnd, (HMENU) 3, ghModule,
  302.                                    (LPVOID)NULL);
  304.         ghwndFunction = CreateDialog(ghModule,
  305.                                     TEXT("FunctionBar"),
  306.                                     hwnd,
  307.                                     (DLGPROC)FunctionBarProc);
  309.         ghwndCommand = CreateWindow(TEXT("EDIT"), NULL,
  310.                                    ES_AUTOHSCROLL | ES_LEFT | WS_BORDER |
  311.                                    ES_NOHIDESEL | WS_CHILD | WS_VISIBLE,
  312.                                    0, 0, 0, 0,
  313.                                    hwnd,
  314.                                    (HMENU) COMMAND_ID,
  315.                                    ghModule,
  316.                                    NULL);
  318.         //
  319.         // Compute height of command window from font; store in window info.
  320.         // Set command window to default font.
  321.         //
  322.         SetWindowLong( ghwndCommand, GWL_USERDATA,
  323.                        tm.tmHeight + GetSystemMetrics(SM_CYBORDER) + 6);
  324.         SendMessage(ghwndCommand, WM_SETFONT, (WPARAM)ghFont, (LPARAM)FALSE);
  326.         //
  327.         // Load String table entries
  328.         //
  329.         LoadString( ghModule, STR_EXE, &gszExtensions[0][0], EXTENSION_LENGTH);
  330.         LoadString( ghModule, STR_COM, &gszExtensions[1][0], EXTENSION_LENGTH);
  331.         LoadString( ghModule, STR_CMD, &gszExtensions[2][0], EXTENSION_LENGTH);
  332.         LoadString( ghModule, STR_BAT, &gszExtensions[3][0], EXTENSION_LENGTH);
  334.         UpdateDrivesMenu(ghMenu, ghDrvThread);
  336.         return(1);
  337.       }
  339.       case WM_COMMAND:{
  341.         //
  342.         // The menu Identifiers for the drives are (potentially)
  343.         // MM_DRIVE_NUM + 0 thru MM_DRIVE_NUM + 25. They all go to the
  344.         // same case, so we will put the Menu ID in lParam, and
  345.         // MM_DRIVE_NUM in LOWORD(wParam).
  346.         //
  347.         if( (LOWORD(wParam) - MM_DRIVE_NUM) <= 25 &&
  348.             (LOWORD(wParam) - MM_DRIVE_NUM) >= 0 ){
  349.             lParam = LOWORD(wParam);
  350.             wParam = MM_DRIVE_NUM;
  351.         }
  353.         switch (LOWORD(wParam)) {
  354.             //
  355.             // If a drive is selected from the Drives menu, or clicked
  356.             //  on the drives toolbar, the currently active child will
  357.             //  switch to this drive. Message 'unconverted' (see top of
  358.             //  WM_COMMAND case), and sent to DriveBarProc
  359.             //
  360.             case MM_DRIVE_NUM:{
  362.                 SendMessage(ghwndDrives, WM_COMMAND,
  363.                             (WPARAM)lParam, (LPARAM)NULL);
  364.                 return(1);
  365.             }
  367.             //
  368.             // Passes these WM_COMMAND messages to the appropriate active child
  369.             //  window proc for processing
  370.             //
  371.             case MM_TAB:
  372.             case MM_ESCAPE:
  373.             case MM_OPEN:
  374.             case MM_COPY:
  375.             case MM_DELETE:
  376.             case MM_MOVE:
  377.             case MM_RENAME:
  378.             case MM_MKDIR:
  379.             case MM_EXPAND:
  380.             case MM_VERSION:{
  382.                 SendMessage(ghActiveChild, WM_COMMAND, wParam, lParam);
  383.                 return(1);
  384.             }
  386.             case MM_EXIT:{
  387.                 SendMessage(ghwndMain, WM_CLOSE, wParam, lParam);
  388.                 return(1);
  389.             }
  391.             //
  392.             // Creates the drive enumeration thread to re-enumerate the
  393.             //   available drives in the main menu.  Also sends a refresh
  394.             //   to the active drive child, and repaints the window.
  395.             //
  396.             case MM_REFRESH: {
  397.                 DWORD   dwThreadID;
  399.                 //
  400.                 // Initialize/Refresh Drives linked list
  401.                 //
  403.                 if( WaitForSingleObject(ghDrvThread, 0) != WAIT_TIMEOUT ){
  405.                     //
  406.                     // Close previous Drive Thread handle before creating new handle.
  407.                     //
  408.                     CloseHandle( ghDrvThread );
  410.                     ghDrvThread = CreateThread(NULL, 0,
  411.                                            (LPTHREAD_START_ROUTINE)EnumDrives,
  412.                                            (LPVOID)&glpDrives,
  413.                                            0, &dwThreadID);
  415.                     //
  416.                     // Refresh active child, drive toolbar, and drives menu
  417.                     //
  418.                     SendMessage(ghActiveChild, WM_COMMAND, wParam, lParam);
  419.                     SendMessage(ghwndDrives, WM_COMMAND, wParam, lParam);
  420.                     UpdateDrivesMenu(ghMenu, ghDrvThread);
  422.                     //
  423.                     // Mark all for repaint
  424.                     //
  425.                     InvalidateRect(hwnd,NULL,TRUE);
  427.                 }
  428.                 else
  429.                     MessageBeep(MB_ICONASTERISK);
  431.                 return(1);
  432.             }
  434.             //
  435.             // Swaps the directory and file list boxes of the active drv child.
  436.             //
  437.             case MM_SWAP:{
  438.                 LPCINFO lpCInfo;
  439.                 RECT    rect;
  441.                 lpCInfo = (LPCINFO)GetWindowLong(ghActiveChild, GWL_USERDATA);
  443.                 //
  444.                 // Switch the flag which indicates which side the Directory
  445.                 //  LB is on.  This is used by the WM_SIZE case of DrvWndProc.
  446.                 //
  447.                 lpCInfo->fDirLeft = !lpCInfo->fDirLeft;
  449.                 //
  450.                 // Send size message with current size to active child,
  451.                 //   in order to redraw the listboxes.
  452.                 //
  453.                 if( !GetClientRect( ghActiveChild, &rect ) )
  454.                     return(0);
  456.                 SendMessage( ghActiveChild, WM_SIZE, SIZENORMAL,
  457.                              MAKELONG( rect.right - rect.left,
  458.                                        rect.bottom - rect.top) );
  459.                 return(1);
  460.             }
  462.             case MM_KEEPCMD:{
  464.                 gfKeepCommandWin = !gfKeepCommandWin;
  466.                 if( gfKeepCommandWin )
  467.                     CheckMenuItem( ghMenu, MM_KEEPCMD,
  468.                                     MF_BYCOMMAND | MF_CHECKED);
  469.                 else
  470.                     CheckMenuItem( ghMenu, MM_KEEPCMD,
  471.                                 MF_BYCOMMAND | MF_UNCHECKED);
  472.             }
  473.             break;
  475.             //
  476.             // Toggles the relative Drive Child orientaion between
  477.             // Over/under and side/side.  gfDrvWndOrient is a flag checked
  478.             // by WM_SIZE to size Drv children
  479.             //
  480.             case MM_ORIENT:{
  481.                 RECT    rect;
  483.                 if( gfDrvWndOrient == OVER_UNDER )
  484.                     gfDrvWndOrient = SIDE_BY_SIDE;
  485.                 else
  486.                     gfDrvWndOrient = OVER_UNDER;
  488.                 //
  489.                 // Send size message with current size to self (main window),
  490.                 //   in order to redraw the Drv children.
  491.                 //
  492.                 if( !GetClientRect( hwnd, &rect ) )
  493.                     return(0);
  495.                 SendMessage( hwnd, WM_SIZE, SIZENORMAL,
  496.                              MAKELONG( rect.right - rect.left,
  497.                                        rect.bottom - rect.top) );
  499.                 InvalidateRect(ghwndDrv1,NULL,TRUE);
  500.                 InvalidateRect(ghwndDrv2,NULL,TRUE);
  502.                 return(1);
  503.             }
  505.             //
  506.             // Toggles the active drive child.  Sent from menu.
  507.             // This behaves the same as a WM_MOUSEACTIVATE in one of the
  508.             //   Drive children.  The PostMessage is so the current Active
  509.             //   child will not process the MM_TOGGLE message until after it
  510.             //   is no longer active.
  511.             //
  512.             case MM_ACTIVEDRV:{
  513.                 LPCINFO lpCInfo;
  515.                 PostMessage(ghActiveChild, WM_COMMAND, (WPARAM)MM_TOGGLE,
  516.                             (LPARAM)NULL);
  518.                 if( ghActiveChild == ghwndDrv1 )
  519.                     ghActiveChild = ghwndDrv2;
  520.                 else
  521.                     ghActiveChild = ghwndDrv1;
  523.                 SendMessage(ghActiveChild, WM_COMMAND, (WPARAM)MM_TOGGLE,
  524.                             (LPARAM)NULL);
  526.                 // change drive button
  527.                 lpCInfo = (LPCINFO)GetWindowLong(ghActiveChild, GWL_USERDATA);
  528.                 SendMessage(ghwndDrives, WM_COMMAND, MM_ACTIVEDRV,
  529.                             (LPARAM)lpCInfo->lpDriveInfo);
  530.                 return(1);
  531.             }
  533.             //
  534.             // Sent by the Command line Edit control.
  535.             //
  536.             case COMMAND_ID:{
  538.                 if( HIWORD(wParam) == EN_SETFOCUS )
  539.                     ghFocusWnd = ghwndCommand;
  540.             }
  541.             break;
  543.             //
  544.             // Launches the About DialogBox.
  545.             //
  546.             case MM_ABOUT:{
  547.                 TCHAR   lpBuffer[128];
  549.                 if (DialogBox(ghModule, TEXT("AboutBox"), ghwndMain, (DLGPROC)AboutProc) == -1) {
  550.                     LoadString(ghModule, IDS_ABOUTDLGERR, lpBuffer, sizeof(lpBuffer));
  551.                     ErrorMsg(lpBuffer);
  552.                 }
  553.                 return(1);
  554.             }
  556.             default:
  557.                 return( DefWindowProc(hwnd, message, wParam, lParam) );
  558.         }
  559.         return(1);
  560.       }
  561.       //
  562.       // Whenever the window is resized, its children have to be
  563.       //  resized accordingly.  The GetWindowLong values are the height
  564.       //  of the windows queried by this function, and are set in the
  565.       //  WM_CREATE cases of their respective WNDPROCs.
  566.       //
  567.       case WM_SIZE:{
  568.         int DrvWndHeight;
  570.         //
  571.         // Always put the command window at the bottom of the frame window
  572.         //
  573.         MoveWindow(ghwndCommand,
  574.            0,
  575.            HIWORD(lParam) - GetWindowLong(ghwndCommand, GWL_USERDATA),
  576.            LOWORD(lParam),
  577.            GetWindowLong(ghwndCommand, GWL_USERDATA),
  578.                TRUE);
  579.         //
  580.         // Always put the drives toolbar at the top of the frame window
  581.         //
  582.         MoveWindow(ghwndDrives,
  583.            0,
  584.            0,
  585.            LOWORD(lParam),
  586.            GetWindowLong(ghwndDrives, GWL_USERDATA),
  587.                TRUE);
  589.         //
  590.         // Always put the Function window just below the drives toolbar.
  591.         //
  592.         MoveWindow(ghwndFunction,
  593.                    0,
  594.                    GetWindowLong(ghwndDrives, GWL_USERDATA),
  595.                    LOWORD(lParam),
  596.                    GetWindowLong(ghwndFunction, GWL_USERDATA),
  597.                    TRUE);
  599.         //
  600.         // Always size the Drive Children between the Drives and Command
  601.         // windows. The width is set so that borders overlap.
  602.         //
  604.         if( gfDrvWndOrient == OVER_UNDER ){
  606.             DrvWndHeight = ( HIWORD(lParam) -
  607.                            GetWindowLong(ghwndDrives, GWL_USERDATA) -
  608.                            GetWindowLong(ghwndFunction, GWL_USERDATA) -
  609.                            GetWindowLong(ghwndCommand, GWL_USERDATA) ) / 2;
  611.             MoveWindow(ghwndDrv1,
  612.                         -1,
  613.                         GetWindowLong(ghwndDrives, GWL_USERDATA)+
  614.                             GetWindowLong(ghwndFunction, GWL_USERDATA),
  615.                         LOWORD(lParam) + 2,
  616.                         DrvWndHeight,
  617.                         TRUE);
  619.             MoveWindow(ghwndDrv2,
  620.                         -1,
  621.                         GetWindowLong(ghwndDrives, GWL_USERDATA)+
  622.                             GetWindowLong(ghwndFunction, GWL_USERDATA) +
  623.                             DrvWndHeight,
  624.                         LOWORD(lParam) + 2,
  625.                         DrvWndHeight,
  626.                         TRUE);
  627.         }
  628.         else{
  630.             DrvWndHeight = HIWORD(lParam) -
  631.                            GetWindowLong(ghwndDrives, GWL_USERDATA) -
  632.                            GetWindowLong(ghwndFunction, GWL_USERDATA) -
  633.                            GetWindowLong(ghwndCommand, GWL_USERDATA);
  635.             MoveWindow(ghwndDrv1,
  636.                         -1,
  637.                         GetWindowLong(ghwndDrives, GWL_USERDATA)+
  638.                             GetWindowLong(ghwndFunction, GWL_USERDATA),
  639.                         LOWORD(lParam)/2 + 1,
  640.                         DrvWndHeight,
  641.                         TRUE);
  643.             MoveWindow(ghwndDrv2,
  644.                         LOWORD(lParam)/2,
  645.                         GetWindowLong(ghwndDrives, GWL_USERDATA)+
  646.                             GetWindowLong(ghwndFunction, GWL_USERDATA),
  647.                         LOWORD(lParam)/2 + 1,
  648.                         DrvWndHeight,
  649.                         TRUE);
  650.         }
  652.         return(1);
  653.       }
  655.       case WM_DESTROY: {
  656.         //
  657.         // Close last drive thread handle, the global heap and it's corresponding critical section,
  658.         //  the created font, and the Drive list critical section.
  659.         //
  660.         CloseHandle( ghDrvThread );
  662.         EnterCriticalSection(&gHeapCS);
  663.         HeapDestroy(ghHeap);
  664.         LeaveCriticalSection(&gHeapCS);
  666.         DeleteObject(ghFont);
  668.         DeleteCriticalSection(&gDrvCS);
  669.         DeleteCriticalSection(&gHeapCS);
  671.         PostQuitMessage(0);
  672.         return(1);
  673.       }
  675.       default:
  676.         return DefWindowProc(hwnd, message, wParam, lParam);
  677.     }
  678. }
  681. /***************************************************************************
  682. * AboutProc
  683. *
  684. * About dialog proc.
  685. *
  686. * History:
  687. *   05-13-92      Created.
  688. ***************************************************************************/
  690. LRESULT WINAPI AboutProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  691. {
  692.     switch (message) {
  693.       case WM_INITDIALOG:{
  694.         return TRUE;
  695.       }
  697.       case WM_COMMAND:{
  698.         if (wParam == IDOK)
  699.             EndDialog(hDlg, wParam);
  700.         break;
  701.       }
  702.     }
  704.     return FALSE;
  706.     UNREFERENCED_PARAMETER(lParam);
  707.     UNREFERENCED_PARAMETER(hDlg);
  708. }
  711. /***************************************************************************
  712. *
  713. * DriveBarProc()
  714. *
  715. * Drive Toolbar procedure for displaying available drive Icons.
  716. *  A bitmap button is displayed corresponding to the drive type of the
  717. *  given drive, with the drive letter alongside.
  718. *  ghwndDrives is the global handle assoc. w/ this window procedure.
  719. *
  720. *
  721. * History:
  722. * 6/9/92
  723. *   Created.
  724. *
  725. ***************************************************************************/
  727. LRESULT WINAPI DriveBarProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  728. {
  729.     static HBITMAP  hDrvBmp[NUM_BITMAPS];
  730.     static HBRUSH   hBrush;         // background brush
  731.     static int      nDrvEntryWidth; // width of button/letter entry
  732.     static int      yVal;           // y value in toolbar for top left of bmp
  733.     static LPBINFO  lpDrvButtonRoot;
  734.     static int      nActiveDrvIndex;
  735.     TCHAR           lpBuffer[128];
  737.     switch (message)
  738.     {
  739.         case WM_CREATE:{
  740.             HDC        hDC;
  741.             HGDIOBJ    hOldFont;
  742.             TEXTMETRIC tm;
  743.             LONG       lHeight;
  746.             lpDrvButtonRoot = NULL;
  748.             //
  749.             // Load drive button bitmaps.
  750.             //
  751.             for(yVal = 0; yVal < NUM_BITMAPS; yVal++)
  752.                 hDrvBmp[yVal] = LoadBitmap( ghModule,
  753.                                       MAKEINTRESOURCE(UB_BMP_MARKER + yVal) );
  755.             //
  756.             // Sets background color of Toolbar non-modal dialog children.
  757.             //
  758.             hBrush = CreateSolidBrush(GetSysColor(COLOR_BTNSHADOW));
  760.             hDC = GetDC(hwnd);
  762.             hOldFont = SelectObject(hDC, ghFont);
  763.             GetTextMetrics(hDC, &tm);
  764.             
  765.             // base the height of the window on size of text
  766.             // Different display height is optimal if on a Japanese language system
  767.             //
  768.             if (PRIMARYLANGID(GetUserDefaultLangID()) == LANG_JAPANESE) 
  769.                 lHeight = tm.tmHeight + GetSystemMetrics(SM_CYBORDER) + 8;
  770.             else 
  771.                 lHeight = tm.tmHeight + GetSystemMetrics(SM_CYBORDER) + 6;
  773.             //
  774.             // saved the window height, drive button entry width
  775.             //   and button y starting value for later reference
  776.             //
  777.             SetWindowLong(hwnd, GWL_USERDATA, lHeight);
  779.             //
  780.             // Width of one button entry = spacing, button, sm. space,
  781.             //   drive letter, spacing.
  782.             //
  783.             nDrvEntryWidth = DRIVE_BITMAP_SPACING + DRIVE_BITMAP_WIDTH +
  784.                              DRIVE_LETTER_SPACING + tm.tmAveCharWidth +
  785.                              DRIVE_BITMAP_SPACING;
  787.             //
  788.             // Center bitmaps (by height) in drive toolbar.
  789.             //
  790.             yVal = (lHeight - DRIVE_BITMAP_HEIGHT)/2;
  792.             SelectObject(hDC, hOldFont);
  793.             ReleaseDC(hwnd, hDC);
  795.             SendMessage(hwnd, WM_COMMAND, (WPARAM)MM_REFRESH, (LPARAM)NULL);
  797.             break;
  798.         }
  800.         case WM_COMMAND:{
  801.             //
  802.             // The button Identifiers for the drives are (potentially)
  803.             // MM_DRIVE_NUM + 0 thru MM_DRIVE_NUM + 25. They all go to the
  804.             // same case, so we will put the Menu ID in lParam, and
  805.             // MM_DRIVE_NUM in LOWORD(wParam).
  806.             //
  807.             if( (LOWORD(wParam) - MM_DRIVE_NUM) <= 25 &&
  808.                 (LOWORD(wParam) - MM_DRIVE_NUM) >= 0 ){
  809.                 lParam = LOWORD(wParam);
  810.                 wParam = MM_DRIVE_NUM;
  811.             }
  813.             switch( LOWORD(wParam) ){
  814.               case MM_REFRESH:{
  816.                 LPDINFO lpWalk;
  817.                 LPBINFO lpBWalk, lpBHold;
  818.                 LPCINFO lpCInfo;
  819.                 int     xVal = 0;
  820.                 int     nCount = MM_DRIVE_NUM;
  821.                 TCHAR   lpBuffer[128];
  823.                 lpCInfo = (LPCINFO)GetWindowLong(ghActiveChild, GWL_USERDATA);
  825.                 //
  826.                 // Wait for Drive Thread to complete, if necessary.
  827.                 //
  828.                 WaitForSingleObject(ghDrvThread, INFINITE);
  829.                 EnterCriticalSection(&gDrvCS);
  831.                 //
  832.                 // Traverse DRVINFO linked list, creating drive buttons and
  833.                 //   allocating corresp. structures as necessary.
  834.                 //
  835.                 lpWalk = glpDrives;
  836.                 lpBWalk = lpDrvButtonRoot;
  838.                 while( lpWalk != NULL ){
  839.                     if( lpBWalk == NULL ){ //If at the end of the button list
  841.                         // Allocate a LPBINFO (button) structure
  842.                         EnterCriticalSection(&gHeapCS);
  843.                         lpBWalk = (LPBINFO)HeapAlloc(ghHeap, 0, (DWORD)sizeof(BINFO) );
  844.                         LeaveCriticalSection(&gHeapCS);
  846.                         // Create a button window
  847.                         lpBWalk->hButton = (HANDLE)CreateWindow(TEXT("BUTTON"),
  848.                                                  lpWalk->DriveName,
  849.                                                  WS_CHILD | WS_VISIBLE |
  850.                                                  BS_OWNERDRAW,
  851.                                                  xVal + DRIVE_BITMAP_SPACING,
  852.                                                  yVal,
  853.                                                  DRIVE_BITMAP_WIDTH,
  854.                                                  DRIVE_BITMAP_HEIGHT,
  855.                                                  hwnd,
  856.                                                  (HMENU)nCount,
  857.                                                  ghModule,
  858.                                                  NULL);
  860.                         // Insert structure into list
  861.                         if( lpDrvButtonRoot == NULL)
  862.                             lpDrvButtonRoot = lpBHold = lpBWalk;
  863.                         else{
  864.                             lpBHold->next = lpBWalk;
  865.                             lpBWalk->next = NULL;
  866.                         }
  868.                     }
  870.                     // An LPBINFO (button) structure exists: now initialize
  872.                     // Set Title of Button (Drive Letter)
  873.                     SetWindowText(lpBWalk->hButton, lpWalk->DriveName);
  875.                     // Set Child Window ID for Button
  876.                     SetMenu( lpBWalk->hButton, (HMENU)nCount);
  878.                     // Determine button up/down status
  879.                     if( lpCInfo->lpDriveInfo == lpWalk ){
  880.                         nActiveDrvIndex = nCount;
  881.                         lpBWalk->fButtonDown = TRUE;
  882.                     }
  883.                     else
  884.                         lpBWalk->fButtonDown = FALSE;
  886.                     // Set a pointer to the corresponding drive in Drive list
  887.                     lpBWalk->lpDrive = lpWalk;
  889.                     nCount++;
  890.                     xVal += nDrvEntryWidth;
  891.                     lpBHold = lpBWalk;
  892.                     lpBWalk = lpBWalk->next;
  894.                     lpWalk = lpWalk->next;
  895.                 }
  897.                 LeaveCriticalSection(&gDrvCS);
  899.                 //
  900.                 // Free any remaining button windows.
  901.                 //
  902.                 while( lpBWalk != NULL ){
  903.                     // NULL out new end of list
  904.                     lpBHold->next = NULL;
  906.                     // Assign pointer to doomed node
  907.                     lpBHold = lpBWalk;
  908.                     lpBWalk = lpBWalk->next;
  910.                     // Free doomed node resources
  911.                     if( !DestroyWindow(lpBHold->hButton) ) {
  912.                         LoadString(ghModule, IDS_DRVBUTTNERR, lpBuffer, sizeof(lpBuffer));
  913.                         ErrorMsg(lpBuffer);
  914.                     }
  916.                     EnterCriticalSection(&gHeapCS);
  917.                     HeapFree(ghHeap, 0, (LPVOID)lpBHold);
  918.                     LeaveCriticalSection(&gHeapCS);
  919.                 }
  921.                 SendMessage(hwnd, WM_PAINT, (WPARAM)NULL, (LPARAM)NULL);
  922.                 break;
  923.               }
  926.               //
  927.               // switches the drive button to the newly active drv child's
  928.               //   current drive.  Called by WM_MOUSEACTIVATE in DrvWndProc,
  929.               //   as well as ChangeDrive.
  930.               //   lParam contains the drive linked list pointer of the active
  931.               //   drv child's LPCINFO struct.
  932.               //
  933.               case MM_ACTIVEDRV:{
  934.                 LPBINFO lpBWalk = lpDrvButtonRoot;
  935.                 int     nCount = 0;
  937.                 //
  938.                 // 'unpush' old active button
  939.                 //
  940.                 for( nCount = MM_DRIVE_NUM; nCount < nActiveDrvIndex; nCount++)
  941.                     lpBWalk = lpBWalk->next;
  942.                 lpBWalk->fButtonDown = FALSE;
  944.                 InvalidateRect(lpBWalk->hButton, NULL, FALSE);
  946.                 //
  947.                 // change active drive to new before redrawing old.
  948.                 //  'push' new active button
  949.                 //
  950.                 lpBWalk = lpDrvButtonRoot;
  951.                 nCount = MM_DRIVE_NUM;
  952.                 while( lpBWalk->lpDrive != (LPDINFO)lParam){
  953.                     lpBWalk = lpBWalk->next;
  954.                     nCount++;
  955.                 }
  957.                 nActiveDrvIndex = nCount;
  959.                 lpBWalk->fButtonDown = TRUE;
  961.                 InvalidateRect(lpBWalk->hButton, NULL, FALSE);
  963.                 break;
  964.               }
  966.               //
  967.               // Changes drive of active child.  ButtonID in lParam.
  968.               //
  969.               case MM_DRIVE_NUM:{
  971.                 LPBINFO lpBWalk = lpDrvButtonRoot;
  972.                 int     nCount = 0;
  973.                 TCHAR    szDrvBuff[DIRECTORY_STRING_SIZE];
  975.                 //
  976.                 // if drive chosen is already current drive, leave.
  977.                 //
  978.                 if( nActiveDrvIndex == (int)lParam )
  979.                     break;
  981.                 //
  982.                 // unpush' old active button
  983.                 //
  984.                 for( nCount = MM_DRIVE_NUM; nCount < nActiveDrvIndex; nCount++)
  985.                     lpBWalk = lpBWalk->next;
  986.                 lpBWalk->fButtonDown = FALSE;
  988.                 //
  989.                 // change active drive to new before redrawing old.
  990.                 //
  991.                 nActiveDrvIndex = (int)lParam;
  993.                 InvalidateRect(lpBWalk->hButton, NULL, FALSE);
  995.                 //
  996.                 // 'push' new active button
  997.                 //
  998.                 lpBWalk = lpDrvButtonRoot;
  1000.                 for( nCount = MM_DRIVE_NUM; nCount < nActiveDrvIndex; nCount++)
  1001.                     lpBWalk = lpBWalk->next;
  1002.                 lpBWalk->fButtonDown = TRUE;
  1004.                 InvalidateRect(lpBWalk->hButton, NULL, FALSE);
  1006.                 GetWindowText(lpBWalk->hButton, szDrvBuff,
  1007.                               DIRECTORY_STRING_SIZE);
  1009.                 if( !ChangeDrive(szDrvBuff, (DWORD)nActiveDrvIndex) ){
  1010.                     LoadString(ghModule, IDS_CHNGDRVERR, lpBuffer, sizeof(lpBuffer));
  1011.                     ErrorMsg(lpBuffer);
  1012.                     return(0);
  1013.                 }
  1015.                 break;
  1016.               }
  1017.             }
  1018.             return(1);
  1019.         }
  1021.         //
  1022.         // Sent by all created buttons for initialization purposes.
  1023.         //
  1024.         case WM_MEASUREITEM:{
  1025.             LPMEASUREITEMSTRUCT lpMIS;
  1027.             lpMIS = (LPMEASUREITEMSTRUCT)lParam;
  1029.             lpMIS->CtlType = ODT_BUTTON;
  1030.             lpMIS->CtlID = (UINT)wParam;
  1031.             lpMIS->itemWidth = DRIVE_BITMAP_WIDTH;
  1032.             lpMIS->itemHeight = DRIVE_BITMAP_HEIGHT;
  1034.             return(1);
  1035.         }
  1037.         //
  1038.         // Sent by owner draw drive buttons when needing redrawing.
  1039.         //
  1040.         case WM_DRAWITEM:{
  1041.             LPBINFO lpBWalk = lpDrvButtonRoot;
  1042.             int     nCount;
  1043.             int     nBmpIndex;
  1044.             HDC     hDC;
  1045.             HDC     hCompatDC;
  1046.             HGDIOBJ hOldBitmap;
  1047.             TCHAR    szDrvBuff[DIRECTORY_STRING_SIZE];
  1048.             LPDRAWITEMSTRUCT    lpDIS;
  1050.             lpDIS = (LPDRAWITEMSTRUCT)lParam;
  1052.             for( nCount = MM_DRIVE_NUM; nCount < (int)wParam; nCount++)
  1053.                 lpBWalk = lpBWalk->next;
  1055.             //
  1056.             // If not the current selected button, handle button stuff.
  1057.             //
  1058.             if( (int)wParam != nActiveDrvIndex ){
  1059.                 //
  1060.                 // mousebutton is down...
  1061.                 //
  1062.                 if( lpDIS->itemAction & ODA_SELECT ){
  1063.                     //
  1064.                     // left button region, 'unpush' button
  1065.                     //
  1066.                     if( lpDIS->itemState == (UINT)ODS_FOCUS )
  1067.                         lpBWalk->fButtonDown = FALSE;
  1068.                     //
  1069.                     // clicked on a button, draw 'pushed' button
  1070.                     //
  1071.                     if( lpDIS->itemState == (UINT)(ODS_SELECTED | ODS_FOCUS))
  1072.                         lpBWalk->fButtonDown = TRUE;
  1073.                 }
  1074.             }
  1076.             //
  1077.             // draw current state of button.
  1078.             //
  1079.             GetWindowText(lpDIS->hwndItem, szDrvBuff,
  1080.                           DIRECTORY_STRING_SIZE);
  1082.             szDrvBuff[1] = TEXT('');
  1084.             hCompatDC = CreateCompatibleDC(lpDIS->hDC);
  1085.             hOldBitmap = CreateCompatibleBitmap(hCompatDC,
  1086.                                                 DRIVE_BITMAP_WIDTH,
  1087.                                                 DRIVE_BITMAP_HEIGHT);
  1089.             nBmpIndex = GetDriveBitmap(lpBWalk);
  1091.             SelectObject( hCompatDC, hDrvBmp[nBmpIndex] );
  1093.             if( !hOldBitmap ) {
  1094.                 LoadString(ghModule, IDS_SELOBJERR, lpBuffer, sizeof(lpBuffer));
  1095.                 ErrorMsg(lpBuffer);
  1096.             }
  1097.             if( !BitBlt(lpDIS->hDC, lpDIS->rcItem.left, lpDIS->rcItem.top,
  1098.                    DRIVE_BITMAP_WIDTH,
  1099.                    DRIVE_BITMAP_HEIGHT,
  1100.                    hCompatDC, 0, 0, SRCCOPY) ) {
  1101.                 LoadString(ghModule, IDS_BITBLTERR, lpBuffer, sizeof(lpBuffer));
  1102.                 ErrorMsg(lpBuffer);
  1103.             }
  1105.             SelectObject( hCompatDC, hOldBitmap);
  1106.             DeleteDC(hCompatDC);
  1108.             hDC = GetDC(hwnd);
  1109.             SetBkMode(hDC, TRANSPARENT);
  1110.             SetTextColor(hDC, GetSysColor(COLOR_BTNTEXT) );
  1111.             SetBkColor(hDC, GetSysColor(COLOR_BTNSHADOW) );
  1113.             // Allow for a different aesthetic for Japanese systems
  1114.             if (GetUserDefaultLangID() == LANG_JAPANESE) 
  1115.                 TextOut(hDC,
  1116.                         ((int)(wParam - MM_DRIVE_NUM) * nDrvEntryWidth) +
  1117.                             DRIVE_BITMAP_SPACING + DRIVE_BITMAP_WIDTH +
  1118.                             DRIVE_LETTER_SPACING,
  1119.                         GetSystemMetrics(SM_CYBORDER)/2,
  1120.                         szDrvBuff, 1);
  1121.             else
  1122.                 TextOut(hDC,
  1123.                         ((int)(wParam - MM_DRIVE_NUM) * nDrvEntryWidth) +
  1124.                             DRIVE_BITMAP_SPACING + DRIVE_BITMAP_WIDTH +
  1125.                             DRIVE_LETTER_SPACING,
  1126.                         (GetSystemMetrics(SM_CYBORDER) + 6)/2,
  1127.                         szDrvBuff, 1);
  1129.             SetBkMode(hDC, OPAQUE);
  1131.             ReleaseDC(hwnd, hDC);
  1133.             break;
  1134.         }
  1137.         case WM_PAINT:{
  1138.             HDC     hCompatDC;
  1139.             RECT     rc;
  1140.             PAINTSTRUCT ps;
  1142.             //
  1143.             // Paint btnshadow background.
  1144.             //
  1145.             GetClientRect(hwnd, &rc);
  1147.             BeginPaint(hwnd, &ps);
  1149.             hCompatDC = CreateCompatibleDC(ps.hdc);
  1150.             FillRect(ps.hdc, &rc, hBrush);
  1152.             EndPaint(hwnd, &ps);
  1154.             return(TRUE);
  1155.         }
  1157.         case WM_DESTROY:{
  1158.             DeleteObject(hBrush);
  1160.             for(yVal = 0; yVal < NUM_BITMAPS; yVal++)
  1161.                 DeleteObject(hDrvBmp[yVal]);
  1163.             break;
  1164.         }
  1165.     }
  1166.     return DefWindowProc(hwnd, message, wParam, lParam);
  1167. }
  1170. /***************************************************************************
  1171. *
  1172. * GetDriveBitmap()
  1173. *
  1174. * Determines the appropriate index into the drive button bitmap array
  1175. *   (hDrvBmp[]), given a pointer to a drive info structure (LPDINFO)
  1176. *
  1177. *   lpWalk          -   pointer to LPDINFO structure.
  1178. *   lpCurrentDrv    -   pointer to current drive of active child.
  1179. *
  1180. *
  1181. * History:
  1182. * 6/16/92
  1183. *   Created.
  1184. *
  1185. ***************************************************************************/
  1186. int GetDriveBitmap(LPBINFO lpBWalk)
  1187. {
  1188.     int nBmpIndex;
  1190.     EnterCriticalSection(&gDrvCS);
  1192.     switch( lpBWalk->lpDrive->DriveType ){
  1193.         case DRIVE_REMOVABLE:{
  1194.           nBmpIndex = UB_FLOPPY1 - UB_BMP_MARKER;
  1195.           break;
  1196.         }
  1198.         case DRIVE_REMOTE:{
  1199.           nBmpIndex = UB_REMOTE1 - UB_BMP_MARKER;
  1200.             break;
  1201.         }
  1203.         case DRIVE_CDROM:{
  1204.           nBmpIndex = UB_CD1 - UB_BMP_MARKER;
  1205.             break;
  1206.         }
  1208.         case DRIVE_FIXED:
  1209.         default:{
  1210.           nBmpIndex = UB_FIXED1 - UB_BMP_MARKER;
  1211.             break;
  1212.         }
  1213.     }
  1215.     LeaveCriticalSection(&gDrvCS);
  1217.     if( lpBWalk->fButtonDown == TRUE )
  1218.         nBmpIndex++;
  1220.     return(nBmpIndex);
  1221. }
  1224. /***************************************************************************
  1225. *
  1226. * ChangeDrive()
  1227. *
  1228. *   Changes the current drive of the active child.  Called by the MM_DRIVE_NUM
  1229. *     cases in MainWndProc and DriveBarProc.  This is caused by choosing a
  1230. *     Drive menu item or selecting a drive button from the drive toolbar.
  1231. *
  1232. *     lpszDriveName -   points to a buffer containing the name of the drive
  1233. *     DriveID       -   points to the ID of the Menu item or button, which
  1234. *                         corresponds to the index into the drives linked list
  1235. *                         of the new drive.
  1236. *
  1237. * History:
  1238. * 6/20/92
  1239. *   Created.
  1240. *
  1241. ***************************************************************************/
  1242. BOOL ChangeDrive(LPTSTR lpszDriveName, DWORD DriveIndex)
  1243. {
  1244.     LPCINFO     lpCInfo;
  1245.     LPDINFO     lpWalk;
  1246.     DWORD       dwLoop;
  1247.     UINT        nDriveType;
  1248.     TCHAR       lpBuffer[128];
  1250.     //
  1251.     // Retrieve active child handle.
  1252.     //
  1253.     if( (ghActiveChild != ghwndDrv1) &&
  1254.         (ghActiveChild != ghwndDrv2) ){
  1255.         LoadString(ghModule, IDS_DRVNOTACTVE, lpBuffer, sizeof(lpBuffer));
  1256.         ErrorMsg(lpBuffer);
  1257.         return(0);
  1258.     }
  1260.     //
  1261.     // Retrieving the child window's DRVCHILDINFO data
  1262.     //
  1263.     lpCInfo = (LPCINFO)GetWindowLong(ghActiveChild, GWL_USERDATA);
  1265.     //
  1266.     // Enter Drive list critical section
  1267.     //
  1268.     EnterCriticalSection(&gDrvCS);
  1270.     //
  1271.     // if removable drive, check for existing media.
  1272.     //
  1273.     nDriveType = GetDriveType(lpszDriveName);
  1274.     if( nDriveType == DRIVE_REMOVABLE ||
  1275.         nDriveType == DRIVE_CDROM ){
  1276.         dwLoop = (DWORD)IDOK;
  1278.         LoadString(ghModule, IDS_INSRTMEDIA, lpBuffer, sizeof(lpBuffer));
  1280.         while( !CheckRM(lpszDriveName) && (dwLoop == (DWORD)IDOK) ){
  1281.            dwLoop = (DWORD)MessageBox(ghwndMain, lpBuffer, lpszDriveName, MB_OKCANCEL);
  1282.         }
  1284.         if( dwLoop == (DWORD)IDCANCEL ){
  1285.             SendMessage(ghwndDrives, WM_COMMAND, MM_ACTIVEDRV,
  1286.                         (LPARAM)lpCInfo->lpDriveInfo);
  1287.         LeaveCriticalSection(&gDrvCS);
  1288.             return(0);
  1289.         }
  1290.     }
  1292.     //
  1293.     // set lpDriveInfo member to associated drive struct.
  1294.     //
  1295.     lpWalk = glpDrives;
  1296.     for( dwLoop = 0; dwLoop < DriveIndex - MM_DRIVE_NUM;
  1297.          dwLoop++)
  1298.          lpWalk = lpWalk->next;
  1300.     lpCInfo->lpDriveInfo = lpWalk;
  1302.     lstrcpy(lpCInfo->CaptionBarText, lpWalk->DriveName);
  1304.     LeaveCriticalSection(&gDrvCS);
  1306.     //
  1307.     // This will terminate any currently running drive thread.
  1308.     //
  1309.     SendMessage(ghActiveChild, WM_COMMAND, MM_ESCAPE, (LPARAM)0);
  1310.     lpCInfo->fEscape = FALSE;
  1312.     //
  1313.     // enact the drive change.
  1314.     //
  1315.     PostMessage(ghActiveChild, WM_COMMAND, MM_REFRESH, (LPARAM)0);
  1317.     return(1);
  1318. }
  1321. /***************************************************************************
  1322. *
  1323. * FunctionBarProc
  1324. *
  1325. * ToolBar Window procedure for displaying File I/O functions.
  1326. *   ghwndFunction is the global handle assoc. w/ this Dlg procedure.
  1327. *
  1328. * History:
  1329. * 6/8/92
  1330. *   Created.
  1331. *
  1332. ***************************************************************************/
  1333. LRESULT WINAPI FunctionBarProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  1334. {
  1335.     static HBRUSH   hBrush;
  1337.     switch (message){
  1338.       case WM_INITDIALOG:{
  1339.         HWND    hButton;
  1340.         RECT     rc;
  1342.         hButton = GetDlgItem(hDlg, MM_COPY);
  1344.         GetWindowRect(hButton, &rc);
  1346.         SetWindowLong(hDlg, GWL_USERDATA, rc.bottom - rc.top);
  1348.         //
  1349.         // Sets background color of Toolbar non-modal dialog children.
  1350.         //
  1351.         hBrush = CreateSolidBrush(GetSysColor(COLOR_BTNSHADOW));
  1353.         return(FALSE);
  1354.       }
  1356.       case WM_PAINT:{
  1357.         RECT     rc;
  1358.         PAINTSTRUCT ps;
  1360.         //
  1361.         // Paint btnshadow background.
  1362.         //
  1363.         GetClientRect(hDlg, &rc);
  1364.         InvalidateRect(hDlg, &rc, FALSE);
  1366.         BeginPaint(hDlg, &ps);
  1368.         FillRect(ps.hdc, &rc, hBrush);
  1370.         EndPaint(hDlg, &ps);
  1372.         return(TRUE);
  1373.       }
  1375.       //
  1376.       // Passes button messages ( = file I/O function messages )
  1377.       //   to active Drv child.
  1378.       //
  1379.       case WM_COMMAND:{
  1380.         switch(wParam){
  1381.           case MM_COPY:
  1382.           case MM_MOVE:
  1383.           case MM_DELETE:
  1384.           case MM_RENAME:
  1385.           case MM_MKDIR:{
  1386.             SendMessage(ghActiveChild, message, wParam, lParam);
  1387.             return(TRUE);
  1388.           }
  1389.         }
  1390.       }
  1392.       case WM_DESTROY:{
  1393.           DeleteObject(hBrush);
  1394.           break;
  1395.       }
  1396.     }
  1398.     return(FALSE);
  1399. }
  1402. /***************************************************************************
  1403. *
  1404. * RunCommandItem()
  1405. *
  1406. *
  1407. * History:
  1408. * 5/26/93
  1409. *   Created.
  1410. *
  1411. ***************************************************************************/
  1412. BOOL RunCommandItem(LPCINFO lpCInfo)
  1413. {
  1414.     TCHAR       szCmdLine[DIRECTORY_STRING_SIZE * 2] = TEXT("cmd ");
  1415.     LPTSTR      lpszHold;
  1416.     TCHAR       lpBuffer[128];
  1418.     STARTUPINFO si;
  1419.     PROCESS_INFORMATION pi;
  1421.     //
  1422.     // Add the CMD.EXE parameter to keep or kill cmd sessions when done.
  1423.     //
  1424.     if( gfKeepCommandWin )
  1425.         lstrcat( szCmdLine, TEXT("/k ") );
  1426.     else
  1427.         lstrcat( szCmdLine, TEXT("/c ") );
  1429.     //
  1430.     // Add command line edit control text.
  1431.     //
  1432.     lpszHold = TStrChr(szCmdLine, TEXT(''));
  1434.     if( SendMessage( ghwndCommand, WM_GETTEXT,
  1435.                             DIRECTORY_STRING_SIZE,
  1436.                             (LPARAM)lpszHold) == LB_ERR ){
  1437.         LoadString(ghModule, IDS_SRCSTRNGERR, lpBuffer, sizeof(lpBuffer));
  1438.         ErrorMsg(lpBuffer);
  1439.         return(0);
  1440.     }
  1442.     //
  1443.     // Attempt to spawn command shell with entry as parameter.
  1444.     //
  1445.     si.cb = sizeof(STARTUPINFO);
  1446.     si.lpReserved = NULL;
  1447.     si.lpDesktop = NULL;
  1448.     si.lpTitle = NULL;
  1449.     si.dwFlags = 0;
  1450.     si.cbReserved2 = 0;
  1451.     si.lpReserved2 = NULL;
  1453.     SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
  1455.     if( !CreateProcess(NULL, (LPTSTR)szCmdLine, NULL, NULL, FALSE,
  1456.                        CREATE_NEW_CONSOLE | NORMAL_PRIORITY_CLASS,
  1457.                        NULL, lpCInfo->CaptionBarText, &si, &pi) ){
  1458.         LoadString(ghModule, IDS_CANTSPAWN, lpBuffer, sizeof(lpBuffer));
  1459.         ErrorMsg(lpBuffer);
  1460.         return(0);
  1461.     }
  1463.     CloseHandle( pi.hProcess );
  1464.     CloseHandle( pi.hThread );
  1466.     SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_NORMAL);
  1468.     return(1);
  1469. }
  1472. /***************************************************************************
  1473. *
  1474. * UpdateDrivesMenu()
  1475. *
  1476. * Adds current drives from the glpDrives linked list to the TEXT('Drives') menu
  1477. *
  1478. * Input: hDrivesMenu - handle to TEXT('Drives') Menu
  1479. *        hThread    - used to wait for drives thread to terminate
  1480. *
  1481. * History:
  1482. * 5/14/92
  1483. *   Created.
  1484. *
  1485. ***************************************************************************/
  1486. BOOL UpdateDrivesMenu(HMENU hMenu, HANDLE hThread)
  1487. {
  1488.     HMENU   hDrivesMenu;
  1489.     int     NumMenuItems;
  1490.     DWORD   dwLoop;
  1491.     LPDINFO lpWalk;
  1492.     TCHAR   lpBuffer[128];
  1494.     //
  1495.     // Remove list of drive menu items from Drive menu, if any.
  1496.     //
  1497.     hDrivesMenu = GetSubMenu( hMenu, DRIVE_MENU_NUM);
  1498.     if( !hDrivesMenu ){
  1499.         LoadString(ghModule, IDS_MENUERR1, lpBuffer, sizeof(lpBuffer));
  1500.         ErrorMsg(lpBuffer);
  1501.         return(FALSE);
  1502.     }
  1504.     if( (NumMenuItems = GetMenuItemCount(hDrivesMenu)) == -1) {
  1505.         LoadString(ghModule, IDS_MENUERR2, lpBuffer, sizeof(lpBuffer));
  1506.         ErrorMsg(lpBuffer);
  1507.     }
  1509.     //
  1510.     // Delete previous menu items.
  1511.     //
  1512.     for( dwLoop = 0; dwLoop < (DWORD)NumMenuItems; dwLoop++)
  1513.         if( !DeleteMenu( hDrivesMenu, 0,
  1514.                          MF_BYPOSITION) ){
  1515.             LoadString(ghModule, IDS_MENUERR3, lpBuffer, sizeof(lpBuffer));
  1516.             ErrorMsg(lpBuffer);
  1517.             return(FALSE);
  1518.         }
  1520.     //
  1521.     // Wait for Enumdrv Thread to terminate, and
  1522.     //   enter drive list critical section
  1523.     //
  1524.     WaitForSingleObject(hThread, INFINITE);
  1525.     EnterCriticalSection(&gDrvCS);
  1527.     //
  1528.     // Fill drive menu from glpDrives linked list
  1529.     //
  1530.     NumMenuItems = 0;
  1531.     lpWalk = glpDrives;
  1533.     while(lpWalk != NULL){
  1534.         if( !InsertMenu( hDrivesMenu, NumMenuItems, MF_STRING |
  1535.             MF_BYPOSITION | MF_ENABLED, MM_DRIVE_NUM + NumMenuItems,
  1536.             lpWalk->DriveName)) {
  1537.             LoadString(ghModule, IDS_MENUERR4, lpBuffer, sizeof(lpBuffer));            
  1538.             ErrorMsg(lpBuffer);
  1539.         }
  1540.         NumMenuItems++;
  1541.         lpWalk = lpWalk->next;
  1542.     }
  1544.     LeaveCriticalSection(&gDrvCS);
  1546.     return(TRUE);
  1547. }
  1550. /***************************************************************************
  1551. *
  1552. * ErrorMsg()
  1553. *
  1554. *   Displays a Message Box with a given error message.
  1555. *
  1556. * History:
  1557. * 5/28/92
  1558. *   Created.
  1559. *
  1560. ***************************************************************************/
  1561. void ErrorMsg(LPTSTR szMsg)
  1562. {
  1563.     TCHAR szHold[DIRECTORY_STRING_SIZE + 1];
  1565.     lstrcpy( szHold, szMsg );
  1566.     lstrcat( szHold, TEXT("n") );
  1568.     OutputDebugString(szHold);
  1569. }