Common Files/WinFramework.c

//////////
//
//  File:       WinFramework.c
//
//  Contains:   Code for the QuickTime sample code framework that is specific to Windows. 
//              This code handles windows, menus, events, and other low-level things. Put your
//              application-specific code into the file ComApplication.c. 
//
//  Written by: Tim Monroe
//              Based on the QTShell code written by Tim Monroe, which in turn was based on the MDIPlayer
//              code written by Brian S. Friedkin (Aug 5, 1996). This current version is now very far removed from
//              MDIPlayer.
//
//  Copyright:  © 1999 by Apple Computer, Inc., all rights reserved.
//
//  Change History (most recent first):
//
//     <11>     07/31/00    rtm     reworked QTFrame_CalcWindowMinMaxInfo to use subsystem 4.0 metrics
//     <10>     07/07/00    rtm     removed QTFrame_CreateMacEditMenu; now we use MCGetMenuString
//     <9>      07/06/00    rtm     made changes to support new parameter to QTFrame_AdjustMenus; added the calls
//                                  QTFrame_CreateMacEditMenu and QTFrame_GetKeyboardModifiers
//     <8>      06/26/00    rtm     added SetFocus call to QTFrame_CreateMovieWindow
//     <7>      04/03/00    rtm     reworked QTFrame_CalcWindowMinMaxInfo; disabled movie window maximize button
//                                  in WM_CREATE message processing (implementing this is left as an exercise...)
//     <6>      01/14/00    rtm     reworked window-drawing code (WM_PAINT message) to support graphics files
//     <5>      01/05/00    rtm     minor tweaks to QuickTime initialization in WinMain
//     <4>      12/26/99    rtm     added WM_LBUTTONDOWN processing to QTFrame_MovieWndProc; minor reorganization
//                                  of QTFrame_MovieWndProc so that myMacEvent and myIsHandled are in scope for
//                                  that message
//     <3>      12/16/99    rtm     made minor change to QTFrame_MovieWndProc so that QTApp_HandleEvent is called
//                                  even if the window has no movie controller
//     <2>      11/29/99    rtm     modified "Save changes" dialog box to use Macintosh wordings prompted by move
//                                  to Navigation Services
//     <1>      11/05/99    rtm     first file; based on earlier sample code
//     
//////////
 
//////////
//
// header files
//
//////////
 
#include "WinFramework.h"
 
 
//////////
//
// global variables
//
//////////
 
BOOL                gShuttingDown = false;              // are we shutting down?
BOOL                gWeAreSizingWindow = false;         // are we resizing a window?
BOOL                gWeAreCreatingWindow = false;       // are we creating a window?
 
HANDLE              ghInst;                             // the instance of this application
HWND                ghWnd;                              // the MDI frame window; this window has the menu bar
HWND                ghWndMDIClient;                     // the MDI client window
 
char                gChildName[] = "QTShellChild";
char                gMovieType[] = "QuickTime Movie";
 
short               gAppResFile = kInvalidFileRefNum;   // file reference number for this application's resource file
FSSpec              gAppFSSpec;                         // file specification for the application itself
char                gAppName[20];                       // the name of this application
 
LPSTR               gCmdLine;                           // the command line passed to WinMain
 
extern Rect         gMCResizeBounds;                    // maximum size for any movie window
 
ModalFilterUPP      gModalFilterUPP = NULL;             // UPP to our custom dialog event filter
 
 
//////////
//
// WinMain
// The main function for this application.
//
// Set up the application's execution environment; make sure QuickTime (etc.) is installed,
// then start handling events. If we terminate before reaching the message loop, we should
// return 0.
//
//////////
 
int CALLBACK WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR theCmdLine, int nCmdShow)
{
    HANDLE              myAccel;
    HWND                myWindowFrame;
    MSG                 myMsg;
    WNDCLASSEX          myWC;
    char                myFileName[MAX_PATH];
    DWORD               myLength;
    OSErr               myErr = noErr;
 
    ghInst = hInstance;
    gCmdLine = theCmdLine;
    
    if (hPrevInstance == NULL) {
        LoadString(hInstance, IDS_APPNAME, gAppName, sizeof(gAppName));
        
        // register the frame window class
        myWC.cbSize        = sizeof(WNDCLASSEX);
        myWC.style         = CS_HREDRAW | CS_VREDRAW;
        myWC.lpfnWndProc   = (WNDPROC)QTFrame_FrameWndProc;
        myWC.cbClsExtra    = 0;
        myWC.cbWndExtra    = 0;
        myWC.hInstance     = hInstance;
        myWC.hIcon         = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPICON));
        myWC.hCursor       = LoadCursor(NULL, IDC_ARROW);
        myWC.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
        myWC.lpszMenuName  = gAppName;
        myWC.lpszClassName = gAppName;
        myWC.hIconSm       = LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 16, 16, 0);
                                     
        if (!RegisterClassEx(&myWC)) {
            if (!RegisterClass((LPWNDCLASS)&myWC.style))
                return(0);
        }
 
        // register the movie child window class
        myWC.cbSize        = sizeof(WNDCLASSEX);
        myWC.style         = 0;
        myWC.lpfnWndProc   = (WNDPROC)QTFrame_MovieWndProc;
        myWC.cbClsExtra    = 0;
        myWC.cbWndExtra    = 0;
        myWC.hInstance     = hInstance;
        myWC.hIcon         = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_CHILDICON));
        // to avoid having QuickTime VR "fight" with the system over the cursor,
        // we set the client area cursor to NULL; this means that for QuickTime
        // movies, we'll need to change the cursor to an arrow manually; see the
        // handling of the WM_MOUSEMOVE message in QTFrame_MovieWndProc
        myWC.hCursor       = NULL;
        myWC.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
        myWC.lpszMenuName  = NULL;
        myWC.lpszClassName = gChildName;
        myWC.hIconSm       = LoadImage(hInstance, MAKEINTRESOURCE(IDI_CHILDICON), IMAGE_ICON, 16, 16, 0);
                                     
        if (!RegisterClassEx(&myWC)) {
            if (!RegisterClass((LPWNDCLASS)&myWC.style))
                return(0);
        }
    }
 
    // load accelerators
    myAccel = LoadAccelerators(hInstance, gAppName);
 
    // initialize QuickTime Media Layer and QuickTime; alert the user and return 0 if unsuccessful
    myErr = InitializeQTML(0L);
    if (myErr != noErr) {
        MessageBox(NULL, "QuickTime is not installed on this computer. Exiting.", gAppName, MB_OK | MB_APPLMODAL);
        return(0);
    }
    
    myErr = EnterMovies();
    if (myErr != noErr) {
        MessageBox(NULL, "Could not initialize QuickTime. Exiting.", gAppName, MB_OK | MB_APPLMODAL);
        return(0);
    }
 
    // get the application's resource file, if it exists
    myLength = GetModuleFileName(NULL, myFileName, MAX_PATH);       // NULL means: the current process
    if (myLength != 0) {
        NativePathNameToFSSpec(myFileName, &gAppFSSpec, kFullNativePath);
 
        gAppResFile = FSpOpenResFile(&gAppFSSpec, fsRdWrPerm);
        if (gAppResFile != kInvalidFileRefNum)
            UseResFile(gAppResFile);
    }
    
    // do any application-specific initialization that must occur before the frame window is created
    QTApp_Init(kInitAppPhase_BeforeCreateFrameWindow);
    
    // create the main frame window
    myWindowFrame = CreateWindow(gAppName, gAppName, WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                                    CW_USEDEFAULT, 
                                    CW_USEDEFAULT,
                                    CW_USEDEFAULT, 
                                    CW_USEDEFAULT,
                                    NULL, 
                                    NULL, 
                                    hInstance, 
                                    NULL);
    ghWnd = myWindowFrame;
    
    // make sure we got a frame window
    if (myWindowFrame == NULL)
        return(0);
        
    // show the window
    ShowWindow(myWindowFrame, nCmdShow);
    UpdateWindow(myWindowFrame);
    
    // do any application-specific initialization that must occur after the frame window is created
    QTApp_Init(kInitAppPhase_AfterCreateFrameWindow);
    
    // get and process events until the user quits
    while (GetMessage(&myMsg, NULL, 0, 0)) {    
        if (!TranslateMDISysAccel(ghWndMDIClient, &myMsg)) {
            if (!TranslateAccelerator(myWindowFrame, myAccel, &myMsg)) {
                TranslateMessage(&myMsg);
                DispatchMessage(&myMsg);
            }
        }
    }
 
    // close the application's resource file, if it was previously opened
    if (gAppResFile != kInvalidFileRefNum)
        CloseResFile(gAppResFile);
 
    // terminate the QuickTime Media Layer
    ExitMovies();
    TerminateQTML();
 
    return(myMsg.wParam);           // returns the value from PostQuitMessage
}
 
 
//////////
//
// QTFrame_FrameWndProc
// The window procedure for the MDI frame window.
//
//////////
 
LRESULT CALLBACK QTFrame_FrameWndProc (HWND theWnd, UINT theMessage, UINT wParam, LONG lParam)
{
    HWND                myChild;
 
    switch (theMessage) {
    
        case WM_CREATE: {
            CLIENTCREATESTRUCT      myClientStruct = {0};
 
            myClientStruct.hWindowMenu  = GetSubMenu(GetMenu(theWnd), WINDOWMENU);
            myClientStruct.idFirstChild = IDM_WINDOWCHILD;
            
            // create the MDI client filling the client area
            ghWndMDIClient = CreateWindow("mdiclient",
                                         NULL,
                                         WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL,
                                         0, 0, 0, 0,
                                         theWnd,
                                         (HMENU)0xCAC,
                                         ghInst,
                                         (LPVOID)&myClientStruct);
            
            // set initial menu state
            QTFrame_AdjustMenus(NULL, GetMenu(theWnd), 0L);
            
            if (ghWndMDIClient != NULL)
                ShowWindow(ghWndMDIClient, SW_SHOW);
            
            return(0);
        }
 
        case WM_ACTIVATE:
            // the MDI frame window is being activated or deactivated;
            // activate or deactivate any active child window by sending this message to DefMDIChildProc 
            myChild = (HWND)SendMessage(ghWndMDIClient, WM_MDIGETACTIVE, 0, 0L);
            if (IsWindow(myChild))
                SendMessage(myChild, WM_ACTIVATE, wParam, lParam);
            break;
 
        case WM_COMMAND: {
 
            switch (LOWORD(wParam)) {
                case IDM_FILENEW:
                case IDM_FILEOPEN:
                case IDM_FILECLOSE:
                case IDM_EXIT:
                    QTFrame_HandleFileMenuItem(NULL, LOWORD(wParam));
                    return(0);
 
                case IDM_FILESAVE:
                case IDM_FILESAVEAS:
                    // save the active child window
                    myChild = (HWND)SendMessage(ghWndMDIClient, WM_MDIGETACTIVE, 0, 0L);
                    if (IsWindow(myChild))
                        SendMessage(myChild, WM_COMMAND, wParam, lParam);
                    return(0);
 
                case IDM_WINDOWTILE:
                    SendMessage(ghWndMDIClient, WM_MDITILE, 0, 0L);
                    return(0);
 
                case IDM_WINDOWCASCADE:
                    SendMessage(ghWndMDIClient, WM_MDICASCADE, 0, 0L);
                    return(0);
 
                case IDM_WINDOWICONS:
                    SendMessage(ghWndMDIClient, WM_MDIICONARRANGE, 0, 0L);
                    return(0);
 
                case IDM_WINDOWCLOSEALL: {
                    WindowReference     myWindow, myNextWindow;
            
                    // walk the window list and destroy any open windows
                    myWindow = QTFrame_GetFrontMovieWindow();
                    while (myWindow != NULL) {
                        myNextWindow = QTFrame_GetNextMovieWindow(myWindow);
                        SendMessage(myWindow, WM_CLOSE, 0L, 0L);
                        myWindow = myNextWindow;
                    }
                    
                    return(0);
                }
 
                case IDM_ABOUT:
                    QTFrame_ShowAboutBox();
                    return(0);
 
                default:                
                    // pass this message to the active child window...
                    myChild = (HWND)SendMessage(ghWndMDIClient, WM_MDIGETACTIVE, 0, 0L);
                    if (IsWindow(myChild))
                        SendMessage(myChild, WM_COMMAND, wParam, lParam);
 
                    // ...then do any application-specific menu handling, if no movie windows are open...
                    if (myChild == NULL)
                        QTApp_HandleMenu((UInt16)LOWORD(wParam));
                    
                    // ...and then pass it to DefFrameProc
                    break;
            }
            break;
        }
 
        case WM_OPENDROPPEDFILES:
            // open any movie files that were dropped onto the application icon
            QTFrame_OpenCommandLineMovies(gCmdLine);
            return(0);
 
        case WM_INITMENU: {
            long        myModifiers = 0L;
            
            myModifiers = QTFrame_GetKeyboardModifiers();
            if (GetMenu(theWnd) == (HMENU)wParam)
                return(QTFrame_AdjustMenus((HWND)SendMessage(ghWndMDIClient, WM_MDIGETACTIVE, 0, 0L), (HMENU)wParam, myModifiers));
            return(1);
        }
        
        case WM_CLOSE:
            // if we're not already in the process of shutting down,
            // simulate the selection of the Quit menu command
            if (!gShuttingDown) {
                SendMessage(ghWnd, WM_COMMAND, IDM_EXIT, 0L);
                return(0);
            }
            break;
            
        case WM_DESTROY:
            // do any application-specific shutdown
            QTApp_Stop(kStopAppPhase_AfterDestroyWindows);
            PostQuitMessage(0);
            break;
    }
    
    return(DefFrameProc(theWnd, ghWndMDIClient, theMessage, wParam, lParam));
}
 
 
//////////
//
// QTFrame_MovieWndProc
// The window procedure for a movie window.
//
//////////
 
LRESULT CALLBACK QTFrame_MovieWndProc (HWND theWnd, UINT theMessage, UINT wParam, LONG lParam)
{
    WPARAM              myWidth, myHeight;
    MovieController     myMC = NULL;
    Movie               myMovie = NULL;
    WindowObject        myWindowObject = NULL;
    MSG                 myMsg = {0};
    EventRecord         myMacEvent;
    Boolean             myIsHandled = false;
 
    // get the window object, movie, and movie controller for this window
    myWindowObject = QTFrame_GetWindowObjectFromWindow(theWnd);
    if (myWindowObject != NULL) {
        myMC = (**myWindowObject).fController;
        myMovie = (**myWindowObject).fMovie;
    }
 
    // give the movie controller this message first
    if ((!gShuttingDown) && (theMessage != WM_COMMAND)) {
        LONG            myPoints = GetMessagePos();
 
        myMsg.hwnd = theWnd;
        myMsg.message = theMessage;
        myMsg.wParam = wParam;
        myMsg.lParam = lParam;
        myMsg.time = GetMessageTime();
        myMsg.pt.x = LOWORD(myPoints);
        myMsg.pt.y = HIWORD(myPoints);
 
        // translate a Windows event to a Mac event
        WinEventToMacEvent(&myMsg, &myMacEvent);
 
        // let the application-specific code have a chance to intercept the event
        myIsHandled = QTApp_HandleEvent(&myMacEvent);
        
        // pass the Mac event to the movie controller, but only if the movie window isn't minimized
        if (!myIsHandled)
            if (myMC != NULL)
                if (!IsIconic(theWnd))
                    myIsHandled = MCIsPlayerEvent(myMC, (EventRecord *)&myMacEvent);
    }
 
    switch (theMessage) {
        case WM_CREATE: {
                LONG        myStyles;
                
                // create a new window object associated with the new window
                QTFrame_CreateWindowObject(theWnd);
            
                // disable the maximize button
                myStyles = GetWindowLong(theWnd, GWL_STYLE);
                myStyles &= ~WS_MAXIMIZEBOX;
                SetWindowLong(theWnd, GWL_STYLE, myStyles);
            }
            break;
 
        case WM_WINDOWPOSCHANGING:
            // don't show the window until we have created a movie and
            // can therefore properly size the window to contain the movie
            if (gWeAreCreatingWindow) {
                WINDOWPOS   *lpWindowPos = (WINDOWPOS*)lParam;
                
                lpWindowPos->flags &= ~SWP_SHOWWINDOW;
            }
            break;
 
        case WM_WINDOWPOSCHANGED:
            // if a movie window has become minimized, stop the movie
            if (IsIconic(theWnd))
                StopMovie(myMovie);
            break;
 
        case WM_SIZE:
            // resize the movie and controller to fit the window
            myWidth = LOWORD(lParam);
            myHeight = HIWORD(lParam);
            
            // we do NOT want to resize the movie controller if the window is minimized,
            // if there is no movie controller, or if we are in the middle of resizing the window
            if (!gWeAreSizingWindow && (myMC != NULL) && (wParam != SIZE_MINIMIZED)) {
                Rect        myRect;
                
                myRect.top = 0;
                myRect.left = 0;
                myRect.right = myWidth;
                myRect.bottom = myHeight;
                
                MCSetControllerBoundsRect(myMC, &myRect);
            }
            break;
 
        case WM_MOUSEMOVE:
            // for QuickTime movies (but NOT for QuickTime VR movies), set the cursor to the arrow cursor
            if (myWindowObject != NULL)
                if (!(**myWindowObject).fIsQTVRMovie)
                    SetCursor(LoadCursor(NULL, IDC_ARROW));
            break;
 
        case WM_PUMPMOVIE:
            // we receive this message only to task the movie
            break;
 
        case WM_LBUTTONDOWN:
            // do any application-specific mouse-button handling, but only if the message hasn't already been handled
            if (!myIsHandled)
                QTApp_HandleContentClick(theWnd, &myMacEvent);
            break;
 
        case WM_CHAR:
            // do any application-specific key press handling
            QTApp_HandleKeyPress((char)wParam);
            break;
 
        case WM_PAINT: {
            // do any application-specific drawing in the window
                PAINTSTRUCT     myPaintStruct;
 
                BeginPaint(theWnd, &myPaintStruct);
 
                // if the window contains an image, draw it using GraphicsImportDraw
                if (myWindowObject != NULL)
                    if ((**myWindowObject).fGraphicsImporter != NULL)
                        GraphicsImportDraw((**myWindowObject).fGraphicsImporter);
            
                QTApp_Draw(theWnd);
                
                EndPaint(theWnd, &myPaintStruct);
            }
            break;
 
        case WM_MDIACTIVATE:
            // activate or deactivate the movie controller in the specified window
            QTFrame_ActivateController(theWnd, (HWND)theWnd == (HWND)lParam);
            break;
 
        case WM_COMMAND: {
 
            switch (LOWORD(wParam)) {
                            
                case IDM_FILESAVE:
                case IDM_FILESAVEAS:
                    QTFrame_HandleFileMenuItem(theWnd, LOWORD(wParam));
                    break;
 
                case IDM_EDITUNDO:
                case IDM_EDITCUT:
                case IDM_EDITCOPY:
                case IDM_EDITPASTE:
                case IDM_EDITCLEAR:
                case IDM_EDITSELECTALL:
                case IDM_EDITSELECTNONE:
                    QTFrame_HandleEditMenuItem(theWnd, LOWORD(wParam));
                    break;
                    
                default:
                    // do any application-specific menu handling
                    QTApp_HandleMenu((UInt16)LOWORD(wParam));
                    break;
            }
            
            break;
        }   // case WM_COMMAND
 
        case WM_GETMINMAXINFO:
            QTFrame_CalcWindowMinMaxInfo(theWnd, (LPMINMAXINFO)lParam);
            return(0);
 
        case WM_CLOSE:
            // prepare to close the window, making sure that any changed data is saved or explicitly discarded;
            // we can still cancel the window closing here
            if (myWindowObject != NULL) {
            
                // if the window's data is "dirty", give the user a chance to save it
                if ((**myWindowObject).fIsDirty) {
                    int         myItem;
                    char        myText[256];
                    UINT        myAction;
        
                    // get the title of the window
                    GetWindowText(theWnd, myText, sizeof(myText));
        
                    // specify the action
                    myAction = gShuttingDown ? IDS_SAVEONQUIT : IDS_SAVEONCLOSE;
        
                    // display the "Save changes" dialog box
                    myItem = QTFrame_ShowCautionAlert(theWnd, myAction, MB_ICONEXCLAMATION, MB_YESNOCANCEL, gAppName, myText);
                    switch (myItem) {
                        case kSaveChanges:
                            // save the data in the window
                            QTFrame_UpdateMovieFile(theWnd);
                            break;
                            
                        case kCancelClose:
                            // do not close the window and do not quit the application
                            gShuttingDown = false;
                            return(0);
                        
                        case kDontSaveChanges:
                            // discard any unsaved changes (that is, don't do anything)
                            break;
                            
                        default:
                            // unexpected item selected; just return
                            return(0);
                    }
                }
            } // if (myWindowObject != NULL)
            
            // if we got to this point, it's okay to close and destroy the window
            SendMessage(ghWndMDIClient, WM_MDIDESTROY, (WPARAM)theWnd, 0L);
            break;
 
        case WM_DESTROY:
            // when we get this message,
            // the window has been removed from the screen and its associated data must be destroyed
            if (myWindowObject != NULL)
                QTFrame_CloseWindowObject(myWindowObject);
        
            SetWindowLong(theWnd, GWL_USERDATA, 0);
 
            // destroy the port association
            DestroyPortAssociation((CGrafPtr)GetHWNDPort(theWnd));
            
            break;
    }
 
    return(DefMDIChildProc(theWnd, theMessage, wParam, lParam));
}
 
 
//////////
//
// QTFrame_QuitFramework
// Do any framework-specific shut-down.
//
//////////
 
void QTFrame_QuitFramework (void)
{
    // set our global flag to indicate we're shutting down
    gShuttingDown = true;
    
    // do application-specific processing that must occur before movie windows are closed
    QTApp_Stop(kStopAppPhase_BeforeDestroyWindows);
    
    // close all open movie windows; note that the user can cancel the shutting down
    QTFrame_CloseMovieWindows();
    
    // close the frame window, if we're still shutting down
    if (gShuttingDown)
        SendMessage(ghWnd, WM_CLOSE, 0, 0L);
}
 
 
//////////
//
// QTFrame_OpenCommandLineMovies
// Parse the command line when the application first starts up and
// open as movie documents any files specified on the command line.
//
// Based on the routine ParseCmdLinePriv in GraphicImporter.c.
//
//////////
 
void QTFrame_OpenCommandLineMovies (LPSTR theCmdLine)
{
#pragma unused(theCmdLine)
    LPSTR               myCmdLine;
    FSSpec              myFSSpec;
    SHFILEINFO          myFileInfo;
    
    // get the command line for the current process
    myCmdLine = GetCommandLine();
 
    // parse the command line
    if (*myCmdLine) {
        LPSTR           myTempLine;
        
        // the string preceding any white space is the name of the module (that is, the application)
        myTempLine = strchr(myCmdLine, ' ');
        if (myTempLine) {
            myCmdLine = myTempLine;                 // skip the name of the application
            while (*myCmdLine == ' ')
                myCmdLine++;                        // skip spaces to end of string or to first command
 
            while (*myCmdLine != '\0') {
                char    myFileName[MAX_PATH];
                char    myTempName[MAX_PATH];
                char    myBuffName[MAX_PATH];
                int     myIndex;
                
                // read thru the remaining string to find file names
                for (myIndex = 0; *myCmdLine != '\0'; myIndex++, myCmdLine++) {
                    // if we encounter a space character, it might be a filename delimiter or a space in the filename;
                    // we'll try to open the filename we have so far to see whether it's a valid filename; if not, the
                    // space must be part of the filename we're constructing
                    if (*myCmdLine == ' ') {
                        HANDLE              myFindFile;
                        WIN32_FIND_DATA     myFile;
                    
                        myTempName[myIndex] = '\0';
                        strcpy(myBuffName, myTempName);
                        
                        myFindFile = FindFirstFile(myBuffName, &myFile);
                        if (myFindFile != INVALID_HANDLE_VALUE) {
                            // we found a file having the specified name; close our file search and
                            // break out of our character-gobbling loop (since we've got a valid filename)
                            FindClose(myFindFile);
                            break;
                        }
                    }
                
                    // if we made it here, *myCmdLine is part of the filename (possibly a space)
                    myFileName[myIndex] = myTempName[myIndex] = *myCmdLine;
                }
                
                if (*myCmdLine != '\0')
                    myCmdLine++;
                
                // add a terminating NULL character
                myFileName[myIndex] = '\0';
 
                // make sure the filename picks out a QuickTime movie
                SHGetFileInfo(myFileName, (DWORD)0, &myFileInfo, sizeof(myFileInfo), SHGFI_TYPENAME);
                if (strcmp(myFileInfo.szTypeName, gMovieType) != 0)
                    continue;
                
                // make an FSSpec record
                NativePathNameToFSSpec(myFileName, &myFSSpec, 0L);
 
                // open the file in a movie window
                QTFrame_OpenMovieInWindow(NULL, &myFSSpec);
            }
 
        } else
            myCmdLine += strlen(myCmdLine);         // point to NULL
    }
}
 
 
//////////
//
// QTFrame_CreateMovieWindow
// Create a new window to display the movie in.
//
//////////
 
WindowReference QTFrame_CreateMovieWindow (void)
{
    WindowReference         myWindow = NULL;
 
    gWeAreCreatingWindow = true;
    
    // create a new window to display the movie in
    myWindow = CreateWindowEx(WS_EX_MDICHILD,
                               gChildName,
                               "",
                               0,
                               CW_USEDEFAULT,
                               CW_USEDEFAULT,
                               CW_USEDEFAULT,
                               CW_USEDEFAULT,
                               ghWndMDIClient, 
                               NULL,
                               ghInst,
                               0);
    
    // CreateWindowEx sends a WM_CREATE message to the window being created;
    // we'll call QTFrame_CreateWindowObject when processing that message
    
    gWeAreCreatingWindow = false;
 
    // make sure the new window has the keyboard focus
    if (myWindow != NULL)
        SetFocus(myWindow);
    
    return(myWindow);
}
 
 
//////////
//
// QTFrame_DestroyMovieWindow
// Close the specified movie window.
//
//////////
 
void QTFrame_DestroyMovieWindow (WindowReference theWindow)
{
#pragma unused(theWindow)
 
    HWND                myChild = NULL;
    
    // close the active child window
    myChild = (HWND)SendMessage(ghWndMDIClient, WM_MDIGETACTIVE, 0, 0L);
    if (IsWindow(myChild))
        SendMessage(myChild, WM_CLOSE, 0L, 0L);
}
 
 
//////////
//
// QTFrame_GetDisplayName
// Given a full pathname, return the part that trails the rightmost path separator,
// in long file name format (not in 8.3 format).
//
//////////
 
void QTFrame_GetDisplayName (char *thePathName, char *theDispName)
{
    SHFILEINFO          myFileInfo;
    DWORD               myResult;
    
    myResult = SHGetFileInfo(thePathName, (DWORD)0, &myFileInfo, sizeof(myFileInfo), SHGFI_DISPLAYNAME);
    if (myResult != 0) {
        // SHGetFileInfo successful
        strcpy(theDispName, myFileInfo.szDisplayName);
    } else {
        // SHGetFileInfo not successful, so find the basename ourselves
        short   myLength = 0;
        short   myIndex;
 
        // get the length of the pathname
        myLength = strlen(thePathName);
        
        // find the position of the rightmost path separator in thePathName
        if (strchr(thePathName, kWinFilePathSeparator) != NULL) {
    
            myIndex = myLength - 1;
            while (thePathName[myIndex] != kWinFilePathSeparator)
                myIndex--;
                
            // calculate the length of the basename
            myLength = myLength - myIndex - 1;
    
        } else {
            // there is no rightmost path separator in thePathName;
            // set myIndex so that myIndex + 1 == 0, for the call to BlockMove below
            myIndex = -1;
        }
        
        // copy into theDispName the substring of thePathName from myIndex + 1 to the end
        BlockMove(&thePathName[myIndex + 1], theDispName, myLength);
        theDispName[myLength] = '\0';
    }
}
 
 
//////////
//
// QTFrame_ShowAboutBox 
// Display and manage the About dialog box.
//
//////////
 
void QTFrame_ShowAboutBox (void)
{
    DialogBox(ghInst, MAKEINTRESOURCE(IDD_ABOUT), ghWnd, (DLGPROC)QTFrame_DialogProcedure);
}
 
 
//////////
//
// QTFrame_ShowCautionAlert 
// Display and manage a caution alert.
//
// Based on ShowUserMessage by Stephen Chernicoff, in his WiniEdit application
// (as described in the book "From Mac to Windows" on CodeWarrior reference CD).
//
//////////
 
int QTFrame_ShowCautionAlert (HWND theWnd, UINT theID, UINT theIconStyle, UINT theButtonStyle, LPSTR theTitle, LPSTR theArgument)
{
    char            myTemplate[kAlertMessageMaxLength];
    char            myText[kAlertMessageMaxLength];
    UINT            myStyle;
    int             myItem;
    
    // beep, to get the user's attention (just like CautionAlert on MacOS)
    QTFrame_Beep();
    
    // load the message text template from a resource
    LoadString(ghInst, theID, myTemplate, sizeof(myTemplate));
    
    // insert argument into the message text template, to get the message text
    wsprintf(myText, myTemplate, theArgument);
    
    // set the dialog box style
    myStyle = theIconStyle | theButtonStyle | MB_APPLMODAL | MB_SETFOREGROUND;
 
    // display the dialog box
    myItem = MessageBox(theWnd, myText, theTitle, myStyle);
    
    return(myItem);
}
 
 
//////////
//
// QTFrame_DialogProcedure 
// Dialog callback procedure.
//
//////////
 
static UINT APIENTRY QTFrame_DialogProcedure (HWND theDialog, UINT theMessage, WPARAM wParam, LPARAM lParam)
{
    BOOL    isHandled = false;
 
    switch (theMessage) {
    
        case WM_INITDIALOG: {
            Point           myPoint;
            long            myWidth;
            long            myHeight;
            RECT            myRect;
            RECT            myDeskRect;
            HWND            myWindow;
            OPENFILENAME    *myOFNPtr = (OPENFILENAME *)lParam;
            
            myWindow = theDialog;
                
            // check whether theDialog is the Open File common dialog box
            
            // we need to do this because, for the Open File dialog box, theDialog isn't
            // the actual visible dialog box, but an invisible child of the visible dialog box;
            // for WM_INITDIALOG, lParam is the address of the structure passed to GetOpenFileName,
            // so we can just look for the value we previously put into the lCustData field
            // to make sure that we've got the correct dialog.
            if (myOFNPtr != NULL)
                if (myOFNPtr->lCustData == kOpenDialogCustomData)
                    myWindow = GetParent(theDialog);
                
            // center the dialog window on the screen
            GetWindowRect(myWindow, &myRect);
            myWidth = myRect.right - myRect.left;
            myHeight = myRect.bottom - myRect.top;
            GetWindowRect(GetDesktopWindow(), &myDeskRect);
            myPoint.h = (short)((myDeskRect.right + myDeskRect.left)/2 - myWidth/2);
            myPoint.v = (short)((myDeskRect.top + myDeskRect.bottom)/3 - myHeight/3);
            SetWindowPos(myWindow, 0, myPoint.h, myPoint.v, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
            
            // let Windows set the input focus
            isHandled = true;
            break;
        }
        
        case WM_CLOSE:
            EndDialog(theDialog, IDOK);
            isHandled = true;
            break;
        
        case WM_COMMAND:
            switch (LOWORD(wParam)) {
                case IDOK:
                    EndDialog(theDialog, IDOK);
                    isHandled = true;
                    break;
                default:
                    isHandled = false;
                    break;
            }
            break;
        
        default:
            isHandled = false;
            break;
    }
 
    return(isHandled);
}
 
 
//////////
//
// QTFrame_CalcWindowMinMaxInfo 
// Get minimum and maximum possible size of this window.
//
//////////
 
static void QTFrame_CalcWindowMinMaxInfo (HWND theWnd, LPMINMAXINFO lpMinMax)
{
    WindowObject                myWindowObject = NULL;
    Movie                       myMovie = NULL;
    MovieController             myMC = NULL;
    GraphicsImportComponent     myImporter = NULL;
    Rect                        myRect;
    ComponentResult             myErr = noErr;
    
    myWindowObject = QTFrame_GetWindowObjectFromWindow(theWnd);
    if (myWindowObject != NULL) {
        myMC = (**myWindowObject).fController;
        myMovie = (**myWindowObject).fMovie;
        myImporter = (**myWindowObject).fGraphicsImporter;
    }
    
    // we're expecting a window with either an image or a movie
    if ((myImporter == NULL) && (myMovie == NULL))
        return;
 
    if (myImporter != NULL) {
        myErr = GraphicsImportGetBoundsRect(myImporter, &myRect);
        if (myErr != noErr)
            return;
    }
    
    if (myMovie != NULL) {
        GetMovieBox(myMovie, &myRect);
        if (myMC != NULL)
            if (MCGetVisible(myMC))
                MCGetControllerBoundsRect(myMC, &myRect);
    }
    
    // we currently don't allow images or movies to be resized, so we return both 
    // min and max rectangles set to the current image or movie size, plus the 
    // appropriate window frame and caption sizes
    lpMinMax->ptMinTrackSize.x = myRect.right + (2 * GetSystemMetrics(SM_CXFRAME));
    lpMinMax->ptMinTrackSize.y = myRect.bottom + (2 * GetSystemMetrics(SM_CXFRAME)) + GetSystemMetrics(SM_CYCAPTION);
 
    lpMinMax->ptMaxTrackSize.x = lpMinMax->ptMinTrackSize.x;
    lpMinMax->ptMaxTrackSize.y = lpMinMax->ptMinTrackSize.y;
    
    lpMinMax->ptMaxSize.x = lpMinMax->ptMinTrackSize.x;
    lpMinMax->ptMaxSize.y = lpMinMax->ptMinTrackSize.y;
}
 
 
//////////
//
// QTFrame_GetKeyboardModifiers 
// Get the current keyboard modifiers; return a long word encoding those modifiers that's
// in the same format as the modifiers field of an event record.
//
// The Windows equivalent of the Option key is defined as the combination of Ctrl and Alt;
// so, if they are both down, we should only return the Option key; if only one of them is
// down, then we return that one.
//
// Based on code from Brian Friedkin.
//
//////////
 
static long QTFrame_GetKeyboardModifiers (void)
{
    long    myModifiers = 0L;
    BYTE    myKeyState[256];
 
    if (GetKeyboardState(&myKeyState[0])) {
        if (QTFrame_IsOptionKeyDown(myKeyState))
            myModifiers |= optionKey;
        else if (QTFrame_IsCommandKeyDown(myKeyState))
            myModifiers |= cmdKey;
        else if (QTFrame_IsControlKeyDown(myKeyState))
            myModifiers |= controlKey;
    
        if (QTFrame_IsShiftKeyDown(myKeyState))
            myModifiers |= shiftKey;
        if (QTFrame_IsAlphaLockKeyDown(myKeyState))
            myModifiers |= alphaLock;
    }
    
    return(myModifiers);
}