![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to filer.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / filer|
Return to filer.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / filer |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: Filer.c
3: *
4: * Filer: SDK sample
5: * + Simple File Management program with GUI front end.
6: * Demonstrates Win32 File I/O API and various User algorithms.
7: *
8: * Created: 5/05/92
9: * Author: Colin Stuart
10: *
11: * Copyright (c) 1990 Microsoft Corporation
12: *
13: * Dependencies:
14: *
15: * (#defines)
16: * (#includes)
17: * -Enumdrv.h
18: * -Walk.h
19: * -Drvproc.h
20: * -Filer.h
21: *
22: \**************************************************************************/
23: #include <windows.h>
24: #include <string.h>
25: #include <stdlib.h>
26: #include <stdarg.h>
27: #include "globals.h"
28: #include "enumdrv.h"
29: #include "walk.h"
30: #include "drvproc.h"
31: #include "filer.h"
32:
33: //
34: // Global Handles
35: //
36: HANDLE ghModule; // Process ID handle
37:
38: HWND ghwndMain; // Main window handle
39: HWND ghwndDrives; // Drives Toolbar window handle
40: HWND ghwndFunction; // Function Toolbar window handle
41: HWND ghwndCommand; // Command Line window handle
42: HWND ghwndDrv1,
43: ghwndDrv2;
44: HWND ghActiveChild = NULL; // Handle to active drive child window
45: HWND ghFocusLB; // Handle to last listbox with focus
46:
47:
48: HANDLE ghHeap; // Application heap handle
49: HFONT ghFont;
50: HANDLE ghDrvThread = NULL;
51:
52: HMENU ghMenu; // App Menu variables
53:
54: //
55: // Global Data Items
56: //
57: BOOL gfDrvWndOrient = SIDE_BY_SIDE; // relative Drv child pos.
58:
59: DRVCHILDINFO gDrvChild1Info,
60: gDrvChild2Info;
61:
62: LPDINFO glpDrives = NULL; // Root of Available Drives linked list
63:
64: CRITICAL_SECTION gDrvCS; // Drive list critical section var.
65: CRITICAL_SECTION gHeapCS; // Global heap critical section.
66: CRITICAL_SECTION gSetDirCS; // SetCurrentDirectory critical sect.
67:
68: char gszCommandLine[DIRECTORY_STRING_SIZE * 2];
69: char gszExtensions[NUM_EXTENSION_STRINGS][EXTENSION_LENGTH];
70:
71:
72: /***************************************************************************\
73: * WinMain
74: *
75: *
76: * History:
77: * 04-17-91
78: * Created.
79: \***************************************************************************/
80: int WinMain(
81: HINSTANCE hInstance,
82: HINSTANCE hPrevInstance,
83: LPSTR lpCmdLine,
84: int nCmdShow)
85: {
86: MSG msg;
87: HANDLE hAccel;
88:
89: ghModule = hInstance;
90: if (!InitializeApp()) {
91: ErrorMsg("Filer: InitializeApp failure!");
92: return 0;
93: }
94: ShowWindow(ghwndMain, nCmdShow);
95:
96: if (!(hAccel = LoadAccelerators (ghModule, MAKEINTRESOURCE(ACCEL_ID))))
97: ErrorMsg("Filer: Load Accel failure!");
98:
99:
100: while (GetMessage(&msg, NULL, 0, 0)) {
101: if( !TranslateAccelerator(ghwndMain, hAccel, &msg) ) {
102: TranslateMessage(&msg);
103: DispatchMessage(&msg);
104: }
105: }
106:
107: return 1;
108:
109: UNREFERENCED_PARAMETER(lpCmdLine);
110: UNREFERENCED_PARAMETER(hPrevInstance);
111: }
112:
113:
114: /***************************************************************************\
115: * InitializeApp
116: *
117: * History:
118: * 5/5/92
119: * Created
120: \***************************************************************************/
121:
122: BOOL InitializeApp(void)
123: {
124: WNDCLASS wc;
125:
126: wc.style = NULL;
127: wc.lpfnWndProc = (WNDPROC)MainWndProc;
128: wc.cbClsExtra = 0;
129: wc.cbWndExtra = 0;
130: wc.hInstance = ghModule;
131: wc.hIcon = LoadIcon(ghModule, MAKEINTRESOURCE(UI_FILERICON));
132: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
133: wc.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE);
134: wc.lpszMenuName = "FilerMenu";
135: wc.lpszClassName = "FilerClass";
136:
137: if (!RegisterClass(&wc))
138: return(FALSE);
139:
140: wc.lpfnWndProc = DrvWndProc;
141: wc.hIcon = NULL;
142: wc.lpszMenuName = NULL;
143: wc.lpszClassName = "DrvClass";
144:
145: if (!RegisterClass(&wc))
146: return(FALSE);
147:
148: wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
149: wc.lpfnWndProc = DriveBarProc;
150: wc.hbrBackground = (HBRUSH)(COLOR_BTNSHADOW);
151: wc.lpszClassName = "DriveBarClass";
152:
153: if (!RegisterClass(&wc))
154: return(FALSE);
155:
156: wc.style = CS_HREDRAW | CS_VREDRAW;
157: wc.lpfnWndProc = TextWndProc;
158: wc.hbrBackground = (HBRUSH)(COLOR_INACTIVECAPTION);
159: wc.lpszClassName = "TextClass";
160:
161: if (!RegisterClass(&wc))
162: return(FALSE);
163:
164: ghMenu = LoadMenu(ghModule, "FilerMenu");
165:
166: ghwndMain = CreateWindow("FilerClass",
167: "Filer",
168: WS_OVERLAPPEDWINDOW,
169: CW_USEDEFAULT,
170: CW_USEDEFAULT,
171: MAIN_WIDTH,
172: MAIN_HEIGHT,
173: HWND_DESKTOP,
174: ghMenu,
175: ghModule,
176: NULL);
177:
178: if (ghwndMain == NULL)
179: return(FALSE);
180:
181: return(TRUE);
182: }
183:
184:
185: /***************************************************************************\
186: * MainWndProc
187: *
188: * History:
189: * 05-01-92 Created.
190: \***************************************************************************/
191:
192: LRESULT MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
193: {
194: switch (message) {
195:
196: case WM_CREATE:{
197: LOGFONT lf;
198: HDC hDC;
199: HGDIOBJ hOldFont;
200: TEXTMETRIC tm;
201:
202: DWORD dwThreadID;
203:
204: //
205: // Initialize drive list and Set Directory critical sections.
206: //
207: InitializeCriticalSection(&gDrvCS);
208: InitializeCriticalSection(&gHeapCS);
209: InitializeCriticalSection(&gSetDirCS);
210:
211: ghDrvThread = CreateThread(NULL, 0,
212: (LPTHREAD_START_ROUTINE)EnumDrives,
213: (LPVOID)&glpDrives,
214: 0, &dwThreadID);
215:
216: //
217: // Create the application's heap
218: //
219: ghHeap = HeapCreate( 0, (DWORD)sizeof(DRVCHILDINFO), 0);
220: if( ghHeap == NULL )
221: ErrorMsg("Main Create: Failed in Creating Heap");
222:
223: //
224: // Compute default application font by creating a bold version
225: // of the system default icon font.
226: //
227: SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lf),
228: (PVOID) &lf, FALSE);
229:
230: hDC = GetDC(hwnd);
231:
232: //
233: // this is the height for 8 point size font in pixels.
234: // (1 point = 1/72 in.)
235: //
236: lf.lfHeight = 8 * GetDeviceCaps(hDC, LOGPIXELSY) / 72;
237: lf.lfWeight = BOLD_FONT;
238:
239: ghFont = CreateFontIndirect(&lf);
240: hOldFont = SelectObject(hDC, ghFont);
241: GetTextMetrics(hDC, &tm);
242: if(hOldFont)
243: SelectObject(hDC, hOldFont);
244: ReleaseDC(hwnd, hDC);
245:
246: //
247: // Create Drive windows
248: //
249: gDrvChild1Info.hParent = hwnd;
250: gDrvChild2Info.hParent = hwnd;
251:
252: ghwndDrv1 = CreateWindow("DrvClass", NULL,
253: WS_CHILD |
254: WS_CLIPSIBLINGS | WS_VISIBLE,
255: 0, 0, 0, 0,
256: hwnd, (HMENU) 1, ghModule,
257: (LPVOID)&gDrvChild1Info);
258:
259: ghActiveChild = ghwndDrv1;
260:
261: ghwndDrv2 = CreateWindow("DrvClass", NULL,
262: WS_CHILD |
263: WS_CLIPSIBLINGS | WS_VISIBLE,
264: 0, 0, 0, 0,
265: hwnd, (HMENU) 2, ghModule,
266: (LPVOID)&gDrvChild2Info);
267:
268: //
269: // Create DriveBar, FunctionBar and Command windows
270: //
271: ghwndDrives = CreateWindow("DriveBarClass", NULL,
272: WS_CHILD | WS_VISIBLE | WS_BORDER,
273: 0, 0, 0, 0,
274: hwnd, (HMENU) 3, ghModule,
275: (LPVOID)NULL);
276:
277: ghwndFunction = CreateDialog(ghModule,
278: "FunctionBar",
279: hwnd,
280: (DLGPROC)FunctionBarProc);
281:
282: ghwndCommand = CreateWindow("EDIT", NULL,
283: ES_AUTOHSCROLL | ES_LEFT | WS_BORDER |
284: ES_NOHIDESEL | WS_CHILD | WS_VISIBLE,
285: 0, 0, 0, 0,
286: hwnd,
287: (HMENU) 3,
288: ghModule,
289: NULL);
290:
291: //
292: // Compute height of command window from font; store in window info.
293: // Set command window to default font.
294: //
295: SetWindowLong( ghwndCommand, GWL_USERDATA,
296: tm.tmHeight + GetSystemMetrics(SM_CYBORDER) + 6);
297: SendMessage(ghwndCommand, WM_SETFONT, (WPARAM)ghFont, (LPARAM)FALSE);
298:
299: //
300: // Load String table entries
301: //
302: LoadString( ghModule, STR_EXE, &gszExtensions[0][0], EXTENSION_LENGTH);
303: LoadString( ghModule, STR_COM, &gszExtensions[1][0], EXTENSION_LENGTH);
304: LoadString( ghModule, STR_CMD, &gszExtensions[2][0], EXTENSION_LENGTH);
305: LoadString( ghModule, STR_BAT, &gszExtensions[3][0], EXTENSION_LENGTH);
306:
307: UpdateDrivesMenu(ghMenu, ghDrvThread);
308:
309: return(1);
310: }
311:
312: case WM_COMMAND:{
313:
314: //
315: // The menu Identifiers for the drives are (potentially)
316: // MM_DRIVE_NUM + 0 thru MM_DRIVE_NUM + 25. They all go to the
317: // same case, so we will put the Menu ID in lParam, and
318: // MM_DRIVE_NUM in LOWORD(wParam).
319: //
320: if( (LOWORD(wParam) - MM_DRIVE_NUM) <= 25 &&
321: (LOWORD(wParam) - MM_DRIVE_NUM) >= 0 ){
322: lParam = LOWORD(wParam);
323: wParam = MM_DRIVE_NUM;
324: }
325:
326: switch (LOWORD(wParam)) {
327: //
328: // If a drive is selected from the Drives menu, or clicked
329: // on the drives toolbar, the currently active child will
330: // switch to this drive. Message 'unconverted' (see top of
331: // WM_COMMAND case), and sent to DriveBarProc
332: //
333: case MM_DRIVE_NUM:{
334:
335: SendMessage(ghwndDrives, WM_COMMAND,
336: (WPARAM)lParam, (LPARAM)NULL);
337: return(1);
338: }
339:
340: //
341: // Passes these WM_COMMAND messages to the appropriate active child
342: // window proc for processing
343: //
344: case MM_TAB:
345: case MM_ESCAPE:
346: case MM_OPEN:
347: case MM_COPY:
348: case MM_DELETE:
349: case MM_MOVE:
350: case MM_RENAME:
351: case MM_MKDIR:{
352:
353: SendMessage(ghActiveChild, WM_COMMAND, wParam, lParam);
354: return(1);
355: }
356:
357: //
358: // Creates the drive enumeration thread to re-enumerate the
359: // available drives in the main menu. Also sends a refresh
360: // to the active drive child, and repaints the window.
361: //
362: case MM_REFRESH: {
363: DWORD dwThreadID;
364: DWORD dwExitCode = 0;
365:
366: //
367: // Initialize/Refresh Drives linked list
368: //
369: GetExitCodeThread( ghDrvThread, &dwExitCode);
370:
371: if( dwExitCode != STILL_ACTIVE ){
372:
373: ghDrvThread = CreateThread(NULL, 0,
374: (LPTHREAD_START_ROUTINE)EnumDrives,
375: (LPVOID)&glpDrives,
376: 0, &dwThreadID);
377:
378: //
379: // Refresh active child, drive toolbar, and drives menu
380: //
381: SendMessage(ghActiveChild, WM_COMMAND, wParam, lParam);
382: SendMessage(ghwndDrives, WM_COMMAND, wParam, lParam);
383: UpdateDrivesMenu(ghMenu, ghDrvThread);
384:
385: //
386: // Mark all for repaint
387: //
388: InvalidateRect(hwnd,NULL,TRUE);
389:
390: }
391: else
392: MessageBeep(MB_ICONASTERISK);
393: return(1);
394: }
395:
396: //
397: // Swaps the directory and file list boxes of the active drv child.
398: //
399: case MM_SWAP:{
400: HWND hHold;
401: LPCINFO lpCInfo;
402: RECT rect;
403:
404: lpCInfo = (LPCINFO)GetWindowLong(ghActiveChild, GWL_USERDATA);
405: hHold = lpCInfo->hwndLL;
406: lpCInfo->hwndLL = lpCInfo->hwndLR;
407: lpCInfo->hwndLR = hHold;
408:
409: //
410: // Send size message with current size to active child,
411: // in order to redraw the listboxes.
412: //
413: if( !GetClientRect( ghActiveChild, &rect ) )
414: return(0);
415:
416: SendMessage( ghActiveChild, WM_SIZE, SIZENORMAL,
417: MAKELONG( rect.right - rect.left,
418: rect.bottom - rect.top) );
419: return(1);
420: }
421:
422: //
423: // Toggles the relative Drive Child orientaion between
424: // Over/under and side/side. gfDrvWndOrient is a flag checked
425: // by WM_SIZE to size Drv children
426: //
427: case MM_ORIENT:{
428: RECT rect;
429:
430: if( gfDrvWndOrient == OVER_UNDER )
431: gfDrvWndOrient = SIDE_BY_SIDE;
432: else
433: gfDrvWndOrient = OVER_UNDER;
434:
435: //
436: // Send size message with current size to self (main window),
437: // in order to redraw the Drv children.
438: //
439: if( !GetClientRect( hwnd, &rect ) )
440: return(0);
441:
442: SendMessage( hwnd, WM_SIZE, SIZENORMAL,
443: MAKELONG( rect.right - rect.left,
444: rect.bottom - rect.top) );
445:
446: InvalidateRect(ghwndDrv1,NULL,TRUE);
447: InvalidateRect(ghwndDrv2,NULL,TRUE);
448:
449: return(1);
450: }
451:
452: //
453: // Toggles the active drive child. Sent from menu.
454: // This behaves the same as a WM_MOUSEACTIVATE in one of the
455: // Drive children. The PostMessage is so the current Active
456: // child will not process the MM_TOGGLE message until after it
457: // is no longer active.
458: //
459: case MM_ACTIVEDRV:{
460:
461: PostMessage(ghActiveChild, WM_COMMAND, (WPARAM)MM_TOGGLE,
462: (LPARAM)NULL);
463:
464: if( ghActiveChild == ghwndDrv1 )
465: ghActiveChild = ghwndDrv2;
466: else
467: ghActiveChild = ghwndDrv1;
468:
469: SendMessage(ghActiveChild, WM_COMMAND, (WPARAM)MM_TOGGLE,
470: (LPARAM)NULL);
471:
472: return(1);
473: }
474:
475: //
476: // Launches the About DialogBox.
477: //
478: case MM_ABOUT:{
479: if (DialogBox(ghModule, "AboutBox", ghwndMain, (DLGPROC)AboutProc) == -1)
480: ErrorMsg("Main: About Dialog Creation Error!");
481: return(1);
482: }
483:
484: default:
485: return( DefWindowProc(hwnd, message, wParam, lParam) );
486: }
487: return(1);
488: }
489: //
490: // Whenever the window is resized, its children have to be
491: // resized accordingly. The GetWindowLong values are the height
492: // of the windows queried by this function, and are set in the
493: // WM_CREATE cases of their respective WNDPROCs.
494: //
495: case WM_SIZE:{
496: int DrvWndHeight;
497:
498: //
499: // Always put the command window at the bottom of the frame window
500: //
501: MoveWindow(ghwndCommand,
502: 0,
503: HIWORD(lParam) - GetWindowLong(ghwndCommand, GWL_USERDATA),
504: LOWORD(lParam),
505: GetWindowLong(ghwndCommand, GWL_USERDATA),
506: TRUE);
507: //
508: // Always put the drives toolbar at the top of the frame window
509: //
510: MoveWindow(ghwndDrives,
511: 0,
512: 0,
513: LOWORD(lParam),
514: GetWindowLong(ghwndDrives, GWL_USERDATA),
515: TRUE);
516:
517: //
518: // Always put the Function window just below the drives toolbar.
519: //
520: MoveWindow(ghwndFunction,
521: 0,
522: GetWindowLong(ghwndDrives, GWL_USERDATA),
523: LOWORD(lParam),
524: GetWindowLong(ghwndFunction, GWL_USERDATA),
525: TRUE);
526:
527: //
528: // Always size the Drive Children between the Drives and Command
529: // windows. The width is set so that borders overlap.
530: //
531:
532: if( gfDrvWndOrient == OVER_UNDER ){
533:
534: DrvWndHeight = ( HIWORD(lParam) -
535: GetWindowLong(ghwndDrives, GWL_USERDATA) -
536: GetWindowLong(ghwndFunction, GWL_USERDATA) -
537: GetWindowLong(ghwndCommand, GWL_USERDATA) ) / 2;
538:
539: MoveWindow(ghwndDrv1,
540: -1,
541: GetWindowLong(ghwndDrives, GWL_USERDATA)+
542: GetWindowLong(ghwndFunction, GWL_USERDATA),
543: LOWORD(lParam) + 2,
544: DrvWndHeight,
545: TRUE);
546:
547: MoveWindow(ghwndDrv2,
548: -1,
549: GetWindowLong(ghwndDrives, GWL_USERDATA)+
550: GetWindowLong(ghwndFunction, GWL_USERDATA) + DrvWndHeight,
551: LOWORD(lParam) + 2,
552: DrvWndHeight,
553: TRUE);
554: }
555: else{
556:
557: DrvWndHeight = HIWORD(lParam) -
558: GetWindowLong(ghwndDrives, GWL_USERDATA) -
559: GetWindowLong(ghwndFunction, GWL_USERDATA) -
560: GetWindowLong(ghwndCommand, GWL_USERDATA);
561:
562: MoveWindow(ghwndDrv1,
563: -1,
564: GetWindowLong(ghwndDrives, GWL_USERDATA)+
565: GetWindowLong(ghwndFunction, GWL_USERDATA),
566: LOWORD(lParam)/2 + 1,
567: DrvWndHeight,
568: TRUE);
569:
570: MoveWindow(ghwndDrv2,
571: LOWORD(lParam)/2,
572: GetWindowLong(ghwndDrives, GWL_USERDATA)+
573: GetWindowLong(ghwndFunction, GWL_USERDATA),
574: LOWORD(lParam)/2 + 1,
575: DrvWndHeight,
576: TRUE);
577: }
578:
579: return(1);
580: }
581:
582: case WM_DESTROY: {
583: EnterCriticalSection(&gHeapCS);
584: HeapDestroy(ghHeap);
585: LeaveCriticalSection(&gHeapCS);
586:
587: DeleteObject(ghFont);
588:
589: DeleteCriticalSection(&gDrvCS);
590: DeleteCriticalSection(&gSetDirCS);
591:
592: PostQuitMessage(0);
593: return(1);
594: }
595:
596: default:
597: return DefWindowProc(hwnd, message, wParam, lParam);
598: }
599: }
600:
601: /***************************************************************************\
602: * AboutProc
603: *
604: * About dialog proc.
605: *
606: * History:
607: * 05-13-92 Created.
608: \***************************************************************************/
609:
610: LRESULT AboutProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
611: {
612: switch (message) {
613: case WM_INITDIALOG:{
614: return TRUE;
615: }
616:
617: case WM_COMMAND:{
618: if (wParam == IDOK)
619: EndDialog(hDlg, wParam);
620: break;
621: }
622: }
623:
624: return FALSE;
625:
626: UNREFERENCED_PARAMETER(lParam);
627: UNREFERENCED_PARAMETER(hDlg);
628: }
629:
630:
631: /***************************************************************************\
632: *
633: * DriveBarProc()
634: *
635: * Drive Toolbar procedure for displaying available drive Icons.
636: * A bitmap button is displayed corresponding to the drive type of the
637: * given drive, with the drive letter alongside.
638: * ghwndDrives is the global handle assoc. w/ this window procedure.
639: *
640: *
641: * History:
642: * 6/9/92
643: * Created.
644: *
645: \***************************************************************************/
646:
647: LRESULT DriveBarProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
648: {
649: static HBITMAP hDrvBmp[NUM_BITMAPS];
650: static HBRUSH hBrush; // background brush
651: static int nDrvEntryWidth; // width of button/letter entry
652: static int yVal; // y value in toolbar for top left of bmp
653: static LPBINFO lpDrvButtonRoot;
654: static int nActiveDrvIndex;
655:
656: switch (message)
657: {
658: case WM_CREATE:{
659: HDC hDC;
660: HGDIOBJ hOldFont;
661: TEXTMETRIC tm;
662: LONG lHeight;
663:
664:
665: lpDrvButtonRoot = NULL;
666:
667: //
668: // Load drive button bitmaps.
669: //
670: for(yVal = 0; yVal < NUM_BITMAPS; yVal++)
671: hDrvBmp[yVal] = LoadBitmap( ghModule,
672: MAKEINTRESOURCE(UB_BMP_MARKER + yVal) );
673:
674: //
675: // Sets background color of Toolbar non-modal dialog children.
676: //
677: hBrush = CreateSolidBrush(GetSysColor(COLOR_BTNSHADOW));
678:
679: hDC = GetDC(hwnd);
680:
681: hOldFont = SelectObject(hDC, ghFont);
682: GetTextMetrics(hDC, &tm);
683:
684: //
685: // base the height of the window on size of text
686: //
687: lHeight = tm.tmHeight + GetSystemMetrics(SM_CYBORDER) + 6;
688:
689: //
690: // saved the window height, drive button entry width
691: // and button y starting value for later reference
692: //
693: SetWindowLong(hwnd, GWL_USERDATA, lHeight);
694:
695: //
696: // Width of one button entry = spacing, button, sm. space,
697: // drive letter, spacing.
698: //
699: nDrvEntryWidth = DRIVE_BITMAP_SPACING + DRIVE_BITMAP_WIDTH +
700: DRIVE_LETTER_SPACING + tm.tmAveCharWidth +
701: DRIVE_BITMAP_SPACING;
702:
703: //
704: // Center bitmaps (by height) in drive toolbar.
705: //
706: yVal = (lHeight - DRIVE_BITMAP_HEIGHT)/2;
707:
708: SelectObject(hDC, hOldFont);
709: ReleaseDC(hwnd, hDC);
710:
711: SendMessage(hwnd, WM_COMMAND, (WPARAM)MM_REFRESH, (LPARAM)NULL);
712:
713: break;
714: }
715:
716: case WM_COMMAND:{
717: //
718: // The button Identifiers for the drives are (potentially)
719: // MM_DRIVE_NUM + 0 thru MM_DRIVE_NUM + 25. They all go to the
720: // same case, so we will put the Menu ID in lParam, and
721: // MM_DRIVE_NUM in LOWORD(wParam).
722: //
723: if( (LOWORD(wParam) - MM_DRIVE_NUM) <= 25 &&
724: (LOWORD(wParam) - MM_DRIVE_NUM) >= 0 ){
725: lParam = LOWORD(wParam);
726: wParam = MM_DRIVE_NUM;
727: }
728:
729: switch( LOWORD(wParam) ){
730: case MM_REFRESH:{
731:
732: LPDINFO lpWalk;
733: LPBINFO lpBWalk, lpBHold;
734: LPCINFO lpCInfo;
735: int xVal = 0;
736: int nCount = MM_DRIVE_NUM;
737:
738: lpCInfo = (LPCINFO)GetWindowLong(ghActiveChild, GWL_USERDATA);
739:
740: //
741: // Traverse DRVINFO linked list, creating drive buttons and
742: // allocating corresp. structures as necessary.
743: //
744: EnterCriticalSection(&gDrvCS);
745: lpWalk = glpDrives;
746: lpBWalk = lpDrvButtonRoot;
747:
748: while( lpWalk != NULL ){
749: if( lpBWalk == NULL ){
750:
751: EnterCriticalSection(&gHeapCS);
752: lpBWalk = (LPBINFO)HeapAlloc(ghHeap, sizeof(BINFO));
753: LeaveCriticalSection(&gHeapCS);
754:
755: lpBWalk->lpDrive = lpWalk;
756: lpBWalk->fButtonDown = FALSE;
757: if( lpDrvButtonRoot == NULL)
758: lpDrvButtonRoot = lpBHold = lpBWalk;
759: else{
760: lpBHold->next = lpBWalk;
761: lpBWalk->next = NULL;
762: }
763: }
764: if( lpCInfo->lpDriveInfo == lpWalk ){
765: nActiveDrvIndex = nCount;
766: lpBWalk->fButtonDown = TRUE;
767: }
768: else
769: lpBWalk->fButtonDown = FALSE;
770:
771: lpBWalk->lpDrive = lpWalk;
772:
773: lpBWalk->hButton = (HANDLE)CreateWindow("BUTTON",
774: lpWalk->DriveName,
775: WS_CHILD | WS_VISIBLE |
776: BS_OWNERDRAW,
777: xVal + DRIVE_BITMAP_SPACING,
778: yVal,
779: DRIVE_BITMAP_WIDTH,
780: DRIVE_BITMAP_HEIGHT,
781: hwnd,
782: (HMENU)nCount,
783: ghModule,
784: NULL);
785:
786: nCount++;
787: xVal += nDrvEntryWidth;
788: lpBHold = lpBWalk;
789: lpBWalk = lpBWalk->next;
790:
791: lpWalk = lpWalk->next;
792: }
793:
794: LeaveCriticalSection(&gDrvCS);
795:
796: //
797: // Free any remaining button windows.
798: //
799: while( lpBWalk != NULL ){
800: lpBHold = lpBWalk;
801: lpBWalk = lpBWalk->next;
802: if( !DestroyWindow(lpBHold->hButton) )
803: ErrorMsg("DriveBarProc: Drive Button Destroy Error");
804:
805: EnterCriticalSection(&gHeapCS);
806: HeapFree(ghHeap, (LPSTR)lpBHold);
807: LeaveCriticalSection(&gHeapCS);
808: }
809:
810: SendMessage(hwnd, WM_PAINT, (WPARAM)NULL, (LPARAM)NULL);
811: break;
812: }
813:
814:
815: //
816: // switches the drive button to the newly active drv child's
817: // current drive. Called by WM_MOUSEACTIVATE in DrvWndProc,
818: // as well as ChangeDrive.
819: // lParam contains the drive linked list pointer of the active
820: // drv child's LPCINFO struct.
821: //
822: case MM_ACTIVEDRV:{
823: LPBINFO lpBWalk = lpDrvButtonRoot;
824: int nCount = 0;
825:
826: //
827: // 'unpush' old active button
828: //
829: for( nCount = MM_DRIVE_NUM; nCount < nActiveDrvIndex; nCount++)
830: lpBWalk = lpBWalk->next;
831: lpBWalk->fButtonDown = FALSE;
832:
833: InvalidateRect(lpBWalk->hButton, NULL, FALSE);
834:
835: //
836: // change active drive to new before redrawing old.
837: // 'push' new active button
838: //
839: lpBWalk = lpDrvButtonRoot;
840: nCount = MM_DRIVE_NUM;
841: while( lpBWalk->lpDrive != (LPDINFO)lParam){
842: lpBWalk = lpBWalk->next;
843: nCount++;
844: }
845:
846: nActiveDrvIndex = nCount;
847:
848: lpBWalk->fButtonDown = TRUE;
849:
850: InvalidateRect(lpBWalk->hButton, NULL, FALSE);
851:
852: break;
853: }
854:
855: //
856: // Changes drive of active child. ButtonID in lParam.
857: //
858: case MM_DRIVE_NUM:{
859:
860: LPBINFO lpBWalk = lpDrvButtonRoot;
861: int nCount = 0;
862: CHAR szDrvBuff[DIRECTORY_STRING_SIZE];
863:
864: //
865: // if drive chosen is already current drive, leave.
866: //
867: if( nActiveDrvIndex == (int)lParam )
868: break;
869:
870: //
871: // 'unpush' old active button
872: //
873: for( nCount = MM_DRIVE_NUM; nCount < nActiveDrvIndex; nCount++)
874: lpBWalk = lpBWalk->next;
875: lpBWalk->fButtonDown = FALSE;
876:
877: //
878: // change active drive to new before redrawing old.
879: //
880: nActiveDrvIndex = (int)lParam;
881:
882: InvalidateRect(lpBWalk->hButton, NULL, FALSE);
883:
884: //
885: // 'push' new active button
886: //
887: lpBWalk = lpDrvButtonRoot;
888:
889: for( nCount = MM_DRIVE_NUM; nCount < nActiveDrvIndex; nCount++)
890: lpBWalk = lpBWalk->next;
891: lpBWalk->fButtonDown = TRUE;
892:
893: InvalidateRect(lpBWalk->hButton, NULL, FALSE);
894:
895: GetWindowText(lpBWalk->hButton, szDrvBuff,
896: DIRECTORY_STRING_SIZE);
897:
898: if( !ChangeDrive(szDrvBuff, (DWORD)nActiveDrvIndex) ){
899: ErrorMsg("Error changing Drives.");
900: return(0);
901: }
902:
903: break;
904: }
905: }
906: return(1);
907: }
908:
909: //
910: // Sent by all created buttons for initialization purposes.
911: //
912: case WM_MEASUREITEM:{
913: LPMEASUREITEMSTRUCT lpMIS;
914:
915: lpMIS = (LPMEASUREITEMSTRUCT)lParam;
916:
917: lpMIS->CtlType = ODT_BUTTON;
918: lpMIS->CtlID = (UINT)wParam;
919: lpMIS->itemWidth = DRIVE_BITMAP_WIDTH;
920: lpMIS->itemHeight = DRIVE_BITMAP_HEIGHT;
921:
922: return(1);
923: }
924:
925: //
926: // Sent by owner draw drive buttons when needing redrawing.
927: //
928: case WM_DRAWITEM:{
929: LPBINFO lpBWalk = lpDrvButtonRoot;
930: int nCount;
931: int nBmpIndex;
932: HDC hDC;
933: HDC hCompatDC;
934: HGDIOBJ hOldBitmap;
935: CHAR szDrvBuff[DIRECTORY_STRING_SIZE];
936: LPDRAWITEMSTRUCT lpDIS;
937:
938: lpDIS = (LPDRAWITEMSTRUCT)lParam;
939:
940: for( nCount = MM_DRIVE_NUM; nCount < (int)wParam; nCount++)
941: lpBWalk = lpBWalk->next;
942:
943: //
944: // If not the current selected button, handle button stuff.
945: //
946: if( (int)wParam != nActiveDrvIndex ){
947: //
948: // mousebutton is down...
949: //
950: if( lpDIS->itemAction & ODA_SELECT ){
951: //
952: // left button region, 'unpush' button
953: //
954: if( lpDIS->itemState == (UINT)ODS_FOCUS )
955: lpBWalk->fButtonDown = FALSE;
956: //
957: // clicked on a button, draw 'pushed' button
958: //
959: if( lpDIS->itemState == (UINT)(ODS_SELECTED | ODS_FOCUS))
960: lpBWalk->fButtonDown = TRUE;
961: }
962: }
963:
964: //
965: // draw current state of button.
966: //
967: GetWindowText(lpDIS->hwndItem, szDrvBuff,
968: DIRECTORY_STRING_SIZE);
969:
970: szDrvBuff[1] = '\0';
971:
972: hCompatDC = CreateCompatibleDC(lpDIS->hDC);
973: hOldBitmap = CreateCompatibleBitmap(hCompatDC,
974: DRIVE_BITMAP_WIDTH,
975: DRIVE_BITMAP_HEIGHT);
976:
977: nBmpIndex = GetDriveBitmap(lpBWalk);
978:
979: SelectObject( hCompatDC, hDrvBmp[nBmpIndex] );
980:
981: if( !hOldBitmap )
982: OutputDebugString("WM_DRAWITEM: SelectObject error\n");
983:
984: if( !BitBlt(lpDIS->hDC, lpDIS->rcItem.left, lpDIS->rcItem.top,
985: DRIVE_BITMAP_WIDTH,
986: DRIVE_BITMAP_HEIGHT,
987: hCompatDC, 0, 0, SRCCOPY) )
988: OutputDebugString("WM_DRAWITEM: BitBlt error\n");
989:
990:
991: SelectObject( hCompatDC, hOldBitmap);
992: DeleteDC(hCompatDC);
993:
994: hDC = GetDC(hwnd);
995: SetBkMode(hDC, TRANSPARENT);
996: SetTextColor(hDC, GetSysColor(COLOR_BTNTEXT) );
997: SetBkColor(hDC, GetSysColor(COLOR_BTNSHADOW) );
998:
999: TextOut(hDC,
1000: ((int)(wParam - MM_DRIVE_NUM) * nDrvEntryWidth) +
1001: DRIVE_BITMAP_SPACING + DRIVE_BITMAP_WIDTH +
1002: DRIVE_LETTER_SPACING,
1003: (GetSystemMetrics(SM_CYBORDER) + 6)/2,
1004: szDrvBuff, 1);
1005:
1006: SetBkMode(hDC, OPAQUE);
1007:
1008: ReleaseDC(hwnd, hDC);
1009:
1010: break;
1011: }
1012:
1013:
1014: case WM_PAINT:{
1015: HDC hCompatDC;
1016: RECT rc;
1017: PAINTSTRUCT ps;
1018:
1019: //
1020: // Paint btnshadow background.
1021: //
1022: GetClientRect(hwnd, &rc);
1023:
1024: BeginPaint(hwnd, &ps);
1025:
1026: hCompatDC = CreateCompatibleDC(ps.hdc);
1027: FillRect(ps.hdc, &rc, hBrush);
1028:
1029: EndPaint(hwnd, &ps);
1030:
1031: return(TRUE);
1032: }
1033:
1034: case WM_DESTROY:{
1035: DeleteObject(hBrush);
1036:
1037: for(yVal = 0; yVal < NUM_BITMAPS; yVal++)
1038: DeleteObject(hDrvBmp[yVal]);
1039:
1040: break;
1041: }
1042: }
1043: return DefWindowProc(hwnd, message, wParam, lParam);
1044: }
1045:
1046:
1047: /***************************************************************************\
1048: *
1049: * GetDriveBitmap()
1050: *
1051: * Determines the appropriate index into the drive button bitmap array
1052: * (hDrvBmp[]), given a pointer to a drive info structure (LPDINFO)
1053: *
1054: * lpWalk - pointer to LPDINFO structure.
1055: * lpCurrentDrv - pointer to current drive of active child.
1056: *
1057: *
1058: * History:
1059: * 6/16/92
1060: * Created.
1061: *
1062: \***************************************************************************/
1063: int GetDriveBitmap(LPBINFO lpBWalk)
1064: {
1065: int nBmpIndex;
1066:
1067: EnterCriticalSection(&gDrvCS);
1068:
1069: switch( lpBWalk->lpDrive->DriveType ){
1070: case DRIVE_REMOVABLE:{
1071: nBmpIndex = UB_FLOPPY1 - UB_BMP_MARKER;
1072: break;
1073: }
1074:
1075: case DRIVE_REMOTE:{
1076: nBmpIndex = UB_REMOTE1 - UB_BMP_MARKER;
1077: break;
1078: }
1079:
1080: case DRIVE_CDROM:{
1081: nBmpIndex = UB_CD1 - UB_BMP_MARKER;
1082: break;
1083: }
1084:
1085: case DRIVE_FIXED:
1086: default:{
1087: nBmpIndex = UB_FIXED1 - UB_BMP_MARKER;
1088: break;
1089: }
1090: }
1091:
1092: LeaveCriticalSection(&gDrvCS);
1093:
1094: if( lpBWalk->fButtonDown == TRUE )
1095: nBmpIndex++;
1096:
1097: return(nBmpIndex);
1098: }
1099:
1100:
1101: /***************************************************************************\
1102: *
1103: * ChangeDrive()
1104: *
1105: * Changes the current drive of the active child. Called by the MM_DRIVE_NUM
1106: * cases in MainWndProc and DriveBarProc. This is caused by choosing a
1107: * Drive menu item or selecting a drive button from the drive toolbar.
1108: *
1109: * lpszDriveName - points to a buffer containing the name of the drive
1110: * DriveID - points to the ID of the Menu item or button, which
1111: * corresponds to the index into the drives linked list
1112: * of the new drive.
1113: *
1114: * History:
1115: * 6/20/92
1116: * Created.
1117: *
1118: \***************************************************************************/
1119: BOOL ChangeDrive(LPSTR lpszDriveName, DWORD DriveIndex)
1120: {
1121: LPCINFO lpCInfo;
1122: LPDINFO lpWalk;
1123: DWORD dwLoop;
1124:
1125: //
1126: // Retrieve active child handle.
1127: //
1128: if( (ghActiveChild != ghwndDrv1) &&
1129: (ghActiveChild != ghwndDrv2) ){
1130: ErrorMsg("A Drive Window Must be Active.");
1131: return(0);
1132: }
1133:
1134: //
1135: // Retrieving the child window's DRVCHILDINFO data
1136: //
1137: lpCInfo = (LPCINFO)GetWindowLong(ghActiveChild, GWL_USERDATA);
1138:
1139: //
1140: // Enter Drive list critical section
1141: //
1142: EnterCriticalSection(&gDrvCS);
1143:
1144: //
1145: // if removable drive, check for existing media.
1146: //
1147: if( GetDriveType(lpszDriveName) == DRIVE_REMOVABLE ){
1148: dwLoop = (DWORD)IDOK;
1149:
1150: while( !CheckRM(lpszDriveName) && (dwLoop == (DWORD)IDOK) ){
1151:
1152: dwLoop = (DWORD)MessageBox(ghwndMain,
1153: "Filer: Insert some media in drive",
1154: lpszDriveName, MB_OKCANCEL);
1155: }
1156:
1157: if( dwLoop == (DWORD)IDCANCEL ){
1158: SendMessage(ghwndDrives, WM_COMMAND, MM_ACTIVEDRV,
1159: (LPARAM)lpCInfo->lpDriveInfo);
1160: return(0);
1161: }
1162: }
1163:
1164: //
1165: // Kill any current dir refresh thread.
1166: //
1167: if( WaitForSingleObject(lpCInfo->hDirThread, 0) == WAIT_TIMEOUT )
1168: lpCInfo->fAlive = FALSE;
1169:
1170: //
1171: // set lpDriveInfo member to associated drive struct.
1172: //
1173: lpWalk = glpDrives;
1174: for( dwLoop = 0; dwLoop < DriveIndex - MM_DRIVE_NUM;
1175: dwLoop++)
1176: lpWalk = lpWalk->next;
1177:
1178: lpCInfo->lpDriveInfo = lpWalk;
1179:
1180: strcpy(lpCInfo->CaptionBarText, lpWalk->DriveName);
1181:
1182: LeaveCriticalSection(&gDrvCS);
1183:
1184: SendMessage(ghActiveChild, WM_COMMAND, MM_REFRESH, (LPARAM)NULL);
1185:
1186: return(1);
1187: }
1188:
1189:
1190: /***************************************************************************\
1191: *
1192: * FunctionBarProc
1193: *
1194: * ToolBar Window procedure for displaying File I/O functions.
1195: * ghwndFunction is the global handle assoc. w/ this Dlg procedure.
1196: *
1197: * History:
1198: * 6/8/92
1199: * Created.
1200: *
1201: \***************************************************************************/
1202:
1203: LRESULT FunctionBarProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
1204: {
1205: static HBRUSH hBrush;
1206:
1207: switch (message){
1208: case WM_INITDIALOG:{
1209: HWND hButton;
1210: RECT rc;
1211:
1212: hButton = GetDlgItem(hDlg, MM_COPY);
1213:
1214: GetWindowRect(hButton, &rc);
1215:
1216: SetWindowLong(hDlg, GWL_USERDATA, rc.bottom - rc.top);
1217:
1218: //
1219: // Sets background color of Toolbar non-modal dialog children.
1220: //
1221: hBrush = CreateSolidBrush(GetSysColor(COLOR_BTNSHADOW));
1222:
1223: return(FALSE);
1224: }
1225:
1226: case WM_PAINT:{
1227: RECT rc;
1228: PAINTSTRUCT ps;
1229:
1230: //
1231: // Paint btnshadow background.
1232: //
1233: GetClientRect(hDlg, &rc);
1234: InvalidateRect(hDlg, &rc, FALSE);
1235:
1236: BeginPaint(hDlg, &ps);
1237:
1238: FillRect(ps.hdc, &rc, hBrush);
1239:
1240: EndPaint(hDlg, &ps);
1241:
1242: return(TRUE);
1243: }
1244:
1245: //
1246: // Passes button messages ( = file I/O function messages )
1247: // to active Drv child.
1248: //
1249: case WM_COMMAND:{
1250: switch(wParam){
1251: case MM_COPY:
1252: case MM_MOVE:
1253: case MM_DELETE:
1254: case MM_RENAME:
1255: case MM_MKDIR:{
1256: SendMessage(ghActiveChild, message, wParam, lParam);
1257: return(TRUE);
1258: }
1259: }
1260: }
1261:
1262: case WM_DESTROY:{
1263: DeleteObject(hBrush);
1264: break;
1265: }
1266: }
1267:
1268: return(FALSE);
1269: }
1270:
1271:
1272: /***************************************************************************\
1273: *
1274: * UpdateDrivesMenu()
1275: *
1276: * Adds current drives from the glpDrives linked list to the 'Drives' menu
1277: *
1278: * Input: hDrivesMenu - handle to 'Drives' Menu
1279: * hThread - used to wait for drives thread to terminate
1280: *
1281: * History:
1282: * 5/14/92
1283: * Created.
1284: *
1285: \***************************************************************************/
1286:
1287: BOOL UpdateDrivesMenu(HMENU hMenu, HANDLE hThread)
1288: {
1289: HMENU hDrivesMenu;
1290: int NumMenuItems;
1291: DWORD dwLoop;
1292: LPDINFO lpWalk;
1293:
1294: //
1295: // Remove list of drive menu items from Drive menu, if any.
1296: //
1297: hDrivesMenu = GetSubMenu( hMenu, DRIVE_MENU_NUM);
1298: if( !hDrivesMenu ){
1299: ErrorMsg("UpdateDrivesMenu: GetSubMenu error.");
1300: return(FALSE);
1301: }
1302:
1303: if( (NumMenuItems = GetMenuItemCount(hDrivesMenu)) == -1)
1304: ErrorMsg("Main Refresh: Menu Item Count Error.");
1305:
1306: //
1307: // Delete previous menu items.
1308: //
1309: for( dwLoop = 0; dwLoop < (DWORD)NumMenuItems; dwLoop++)
1310: if( !DeleteMenu( hDrivesMenu, 0,
1311: MF_BYPOSITION) ){
1312: ErrorMsg("Main Refresh: Menu Item Delete Error.");
1313: return(FALSE);
1314: }
1315:
1316: //
1317: // Wait for Enumdrv Thread to terminate, and
1318: // enter drive list critical section
1319: //
1320: WaitForSingleObject(hThread, (DWORD)0xFFFFFFFF);
1321: EnterCriticalSection(&gDrvCS);
1322:
1323: //
1324: // Fill drive menu from glpDrives linked list
1325: //
1326: NumMenuItems = 0;
1327: lpWalk = glpDrives;
1328:
1329: while(lpWalk != NULL){
1330: if( !InsertMenu( hDrivesMenu, NumMenuItems, MF_STRING |
1331: MF_BYPOSITION | MF_ENABLED, MM_DRIVE_NUM + NumMenuItems,
1332: lpWalk->DriveName) )
1333: ErrorMsg("Main Refresh: Menu Item Insert Error.");
1334:
1335: NumMenuItems++;
1336: lpWalk = lpWalk->next;
1337: }
1338:
1339: LeaveCriticalSection(&gDrvCS);
1340:
1341: return(TRUE);
1342: }
1343:
1344:
1345: /***************************************************************************\
1346: *
1347: * ErrorMsg()
1348: *
1349: * Displays a Message Box with a given error message.
1350: *
1351: * History:
1352: * 5/28/92
1353: * Created.
1354: *
1355: \***************************************************************************/
1356: void ErrorMsg(LPSTR szMsg)
1357: {
1358: MessageBox(ghwndMain, szMsg, "FILER Error.", MB_OK);
1359: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.