//////////
//
//	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);
}