![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mcitest.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / mcitest|
Return to mcitest.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / mcitest |
1.1 root 1: /* mcitest.c - WinMain(), main dialog box and support code for MCITest.
2: *
3: * MCITest is a Windows with Multimedia sample application illustrating
4: * the use of the Media Control Interface (MCI). MCITest puts up a dialog
5: * box allowing you to enter and execute MCI string commands.
6: *
7: * (C) Copyright Microsoft Corp. 1991, 1992. All rights reserved.
8: *
9: * You have a royalty-free right to use, modify, reproduce and
10: * distribute the Sample Files (and/or any modified version) in
11: * any way you find useful, provided that you agree that
12: * Microsoft has no warranty obligations or liability for any
13: * Sample Application Files which are modified.
14: */
15:
16: /*----------------------------------------------------------------------------*\
17: | mcitest.c - A testbed for MCI |
18: | |
19: | |
20: | History: |
21: | 01/01/88 toddla Created |
22: | 03/01/90 davidle Modified quick app into MCI testbed |
23: | 09/17/90 t-mikemc Added Notification box with 3 notification types |
24: | 11/02/90 w-dougb Commented & formatted the code to look pretty |
25: | 05/29/91 NigelT ported to Win32
26: | 02/05/92 SteveDav Merged latest Win 3.1 stuff
27: | |
28: \*----------------------------------------------------------------------------*/
29:
30: /*----------------------------------------------------------------------------*\
31: | |
32: | i n c l u d e f i l e s |
33: | |
34: \*----------------------------------------------------------------------------*/
35:
36: #include <stdio.h>
37: #include <string.h>
38: #include <windows.h>
39: #include "mcitest.h"
40: #include "mcimain.h"
41: #include "edit.h"
42:
43:
44: /*----------------------------------------------------------------------------*\
45: | |
46: | c o n s t a n t a n d m a c r o d e f i n i t i o n s |
47: | |
48: \*----------------------------------------------------------------------------*/
49:
50: #define BUFFER_LENGTH 256
51: #define SLASH(c) ((c) == '/' || (c) == '\\')
52:
53:
54: /*----------------------------------------------------------------------------*\
55: | |
56: | g l o b a l v a r i a b l e s |
57: | |
58: \*----------------------------------------------------------------------------*/
59: #ifndef STATICDT
60: #if DBG
61: #define STATICDT
62: #else
63: #define STATICDT static
64: #endif
65: #endif
66:
67: STATICDT int nLastNumberOfDevices = 0;
68: STATICDT HANDLE hAccTable;
69: STATICDT HANDLE hInstApp;
70: HWND hwndMainDlg = 0;
71: STATICDT HWND hwndEdit = 0;
72: STATICDT HWND hwndDevices = 0;
73: STATICDT char aszMciFile[BUFFER_LENGTH] = "";
74: STATICDT char aszBuffer[BUFFER_LENGTH];
75: STATICDT char aszExt[] = "*.mcs";
76: char aszAppName[] = "MCITest";
77: STATICDT char aszMainTextFormat[] = "%s - %s";
78: STATICDT char aszDeviceTextFormat[] = "Open MCI Devices(count=%d)";
79: STATICDT char aszNULL[] = "";
80: STATICDT char aszTRUE[] = "TRUE";
81: STATICDT char aszFALSE[] = "FALSE";
82: STATICDT char aszEOL[] = "\r\n";
83: STATICDT char aszOpenFileTitle[] = "Open MCITest File";
84: STATICDT char aszSaveFileTitle[] = "Save MCITest File";
85: STATICDT char aszSaveFileControl[] = "Save File &Name";
86: STATICDT char aszProfileSection[] = "extensions";
87: STATICDT char aszProfileKey[] = "mcs";
88: STATICDT char aszProfileSetting[] = "mcitest.exe ^.mcs";
89: STATICDT char aszMciTester[] = "MciTester";
90:
91: /*----------------------------------------------------------------------------*\
92: | |
93: | f u n c t i o n d e f i n i t i o n s |
94: | |
95: \*----------------------------------------------------------------------------*/
96:
97: BOOL mcitester(HWND hwnd, UINT Msg, LONG wParam, LONG lParam);
98: PSTR FileName(PSTR szPath);
99: STATICFN void update_device_list(void);
100: DWORD sendstring(HWND hwndDlg, PSTR strBuffer);
101: void execute( HWND hwndDlg, BOOL fStep);
102: void OpenMciFile( HWND hwndDlg, LPSTR szFile);
103: BOOL AppInit(int argc, char *argv[]);
104: BOOL ErrDlgFunc( HWND hwndDlg, UINT Msg, LONG w, LONG l );
105: void create_device_list(void);
106: STATICFN BOOL devices(HWND hwndDlg, UINT Msg, LONG wParam, LONG lParam);
107:
108: /*----------------------------------------------------------------------------*\
109: | AboutDlgProc( hwndDlg, Message, wParam, lParam ) |
110: | |
111: | Description: |
112: | This function handles messages belonging to the "About" dialog box. |
113: | The only message that it looks for is WM_COMMAND, indicating the user |
114: | has pressed the "OK" button. When this happens, it takes down |
115: | the dialog box. |
116: | |
117: | Arguments: |
118: | hwndDlg window handle of the about dialog window |
119: | Message message number |
120: | wParam message-dependent parameter |
121: | lParam message-dependent parameter |
122: | |
123: | Returns: |
124: | TRUE if the message has been processed, else FALSE |
125: | |
126: \*----------------------------------------------------------------------------*/
127:
128: BOOL AboutDlgProc(
129: HWND hwndDlg,
130: UINT Msg,
131: LONG wParam,
132: LONG lParam)
133: {
134: dprintf4("AboutDlgProc");
135: switch (Msg) {
136: case WM_COMMAND:
137:
138: if (LOWORD(wParam) == IDOK) {
139: EndDialog(hwndDlg,TRUE);
140: }
141: break;
142:
143: case WM_INITDIALOG:
144: return TRUE;
145:
146: }
147:
148: return FALSE;
149: }
150:
151: /*----------------------------------------------------------------------------*\
152: | FileName(szPath) |
153: | |
154: | Description: |
155: | This function takes the full path\filename string specified in <szPath>|
156: | and returns a pointer to the first character of the filename in the |
157: | same string. |
158: | |
159: | Arguments: |
160: | szPath pointer to the full path\filename string |
161: | |
162: | Returns: |
163: | a pointer to the first character of the filename in the same string |
164: | |
165: \*----------------------------------------------------------------------------*/
166:
167: PSTR FileName(
168: PSTR szPath)
169: {
170: PSTR szCurrent; /* temporary pointer to the string */
171:
172: /* Scan to the end of the string */
173:
174: for (szCurrent = szPath; *szCurrent; szCurrent++)
175: {} ;
176:
177: /*
178: * Now start scanning back towards the beginning of the string until
179: * a slash (\) character, colon, or start of the string is encountered.
180: */
181:
182: for (; szCurrent >= szPath
183: && !SLASH(*szCurrent)
184: && *szCurrent != ':'
185: ; szCurrent--)
186: {} ;
187:
188: /* This should be done by calling a Win 32 function, e.g. GetFullPathName
189: */
190:
191: /* Now pointing to the char before the first char in the filename.
192: */
193: return ++szCurrent;
194: }
195:
196: /*----------------------------------------------------------------------------*\
197: | OpenMciFile( hwndDlg, szFile ) |
198: | |
199: | Description: |
200: | This function opens the MCI file specified by <szFile> and updates the |
201: | main window caption to display this file name along with the app name. |
202: | |
203: | Arguments: |
204: | hwndDlg window handle of the main dialog window |
205: | szFile pointer to the string containing the filename to be |
206: | opened |
207: | Returns: |
208: | void |
209: | |
210: \*----------------------------------------------------------------------------*/
211:
212: void OpenMciFile(
213: HWND hwndDlg,
214: LPSTR lszFile)
215: {
216: dprintf2("OpenMciFile: %s", lszFile);
217:
218: if (EditOpenFile(hwndEdit, lszFile)) {
219:
220: strcpy(aszMciFile, lszFile);
221: wsprintf(aszBuffer, aszMainTextFormat, (LPSTR)aszAppName,
222: (LPSTR)FileName(aszMciFile));
223: dprintf3("Set caption: %s", aszBuffer);
224: SetWindowText(hwndDlg, aszBuffer);
225: } else {
226: dprintf1("failed to open %s", lszFile);
227: }
228: }
229:
230: /*----------------------------------------------------------------------------*\
231: | get_number_of_devices() |
232: | |
233: | Description: |
234: | This function sends a command to MCI querying it as to how many |
235: | are currently open in the system. It returns the value provided by MCI.|
236: | |
237: | Arguments: |
238: | none |
239: | |
240: | Returns: |
241: | The number of MCI devices currently open, or 0 if an error occurred. |
242: | |
243: \*----------------------------------------------------------------------------*/
244:
245: int get_number_of_devices(
246: void)
247: {
248: MCI_SYSINFO_PARMS sysinfo; /* Parameter structure used for getting
249: information about the MCI devices in
250: the system */
251: DWORD dwDevices; /* count of open devices */
252:
253: /*
254: * Set things up so that MCI puts the number of open devices directly
255: * into <dwDevices>.
256: */
257:
258: sysinfo.lpstrReturn = (LPSTR)(LPDWORD)&dwDevices;
259: sysinfo.dwRetSize = sizeof(dwDevices);
260:
261: /*
262: * Send MCI a command querying all devices in the system to see if they
263: * are open. If the command was successful, return the number provided by
264: * MCI. Otherwise, return 0.
265: *
266: */
267:
268: if (mciSendCommand (MCI_ALL_DEVICE_ID,
269: MCI_SYSINFO,
270: (MCI_SYSINFO_OPEN | MCI_SYSINFO_QUANTITY),
271: (DWORD)(LPMCI_SYSINFO_PARMS)&sysinfo) != 0)
272: return 0;
273: else
274: return (int)dwDevices;
275: }
276:
277:
278: /*----------------------------------------------------------------------------*\
279: | update_device_list() |
280: | |
281: | Description: |
282: | This function updates the list of devices displayed in the Devices |
283: | dialog. |
284: | |
285: | Arguments: |
286: | none |
287: | |
288: | Returns: |
289: | void |
290: | |
291: \*----------------------------------------------------------------------------*/
292:
293: STATICFN void update_device_list(
294: void)
295: {
296: char aszBuf[BUFFER_LENGTH]; /* string used for several things */
297: MCI_SYSINFO_PARMS sysinfo; /* Parameter structure used for getting
298: information about the devices in the
299: system */
300: HWND hwndList; /* handle to the Devices listbox window */
301: int nDevices;
302: int nCurrentDevice;
303: #if DBG
304: BOOL fNoRedraw = FALSE;
305: #endif
306:
307: /* If the Devices dialog is not present, then return */
308:
309: if (hwndDevices == 0) {
310: return;
311: }
312:
313: /* Find out how many devices are currently open in the system */
314:
315: nDevices = get_number_of_devices();
316:
317: /* Update the dialog caption appropriately */
318:
319: wsprintf(aszBuf, aszDeviceTextFormat, nDevices);
320: SetWindowText(hwndDevices, aszBuf);
321:
322: /* Get a handle to the dialog's listbox, and prepare it for updating */
323:
324: hwndList = GetDlgItem (hwndDevices, ID_DEVICE_LIST);
325: SendMessage (hwndList, LB_RESETCONTENT, 0, 0L);
326:
327: if (nDevices) {
328: SendMessage (hwndList, WM_SETREDRAW, FALSE, 0L);
329: #if DBG
330: fNoRedraw = TRUE;
331: #endif
332: }
333:
334: /*
335: * Get the name of each open device in the system, one device at a time.
336: * Add each device's name to the listbox.
337: */
338:
339: for (nCurrentDevice = 1; nCurrentDevice <= nDevices; ++nCurrentDevice) {
340:
341: sysinfo.dwNumber = nCurrentDevice;
342: sysinfo.lpstrReturn = (LPSTR)&aszBuf;
343: sysinfo.dwRetSize = sizeof(aszBuf);
344:
345: /* If an error is encountered, skip to the next device.
346: */
347: if (mciSendCommand(MCI_ALL_DEVICE_ID, MCI_SYSINFO,
348: MCI_SYSINFO_OPEN | MCI_SYSINFO_NAME,
349: (DWORD)(LPMCI_SYSINFO_PARMS)&sysinfo) != 0) {
350: continue;
351: }
352:
353: /* Redraw the list when all device names have been added.
354: */
355: if (nCurrentDevice == nDevices) {
356: /* About to add the last device - allow redrawing */
357: SendMessage(hwndList, WM_SETREDRAW, TRUE, 0L);
358: #if DBG
359: fNoRedraw = FALSE;
360: #endif
361: }
362:
363: /* Add the device name to the listbox.
364: */
365: SendMessage(hwndList, LB_ADDSTRING, 0, (LONG)(LPSTR)aszBuf);
366: }
367:
368:
369: #if DBG
370: if (fNoRedraw) { // We had an error...
371: dDbgAssert("Assert failed, REDRAW is still off", __FILE__, __LINE__);
372: }
373: #endif
374:
375: /* Remember the number of open devices we found this time */
376:
377: nLastNumberOfDevices = nDevices;
378: }
379:
380: /*----------------------------------------------------------------------------*\
381: | sendstring( hwndDlg, strBuffer ) |
382: | |
383: | Description: |
384: | This function sends the string command specified in <strBuffer> to MCI |
385: | via the MCI string interface. Any message returned by MCI is displayed |
386: | in the 'MCI output' box. Any error which may have occurred is displayed|
387: | in the 'Error' box'. |
388: | |
389: | Arguments: |
390: | hwndDlg window handle of the main dialog window |
391: | strBuffer pointer to the string containing the string command to |
392: | be executed |
393: | Returns: |
394: | void |
395: | |
396: \*----------------------------------------------------------------------------*/
397:
398: DWORD sendstring(
399: HWND hwndDlg,
400: PSTR strBuffer)
401: {
402: char aszReturn[BUFFER_LENGTH]; /* string containing the message
403: returned by MCI */
404: DWORD dwErr; /* variable containing the return
405: code from the MCI command */
406: dprintf2("sendstring: %s", strBuffer);
407:
408: /* Uncheck the notification buttons */
409:
410: CheckDlgButton (hwndDlg, ID_NOT_SUCCESS, FALSE);
411: CheckDlgButton (hwndDlg, ID_NOT_SUPER, FALSE);
412: CheckDlgButton (hwndDlg, ID_NOT_ABORT, FALSE);
413: CheckDlgButton (hwndDlg, ID_NOT_FAIL, FALSE);
414:
415: /* Send the string command to MCI */
416:
417: dwErr = mciSendString(strBuffer, aszReturn, sizeof(aszReturn), hwndDlg);
418:
419: /* Put the text message returned by MCI into the 'MCI Output' box */
420:
421: SetDlgItemText (hwndDlg, ID_OUTPUT, aszReturn);
422:
423: /*
424: * Decode the error # returned by MCI, and display the string in the
425: * 'Error' box.
426: */
427:
428: mciGetErrorString(dwErr, strBuffer, BUFFER_LENGTH);
429: SetDlgItemText(hwndDlg, ID_ERRORCODE, strBuffer);
430:
431: /* Update the internal list of currently open devices */
432:
433: update_device_list();
434: return dwErr;
435: }
436:
437:
438: /*----------------------------------------------------------------------------*\
439: | ErrDlgFunc( hwndDlg, Msg, wParam, lParam ) |
440: | |
441: | Description: |
442: | This function is the callback function for the dialog box which |
443: | occurs during the execution of a error in a loop of MCITEST commands |
444: | It displays Abort, Continue and Ignore buttons |
445: | |
446: | Arguments: |
447: | hwndDlg window handle of the error message dialog window |
448: | Msg message number |
449: | wParam message-dependent parameter |
450: | lParam message-dependent parameter |
451: | |
452: | Returns: |
453: | normal message passing return values |
454: | |
455: \*----------------------------------------------------------------------------*/
456:
457:
458: BOOL ErrDlgFunc(
459: HWND hwndDlg,
460: UINT Msg,
461: LONG wParam,
462: LONG lParam)
463: {
464: dprintf4("ErrDlgFunc");
465: switch( Msg ) {
466: case WM_INITDIALOG:
467: return TRUE;
468:
469:
470: case WM_COMMAND:
471: switch( LOWORD(wParam) ) { // button pushed
472: case IDABORT:
473: case IDOK:
474: case IDIGNORE:
475: EndDialog( hwndDlg, LOWORD(wParam) ); // return button ID
476: break;
477: }
478: break;
479: }
480: return( FALSE );
481: }
482:
483: /*----------------------------------------------------------------------------*\
484: | execute( hwndDlg, fStep ) |
485: | |
486: | Description: |
487: | This function executes the MCI command which is currently selected in |
488: | the edit box. If <fStep> is true, then only this one line will be |
489: | executed. Otherwise, every line from the currently selected line to |
490: | the last line in the edit box will be executed sequentially. |
491: | |
492: | Arguments: |
493: | hwndDlg window handle of the main dialog window |
494: | fSingleStep flag indicating whether or not to work in 'single step'|
495: | mode |
496: | Returns: |
497: | void |
498: | |
499: \*----------------------------------------------------------------------------*/
500:
501: void execute(
502: HWND hwndDlg,
503: BOOL fSingleStep)
504: {
505: int iLine; /* line # of the command currently being executed
506: in the edit box */
507: int n=0; /* counter variable */
508: int runcount = 1;
509: int count;
510: int iLineStart;
511: BOOL fIgnoreErrors = FALSE;
512:
513: runcount = GetDlgItemInt(hwndDlg, ID_RUNCOUNT, NULL, TRUE);
514:
515: /*
516: * Go through this loop for every line in the edit box from the currently
517: * selected line to the last line, or a single line if in single step mode
518: */
519:
520: iLineStart = EditGetCurLine(hwndEdit);
521: dprintf2("Called to execute %d lines from line %d", runcount, iLineStart);
522:
523: for (count = runcount; count-- > 0; )
524: {
525: for (iLine = iLineStart;
526: EditGetLine(hwndEdit, iLine, aszBuffer, sizeof(aszBuffer));
527: iLine++ ) {
528:
529: /* If we hit a comment line or a blank line, skip to the next line */
530:
531: if (*aszBuffer == ';' || *aszBuffer == 0) {
532: continue;
533: }
534:
535: /* Select the line that is about to be processed */
536:
537: EditSelectLine(hwndEdit,iLine);
538:
539: /*
540: * If we're in 'single step' mode and we've already processed one
541: * line, then break out of the loop (and exit the routine).
542: */
543:
544: if (fSingleStep && ++n == 2) {
545: break;
546: }
547:
548: /*
549: * Send the command on the current line to MCI via the string
550: * interface.
551: */
552:
553: if (sendstring(hwndDlg, aszBuffer) != 0
554: && !fIgnoreErrors
555: && runcount > 1
556: && !fSingleStep) {
557:
558: int nRet;
559:
560: nRet = DialogBox(hInstApp, MAKEINTRESOURCE(IDD_ERRORDLG),
561: hwndDlg, (DLGPROC)ErrDlgFunc);
562:
563: if (nRet == IDABORT) { goto exit_fn; }
564: if (nRet == IDIGNORE) { fIgnoreErrors = TRUE; }
565:
566: }
567: }
568: SetDlgItemInt (hwndDlg, ID_RUNCOUNT, count, TRUE);
569: if (fSingleStep) { break; }
570: }
571: exit_fn:;
572: SetDlgItemInt (hwndDlg, ID_RUNCOUNT, runcount, TRUE);
573: }
574:
575:
576: /*----------------------------------------------------------------------------*\
577: | devices( hwndDlg, uMessage, wParam, lParam ) |
578: | |
579: | Description: |
580: | This function handles messages belonging to the "List of open devices" |
581: | dialog box. The only message that it looks for is WM_COMMAND, |
582: | indicating the user has pressed the "OK" button. When this happens, |
583: | it takes down the dialog box. |
584: | |
585: | Arguments: |
586: | hwndDlg window handle of the Devices dialog window |
587: | uMessage message number |
588: | wParam message-dependent parameter |
589: | lParam message-dependent parameter |
590: | |
591: | Returns: |
592: | TRUE if the message has been processed, else FALSE |
593: | |
594: \*----------------------------------------------------------------------------*/
595:
596: STATICFN BOOL devices(
597: HWND hwndDlg,
598: UINT Msg,
599: LONG wParam,
600: LONG lParam)
601: {
602: switch (Msg) {
603:
604: case WM_COMMAND:
605:
606: dprintf4("Devices -- WM_COMMAND");
607: switch (LOWORD(wParam)) {
608:
609: case ID_END_DEVICE_LIST:
610:
611: hwndDevices = 0;
612: EndDialog(hwndDlg,TRUE);
613:
614: break;
615: }
616:
617: break;
618: }
619:
620: return FALSE;
621: }
622:
623:
624:
625: /*----------------------------------------------------------------------------*\
626: | create_device_list() |
627: | |
628: | Description: |
629: | This function creates the Devices dialog box and updates the list of |
630: | open devices displayed in it. |
631: | |
632: | Arguments: |
633: | none |
634: | |
635: | Returns: |
636: | void |
637: | |
638: \*----------------------------------------------------------------------------*/
639:
640: void create_device_list(
641: void)
642: {
643: /* Create the Devices dialog box */
644:
645: hwndDevices = CreateDialog(hInstApp, MAKEINTRESOURCE(IDD_DEVICES),
646: hwndMainDlg, (DLGPROC)devices);
647: //hwndDevices = CreateDialog (hInstApp, "devices", hwndMainDlg, (WNDPROC)devices);
648:
649: if (hwndDevices == NULL) {
650: dprintf1("NULL hwndDevices");
651: return;
652: }
653:
654: /* Update the information displayed in the listbox */
655:
656: update_device_list();
657: }
658:
659:
660: /*----------------------------------------------------------------------------*\
661: | mcitester( hwndDlg, Msg, wParam, lParam ) |
662: | |
663: | Description: |
664: | This function is the main message handler for MCI test. It handles |
665: | messages from the pushbuttons, radio buttons, edit controls, menu |
666: | system, etc. When it receives a WM_EXIT message, this routine tears |
667: | everything down and exits. |
668: | |
669: | Arguments: |
670: | hwndDlg window handle of the main dialog window |
671: | Msg message number |
672: | wParam message-dependent parameter |
673: | lParam message-dependent parameter |
674: | |
675: | Returns: |
676: | TRUE if the message has been processed, else FALSE |
677: | |
678: \*----------------------------------------------------------------------------*/
679:
680: BOOL mcitester(
681: HWND hwndDlg,
682: UINT Msg,
683: LONG wParam,
684: LONG lParam)
685: {
686: DWORD dw; /* return value from various messages */
687: UINT EnableOrNot; /* is something currently selected? */
688: UINT wID; /* the type of notification required */
689: int i;
690:
691: #if DBG
692: if (Msg != WM_MOUSEMOVE && Msg != WM_NCHITTEST && Msg != WM_NCMOUSEMOVE
693: && (Msg < WM_CTLCOLORMSGBOX || Msg > WM_CTLCOLORSTATIC)
694: && Msg != WM_SETCURSOR) {
695: dprintf4("hWnd: %08XH, Msg: %08XH, wParam: %08XH, lParam: %08XH", hwndDlg, Msg, wParam, lParam );
696: }
697: #endif
698: switch (Msg) {
699:
700: case WM_COMMAND:
701:
702: dprintf3("WM_COMMAND, wParam: %08XH, lParam: %08XH", wParam, lParam);
703: switch (LOWORD(wParam)) {
704:
705: case IDOK:
706:
707: /*
708: * When the OK button gets pressed, insert a CR LF into
709: * the edit control. and execute the current line.
710: *
711: */
712:
713: SetFocus(hwndEdit);
714: i = EditGetCurLine(hwndEdit);
715:
716: execute(hwndDlg, TRUE);
717:
718: EditSetCurLine(hwndEdit, i);
719:
720: SendMessage(hwndEdit, WM_KEYDOWN, VK_END, 0L);
721: SendMessage(hwndEdit, WM_KEYUP, VK_END, 0L);
722: SendMessage(hwndEdit, EM_REPLACESEL, 0,(LONG)(LPSTR)aszEOL);
723:
724: break;
725:
726: case ID_GO:
727:
728: /*
729: * When the GO! button gets pressed, execute every line
730: * in the edit box starting with the first one.
731: *
732: */
733:
734: EditSetCurLine(hwndEdit, 0);
735: execute(hwndDlg, FALSE);
736:
737: break;
738:
739: case ID_STEP:
740:
741: /*
742: * When the STEP button gets pressed, execute the currently
743: * selected line in the edit box.
744: */
745:
746: execute(hwndDlg, TRUE);
747:
748: break;
749:
750: case MENU_EXIT:
751: case ID_EXIT:
752: case IDCANCEL:
753:
754: /*
755: * If the user indicates that he/she wishes to exit the
756: * application, then end the main dialog and post a WM_QUIT
757: * message.
758: *
759: */
760:
761: EndDialog(hwndDlg,TRUE);
762: PostQuitMessage (0);
763: hwndMainDlg = 0;
764:
765: break;
766:
767: case MENU_ABOUT:
768:
769: /* Show the 'About...' box */
770:
771: DialogBox(hInstApp, MAKEINTRESOURCE(IDD_ABOUTBOX), hwndDlg, (DLGPROC)AboutDlgProc);
772: break;
773:
774: case WM_CLEAR:
775: case WM_CUT:
776: case WM_COPY:
777: case WM_PASTE:
778: case WM_UNDO:
779:
780: /* Pass whatever edit message we receive to the edit box */
781: // BUGBUG This might well be bogus
782: dprintf3("sending edit Msg to edit control");
783: SendMessage(hwndEdit, LOWORD(wParam), 0, 0);
784:
785: break;
786:
787: case MENU_OPEN:
788:
789: /* Open a 'File Open' dialog */
790: #ifdef WIN16
791:
792: f = OpenFileDialog(hwndDlg, aszOpenFileTitle, aszExt,
793: DLGOPEN_MUSTEXIST | OF_EXIST | OF_READ, NULL,
794: aszBuffer, sizeof(aszBuffer));
795:
796: /* If the user selected a valid file, then open it */
797:
798: if ((int)f >= 0)
799: OpenMciFile(hwndDlg, aszBuffer);
800: #else
801:
802: strcpy(aszBuffer, aszExt);
803: i = DlgOpen(hInstApp, hwndDlg, aszBuffer, sizeof(aszBuffer) );
804:
805: /* If the user selected a valid file, then open it */
806:
807: if (i == 1)
808: OpenMciFile(hwndDlg, aszBuffer);
809: #endif
810:
811: break;
812:
813: case MENU_SAVE:
814:
815: /*
816: * If a filename exists, then save the contents of the edit
817: * box under that filename.
818: *
819: */
820:
821: if (*aszMciFile) {
822:
823: EditSaveFile(hwndEdit, aszMciFile);
824: break;
825: }
826:
827: break;
828:
829: case MENU_SAVEAS:
830:
831: /*
832: */
833:
834: #ifdef WIN16
835: *aszBuffer = (char)0;
836: f = OpenFileDialog(hwndDlg, aszSaveFileTitle, aszExt,
837: DLGOPEN_SAVE | OF_EXIST, aszSaveFileControl, aszBuffer,
838: sizeof(aszBuffer));
839:
840: /* If the user didn't hit Cancel, then he must have set a
841: * filename, so save the contents of the edit box under
842: * that filename.
843: */
844: if (f != DLGOPEN_CANCEL) {
845:
846: EditSaveFile(hwndEdit, aszBuffer);
847: }
848:
849: #else
850: strcpy(aszBuffer, aszExt);
851: i = DlgOpen(hInstApp, hwndDlg, aszBuffer, sizeof(aszBuffer) );
852:
853: /*
854: * If the user didn't hit Cancel, then he must have set a
855: * filename, so save the contents of the edit box under
856: * that filename.
857: *
858: */
859:
860: if (i != 2) {
861:
862: EditSaveFile(hwndEdit, aszBuffer);
863: }
864: #endif
865: break;
866:
867: case MENU_DEVICES:
868:
869: /*
870: * If the Devices dialog box doesn't already exist, then
871: * create and display it.
872: *
873: */
874:
875: if (hwndDevices == 0) {
876: create_device_list();
877: }
878:
879: break;
880:
881: #if DBG
882: case IDM_DEBUG0:
883: case IDM_DEBUG1:
884: case IDM_DEBUG2:
885: case IDM_DEBUG3:
886: case IDM_DEBUG4:
887: dDbgSetDebugMenuLevel(wParam - IDM_DEBUG0);
888: break;
889: #endif
890:
891: }
892: break; // end of WM_COMMAND case
893:
894: case WM_INITDIALOG:
895:
896: /* Do general initialization stuff */
897:
898: hwndEdit = GetDlgItem(hwndDlg,ID_INPUT);
899:
900: dprintf3("WM_INITDIALOG: hwndEdit = %08xH", hwndEdit);
901:
902: SetMenu(hwndDlg, LoadMenu(hInstApp, MAKEINTRESOURCE(IDM_MCITEST)));
903:
904: SetClassLong (hwndDlg, GCL_HICON,
905: (DWORD)LoadIcon (hInstApp, MAKEINTRESOURCE(IDI_MCITEST)));
906:
907: CheckDlgButton (hwndDlg, ID_NOT_SUCCESS, FALSE);
908: CheckDlgButton (hwndDlg, ID_NOT_SUPER, FALSE);
909: CheckDlgButton (hwndDlg, ID_NOT_ABORT, FALSE);
910: CheckDlgButton (hwndDlg, ID_NOT_FAIL, FALSE);
911: SetDlgItemInt (hwndDlg, ID_RUNCOUNT, 1, TRUE);
912:
913: #if DBG
914: // Check the initial debug level
915: {
916: HANDLE hMenu;
917: hMenu = GetMenu(hwndDlg);
918: CheckMenuItem(hMenu, (UINT)(__iDebugLevel + IDM_DEBUG0), MF_CHECKED);
919: }
920: #endif
921:
922: hAccTable = LoadAccelerators(hInstApp, MAKEINTRESOURCE(IDA_MCITEST));
923:
924: dprintf4("INIT_DIALOG: hwndEdit = %08XH Haccel = %08XH,", hwndEdit, hAccTable);
925:
926: return TRUE;
927:
928: case WM_DESTROY:
929:
930: /* End the dialog and send a WM_QUIT message */
931:
932: dprintf2("dialog ending");
933: dSaveDebugLevel(aszAppName);
934: EndDialog(hwndDlg,TRUE);
935: PostQuitMessage (0);
936: hwndMainDlg = 0;
937:
938: break;
939:
940: case MM_MCINOTIFY:
941:
942: /*
943: * Check the radio button corresponding to the notification
944: * received.
945: *
946: */
947:
948: dprintf3("MM_MCINOTIFY, wParam: %08XH", wParam);
949: wID = 0;
950: switch (wParam) {
951: case MCI_NOTIFY_SUCCESSFUL:
952:
953: wID = ID_NOT_SUCCESS;
954: break;
955:
956: case MCI_NOTIFY_SUPERSEDED:
957:
958: wID = ID_NOT_SUPER;
959: break;
960:
961: case MCI_NOTIFY_ABORTED:
962:
963: wID = ID_NOT_ABORT;
964: break;
965:
966: case MCI_NOTIFY_FAILURE:
967:
968: wID = ID_NOT_FAIL;
969: break;
970:
971: default:
972: break;
973: }
974:
975: if (wID) {
976:
977: CheckDlgButton (hwndDlg, wID, TRUE);
978: SetFocus (GetDlgItem(hwndDlg, ID_INPUT));
979: }
980:
981: break;
982:
983: case WM_INITMENUPOPUP: /* wParam is menu handle */
984:
985: dprintf3("WM_INITMENUPOPUP");
986:
987: /* Enable the 'Save' option if a valid filename exists */
988:
989: EnableMenuItem((HMENU)wParam, (UINT)MENU_SAVE,
990: (UINT)(*aszMciFile ? MF_ENABLED : MF_GRAYED));
991:
992: /* Find out if something is currently selected in the edit box */
993:
994: dw = SendMessage(hwndEdit,EM_GETSEL,0,0L);
995: EnableOrNot = (UINT)((HIWORD(dw) != LOWORD(dw) ? MF_ENABLED : MF_GRAYED));
996:
997: /* Enable / disable the Edit menu options appropriately */
998:
999: EnableMenuItem ((HMENU)wParam, (UINT)WM_UNDO ,
1000: (UINT)(SendMessage(hwndEdit,EM_CANUNDO,0,0L) ? MF_ENABLED : MF_GRAYED));
1001: EnableMenuItem ((HMENU)wParam, WM_CUT , EnableOrNot);
1002: EnableMenuItem ((HMENU)wParam, WM_COPY , EnableOrNot);
1003: EnableMenuItem ((HMENU)wParam, WM_PASTE,
1004: (UINT)(IsClipboardFormatAvailable(CF_TEXT) ? MF_ENABLED : MF_GRAYED));
1005: EnableMenuItem ((HMENU)wParam, WM_CLEAR, EnableOrNot);
1006:
1007: return 0L;
1008: }
1009:
1010: return 0;
1011: }
1012:
1013:
1014: /*----------------------------------------------------------------------------*\
1015: | AppInit( hInst, hPrev, sw, szCmdLine) |
1016: | |
1017: | Description: |
1018: | This is called when the application is first loaded into memory. It |
1019: | performs all initialization that doesn't need to be done once per |
1020: | instance. |
1021: | |
1022: | Arguments: |
1023: | hInstance instance handle of current instance |
1024: | hPrev instance handle of previous instance |
1025: | sw not really used at all |
1026: | szCmdLine string containing the command line arguments |
1027: | |
1028: | Returns: |
1029: | TRUE if successful, FALSE if not |
1030: | |
1031: \*----------------------------------------------------------------------------*/
1032:
1033: BOOL AppInit(
1034: int argc,
1035: char *argv[])
1036: {
1037: /* Put up the main dialog box */
1038:
1039: hInstApp = GetModuleHandle(NULL);
1040: dprintf1("MCITEST starting... module handle is %xH", hInstApp);
1041:
1042: if (NULL ==
1043: (hwndMainDlg = CreateDialog (hInstApp,
1044: MAKEINTRESOURCE(IDD_MCITEST),// "mcitester",
1045: NULL, (DLGPROC)mcitester)
1046: )) {
1047: DWORD n;
1048:
1049: n = GetLastError();
1050: dprintf1("NULL hwndMainDLG, last error is %d", n);
1051: DebugBreak();
1052:
1053: return(FALSE);
1054: }
1055:
1056: /* Fix up WIN.INI if this is the first time we are run... */
1057:
1058: if (!GetProfileString(aszProfileSection, aszProfileKey, aszNULL, aszBuffer, sizeof(aszBuffer)))
1059: WriteProfileString(aszProfileSection, aszProfileKey, aszProfileSetting);
1060:
1061: /*
1062: * If a command line argument was specified, assume it to be a filename
1063: * and open that file.
1064: *
1065: */
1066:
1067: if (argc > 1 && *argv[1])
1068: OpenMciFile(hwndMainDlg, argv[1]);
1069:
1070: return TRUE;
1071: }
1072:
1073:
1074: /*----------------------------------------------------------------------------*\
1075: | WinMain( hInst, hPrev, lpszCmdLine, sw ) |
1076: | |
1077: | Description: |
1078: | The main procedure for the app. After initializing, it just goes |
1079: | into a message-processing loop until it gets a WM_QUIT message |
1080: | (meaning the app was closed). |
1081: | |
1082: | Arguments: |
1083: | hInst instance handle of this instance of the app |
1084: | hPrev instance handle of previous instance, NULL if first |
1085: | szCmdLine null-terminated command line string |
1086: | sw specifies how the window is to be initially displayed |
1087: | |
1088: | Returns: |
1089: | The exit code as specified in the WM_QUIT message. |
1090: | |
1091: \*----------------------------------------------------------------------------*/
1092:
1093: int _CRTAPI1 main(
1094: int argc,
1095: char *argv[],
1096: char *envp[])
1097: {
1098: MSG Msg; /* Windows message structure */
1099:
1100: // If we are in DEBUG mode, get debug level for this module
1101: dGetDebugLevel(aszAppName);
1102: #if DBG
1103: dprintf1("started (debug level %d)", __iDebugLevel);
1104: #endif
1105:
1106: /* Call the initialization procedure */
1107:
1108: if (!AppInit(argc, argv)) {
1109: return FALSE;
1110: }
1111:
1112:
1113: /* Poll the event queue for messages */
1114:
1115: while (GetMessage(&Msg, NULL, 0, 0)) {
1116:
1117: /*
1118: * If the Devices dialog is showing and the number of open devices has
1119: * changed since we last checked, then update the list of open devices.
1120: */
1121:
1122: if (hwndDevices != 0 && get_number_of_devices() != nLastNumberOfDevices) {
1123: update_device_list();
1124: }
1125:
1126: /* Main message processing */
1127:
1128: if (!hwndMainDlg || !IsDialogMessage(hwndMainDlg, &Msg)) {
1129: TranslateMessage(&Msg);
1130: DispatchMessage(&Msg);
1131: // IsDialogMessage may enter with hwndMainDlg != NULL and exit with
1132: // hwndMainDlg == NULL after processing the message
1133: }
1134: else if (hwndMainDlg) {
1135: TranslateAccelerator (hwndMainDlg, hAccTable, &Msg);
1136: }
1137: }
1138:
1139: return Msg.wParam;
1140: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.