home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / warptlk3.zip / TOOLKIT / SAMPLES / MM / MOVIE / MOVIE.C < prev    next >
C/C++ Source or Header  |  1995-08-24  |  81KB  |  2,034 lines
  1. /*************************************************************************
  2.  * File Name    :  movie.c
  3.  *
  4.  * Description  :  This file contains the C source code required for the
  5.  *                 movie sample program.
  6.  *
  7.  * Concepts     :  The sample program illustrates how an application
  8.  *                 can play and edit a movie in a hardware independent manner.
  9.  *
  10.  *                 This sample application will demonstrate device control
  11.  *                 of a Software Motion Video device, playing and editing of
  12.  *                 a movie in an application specified window and in a window
  13.  *                 provided by the Softare Motion Video subsystem.
  14.  *
  15.  * MMPM/2 API's :  List of all MMPM/2 API's that are used in
  16.  *                 this module:
  17.  *
  18.  *                 mciSendCommand    MCI_OPEN
  19.  *                                   MCI_PLAY
  20.  *                                   MCI_PAUSE
  21.  *                                   MCI_RESUME
  22.  *                                   MCI_SEEK
  23.  *                                   MCI_CLOSE
  24.  *                                   MCI_SET
  25.  *                                   MCI_WINDOW
  26.  *                                   MCI_PUT
  27.  *                                   MCI_CUT
  28.  *                                   MCI_COPY
  29.  *                                   MCI_PASTE
  30.  *                  mmioGetHeader
  31.  *                  mmioSet
  32.  *                  mmioOpen
  33.  *                  mmioClose
  34.  *
  35.  * Required
  36.  *    Files     :  movie.c        Source Code.
  37.  *                 movie.h        Include file.
  38.  *                 movie.dlg      Dialog definition.
  39.  *                 movie.rc       Resources.
  40.  *                 movie.mak      Make file.
  41.  *                 movie.def      Linker definition file.
  42.  *                 movie.ico      Program icon.
  43.  *                 movie.wav      Program icon.
  44.  *
  45.  * Copyright (C) IBM 1993
  46.  *************************************************************************/
  47.  
  48. #define  INCL_WIN                   /* required to use Win APIs.           */
  49. #define  INCL_PM                    /* required to use PM APIs.            */
  50. #define  INCL_WINHELP               /* required to use IPF.                */
  51. #define  INCL_OS2MM                 /* required for MCI and MMIO headers   */
  52. #define  INCL_MMIOOS2               /* required for MMVIDEOHEADER          */
  53. #define  INCL_MMIO_CODEC            /* required for circular, secondary    */
  54. #define  INCL_SW                    /* required for circular, secondary    */
  55.                                     /* windows and graphic buttons         */
  56. #define  INCL_WINSTDFILE            /* required for open file dlg          */
  57. #define  INCL_WINSTDDLGS            /* required for open file dlg          */
  58.  
  59.  
  60. #include <os2.h>
  61. #include <os2me.h>
  62. #include <stdio.h>
  63. #include <stdlib.h>
  64. #include <string.h>
  65. #include <math.h>
  66. #include <dive.h>
  67.  
  68. #include <sw.h>
  69.  
  70.  
  71. #include "movie.h"
  72.  
  73. enum DeviceStates {ST_STOPPED, ST_PLAYING, ST_PAUSED, ST_REWIND};
  74. /*
  75.  * Procedure/Function Prototypes
  76.  */
  77.  
  78. MRESULT EXPENTRY MainDlgProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 );
  79.  
  80. BOOL    DoesFileExist( PSZ pszFileName );
  81. VOID    Finalize( VOID );
  82. BOOL    Initialize( VOID );
  83. VOID    InitializeHelp( VOID );
  84. USHORT  MessageBox( USHORT usMessageID, ULONG  ulStyle );
  85. BOOL    PlayTheAppFile( HWND hwnd );
  86. BOOL    PlayTheDefaultFile( HWND hwnd );
  87. BOOL    PlayTheMovie( HWND hwnd );
  88. VOID    SetMovieVolume( VOID );
  89. VOID    ShowMCIErrorMessage( ULONG ulError );
  90. VOID    StopTheDevice( VOID );
  91. VOID    ResumeTheMovie( HWND hwnd );
  92. VOID    PauseTheMovie( HWND hwnd );
  93. VOID    CloseTheDevice( VOID );
  94. BOOL    OpenTheDevice( HWND hwnd);
  95. BOOL    EditTheMovie( HWND hwnd );
  96. BOOL    SendString( HWND hwnd, PCHAR pcMCIString, USHORT usUserParm );
  97. VOID    ResizeMovieWindow(HWND hwnd);
  98. VOID    InsertHelpMenuItem (PCHAR );
  99. BOOL    QueryDirectMode(VOID);
  100.  
  101. /*************** End of Procedure/Function Prototypes *************************/
  102.  
  103.   /********************/
  104.   /* Global Variables.*/
  105.   /********************/
  106. HAB    hab;
  107. HMQ    hmq;
  108. HWND   hwndFrame;                      /* Handle to the frame window.         */
  109. HWND   hwndClient;                     /* Handle to the client App window     */
  110. HWND   hwndAppFrame;                   /* Handle to the App frame window      */
  111. HWND   hwndHelpInstance;               /* Handle to Main Help window.         */
  112. HWND   hwndMainDialogBox;              /* Handle to the dialog window.        */
  113. HWND   hwndPlayPB;                     /* Handle to the play push button      */
  114. HWND   hwndRewindPB;                   /* Handle to the rewind push button    */
  115. HWND   hwndStopPB;                     /* Handle to the stop push button      */
  116. HWND   hwndPausePB;                    /* Handle to the pause push button     */
  117. HWND   hwndEditPB;                     /* Handle to the edit push button      */
  118. HWND   hwndApplication;                /* Handle to the Application RB        */
  119. HWND   hwndStandard;                   /* Handle to the Standard RB           */
  120. HWND   hwndVolumeSlider;               /* Handle to the Volume slider         */
  121. ULONG  ulMovieLength;                  /* Length of movie in mmtimeperframe   */
  122. ULONG  ulMovieWidth;                   /* Width of movie                      */
  123. ULONG  ulMovieHeight;                  /* Height of movie                     */
  124. SWP    swpAppFrame;
  125. HMMIO  hFile;                          /* handle to file                      */
  126.  
  127. enum   DeviceStates   eState = ST_STOPPED;      /* state of the device        */
  128.  
  129. SHORT  sVolumeLevel   = INIT_VOLUME;   /* desired volume level                */
  130. BOOL   fAudioOn       = FALSE;         /* Indicates that sound is supported   */
  131. BOOL   fPassedDevice  = FALSE;         /* for MCI_ACQUIRE to play the file    */
  132. BOOL   fDeviceOpen    = FALSE;         /* indicate we've opened for first time*/
  133. BOOL   fMovieLoaded   = FALSE;         /* indicate if we are loaded           */
  134. CHAR   achMsgBoxTitle[MAXNAMEL];       /* Error message box title             */
  135. CHAR   achTitle[MAXNAMEL];             /* buffer for window title text      */
  136.  
  137. CHAR   szReturn[CCHMAXPATH];           /* return value from mciSendString     */
  138. SHORT  sResizeWindow = 0;              /* flag set for resizing the widow     */
  139. SHORT  sKindOfPlay = 0;                /* flag set for which movie is playing */
  140. HPOINTER  hptrWait, hptrArrow;  /* Pointer handles for use during long waits. */
  141.  
  142. /************************** End of Global Variables ***************************/
  143.  
  144. /******************************************************************************
  145.  * Name         : main
  146.  *
  147.  * Description  : This function calls the Initialize procedure to prepare
  148.  *                everything for the program's operation, enters the
  149.  *                message loop, then calls Finalize to shut everything down
  150.  *                when the program is terminated.
  151.  *
  152.  * Concepts     : None.
  153.  *
  154.  * MMPM/2 API's : None.
  155.  *
  156.  * Parameters   : argc - Number of parameters passed into the program.
  157.  *                argv - Command line parameters.
  158.  *
  159.  * Return       : TRUE is returned to the operating system.
  160.  *
  161.  ******************************************************************************/
  162. INT main( VOID )
  163. {
  164.    QMSG    qmsg;
  165.  
  166.  
  167.  
  168.    if( !Initialize() )
  169.    {
  170.    while ( WinGetMsg( hab, (PQMSG) &qmsg, (HWND) NULL, 0, 0) )
  171.       WinDispatchMsg( hab, (PQMSG) &qmsg );
  172.  
  173.    Finalize();
  174.    }
  175.  
  176.    return( TRUE);
  177.  
  178. } /* End of main */
  179.  
  180. /******************************************************************************
  181.  * Name         : Initialize
  182.  *
  183.  * Description  : This function performs the necessary initializations and
  184.  *                setups that are required to show/run a secondary window
  185.  *                as a main window.  The message queue will be created, as will
  186.  *                the dialog box.
  187.  *
  188.  * Concepts     : Illustrates how to use secondary windows
  189.  *
  190.  * MMPM/2 API's : WinLoadSecondaryWindow
  191.  *
  192.  * Parameters   : None.
  193.  *
  194.  * Return       : BOOL, FALSE = success, TRUE = fail
  195.  *
  196.  ******************************************************************************/
  197. BOOL Initialize( VOID)
  198. {
  199.    CHAR     szHelp[CCHMAXPATH];          /* buffer for help menu text         */
  200.    CHAR     szDefaultSize[CCHMAXPATH];   /* buffer for default size menu text */
  201.    LONG     lmciSendStringRC;            /* return code from SendString       */
  202.    LONG     scrwidth,scrheight;          /* Width and height of screen        */
  203.    SWP      swpSEFrame;          /* struc containing information on Frame     */
  204.  
  205.  
  206.  
  207.    hab       = WinInitialize( 0);
  208.    hmq       = WinCreateMsgQueue( hab, 0);
  209.  
  210.  
  211.    /*****************************************************************/
  212.    /* Make sure that Direct Video is supported                      */
  213.    /*****************************************************************/
  214.  
  215.    if (!QueryDirectMode())
  216.    {
  217.       WinMessageBox( HWND_DESKTOP, HWND_DESKTOP,
  218.                     (PSZ)"Direct software motion video mode is not supported on this system.",
  219.                     (PSZ)"Ultieyes - Direct Mode Support Detection",
  220.                     0,
  221.                     MB_CANCEL | MB_ERROR | MB_MOVEABLE );
  222.  
  223.       return( TRUE );
  224.    }
  225.  
  226.  
  227.  
  228.  
  229.    hptrArrow = WinQuerySysPointer ( HWND_DESKTOP, SPTR_ARROW, FALSE );
  230.    hptrWait  = WinQuerySysPointer ( HWND_DESKTOP, SPTR_WAIT,  FALSE );
  231.  
  232.    /*****************************************************************/
  233.    /* Initialize the window. First, change pointer to a waiting     */
  234.    /* pointer, since this might take a couple of seconds.           */
  235.    /*****************************************************************/
  236.  
  237.    WinSetPointer ( HWND_DESKTOP, hptrWait );
  238.  
  239.    WinLoadString(
  240.       hab,                                  /* HAB for this window.           */
  241.       (HMODULE) NULL,                       /* Get the string from the .exe.  */
  242.       IDS_DEFAULTSIZE,                      /* Which string to get.           */
  243.       sizeof(szDefaultSize),                /* The size of the buffer.        */
  244.       szDefaultSize);                       /* The buffer to place the string.*/
  245.  
  246.    WinLoadString(
  247.       hab,                                  /* HAB for this window.           */
  248.       (HMODULE) NULL,                       /* Get the string from the .exe.  */
  249.       IDS_HELP,                             /* Which string to get.           */
  250.       sizeof(szHelp),                       /* The size of the buffer.        */
  251.       szHelp);                              /* The buffer to place the string.*/
  252.  
  253.    WinLoadString(
  254.       hab,                                  /* HAB for this dialog box.       */
  255.       (HMODULE) NULL,                       /* Get the string from the .exe.  */
  256.       IDS_MOVIE_ERROR,                      /* Which string to get.           */
  257.       (SHORT) sizeof( achMsgBoxTitle),      /* The size of the buffer.        */
  258.       achMsgBoxTitle);                      /* The buffer to place the string.*/
  259.  
  260.    hwndFrame =                    /* Returns the handle to the frame.         */
  261.        WinLoadSecondaryWindow(
  262.           HWND_DESKTOP,           /* Parent of the dialog box.                */
  263.           HWND_DESKTOP,           /* Owner of the dialog box.                 */
  264.           (PFNWP) MainDlgProc,    /* 'Window' procedure for the dialog box.   */
  265.           (HMODULE) NULL,         /* Where is the dialog.  Null is EXE file.  */
  266.           IDD_MAIN_WINDOW,        /* Dialog ID.                               */
  267.           (PVOID) NULL);          /* Creation Parameters for the dialog.      */
  268.  
  269.    /***************************************************************************/
  270.    /* Retrieve the handle to the dialog box by specifying the QS_DIALOG flag. */
  271.    /***************************************************************************/
  272.  
  273.    hwndMainDialogBox = WinQuerySecondaryHWND(hwndFrame, QS_DIALOG);
  274.  
  275.    /***************************************************************************/
  276.    /* Add Default Size menu item to system menu of the secondary window.      */
  277.    /***************************************************************************/
  278.  
  279.    WinInsertDefaultSize(hwndFrame, szDefaultSize);
  280.  
  281.    /***************************************************************************/
  282.    /* Add Help menu item to system menu of the secondary window.              */
  283.    /***************************************************************************/
  284.  
  285.    InsertHelpMenuItem(szHelp);
  286.  
  287.    /******************************************************************/
  288.    /* Get the window title string from the Resource string table     */
  289.    /* and set it as the window text for the dialog window.           */
  290.    /******************************************************************/
  291.    WinLoadString(
  292.       hab,                                  /* HAB for this dialog box.       */
  293.       (HMODULE) NULL,                       /* Get the string from the .exe.  */
  294.       IDS_PROGRAM_TITLE,                    /* Which string to get.           */
  295.       (SHORT) sizeof( achTitle),            /* The size of the buffer.        */
  296.       achTitle);                            /* The buffer to place the string.*/
  297.  
  298.    WinSetWindowText( hwndFrame, achTitle);
  299.  
  300.  
  301.    /******************************************************************/
  302.    /* Get the system values for screen width and height and then     */
  303.    /* place the main window appropriately(centered on the screen).   */
  304.    /******************************************************************/
  305.  
  306.    WinQueryWindowPos( HWND_DESKTOP, &swpSEFrame );
  307.    scrwidth  = swpSEFrame.cx;
  308.    scrheight = swpSEFrame.cy;
  309.  
  310.    WinQueryWindowPos( hwndFrame, &swpSEFrame );
  311.    scrwidth  = ceil((scrwidth - swpSEFrame.cx)/2);
  312.    scrheight = ceil((scrheight - swpSEFrame.cy)/2);
  313.  
  314.    WinSetWindowPos(hwndFrame,
  315.                    HWND_TOP,
  316.                    scrwidth,
  317.                    scrheight,
  318.                    swpSEFrame.cx,
  319.                    swpSEFrame.cy,
  320.                    SWP_SIZE | SWP_MOVE);
  321.  
  322.   /*************************************************************************/
  323.   /* Create a new window within our secondary window to play the movie.    */
  324.   /* When playing a movie in this window the Sendstring                    */
  325.   /* function will be passed this windows handle in order to know where    */
  326.   /* to put the movie before playing.                                      */
  327.   /*************************************************************************/
  328.  
  329.     WinRegisterClass(
  330.       hab,
  331.     "MovieWindow",
  332.     (PFNWP) NULL,
  333.     CS_SIZEREDRAW | CS_MOVENOTIFY,
  334.     0 );
  335.  
  336.   hwndAppFrame =  WinCreateWindow((HWND)hwndMainDialogBox,
  337.                                  "MovieWindow",
  338.                                   NULL,
  339.                                   WS_VISIBLE,
  340.                                   0,
  341.                                   0,
  342.                                   0,
  343.                                   0,
  344.                                   (HWND)hwndMainDialogBox,
  345.                                   HWND_TOP, ID_APPWINDOW, NULL, NULL );
  346.  
  347.    WinShowWindow( hwndFrame, TRUE );           /* Display the main window.    */
  348.  
  349.    InitializeHelp();                           /* Initialize the help.        */
  350.  
  351.    /*
  352.     * Now that we're done here, change the pointer back to the arrow.
  353.     */
  354.    WinSetPointer ( HWND_DESKTOP, hptrArrow );
  355.  
  356.    return( FALSE );
  357.  
  358. } /* end initialization */
  359.  
  360. /******************************************************************************
  361.  * Name         : Finalize
  362.  *
  363.  * Description  : This routine is called after the message dispatch loop
  364.  *                has ended because of a WM_QUIT message.  The code will
  365.  *                destroy the help instance, messages queue, and window.
  366.  *
  367.  * Concepts     : None.
  368.  *
  369.  * MMPM/2 API's : WinDestroySecondaryWindow
  370.  *
  371.  * Parameters   : None.
  372.  *
  373.  * Return       : None.
  374.  *
  375.  ******************************************************************************/
  376. VOID Finalize( VOID )
  377. {
  378.    /*
  379.     * Destroy the Help Instances.
  380.     */
  381.    if ( hwndHelpInstance != (HWND) NULL)
  382.    {
  383.       WinDestroyHelpInstance( hwndHelpInstance );
  384.    }
  385.  
  386.    WinDestroySecondaryWindow( hwndFrame );
  387.    WinDestroyMsgQueue( hmq );
  388.    WinTerminate( hab );
  389.  
  390. }  /* End of Finalize */
  391.  
  392. /******************************************************************************
  393.  * Name         : MainDlgProc
  394.  *
  395.  * Description  : This function controls the main dialog box.  It will handle
  396.  *                received messages such as pushbutton notifications, timing
  397.  *                events, etc.
  398.  *
  399.  * Concepts     : Illustrates:
  400.  *                  - How to participate in MMPM/2 device sharing scheme.
  401.  *                  - How to handle notification messages.
  402.  *                  - How to implement graphic pushbutton's
  403.  *                  - How to implement secondary windows.
  404.  *
  405.  * MMPM/2 API's : WinDefSecondaryWindowProc
  406.  *                mciSendString
  407.  *                   - acquire
  408.  *
  409.  * Parameters   : hwnd - Handle for the Main dialog box.
  410.  *                msg  - Message received by the dialog box.
  411.  *                mp1  - Parameter 1 for the just received message.
  412.  *                mp2  - Parameter 2 for the just received message.
  413.  *
  414.  * Return       : 0 or the result of default processing.
  415.  *
  416.  ******************************************************************************/
  417. MRESULT EXPENTRY MainDlgProc( HWND   hwnd,
  418.                               ULONG  msg,
  419.                               MPARAM mp1,
  420.                               MPARAM mp2 )
  421. {
  422.    LONG        lmciSendStringRC;      /* return value form mciSendString      */
  423.    HPOINTER    hpProgramIcon;         /* handle to program's icon             */
  424.    USHORT      usCommandMessage;      /* command message for notify           */
  425.    USHORT      usNotifyCode;          /* notification message code            */
  426.    SHORT       sWmControlID;          /* WM_CONTROL id                        */
  427.    ULONG       ulFrame;               /* video position in frames.            */
  428.    MRESULT     mresult;               /* return result                        */
  429.  
  430.    switch( msg )
  431.    {
  432.       case WM_INITDLG :
  433.          hpProgramIcon =
  434.             WinLoadPointer(
  435.                HWND_DESKTOP,
  436.                (HMODULE) NULL,              /* Resource is kept in .Exe file. */
  437.                ID_ICON );                   /* Which icon to use.             */
  438.  
  439.          WinDefSecondaryWindowProc(
  440.             hwnd,                    /* Dialog window handle.                 */
  441.             WM_SETICON,              /* Message to the dialog.  Set it's icon.*/
  442.             (MPARAM) hpProgramIcon,
  443.             (MPARAM) 0 );            /* mp2 no value.                         */
  444.  
  445.          /*********************************/
  446.          /* get all the required handles. */
  447.          /*********************************/
  448.                                                          /* volume slider     */
  449.          hwndVolumeSlider = WinWindowFromID( hwnd, IDC_VOLUME_SLIDER );
  450.  
  451.                                                          /* play push button  */
  452.  
  453.          hwndPlayPB      = WinWindowFromID( hwnd, IDC_GPB_PLAY );
  454.          hwndRewindPB    = WinWindowFromID( hwnd, IDC_GPB_REWIND );
  455.          hwndStopPB      = WinWindowFromID( hwnd, IDC_GPB_STOP);
  456.          hwndPausePB     = WinWindowFromID( hwnd, IDC_GPB_PAUSE );
  457.  
  458.          hwndEditPB      = WinWindowFromID( hwnd, IDC_GPB_EDIT );
  459.  
  460.                                                          /* application RB    */
  461.          hwndApplication = WinWindowFromID( hwnd, IDC_RADIO1 );
  462.  
  463.          if (!DoesFileExist( "movie.avi" ))
  464.           {
  465.              MessageBox( IDS_CANNOT_FIND_MOVIE_FILE,     /* ID of the message */
  466.                          MB_CANCEL | MB_ERROR  | MB_MOVEABLE);    /* style    */
  467.  
  468.              WinEnableWindow( hwndPlayPB, FALSE );
  469.              WinEnableWindow( hwndEditPB, FALSE );
  470.           }
  471.  
  472.  
  473.          /********************************************************************/
  474.          /*  Check to see if we have audio support                           */
  475.          /*                                                                  */
  476.          /********************************************************************/
  477.  
  478.          lmciSendStringRC =
  479.                SendString(hwnd, "sysinfo all name 1", 0);
  480.  
  481.          if ( strstr( szReturn, "Waveaudio" ) )
  482.          {
  483.             fAudioOn = TRUE;
  484.  
  485.             /********************************************************************/
  486.             /* The slider control cannot be completely set from the dialog      */
  487.             /* template so some aspects must be set here.  We will set the      */
  488.             /* volume range to 0-100, increment 1-10, and set the initial       */
  489.             /* volume level to 100.                                             */
  490.             /********************************************************************/
  491.             WinSendMsg( hwndVolumeSlider,
  492.                         CSM_SETRANGE,
  493.                         (MPARAM) 0L,
  494.                         (MPARAM) 100L);
  495.  
  496.             WinSendMsg( hwndVolumeSlider,
  497.                         CSM_SETINCREMENT,
  498.                         (MPARAM) 10L,
  499.                         (MPARAM) 1L);
  500.  
  501.             WinSendMsg( hwndVolumeSlider,
  502.                         CSM_SETVALUE,
  503.                         (MPARAM) sVolumeLevel,
  504.                         (MPARAM) NULL);
  505.          }
  506.  
  507.             /*****************/
  508.             /* Volume Slider */
  509.             /*****************/
  510.  
  511.             WinEnableWindow( hwndVolumeSlider, TRUE );
  512.  
  513.          /**********************************************/
  514.          /* Set the application window as the default  */
  515.          /**********************************************/
  516.          WinSendMsg(hwndApplication, BM_SETCHECK, MPFROMSHORT(1), NULL);
  517.  
  518.          return( (MRESULT) 0);
  519.  
  520.       case WM_CLOSE :
  521.  
  522.          /*********************************************/
  523.          /* If the device is opened, close the device */
  524.          /*********************************************/
  525.  
  526.          if (fDeviceOpen)
  527.             CloseTheDevice();
  528.  
  529.          return( WinDefSecondaryWindowProc( hwnd, msg, mp1, mp2 ) );
  530.  
  531.  
  532.       /*************************************************************/
  533.       /* This message is recieved when the user changes the volume */
  534.       /* or the radio buttons.                                     */
  535.       /*************************************************************/
  536.  
  537.       case WM_CONTROL:
  538.         sWmControlID  = SHORT1FROMMP(mp1);
  539.         usNotifyCode  = (USHORT) SHORT2FROMMP(mp1);
  540.  
  541.         switch ( sWmControlID )
  542.         {
  543.  
  544.            case IDC_VOLUME_SLIDER:
  545.               if ( ( usNotifyCode == CSN_CHANGED ) ||
  546.                    ( usNotifyCode == CSN_TRACKING ) )
  547.               {
  548.  
  549.                /**************************************************************/
  550.                /*  Every time the volume control setting is changed, save the*/
  551.                /*  new value in sVolumeLevel.                                */
  552.                /**************************************************************/
  553.  
  554.                  sVolumeLevel = SHORT1FROMMP (mp2);
  555.  
  556.                 /*****************************/
  557.                 /*  Set the new volume level */
  558.                 /*****************************/
  559.  
  560.                  SetMovieVolume();
  561.               }
  562.               break;
  563.  
  564.            case IDC_RADIO1:
  565.                     sKindOfPlay = 0;          /* play in application window */
  566.                 break;
  567.  
  568.            case IDC_RADIO2:
  569.                     sKindOfPlay = 1;          /* play in the default window */
  570.                     break;
  571.  
  572.  
  573.         }
  574.  
  575.         return( (MRESULT) 0);
  576.  
  577.       case WM_COMMAND :
  578.  
  579.         /**********************************************************************/
  580.         /* To get which pushbutton was pressed the SHORT1FROMMP macro is used.*/
  581.         /**********************************************************************/
  582.  
  583.          switch (SHORT1FROMMP(mp1))
  584.          {
  585.             case IDC_GPB_PLAY:               /* user selected "Play"        */
  586.  
  587.                switch ( eState )
  588.                {
  589.                   /**********************************************************/
  590.                   /* If the Movie is currently stopped, check to see if we  */
  591.                   /* were playing. if we were then resume.                  */
  592.                   /**********************************************************/
  593.                   case ST_STOPPED:
  594.  
  595.                     /****************************************************/
  596.                     /* Open the movie, resize the window if needed for  */
  597.                     /* the movie, then start playing.                   */
  598.                     /****************************************************/
  599.                      if (!fDeviceOpen)
  600.                        {
  601.                          OpenTheDevice ( hwnd );
  602.                        } /* if */
  603.                      if(sResizeWindow == 0 )
  604.                        {
  605.                          ResizeMovieWindow(hwnd);
  606.                          sResizeWindow = 1;
  607.                        }
  608.                      PlayTheMovie( hwnd );
  609.                      break;
  610.  
  611.                   /******************************************************/
  612.                   /* If the Movie is currently paused, resume the Movie */
  613.                   /******************************************************/
  614.                   case ST_PAUSED:
  615.                      ResumeTheMovie(hwnd);
  616.                      break;
  617.  
  618.                   case ST_REWIND:
  619.                      PlayTheMovie(hwnd);
  620.                      break;
  621.                }
  622.                break;
  623.  
  624.             case IDC_GPB_PAUSE:
  625.                switch ( eState )
  626.                {
  627.                  /************************************************/
  628.                  /* If the Movie is currently playing, pause it. */
  629.                  /************************************************/
  630.  
  631.                  case ST_PLAYING:
  632.                     PauseTheMovie(hwnd);
  633.                     break;
  634.  
  635.                  /***********************************************************/
  636.                  /* If the Movie is currently paused, resume the Movie play.*/
  637.                  /***********************************************************/
  638.  
  639.                  case ST_PAUSED:
  640.                     ResumeTheMovie(hwnd);
  641.                     break;
  642.                }
  643.               break;
  644.  
  645.             case IDC_GPB_REWIND:         /* User selected "Rewind" pushbutton */
  646.                if (fDeviceOpen)          /* If the device is opened.          */
  647.                  {
  648.                   eState = ST_REWIND;
  649.                   lmciSendStringRC =
  650.                             SendString(hwnd, "seek movie to start notify", 0);
  651.                  }
  652.                break;
  653.  
  654.             case IDC_GPB_EDIT:           /* User selected "Edit" pushbutton. */
  655.                  {
  656.                  MessageBox( IDS_EDIT_MOVIE,
  657.                              MB_OK | MB_INFORMATION  | MB_MOVEABLE);
  658.                  if (!fDeviceOpen)     /* check to see if the device is open.*/
  659.                    {
  660.                      OpenTheDevice ( hwnd );
  661.                    } /* if */
  662.                                        /* Stop the device if we are in a */
  663.                                        /* playing or paused state.       */
  664.                  if ((eState == ST_PLAYING) || (eState == ST_PAUSED))
  665.                    {
  666.                      StopTheDevice();
  667.                    } /* if */
  668.                   /*****************************************************/
  669.                   /* This function illustrates the cut, copy and paste */
  670.                   /* functionality.                                    */
  671.                   /*****************************************************/
  672.                   EditTheMovie(hwnd);
  673.  
  674.                  }
  675.                break;
  676.  
  677.             case IDC_GPB_STOP:         /* user selected "Stop" pushbutton */
  678.  
  679.                /***********************************************************/
  680.                /* If the Movie is not in stopped state, stop the device.  */
  681.                /***********************************************************/
  682.  
  683.                if (eState != ST_STOPPED)
  684.                  {
  685.                     StopTheDevice();
  686.                  }
  687.                break;
  688.  
  689.             case WM_HELP:      /* User selected "Help" from System menu   */
  690.  
  691.        /*********************************************************************/
  692.        /* The dialog window has received a request for help from the user.  */
  693.        /* Send the HM_DISPLAY_HELP message to the Help Instance with the IPF*/
  694.        /* resource identifier for the correct HM panel.  This will show the */
  695.        /* help panel for this sample program.                               */
  696.        /*********************************************************************/
  697.  
  698.          WinSendMsg( hwndHelpInstance,
  699.                      HM_DISPLAY_HELP,
  700.                      MPFROMSHORT(1),
  701.                      MPFROMSHORT(HM_RESOURCEID));
  702.  
  703.                break;
  704.  
  705.             default:
  706.                break;
  707.  
  708.          }  /* End of Command Switch */
  709.  
  710.          return( (MRESULT) 0);
  711.  
  712.       /**********************************************************************/
  713.       /* The next two messages are handled so that this application can     */
  714.       /* participate in device sharing.  Since it opens the device as a     */
  715.       /* shareable device, other applications can gain control of the       */
  716.       /* device.  When this happens, we will receive a MM_MCIPASSDEVICE     */
  717.       /* message.  We keep track of this device passing in the              */
  718.       /* fPassedDevice Boolean variable.                                    */
  719.       /*                                                                    */
  720.       /* We use the WM_ACTIVATE message to participate in device            */
  721.       /* sharing.  We first check to see if this is an activate             */
  722.       /* or a deactivate message (indicated by mp1).  Then,                 */
  723.       /* we check to see if we've passed control of the                     */
  724.       /* devices.  If these conditions are true, then                       */
  725.       /* we issue an acquire device command to regain control of            */
  726.       /* the device, since we're now the active window on the screen.       */
  727.       /*                                                                    */
  728.       /* This is one possible method that can be used to implement          */
  729.       /* device sharing. For applications that are more complex             */
  730.       /* than this sample program, developers may wish to take              */
  731.       /* advantage of a more robust method of device sharing.               */
  732.       /* This can be done by using the MCI_ACQUIRE_QUEUE flag on            */
  733.       /* the MCI_ACQUIREDEVICE command.  Please refer to the MMPM/2         */
  734.       /* documentation for more information on this flag.                   */
  735.       /**********************************************************************/
  736.  
  737.       case MM_MCIPASSDEVICE:
  738.          if (SHORT1FROMMP(mp2) == MCI_GAINING_USE)           /* GAINING USE */
  739.            {
  740.              fPassedDevice = FALSE;            /* Gaining control of device.*/
  741.            }
  742.          else                                               /* Losing use   */
  743.            {
  744.              fPassedDevice = TRUE;             /* Losing  control of device.*/
  745.            }
  746.          return( WinDefSecondaryWindowProc( hwnd, msg, mp1, mp2 ) );
  747.  
  748.       case WM_ACTIVATE:
  749.  
  750.        /*********************************************************************/
  751.        /* We use the WM_ACTIVATE message to participate in device sharing.  */
  752.        /* We first check to see if this is an activate or a deactivate      */
  753.        /* message (indicated by mp1).  Then, we check to see if we've passed*/
  754.        /* control of the Movie device.  If these conditions are true,       */
  755.        /* then we issue an acquire device command to regain control of      */
  756.        /* the device, since we're now the active window on the screen.      */
  757.        /*********************************************************************/
  758.          if ((BOOL)mp1 && fPassedDevice == TRUE)
  759.          {
  760.            /***********************************************************/
  761.            /* To acquire the device, we will issue MCI_ACQUIREDEVICE  */
  762.            /* command to the MCI.                                     */
  763.            /***********************************************************/
  764.  
  765.             SendString( hwnd, "acquire movie notify", 0 );
  766.          }
  767.          return( WinDefSecondaryWindowProc( hwnd, msg, mp1, mp2 ) );
  768.  
  769.       case MM_MCINOTIFY:
  770.  
  771.        /***********************************************************************/
  772.        /* This message is returned to an application when a device            */
  773.        /* successfully completes a command that was issued with a NOTIFY      */
  774.        /* flag, or when an error occurs with the command.                     */
  775.        /*                                                                     */
  776.        /* This message returns two values. A user parameter (mp1) and         */
  777.        /* the command message (mp2) that was issued. The low word of mp1      */
  778.        /* is the Notification Message Code which indicates the status of the  */
  779.        /* command like success or failure. The high word of mp2 is the        */
  780.        /* Command Message which indicates the source of the command.          */
  781.        /***********************************************************************/
  782.  
  783.          usNotifyCode    = (USHORT) SHORT1FROMMP( mp1);  /* low-word  */
  784.          usCommandMessage = (USHORT) SHORT2FROMMP( mp2); /* high-word */
  785.  
  786.          switch (usCommandMessage)
  787.          {
  788.             case MCI_PLAY:
  789.                switch (usNotifyCode)
  790.                {
  791.                   case MCI_NOTIFY_SUPERSEDED:
  792.                   case MCI_NOTIFY_ABORTED:
  793.  
  794.                      /* we don't need to handle these messages. */
  795.                      break;
  796.  
  797.                   /********************************************************/
  798.                   /* This case is used for either successful completion   */
  799.                   /* of a command or for an error.                        */
  800.                   /********************************************************/
  801.  
  802.                   default:
  803.                    if (eState != ST_STOPPED)
  804.                      {
  805.                         eState = ST_STOPPED;
  806.                         if ( usNotifyCode != MCI_NOTIFY_SUCCESSFUL)
  807.  
  808.                            /*************************************************/
  809.                            /* Notification error message. We need to display*/
  810.                            /* the error message to the user.                */
  811.                            /*************************************************/
  812.  
  813.                            ShowMCIErrorMessage( usNotifyCode);
  814.                            fMovieLoaded = FALSE;
  815.  
  816.                      }
  817.  
  818.                     break;
  819.                }
  820.                break;
  821.          }
  822.          return( (MRESULT) 0);
  823.  
  824.       default:
  825.          return( WinDefSecondaryWindowProc( hwnd, msg, mp1, mp2));
  826.  
  827.    }  /* End of msg Switch */
  828.  
  829. } /* End of MainDlgProc */
  830.  
  831. /******************************************************************************
  832.  * Name         :  PlayTheAppFile
  833.  *
  834.  * Description  :  This procedure will load a specific movie file into the
  835.  *                 application defined video window.
  836.  *
  837.  * Concepts     :  - Playing a movie in a application defined window.
  838.  *                   in a device independent manner.
  839.  *                 - Loading a file into an already open device.
  840.  *
  841.  * MMPM/2 API's :  mciSendString
  842.  *                    - load
  843.  *                    - put
  844.  *                    - window handle
  845.  *
  846.  * Parameters   :  hwnd  - Handle for the main window.
  847.  *
  848.  * Return       :  TRUE  -  if the operation was initiated without error.
  849.  *                 FALSE -  if an error occurred.
  850.  *
  851.  ******************************************************************************/
  852. BOOL PlayTheAppFile( HWND hwnd )
  853. {
  854.    LONG    lmciSendStringRC;         /* return code from SendString           */
  855.  
  856.    CHAR    szHandle[10] = "";        /* string used for window handle         */
  857.    CHAR    szx[5]       = "";        /* string used for x position of window  */
  858.    CHAR    szy[5]       = "";        /* string used for y position of window  */
  859.    CHAR    szcx[5]      = "";        /* string used for cx position of window */
  860.    CHAR    szcy[5]      = "";        /* string used for cy position of window */
  861.  
  862.    /*******************************************************************/
  863.    /* The szWindowString and szPutString are used as a foundation     */
  864.    /* for building a string command to send to sendstring             */
  865.    /*******************************************************************/
  866.  
  867.    CHAR    szWindowString[CCHMAXPATH] =
  868.              "window movie handle ";      /* string command to mciSendString */
  869.  
  870.    CHAR    szPutString[CCHMAXPATH] =
  871.             "put movie destination at ";  /* string command to mciSendString */
  872.  
  873.    /**********************************************************************/
  874.    /* Change pointer to a waiting pointer first, since this might take a */
  875.    /* couple of seconds.                                                 */
  876.    /**********************************************************************/
  877.  
  878.    WinSetPointer( HWND_DESKTOP, hptrWait );
  879.  
  880.    /******************************************************/
  881.    /* Convert the Frame window handle to a string so     */
  882.    /* we can use the mciSendStringCommand.               */
  883.    /******************************************************/
  884.  
  885.    hwndAppFrame    = WinWindowFromID( hwnd, ID_APPWINDOW );
  886.  
  887.    _ultoa(hwndAppFrame,szHandle,10);
  888.  
  889.  
  890.    /*****************************************/
  891.    /* Concatenate the converted handle to   */
  892.    /* the window string so we can issue the */
  893.    /* send string command.                  */
  894.    /*****************************************/
  895.    strcat (szWindowString, szHandle);
  896.    strcat (szWindowString, " ");
  897.    strcat (szWindowString, "wait");
  898.  
  899.    /* Send the window handle to the alias window */
  900.    lmciSendStringRC = SendString(hwnd, szWindowString, 0);
  901.  
  902.    /* Load the movie if it needs to be loaded */
  903.  
  904.    if (!fMovieLoaded)
  905.      {
  906.        if (lmciSendStringRC = SendString(hwnd, "load movie movie.avi wait", 0))
  907.          {
  908.            fMovieLoaded = TRUE;
  909.          }
  910.        else
  911.          {
  912.            MessageBox( IDS_CANNOT_LOAD_MOVIE_FILE,
  913.                        MB_CANCEL | MB_ERROR  | MB_MOVEABLE);
  914.            return( FALSE );
  915.          } /* else */
  916.  
  917.      } /* if */
  918.  
  919.    /******************************************************/
  920.    /* Convert the frame windows sizes to strings so      */
  921.    /* we can use the mciSendStringCommand to put the     */
  922.    /* video in our application frame window.             */
  923.    /******************************************************/
  924.  
  925.      WinQueryWindowPos (hwndAppFrame, &swpAppFrame);
  926.  
  927.        swpAppFrame.x = 0;
  928.        swpAppFrame.y = 0;
  929.  
  930.      /**********************************************************/
  931.      /* convert the application windows coordinates to strings */
  932.      /* so we can issue the the sendstring command             */
  933.      /**********************************************************/
  934.      _ultoa(swpAppFrame.x,szx,10);
  935.      _ultoa(swpAppFrame.y,szy,10);
  936.      _ultoa(swpAppFrame.cx,szcx,10);
  937.      _ultoa(swpAppFrame.cy,szcy,10);
  938.  
  939.      /**********************************************************/
  940.      /* concatenate the converted strings to the the put string*/
  941.      /* so we can issue the the sendstring command             */
  942.      /**********************************************************/
  943.  
  944.      strcat (szPutString, szx);
  945.      strcat (szPutString, " ");
  946.      strcat (szPutString, szy);
  947.      strcat (szPutString, " ");
  948.      strcat (szPutString, szcx);
  949.      strcat (szPutString, " ");
  950.      strcat (szPutString, szcy);
  951.      strcat (szPutString, " ");
  952.      strcat (szPutString, "wait");
  953.  
  954.    /* Send the put command along with the window coordinates. */
  955.  
  956.      lmciSendStringRC = SendString( hwnd, szPutString, 0 );
  957.  
  958.    /******************************************************************/
  959.    /* Now that we're done here, change the pointer back to the arrow.*/
  960.    /******************************************************************/
  961.    WinSetPointer ( HWND_DESKTOP, hptrArrow );
  962.  
  963.    return( TRUE );
  964.  
  965. }  /* end of PlayTheAppFile */
  966.  
  967. /******************************************************************************
  968.  * Name         :  PlayTheDefaultFile
  969.  *
  970.  * Description  :  This procedure will load a specific movie file into
  971.  *                 the applications default video window.  Default video
  972.  *                 window will appear in the lower left origin of the screen.
  973.  *
  974.  *
  975.  * Concepts     :  - Playing a movie in the default window in a device
  976.  *                   independent manner.
  977.  *                 - Loading a file into an already open device.
  978.  *
  979.  * MMPM/2 API's :  mciSendString
  980.  *                    - load
  981.  *
  982.  * Parameters   :  hwnd  - Handle for the Main dialog box.
  983.  *
  984.  * Return       :  TRUE  -  if the operation was initiated without error.
  985.  *                 FALSE -  if an error occurred.
  986.  *
  987.  ******************************************************************************/
  988. BOOL PlayTheDefaultFile( HWND hwnd )
  989. {
  990.    LONG    lmciSendStringRC;            /* return code from SendString   */
  991.  
  992.    /**********************************************************************/
  993.    /* Change pointer to a waiting pointer first, since this might take a */
  994.    /* couple of seconds.                                                 */
  995.    /**********************************************************************/
  996.  
  997.    WinSetPointer( HWND_DESKTOP, hptrWait );
  998.  
  999.    if (!fMovieLoaded)
  1000.      {
  1001.        if (lmciSendStringRC = SendString(hwnd, "load movie movie.avi wait", 0))
  1002.          {
  1003.            fMovieLoaded = TRUE;
  1004.          }
  1005.        else
  1006.          {
  1007.            MessageBox( IDS_CANNOT_LOAD_MOVIE_FILE,
  1008.                        MB_CANCEL | MB_ERROR  | MB_MOVEABLE);
  1009.            return( FALSE );
  1010.          } /* else */
  1011.      } /* if */
  1012.  
  1013.  
  1014.    /* Send the window command to play the movie in the default window. */
  1015.    SendString(hwnd,"window movie handle default wait", 0 );
  1016.  
  1017.    /******************************************************************/
  1018.    /* Now that we're done here, change the pointer back to the arrow.*/
  1019.    /******************************************************************/
  1020.    WinSetPointer ( HWND_DESKTOP, hptrArrow );
  1021.  
  1022.    return( TRUE );
  1023.  
  1024. }  /* end of PlayTheDefaultFile */
  1025.  
  1026. /*************************************************************************
  1027.  * Name         :  PlayTheMovie
  1028.  *
  1029.  * Description  :  This procedure will begin playing a movie file.
  1030.  *                 It is invoked when the user selects the Play pushbutton
  1031.  *                 on the application's main window.  The movie will be
  1032.  *                 played in either a application defined window or in a
  1033.  *                 default window depending on the state of the radio buttons.
  1034.  *
  1035.  *
  1036.  * Concepts     :  Playing a movie file using the MCI interface.
  1037.  *
  1038.  * MMPM/2 API's :  mciSendString
  1039.  *                    - play
  1040.  *
  1041.  * Parameters   :  hwnd - Handle for the main dialog box.
  1042.  *
  1043.  * Return       :  TRUE  -  if the operation was initiated without error.
  1044.  *                 FALSE -  if an error occurred.
  1045.  *
  1046.  ******************************************************************************/
  1047. BOOL PlayTheMovie( HWND hwnd)
  1048. {
  1049.  
  1050.    /*******************************************/
  1051.    /* Check to see which window we want to    */
  1052.    /* play the movie in.                      */
  1053.    /*******************************************/
  1054.  
  1055.    if (WinSendMsg(hwndApplication, BM_QUERYCHECK, NULL,NULL ))
  1056.      {
  1057.        /* Play the movie in the application window */
  1058.        if (!PlayTheAppFile(hwnd))
  1059.          {
  1060.            return (FALSE);
  1061.          }
  1062.  
  1063.      } /* if */
  1064.    else
  1065.      {
  1066.        /* Play the movie in the default window */
  1067.        if (!PlayTheDefaultFile(hwnd))
  1068.          {
  1069.            return( FALSE );
  1070.          } /* if */
  1071.      }
  1072.  
  1073.    eState = ST_PLAYING;                      /* set state to PLAYING         */
  1074.  
  1075.    SetMovieVolume();                         /* set the starting volume      */
  1076.  
  1077.    /**************************************************************************/
  1078.    /* To play the movie, we will issue an MCI_PLAY command via mciSendString.*/
  1079.    /* A MM_MCINOTIFY message will be sent to the window specified in         */
  1080.    /* SendString when the operation is completed.                            */
  1081.    /**************************************************************************/
  1082.    SendString( hwnd,"play movie notify", 0 );
  1083.  
  1084.    return( TRUE );
  1085.  
  1086. }  /* end of PlayTheMovie */
  1087.  
  1088. /*************************************************************************
  1089.  * Name         :  ResumeTheMovie
  1090.  *
  1091.  * Description  :  This procedure will resume the playing of the movie
  1092.  *                 once it has been paused.
  1093.  *
  1094.  * Concepts     :  Resuming the movie using MCI interface.
  1095.  *
  1096.  * MMPM/2 API's :  mciSendString
  1097.  *                    - resume
  1098.  *
  1099.  * Parameters   :  hwnd - window handle
  1100.  *
  1101.  * Return       :  none.
  1102.  *
  1103.  *************************************************************************/
  1104. VOID ResumeTheMovie( HWND hwnd)
  1105. {
  1106.      /*********************************************/
  1107.      /* Check to see which pushbutton is selected.*/
  1108.      /*********************************************/
  1109.  
  1110.       if (!WinSendMsg(hwndApplication, BM_QUERYCHECK, NULL, NULL))
  1111.         {
  1112.           PlayTheDefaultFile(hwnd);
  1113.         } /* if */
  1114.       else
  1115.         {
  1116.           PlayTheAppFile(hwnd);
  1117.         } /* else */
  1118.  
  1119.    /*******************************************************************/
  1120.    /* To resume the movie, we will issue an MCI_RESUME command via    */
  1121.    /* MciSendString.                                                  */
  1122.    /*******************************************************************/
  1123.    if (SendString( (HWND)NULL, "resume movie wait", 0 ) )
  1124.      {
  1125.        eState = ST_PLAYING;
  1126.        SetMovieVolume();
  1127.      }
  1128.  
  1129.    return;
  1130. }  /* End of ResumeTheMovie */
  1131.  
  1132. /******************************************************************************
  1133.  * Name         :  PauseTheMovie
  1134.  *
  1135.  * Description  :  This procedure will pause the playing of the movie that
  1136.  *                 that is currently playing.
  1137.  *
  1138.  * Concepts     :  Pausing the movie using MCI interface.
  1139.  *
  1140.  * MMPM/2 API's :  mciSendString
  1141.  *                    - pause
  1142.  *
  1143.  * Parameters   :  hwnd - window handle
  1144.  *
  1145.  * Return       :  none.
  1146.  *
  1147.  ******************************************************************************/
  1148. VOID PauseTheMovie( HWND hwnd)
  1149. {
  1150.  
  1151.   USHORT sCheckState;
  1152.  
  1153.    /*******************************************************************/
  1154.    /* To pause the movie, we will issue an MCI_PAUSE command via      */
  1155.    /* MciSendString.                                                  */
  1156.    /*******************************************************************/
  1157.  
  1158.    if ( SendString( (HWND)NULL, "pause movie wait", 0 ) )
  1159.     {
  1160.        eState = ST_PAUSED;
  1161.     }
  1162.  
  1163.    return;
  1164. }  /* end of PauseTheMovie */
  1165.  
  1166. /******************************************************************************
  1167.  * Name         :  StopTheDevice
  1168.  *
  1169.  * Description  :  This procedure will stop the device that is playing.
  1170.  *
  1171.  * Concepts     :  Stopping a device using the MCI interface.
  1172.  *
  1173.  * MMPM/2 API's :  mciSendString
  1174.  *                    - stop
  1175.  *
  1176.  * Parameters   :  none
  1177.  *
  1178.  * Return       :  nothing.
  1179.  *
  1180.  *****************************************************************************/
  1181. VOID StopTheDevice( VOID )
  1182. {
  1183.  
  1184.  /****************************************************************************/
  1185.  /* To stop the device , we will issue an string command using mciSendString.*/
  1186.  /* This stop command is done for the alias.                                 */
  1187.  /****************************************************************************/
  1188.  
  1189.    if (SendString( (HWND)NULL, "stop movie wait", 0 ) )
  1190.    {
  1191.       if (eState == ST_PLAYING)
  1192.         {
  1193.           eState = ST_STOPPED;
  1194.         }
  1195.    }
  1196.  
  1197.    return;
  1198. }  /* end of StopTheDevice */
  1199.  
  1200.  
  1201. /*************************************************************************
  1202.  * Name         :  CloseTheDevice
  1203.  *
  1204.  * Description  :  This procedure will close the Movie device.
  1205.  *
  1206.  * Concepts     :  Closing a device using MCI interface.
  1207.  *
  1208.  * MMPM/2 API's :  mciSendString
  1209.  *                    - close
  1210.  *
  1211.  * Parameters   :  None.
  1212.  *
  1213.  * Return       :  nothing.
  1214.  *
  1215.  *****************************************************************************/
  1216. VOID CloseTheDevice( VOID)
  1217. {
  1218.  
  1219.  /****************************************************************************/
  1220.  /* To close the device , we will issue a string command using mciSendString.*/
  1221.  /* This close command is done for the alias.                                */
  1222.  /****************************************************************************/
  1223.  
  1224.    fDeviceOpen = FALSE;
  1225.    fMovieLoaded = FALSE;
  1226.    SendString((HWND)NULL, "close movie wait", 0 );
  1227.  
  1228.    return;
  1229.  
  1230. }  /* end of CloseTheDevice */
  1231.  
  1232. /*************************************************************************
  1233.  * Name         :  OpenTheDevice
  1234.  *
  1235.  * Description  :  This procedure will open the Movie device.
  1236.  *
  1237.  * Concepts     :  Opening a device using MCI interface.
  1238.  *
  1239.  * MMPM/2 API's :  mciSendString
  1240.  *                    - open
  1241.  *
  1242.  * Parameters   :  hwnd - window handle
  1243.  *
  1244.  * Return       :  None
  1245.  *
  1246.  *****************************************************************************/
  1247. BOOL OpenTheDevice( HWND hwnd)
  1248. {
  1249.   if (!fDeviceOpen )
  1250.  
  1251.   {
  1252.      /******************************************************************/
  1253.      /* To open the device, we will issue MCI_OPEN command to the MCI  */
  1254.      /* for digital video.                                             */
  1255.      /******************************************************************/
  1256.      if ( SendString( hwnd,
  1257.                       "open digitalvideo alias movie wait shareable",
  1258.                       0 ) )
  1259.  
  1260.      {
  1261.         /* Open success, set the flag and return true */
  1262.  
  1263.         fDeviceOpen = TRUE;
  1264.  
  1265.         return(TRUE);
  1266.  
  1267.      }
  1268.      else
  1269.         return( FALSE );
  1270.   }
  1271.  
  1272. }  /* end of OpenTheDevice */
  1273.  
  1274. /*************************************************************************
  1275.  * Name         :  EditTheMovie
  1276.  *
  1277.  * Description  :  This procedure will edit the movie file in the following
  1278.  *                 manner:  first we will load the movie, then set the data
  1279.  *                 format to frames.  The next thing we do is copy the first
  1280.  *                 25 frames which places these frames into the clipboard.
  1281.  *                 Then paste the 25 frames 4 times, which actually duplicates
  1282.  *                 our first 25 frames 4 times.  The last step is to cut the
  1283.  *                 first 10 frames from the movie which places them in the
  1284.  *                 clipboard then seek to the end of the movie and paste them
  1285.  *                 to the end.  The cut API actually deletes the specified
  1286.  *                 number of frames from the position you specified the cut.
  1287.  *
  1288.  * Concepts     :  Editing a movie using the MCI string interface.
  1289.  *
  1290.  * MMPM/2 API's :  mciSendString
  1291.  *                    - cut
  1292.  *                    - copy
  1293.  *                    - paste
  1294.  *
  1295.  * Parameters   :  hwnd - window handle
  1296.  *
  1297.  * Return       :  nothing.
  1298.  *
  1299.  ******************************************************************************/
  1300. BOOL EditTheMovie( HWND hwnd)
  1301. {
  1302.    LONG    lmciSendStringRC;            /* return code from SendString */
  1303.  
  1304.  /**********************************************************************/
  1305.  /* Change pointer to a waiting pointer first, since this might take a */
  1306.  /* couple of seconds.                                                 */
  1307.  /**********************************************************************/
  1308.    WinSetPointer ( HWND_DESKTOP, hptrWait );
  1309.  
  1310.    if (!fMovieLoaded)   /* If the movie is not loaded then load it */
  1311.      {
  1312.        if (lmciSendStringRC = SendString(hwnd, "load movie movie.avi wait", 0))
  1313.          {
  1314.            fMovieLoaded = TRUE;
  1315.          }
  1316.        else
  1317.          {
  1318.            MessageBox( IDS_CANNOT_LOAD_MOVIE_FILE,
  1319.                        MB_CANCEL | MB_ERROR  | MB_MOVEABLE);
  1320.            return( FALSE );
  1321.          } /* else */
  1322.      } /* if */
  1323.  
  1324.    /* Seek to the beginning of the movie */
  1325.    lmciSendStringRC = SendString(hwnd, "seek movie to start notify", 0);
  1326.  
  1327.  /********************************************************************/
  1328.  /* Before we start editing, change the data format to frames. Frame */
  1329.  /* format is sometimes easier to work with.                         */
  1330.  /********************************************************************/
  1331.    lmciSendStringRC = SendString( hwnd, "set movie time format frames wait",
  1332.                                   0 );
  1333.  
  1334.  /***********************************************************/
  1335.  /* copy the first 25 frames. The copy will place the       */
  1336.  /* data into the clipboard.                                */
  1337.  /***********************************************************/
  1338.  
  1339.    lmciSendStringRC = SendString(hwnd,"copy movie from 1 to 25 wait", 0);
  1340.  
  1341.  /*******************************************************************/
  1342.  /* Paste our information we just copied.  We will paste the 25     */
  1343.  /* frames 4 times which will duplciate what we have just copied.   */
  1344.  /* The paste will start at the current frame of the movie.         */
  1345.  /*******************************************************************/
  1346.  
  1347.    lmciSendStringRC = SendString(hwnd, "paste movie from 25 wait", 0);
  1348.  
  1349.    lmciSendStringRC = SendString(hwnd, "paste movie from 25 wait", 0);
  1350.  
  1351.    lmciSendStringRC = SendString(hwnd, "paste movie from 25 wait", 0);
  1352.  
  1353.    lmciSendStringRC = SendString(hwnd, "paste movie from 25 wait", 0);
  1354.  
  1355.  /******************************************/
  1356.  /* Cut the first 10 frames from the movie.*/
  1357.  /* This will delete the first 10 frames.  */
  1358.  /******************************************/
  1359.  
  1360.    lmciSendStringRC = SendString(hwnd, "cut movie from 1 to 25 wait", 0);
  1361.  
  1362.  /******************************************/
  1363.  /* Seek to the end of the movie so we can */
  1364.  /* paste the first 25 frames to the end.  */
  1365.  /******************************************/
  1366.  
  1367.    lmciSendStringRC = SendString(hwnd, "seek movie to end wait", 0);
  1368.  
  1369.    lmciSendStringRC = SendString(hwnd, "paste movie wait",0);
  1370.  
  1371.  /*******************************************************************/
  1372.  /* Seek to the beginning of the file so we can be ready to play.   */
  1373.  /*******************************************************************/
  1374.  
  1375.    lmciSendStringRC = SendString(hwnd, "seek movie to start notify", 0);
  1376.  
  1377.  /******************************************************************/
  1378.  /* Now that we're done here, change the pointer back to the arrow.*/
  1379.  /******************************************************************/
  1380.  
  1381.    WinSetPointer ( HWND_DESKTOP, hptrArrow );
  1382.  
  1383. }  /* end of EditTheMovie */
  1384.  
  1385.  
  1386.  
  1387. /*************************************************************************
  1388.  * Name         :  SendString
  1389.  *
  1390.  * Description  :  This procedure will send string to MCI.
  1391.  *
  1392.  * Concepts     :  Sending a string command using the mciSendString interface.
  1393.  *
  1394.  * MMPM/2 API's :  mciSendString
  1395.  *
  1396.  * Parameters   :  hwnd        - window handle.
  1397.  *                 pcMCIString - string command.
  1398.  *                 usUserParm  - user parameter.
  1399.  *
  1400.  * Return       :  TRUE  - if the operation was initiated without error.
  1401.  *                 FALSE - if an error occurred.
  1402.  *
  1403.  ******************************************************************************/
  1404. BOOL  SendString( HWND hwnd, PCHAR pcMCIString, USHORT usUserParm )
  1405. {
  1406.    LONG           lmciSendStringRC;    /* return value fromm mciSendString    */
  1407.  
  1408.  
  1409.    lmciSendStringRC =
  1410.        mciSendString( (PSZ)pcMCIString,
  1411.                       (PSZ)szReturn,
  1412.                       (USHORT)CCHMAXPATH,
  1413.                       (HWND)hwnd,
  1414.                       (USHORT)usUserParm );
  1415.  
  1416.    if (lmciSendStringRC != 0)
  1417.    {
  1418.       ShowMCIErrorMessage(lmciSendStringRC);
  1419.       return( FALSE );
  1420.    }
  1421.  
  1422.    return( TRUE );
  1423. }
  1424.  
  1425.  
  1426. /******************************************************************************
  1427.  * Name         :  MessageBox
  1428.  *
  1429.  * Description  :  This procedure will display messages for the application
  1430.  *                 based upon string IDs passed in.  The actual text will be
  1431.  *                 loaded from the string table in the resource.
  1432.  *
  1433.  * Concepts     :  None.
  1434.  *
  1435.  * MMPM/2 API's :  None.
  1436.  *
  1437.  * Parameters   :  usMessageID - ID of the message string
  1438.  *                 ulStyle     - Style of the message box (WinMessageBox)
  1439.  *
  1440.  * Return       :  TRUE  -  if the operation was initiated without error.
  1441.  *                 FALSE -  if an error occurred.
  1442.  *
  1443.  ******************************************************************************/
  1444. USHORT MessageBox( USHORT usMessageID, ULONG  ulStyle)
  1445. {
  1446.    CHAR     achMessage[LEN_ERROR_MESSAGE];
  1447.    USHORT   usResult;
  1448.  
  1449.    /***************************************************************************/
  1450.    /* Get the string from the Resource defined string table and show it       */
  1451.    /* in the message box.                                                     */
  1452.    /***************************************************************************/
  1453.    WinLoadString(
  1454.       hab,                             /* HAB for this dialog box.            */
  1455.       (HMODULE) NULL,                  /* Get the string from the .exe file.  */
  1456.       usMessageID,                     /* Which string to get.                */
  1457.       (SHORT) sizeof( achMessage),     /* The size of the buffer.             */
  1458.       achMessage );                    /* The buffer to place the string.     */
  1459.  
  1460.    if ( !(ulStyle & MB_INFORMATION) )
  1461.       {
  1462.       usResult =
  1463.          WinMessageBox(
  1464.             HWND_DESKTOP,              /* Parent handle of the message box.   */
  1465.             hwndMainDialogBox,         /* Owner handle of the message box.    */
  1466.             achMessage,                /* String to show in the message box.  */
  1467.             achMsgBoxTitle,            /* Title to shown in the message box.  */
  1468.             (USHORT) ID_MESSAGEBOX,    /* Message Box Id.                     */
  1469.             ulStyle );                 /* The style of the message box.       */
  1470.       }
  1471.    else
  1472.       {
  1473.       usResult =
  1474.          WinMessageBox(
  1475.             HWND_DESKTOP,              /* Parent handle of the message box.   */
  1476.             hwndMainDialogBox,         /* Owner handle of the message box.    */
  1477.             achMessage,                /* String to show in the message box.  */
  1478.             achTitle,                  /* Title to shown in the message box.  */
  1479.             (USHORT) ID_MESSAGEBOX,    /* Message Box Id.                     */
  1480.             ulStyle );                 /* The style of the message box.       */
  1481.       }
  1482.  
  1483.    return( usResult );
  1484.  
  1485. }  /* End of MessageBox */
  1486.  
  1487.  
  1488. /******************************************************************************
  1489.  * Name         :  ShowMCIErrorMessage
  1490.  *
  1491.  * Description  :  This window procedure displays an MCI error message
  1492.  *                 based upon a ulError return code.  The MCI function
  1493.  *                 mciGetErrorString is used to convert the error code into
  1494.  *                 a text string and the title is pulled from the resource
  1495.  *                 based upon a string id.
  1496.  *
  1497.  * Concepts     :  Using mciGetErrorString to convert an error code into
  1498.  *                 a textual message.
  1499.  *
  1500.  * MMPM/2 API's :  mciGetErrorString
  1501.  *
  1502.  * Parameters   :  ulError  -  MCI error code.
  1503.  *
  1504.  * Return       :  nothing
  1505.  *
  1506.  ******************************************************************************/
  1507. VOID  ShowMCIErrorMessage( ULONG ulError)
  1508. {
  1509.    CHAR  achBuffer[LEN_ERROR_MESSAGE];
  1510.  
  1511.    switch(mciGetErrorString( ulError, (PSZ)achBuffer,   sizeof( achBuffer)))
  1512.    {
  1513.       case MCIERR_SUCCESS:
  1514.  
  1515.          /*******************************************************************/
  1516.          /* This is what we want.  We were able to use mciGetErrorString to */
  1517.          /* retrieve a textual error message we can show in a message box.  */
  1518.          /*******************************************************************/
  1519.          WinMessageBox( HWND_DESKTOP,
  1520.                         hwndMainDialogBox,
  1521.                         achBuffer,
  1522.                         achMsgBoxTitle,
  1523.                         (USHORT) ID_MESSAGEBOX,
  1524.                         MB_CANCEL | MB_HELP | MB_ERROR | MB_MOVEABLE);
  1525.          break;
  1526.  
  1527.       case MCIERR_INVALID_DEVICE_ID:
  1528.       case MCIERR_OUTOFRANGE:
  1529.       case MCIERR_INVALID_BUFFER:
  1530.       default:
  1531.          MessageBox( IDS_UNKNOWN,
  1532.                      MB_CANCEL | MB_HELP | MB_ERROR | MB_MOVEABLE);
  1533.          break;
  1534.    }
  1535.  
  1536.    return;
  1537.  
  1538. }  /* end of ShowMCIErrorMessage */
  1539.  
  1540.  
  1541. /******************************************************************************
  1542.  * Name         :  DoesFileExist
  1543.  *
  1544.  * Description  :  This helper function determines if a file with a given
  1545.  *                 file name exists. If it does, we want to attain specific
  1546.  *                 information for future use.  This information is attained
  1547.  *                 by getting the track ID of the movie.
  1548.  *
  1549.  * Concepts     :  Using MMIO interface to access a data file and header
  1550.  *                 information.
  1551.  *
  1552.  * MMPM/2 API's :  mmioOpen
  1553.  *                 mmioClose
  1554.  *                 mmioGetHeader
  1555.  *                 mmioSet
  1556.  *
  1557.  * Parameters   :  pszFileName - The file name to be tested.
  1558.  *
  1559.  * Return       :  TRUE  -  if the a file exists matching pszFilename
  1560.  *                          and there are no errors getting the movie file
  1561.  *                          header information.
  1562.  *                 FALSE -  if the file does not exist or problem getting
  1563.  *                          the movie file header information
  1564.  *
  1565.  *
  1566.  ******************************************************************************/
  1567. BOOL DoesFileExist( PSZ pszFileName )
  1568. {
  1569.    BOOL  bReturn = 0;                    /* Function return value       */
  1570.    HMMIO hFile;                          /* Handle to file              */
  1571.    LONG  lHeaderLengthMovie;             /* Header length of movie file */
  1572.    LONG  lHeaderLengthVideo;             /* Header length of movie file */
  1573.    ULONG ulTrackID;                      /* Track ID                    */
  1574.    LONG  lBytes;                         /* Number of bytes read        */
  1575.    LONG  lSize;                          /* Size of Header information  */
  1576.    PMMMOVIEHEADER pmmMovieHeader;        /* Std Movie Header            */
  1577.    MMVIDEOHEADER  mmVideoHeader;         /* Std Video Header            */
  1578.    MMEXTENDINFO   mmExtendinfo;          /* Std Extended Information    */
  1579.    MMIOINFO       mmioinfo;              /* Structure for mmio info     */
  1580.    PMMIOPROC      pIOProc;
  1581.    PMMIOPROC      pAnswer;
  1582.    HMODULE        hmod;
  1583.    FOURCC         fcc;
  1584.    CHAR           LoadError[100];
  1585.    ULONG          rc = MMIO_SUCCESS;
  1586.  
  1587.  
  1588.    /*********************************************************/
  1589.    /* Reset all my my mmio information structures           */
  1590.    /*********************************************************/
  1591.  
  1592.    memset(&mmioinfo, '\0', sizeof(MMIOINFO));
  1593.    memset(&mmExtendinfo, '\0', sizeof(MMEXTENDINFO));
  1594.    memset(&mmVideoHeader, '\0', sizeof(MMVIDEOHEADER));
  1595.  
  1596.    mmioinfo.ulTranslate =  MMIO_TRANSLATEHEADER;   /* Set to std translation */
  1597.  
  1598.                                     /* Set all operations on the active track*/
  1599.    mmExtendinfo.ulFlags = MMIO_TRACK;
  1600.  
  1601.    hFile = mmioOpen( pszFileName, &mmioinfo, MMIO_READ );
  1602.  
  1603.    if (hFile != (HMMIO) NULL)
  1604.     {
  1605.  
  1606.       mmExtendinfo.ulTrackID = -1;                     /* reset the track id */
  1607.  
  1608.      /*********************************************************/
  1609.      /* The mmioSet function associates an MMIO handle with   */
  1610.      /* the CODEC information.  The MMIO_SET_EXTENDEDINFO     */
  1611.      /* is set to associate the CODEC Procs with the file.    */
  1612.      /*********************************************************/
  1613.  
  1614.       bReturn = mmioSet(hFile, &mmExtendinfo, MMIO_SET_EXTENDEDINFO);
  1615.  
  1616.      /*********************************************************/
  1617.      /* The mmioQueryHeaderLength returns the length of the   */
  1618.      /* header in bytes.  This length is actually variable    */
  1619.      /* because a chunk of information gets added to each     */
  1620.      /* track or stream in the movie.                         */
  1621.      /*********************************************************/
  1622.       bReturn = mmioQueryHeaderLength(hFile, &lHeaderLengthMovie,0L, 0L);
  1623.  
  1624.       if (!bReturn)
  1625.         {
  1626.           pmmMovieHeader = malloc(lHeaderLengthMovie);
  1627.         } /* if */
  1628.  
  1629.      /*********************************************************/
  1630.      /* The mmioGetHeader function returns the header of the  */
  1631.      /* media structure of the file opened by mmioOpen.       */
  1632.      /* The header contains information about the media.      */
  1633.      /*********************************************************/
  1634.       if (!(bReturn = mmioGetHeader(hFile,
  1635.                                     pmmMovieHeader,
  1636.                                     lHeaderLengthMovie,
  1637.                                     &lBytes,
  1638.                                     0L,
  1639.                                     0L)))
  1640.        {
  1641.  
  1642.          /*********************************************************/
  1643.          /* Read the movie header informationn and get the track  */
  1644.          /* information.                                          */
  1645.          /*********************************************************/
  1646.  
  1647.           mmExtendinfo.ulTrackID = pmmMovieHeader->ulNextTrackID;
  1648.  
  1649.           /**************************************************************/
  1650.           /* Here we will use the mmioSet to set the extended info      */
  1651.           /* to the correct track after issuing the mmioGetHeader. Once */
  1652.           /* we have the correct track we can issue mmioGetHeader       */
  1653.           /* requesting the movie information we wish to have. In this  */
  1654.           /* sample we are asking for the height, width, length of the  */
  1655.           /* movie.                                                     */
  1656.           /**************************************************************/
  1657.  
  1658.           bReturn = mmioSet(hFile, &mmExtendinfo, MMIO_SET_EXTENDEDINFO);
  1659.  
  1660.           lHeaderLengthVideo = sizeof(MMVIDEOHEADER);
  1661.  
  1662.           /*******************************************************/
  1663.           /* Get the information we need from the video header   */
  1664.           /* height, width, length.                              */
  1665.           /*******************************************************/
  1666.  
  1667.           bReturn = mmioGetHeader(hFile,
  1668.                                   &mmVideoHeader,
  1669.                                   lHeaderLengthVideo,
  1670.                                   &lBytes,
  1671.                                   0L,
  1672.                                   0L);
  1673.  
  1674.           ulMovieWidth  = mmVideoHeader.ulWidth;
  1675.  
  1676.           ulMovieHeight = mmVideoHeader.ulHeight;
  1677.  
  1678.           ulMovieLength = mmVideoHeader.ulLength;
  1679.  
  1680.           /*****************************************************/
  1681.           /* Here we are using the mmioSet to reset the tracks */
  1682.           /* We do this just in case we would need to do some- */
  1683.           /* thing different with the movie file.              */
  1684.           /*****************************************************/
  1685.           mmExtendinfo.ulTrackID = MMIO_RESETTRACKS;
  1686.  
  1687.           bReturn = mmioSet(hFile, &mmExtendinfo,MMIO_SET_EXTENDEDINFO);
  1688.  
  1689.           mmioClose( hFile, 0);
  1690.  
  1691.           bReturn = TRUE;
  1692.           return (bReturn);
  1693.           free(pmmMovieHeader);
  1694.        }
  1695.     }
  1696.    bReturn = FALSE;
  1697.    return (bReturn);
  1698.  
  1699.  
  1700. }
  1701. /******************************************************************************
  1702.  * Name         :  SetMovieVolume
  1703.  *
  1704.  * Description  :  This helper function sets the Movie file volume based upon
  1705.  *                 the position of the volume slider.  The slider will be
  1706.  *                 queried and the Movie file volume will be set.
  1707.  *
  1708.  * Concepts     :  Setting the volume of a device.
  1709.  *
  1710.  * MMPM/2 API's :  mciSendString
  1711.  *                    - set
  1712.  *
  1713.  * Parameters   :  none.
  1714.  *
  1715.  * Return       :  none.
  1716.  *
  1717.  ******************************************************************************/
  1718. VOID SetMovieVolume( VOID )
  1719. {
  1720.    LONG      lmciSendStringRC;             /* return value form mciSendString */
  1721.    CHAR      szVolume[4] = "";             /* to hold the volume level        */
  1722.    CHAR      szCommandString[CCHMAXPATH] = /* string command to MCI           */
  1723.                "set movie audio volume ";
  1724.  
  1725.    if( !fAudioOn ) return;
  1726.  
  1727.    if ((!fPassedDevice) && (eState == ST_PLAYING ))
  1728.    {
  1729.       /*****************************************************************/
  1730.       /* To set the volume,  first, build the string command for the   */
  1731.       /* MCI.  Then an MCI_SET command should be issued to the device  */
  1732.       /* to perform the volume change.                                 */
  1733.       /*****************************************************************/
  1734.       _itoa(sVolumeLevel, szVolume, 10);
  1735.       strcat( szCommandString, szVolume);
  1736.       strcat( szCommandString, " ");
  1737.       strcat( szCommandString, "wait");
  1738.  
  1739.       lmciSendStringRC =
  1740.           mciSendString( (PSZ)szCommandString,
  1741.                          (PSZ)szReturn,
  1742.                          CCHMAXPATH,
  1743.                          (HWND)NULL,
  1744.                          (USHORT)NULL );
  1745.       if (lmciSendStringRC != 0)
  1746.          ShowMCIErrorMessage(lmciSendStringRC);
  1747.  
  1748.    }
  1749.    return;
  1750. }  /* end of SetMovieVolume */
  1751.  
  1752. /*************************************************************************
  1753.  * Name         : InitializeHelp
  1754.  *
  1755.  * Description  : This procedure will set up the initial values in the
  1756.  *                global help structure.  This help structure will then
  1757.  *                be passed on to the Help Manager when the Help Instance
  1758.  *                is created.  The handle to the Help Instance will be
  1759.  *                kept for later use.
  1760.  *
  1761.  * Concepts     : None.
  1762.  *
  1763.  * MMPM/2 API's : None.
  1764.  *
  1765.  * Parameters   : None.
  1766.  *
  1767.  * Return       : None.
  1768.  *
  1769.  *************************************************************************/
  1770. VOID InitializeHelp( VOID )
  1771. {
  1772.  
  1773.    HELPINIT helpInit;                 /* Help initialization structure. */
  1774.    CHAR     achHelpLibraryName[LEN_HELP_LIBRARY_NAME];
  1775.    CHAR     achHelpWindowTitle[LEN_HELP_WINDOW_TITLE];
  1776.  
  1777.    /*
  1778.     * Load the strings for the Help window title and library name.
  1779.     * Initialize the help structure and associate the help instance.
  1780.     */
  1781.    WinLoadString( hab,
  1782.                   (HMODULE) NULL,
  1783.                   IDS_HELP_WINDOW_TITLE,
  1784.                   (SHORT) sizeof( achHelpWindowTitle),
  1785.                   achHelpWindowTitle);
  1786.  
  1787.    WinLoadString( hab,
  1788.                   (HMODULE) NULL,
  1789.                   IDS_HELP_LIBRARY_NAME,
  1790.                   (SHORT) sizeof( achHelpLibraryName),
  1791.                   achHelpLibraryName);
  1792.  
  1793.    memset ( &helpInit, 0, sizeof(helpInit) );
  1794.    /*
  1795.     * Initialize the help structure.
  1796.     */
  1797.    helpInit.cb                 = sizeof( helpInit);  /* size of the help struc*/
  1798.    helpInit.ulReturnCode       = (ULONG) 0;          /* RC from HM init       */
  1799.    helpInit.pszTutorialName    = (PSZ) NULL;         /* No tutorial program   */
  1800.    helpInit.pszHelpWindowTitle = achHelpWindowTitle; /* The Help window title.*/
  1801.    helpInit.fShowPanelId       = (ULONG) 0;          /* help panel ID.        */
  1802.    helpInit.pszHelpLibraryName = achHelpLibraryName; /* library name          */
  1803.    helpInit.phtHelpTable       = (PVOID)(0xffff0000 | ID_MOVIE_HELPTABLE);
  1804.  
  1805.    /*
  1806.     * Create the Help Instance for IPF.
  1807.     * Give IPF the Anchor Block handle and address of the IPF initialization
  1808.     * structure, and check that creation of Help was a success.
  1809.     */
  1810.    hwndHelpInstance = WinCreateHelpInstance(
  1811.                          hab,                   /* Anchor Block Handle.       */
  1812.                          &helpInit );           /* Help Structure.            */
  1813.  
  1814.    if ( hwndHelpInstance == (HWND) NULL)
  1815.    {
  1816.       MessageBox( IDS_HELP_CREATION_FAILED,     /* ID of the message          */
  1817.                   MB_OK | MB_INFORMATION  | MB_MOVEABLE);    /* style         */
  1818.    }
  1819.    else
  1820.    {
  1821.       if ( helpInit.ulReturnCode)
  1822.       {
  1823.          WinDestroyHelpInstance( hwndHelpInstance);
  1824.          MessageBox( IDS_HELP_CREATION_FAILED,
  1825.                      MB_OK | MB_INFORMATION | MB_MOVEABLE);
  1826.       }
  1827.       else  /* help creation worked */
  1828.          WinAssociateHelpInstance(
  1829.             hwndHelpInstance,        /* The handle of the Help Instance.      */
  1830.             hwndFrame);              /* Associate to this dialog window.      */
  1831.    }  /* End of IF checking the creation of the Help Instance. */
  1832.  
  1833. }  /* End of InitializeHelp */
  1834.  
  1835. /*************************************************************************
  1836.  * Name         : InsertHelpMenuItem
  1837.  *
  1838.  * Description  : This procedure will set up "Help" menu item to
  1839.  *                the system menu.
  1840.  *
  1841.  * Concepts     : None.
  1842.  *
  1843.  * MMPM/2 API's : None.
  1844.  *
  1845.  * Parameters   : Pointer to the "Help" text data.
  1846.  *
  1847.  * Return       : None.
  1848.  *
  1849.  *************************************************************************/
  1850. VOID InsertHelpMenuItem( PCHAR szHelp )
  1851. {
  1852.    MENUITEM MenuItem;                     /* Menu-Item Structure           */
  1853.    HWND     hwndSysMenuPullDown;          /* window handle for pulldown    */
  1854.    USHORT   idSysMenu;                    /*                               */
  1855.    HWND     hwndSysMenu;                  /* window handle for system menu */
  1856.    USHORT   i;                            /*                               */
  1857.    USHORT   iDefaultSize = MIT_END;       /*                               */
  1858.    BOOL     fSearch = TRUE;               /*                               */
  1859.    LONG     cntSeparator = 0;             /*                               */
  1860.  
  1861.  
  1862.    /*
  1863.     *  Get the system pull down menu window handle.
  1864.     */
  1865.    hwndSysMenu = WinWindowFromID(hwndFrame,
  1866.                                    FID_SYSMENU);
  1867.    idSysMenu = SHORT1FROMMR (WinSendMsg (hwndSysMenu,
  1868.                                MM_ITEMIDFROMPOSITION, 0L, 0L));
  1869.    WinSendMsg (hwndSysMenu, MM_QUERYITEM,
  1870.                  MPFROM2SHORT (idSysMenu, FALSE), MPFROMP(&MenuItem));
  1871.    hwndSysMenuPullDown = MenuItem.hwndSubMenu;
  1872.  
  1873.    /*
  1874.     *  Find the position to insert "Help" item.
  1875.     */
  1876.    for (i=0; fSearch; i++)
  1877.    {
  1878.       idSysMenu = SHORT1FROMMR (WinSendMsg (hwndSysMenuPullDown,
  1879.                                 MM_ITEMIDFROMPOSITION, (MPARAM)i, 0L));
  1880.       fSearch = (BOOL)WinSendMsg (hwndSysMenuPullDown, MM_QUERYITEM,
  1881.                   MPFROM2SHORT (idSysMenu, FALSE), MPFROMP(&MenuItem));
  1882.  
  1883.       if (fSearch && MenuItem.afStyle & MIS_SEPARATOR)
  1884.       {
  1885.          cntSeparator ++;
  1886.          if (cntSeparator == 2)
  1887.          {
  1888.             cntSeparator ++;
  1889.             break;
  1890.          } /* endif */
  1891.       } /* endif */
  1892.  
  1893.    } /* endfor */
  1894.  
  1895.    if (fSearch)
  1896.    {
  1897.       if (i==0)
  1898.       {
  1899.          iDefaultSize = MIT_FIRST;
  1900.       }
  1901.       else
  1902.       {
  1903.          iDefaultSize = i;
  1904.       }
  1905.    }
  1906.  
  1907.    /*
  1908.     *  Insert separator first.
  1909.     */
  1910.    MenuItem.iPosition   = iDefaultSize;
  1911.    MenuItem.afStyle     = MIS_SEPARATOR;
  1912.    MenuItem.afAttribute = (ULONG)NULL;
  1913.    MenuItem.id          = (ULONG)NULL;
  1914.    MenuItem.hwndSubMenu = (HWND)NULL;
  1915.    MenuItem.hItem       = (ULONG)NULL;
  1916.    WinSendMsg (hwndSysMenuPullDown, MM_INSERTITEM,
  1917.                  (MPARAM)&MenuItem, (MPARAM)NULL);
  1918.    /*
  1919.     *  Insert "Help" text next.
  1920.     */
  1921.    MenuItem.iPosition   = ++iDefaultSize;
  1922.    MenuItem.afStyle     = (ULONG)NULL;
  1923.    MenuItem.afAttribute = (ULONG)NULL;
  1924.    MenuItem.id          = WM_HELP;
  1925.    MenuItem.hwndSubMenu = (HWND)NULL;
  1926.    MenuItem.hItem       = (ULONG)NULL;
  1927.    WinSendMsg (hwndSysMenuPullDown, MM_INSERTITEM,
  1928.                  (MPARAM)&MenuItem, (MPARAM)szHelp);
  1929.  
  1930. }  /* End of InsertHelpMenuItem */
  1931.  
  1932. /******************************************************************************
  1933.  * Name         : ResizeMovieWindow
  1934.  *
  1935.  * Description  : This function will resize the applications movie window
  1936.  *                according to the height and width of the movie file being
  1937.  *                opened.
  1938.  *
  1939.  * Parameters   : hwnd - Handle of the secondary window.
  1940.  *
  1941.  * Return       : none.
  1942.  *
  1943.  ******************************************************************************/
  1944. VOID ResizeMovieWindow (HWND hwnd)
  1945. {
  1946.  
  1947.    HWND hwndSEFrame;             /* handle for the Secondary Window Frame     */
  1948.    SWP  swpSEFrame;              /* struc containing information on Frame     */
  1949.    SWP  swpRewind;               /* struc containing information rewind button*/
  1950.    LONG cxWidthBorder = 0;
  1951.    LONG cyWidthBorder = 0;
  1952.    LONG cyTitleBar = 0;
  1953.  
  1954.   /*************************************************************/
  1955.   /* Query the position of the secondary window frame          */
  1956.   /* and the rewind button so we can postion our application   */
  1957.   /* frame for the movie.                                      */
  1958.   /*************************************************************/
  1959.  
  1960.    WinQueryWindowPos( hwndFrame, &swpSEFrame );
  1961.  
  1962.    WinQueryWindowPos( WinWindowFromID( hwnd, IDC_GPB_REWIND ),
  1963.                       &swpRewind );
  1964.  
  1965.    cxWidthBorder = (LONG) WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER);
  1966.    cyWidthBorder = (LONG) WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER);
  1967.    cyTitleBar =    (LONG) WinQuerySysValue(HWND_DESKTOP, SV_CYTITLEBAR);
  1968.  
  1969.   /*************************************************************/
  1970.   /* Check to see if our movie size is larger than our frame.  */
  1971.   /* If it is then resize our frame to fit the movie.          */
  1972.   /*************************************************************/
  1973.  
  1974.  if ((swpSEFrame.cx - (2 * cxWidthBorder)) <= ulMovieWidth)
  1975.   {
  1976.     swpSEFrame.cx = ulMovieWidth + (2 * cxWidthBorder);
  1977.   } /* if */
  1978.  if ((swpSEFrame.cy - swpRewind.cy - ulMovieHeight -
  1979.                                      cyTitleBar - (2 * cyWidthBorder)
  1980.                                       < ulMovieHeight ))
  1981.   {
  1982.     swpSEFrame.cy = ulMovieHeight + cyTitleBar + (2 * cyWidthBorder);
  1983.   } /* if */
  1984.  
  1985.   /*************************************************************/
  1986.   /* Set the position and size of the application window       */
  1987.   /* to the position and size of the movie.                    */
  1988.   /*************************************************************/
  1989.  
  1990.      WinSetWindowPos( hwndAppFrame, HWND_TOP,
  1991.                       (swpSEFrame.cx - ulMovieWidth - cxWidthBorder) / 2,
  1992.                       (cyWidthBorder + swpRewind.y + swpRewind.cy) + 5,
  1993.                       ulMovieWidth,
  1994.                       ulMovieHeight,
  1995.                       SWP_SIZE | SWP_MOVE);
  1996.  
  1997. }
  1998.  
  1999.  
  2000.  
  2001.  
  2002. /*****************************************************************
  2003.  * Name : QueryDirectMode
  2004.  *
  2005.  * Function: Determine if direct mode is supported.
  2006.  *
  2007.  ******************************************************************/
  2008.  
  2009. BOOL  QueryDirectMode(VOID)
  2010. {
  2011.     DIVE_CAPS    DiveCaps;             /* Dive Query Capabilities */
  2012.     ULONG        rc;                   /* API Return Code         */
  2013.     FOURCC       fccFormats[100] = {0};
  2014.  
  2015.     memset (&DiveCaps,0,sizeof(DiveCaps));
  2016.     DiveCaps.pFormatData = fccFormats;
  2017.     DiveCaps.ulFormatLength = 120;
  2018.     DiveCaps.ulStructLen = sizeof(DIVE_CAPS);
  2019.     rc = DiveQueryCaps( &DiveCaps, DIVE_BUFFER_SCREEN);
  2020.     if (!rc)
  2021.       {
  2022.         if (DiveCaps.fScreenDirect)
  2023.          {
  2024.            if (DiveCaps.ulDepth < 8)
  2025.               return (BOOL)(FALSE);
  2026.          }
  2027.          else
  2028.               return (BOOL)(FALSE);
  2029.  
  2030.       }
  2031.     return (BOOL)(TRUE);
  2032. }
  2033.  
  2034.