home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / graphics / audio / mciplay / mciplay.c < prev    next >
C/C++ Source or Header  |  1996-07-16  |  27KB  |  718 lines
  1. /*----------------------------------------------------------------------------*\
  2.  *
  3.  *  MCIPLAY:
  4.  *
  5.  *    Sample app showing the use of MCIWnd
  6.  *
  7.  *    MCIPLAY is a MDI aplication that demonstates the following:
  8.  *
  9.  *      - Using the MCIWnd window class to play MCI files.
  10.  *
  11.  *----------------------------------------------------------------------------*/
  12. /**************************************************************************
  13.  *
  14.  *  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  15.  *  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  16.  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  17.  *  PURPOSE.
  18.  *
  19.  *  Copyright (C) 1992 - 1996    Microsoft Corporation.    All Rights Reserved.
  20.  *
  21.  **************************************************************************/
  22.  
  23. #define  STRICT
  24. #define  INC_OLE2
  25. #include <windows.h>
  26. #include <windowsx.h>
  27. #include <commdlg.h>
  28. #include <vfw.h>
  29.  
  30. #include "mciplay.h"
  31.  
  32. #define BUFSIZE 260
  33. #define MCIPLAY_APP_CLASS "MCIPlay_App"
  34. #define MCIPLAY_DOC_CLASS MCIWND_WINDOW_CLASS
  35.  
  36. //---------------------------------------------------------------------------
  37.  
  38. #define ISCHECKED(hwnd,id) (BOOL)(GetMenuState(GetMenu(hwnd), id, 0) & MF_CHECKED)
  39.  
  40. /*-------------------------------------------------------------------------*\
  41. |                                                                          |
  42. |   g l o b a l   v a r i a b l e s                                        |
  43. |                                                                          |
  44. \*------------------------------------------------------------------------*/
  45.  
  46.     HINSTANCE ghInstApp;        /* Instance handle */
  47.     HACCEL ghAccelApp;
  48.     HWND ghwndApp;          /* Handle to parent window */
  49.     HWND ghwndMdi;          /* Handle to MCI client window */
  50.     char gszBuffer[BUFSIZE];
  51.  
  52. /*----------------------------------------------------------------------------*\
  53. \*----------------------------------------------------------------------------*/
  54.  
  55. LRESULT CALLBACK AppWndProc(HWND, UINT, WPARAM, LPARAM);
  56. BOOL    CALLBACK AppAbout(HWND, UINT, WPARAM, LPARAM);
  57.  
  58. static BOOL AppInit(HINSTANCE, HINSTANCE, LPSTR, int);
  59. static HWND mdiCreateDoc(LPSTR, LPSTR, LPARAM);
  60. static HWND mdiCreateClient(HWND, HMENU);
  61. static LRESULT mdiSendMessage(HWND, HWND, UINT, WPARAM, LPARAM);
  62. static BOOL FormatFilterString(UINT, LPSTR);
  63. static void MCI_OnCommand(HWND, int, HWND, UINT);
  64. static void mdiFilterSendMessage(HWND, UINT, WPARAM, LPARAM);
  65. static void MCI_OnInitMenuPopup(HWND, HMENU, int, BOOL);
  66. static void MCI_OnSize(HWND, UINT, int, int);
  67.  
  68. /*----------------------------------------------------------------------------*\
  69. |   AppAbout( hDlg, msg, wParam, lParam )                                      |
  70. |                                                                              |
  71. |   Description:                                                               |
  72. |       This function handles messages belonging to the "About" dialog box.    |
  73. |       The only message that it looks for is WM_COMMAND, indicating the use   |
  74. |       has pressed the "OK" button.  When this happens, it takes down         |
  75. |       the dialog box.                                                        |
  76. |                                                                              |
  77. |   Arguments:                                                                 |
  78. |       hDlg            window handle of about dialog window                   |
  79. |       msg             message number                                         |
  80. |       wParam          message-dependent                                      |
  81. |       lParam          message-dependent                                      |
  82. |                                                                              |
  83. |   Returns:                                                                   |
  84. |       TRUE if message has been processed, else FALSE                         |
  85. |                                                                              |
  86. \*----------------------------------------------------------------------------*/
  87. BOOL CALLBACK AppAbout(
  88. HWND hwnd,
  89. UINT msg,
  90. WPARAM wParam,
  91. LPARAM lParam)
  92. {
  93.     switch (msg) {
  94.         case WM_COMMAND:
  95.         EndDialog(hwnd,TRUE);
  96.         return TRUE;
  97.     }
  98.     return FALSE;
  99. }
  100.  
  101. /*----------------------------------------------------------------------------*\
  102. |   AppInit ( hInstance, hPrevInstance )                                       |
  103. |                                                                              |
  104. |   Description:                                                               |
  105. |       This is called when the application is first loaded into               |
  106. |       memory.  It performs all initialization that doesn't need to be done   |
  107. |       once per instance.                                                     |
  108. |                                                                              |
  109. |   Arguments:                                                                 |
  110. |   hPrevInstance   instance handle of previous instance                       |
  111. |       hInstance       instance handle of current instance                    |
  112. |                                                                              |
  113. |   Returns:                                                                   |
  114. |       TRUE if successful, FALSE if not                                       |
  115. |                                                                              |
  116. \*----------------------------------------------------------------------------*/
  117. static BOOL AppInit(
  118. HINSTANCE hInst,
  119. HINSTANCE hPrev,
  120. LPSTR szCmd,
  121. int sw)
  122. {
  123.     WNDCLASS cls;
  124.     WORD wVer;
  125.     char szAppName[BUFSIZE];
  126.  
  127.     /* Save instance handle for DialogBox */
  128.     ghInstApp = hInst;
  129.  
  130.     LoadString( ghInstApp, IDS_APPNAME, szAppName, BUFSIZE );
  131.  
  132.     /* first let's make sure we are running on 1.1 */
  133.     wVer = HIWORD(VideoForWindowsVersion());
  134.     if (wVer < 0x010a){
  135.         char szTitle[BUFSIZE];
  136.         /* oops, we are too old, blow out of here */
  137.         LoadString( ghInstApp, IDS_APPERR, szTitle, BUFSIZE );
  138.         LoadString( ghInstApp, IDS_VFWTOOOLD, gszBuffer, BUFSIZE );
  139.         MessageBeep(MB_ICONHAND);
  140.         MessageBox(NULL, gszBuffer, szTitle, MB_OK|MB_ICONSTOP);
  141.         return FALSE;
  142.     }
  143.  
  144.     ghAccelApp = LoadAccelerators(ghInstApp, "AppAccel");
  145.  
  146.     if (!hPrev) {
  147.         cls.hCursor        = LoadCursor(NULL,IDC_ARROW);
  148.         cls.hIcon          = LoadIcon(hInst,"AppIcon");
  149.         cls.lpszMenuName   = "AppMenu";
  150.         cls.lpszClassName  = MCIPLAY_APP_CLASS;
  151.         cls.hbrBackground  = (HBRUSH)(COLOR_APPWORKSPACE+1);
  152.         cls.hInstance      = hInst;
  153.         cls.style          = 0;
  154.         cls.lpfnWndProc    = (WNDPROC)AppWndProc;
  155.         cls.cbClsExtra     = 0;
  156.         cls.cbWndExtra     = 0;
  157.  
  158.         if (!RegisterClass(&cls))
  159.             return FALSE;
  160.     }
  161.  
  162.     // !!! Not using MCIWndCreate, so we must init ourselves
  163.     if (!MCIWndRegisterClass())
  164.         return FALSE;
  165.  
  166.     ghwndApp = CreateWindow(
  167.         MCIPLAY_APP_CLASS,
  168.         szAppName,
  169.         WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
  170.         CW_USEDEFAULT,
  171.         0,
  172.         CW_USEDEFAULT,
  173.         0,
  174.         (HWND)NULL,   /* no parent */
  175.         (HMENU)NULL,      /* use class menu */
  176.         (HANDLE)hInst,     /* handle to window instance */
  177.         (LPSTR)NULL);     /* no params to pass on */
  178.  
  179.     /* Make window visible according to the way the app is activated */
  180.     ShowWindow(ghwndApp,sw);
  181.  
  182.     return TRUE;
  183. }
  184.  
  185. /*----------------------------------------------------------------------------*\
  186. |   WinMain( hInstance, hPrevInstance, lpszCmdLine, cmdShow )                  |
  187. |                                                                              |
  188. |   Description:                                                               |
  189. |       The main procedure for the App.  After initializing, it just goes      |
  190. |       into a message-processing loop until it gets a WM_QUIT message         |
  191. |       (meaning the app was closed).                                          |
  192. |                                                                              |
  193. |   Arguments:                                                                 |
  194. |       hInstance       instance handle of this instance of the app            |
  195. |       hPrevInstance   instance handle of previous instance, NULL if first    |
  196. |       lpszCmdLine     ->null-terminated command line                         |
  197. |       cmdShow         specifies how the window is initially displayed        |
  198. |                                                                              |
  199. |   Returns:                                                                   |
  200. |       The exit code as specified in the WM_QUIT message.                     |
  201. |                                                                              |
  202. \*----------------------------------------------------------------------------*/
  203. int PASCAL WinMain(
  204. HINSTANCE hInstance,
  205. HINSTANCE hPrevInstance,
  206. LPSTR szCmdLine,
  207. int sw)
  208. {
  209.     MSG msg;
  210.  
  211.     if (!AppInit(hInstance,hPrevInstance,szCmdLine,sw))
  212.         return FALSE;
  213.  
  214.     //Polling messages from event queue
  215.     for (;;) {
  216.         if (PeekMessage(&msg, NULL, 0, 0,PM_REMOVE)) {
  217.             if (msg.message == WM_QUIT)
  218.                 break;
  219.  
  220.             if (ghAccelApp && ghwndApp && TranslateAccelerator(ghwndApp, ghAccelApp, &msg))
  221.                 continue;
  222.  
  223.             if(!TranslateMDISysAccel(ghwndMdi, &msg)) {
  224.                 TranslateMessage(&msg);
  225.                 DispatchMessage(&msg);
  226.             }
  227.         } else {
  228.             // idle time here, DONT BE A PIG!
  229.             WaitMessage();
  230.         }
  231.     }
  232.     return msg.wParam;
  233. }
  234.  
  235. /*----------------------------------------------------------------------------*\
  236. \*----------------------------------------------------------------------------*/
  237.  
  238. static HWND mdiCreateDoc(
  239. LPSTR szClass,
  240. LPSTR szTitle,
  241. LPARAM l)
  242. {
  243.     MDICREATESTRUCT mdics;
  244.  
  245.     mdics.szClass   = szClass;
  246.     mdics.szTitle   = szTitle;
  247.     mdics.hOwner    = ghInstApp;
  248.     mdics.x         = CW_USEDEFAULT;
  249.     mdics.y         = 0;
  250.     mdics.cx        = CW_USEDEFAULT;
  251.     mdics.cy        = 0;
  252.     mdics.style     = WS_CLIPCHILDREN | WS_CLIPSIBLINGS | MCIWNDF_SHOWALL;
  253.     mdics.lParam    = l;
  254.  
  255.     return FORWARD_WM_MDICREATE(ghwndMdi, (LPMDICREATESTRUCT)&mdics, SendMessage);
  256. }
  257.  
  258. /*----------------------------------------------------------------------------*\
  259. |   mdiCreateClient()                                                          |
  260. |                                                                              |
  261. |   Description:                                                               |
  262. |                                                                              |
  263. |   Arguments:                                                                 |
  264. |                                                                              |
  265. |   Returns:                                                                   |
  266. |   HWND if successful, NULL otherwise                                         |
  267. |                                                                              |
  268. \*----------------------------------------------------------------------------*/
  269. static HWND mdiCreateClient(
  270. HWND hwndP,
  271. HMENU hmenuWindow)
  272. {
  273.     CLIENTCREATESTRUCT ccs;
  274.  
  275.     ccs.hWindowMenu = hmenuWindow;
  276.     ccs.idFirstChild = 100;
  277.  
  278.     return CreateWindow(
  279.             "MDICLIENT",
  280.             NULL,
  281.             WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,
  282.             0,
  283.             0,
  284.             0,
  285.             0,
  286.             hwndP,
  287.             0,
  288.             ghInstApp,
  289.             (LPVOID)&ccs);
  290. }
  291.  
  292. /*----------------------------------------------------------------------------*\
  293. \*----------------------------------------------------------------------------*/
  294.  
  295. static LRESULT mdiSendMessage(
  296. HWND hwndMdi,
  297. HWND hwnd,
  298. UINT msg,
  299. WPARAM wParam,
  300. LPARAM lParam)
  301. {
  302.     if (hwnd == (HWND)-1) {
  303.         for (hwnd = GetWindow(hwndMdi, GW_CHILD); hwnd;
  304.                     hwnd = GetWindow(hwnd, GW_HWNDNEXT))
  305.             SendMessage(hwnd, msg, wParam, lParam);
  306.         return 0L;
  307.     } else {
  308.         if (hwnd == NULL)
  309.             hwnd = FORWARD_WM_MDIGETACTIVE(hwndMdi, SendMessage);
  310.         if (hwnd)
  311.             return SendMessage(hwnd, msg, wParam, lParam);
  312.     }
  313. }
  314.  
  315. //----------------------------------------------------------------------------
  316. // MCI_OnCommand - Handles WM_COMMAND
  317. //----------------------------------------------------------------------------
  318. static void MCI_OnCommand(
  319. HWND hwnd,
  320. int id,
  321. HWND hwndCtl,
  322. UINT codeNotify)
  323. {
  324.     HWND hwndNew;
  325.     HWND hwndMovie = FORWARD_WM_MDIGETACTIVE(ghwndMdi, SendMessage);
  326.  
  327.     switch(id) {
  328.         case MENU_ABOUT:
  329.             DialogBox(ghInstApp,MAKEINTRESOURCE(ABOUTBOX),hwnd,AppAbout);
  330.             break;
  331.  
  332.         case MENU_EXIT:
  333.             PostMessage(hwnd,WM_CLOSE,0,0L);
  334.             break;
  335.  
  336.         case MENU_CLOSE:
  337.             PostMessage(hwndMovie, WM_CLOSE, 0, 0L);
  338.             break;
  339.  
  340.         case MENU_NEW:
  341.             LoadString( ghInstApp, IDS_UNTITLLED, gszBuffer, BUFSIZE );
  342.             if (hwndNew = mdiCreateDoc(MCIPLAY_DOC_CLASS, gszBuffer, 0))
  343.                 SetFocus(hwndNew);
  344.             break;
  345.  
  346.         case MENU_OPEN:
  347.         {
  348.             OPENFILENAME ofn;
  349.             char szFileName[BUFSIZE];
  350.             char szFilter[BUFSIZE];
  351.  
  352.             FormatFilterString( IDS_FILTERSTRING, szFilter );
  353.  
  354.             /* prompt user for file to open */
  355.             ofn.lStructSize = sizeof(OPENFILENAME);
  356.             ofn.hwndOwner = hwnd;
  357.             ofn.hInstance = NULL;
  358.             ofn.lpstrFilter = szFilter;
  359.             ofn.lpstrCustomFilter = NULL;
  360.             ofn.nMaxCustFilter = 0;
  361.             ofn.nFilterIndex = 0;
  362.             *szFileName = '\0';
  363.             ofn.lpstrFile = szFileName;
  364.             ofn.nMaxFile = BUFSIZE;
  365.             ofn.lpstrFileTitle = NULL;
  366.             ofn.nMaxFileTitle = 0;
  367.             ofn.lpstrInitialDir = NULL;
  368.             ofn.lpstrTitle = "Open";
  369.             ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
  370.             ofn.nFileOffset = 0;
  371.             ofn.nFileExtension = 0;
  372.             ofn.lpstrDefExt = NULL;
  373.             ofn.lCustData = 0;
  374.             ofn.lpfnHook = NULL;
  375.             ofn.lpTemplateName = NULL;
  376.  
  377.             if (GetOpenFileName(&ofn))
  378.                 if (hwndNew = mdiCreateDoc(MCIPLAY_DOC_CLASS, 0, (LPARAM)(LPSTR)szFileName))
  379.                     SetFocus(hwndNew);
  380.         }
  381.         break;
  382.  
  383.         case WM_MDITILE:
  384.         case WM_MDICASCADE:
  385.         case WM_MDIICONARRANGE:
  386.             SendMessage(ghwndMdi, id, 0, 0);
  387.             break;
  388.  
  389.         /* Movie Menu */
  390.         case IDM_PLAY:
  391.             MCIWndPlay(hwndMovie);
  392.             break;
  393.  
  394.         case IDM_RPLAY:
  395.             MCIWndPlayReverse(hwndMovie);
  396.             break;
  397.  
  398.         case IDM_STOP:
  399.             MCIWndStop(hwndMovie);
  400.             break;
  401.  
  402.         case IDM_HOME:
  403.             MCIWndHome(hwndMovie);
  404.             break;
  405.  
  406.         case IDM_END:
  407.             MCIWndEnd(hwndMovie);
  408.             break;
  409.  
  410.         case IDM_STEP:
  411.             MCIWndStep(hwndMovie, 1);
  412.             break;
  413.  
  414.         case IDM_RSTEP:
  415.             MCIWndStep(hwndMovie, -1);
  416.             break;
  417.  
  418.         /* Styles POPUP */
  419.  
  420.         case IDM_SAutosizeWindow:
  421.             MCIWndChangeStyles(hwndMovie, MCIWNDF_NOAUTOSIZEWINDOW,
  422.                 ISCHECKED(hwnd,id) ? MCIWNDF_NOAUTOSIZEWINDOW : 0);
  423.             break;
  424.  
  425.         case IDM_SAutosizeMovie:
  426.             MCIWndChangeStyles(hwndMovie, MCIWNDF_NOAUTOSIZEMOVIE,
  427.                 ISCHECKED(hwnd,id) ? MCIWNDF_NOAUTOSIZEMOVIE : 0);
  428.             break;
  429.  
  430.         case IDM_SPlaybar:
  431.             MCIWndChangeStyles(hwndMovie, MCIWNDF_NOPLAYBAR,
  432.                 ISCHECKED(hwnd,id) ? MCIWNDF_NOPLAYBAR : 0);
  433.             break;
  434.  
  435.         case IDM_SRecord:
  436.             MCIWndChangeStyles(hwndMovie, MCIWNDF_RECORD,
  437.                 ISCHECKED(hwnd,id) ? 0 : MCIWNDF_RECORD);
  438.             break;
  439.  
  440.         case IDM_SMenu:
  441.             MCIWndChangeStyles(hwndMovie, MCIWNDF_NOMENU,
  442.                 ISCHECKED(hwnd,id) ? MCIWNDF_NOMENU : 0);
  443.             break;
  444.  
  445.         case IDM_SErrorDlg:
  446.             MCIWndChangeStyles(hwndMovie, MCIWNDF_NOERRORDLG,
  447.                 ISCHECKED(hwnd,id) ? MCIWNDF_NOERRORDLG : 0);
  448.             break;
  449.  
  450.         case IDM_SShowName:
  451.             MCIWndChangeStyles(hwndMovie, MCIWNDF_SHOWNAME,
  452.                 ISCHECKED(hwnd,id) ? 0 : MCIWNDF_SHOWNAME);
  453.             break;
  454.  
  455.         case IDM_SShowMode:
  456.             MCIWndChangeStyles(hwndMovie, MCIWNDF_SHOWMODE,
  457.                 ISCHECKED(hwnd,id) ? 0 : MCIWNDF_SHOWMODE);
  458.             break;
  459.  
  460.         case IDM_SShowPos:
  461.             MCIWndChangeStyles(hwndMovie, MCIWNDF_SHOWPOS,
  462.                 ISCHECKED(hwnd,id) ? 0 : MCIWNDF_SHOWPOS);
  463.             break;
  464.  
  465.         case IDM_SNotifyMedia:
  466.             MCIWndChangeStyles(hwndMovie, MCIWNDF_NOTIFYMEDIA,
  467.                 ISCHECKED(hwnd,id) ? 0 : MCIWNDF_NOTIFYMEDIA);
  468.             break;
  469.  
  470.         case IDM_SNotifyMode:
  471.             MCIWndChangeStyles(hwndMovie, MCIWNDF_NOTIFYMODE,
  472.                 ISCHECKED(hwnd,id) ? 0 : MCIWNDF_NOTIFYMODE);
  473.             break;
  474.  
  475.         case IDM_SNotifyPos:
  476.             MCIWndChangeStyles(hwndMovie, MCIWNDF_NOTIFYPOS,
  477.                 ISCHECKED(hwnd,id) ? 0 : MCIWNDF_NOTIFYPOS);
  478.             break;
  479.  
  480.         case IDM_SNotifySize:
  481.             MCIWndChangeStyles(hwndMovie, MCIWNDF_NOTIFYSIZE,
  482.                 ISCHECKED(hwnd,id) ? 0 : MCIWNDF_NOTIFYSIZE);
  483.             break;
  484.  
  485.         default:
  486.             FORWARD_WM_COMMAND(NULL, id, hwndCtl, codeNotify, mdiFilterSendMessage);
  487.             break;
  488.     }
  489.     return;
  490. }
  491.  
  492. /*----------------------------------------------------------------------------*/
  493. static void mdiFilterSendMessage(
  494. HWND    hwnd,
  495. UINT    msg,
  496. WPARAM  wParam,
  497. LPARAM  lParam)
  498. {
  499.     mdiSendMessage(ghwndMdi, hwnd, msg, wParam, lParam);
  500. }
  501.  
  502. //----------------------------------------------------------------------------
  503. // MCI_OnInitMenuPopup - Handles WM_INITMENUPOPUP
  504. //----------------------------------------------------------------------------
  505. static void MCI_OnInitMenuPopup(
  506. HWND hwnd,
  507. HMENU hMenu,
  508. int item,
  509. BOOL fSystemMenu)
  510. {
  511.     HMENU hStylesMenu = GetSubMenu(GetSubMenu(GetMenu(hwnd), 1), 10);
  512.     HMENU hFileMenu = GetSubMenu(GetMenu(hwnd), 0);
  513.     HMENU hMovieMenu = GetSubMenu(GetMenu(hwnd), 1);
  514.     HMENU hWindowMenu = GetSubMenu(GetMenu(hwnd), 2);
  515.     HWND  hwndMovie = FORWARD_WM_MDIGETACTIVE(ghwndMdi, SendMessage);
  516.     UINT f;
  517.  
  518.     // be sure this isn't the system menu
  519.     if (fSystemMenu)
  520.         return;
  521.  
  522.     //
  523.     // Check the styles properly when styles is chosen
  524.     // !!! Make sure position constants don't change!
  525.     // Dont forget that some of these styles use multiple bits
  526.     // in wStyles - therefore check carefully.
  527.     if ((hMenu == hStylesMenu) && hwndMovie) {
  528.  
  529.         UINT  wStyles = MCIWndGetStyles(hwndMovie);
  530.  
  531.         CheckMenuItem(hStylesMenu, IDM_SAutosizeWindow,
  532.             ((wStyles & MCIWNDF_NOAUTOSIZEWINDOW) == MCIWNDF_NOAUTOSIZEWINDOW) ? MF_UNCHECKED : MF_CHECKED);
  533.         CheckMenuItem(hStylesMenu, IDM_SAutosizeMovie,
  534.             ((wStyles & MCIWNDF_NOAUTOSIZEMOVIE) == MCIWNDF_NOAUTOSIZEMOVIE) ? MF_UNCHECKED : MF_CHECKED);
  535.         CheckMenuItem(hStylesMenu, IDM_SPlaybar,
  536.             ((wStyles & MCIWNDF_NOPLAYBAR) == MCIWNDF_NOPLAYBAR) ? MF_UNCHECKED : MF_CHECKED);
  537.         CheckMenuItem(hStylesMenu, IDM_SRecord,
  538.             ((wStyles & MCIWNDF_RECORD) == MCIWNDF_RECORD) ? MF_CHECKED :MF_UNCHECKED);
  539.         CheckMenuItem(hStylesMenu, IDM_SMenu,
  540.             ((wStyles & MCIWNDF_NOMENU) == MCIWNDF_NOMENU) ? MF_UNCHECKED :MF_CHECKED);
  541.         CheckMenuItem(hStylesMenu, IDM_SErrorDlg,
  542.             ((wStyles & MCIWNDF_NOERRORDLG) == MCIWNDF_NOERRORDLG) ? MF_UNCHECKED :MF_CHECKED);
  543.         CheckMenuItem(hStylesMenu, IDM_SShowName,
  544.             ((wStyles & MCIWNDF_SHOWNAME) == MCIWNDF_SHOWNAME) ? MF_CHECKED :MF_UNCHECKED);
  545.         CheckMenuItem(hStylesMenu, IDM_SShowMode,
  546.             ((wStyles & MCIWNDF_SHOWMODE) == MCIWNDF_SHOWMODE) ? MF_CHECKED :MF_UNCHECKED);
  547.         CheckMenuItem(hStylesMenu, IDM_SShowPos,
  548.             ((wStyles & MCIWNDF_SHOWPOS) == MCIWNDF_SHOWPOS) ? MF_CHECKED :MF_UNCHECKED);
  549.         CheckMenuItem(hStylesMenu, IDM_SNotifyMedia,
  550.             ((wStyles & MCIWNDF_NOTIFYMEDIA) == MCIWNDF_NOTIFYMEDIA) ? MF_CHECKED :MF_UNCHECKED);
  551.         CheckMenuItem(hStylesMenu, IDM_SNotifyMode,
  552.             ((wStyles & MCIWNDF_NOTIFYMODE) == MCIWNDF_NOTIFYMODE) ? MF_CHECKED :MF_UNCHECKED);
  553.         CheckMenuItem(hStylesMenu, IDM_SNotifyPos,
  554.             ((wStyles & MCIWNDF_NOTIFYPOS) == MCIWNDF_NOTIFYPOS) ? MF_CHECKED :MF_UNCHECKED);
  555.         CheckMenuItem(hStylesMenu, IDM_SNotifySize,
  556.             ((wStyles & MCIWNDF_NOTIFYSIZE) == MCIWNDF_NOTIFYSIZE) ? MF_CHECKED :MF_UNCHECKED);
  557.     }
  558.  
  559.     //
  560.     // Enable/Disable the stuff under the MOVIE popup
  561.     // !!! Make sure position constants don't change!
  562.     //
  563.     else if (hMenu == hMovieMenu) {
  564.  
  565.         EnableMenuItem( hMenu, 10,
  566.                         MF_BYPOSITION | (hwndMovie ? MF_ENABLED : MF_GRAYED) );
  567.  
  568.         if ( !hwndMovie
  569.            || MCIWndGetMode(hwndMovie, NULL, 0) == MCI_MODE_NOT_READY) {
  570.  
  571.             EnableMenuItem( hFileMenu, MENU_CLOSE,
  572.                             hwndMovie ? MF_ENABLED : MF_GRAYED );
  573.  
  574.             EnableMenuItem(hMenu, IDM_STOP, MF_GRAYED);
  575.             EnableMenuItem(hMenu, IDM_PLAY, MF_GRAYED);
  576.             EnableMenuItem(hMenu, IDM_RPLAY, MF_GRAYED);
  577.             EnableMenuItem(hMenu, IDM_HOME, MF_GRAYED);
  578.             EnableMenuItem(hMenu, IDM_END, MF_GRAYED);
  579.             EnableMenuItem(hMenu, IDM_STEP, MF_GRAYED);
  580.             EnableMenuItem(hMenu, IDM_RSTEP, MF_GRAYED);
  581.  
  582.         } else {
  583.  
  584.             EnableMenuItem(hFileMenu, MENU_CLOSE, MF_ENABLED);
  585.             f = MCIWndGetMode(hwndMovie, NULL, 0) != MCI_MODE_STOP;
  586.             EnableMenuItem(hMenu, IDM_PLAY, !f ? MF_ENABLED : MF_GRAYED);
  587.             EnableMenuItem(hMenu, IDM_RPLAY, !f ? MF_ENABLED : MF_GRAYED);
  588.             EnableMenuItem(hMenu, IDM_STOP, f ? MF_ENABLED : MF_GRAYED);
  589.             EnableMenuItem(hMenu, IDM_HOME, MF_ENABLED);
  590.             EnableMenuItem(hMenu, IDM_END,  MF_ENABLED);
  591.             EnableMenuItem(hMenu, IDM_STEP, MF_ENABLED);
  592.             EnableMenuItem(hMenu, IDM_RSTEP,MF_ENABLED);
  593.         }
  594.     }
  595.  
  596.     //
  597.     // Enable/Disable the stuff under the WINDOW menu
  598.     // !!! Make sure position constants don't change!
  599.     //
  600.     else if (hMenu == hWindowMenu) {
  601.  
  602.             EnableMenuItem(hMenu, 0,
  603.                         MF_BYPOSITION | (hwndMovie ? MF_ENABLED : MF_GRAYED));
  604.             EnableMenuItem(hMenu, 1,
  605.                         MF_BYPOSITION | (hwndMovie ? MF_ENABLED : MF_GRAYED));
  606.             EnableMenuItem(hMenu, 2,
  607.                         MF_BYPOSITION | (hwndMovie ? MF_ENABLED : MF_GRAYED));
  608.     }
  609.  
  610.     //
  611.     // Enable/Disable the stuff under the FILE menu
  612.     //
  613.     else if (hMenu == hFileMenu) {
  614.  
  615.         EnableMenuItem( hFileMenu, MENU_CLOSE,
  616.                         hwndMovie ? MF_ENABLED : MF_GRAYED);
  617.     }
  618.  
  619.     FORWARD_WM_INITMENUPOPUP(NULL, hMenu, item,
  620.                              fSystemMenu, mdiFilterSendMessage);
  621.     return;
  622. }
  623.  
  624. //----------------------------------------------------------------------------
  625. // MCI_OnSize - Handles WM_SIZE
  626. //----------------------------------------------------------------------------
  627. static void MCI_OnSize(
  628. HWND hwnd,
  629. UINT state,
  630. int cx,
  631. int cy)
  632. {
  633.     MoveWindow(ghwndMdi,0,0,cx,cy,TRUE);
  634.     return;
  635. }
  636.  
  637. /*----------------------------------------------------------------------------*\
  638. |   AppWndProc( hwnd, msg, wParam, lParam )                                    |
  639. |                                                                              |
  640. |   Description:                                                               |
  641. |       The window proc for the app's main (tiled) window.  This processes all |
  642. |       of the parent window's messages.                                       |
  643. |                                                                              |
  644. |   Arguments:                                                                 |
  645. |       hwnd            window handle for the parent window                    |
  646. |       msg             message number                                         |
  647. |       wParam          message-dependent                                      |
  648. |       lParam          message-dependent                                      |
  649. |                                                                              |
  650. |   Returns:                                                                   |
  651. |       0 if processed, nonzero if ignored                                     |
  652. |                                                                              |
  653. \*----------------------------------------------------------------------------*/
  654. LRESULT CALLBACK AppWndProc(
  655. HWND hwnd,
  656. UINT msg,
  657. WPARAM wParam,
  658. LPARAM lParam)
  659. {
  660.  
  661.     switch (msg) {
  662.        case WM_CREATE:
  663.         ghwndMdi = mdiCreateClient(hwnd, GetSubMenu(GetMenu(hwnd), GetMenuItemCount(GetMenu(hwnd))-1));
  664.         break;
  665.  
  666.         case WM_COMMAND:
  667.             HANDLE_WM_COMMAND(hwnd, wParam, lParam, MCI_OnCommand);
  668.             break;
  669.  
  670.     case WM_PALETTECHANGED:
  671.         mdiSendMessage(ghwndMdi, (HWND)-1, msg, wParam, lParam);
  672.         break;
  673.  
  674.     case WM_QUERYNEWPALETTE:
  675.         return mdiSendMessage(ghwndMdi, NULL, msg, wParam, lParam);
  676.             break;
  677.  
  678.         case WM_INITMENUPOPUP:
  679.         HANDLE_WM_INITMENUPOPUP(hwnd, wParam, lParam, MCI_OnInitMenuPopup);
  680.         break;
  681.  
  682.     case WM_SIZE:
  683.         HANDLE_WM_SIZE(hwnd, wParam, lParam, MCI_OnSize);
  684.         break;
  685.  
  686.     case WM_DESTROY:
  687.         PostQuitMessage(0);
  688.         return (0);
  689.     }
  690.     return DefFrameProc(hwnd,ghwndMdi,msg,wParam,lParam);
  691. }
  692.  
  693. /*--------------------------------------------------------------+
  694. | FormatFilterString                                            |
  695. |                                                               |
  696. +--------------------------------------------------------------*/
  697. static BOOL FormatFilterString(
  698. UINT uID,
  699. LPSTR lpszString )
  700. {
  701.     int nLength, nCtr = 0;
  702.     char chWildCard;
  703.  
  704.     *lpszString = 0;
  705.  
  706.     nLength = LoadString( ghInstApp, uID, lpszString, BUFSIZE );
  707.  
  708.     chWildCard = lpszString[nLength-1];
  709.  
  710.     while( lpszString[nCtr] ) {
  711.         if( lpszString[nCtr] == chWildCard )
  712.             lpszString[nCtr] = 0;
  713.         nCtr++;
  714.     }
  715.  
  716.     return TRUE;
  717. }
  718.