You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4855 lines
139 KiB
4855 lines
139 KiB
/*-----------------------------------------------------------------------------+
|
|
| MPLAYER.C |
|
|
| |
|
|
| This file contains the code that implements the "MPlayer" (main) dialog box. |
|
|
| |
|
|
| (C) Copyright Microsoft Corporation 1991. All rights reserved. |
|
|
| |
|
|
| Revision History |
|
|
| Oct-1992 MikeTri Ported to WIN32 / WIN16 common code |
|
|
| |
|
|
+-----------------------------------------------------------------------------*/
|
|
|
|
/* include files */
|
|
#include "nocrap.h"
|
|
#include "stdio.h"
|
|
|
|
#include <windows.h>
|
|
#include <mmsystem.h>
|
|
#include <shellapi.h>
|
|
#include <windowsx.h>
|
|
#include <htmlhelp.h>
|
|
#include <tchar.h>
|
|
#define INCGUID
|
|
#include "mpole.h"
|
|
|
|
#include "mplayer.h"
|
|
#include "toolbar.h"
|
|
#include "fixreg.h"
|
|
#include "helpids.h"
|
|
|
|
//These include files for WM_DEVICECHANGE messages from the mixer
|
|
#include <dbt.h>
|
|
#include <cfgmgr32.h>
|
|
#include <initguid.h>
|
|
#include <mmddk.h>
|
|
#include <ks.h>
|
|
#include <ksmedia.h>
|
|
|
|
HDEVNOTIFY MixerEventContext = NULL; //Event Context for WM_DEVICECHANGE messages related to mixer
|
|
|
|
BOOL DeviceChange_Init(HWND hWnd);
|
|
void DeviceChange_Cleanup();
|
|
|
|
//extern int FAR PASCAL ShellAbout(HWND hWnd, LPCTSTR szApp, LPCTSTR szOtherStuff, HICON hIcon);
|
|
|
|
/* in server.c, but not in a header file like it should be... */
|
|
extern PTSTR FAR FileName(LPCTSTR szPath);
|
|
|
|
/* globals */
|
|
|
|
|
|
// Used in converting units from pixels to Himetric and vice-versa
|
|
int giXppli = 0; // pixels per logical inch along width
|
|
int giYppli = 0; // pixels per logical inch along height
|
|
|
|
// Since this is a not an MDI app, there can be only one server and one doc.
|
|
CLSID clsid;
|
|
SRVR srvrMain;
|
|
DOC docMain;
|
|
LPMALLOC lpMalloc;
|
|
|
|
TCHAR szClient[cchFilenameMax];
|
|
TCHAR szClientDoc[cchFilenameMax];
|
|
|
|
// Has the user made changes to the document?
|
|
BOOL fDocChanged = FALSE;
|
|
|
|
/*********************************************************************
|
|
** OLE2NOTE: the very last thing an app must be do is properly shut
|
|
** down OLE. This call MUST be guarded! it is only allowable to
|
|
** call OleUninitialize if OleInitialize has been called.
|
|
*********************************************************************/
|
|
|
|
// Has OleInitialize been called? assume not.
|
|
BOOL gfOleInitialized = FALSE;
|
|
|
|
// Clipboard formats
|
|
CLIPFORMAT cfNative;
|
|
CLIPFORMAT cfEmbedSource;
|
|
CLIPFORMAT cfObjectDescriptor;
|
|
CLIPFORMAT cfMPlayer;
|
|
|
|
LPWSTR sz1Ole10Native = L"\1Ole10Native";
|
|
|
|
/* in server.c, but not in a header file like it should be... */
|
|
extern LPTSTR FAR FileName(LPCTSTR szPath);
|
|
/* in init.c */
|
|
extern PTSTR gpchFilter;
|
|
//extern HMREGNOTIFY ghmrn;
|
|
|
|
/* globals */
|
|
|
|
DWORD gwPlatformId;
|
|
UINT gwPlaybarHeight=TOOLBAR_HEIGHT;/* Taken from server.c */
|
|
UINT gwOptions; /* The object options from the dlg box */
|
|
BOOL gfEmbeddedObject; // TRUE if editing embedded OLE object
|
|
BOOL gfRunWithEmbeddingFlag; // TRUE if we are run with "-Embedding"
|
|
BOOL gfPlayingInPlace; // TRUE if playing in place
|
|
BOOL gfParentWasEnabled; // TRUE if parent was enabled
|
|
BOOL gfShowWhilePlaying; //
|
|
BOOL gfDirty; //
|
|
int gfErrorBox; // TRUE if we have a message box active
|
|
BOOL gfErrorDeath;
|
|
BOOL gfWinIniChange;
|
|
|
|
HHOOK hHookMouse; // Mouse hook handle.
|
|
HOOKPROC fpMouseHook; // Mouse hook proc address.
|
|
|
|
HWND ghwndFocusSave; // saved focus window
|
|
|
|
BOOL gfOpenDialog = FALSE; // If TRUE, put up open dialog
|
|
BOOL gfCloseAfterPlaying = FALSE;// TRUE if we are to hide after play
|
|
HICON hiconApp; /* app icon */
|
|
HMENU ghMenu; /* handle to the dialog's main menu */
|
|
HMENU ghDeviceMenu; /* handle to the Device popup menu */
|
|
HWND ghwndApp; /* handle to the MPlayer (main) dialog box*/
|
|
HWND ghwndMap; /* handle to the track map window */
|
|
HWND ghwndStatic; /* handle to the static text window */
|
|
HBRUSH ghbrFillPat; /* The selection fill pattern. */
|
|
HWND ghwndToolbar; /* handle of the toolbar */
|
|
HWND ghwndMark; /* handle of the mark buttons toolbar */
|
|
HWND ghwndFSArrows; /* handle of the arrows to the scrollbar */
|
|
HWND ghwndTrackbar; /* handle to the trackbar window */
|
|
UINT gwStatus = (UINT)(-1); /* device status (if <gwDeviceID> != NULL)*/
|
|
DWORD gdwSeekPosition; /* Place to seek to next */
|
|
BOOL gfValidMediaInfo; /* are we displaying valid media info? */
|
|
BOOL gfValidCaption; /* are we displaying a valid caption? */
|
|
BOOL gfScrollTrack; /* is user dragging the scrollbar thumb? */
|
|
BOOL gfPlayOnly; /* play only window? */
|
|
BOOL gfJustPlayed = FALSE; /* Just sent a PlayMCI() command */
|
|
BOOL gfJustPlayedSel = FALSE; /* Just sent a ID_PLAYSEL command. */
|
|
BOOL gfUserStopped = FALSE; /* user pressed stop - didn't happen itslf*/
|
|
DWORD_PTR dwLastPageUpTime; /* time of last page-left operation */
|
|
UINT gwCurScale = ID_NONE; /* current scale style */
|
|
LONG glSelStart = -1; /* See if selection changes (dirty object)*/
|
|
LONG glSelEnd = -1; /* See if selection changes (dirty object)*/
|
|
|
|
int gInc; /* how much to inc/dec spin arrows by */
|
|
|
|
BOOL gfAppActive = FALSE; /* Are we the active application? */
|
|
UINT gwHeightAdjust;
|
|
HWND ghwndFocus = NULL; /* Who had the focus when we went inactive*/
|
|
BOOL gfInClose = FALSE; /* ack?*/
|
|
BOOL gfCurrentCDChecked = FALSE; /* TRUE if we've checked whether it can play */
|
|
BOOL gfCurrentCDNotAudio = FALSE;/* TRUE when we have a CD that we can't play */
|
|
|
|
extern BOOL gfInPlayMCI;
|
|
|
|
LPDATAOBJECT gpClipboardDataObject = NULL; /* If non-NULL, call OleFlushClipboard on exit */
|
|
|
|
HPALETTE ghpalApp;
|
|
|
|
static sfSeekExact; // last state
|
|
|
|
UINT gwCurDevice = 0; /* current device */
|
|
UINT gwNumDevices = 0; /* number of available media devices */
|
|
MCIDEVICE garMciDevices[MAX_MCI_DEVICES]; /* array with info about a device */
|
|
|
|
|
|
/* strings which get loaded in InitMplayerDialog in init.c, English version shown here
|
|
All the sizes are much larger than needed, probably. Maybe could save nearly 100 bytes!! :)
|
|
*/
|
|
extern TCHAR gszFrames[40]; /* "frames" */
|
|
extern TCHAR gszHrs[20]; /* "hrs" */
|
|
extern TCHAR gszMin[20]; /* "min" */
|
|
extern TCHAR gszSec[20]; /* "sec" */
|
|
extern TCHAR gszMsec[20]; /* "msec" */
|
|
|
|
|
|
static SZCODE aszNULL[] = TEXT("");
|
|
static BOOL sfInLayout = FALSE; // don't let Layout get re-entered
|
|
|
|
static SZCODE szSndVol32[] = TEXT("sndvol32.exe");
|
|
|
|
|
|
static SZCODE aszTitleFormat[] = TEXT("%"TS" - %"TS"");
|
|
|
|
HANDLE ghInst; /* handle to the application instance */
|
|
HFONT ghfontMap; /* handle to the font used for drawing
|
|
the track map */
|
|
LPTSTR gszCmdLine; /* string holding the command line parms */
|
|
int giCmdShow; /* command show */
|
|
TCHAR gachFileDevice[MAX_PATH]; /* string holding the curr file or device */
|
|
TCHAR gachWindowTitle[MAX_PATH]; /* string holding name we will display */
|
|
TCHAR gachCaption[MAX_PATH]; /* string holding name we will display */
|
|
|
|
HACCEL hAccel;
|
|
int gcAccelEntries;
|
|
|
|
typedef struct _POS
|
|
{
|
|
int x;
|
|
int y;
|
|
int cx; /* This field is non-0 if we're currently sizing/moving */
|
|
int cy;
|
|
}
|
|
POS, *PPOS;
|
|
|
|
POS posSizeMove = {0,0,0,0}; /* POS we want during size/move operations */
|
|
|
|
|
|
|
|
STRING_TO_ID_MAP DevToIconIDMap[] =
|
|
{
|
|
{ szCDAudio, IDI_DCDA },
|
|
{ szVideoDisc, IDI_DDEFAULT },
|
|
{ szSequencer, IDI_DMIDI },
|
|
{ szVCR, IDI_DDEFAULT },
|
|
{ szWaveAudio, IDI_DSOUND },
|
|
{ szAVIVideo, IDI_DVIDEO }
|
|
};
|
|
|
|
|
|
//CDA file processing///////////////////////////////////////////////////
|
|
//The following structure taken from deluxecd. This is used in processing
|
|
typedef struct {
|
|
DWORD dwRIFF; // 'RIFF'
|
|
DWORD dwSize; // Chunk size = (file size - 8)
|
|
DWORD dwCDDA; // 'CDDA'
|
|
DWORD dwFmt; // 'fmt '
|
|
DWORD dwCDDASize; // Chunk size of 'fmt ' = 24
|
|
WORD wFormat; // Format tag
|
|
WORD wTrack; // Track number
|
|
DWORD DiscID; // Unique disk id
|
|
DWORD lbnTrackStart; // Track starting sector (LBN)
|
|
DWORD lbnTrackLength; // Track length (LBN count)
|
|
DWORD msfTrackStart; // Track starting sector (MSF)
|
|
DWORD msfTrackLength; // Track length (MSF)
|
|
} RIFFCDA;
|
|
|
|
void HandleCDAFile(TCHAR *szFile);
|
|
BOOL IsTrackFileNameValid(LPTSTR lpstFileName, UINT *pUiTrackIndex);
|
|
void JumpToCDTrack(UINT trackno);
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
/* private function prototypes */
|
|
|
|
//int PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int iCmdShow);
|
|
void CleanUpClipboard();
|
|
int GetHeightAdjust(HWND hwnd);
|
|
HANDLE PASCAL GetDib (VOID);
|
|
|
|
|
|
static HHOOK fpfnOldMsgFilter;
|
|
static HOOKPROC fpfnMsgHook;
|
|
//Data used for supporting context menu help
|
|
BOOL bF1InMenu=FALSE; //If true F1 was pressed on a menu item.
|
|
UINT currMenuItem=0; //The current menu item if any.
|
|
|
|
|
|
typedef void (FAR PASCAL *PENWINREGISTERPROC)(UINT, BOOL);
|
|
|
|
/* Define some constants to make parameters to CreateEvent a tad less obscure:
|
|
*/
|
|
#define EVENT_DEFAULT_SECURITY NULL
|
|
#define EVENT_RESET_MANUAL TRUE
|
|
#define EVENT_RESET_AUTOMATIC FALSE
|
|
#define EVENT_INITIAL_STATE_SIGNALED TRUE
|
|
#define EVENT_INITIAL_STATE_NOT_SIGNALED FALSE
|
|
#define EVENT_NO_NAME NULL
|
|
|
|
HANDLE heventCmdLineScanned; /* Event will be signaled when command line scanned */
|
|
HANDLE heventDeviceMenuBuilt; /* Event will be signaled when device menu complete */
|
|
|
|
#ifdef LATER
|
|
SCALE gscaleInitXY[2] = { 0, 0, 0, 0 }; // Initial scale to use for inserting OLE objects
|
|
#endif
|
|
|
|
|
|
|
|
/*------------------------------------------------------+
|
|
| HelpMsgFilter - filter for F1 key in dialogs |
|
|
| |
|
|
+------------------------------------------------------*/
|
|
|
|
DWORD FAR PASCAL HelpMsgFilter(int nCode, DWORD_PTR wParam, DWORD_PTR lParam)
|
|
{
|
|
if (nCode >= 0){
|
|
LPMSG msg = (LPMSG)lParam;
|
|
|
|
if ((msg->message == WM_KEYDOWN) && (msg->wParam == VK_F1))
|
|
{
|
|
if(nCode == MSGF_MENU)
|
|
bF1InMenu = TRUE;
|
|
SendMessage(ghwndApp, WM_COMMAND, (WPARAM)IDM_HELPTOPICS, 0L);
|
|
}
|
|
}
|
|
// return DefHookProc(nCode, wParam, lParam, (HHOOK FAR *)&fpfnOldMsgFilter);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CHICAGO_PRODUCT
|
|
|
|
BOOL IsBadSegmentedCodePtr(LPARAM lpPtr)
|
|
{
|
|
#define DSC_PRESENT 0x80
|
|
#define DSC_CODE_BIT 0x08
|
|
#define DSC_RW_BIT 0x02
|
|
#define DSC_DISCARDABLE 0x10
|
|
|
|
WORD wSel;
|
|
WORD wOff;
|
|
BOOL fRet;
|
|
|
|
wSel = HIWORD(lpPtr);
|
|
wOff = LOWORD(lpPtr);
|
|
|
|
_asm {
|
|
mov ax, [wSel];
|
|
lar bx, ax;
|
|
jnz ValidDriverCallback_Failure ; //Return TRUE for error
|
|
|
|
mov ch, DSC_CODE_BIT or DSC_RW_BIT or DSC_PRESENT ;
|
|
and bh, ch;
|
|
cmp bh, ch;
|
|
jne ValidDriverCallback_Failure ; //Not executable segment
|
|
|
|
test bl, DSC_DISCARDABLE ;
|
|
jnz ValidDriverCallback_Failure ; //Not fixed segment
|
|
|
|
lsl cx, ax; ; //Get segment limit
|
|
mov bx, [wOff];
|
|
cmp bx, cx;
|
|
jb ValidDriverCallback_Success ; //Valid offset
|
|
|
|
jne ValidDriverCallback_Failure ; //Not executable segment
|
|
|
|
ValidDriverCallback_Failure:
|
|
mov eax, 1;
|
|
jmp ValidDriverCallback_Return;
|
|
ValidDriverCallback_Success:
|
|
xor eax, eax;
|
|
ValidDriverCallback_Return:
|
|
mov [fRet], eax;
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* RouteKeyPresses
|
|
*
|
|
* Reroutes cursor keys etc to track bar.
|
|
*/
|
|
void RouteKeyPresses(PMSG pMsg)
|
|
{
|
|
/* Hack for PowerPoint
|
|
*
|
|
* Mail from PaulWa:
|
|
*
|
|
* --------
|
|
* Here's a problem you might consider fixing.
|
|
* Launching Media Player with certain keystrokes
|
|
* doesn't work right (e.g. arrow keys, page up/down,
|
|
* etc.).
|
|
*
|
|
* The problem is due to the fact that Media Player
|
|
* handles key up events. We use the key down event
|
|
* to launch the server in slideshow, but then the key
|
|
* up event is passed to the server. It would probably
|
|
* be best for Media Player to ignore key up events
|
|
* unless it had previously received a key down.
|
|
* If this is very difficult to fix in Media Player,
|
|
* then we can fix it in PP by launching servers on
|
|
* key up rather than key down. However, other container
|
|
* apps will see the same problem.
|
|
* --------
|
|
*
|
|
* OK, in the spirit of cooperation, let's hack things
|
|
* so our PowerPoint friends can carry on with their
|
|
* dubious practices.
|
|
*/
|
|
static WPARAM LastVKeyDown;
|
|
|
|
/* On key down when we're embedded, remember what is was:
|
|
*/
|
|
if (gfRunWithEmbeddingFlag && (pMsg->message == WM_KEYDOWN))
|
|
LastVKeyDown = pMsg->wParam;
|
|
|
|
/* Don't reroute if it's a key up that doesn't match
|
|
* the last key down; this effectively ignores it:
|
|
*/
|
|
if (gfRunWithEmbeddingFlag &&
|
|
(pMsg->message == WM_KEYUP) && (pMsg->wParam != LastVKeyDown))
|
|
{
|
|
DPF0("Ignoring WM_KEYUP, since it doesn't match last WM_KEYDOWN.\n");
|
|
}
|
|
else
|
|
{
|
|
switch(pMsg->wParam)
|
|
{
|
|
case VK_UP:
|
|
case VK_LEFT:
|
|
case VK_DOWN:
|
|
case VK_RIGHT:
|
|
case VK_NEXT:
|
|
case VK_PRIOR:
|
|
case VK_HOME:
|
|
case VK_END:
|
|
pMsg->hwnd = ghwndTrackbar;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pMsg->message == WM_KEYUP)
|
|
LastVKeyDown = 0;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* WinMain(hInst, hPrev, szCmdLine, iCmdShow)
|
|
*
|
|
* This is the main procedure for the application. It performs initialization
|
|
* and then enters a message-processing loop, where it remains until it
|
|
* receives a WM_QUIT message (meaning the app was closed). This function
|
|
* always returns TRUE..
|
|
*
|
|
*/
|
|
int WINAPI WinMain( HINSTANCE hInst /* handle to the current instance of the application */
|
|
, HINSTANCE hPrev /* handle to the previous instance of the application */
|
|
, LPSTR szCmdLine /* null-terminated string holding the command line params */
|
|
, int iCmdShow /* how the window should be initially displayed */
|
|
)
|
|
{
|
|
MSG rMsg; /* variable used for holding a message */
|
|
HWND hwndFocus;
|
|
HWND hwndP;
|
|
|
|
/* call the Pen Windows extensions to allow them to subclass our
|
|
edit controls if they so wish
|
|
*/
|
|
|
|
OSVERSIONINFO OSVersionInfo;
|
|
|
|
#ifdef UNICODE
|
|
LPTSTR szUnicodeCmdLine;
|
|
|
|
szUnicodeCmdLine = AllocateUnicodeString(szCmdLine);
|
|
#endif
|
|
|
|
heventCmdLineScanned = CreateEvent( EVENT_DEFAULT_SECURITY,
|
|
EVENT_RESET_MANUAL,
|
|
EVENT_INITIAL_STATE_NOT_SIGNALED,
|
|
EVENT_NO_NAME );
|
|
|
|
heventDeviceMenuBuilt = CreateEvent( EVENT_DEFAULT_SECURITY,
|
|
EVENT_RESET_MANUAL,
|
|
EVENT_INITIAL_STATE_NOT_SIGNALED,
|
|
EVENT_NO_NAME );
|
|
|
|
if (!heventCmdLineScanned || !heventDeviceMenuBuilt)
|
|
return FALSE;
|
|
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
|
|
GetVersionEx(&OSVersionInfo);
|
|
|
|
gwPlatformId = OSVersionInfo.dwPlatformId;
|
|
|
|
|
|
giCmdShow = iCmdShow;
|
|
|
|
#ifdef UNICODE
|
|
if (!AppInit(hInst,hPrev,szUnicodeCmdLine))
|
|
#else
|
|
if (!AppInit(hInst,hPrev,szCmdLine))
|
|
#endif
|
|
return FALSE;
|
|
|
|
/* Device Menu Initialization:
|
|
*
|
|
* If the user has requested an Open dialog (by supplying the /open
|
|
* flag with no file name), we've already built the Device menu,
|
|
* since the list of devices is required up front.
|
|
*
|
|
* If we're just playing in tiny mode, we don't need the device list.
|
|
* It will be built if the user switches to full mode and then accesses
|
|
* the Device menu or selects File.Open.
|
|
*
|
|
* Otherwise go for it. The main window's already up now, so we
|
|
* can build the list on a background thread. Don't forget to wait
|
|
* for the event to be signaled when the appropriate menu is accessed.
|
|
*/
|
|
if (!gfOpenDialog && !gfPlayOnly)
|
|
InitDeviceMenu();
|
|
|
|
#ifdef UNICODE
|
|
// ScanCmdLine mangles it, so forget it
|
|
// FreeUnicodeString(szUnicodeCmdLine);
|
|
#endif
|
|
|
|
/* setup the message filter to handle grabbing F1 for this task */
|
|
fpfnMsgHook = (HOOKPROC)MakeProcInstance((FARPROC)HelpMsgFilter, ghInst);
|
|
fpfnOldMsgFilter = (HHOOK)SetWindowsHook(WH_MSGFILTER, fpfnMsgHook);
|
|
|
|
#ifdef DEBUG
|
|
GdiSetBatchLimit(1);
|
|
#endif
|
|
|
|
for (;;)
|
|
{
|
|
/* If we're ever still around after being destroyed, DIE! */
|
|
if (!IsWindow(ghwndApp))
|
|
break;
|
|
|
|
/* call the server code and let it unblock the server */
|
|
#ifdef OLE1_HACK
|
|
ServerUnblock();
|
|
#endif /* OLE1_HACK */
|
|
|
|
/* Polling messages from event queue */
|
|
|
|
if (!GetMessage(&rMsg, NULL, 0, 0))
|
|
break;
|
|
|
|
if (gfPlayingInPlace) {
|
|
|
|
// If focus ever gets to the client during play in place,
|
|
// be really nasty and force focus to us. (Aldus BUG!!!!)
|
|
// Aldus Persuasion won't play in place without this.
|
|
|
|
hwndFocus = GetFocus();
|
|
hwndP = GetParent(ghwndApp);
|
|
|
|
if (!ghwndIPHatch && hwndFocus && hwndP &&
|
|
GetWindowTask(hwndP) == GetWindowTask(hwndFocus))
|
|
PostCloseMessage();
|
|
}
|
|
|
|
/* Hack: post END_SCROLL messages with lParam == -1 */
|
|
|
|
if ((rMsg.hwnd==ghwndApp)
|
|
|| (rMsg.hwnd && GetParent(rMsg.hwnd)==ghwndApp))
|
|
{
|
|
/* Reroute arrow keys etc to track bar:
|
|
*/
|
|
if (rMsg.message == WM_KEYDOWN || rMsg.message == WM_KEYUP)
|
|
RouteKeyPresses(&rMsg);
|
|
}
|
|
|
|
|
|
if (IsWindow(ghwndApp)) {
|
|
|
|
if (gfRunWithEmbeddingFlag
|
|
&& docMain.lpIpData
|
|
&& docMain.lpIpData->lpFrame
|
|
&& !IsAccelerator(hAccel, gcAccelEntries, &rMsg, NULL)
|
|
&& OleTranslateAccelerator(docMain.lpIpData->lpFrame,
|
|
&docMain.lpIpData->frameInfo, &rMsg) == NOERROR) {
|
|
continue;
|
|
}
|
|
|
|
if (hAccel && TranslateAccelerator(ghwndApp, hAccel, &rMsg))
|
|
continue;
|
|
|
|
}
|
|
|
|
if (rMsg.message == WM_TIMER && rMsg.hwnd == NULL) {
|
|
#ifdef CHICAGO_PRODUCT
|
|
/* The reason for requiring the following test is now lost
|
|
* in the mists of time. Now this app is 32-bit, these
|
|
* bogus timer callbacks (if they really do still occur)
|
|
* could be 16-bit, so we need to add yet more ugliness
|
|
* in the form of assembler to an app which is already
|
|
* hardly a paragon of pulchritude.
|
|
*
|
|
* A plea:
|
|
*
|
|
* If you add some obscure code such as below, to this or
|
|
* any other app, even if it has only the teeniest chance
|
|
* of being less blindingly obvious to someone else than
|
|
* it is to you at the time of writing, please please please
|
|
* add a f***ing comment.
|
|
*
|
|
* Respectfully,
|
|
* A Developer
|
|
*/
|
|
if (IsBadSegmentedCodePtr(rMsg.lParam))
|
|
#else
|
|
if (IsBadCodePtr((FARPROC)rMsg.lParam))
|
|
#endif /* ~CHICAGO_PRODUCT */
|
|
{
|
|
DPF0("Bad function pointer (%08lx) in WM_TIMER message\n", rMsg.lParam);
|
|
rMsg.message = WM_NULL;
|
|
}
|
|
}
|
|
if (rMsg.message == WM_SYSCOMMAND
|
|
&& (((0xFFF0 & rMsg.wParam) == SC_MOVE)|| ((0xFFF0 & rMsg.wParam) == SC_SIZE)) ) {
|
|
// If ANY window owned by our thread is going into a modal
|
|
// size or move loop then we need to force some repainting to
|
|
// take place. The cost of not doing so is that garbage can
|
|
// be left lying around on the trackbar, e.g. bits of system
|
|
// menu, or partially drawn sliders.
|
|
UpdateWindow(ghwndApp);
|
|
}
|
|
TranslateMessage(&rMsg);
|
|
DispatchMessage(&rMsg);
|
|
}
|
|
|
|
ghwndApp = NULL;
|
|
|
|
/* Delete the track map font that we created earlier. */
|
|
|
|
if (ghfontMap != NULL) {
|
|
DeleteObject(ghfontMap);
|
|
ghfontMap = NULL;
|
|
}
|
|
|
|
if (ghbrFillPat)
|
|
DeleteObject(ghbrFillPat);
|
|
|
|
if (ghpalApp)
|
|
DeleteObject(ghpalApp);
|
|
|
|
/* if the message hook was installed, remove it and free */
|
|
/* up our proc instance for it. */
|
|
if (fpfnOldMsgFilter){
|
|
UnhookWindowsHook(WH_MSGFILTER, fpfnMsgHook);
|
|
}
|
|
|
|
ControlCleanup();
|
|
|
|
// TermServer();
|
|
|
|
/*********************************************************************
|
|
** OLE2NOTE: the very last thing an app must be do is properly shut
|
|
** down OLE. This call MUST be guarded! it is only allowable to
|
|
** call OleUninitialize if OleInitialize has been called.
|
|
*********************************************************************/
|
|
|
|
// Clean shutdown for OLE
|
|
DPFI("*before oleunint");
|
|
if (gfOleInitialized) {
|
|
if (gpClipboardDataObject)
|
|
CleanUpClipboard();
|
|
(void)OleUninitialize();
|
|
IMalloc_Release(lpMalloc);
|
|
lpMalloc = NULL;
|
|
gfOleInitialized = FALSE;
|
|
}
|
|
|
|
|
|
if (hOLE32)
|
|
FreeLibrary(hOLE32);
|
|
|
|
/* End of program */
|
|
|
|
return((int)rMsg.wParam);
|
|
}
|
|
|
|
void CleanUpClipboard()
|
|
{
|
|
/* Check whether the DATAOBJECT we put on the clipboard is still there:
|
|
*/
|
|
if (OleIsCurrentClipboard(gpClipboardDataObject) == S_OK)
|
|
{
|
|
LPDATAOBJECT pIDataObject;
|
|
|
|
if (OleGetClipboard(&pIDataObject) == S_OK)
|
|
{
|
|
OleFlushClipboard();
|
|
IDataObject_Release(pIDataObject);
|
|
}
|
|
else
|
|
{
|
|
DPF0("OleGetClipboard failed\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(ghClipData)
|
|
GLOBALFREE(ghClipData);
|
|
if(ghClipMetafile)
|
|
GLOBALFREE(ghClipMetafile);
|
|
if(ghClipDib)
|
|
GLOBALFREE(ghClipDib);
|
|
}
|
|
}
|
|
|
|
//
|
|
// cancel any active menus and close the app.
|
|
//
|
|
void PostCloseMessage()
|
|
{
|
|
HWND hwnd;
|
|
|
|
hwnd = GetWindowMCI();
|
|
if (hwnd != NULL)
|
|
SendMessage(hwnd, WM_CANCELMODE, 0, 0);
|
|
SendMessage(ghwndApp, WM_CANCELMODE, 0, 0);
|
|
PostMessage(ghwndApp, WM_CLOSE, 0, 0);
|
|
}
|
|
|
|
//
|
|
// If we have a dialog box up (gfErrorBox is set) or we're disabled (we have
|
|
// a dialog box up) or the MCI device's default window is disabled (it has a
|
|
// dialog box up) then closing us would result in our deaths.
|
|
//
|
|
BOOL ItsSafeToClose(void)
|
|
{
|
|
HWND hwnd;
|
|
|
|
if (gfErrorBox)
|
|
return FALSE;
|
|
if (!IsWindowEnabled(ghwndApp))
|
|
return FALSE;
|
|
hwnd = GetWindowMCI();
|
|
if (hwnd && !IsWindowEnabled(hwnd))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* ResolveLink
|
|
*
|
|
* This routine is called when the user drags and drops a shortcut
|
|
* onto Media Player. If it succeeds, it returns the full path
|
|
* of the actual file in szResolved.
|
|
*/
|
|
BOOL ResolveLink(LPTSTR szPath, LPTSTR szResolved, LONG cbSize)
|
|
{
|
|
IShellLink *psl = NULL;
|
|
HRESULT hres;
|
|
|
|
if (!InitOLE(&gfOleInitialized, &lpMalloc))
|
|
{
|
|
DPF0("Initialization of OLE FAILED!! Can't resolve link.\n");
|
|
return FALSE;
|
|
}
|
|
|
|
hres = (HRESULT)CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC,
|
|
&IID_IShellLink, &psl);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
IPersistFile *ppf;
|
|
|
|
psl->lpVtbl->QueryInterface(psl, &IID_IPersistFile, &ppf);
|
|
|
|
if (ppf)
|
|
{
|
|
WCHAR wszPath[MAX_PATH];
|
|
#ifdef UNICODE
|
|
lstrcpy (wszPath, szPath);
|
|
#else
|
|
AnsiToUnicodeString(szPath, wszPath, UNKNOWN_LENGTH);
|
|
#endif
|
|
hres = ppf->lpVtbl->Load(ppf, wszPath, 0);
|
|
ppf->lpVtbl->Release(ppf);
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
psl->lpVtbl->Release(psl);
|
|
psl = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
psl->lpVtbl->Release(psl);
|
|
psl = NULL;
|
|
}
|
|
}
|
|
|
|
if (psl)
|
|
{
|
|
psl->lpVtbl->Resolve(psl, NULL, SLR_NO_UI);
|
|
psl->lpVtbl->GetPath(psl, szResolved, cbSize, NULL, 0);
|
|
psl->lpVtbl->Release(psl);
|
|
}
|
|
|
|
return SUCCEEDED(hres);
|
|
}
|
|
|
|
|
|
/* ResolveIfLink
|
|
*
|
|
* Called to check whether a given file name is a shortcut
|
|
* on Windows 95.
|
|
*
|
|
* Copies the resolved file name into the buffer provided,
|
|
* overwriting the original name.
|
|
*
|
|
* Returns TRUE if the function succeeded, whether or not the
|
|
* file name was changed. FALSE indicates that an error occurred.
|
|
*
|
|
* Andrew Bell, 16 February 1995
|
|
*/
|
|
BOOL ResolveIfLink(PTCHAR szFileName)
|
|
{
|
|
SHFILEINFO sfi;
|
|
BOOL rc = TRUE;
|
|
|
|
if ((SHGetFileInfo(szFileName, 0, &sfi, sizeof sfi, SHGFI_ATTRIBUTES) == 1)
|
|
&& ((sfi.dwAttributes & SFGAO_LINK) == SFGAO_LINK))
|
|
{
|
|
TCHAR szResolvedLink[MAX_PATH];
|
|
|
|
if (ResolveLink(szFileName, szResolvedLink, CHAR_COUNT(szResolvedLink)))
|
|
lstrcpy(szFileName, szResolvedLink);
|
|
else
|
|
rc = FALSE;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/* JumpToCDTrack()
|
|
*
|
|
* Jumps to the appropriate track on the CD and updates the UI accordingly
|
|
*
|
|
*/
|
|
void JumpToCDTrack(UINT trackno)
|
|
{
|
|
//If the track number is invalid just ignore.
|
|
//Let the default behaviour take place, There is no need to give a message box
|
|
//saying we couldn't jump to track.
|
|
if(trackno > gwNumTracks)
|
|
return;
|
|
|
|
/* We MUST use PostMessage because the */
|
|
/* SETPOS and ENDTRACK must happen one */
|
|
/* immediately after the other */
|
|
PostMessage(ghwndTrackbar, TBM_SETPOS, (WPARAM)TRUE, gadwTrackStart[trackno]);
|
|
PostMessage(ghwndApp, WM_HSCROLL, (WPARAM)TB_ENDTRACK, (LPARAM)ghwndTrackbar);
|
|
}
|
|
|
|
/*****************************Private*Routine******************************\
|
|
* IsTrackFileNameValid
|
|
*
|
|
* This routine copied from deluxecd and modified
|
|
*
|
|
* This function returns true if the specified filename is a valid CD track.
|
|
|
|
* On NT track filenames must be of the form:
|
|
* d:\track(n).cda where d: is the CD-Rom device and \track(n).cda
|
|
* is the index of the track to be played (starting from 1).
|
|
*
|
|
* On Chicago the track filename is actually a riff CDDA file which contains
|
|
* the track info that we require.
|
|
*
|
|
* If the filename is valid the function true and sets
|
|
* piTrackIndex to the correct value.
|
|
*
|
|
* History:
|
|
* 29-09-94 - StephenE - Created
|
|
*
|
|
\**************************************************************************/
|
|
BOOL
|
|
IsTrackFileNameValid(
|
|
LPTSTR lpstFileName,
|
|
UINT *puiTrackIndex
|
|
)
|
|
{
|
|
#define RIFF_RIFF 0x46464952
|
|
#define RIFF_CDDA 0x41444443
|
|
|
|
|
|
RIFFCDA cda;
|
|
HANDLE hFile;
|
|
int i;
|
|
DWORD cbRead;
|
|
BOOL fRead;
|
|
|
|
// Open file and read in CDA info
|
|
hFile = CreateFile (lpstFileName, GENERIC_READ,
|
|
FILE_SHARE_READ, NULL,
|
|
OPEN_EXISTING, 0, NULL);
|
|
if (INVALID_HANDLE_VALUE == hFile) {
|
|
return FALSE;
|
|
}
|
|
|
|
ZeroMemory (&cda, sizeof (cda));
|
|
fRead = ReadFile(hFile, &cda, sizeof(cda), &cbRead, NULL);
|
|
CloseHandle (hFile);
|
|
|
|
if (!fRead)
|
|
return FALSE;
|
|
|
|
//
|
|
// Make sure its a RIFF CDDA file
|
|
//
|
|
if ( (cda.dwRIFF != RIFF_RIFF) || (cda.dwCDDA != RIFF_CDDA) ) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
*puiTrackIndex = cda.wTrack - 1;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* HandleCDAFile()
|
|
*
|
|
* Checks to see if the opened file is a CDA file and tries to jump to the appropriate track.
|
|
*
|
|
*/
|
|
void HandleCDAFile(TCHAR *szFile)
|
|
{
|
|
UINT trackno;
|
|
if(IsTrackFileNameValid(szFile, &trackno))
|
|
{
|
|
JumpToCDTrack(trackno);
|
|
}
|
|
}
|
|
|
|
|
|
/* Process file drop/drag options. */
|
|
void PASCAL NEAR doDrop(HWND hwnd, HDROP hDrop)
|
|
{
|
|
RECT rc;
|
|
|
|
if(DragQueryFile(hDrop,(UINT)(~0),NULL,0)){/* # of files dropped */
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
/* If user dragged/dropped a file regardless of keys pressed
|
|
* at the time, open the first selected file from file
|
|
* manager.
|
|
*/
|
|
DragQueryFile(hDrop,0,szPath,sizeof(szPath)/sizeof(TCHAR));
|
|
SetActiveWindow(hwnd);
|
|
|
|
ResolveIfLink(szPath);
|
|
|
|
if (OpenMciDevice(szPath, NULL)) {
|
|
SubClassMCIWindow();
|
|
PostMessage(hwnd, WM_COMMAND, (WPARAM)ID_PLAY, 0);
|
|
DirtyObject(FALSE); // we're dirty now!
|
|
gfCloseAfterPlaying = FALSE; // stay up from now on
|
|
|
|
//If the CD Audio device was opened it must have been a *.cda file.
|
|
//Try to jump to the track corresponding to the file opened.
|
|
if ((gwDeviceType & DTMCI_DEVICE) == DTMCI_CDAUDIO)
|
|
{
|
|
HandleCDAFile(szPath);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gwCurDevice = 0;// force next file open dialog to say
|
|
// "all files" because CloseMCI won't.
|
|
gwCurScale = ID_NONE; // uncheck all scale types
|
|
Layout(); // Make window snap back to smaller size
|
|
}
|
|
|
|
SetMPlayerIcon();
|
|
|
|
/* Force WM_GETMINMAXINFO to be called so we'll snap to a */
|
|
/* proper size. */
|
|
GetWindowRect(ghwndApp, &rc);
|
|
MoveWindow(ghwndApp, rc.left, rc.top, rc.right - rc.left,
|
|
rc.bottom - rc.top, TRUE);
|
|
}
|
|
DragFinish(hDrop); /* Delete structure alocated for WM_DROPFILES*/
|
|
}
|
|
|
|
/* Change the number in dwPosition to the proper format. szNum contains the */
|
|
/* formatted number only "01 45:10" while szBuf contains units such as */
|
|
/* "01 45:10 (min:sec)" */
|
|
/* If fRound is set, it will not always display millisecond accuracy, but */
|
|
/* choose something useful like second accuracy or hundreth sec accuracy. */
|
|
void FAR PASCAL FormatTime(DWORD_PTR dwPosition, LPTSTR szNum, LPTSTR szBuf, BOOL fRound)
|
|
{
|
|
UINT w;
|
|
UINT hrs;
|
|
UINT min;
|
|
UINT sec;
|
|
UINT hsec;
|
|
UINT msec;
|
|
DWORD dwMaxSize = gdwMediaLength;
|
|
static TCHAR framestr[40] = TEXT("");
|
|
static TCHAR sec_str[40] = TEXT("");
|
|
static TCHAR min_str[40] = TEXT("");
|
|
static TCHAR hrs_str[40] = TEXT("");
|
|
static TCHAR msec_str[40] = TEXT("");
|
|
|
|
static SZCODE aszLongDecimal[] = TEXT("%ld");
|
|
static SZCODE aszFrameFormat[] = TEXT("%"TS" %ld");
|
|
static SZCODE asz02Decimal[] = TEXT("%02d ");
|
|
static SZCODE aszTimeFormat1[] = TEXT("%02d%c%02d%c%02d");
|
|
static SZCODE aszTimeFormat2[] = TEXT("%02d%c%02d%c%02d%c%03d");
|
|
static SZCODE aszTimeFormat3[] = TEXT("%02d%c%02d%c%02d (%"TS"%c%"TS"%c%"TS")");
|
|
static SZCODE aszTimeFormat4[] = TEXT("%02d%c%02d%c%02d%c%03d (%"TS"%c%"TS"%c%"TS"%c%"TS")");
|
|
static SZCODE aszTimeFormat5[] = TEXT("%02d%c%02d");
|
|
static SZCODE aszTimeFormat6[] = TEXT("%02d%c%02d%c%03d");
|
|
static SZCODE aszTimeFormat7[] = TEXT("%02d%c%02d (%"TS"%c%"TS")");
|
|
static SZCODE aszTimeFormat8[] = TEXT("%02d%c%02d%c%03d (%"TS"%c%"TS"%c%"TS")");
|
|
static SZCODE aszTimeFormat9[] = TEXT("%c%02d");
|
|
static SZCODE aszTimeFormat10[] = TEXT("%c%03d");
|
|
static SZCODE aszTimeFormat11[] = TEXT("%02d%c%03d");
|
|
static SZCODE aszTimeFormat12[] = TEXT("%c%02d (%"TS")");
|
|
static SZCODE aszTimeFormat13[] = TEXT("%02d%c%02d (%"TS")");
|
|
static SZCODE aszTimeFormat14[] = TEXT("%c%03d (%"TS"%c%"TS")");
|
|
static SZCODE aszTimeFormat15[] = TEXT("%02d%c%03d (%"TS"%c%"TS")");
|
|
|
|
|
|
//!!! LoadStrings at init time, dont hardcode...
|
|
|
|
#define ONE_HOUR (60ul*60ul*1000ul)
|
|
#define ONE_MINUTE (60ul*1000ul)
|
|
#define ONE_SECOND (1000ul)
|
|
|
|
if (szBuf)
|
|
*szBuf = 0;
|
|
if (szNum)
|
|
*szNum = 0;
|
|
|
|
if (gwDeviceID == (UINT)0)
|
|
return;
|
|
|
|
if (gwStatus == MCI_MODE_NOT_READY || gwStatus == MCI_MODE_OPEN)
|
|
return;
|
|
|
|
switch (gwCurScale) {
|
|
|
|
case ID_FRAMES:
|
|
if (!STRLEN(framestr))
|
|
LOADSTRING(IDS_FRAME,framestr);
|
|
if (szNum)
|
|
wsprintf(szNum, aszLongDecimal, (long)dwPosition);
|
|
if (szBuf)
|
|
wsprintf(szBuf, aszFrameFormat, framestr, (long)dwPosition);
|
|
gInc = 1; // spin arrow inc/dec by one frame
|
|
break;
|
|
|
|
case ID_TRACKS:
|
|
//
|
|
// find the track that contains this position
|
|
// also, find the longest track so we know if we should display
|
|
// hh:mm:ss or mm:ss or ss.sss or whatever.
|
|
//
|
|
|
|
if (gwNumTracks == 0)
|
|
return;
|
|
|
|
dwMaxSize = 0;
|
|
|
|
for (w=0; w<gwNumTracks-1; w++) {
|
|
|
|
if (gadwTrackStart[w+1] - gadwTrackStart[w] > dwMaxSize)
|
|
dwMaxSize = gadwTrackStart[w+1] - gadwTrackStart[w];
|
|
|
|
/* When a CD is stopped, it's still spinning, and after we */
|
|
/* seek to the beginning of a track, it may return a value */
|
|
/* slightly less than the track start everyonce in a while.*/
|
|
/* So if we're within 200ms of the track start, let's just */
|
|
/* pretend we're exactly on the start of the track. */
|
|
|
|
if (dwPosition < gadwTrackStart[w+1] &&
|
|
gadwTrackStart[w+1] - dwPosition < 200)
|
|
dwPosition = gadwTrackStart[w+1];
|
|
|
|
if (gadwTrackStart[w+1] > dwPosition)
|
|
break;
|
|
}
|
|
|
|
if (szNum) {
|
|
wsprintf(szNum, asz02Decimal, gwFirstTrack + w);
|
|
szNum += 3;
|
|
}
|
|
if (szBuf) {
|
|
wsprintf(szBuf, asz02Decimal, gwFirstTrack + w);
|
|
szBuf += 3;
|
|
}
|
|
|
|
dwPosition -= gadwTrackStart[w];
|
|
|
|
for (; w < gwNumTracks - 1; w++) {
|
|
if (gadwTrackStart[w+1] - gadwTrackStart[w] > dwMaxSize)
|
|
dwMaxSize = gadwTrackStart[w+1] - gadwTrackStart[w];
|
|
}
|
|
|
|
// fall through
|
|
|
|
case ID_TIME:
|
|
if (!STRLEN(sec_str))
|
|
{
|
|
LOADSTRING(IDS_SEC,sec_str);
|
|
LOADSTRING(IDS_HRS,hrs_str);
|
|
LOADSTRING(IDS_MIN,min_str);
|
|
LOADSTRING(IDS_MSEC,msec_str);
|
|
}
|
|
|
|
min = (UINT)((dwPosition / ONE_MINUTE) % 60);
|
|
sec = (UINT)((dwPosition / ONE_SECOND) % 60);
|
|
msec = (UINT)(dwPosition % 1000);
|
|
|
|
if (dwMaxSize > ONE_HOUR) {
|
|
|
|
hrs = (UINT)(dwPosition / ONE_HOUR);
|
|
|
|
if (szNum && fRound) {
|
|
wsprintf(szNum, aszTimeFormat1,
|
|
hrs, chTime, min, chTime, sec);
|
|
} else if (szNum) {
|
|
wsprintf(szNum, aszTimeFormat2,
|
|
hrs, chTime, min, chTime, sec, chDecimal, msec);
|
|
}
|
|
|
|
if (szBuf && fRound) {
|
|
wsprintf(szBuf, aszTimeFormat3,
|
|
hrs, chTime, min, chTime, sec, hrs_str,
|
|
chTime, min_str, chTime, sec_str);
|
|
} else if (szBuf) {
|
|
wsprintf(szBuf,
|
|
aszTimeFormat4,
|
|
hrs, chTime, min, chTime, sec, chDecimal, msec,
|
|
hrs_str,chTime, min_str,chTime,
|
|
sec_str, chDecimal, msec_str);
|
|
}
|
|
|
|
gInc = 1000; // spin arrow inc/dec by seconds
|
|
|
|
} else if (dwMaxSize > ONE_MINUTE) {
|
|
|
|
if (szNum && fRound) {
|
|
wsprintf(szNum, aszTimeFormat5, min, chTime, sec);
|
|
} else if (szNum) {
|
|
wsprintf(szNum, aszTimeFormat6, min, chTime, sec,
|
|
chDecimal, msec);
|
|
}
|
|
|
|
if (szBuf && fRound) {
|
|
wsprintf(szBuf, aszTimeFormat7, min, chTime, sec,
|
|
min_str,chTime,sec_str);
|
|
} else if (szBuf) {
|
|
wsprintf(szBuf, aszTimeFormat8,
|
|
min, chTime, sec, chDecimal, msec,
|
|
min_str,chTime,sec_str, chDecimal,
|
|
msec_str);
|
|
}
|
|
|
|
gInc = 1000; // spin arrow inc/dec by seconds
|
|
|
|
} else {
|
|
|
|
hsec = (UINT)((dwPosition % 1000) / 10);
|
|
|
|
if (szNum && fRound) {
|
|
if (!sec && chLzero == TEXT('0'))
|
|
wsprintf(szNum, aszTimeFormat9, chDecimal, hsec);
|
|
else
|
|
wsprintf(szNum, aszTimeFormat5, sec, chDecimal, hsec);
|
|
|
|
} else if (szNum) {
|
|
if (!sec && chLzero == TEXT('0'))
|
|
wsprintf(szNum, aszTimeFormat10, chDecimal, msec);
|
|
else
|
|
wsprintf(szNum, aszTimeFormat11, sec, chDecimal, msec);
|
|
}
|
|
|
|
if (szBuf && fRound) {
|
|
if (!sec && chLzero == TEXT('0'))
|
|
wsprintf(szBuf, aszTimeFormat12, chDecimal, hsec, sec_str);
|
|
else
|
|
wsprintf(szBuf, aszTimeFormat13, sec, chDecimal, hsec, sec_str);
|
|
|
|
} else if (szBuf) {
|
|
if (!sec && chLzero == TEXT('0'))
|
|
wsprintf(szBuf, aszTimeFormat14, chDecimal,
|
|
msec, sec_str,chDecimal,msec_str);
|
|
else
|
|
wsprintf(szBuf, aszTimeFormat15, sec, chDecimal,
|
|
msec, sec_str,chDecimal,msec_str);
|
|
}
|
|
|
|
gInc = 100; // spin arrow inc/dec by 1/10 second
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
BOOL IsCdromDataOnly();
|
|
|
|
|
|
BOOL UpdateWindowText(HWND hwnd, LPTSTR Text)
|
|
{
|
|
TCHAR CurrentText[80];
|
|
|
|
GetWindowText(hwnd, CurrentText, CHAR_COUNT(CurrentText));
|
|
|
|
if(lstrcmp(Text, CurrentText))
|
|
return SetWindowText(hwnd, Text);
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* UpdateDisplay()
|
|
*
|
|
* Update the scrollbar, buttons, etc. If the media information (media
|
|
* length, no. tracks, etc.) is not currently valid, then update it first.
|
|
*
|
|
* The following table shows how the current status (value of <gwStatus>)
|
|
* affects which windows are enabled:
|
|
*
|
|
* Play Pause Stop Eject
|
|
* MCI_MODE_STOP ENABLE n/a ENABLE
|
|
* MCI_MODE_PAUSE ENABLE n/a ENABLE ENABLE
|
|
* MCI_MODE_PLAY n/a ENABLE ENABLE ENABLE
|
|
* MCI_MODE_OPEN n/a ENABLE
|
|
* MCI_MODE_RECORD ?????? ?????? ?????? ??????
|
|
* MCI_MODE_SEEK ENABLE n/a ENABLE ENABLE
|
|
*
|
|
* MCI_MODE_NOT_READY ALL DISABLED
|
|
*
|
|
* The eject button is always enabled if the medium can be ejected and
|
|
* disabled otherwise.
|
|
*
|
|
* In open mode, either Play or Eject will cause the media door to close,
|
|
* but Play will also begin play. In any mode, Eject always does an
|
|
* implicit Stop first.
|
|
*
|
|
* If <gwDeviceID> is NULL, then there is no current device and all four
|
|
* of these buttons are disabled.
|
|
*
|
|
*/
|
|
void FAR PASCAL UpdateDisplay(void)
|
|
{
|
|
DWORD_PTR dwPosition; /* the current position within the medium */
|
|
UINT wStatusMCI; /* status of the device according to MCI */
|
|
#if 0
|
|
TOOLBUTTON tb;
|
|
#endif
|
|
static BOOL sfBlock = FALSE; // keep SeekMCI from causing infinite loop
|
|
|
|
/* Don't even think about updating the display if the trackbar's scrolling: */
|
|
if (gfScrollTrack)
|
|
return;
|
|
|
|
/* We've been re-entered */
|
|
if (sfBlock)
|
|
return;
|
|
|
|
/*
|
|
* if for some reason we were closed, close now!
|
|
*/
|
|
if (gfErrorDeath) {
|
|
DPF("*** Trying to close window now!\n");
|
|
PostMessage(ghwndApp, gfErrorDeath, 0, 0);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If the track information is not valid (e.g. a CD was just inserted),
|
|
* then update it.
|
|
*
|
|
*/
|
|
|
|
if (!gfValidMediaInfo)
|
|
UpdateMCI(); /* update the appropriate global variables*/
|
|
|
|
/*
|
|
* Determine the current position and status ( stopped, playing, etc. )
|
|
* as MCI believes them to be.
|
|
*
|
|
*/
|
|
|
|
wStatusMCI = StatusMCI(&dwPosition);
|
|
|
|
|
|
|
|
/* The deal here is that the user can insert CDs, any of which may not be
|
|
* playable because they contain no audio tracks. So, as soon as we detect
|
|
* that we have a CD we haven't checked, make sure we can play it.
|
|
* If the current device is CD, and the door isn't open, check it.
|
|
*
|
|
*/
|
|
if (((gwDeviceType & DTMCI_DEVICE) == DTMCI_CDAUDIO) &&
|
|
(wStatusMCI != MCI_MODE_OPEN))
|
|
{
|
|
if (!gfCurrentCDChecked)
|
|
{
|
|
if (IsCdromDataOnly())
|
|
{
|
|
gfCurrentCDNotAudio = TRUE;
|
|
gwCurScale = ID_NONE;
|
|
Error(ghwndApp, IDS_INSERTAUDIODISC);
|
|
}
|
|
else
|
|
gfCurrentCDNotAudio = FALSE;
|
|
|
|
gfCurrentCDChecked = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gfCurrentCDChecked = FALSE; // Otherwise, make sure it gets cleared.
|
|
gfCurrentCDNotAudio = FALSE;
|
|
}
|
|
|
|
|
|
/* Here's the problem: If the medium is short, we'll send a Play command */
|
|
/* but it'll stop before we notice it was ever playing. So if we know */
|
|
/* that we just sent a PlayMCI command, but the status isn't PLAY, then */
|
|
/* force the last command to be PLAY. Also, once we notice we are playing*/
|
|
/* we can clear gfJustPlayed. */
|
|
|
|
if (wStatusMCI == MCI_MODE_PLAY && gfJustPlayed)
|
|
gfJustPlayed = FALSE;
|
|
if (((wStatusMCI == MCI_MODE_STOP) || (wStatusMCI == MCI_MODE_SEEK)) && gfJustPlayed) {
|
|
gwStatus = MCI_MODE_PLAY;
|
|
gfJustPlayed = FALSE;
|
|
}
|
|
|
|
if (wStatusMCI == MCI_MODE_SEEK) {
|
|
// The second major problem is this. During rewind the status
|
|
// is SEEK. If we detect MODE_SEEK we will not restart the play,
|
|
// and it looks like the auto replay simply ended. Seeking back to
|
|
// the beginning can take a significant amount of time. We allow
|
|
// ourselves to wait for up to half a second to give the device,
|
|
// particularly AVI from a CD or over the network, a chance to
|
|
// catch up. Any slower response and the autorepeat will terminate.
|
|
dwPosition = gdwLastSeekToPosition;
|
|
if (!gfUserStopped && (gwOptions&OPT_AUTOREP)) {
|
|
UINT n=15;
|
|
for (; n; --n) {
|
|
|
|
Sleep(32);
|
|
// If autorepeating and device is seeking, try the status
|
|
// again in case it has got back to the beginning
|
|
wStatusMCI = StatusMCI(&dwPosition);
|
|
|
|
if (wStatusMCI != MCI_MODE_SEEK) {
|
|
wStatusMCI = MCI_MODE_STOP;
|
|
break; // Exit the FOR loop
|
|
} else {
|
|
dwPosition = gdwLastSeekToPosition;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The current device status has
|
|
* changed from the way MPlayer last perceived it, so update the display
|
|
* and make MPlayer agree with MCI again.
|
|
*
|
|
*/
|
|
|
|
// After we close, our last timer msg must gray stuff and execute this //
|
|
if (!gwDeviceID || wStatusMCI != gwStatus) {
|
|
DWORD dwEndMedia, dwStartSel, dwEndSel, dwEndSelDelta;
|
|
|
|
/* Auto-repeat and Rewind happen if you stop at the end of the media */
|
|
/* (rewind to beginning) or if you stop at the end of the selection */
|
|
/* (rewind to beginning of selection). */
|
|
|
|
dwEndMedia = MULDIV32(gdwMediaLength + gdwMediaStart, 99, 100L);
|
|
dwStartSel = (DWORD)SendMessage(ghwndTrackbar, TBM_GETSELSTART, 0, 0);
|
|
dwEndSel = (DWORD)SendMessage(ghwndTrackbar, TBM_GETSELEND, 0, 0);
|
|
if (dwEndSel != -1) {
|
|
dwEndSelDelta = MULDIV32(dwEndSel, 99, 100L);
|
|
} else {
|
|
dwEndSelDelta = 0; // force (dwPosition >= dwEndSelDelta) to FALSE
|
|
}
|
|
|
|
if ((wStatusMCI == MCI_MODE_STOP || wStatusMCI == MCI_MODE_PAUSE)
|
|
&& ((dwPosition >= dwEndMedia) || (dwPosition==0) ||
|
|
(dwPosition >= dwEndSelDelta && gfJustPlayedSel))
|
|
&& dwPosition >= gdwMediaStart // dwPosition may == the beginning
|
|
&& !gfScrollTrack
|
|
&& (gwStatus == MCI_MODE_PLAY || gwStatus == MCI_MODE_SEEK)) {
|
|
|
|
DPF("End of medium\n");
|
|
|
|
/* We're at the end of the entire media or at the end of */
|
|
/* our selection now, and stopped automatically (not */
|
|
/* by the user). We were playing or seeking. So */
|
|
/* we can check the Auto Repeat and Auto Rewind flags. */
|
|
/* CD players seem to return a length that's too big, so */
|
|
/* we check for > 99% done. Use semaphore to keep from */
|
|
/* causing an infinite loop. */
|
|
|
|
if (!gfUserStopped && (gwOptions & OPT_AUTOREP)) {
|
|
DPF("Auto-Repeat\n");
|
|
sfBlock = TRUE; // calls UpdateDisplay which will
|
|
// re-enter this code just before mode
|
|
|
|
/* Repeat either the selection or whole thing. */
|
|
/* NOTE: Must send message while gwStatus is STOPPED.*/
|
|
|
|
gwStatus = wStatusMCI; // old status no longer valid
|
|
if (gfJustPlayedSel && dwPosition >= dwEndSelDelta)
|
|
{
|
|
SeekMCI(dwStartSel); // MCICDA doen't go to start w/out this.
|
|
SendMessage(ghwndApp, WM_COMMAND, (WPARAM)ID_PLAYSEL, 0);
|
|
}
|
|
else
|
|
{
|
|
SeekToStartMCI();
|
|
SendMessage(ghwndApp, WM_COMMAND, (WPARAM)ID_PLAY, 0);
|
|
}
|
|
|
|
sfBlock = FALSE; // switches to SEEK.
|
|
gwStatus = (UINT)(-1); // old status no longer valid
|
|
return; // because we are switching modes
|
|
|
|
} else if (!gfCloseAfterPlaying && !gfUserStopped &&
|
|
(gwOptions & OPT_AUTORWD)) {
|
|
DPF("Auto-Rewind to media start\n");
|
|
//
|
|
// set gwStatus so SeekMCI will just seek!
|
|
sfBlock = TRUE; // calls UpdateDisplay which will
|
|
// re-enter this code just before mode
|
|
// switches to SEEK.
|
|
|
|
/* Rewind either the selection or whole thing. */
|
|
gwStatus = wStatusMCI; // or SeekMCI will play, too.
|
|
if (gfJustPlayedSel && dwPosition >= dwEndSelDelta)
|
|
{
|
|
SeekMCI(dwStartSel);
|
|
}
|
|
else
|
|
{
|
|
SeekToStartMCI();
|
|
}
|
|
sfBlock = FALSE;
|
|
gwStatus = (UINT)(-1); // old status no longer valid
|
|
return; // because we are switching modes
|
|
}
|
|
else if (gfCloseAfterPlaying)
|
|
PostCloseMessage();
|
|
}
|
|
|
|
/*
|
|
* Enable or disable the various controls according to the new status,
|
|
* following the rules given in the header to this function.
|
|
*
|
|
*/
|
|
|
|
EnableWindow(ghwndTrackbar, TRUE); // Good to always have something enabled
|
|
|
|
/* Show status bar if full mplayer and if device loaded */
|
|
if (ghwndStatic && !gfPlayOnly)
|
|
{
|
|
if (IsWindowVisible(ghwndStatic) != (gwDeviceID ? TRUE : FALSE))
|
|
{
|
|
ShowWindow(ghwndStatic, gwDeviceID ? SW_SHOW : SW_HIDE);
|
|
InvalidateRect(ghwndApp, NULL, TRUE);
|
|
}
|
|
}
|
|
|
|
if (gwDeviceID != (UINT)0 ) {
|
|
|
|
switch (wStatusMCI)
|
|
{
|
|
case MCI_MODE_PLAY:
|
|
toolbarSetFocus(ghwndToolbar,BTN_PAUSE);
|
|
break;
|
|
|
|
case MCI_MODE_PAUSE:
|
|
case MCI_MODE_STOP:
|
|
toolbarSetFocus(ghwndToolbar,BTN_PLAY);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (wStatusMCI == MCI_MODE_OPEN || wStatusMCI == MCI_MODE_NOT_READY ||
|
|
gwDeviceID == (UINT)0 ||
|
|
((gwDeviceType & DTMCI_DEVICE) == DTMCI_CDAUDIO) && gfCurrentCDNotAudio) {
|
|
/* Try to modify both -- one of them should work */
|
|
|
|
toolbarModifyState(ghwndToolbar, BTN_PLAY, TBINDEX_MAIN, BTNST_GRAYED);
|
|
toolbarModifyState(ghwndToolbar, BTN_PAUSE, TBINDEX_MAIN, BTNST_GRAYED);
|
|
|
|
toolbarModifyState(ghwndToolbar, BTN_HOME, TBINDEX_MAIN, BTNST_GRAYED);
|
|
toolbarModifyState(ghwndToolbar, BTN_END, TBINDEX_MAIN, BTNST_GRAYED);
|
|
toolbarModifyState(ghwndToolbar, BTN_RWD, TBINDEX_MAIN, BTNST_GRAYED);
|
|
toolbarModifyState(ghwndToolbar, BTN_FWD, TBINDEX_MAIN, BTNST_GRAYED);
|
|
|
|
SendMessage(ghwndTrackbar, TBM_SETRANGEMIN, (WPARAM)FALSE, 0);
|
|
SendMessage(ghwndTrackbar, TBM_SETRANGEMAX, (WPARAM)FALSE, 0);
|
|
SendMessage(ghwndTrackbar, TBM_CLEARTICS, (WPARAM)FALSE, 0);
|
|
SendMessage(ghwndTrackbar, TBM_CLEARSEL, (WPARAM)TRUE, 0);
|
|
|
|
if (ghwndMark) {
|
|
toolbarModifyState(ghwndMark, BTN_MARKIN, TBINDEX_MARK, BTNST_GRAYED);
|
|
toolbarModifyState(ghwndMark, BTN_MARKOUT, TBINDEX_MARK, BTNST_GRAYED);
|
|
}
|
|
|
|
if (ghwndFSArrows) {
|
|
toolbarModifyState(ghwndFSArrows, ARROW_NEXT, TBINDEX_ARROWS, BTNST_GRAYED);
|
|
toolbarModifyState(ghwndFSArrows, ARROW_PREV, TBINDEX_ARROWS, BTNST_GRAYED);
|
|
}
|
|
|
|
/* Enable transport and Mark buttons if we come from a state where */
|
|
/* they were gray. Layout will then re-gray the ones that */
|
|
/* shouldn't have been enabled because they don't fit. */
|
|
} else if (gwStatus == MCI_MODE_OPEN || gwStatus == MCI_MODE_NOT_READY
|
|
|| gwStatus == -1 ) {
|
|
|
|
/* Only one of these buttons exists */
|
|
toolbarModifyState(ghwndToolbar, BTN_PLAY, TBINDEX_MAIN, BTNST_UP);
|
|
toolbarModifyState(ghwndToolbar, BTN_PAUSE, TBINDEX_MAIN, BTNST_UP);
|
|
|
|
if (!gfPlayOnly || gfOle2IPEditing) {
|
|
toolbarModifyState(ghwndToolbar, BTN_HOME, TBINDEX_MAIN, BTNST_UP);
|
|
toolbarModifyState(ghwndToolbar, BTN_END, TBINDEX_MAIN, BTNST_UP);
|
|
toolbarModifyState(ghwndToolbar, BTN_RWD, TBINDEX_MAIN, BTNST_UP);
|
|
toolbarModifyState(ghwndToolbar, BTN_FWD, TBINDEX_MAIN, BTNST_UP);
|
|
|
|
if (ghwndMark) {
|
|
toolbarModifyState(ghwndMark, BTN_MARKIN, TBINDEX_MARK, BTNST_UP);
|
|
toolbarModifyState(ghwndMark, BTN_MARKOUT, TBINDEX_MARK, BTNST_UP);
|
|
}
|
|
if (ghwndFSArrows) {
|
|
toolbarModifyState(ghwndFSArrows, ARROW_PREV, TBINDEX_ARROWS, BTNST_UP);
|
|
toolbarModifyState(ghwndFSArrows, ARROW_NEXT, TBINDEX_ARROWS, BTNST_UP);
|
|
}
|
|
}
|
|
/* AND we need to call layout to gray the buttons that are too
|
|
* short to fit in this window right now.
|
|
*/
|
|
Layout();
|
|
}
|
|
|
|
//
|
|
// always have the stop button if we are playing in place
|
|
//
|
|
if ((gwDeviceID != (UINT)0) &&
|
|
(wStatusMCI == MCI_MODE_PAUSE ||
|
|
wStatusMCI == MCI_MODE_PLAY ||
|
|
wStatusMCI == MCI_MODE_SEEK || gfPlayingInPlace)) {
|
|
|
|
if (toolbarStateFromButton(ghwndToolbar, BTN_STOP, TBINDEX_MAIN) == BTNST_GRAYED)
|
|
toolbarModifyState(ghwndToolbar, BTN_STOP, TBINDEX_MAIN, BTNST_UP);
|
|
|
|
} else {
|
|
toolbarModifyState(ghwndToolbar, BTN_STOP, TBINDEX_MAIN, BTNST_GRAYED);
|
|
}
|
|
|
|
if (!gfPlayOnly || gfOle2IPEditing) {
|
|
if ((gwDeviceID != (UINT)0) && (gwDeviceType & DTMCI_CANEJECT))
|
|
toolbarModifyState(ghwndToolbar, BTN_EJECT, TBINDEX_MAIN, BTNST_UP);
|
|
else
|
|
toolbarModifyState(ghwndToolbar, BTN_EJECT, TBINDEX_MAIN, BTNST_GRAYED);
|
|
|
|
EnableWindow(ghwndMap, (gwDeviceID != (UINT)0));
|
|
}
|
|
|
|
// WHO had the idea that setting focus back to play every
|
|
// time the status changes was a good idea ??
|
|
/* Only set focus if we won't take activation by doing so */
|
|
//VIJRif (gfAppActive) {
|
|
if (wStatusMCI == MCI_MODE_NOT_READY) {
|
|
//if (gfAppActive)
|
|
//SetFocus(ghwndToolbar); //Setting focus messes up menu access
|
|
//using the ALT key
|
|
} else if (wStatusMCI != MCI_MODE_SEEK &&
|
|
gwStatus != MCI_MODE_SEEK) {
|
|
if (wStatusMCI == MCI_MODE_PLAY) {
|
|
//VIJR SetFocus(ghwndToolbar); // give focus to PAUSE button
|
|
toolbarSetFocus(ghwndToolbar, BTN_PAUSE);
|
|
} else {
|
|
//VIJR SetFocus(ghwndToolbar); // give focus to PLAY button
|
|
toolbarSetFocus(ghwndToolbar, BTN_PLAY);
|
|
if (wStatusMCI == MCI_MODE_OPEN || wStatusMCI == MCI_MODE_NOT_READY ||
|
|
gwDeviceID == (UINT)0) {
|
|
/* Try to modify both -- one of them should work */
|
|
toolbarModifyState(ghwndToolbar, BTN_PLAY, TBINDEX_MAIN, BTNST_GRAYED);
|
|
}
|
|
}
|
|
}
|
|
//VIJR}
|
|
|
|
if (wStatusMCI == MCI_MODE_OPEN || gwStatus == MCI_MODE_OPEN
|
|
|| gwStatus == MCI_MODE_NOT_READY
|
|
|| wStatusMCI == MCI_MODE_NOT_READY) {
|
|
|
|
/* Either the medium was just ejected, or it was just
|
|
* re-inserted -- in either case, the media information (length,
|
|
* # of tracks, etc.) is currently invalid and needs to be updated.
|
|
*/
|
|
|
|
gfValidMediaInfo = FALSE;
|
|
}
|
|
|
|
/*
|
|
* Set <gwStatus> to agree with what MCI tells us, and update the
|
|
* display accordingly.
|
|
*
|
|
*/
|
|
|
|
gwStatus = wStatusMCI;
|
|
gfValidCaption = FALSE;
|
|
}
|
|
|
|
/*
|
|
* The previous code may have invalidated the Media again, so we'll update
|
|
* now instead of waiting for the next UpdateDisplay call.
|
|
*
|
|
*/
|
|
|
|
if (!gfValidMediaInfo)
|
|
UpdateMCI(); /* update the appropriate global variables*/
|
|
|
|
/* If the caption is not valid, then update it */
|
|
|
|
if (!gfValidCaption) {
|
|
|
|
TCHAR ach[_MAX_PATH * 2 + 60]; // string used for the window caption
|
|
TCHAR achWhatToPrint[_MAX_PATH * 2 + 40]; // room for doc title too
|
|
|
|
if (gfPlayOnly) {
|
|
if (gwDeviceID == (UINT)0)
|
|
lstrcpy(ach, gachAppName); /* just use the app name */
|
|
else
|
|
lstrcpy(ach, gachWindowTitle); /* just use device */
|
|
} else {
|
|
/* Latest style guide says title bars should have
|
|
* <object> - <appname>, so do that for anything
|
|
* other than NT:
|
|
*/
|
|
if (gwPlatformId == VER_PLATFORM_WIN32_NT)
|
|
wsprintf(achWhatToPrint, aszTitleFormat, gachAppName,
|
|
gachWindowTitle);
|
|
else
|
|
wsprintf(achWhatToPrint, aszTitleFormat, gachWindowTitle,
|
|
gachAppName);
|
|
|
|
if (gwDeviceID == (UINT)0) {
|
|
lstrcpy(ach, gachAppName); /* just display the app name */
|
|
} else if (gwStatus == MCI_MODE_NOT_READY) {
|
|
wsprintf(ach, aszNotReadyFormat,
|
|
achWhatToPrint); /* the current file / device */
|
|
} else {
|
|
wsprintf(ach, aszReadyFormat,
|
|
achWhatToPrint, /* the current file / device */
|
|
MapModeToStatusString((WORD)wStatusMCI));
|
|
}
|
|
}
|
|
|
|
if (gfEmbeddedObject) {
|
|
if (!SetTitle((LPDOC)&docMain, szClientDoc))
|
|
UpdateWindowText(ghwndApp, ach);
|
|
|
|
SetMPlayerIcon();
|
|
|
|
} else {
|
|
UpdateWindowText(ghwndApp, ach);
|
|
}
|
|
|
|
gfValidCaption = TRUE;
|
|
|
|
}
|
|
|
|
/* Update the scrollbar thumb position unless the user is dragging it */
|
|
/* or the media is current seeking to a previously requested position. */
|
|
|
|
if (!gfScrollTrack && gfValidMediaInfo && wStatusMCI != MCI_MODE_SEEK) {
|
|
TCHAR ach[40];
|
|
|
|
if (ghwndStatic) {
|
|
FormatTime(dwPosition, NULL, ach, TRUE);
|
|
WriteStatusMessage(ghwndStatic, ach);
|
|
}
|
|
SendMessage(ghwndTrackbar, TBM_SETPOS, (WPARAM)TRUE, dwPosition);
|
|
}
|
|
|
|
/* Finish any required window painting immediately */
|
|
|
|
if (gfOle2IPEditing && wStatusMCI == MCI_MODE_STOP &&
|
|
((gwDeviceType & DTMCI_DEVICE) == DTMCI_AVIVIDEO))
|
|
{
|
|
RedrawWindow(ghwndTrackbar, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW);
|
|
}
|
|
UpdateWindow(ghwndApp);
|
|
}
|
|
|
|
|
|
/*
|
|
* EnableTimer(fEnable)
|
|
*
|
|
* Enable the display-update timer if <fEnable> is TRUE.
|
|
* Disable the timer if <fEnable> is FALSE.
|
|
*
|
|
*/
|
|
|
|
void FAR PASCAL EnableTimer(BOOL fEnable)
|
|
{
|
|
DPF("EnableTimer(%d) %dms\n", fEnable, gfAppActive ? UPDATE_MSEC : UPDATE_INACTIVE_MSEC);
|
|
|
|
if (fEnable)
|
|
SetTimer(ghwndApp, UPDATE_TIMER,
|
|
gfAppActive ? UPDATE_MSEC : UPDATE_INACTIVE_MSEC, NULL);
|
|
else
|
|
KillTimer(ghwndApp, UPDATE_TIMER);
|
|
}
|
|
|
|
|
|
void FAR PASCAL Layout(void)
|
|
{
|
|
RECT rcClient, rc;
|
|
int iYOffset;
|
|
UINT wWidth;
|
|
UINT wFSArrowsWidth = 2 * FSARROW_WIDTH - 1; // 2 arrow buttons wide
|
|
UINT wFSArrowsHeight = FSARROW_HEIGHT;
|
|
UINT wFSTrackHeight = FSTRACK_HEIGHT;
|
|
UINT wFSTrackWidth;
|
|
UINT wToolbarWidth;
|
|
UINT wMinStatusWidth = 0;
|
|
int iYPosition;
|
|
BOOL fShowMark;
|
|
BOOL fShowTrackbar;
|
|
BOOL fShowStatus;
|
|
HDWP hdwp;
|
|
int nState; // The status of the transport buttons (when visible)
|
|
DWORD_PTR dw; // the current position within the medium
|
|
UINT wStatusMCI; // status of the device according to MCI
|
|
UINT wBaseUnits;
|
|
BOOL fRedrawFrame;
|
|
SIZE StatusTextExtent;
|
|
BOOL fRepaintToolbar; // TRUE if we remove or add something to toolbar area
|
|
|
|
/* OK to execute if we're hidden to set ourselves up for being shown */
|
|
|
|
if (sfInLayout || IsIconic(ghwndApp))
|
|
return;
|
|
|
|
if (gfInPlayMCI) {
|
|
DPF("Layout() called when in PlayMCI(). Posting message to Layout() later.\n");
|
|
/* Don't allow this to happen, because Layout() may cause a call to
|
|
* MCI_PUT (via SetWindowPos(ghwndMCI)), which will result in a
|
|
* device-not-ready error, as the MCI_PLAY hasn't completed.
|
|
*/
|
|
PostMessage(ghwndApp, WM_DOLAYOUT, 0, 0);
|
|
return;
|
|
}
|
|
|
|
sfInLayout = TRUE;
|
|
|
|
#ifdef DEBUG
|
|
GetWindowRect(ghwndApp, &rc);
|
|
DPF("***** Layout Window Rect ***** %d %d\n", rc.right - rc.left, rc.bottom - rc.top);
|
|
#endif
|
|
|
|
if (gfPlayOnly) {
|
|
|
|
extern UINT gwPlaybarHeight; // in server.c
|
|
|
|
#define XSLOP 0
|
|
#define XOFF 2
|
|
|
|
|
|
if (gfOle2IPEditing || gfOle2IPPlaying)
|
|
{
|
|
/* Don't call GetClientrect, because the window may have a border,
|
|
* and this will cause us to shrink the window.
|
|
* Note this is a hack to get around the problem of the window
|
|
* changing size when it is in place, making some displays dither
|
|
* the video in a disgusting manner.
|
|
*/
|
|
GetWindowRect(ghwndApp, &rc);
|
|
rc.right -= rc.left;
|
|
rc.bottom -= rc.top;
|
|
rc.left = rc.top = 0;
|
|
}
|
|
else
|
|
GetClientRect(ghwndApp, &rc);
|
|
|
|
rc.bottom -= gwPlaybarHeight;
|
|
|
|
#if 0
|
|
/* If we set WS_MAXIMIZE, user doesn't allow the window to be
|
|
* sized on NT. What's the idea behind this code anyway?
|
|
*/
|
|
|
|
if (ghwndMCI && !EqualRect(&rc, &grcSize))
|
|
fRedrawFrame = SetWS(ghwndApp, WS_MAXIMIZE /* |WS_MAXIMIZEBOX */);
|
|
else if (ghwndMCI)
|
|
fRedrawFrame = //SetWS(ghwndApp, WS_MAXIMIZEBOX) ||
|
|
ClrWS(ghwndApp, WS_MAXIMIZE);
|
|
else
|
|
fRedrawFrame = ClrWS(ghwndApp, WS_MAXIMIZEBOX);
|
|
#endif
|
|
fRedrawFrame = FALSE;
|
|
|
|
/* Here's another horrible hack.
|
|
* When you try to Play an in-place video after an Open (OLE),
|
|
* the toolbar and trackbar don't get drawn correctly.
|
|
* I haven't figured out why this is, but forcing a redraw
|
|
* seems to fix it. This code gets executed only when the window
|
|
* position changes, so it isn't too much of a hit.
|
|
*/
|
|
if (gfOle2IPEditing || gfOle2IPPlaying)
|
|
fRedrawFrame = TRUE;
|
|
|
|
if (fRedrawFrame)
|
|
SetWindowPos(ghwndApp,
|
|
NULL,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
SWP_DRAWFRAME|SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE);
|
|
|
|
if (ghwndMCI)
|
|
SetWindowPos(ghwndMCI,
|
|
NULL,
|
|
0,
|
|
0,
|
|
rc.right,
|
|
rc.bottom,
|
|
SWP_NOZORDER|SWP_NOACTIVATE);
|
|
|
|
// If we are inplace editing place controls on the ghwndIPToolWindow
|
|
// and the static window at the bottom of ghwndApp.
|
|
if(gfOle2IPEditing) {
|
|
|
|
SendMessage(ghwndTrackbar, TBM_SHOWTICS, TRUE, FALSE);
|
|
|
|
SetWindowPos(ghwndStatic,
|
|
NULL,
|
|
3,
|
|
rc.bottom + 2 + (gwPlaybarHeight - TOOLBAR_HEIGHT)/2,
|
|
rc.right - rc.left - 8,
|
|
TOOLBAR_HEIGHT-7,
|
|
SWP_NOZORDER|SWP_NOACTIVATE);
|
|
|
|
// Why are we getting the Status here when we have a global that
|
|
// contains it? Because gwStatus is set in UpdateDisplay, but
|
|
// Layout() is called by UpdateDisplay, so the global is not always
|
|
// set properly when this code runs. BUT! We must NOT pass a string
|
|
// to StatusMCI() or it will think UpdateDisplay() called it, and
|
|
// not tell UpdateDisplay() the proper mode next time it asks for it,
|
|
// because it will think that it already knows it.
|
|
|
|
wStatusMCI = StatusMCI(NULL);
|
|
nState = (wStatusMCI == MCI_MODE_OPEN
|
|
|| wStatusMCI == MCI_MODE_NOT_READY
|
|
|| gwDeviceID == (UINT) 0)
|
|
? BTNST_GRAYED
|
|
: BTNST_UP;
|
|
|
|
toolbarModifyState(ghwndToolbar, BTN_HOME, TBINDEX_MAIN, nState);
|
|
toolbarModifyState(ghwndToolbar, BTN_RWD, TBINDEX_MAIN, nState);
|
|
toolbarModifyState(ghwndToolbar, BTN_FWD, TBINDEX_MAIN, nState);
|
|
toolbarModifyState(ghwndToolbar, BTN_END, TBINDEX_MAIN, nState);
|
|
|
|
ShowWindow(ghwndTrackbar, SW_SHOW);
|
|
ShowWindow(ghwndToolbar, SW_SHOW);
|
|
ShowWindow(ghwndStatic, SW_SHOW);
|
|
ShowWindow(ghwndFSArrows, SW_SHOW);
|
|
ShowWindow(ghwndMark, SW_SHOW);
|
|
ShowWindow(ghwndMap, SW_SHOW);
|
|
|
|
if (ghwndIPToolWindow && (ghwndIPToolWindow != GetParent(ghwndTrackbar))
|
|
&& (ghwndIPScrollWindow != GetParent(ghwndTrackbar)))
|
|
{
|
|
SetParent(ghwndTrackbar,ghwndIPToolWindow);
|
|
SetWindowPos(ghwndTrackbar, NULL,4,TOOL_WIDTH+2,
|
|
11*BUTTONWIDTH+3,FSTRACK_HEIGHT,SWP_NOZORDER | SWP_NOACTIVATE);
|
|
SetParent(ghwndMap,ghwndIPToolWindow);
|
|
SetWindowPos(ghwndMap, NULL,4,TOOL_WIDTH+FSTRACK_HEIGHT+2+2,
|
|
11*BUTTONWIDTH+50,MAP_HEIGHT,SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
CalcTicsOfDoom();
|
|
|
|
} else {
|
|
|
|
#define LEFT_MARGIN 1
|
|
|
|
SendMessage(ghwndTrackbar, TBM_SHOWTICS, FALSE, FALSE);
|
|
|
|
SetWindowPos(ghwndToolbar,
|
|
NULL,
|
|
LEFT_MARGIN,
|
|
rc.bottom + 2 + (gwPlaybarHeight - TOOLBAR_HEIGHT)/2,
|
|
XSLOP + 2 * (BUTTONWIDTH - XOFF),
|
|
TOOLBAR_HEIGHT,
|
|
SWP_NOZORDER|SWP_NOACTIVATE);
|
|
|
|
SetWindowPos(ghwndTrackbar,
|
|
NULL,
|
|
XSLOP + 2 * (BUTTONWIDTH - XOFF) + LEFT_MARGIN,
|
|
rc.bottom + (gwPlaybarHeight - TOOLBAR_HEIGHT)/2 + 1,
|
|
rc.right-rc.left-(2 * XSLOP + 2 *(BUTTONWIDTH - XOFF) - LEFT_MARGIN),
|
|
TOOLBAR_HEIGHT - 1,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
// HACK!!!
|
|
// If we aren't visible, officially disable ourselves so that the
|
|
// trackbar shift code won't try and set selection
|
|
|
|
ShowWindow(ghwndTrackbar, gwPlaybarHeight > 0 ? SW_SHOW : SW_HIDE);
|
|
ShowWindow(ghwndToolbar, gwPlaybarHeight > 0 ? SW_SHOW : SW_HIDE);
|
|
ShowWindow(ghwndStatic, SW_HIDE);
|
|
ShowWindow(ghwndFSArrows, SW_HIDE);
|
|
ShowWindow(ghwndMark, SW_HIDE);
|
|
ShowWindow(ghwndMap, SW_HIDE);
|
|
}
|
|
|
|
goto Exit_Layout;
|
|
}
|
|
|
|
fRedrawFrame = ClrWS(ghwndApp, WS_MAXIMIZEBOX);
|
|
|
|
if (fRedrawFrame)
|
|
SetWindowPos(ghwndApp, NULL, 0, 0, 0, 0, SWP_DRAWFRAME|
|
|
SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE);
|
|
|
|
if (GetMenu(ghwndApp) != ghMenu)
|
|
SetMenu(ghwndApp, ghMenu);
|
|
|
|
wBaseUnits = LOWORD(GetDialogBaseUnits()); // prop. to size of system font
|
|
|
|
/* If we're bigger than we're allowed to be then shrink us right now */
|
|
GetWindowRect(ghwndApp, &rc);
|
|
|
|
gwHeightAdjust = GetHeightAdjust(ghwndApp);
|
|
|
|
DPF1("Layout: WindowRect = %x, %x, %x, %x\n", rc);
|
|
|
|
if (rc.bottom - rc.top != (int)(MAX_NORMAL_HEIGHT + gwHeightAdjust)) {
|
|
MoveWindow(ghwndApp,
|
|
rc.left,
|
|
rc.top,
|
|
rc.right - rc.left,
|
|
(int)(MAX_NORMAL_HEIGHT + gwHeightAdjust),
|
|
TRUE);
|
|
}
|
|
|
|
|
|
hdwp = BeginDeferWindowPos(6);
|
|
|
|
if (!hdwp)
|
|
goto Exit_Layout;
|
|
|
|
GetClientRect(ghwndApp, &rcClient); // get new size
|
|
|
|
wWidth = rcClient.right;
|
|
|
|
iYOffset = rcClient.bottom - MAX_NORMAL_HEIGHT + 2; // start here
|
|
|
|
/* ??? Hide the trackbar if it can't fit on completely ??? */
|
|
iYPosition = iYOffset >= 0 ? iYOffset :
|
|
((iYOffset >= - 9) ? iYOffset + 9 : 1000);
|
|
|
|
fShowTrackbar = (iYOffset >= - 9);
|
|
|
|
/* Focus in on trackbar which is about to go away */
|
|
if (!fShowTrackbar && GetFocus() == ghwndTrackbar)
|
|
SetFocus(ghwndToolbar);
|
|
|
|
ShowWindow(ghwndToolbar, SW_SHOW);
|
|
|
|
/* The space that COMMCTRL puts to the left of the first toolbar button:
|
|
*/
|
|
#define SLOPLFT 0
|
|
#define XOFF1 8
|
|
|
|
// how long did it end up being?
|
|
wFSTrackWidth = wWidth - SB_XPOS - 1 - wFSArrowsWidth - SLOPLFT;
|
|
|
|
DeferWindowPos(hdwp,
|
|
ghwndTrackbar,
|
|
HWND_TOP,
|
|
SB_XPOS,
|
|
iYPosition,
|
|
wFSTrackWidth,
|
|
wFSTrackHeight,
|
|
SWP_NOZORDER | SWP_NOREDRAW |
|
|
(fShowTrackbar ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
|
|
|
|
|
|
/* Toolbar positioning:
|
|
*
|
|
* If the window is not wide enough to accommodate all the buttons
|
|
* and status bar, here's what we do:
|
|
*
|
|
* If the status bar is invisible, first remove the mark buttons,
|
|
* then use the small control width (with only three buttons).
|
|
*
|
|
* If the status bar is visible, give it priority over the mark
|
|
* buttons and the extra controls, but remove it if there isn't
|
|
* room for it and the small control width.
|
|
*/
|
|
|
|
if (gwDeviceID)
|
|
{
|
|
fShowStatus = TRUE;
|
|
|
|
if (GetStatusTextExtent(ghwndStatic, &StatusTextExtent))
|
|
{
|
|
RECT rc;
|
|
LONG StatusWidth; /* Total width of status window */
|
|
LONG TextAreaWidth; /* Width minus border and size grip */
|
|
|
|
/* Allow for the border around the status window:
|
|
*/
|
|
GetWindowRect(ghwndStatic, &rc);
|
|
StatusWidth = rc.right - rc.left;
|
|
|
|
SendMessage(ghwndStatic, SB_GETRECT, 0, (LPARAM)&rc);
|
|
TextAreaWidth = rc.right - rc.left;
|
|
|
|
wMinStatusWidth = StatusTextExtent.cx + (StatusWidth - TextAreaWidth) + 16;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fShowStatus = FALSE;
|
|
}
|
|
|
|
wToolbarWidth = LARGE_CONTROL_WIDTH + SLOPLFT;
|
|
fShowMark = TRUE;
|
|
|
|
if (wWidth < LARGE_CONTROL_WIDTH + SLOPLFT + MARK_WIDTH + XOFF1 + wMinStatusWidth)
|
|
{
|
|
fShowMark = FALSE;
|
|
|
|
if (wWidth < LARGE_CONTROL_WIDTH + SLOPLFT + wMinStatusWidth)
|
|
wToolbarWidth = SMALL_CONTROL_WIDTH + SLOPLFT;
|
|
|
|
if (wWidth < SMALL_CONTROL_WIDTH + SLOPLFT + wMinStatusWidth)
|
|
fShowStatus = FALSE;
|
|
}
|
|
|
|
fRepaintToolbar = FALSE;
|
|
|
|
/* If we're adding or removing the mark buttons or the status window,
|
|
* make sure we repaint things so that the separator bar corresponds.
|
|
* (It should separate the status window from the buttons, but should
|
|
* go away when the status window does.)
|
|
*/
|
|
if (IsWindowVisible(ghwndStatic) != fShowStatus)
|
|
fRepaintToolbar = TRUE;
|
|
else if (IsWindowVisible(ghwndMark) != fShowMark)
|
|
fRepaintToolbar = TRUE;
|
|
|
|
ShowWindow(ghwndStatic, fShowStatus);
|
|
|
|
/* Turn off the toolbar (for tabbing) if it's not going to be there */
|
|
/* and if we're disabled, we better not keep the focus. */
|
|
if (!fShowMark) {
|
|
if (GetFocus() == ghwndMark)
|
|
SetFocus(ghwndToolbar); // can't give it to SB, might be gone too
|
|
EnableWindow(ghwndMark, FALSE);
|
|
} else
|
|
EnableWindow(ghwndMark, TRUE);
|
|
|
|
DeferWindowPos(hdwp,
|
|
ghwndFSArrows,
|
|
HWND_TOP,
|
|
SB_XPOS + wFSTrackWidth,
|
|
// wWidth - 1 - wFSArrowsWidth,
|
|
iYPosition + 2,
|
|
wFSArrowsWidth + SLOPLFT,
|
|
wFSArrowsHeight + 4, /* Er, 4 because it works */
|
|
SWP_NOZORDER);
|
|
|
|
iYOffset += wFSTrackHeight;
|
|
|
|
DeferWindowPos(hdwp,
|
|
ghwndMap,
|
|
HWND_TOP,
|
|
SB_XPOS,
|
|
iYOffset,
|
|
wWidth - SB_XPOS,
|
|
MAP_HEIGHT,
|
|
SWP_NOZORDER | SWP_NOREDRAW |
|
|
(fShowTrackbar ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
|
|
iYOffset += MAP_HEIGHT;
|
|
|
|
/* Do we show the last four buttons on the main toolbar? */
|
|
/* If not, then disable them for tabs and such. */
|
|
if (wToolbarWidth == LARGE_CONTROL_WIDTH + SLOPLFT)
|
|
{
|
|
|
|
// Why are we getting the Status here when we have a global that
|
|
// contains it? Because gwStatus is set in UpdateDisplay, but
|
|
// Layout() is called by UpdateDisplay, so the global is not always
|
|
// set properly when this code runs. BUT! We must NOT pass a string
|
|
// to StatusMCI() or it will think UpdateDisplay() called it, and
|
|
// not tell UpdateDisplay() the proper mode next time it asks for it,
|
|
// because it will think that it already knows it.
|
|
|
|
wStatusMCI = StatusMCI(&dw);
|
|
nState = (wStatusMCI == MCI_MODE_OPEN
|
|
|| wStatusMCI == MCI_MODE_NOT_READY
|
|
|| gwDeviceID == (UINT)0) ? BTNST_GRAYED : BTNST_UP;
|
|
|
|
toolbarModifyState(ghwndToolbar, BTN_HOME, TBINDEX_MAIN, nState);
|
|
toolbarModifyState(ghwndToolbar, BTN_RWD, TBINDEX_MAIN, nState);
|
|
toolbarModifyState(ghwndToolbar, BTN_FWD, TBINDEX_MAIN, nState);
|
|
toolbarModifyState(ghwndToolbar, BTN_END, TBINDEX_MAIN, nState);
|
|
toolbarModifyState(ghwndToolbar, BTN_PLAY, TBINDEX_MAIN, nState);
|
|
}
|
|
else
|
|
{
|
|
toolbarModifyState(ghwndToolbar, BTN_HOME, TBINDEX_MAIN, BTNST_GRAYED);
|
|
toolbarModifyState(ghwndToolbar, BTN_RWD, TBINDEX_MAIN, BTNST_GRAYED);
|
|
toolbarModifyState(ghwndToolbar, BTN_FWD, TBINDEX_MAIN, BTNST_GRAYED);
|
|
toolbarModifyState(ghwndToolbar, BTN_END, TBINDEX_MAIN, BTNST_GRAYED);
|
|
}
|
|
|
|
DeferWindowPos(hdwp,
|
|
ghwndToolbar,
|
|
HWND_TOP,
|
|
2,
|
|
iYOffset + 2,
|
|
wToolbarWidth,
|
|
TOOLBAR_HEIGHT,
|
|
SWP_NOZORDER);
|
|
|
|
DeferWindowPos(hdwp,
|
|
ghwndMark,
|
|
HWND_TOP,
|
|
wToolbarWidth + XOFF1,
|
|
iYOffset + 2,
|
|
MARK_WIDTH,
|
|
TOOLBAR_HEIGHT,
|
|
SWP_NOZORDER | (fShowMark ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
|
|
|
|
#define ARBITRARY_Y_OFFSET 4
|
|
|
|
DeferWindowPos(hdwp,
|
|
ghwndStatic,
|
|
HWND_TOP,
|
|
wToolbarWidth + (fShowMark ? MARK_WIDTH + XOFF1 : 0) + XOFF1,
|
|
iYOffset + ARBITRARY_Y_OFFSET,
|
|
wWidth - (wToolbarWidth + 3) -
|
|
(fShowMark ? MARK_WIDTH + XOFF1 : 0) - XOFF1,
|
|
TOOLBAR_HEIGHT - 6,
|
|
SWP_NOZORDER);
|
|
|
|
EndDeferWindowPos(hdwp);
|
|
|
|
if (fRepaintToolbar)
|
|
{
|
|
InvalidateRect(ghwndApp, NULL, TRUE);
|
|
}
|
|
|
|
CalcTicsOfDoom();
|
|
|
|
/* These little gems have just cost me about ten hours worth of debugging -
|
|
* note the useful and descriptive comments...
|
|
*
|
|
* The Win32 problem caused by this only arises with CD Audio, when the disk is
|
|
* ejected and then another one is inserted into the drive. At that point
|
|
* the redrawing misses out the Trackmap FSArrows, the borders on the
|
|
* Mark buttons, and various bits of the toolbar.
|
|
*
|
|
* I will leave this here on the assumption that whichever bout
|
|
* on Win16 they are intended to fix still exists - it certainly doesn't on
|
|
* Win32.
|
|
*/
|
|
|
|
|
|
Exit_Layout:
|
|
sfInLayout = FALSE;
|
|
return;
|
|
}
|
|
|
|
|
|
/* What is the previous mark from our current spot? */
|
|
LONG_PTR CalcPrevMark(void)
|
|
{
|
|
LONG_PTR lStart, lEnd, lPos, lTol, lTrack = -1, lTarget;
|
|
LONG_PTR l;
|
|
|
|
lStart = SendMessage(ghwndTrackbar, TBM_GETSELSTART, 0, 0);
|
|
lEnd = SendMessage(ghwndTrackbar, TBM_GETSELEND, 0, 0);
|
|
lPos = SendMessage(ghwndTrackbar, TBM_GETPOS, 0, 0);
|
|
|
|
/* Find the next track we should go to (ignore selection markers) */
|
|
if (gwCurScale == ID_TRACKS) {
|
|
lTol = (LONG)gdwMediaLength / 2000;
|
|
for (l = (LONG)gwNumTracks - 1; l >= 0; l--) {
|
|
if (gadwTrackStart[l] < (DWORD)lPos - lTol) {
|
|
lTrack = gadwTrackStart[l];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* For msec mode: */
|
|
/* Our current position fluctuates randomly and even if we're dead on */
|
|
/* a selection mark, it might say we're a little before or after it. */
|
|
/* So we'll allow a margin for error so that you don't forever stay */
|
|
/* still while you hit PrevMark because it happens to be saying you're*/
|
|
/* always past the mark you're at. The margin of error will be */
|
|
/* half the width of the thumb. */
|
|
|
|
if (gwCurScale == ID_FRAMES)
|
|
lTol = 0L;
|
|
else
|
|
lTol = 0L;//VIJR-TBTrackGetLogThumbWidth(ghwndTrackbar) / 2;
|
|
|
|
if (lEnd != -1 && lPos > lEnd + lTol)
|
|
lTarget = lEnd;
|
|
else if (lStart != -1 && lPos > lStart + lTol)
|
|
lTarget = lStart;
|
|
else
|
|
lTarget = 0;
|
|
|
|
/* go to the either the selection mark or the next track (the closest) */
|
|
if (lTrack != -1 && lTrack > lTarget)
|
|
lTarget = lTrack;
|
|
|
|
return lTarget;
|
|
}
|
|
|
|
/* What is the next mark from our current spot? */
|
|
LONG_PTR CalcNextMark(void)
|
|
{
|
|
LONG_PTR lStart, lEnd, lPos, lTol, lTrack = -1, lTarget;
|
|
UINT_PTR w;
|
|
|
|
lStart = SendMessage(ghwndTrackbar, TBM_GETSELSTART, 0, 0);
|
|
lEnd = SendMessage(ghwndTrackbar, TBM_GETSELEND, 0, 0);
|
|
lPos = SendMessage(ghwndTrackbar, TBM_GETPOS, 0, 0);
|
|
|
|
/* Find the next track we should go to (ignore selection markers) */
|
|
if (gwCurScale == ID_TRACKS) {
|
|
lTol = (LONG)gdwMediaLength / 2000;
|
|
for (w = 0; w < gwNumTracks; w++) {
|
|
if (gadwTrackStart[w] > (DWORD)lPos + lTol) {
|
|
lTrack = gadwTrackStart[w];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* For msec mode: */
|
|
/* Our current position fluctuates randomly and even if we're dead on */
|
|
/* a selection mark, it might say we're a little before or after it. */
|
|
/* So we'll allow a margin for error so that you don't forever stay */
|
|
/* still while you hit NextMark because it happens to be saying you're*/
|
|
/* always before the mark you're at. The margin of error will be */
|
|
/* half the width of the thumb. */
|
|
|
|
if (gwCurScale == ID_FRAMES)
|
|
lTol = 0L;
|
|
else
|
|
lTol = 0L;//VIJR-TBTrackGetLogThumbWidth(ghwndTrackbar) / 2;
|
|
|
|
/* Find the selection mark we should go to */
|
|
if (lStart != -1 && lPos < lStart - lTol)
|
|
lTarget = lStart;
|
|
else if (lEnd != -1 && lPos < lEnd - lTol)
|
|
lTarget = lEnd;
|
|
else
|
|
lTarget = gdwMediaStart + gdwMediaLength;
|
|
|
|
/* go to the either the selection mark or the next track (the closest) */
|
|
if (lTrack != -1 && lTrack < lTarget)
|
|
lTarget = lTrack;
|
|
|
|
return lTarget;
|
|
}
|
|
|
|
|
|
HICON GetIconFromProgID(LPTSTR szProgID)
|
|
{
|
|
DWORD Status;
|
|
HKEY hkeyDefaultIcon;
|
|
BOOL rc = FALSE;
|
|
DWORD Type;
|
|
DWORD Size;
|
|
TCHAR szProgIDDefaultIcon[128];
|
|
TCHAR szDefaultIcon[MAX_PATH+4]; /* <path>,N */
|
|
HICON hicon = NULL;
|
|
LPTSTR pIconIndex;
|
|
UINT IconIndex;
|
|
|
|
wsprintf(szProgIDDefaultIcon, TEXT("%s\\DefaultIcon"), szProgID);
|
|
|
|
Status = RegOpenKeyEx( HKEY_CLASSES_ROOT, szProgIDDefaultIcon, 0,
|
|
KEY_READ, &hkeyDefaultIcon );
|
|
|
|
if (Status == NO_ERROR)
|
|
{
|
|
Size = CHAR_COUNT(szDefaultIcon);
|
|
|
|
Status = RegQueryValueEx( hkeyDefaultIcon,
|
|
aszNULL,
|
|
0,
|
|
&Type,
|
|
(LPBYTE)szDefaultIcon,
|
|
&Size );
|
|
|
|
if (Status == NO_ERROR)
|
|
{
|
|
/* Find a comma in the string. After it comes the icon index:
|
|
*/
|
|
pIconIndex = STRCHR(szDefaultIcon, TEXT(','));
|
|
|
|
if (pIconIndex)
|
|
{
|
|
/* Null terminate the file name:
|
|
*/
|
|
*pIconIndex = TEXT('\0');
|
|
|
|
/* Get the index that comes after the comma:
|
|
*/
|
|
IconIndex = ATOI(pIconIndex+1);
|
|
|
|
DPF1("Extracting icon #%d from %"DTS"\n", IconIndex, szDefaultIcon);
|
|
|
|
hicon = ExtractIcon(ghInst, szDefaultIcon, IconIndex);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
DPF0("Couldn't find Default Icon for %"DTS"\n", szProgID);
|
|
}
|
|
|
|
RegCloseKey(hkeyDefaultIcon);
|
|
}
|
|
|
|
return hicon;
|
|
}
|
|
|
|
|
|
|
|
/* GetIconForCurrentDevice
|
|
*
|
|
* Checks what device is currently selected, and returns a handle to the
|
|
* appropriate icon of the specified size. If there is no current device,
|
|
* returns either the application's icon or the default icon for media
|
|
* documents.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* Size - GI_SMALL (for title bar) or GI_LARGE (for in-place icon).
|
|
*
|
|
* DefaultID - Default to use if no current device. APPICON or IDI_DDEFAULT.
|
|
*
|
|
* Return:
|
|
*
|
|
* Icon handle
|
|
*
|
|
*
|
|
* Andrew Bell (andrewbe), 31 March 1995
|
|
*/
|
|
HICON GetIconForCurrentDevice(UINT Size, UINT DefaultID)
|
|
{
|
|
TCHAR DeviceName[256];
|
|
DWORD i;
|
|
LPTSTR ImageID = NULL;
|
|
int cx;
|
|
int cy;
|
|
HICON hIcon;
|
|
|
|
GetDeviceNameMCI(DeviceName, BYTE_COUNT(DeviceName));
|
|
|
|
if (DeviceName[0])
|
|
{
|
|
for (i = 0; i < sizeof DevToIconIDMap / sizeof *DevToIconIDMap; i++)
|
|
{
|
|
if (!lstrcmpi(DeviceName, DevToIconIDMap[i].pString))
|
|
{
|
|
ImageID = MAKEINTRESOURCE(DevToIconIDMap[i].ID);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
if (Size == GI_LARGE)
|
|
{
|
|
|
|
hIcon = GetIconFromProgID(gachProgID);
|
|
|
|
if (hIcon)
|
|
{
|
|
return hIcon;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ImageID == NULL)
|
|
ImageID = MAKEINTRESOURCE(DefaultID);
|
|
|
|
cx = (Size == GI_SMALL ? GetSystemMetrics(SM_CXSMICON) : 0);
|
|
cy = (Size == GI_SMALL ? GetSystemMetrics(SM_CYSMICON) : 0);
|
|
|
|
hIcon = (HICON)LoadImage(ghInst, ImageID, IMAGE_ICON,
|
|
cx, cy, LR_DEFAULTSIZE);
|
|
|
|
return hIcon;
|
|
}
|
|
|
|
|
|
/* SetMPlayerIcon
|
|
*
|
|
* Sets the icon based upon the current device. Uses default document
|
|
* icon if embedded, otherwise the application icon.
|
|
*
|
|
* Andrew Bell (andrewbe), 31 March 1995
|
|
*/
|
|
void SetMPlayerIcon()
|
|
{
|
|
UINT DefaultID;
|
|
|
|
DefaultID = gfEmbeddedObject ? IDI_DDEFAULT : APPICON;
|
|
|
|
SendMessage(ghwndApp, WM_SETICON, FALSE,
|
|
(LPARAM)GetIconForCurrentDevice(GI_SMALL, DefaultID));
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------+
|
|
| AskUpdate - ask the user if they want to update the |
|
|
| object (if we're dirty). |
|
|
| IDYES means yes, go ahead and update please. |
|
|
| IDNO means don't update, but continue. |
|
|
| IDCANCEL means don't update, and cancel what |
|
|
| you were doing. |
|
|
+--------------------------------------------------------------*/
|
|
int NEAR PASCAL AskUpdate(void)
|
|
{
|
|
UINT w;
|
|
|
|
/* Don't update object if no device is loaded into mplayer! */
|
|
if (IsObjectDirty() && gfDirty != -1 && gfEmbeddedObject && gwDeviceID) {
|
|
|
|
if((glCurrentVerb == OLEIVERB_PRIMARY) && !gfOle2IPEditing)
|
|
return IDNO;
|
|
//
|
|
// if we are a hidden MPlayer (most likely doing a Play verb) then
|
|
// update without asking?
|
|
//
|
|
if (!IsWindowVisible(ghwndApp) || gfOle2IPEditing)
|
|
return IDYES;
|
|
|
|
w = ErrorResBox(ghwndApp, ghInst,
|
|
MB_YESNOCANCEL | MB_ICONQUESTION,
|
|
IDS_APPNAME, IDS_UPDATEOBJECT, szClientDoc);
|
|
|
|
} else
|
|
w = IDNO;
|
|
|
|
return w;
|
|
}
|
|
|
|
void SizePlaybackWindow(int dx, int dy)
|
|
{
|
|
RECT rc;
|
|
HWND hwndPlay;
|
|
|
|
if (gfPlayOnly) {
|
|
SetRect(&rc, 0, 0, dx, dy);
|
|
SetMPlayerSize(&rc);
|
|
}
|
|
else {
|
|
if (dx == 0 && dy == 0) {
|
|
SetMPlayerSize(NULL); // size MPlayer to default size
|
|
dx = grcSize.right; // then size the playback window too.
|
|
dy = grcSize.bottom;
|
|
}
|
|
hwndPlay = GetWindowMCI();
|
|
|
|
if (hwndPlay != NULL) {
|
|
|
|
/* make sure that the play window isn't iconized */
|
|
|
|
if (IsIconic(hwndPlay))
|
|
return;
|
|
|
|
GetClientRect(hwndPlay, &rc);
|
|
ClientToScreen(hwndPlay, (LPPOINT)&rc);
|
|
SetRect(&rc, rc.left, rc.top, rc.left+dx, rc.top+dy);
|
|
PutWindowMCI(&rc);
|
|
SetRect(&rc, 0, 0, dx, dy);
|
|
SetDestRectMCI(&rc);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* StartSndVol
|
|
*
|
|
* Kicks off the Sound Volume app asynchronously so we don't hang the UI.
|
|
*/
|
|
VOID StartSndVol( )
|
|
{
|
|
STARTUPINFO StartupInfo;
|
|
PROCESS_INFORMATION ProcessInformation;
|
|
|
|
memset( &StartupInfo, 0, sizeof StartupInfo );
|
|
StartupInfo.cb = sizeof(StartupInfo);
|
|
StartupInfo.wShowWindow = SW_SHOW;
|
|
|
|
CreateProcess( NULL, szSndVol32, NULL, NULL, FALSE, 0,
|
|
NULL, NULL, &StartupInfo, &ProcessInformation );
|
|
|
|
ExitThread( 0 );
|
|
}
|
|
|
|
|
|
/* GetHeightAdjust
|
|
*
|
|
* Finds the real height adjustment needed, by subtracting the client
|
|
* height from the main window height. This allows for menus that
|
|
* have wrapped.
|
|
*/
|
|
int GetHeightAdjust(HWND hwnd)
|
|
{
|
|
RECT rcWindow;
|
|
RECT rcClient;
|
|
int WindowHeight;
|
|
int ClientHeight;
|
|
|
|
GetWindowRect(hwnd, &rcWindow);
|
|
GetClientRect(hwnd, &rcClient);
|
|
WindowHeight = rcWindow.bottom - rcWindow.top;
|
|
ClientHeight = rcClient.bottom - rcClient.top;
|
|
|
|
return WindowHeight - ClientHeight;
|
|
}
|
|
|
|
|
|
/* Message-cracking routines for MPlayerWndProc:
|
|
*/
|
|
|
|
BOOL MPlayer_OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
|
|
{
|
|
InitMPlayerDialog(hwnd);
|
|
|
|
/* set off a thread to check that the OLE registry stuff is not corrupted */
|
|
|
|
#ifdef CHICAGO_PRODUCT
|
|
/* If this is the Chicago Media Player, only mess with the registry
|
|
* if we're actually running on that platform.
|
|
* The guy may be running it on NT.
|
|
*/
|
|
if (gwPlatformId != VER_PLATFORM_WIN32_WINDOWS)
|
|
return TRUE;
|
|
#endif
|
|
|
|
if (!IgnoreRegCheck())
|
|
BackgroundRegCheck(hwnd);
|
|
|
|
//Register for WM_DEVICECHANGE notification.
|
|
DeviceChange_Init(hwnd);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void MPlayer_OnShowWindow(HWND hwnd, BOOL fShow, UINT status)
|
|
{
|
|
if (fShow)
|
|
Layout(); // we're about to be shown and want to set
|
|
}
|
|
|
|
|
|
void MPlayer_OnSize(HWND hwnd, UINT state, int cx, int cy)
|
|
{
|
|
/* Don't waste time Layout()ing if we're not visible */
|
|
if (state != SIZE_RESTORED || IsWindowVisible(hwnd)) {
|
|
|
|
Layout();
|
|
|
|
// If we are inplace editing, our size change must be informed
|
|
// to the container, unless the size change was a result of a
|
|
// OnPosRectChange sent to us by the container.
|
|
if ((gfOle2IPEditing || gfOle2IPPlaying) && ghwndMCI) {
|
|
|
|
RECT rc;
|
|
RECT rcPrev;
|
|
|
|
rcPrev = gInPlacePosRect;
|
|
GetWindowRect(ghwndApp, &gInPlacePosRect);
|
|
gfInPlaceResize = TRUE;
|
|
rc = gInPlacePosRect;
|
|
|
|
/* Check that the previous rect wasn't empty, otherwise we send
|
|
* a bogus OLE_CHANGED on startup.
|
|
*/
|
|
if (!gfPosRectChange /*&& !IsRectEmpty(&rcPrev)*/) {
|
|
|
|
MapWindowPoints(NULL,ghwndCntr,(POINT FAR *)&rc,(UINT)2);
|
|
|
|
DPF("IOleInPlaceSite::OnPosRectChange %d, %d, %d, %d\n", rc);
|
|
if (!gfInPPViewer)
|
|
IOleInPlaceSite_OnPosRectChange(docMain.lpIpData->lpSite, &rc);
|
|
fDocChanged = TRUE;
|
|
SendDocMsg((LPDOC)&docMain, OLE_CHANGED);
|
|
}
|
|
|
|
gfPosRectChange = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
BOOL MPlayer_OnWindowPosChanging(HWND hwnd, LPWINDOWPOS lpwpos)
|
|
{
|
|
#define SNAPTOGOODSIZE
|
|
#ifdef SNAPTOGOODSIZE
|
|
BOOL wHeight;
|
|
#endif
|
|
|
|
DPF2("ENTER OnWindowPosChanging: lpwpos = %x, %x, %x, %x\n", *((PPOS)&lpwpos->x));
|
|
|
|
if (IsIconic(hwnd) || gfPlayOnly)
|
|
return TRUE;
|
|
|
|
/* posSizeMove contains the height we want to be when sizing.
|
|
* Don't let the system tell us otherwise.
|
|
*/
|
|
if (posSizeMove.cx != 0)
|
|
{
|
|
lpwpos->cy = posSizeMove.cy;
|
|
posSizeMove = *(PPOS)&lpwpos->x;
|
|
}
|
|
|
|
else if (!(lpwpos->flags & SWP_NOSIZE)) {
|
|
|
|
#ifdef SNAPTOGOODSIZE
|
|
/* We should also do things here to make the window
|
|
** snap to good sizes */
|
|
wHeight = lpwpos->cy - gwHeightAdjust;
|
|
// if (lpwpos->cy >= (int) gwHeightAdjust + MAX_NORMAL_HEIGHT) {
|
|
// } else if (lpwpos->cy < (int) gwHeightAdjust +
|
|
// ((MIN_NORMAL_HEIGHT + MAX_NORMAL_HEIGHT) / 2)) {
|
|
// lpwpos->cy = (int) gwHeightAdjust + MIN_NORMAL_HEIGHT;
|
|
// } else {
|
|
lpwpos->cy = (int) gwHeightAdjust + MAX_NORMAL_HEIGHT;
|
|
// }
|
|
#endif
|
|
}
|
|
|
|
DPF2("EXIT OnWindowPosChanging: lpwpos = %x, %x, %x, %x\n", *((PPOS)&lpwpos->x));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL MPlayer_OnWindowPosChanged(HWND hwnd, LPWINDOWPOS lpwpos)
|
|
{
|
|
if (!IsIconic(hwnd) && !gfPlayOnly && !gfOle2IPEditing && !gfOle2IPPlaying)
|
|
{
|
|
/* The problem here is that we want to modify the height of the
|
|
* window while tracking to take account of the menu height.
|
|
* In its wisdom, the system keeps trying to resize us back to the
|
|
* original height. So, during tracking, we keep hold of the
|
|
* dimensions we want to be and ignore the height that we get
|
|
* passed on WM_WINDOWPOSCHANGING.
|
|
*/
|
|
if (posSizeMove.cx != 0)
|
|
{
|
|
int NewHeightAdjust = GetHeightAdjust(hwnd);
|
|
|
|
if ((int)gwHeightAdjust != NewHeightAdjust)
|
|
{
|
|
/* The total non-client height has changed, so it must
|
|
* be the menu that's wrapped or unwrapped.
|
|
* Modify our height adjustment accordingly and resize
|
|
* the window.
|
|
*/
|
|
DPF("Menu appears to have wrapped. Changing window height.\n");
|
|
|
|
posSizeMove.cy += ( NewHeightAdjust - gwHeightAdjust );
|
|
gwHeightAdjust = NewHeightAdjust;
|
|
MoveWindow(ghwndApp,
|
|
posSizeMove.x, posSizeMove.y,
|
|
posSizeMove.cx, posSizeMove.cy, TRUE);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (ghwndStatic && IsWindowVisible(ghwndStatic))
|
|
{
|
|
InvalidateRect(ghwndStatic, NULL, FALSE);
|
|
}
|
|
}
|
|
|
|
FORWARD_WM_WINDOWPOSCHANGED(hwnd, lpwpos, DefWindowProc);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void MPlayer_OnPaletteChanged(HWND hwnd, HWND hwndPaletteChange)
|
|
{
|
|
if (ghwndMCI && !IsIconic(hwnd))
|
|
FORWARD_WM_PALETTECHANGED(ghwndMCI, hwndPaletteChange, SendMessage);
|
|
}
|
|
|
|
|
|
BOOL MPlayer_OnQueryNewPalette(HWND hwnd)
|
|
{
|
|
HWND hwndT;
|
|
HPALETTE hpal, hpalT;
|
|
HDC hdc;
|
|
UINT PaletteEntries;
|
|
|
|
if (IsIconic(hwnd))
|
|
return FALSE;
|
|
|
|
if (ghwndMCI)
|
|
return FORWARD_WM_QUERYNEWPALETTE(ghwndMCI, SendMessage);
|
|
|
|
hwndT = GetWindowMCI();
|
|
hpal = PaletteMCI();
|
|
|
|
if ((hwndT != NULL) && (hpal != NULL)) {
|
|
hdc = GetDC(hwnd);
|
|
hpalT = SelectPalette(hdc, hpal, FALSE);
|
|
PaletteEntries = RealizePalette(hdc);
|
|
SelectPalette(hdc, hpalT, FALSE);
|
|
ReleaseDC(hwnd, hdc);
|
|
|
|
if (PaletteEntries != GDI_ERROR) {
|
|
InvalidateRect(hwndT, NULL, TRUE);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
HBRUSH MPlayer_OnCtlColor(HWND hwnd, HDC hdc, HWND hwndChild, int type)
|
|
{
|
|
/* Only interested in the CTLCOLOR_STATIC messages.
|
|
* On Win32, type should always equal CTLCOLOR_STATIC:
|
|
*/
|
|
switch( type )
|
|
{
|
|
case CTLCOLOR_STATIC:
|
|
SetBkColor(hdc, rgbButtonFace);
|
|
SetTextColor(hdc, rgbButtonText);
|
|
}
|
|
|
|
return hbrButtonFace;
|
|
}
|
|
|
|
|
|
void MPlayer_OnWinIniChange(HWND hwnd, LPCTSTR lpszSectionName)
|
|
{
|
|
if (!lpszSectionName || !lstrcmpi(lpszSectionName, (LPCTSTR)aszIntl))
|
|
if (GetIntlSpecs())
|
|
InvalidateRect(ghwndMap, NULL, TRUE);
|
|
|
|
if (!gfPlayOnly) {
|
|
|
|
if (gwHeightAdjust != (WORD)(2 * GetSystemMetrics(SM_CYFRAME) +
|
|
GetSystemMetrics(SM_CYCAPTION) +
|
|
GetSystemMetrics(SM_CYBORDER) +
|
|
GetSystemMetrics(SM_CYMENU))) {
|
|
|
|
RECT rc;
|
|
|
|
gwHeightAdjust = 2 * GetSystemMetrics(SM_CYFRAME) +
|
|
GetSystemMetrics(SM_CYCAPTION) +
|
|
GetSystemMetrics(SM_CYBORDER) +
|
|
GetSystemMetrics(SM_CYMENU);
|
|
GetClientRect(hwnd, &rc);
|
|
gfWinIniChange = TRUE;
|
|
SetMPlayerSize(&rc);
|
|
gfWinIniChange = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void MPlayer_OnMenuSelect(HWND hwnd, HMENU hmenu, int item, HMENU hmenuPopup, UINT flags)
|
|
{
|
|
// Make sure that the container is still not displaying info. about
|
|
// its own menu.
|
|
|
|
if (gfOle2IPEditing && docMain.lpIpData->lpFrame) {
|
|
|
|
//Should have some useful text later.
|
|
IOleInPlaceFrame_SetStatusText(docMain.lpIpData->lpFrame, L"");
|
|
}
|
|
else
|
|
{
|
|
//Keep track of which menu bar item is currently popped up.
|
|
//This will be used for displaying the appropriate help from the mplayer.hlp file
|
|
//when the user presses the F1 key.
|
|
currMenuItem = item;
|
|
}
|
|
}
|
|
|
|
|
|
#define MVSIZEFIRST 1
|
|
#define MVMOVE 9
|
|
void MPlayer_OnNCLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT codeHitTest)
|
|
{
|
|
RECT rc;
|
|
|
|
if (gfPlayOnly && !IsIconic(hwnd) && IsZoomed(hwnd)) {
|
|
|
|
if (codeHitTest >= HTSIZEFIRST && codeHitTest <= HTSIZELAST) {
|
|
|
|
SendMessage(hwnd, WM_SYSCOMMAND,
|
|
// (WPARAM)(SC_SIZE + (codeHitTest - HTSIZEFIRST + MVSIZEFIRST) ),
|
|
(WPARAM)SC_SIZE,
|
|
MAKELPARAM(x, y));
|
|
return;
|
|
}
|
|
|
|
GetWindowRect(hwnd, &rc);
|
|
|
|
if (codeHitTest == HTCAPTION && (rc.left > 0 || rc.top > 0 ||
|
|
rc.right < GetSystemMetrics(SM_CXSCREEN) ||
|
|
rc.bottom < GetSystemMetrics(SM_CYSCREEN))) {
|
|
|
|
SendMessage(hwnd, WM_SYSCOMMAND,
|
|
// (WPARAM)(SC_MOVE | MVMOVE),
|
|
(WPARAM)SC_MOVE,
|
|
MAKELPARAM(x, y));
|
|
return;
|
|
}
|
|
}
|
|
|
|
FORWARD_WM_NCLBUTTONDOWN(hwnd, fDoubleClick, x, y, codeHitTest, DefWindowProc);
|
|
}
|
|
|
|
|
|
void MPlayer_OnNCLButtonDblClk(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT codeHitTest)
|
|
{
|
|
//
|
|
// when the user dbl-clicks on the caption, toggle the play mode.
|
|
//
|
|
if (codeHitTest == HTCAPTION && !IsIconic(hwnd))
|
|
SendMessage(hwnd, WM_COMMAND, (WPARAM)IDM_WINDOW, 0);
|
|
}
|
|
|
|
|
|
void MPlayer_OnInitMenu(HWND hwnd, HMENU hMenu)
|
|
{
|
|
|
|
EnableMenuItem(hMenu, IDM_CLOSE, gwDeviceID ? MF_ENABLED : MF_GRAYED);
|
|
// EnableMenuItem(hMenu, IDM_UPDATE, gwDeviceID && gfEmbeddedObject ? MF_ENABLED : MF_GRAYED);
|
|
|
|
EnableMenuItem(hMenu, IDM_COPY_OBJECT, (gwDeviceID && (gwStatus != MCI_MODE_OPEN) && (gwStatus != MCI_MODE_NOT_READY)) ? MF_ENABLED : MF_GRAYED);
|
|
EnableMenuItem(hMenu, IDM_CONFIG, gwDeviceID && (gwDeviceType & DTMCI_CANCONFIG) ? MF_ENABLED : MF_GRAYED);
|
|
|
|
CheckMenuItem(hMenu, IDM_SCALE + ID_TIME, gwCurScale == ID_TIME ? MF_CHECKED : MF_UNCHECKED);
|
|
CheckMenuItem(hMenu, IDM_SCALE + ID_TRACKS, gwCurScale == ID_TRACKS ? MF_CHECKED : MF_UNCHECKED);
|
|
CheckMenuItem(hMenu, IDM_SCALE + ID_FRAMES, gwCurScale == ID_FRAMES ? MF_CHECKED : MF_UNCHECKED);
|
|
|
|
EnableMenuItem(hMenu, IDM_SCALE + ID_TIME, gwDeviceID && !gfCurrentCDNotAudio && (gwDeviceType & DTMCI_TIMEMS) ? MF_ENABLED : MF_GRAYED);
|
|
EnableMenuItem(hMenu, IDM_SCALE + ID_FRAMES, gwDeviceID && !gfCurrentCDNotAudio && (gwDeviceType & DTMCI_TIMEFRAMES) ? MF_ENABLED : MF_GRAYED);
|
|
EnableMenuItem(hMenu, IDM_SCALE + ID_TRACKS, gwDeviceID && !gfCurrentCDNotAudio && (gwNumTracks > 1) ? MF_ENABLED : MF_GRAYED);
|
|
|
|
EnableMenuItem(hMenu, IDM_OPTIONS, gwDeviceID ? MF_ENABLED : MF_GRAYED);
|
|
EnableMenuItem(hMenu, IDM_SELECTION, gwDeviceID && gdwMediaLength ? MF_ENABLED : MF_GRAYED);
|
|
|
|
#ifdef DEBUG
|
|
EnableMenuItem(hMenu, IDM_MCISTRING, gwDeviceID ? MF_ENABLED : MF_GRAYED);
|
|
#endif
|
|
|
|
/*
|
|
EnableMenuItem(hMenu, IDM_PASTE_PICTURE , gwDeviceID &&
|
|
(IsClipboardFormatAvailable(CF_METAFILEPICT) ||
|
|
IsClipboardFormatAvailable(CF_BITMAP) ||
|
|
IsClipboardFormatAvailable(CF_DIB))
|
|
? MF_ENABLED : MF_GRAYED);
|
|
|
|
//
|
|
// what is paste frame!
|
|
//
|
|
EnableMenuItem(hMenu, IDM_PASTE_FRAME, gwDeviceID &&
|
|
(gwDeviceType & DTMCI_CANCONFIG) ? MF_ENABLED : MF_GRAYED);
|
|
*/
|
|
}
|
|
|
|
|
|
void MPlayer_OnInitMenuPopup(HWND hwnd, HMENU hMenu, UINT item, BOOL fSystemMenu)
|
|
{
|
|
static BOOL VolumeControlChecked = FALSE;
|
|
|
|
/* Here we look to see whether the menu selected is the Device popup,
|
|
* and, if it is the first time, search for the Sound Volume applet.
|
|
* If we can't find it, grey out the menu item.
|
|
*/
|
|
|
|
/* Caution: When we're in place, there seems to be a discrepancy
|
|
* in the value of parameter UINT item depending on which app is our
|
|
* container. If you use Spy to look at the parameters sent on
|
|
* WM_INITMENUPOPUP, some apps seem to have zero-based menus (e.g.
|
|
* ProgMan, PowerPoint, FileMan), which is what I would expect,
|
|
* but others seem to have one-based menus (e.g. Word, Excel).
|
|
* Why is this? I don't know. But it means that, when the
|
|
* Insert Clip menu item is selected, the item parameter may be
|
|
* either 2 or 3. That's why I'm calling GetSubMenu, since hMenu
|
|
* is always what I would expect.
|
|
*
|
|
* I sent some mail to the User and OLE guys to point this out,
|
|
* but haven't heard anything yet.
|
|
*
|
|
* andrewbe, 28 February 1995
|
|
*/
|
|
|
|
if (hMenu == GetSubMenu(ghMenu, menuposDevice))
|
|
{
|
|
HCURSOR hcurPrev;
|
|
|
|
if(!VolumeControlChecked)
|
|
{
|
|
/*
|
|
** Check to see if the volume controller piglet can be found on
|
|
** the path.
|
|
*/
|
|
{
|
|
TCHAR chBuffer[8];
|
|
LPTSTR lptstr;
|
|
|
|
if( SearchPath( NULL, szSndVol32, NULL, 8, chBuffer, &lptstr ) == 0L )
|
|
EnableMenuItem( hMenu, IDM_VOLUME, MF_GRAYED );
|
|
|
|
VolumeControlChecked = TRUE;
|
|
}
|
|
}
|
|
|
|
/* On Device (or Insert Clip) menu start menu building if necessary
|
|
* (e.g. if we came up in tiny mode then switched to full size),
|
|
* and wait for the separate thread to complete.
|
|
*/
|
|
InitDeviceMenu();
|
|
hcurPrev = SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
WaitForDeviceMenu();
|
|
SetCursor(hcurPrev);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// This code allows a window to by sized even when in the maximized state
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
if (gfPlayOnly && !IsIconic(hwnd) && fSystemMenu && IsZoomed(hwnd))
|
|
EnableMenuItem(hMenu, SC_SIZE,
|
|
!IsIconic(hwnd) ? MF_ENABLED : MF_GRAYED);
|
|
}
|
|
|
|
|
|
void MPlayer_OnGetMinMaxInfo(HWND hwnd, LPMINMAXINFO lpMinMaxInfo)
|
|
{
|
|
RECT rc;
|
|
|
|
if (gfPlayOnly) {
|
|
SetRect(&rc, 0, 0, 0, TOOLBAR_HEIGHT);
|
|
AdjustWindowRect(&rc, (DWORD)GetWindowLongPtr(hwnd, GWL_STYLE), FALSE);
|
|
lpMinMaxInfo->ptMinTrackSize.y = rc.bottom - rc.top - 1;
|
|
|
|
if (!gfPlayingInPlace &&
|
|
(gwDeviceID == (UINT)0 || !(gwDeviceType & DTMCI_CANWINDOW)))
|
|
lpMinMaxInfo->ptMaxTrackSize.y = lpMinMaxInfo->ptMinTrackSize.y;
|
|
}
|
|
else {
|
|
lpMinMaxInfo->ptMinTrackSize.y = MAX_NORMAL_HEIGHT + gwHeightAdjust;
|
|
lpMinMaxInfo->ptMaxTrackSize.y = MAX_NORMAL_HEIGHT + gwHeightAdjust;
|
|
}
|
|
}
|
|
|
|
|
|
void MPlayer_OnPaint(HWND hwnd)
|
|
{
|
|
PAINTSTRUCT ps;
|
|
RECT rc;
|
|
int x1, x2, y, y2;
|
|
UINT wParent;
|
|
HBRUSH hbrOld;
|
|
|
|
BeginPaint(hwnd, &ps);
|
|
|
|
if (gfPlayOnly) {
|
|
|
|
extern UINT gwPlaybarHeight; // in server.c
|
|
|
|
/* Separate mci playback window from controls */
|
|
if (gwDeviceType & DTMCI_CANWINDOW) {
|
|
SelectObject(ps.hdc, hbrButtonText);
|
|
GetClientRect(ghwndApp, &rc);
|
|
PatBlt(ps.hdc, 0, rc.bottom - gwPlaybarHeight, rc.right, 1, PATCOPY);
|
|
}
|
|
}
|
|
else {
|
|
hbrOld = SelectObject(ps.hdc, hbrButtonText);
|
|
GetClientRect(ghwndApp, &rc);
|
|
wParent = rc.right;
|
|
|
|
y = rc.bottom - 27; // where to paint borders around toolbar
|
|
|
|
/* Line above trackbar */
|
|
#ifdef CHICAGO_PRODUCT
|
|
y2 = rc.bottom - 74;
|
|
/* This looks bad on NT */
|
|
PatBlt(ps.hdc, 0, y2, wParent, 1, PATCOPY);
|
|
#else
|
|
y2 = rc.bottom - 75;
|
|
#endif
|
|
/* Lines around toolbars */
|
|
PatBlt(ps.hdc, 0, y, wParent, 1, PATCOPY);
|
|
GetClientRect(ghwndToolbar, &rc);
|
|
x1 = rc.right;
|
|
PatBlt(ps.hdc, x1, y, 1, TOOLBAR_HEIGHT + 3, PATCOPY);
|
|
GetWindowRect(ghwndApp, &rc);
|
|
x2 = rc.left;
|
|
|
|
if (IsWindowVisible(ghwndStatic)) {
|
|
GetWindowRect(ghwndStatic, &rc);
|
|
MapWindowPoints(NULL, ghwndApp, (LPPOINT)&rc, 1);
|
|
x2 = rc.left - 2 - GetSystemMetrics(SM_CXFRAME);
|
|
|
|
PatBlt(ps.hdc, x2, y, 1, TOOLBAR_HEIGHT + 3, PATCOPY);
|
|
}
|
|
|
|
SelectObject(ps.hdc, hbrButtonHighLight);
|
|
/* Line above trackbar */
|
|
PatBlt(ps.hdc, 0, y2 + 1, wParent, 1, PATCOPY);
|
|
/* Lines around toolbar */
|
|
PatBlt(ps.hdc, 0, y + 1, wParent, 1, PATCOPY);
|
|
PatBlt(ps.hdc, x1 + 1, y + 1, 1, TOOLBAR_HEIGHT + 2, PATCOPY);
|
|
if (IsWindowVisible(ghwndStatic)) {
|
|
PatBlt(ps.hdc, x2 + 1, y + 1, 1,TOOLBAR_HEIGHT +2, PATCOPY);
|
|
}
|
|
SelectObject(ps.hdc, hbrOld);
|
|
}
|
|
|
|
EndPaint(hwnd, &ps);
|
|
|
|
}
|
|
|
|
|
|
void MPlayer_OnCommand_Toolbar_Play()
|
|
{
|
|
/* This checks to see whether the ALT key is held down.
|
|
* If so, the current selection (if it exists) is played,
|
|
* otherwise the whole shooting match.
|
|
* Note, this does not appear to be documented at present.
|
|
*/
|
|
if (GetKeyState(VK_MENU) < 0)
|
|
PostMessage(ghwndApp, WM_COMMAND, (WPARAM)ID_PLAYSEL, 0);
|
|
|
|
/* On WFW, pressing the play button when in place plays the
|
|
* current selection, if there is one. Do the same if we're
|
|
* playing or editing in place.
|
|
*/
|
|
else if (gfOle2IPPlaying || gfOle2IPEditing)
|
|
PostMessage(ghwndApp, WM_COMMAND, (WPARAM)ID_PLAYSEL, 0);
|
|
else
|
|
PostMessage(ghwndApp, WM_COMMAND, (WPARAM)ID_PLAY, 0);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_Pause()
|
|
{
|
|
PostMessage(ghwndApp, WM_COMMAND, (WPARAM)ID_PAUSE, 0L);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_Stop()
|
|
{
|
|
PostMessage(ghwndApp, WM_COMMAND, (WPARAM)ID_STOP, 0L);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_Eject()
|
|
{
|
|
PostMessage(ghwndApp, WM_COMMAND, (WPARAM)ID_EJECT, 0L);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_Home()
|
|
{
|
|
LONG_PTR lPos = CalcPrevMark();
|
|
|
|
/* We MUST use PostMessage because the */
|
|
/* SETPOS and ENDTRACK must happen one */
|
|
/* immediately after the other */
|
|
|
|
PostMessage(ghwndTrackbar, TBM_SETPOS, (WPARAM)TRUE, lPos);
|
|
|
|
PostMessage(ghwndApp, WM_HSCROLL, (WPARAM)TB_ENDTRACK, (LPARAM)ghwndTrackbar);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_End()
|
|
{
|
|
LONG_PTR lPos = CalcNextMark();
|
|
|
|
/* We MUST use PostMessage because the */
|
|
/* SETPOS and ENDTRACK must happen one */
|
|
/* immediately after the other */
|
|
|
|
PostMessage(ghwndTrackbar, TBM_SETPOS, (WPARAM)TRUE, lPos);
|
|
|
|
PostMessage(ghwndApp, WM_HSCROLL, (WPARAM)TB_ENDTRACK, (LPARAM)ghwndTrackbar);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_Rwd(HWND hwndCtl)
|
|
{
|
|
if (hwndCtl == (HWND)REPEAT_ID)
|
|
{
|
|
if (gwCurScale != ID_TRACKS)
|
|
PostMessage(ghwndApp, WM_HSCROLL, (WPARAM)TB_PAGEUP, 0L);
|
|
else
|
|
PostMessage(ghwndApp, WM_HSCROLL, (WPARAM)TB_LINEUP, 0L);
|
|
}
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_Fwd(HWND hwndCtl)
|
|
{
|
|
if (hwndCtl == (HWND)REPEAT_ID)
|
|
{
|
|
if (gwCurScale != ID_TRACKS)
|
|
PostMessage(ghwndApp, WM_HSCROLL, (WPARAM)TB_PAGEDOWN, 0L);
|
|
else
|
|
PostMessage(ghwndApp, WM_HSCROLL, (WPARAM)TB_LINEDOWN, 0L);
|
|
}
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_MarkIn()
|
|
{
|
|
SendMessage(ghwndTrackbar, TBM_SETSELSTART, (WPARAM)TRUE,
|
|
SendMessage(ghwndTrackbar, TBM_GETPOS, 0, 0));
|
|
|
|
DirtyObject(TRUE);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_MarkOut()
|
|
{
|
|
SendMessage(ghwndTrackbar, TBM_SETSELEND, (WPARAM)TRUE,
|
|
SendMessage(ghwndTrackbar, TBM_GETPOS, 0, 0));
|
|
|
|
DirtyObject(TRUE);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_ArrowPrev(HWND hwndCtl)
|
|
{
|
|
if (hwndCtl == (HWND)REPEAT_ID)
|
|
SendMessage(ghwndApp, WM_HSCROLL, (WPARAM)TB_LINEUP, 0L);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Toolbar_ArrowNext(HWND hwndCtl)
|
|
{
|
|
if (hwndCtl == (HWND)REPEAT_ID)
|
|
SendMessage(ghwndApp, WM_HSCROLL, (WPARAM)TB_LINEDOWN, 0L);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_CopyObject(HWND hwnd)
|
|
{
|
|
if (gfPlayingInPlace)
|
|
{
|
|
DPF0("Mplayer WndProc: Can't cutorcopy\n");
|
|
return;
|
|
}
|
|
|
|
DPF("Mplayer WndProc: Calling cutorcopy\n");
|
|
|
|
if (!InitOLE(&gfOleInitialized, &lpMalloc))
|
|
{
|
|
/* How likely is this? Do we need a dialog box?
|
|
*/
|
|
DPF0("Initialization of OLE FAILED!! Can't do copy.\n");
|
|
}
|
|
|
|
#ifdef OLE1_HACK
|
|
CopyObject(hwnd);
|
|
#endif /* OLE1_HACK */
|
|
CutOrCopyObj(&docMain);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_Config(HWND hwnd)
|
|
{
|
|
RECT rcBefore;
|
|
RECT rcAfter;
|
|
|
|
if (gfPlayingInPlace)
|
|
return;
|
|
|
|
GetDestRectMCI (&rcBefore);
|
|
|
|
ConfigMCI(hwnd);
|
|
|
|
/* If the MCI window size changed, we need to resize */
|
|
/* our reduced mplayer. */
|
|
if (gfPlayOnly)
|
|
{
|
|
GetDestRectMCI (&rcAfter);
|
|
|
|
if (!EqualRect(&rcBefore, &rcAfter) && (!IsRectEmpty(&rcAfter)))
|
|
SetMPlayerSize(&rcAfter);
|
|
}
|
|
}
|
|
|
|
|
|
void MPlayer_OnCommand_Menu_Volume(HWND hwnd)
|
|
{
|
|
HANDLE hThread;
|
|
DWORD dwThreadId;
|
|
|
|
hThread = CreateThread( NULL, 0L,
|
|
(LPTHREAD_START_ROUTINE)StartSndVol,
|
|
NULL, 0L, &dwThreadId );
|
|
|
|
if ( hThread != NULL ) {
|
|
CloseHandle( hThread );
|
|
}
|
|
}
|
|
|
|
|
|
void MPlayer_OnCommand_PlayToggle(HWND hwnd)
|
|
{
|
|
/* This is for the accelerator to toggle play and pause. */
|
|
/* Ordinary play commands better not toggle. */
|
|
|
|
DPF2("MPlayer_OnCommand_PlayToggle: gwStatus == %x\n", gwStatus);
|
|
|
|
switch(gwStatus) {
|
|
|
|
case MCI_MODE_STOP:
|
|
case MCI_MODE_PAUSE:
|
|
case MCI_MODE_SEEK:
|
|
PostMessage(hwnd, WM_COMMAND, (WPARAM)ID_PLAY, 0);
|
|
break;
|
|
|
|
case MCI_MODE_PLAY:
|
|
PostMessage(hwnd, WM_COMMAND, (WPARAM)ID_PAUSE, 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void MPlayer_OnCommand_PlaySel(HWND hwnd, HWND hwndCtl)
|
|
{
|
|
DWORD_PTR dwPos, dwStart, dwEnd;
|
|
BOOL f;
|
|
dwPos = 0; // Make Prefix Happy..
|
|
|
|
DPF2("MPlayer_OnCommand_PlaySel: gwStatus == %x\n", gwStatus);
|
|
|
|
switch(gwStatus) {
|
|
|
|
case MCI_MODE_OPEN:
|
|
case MCI_MODE_NOT_READY:
|
|
|
|
Error(ghwndApp, IDS_CANTPLAY);
|
|
if (gfCloseAfterPlaying) // get us out now!!
|
|
PostCloseMessage();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* If the shift key's being held down, make this the start
|
|
* of a selection:
|
|
*/
|
|
|
|
if((GetKeyState(VK_SHIFT) < 0)
|
|
&&(toolbarStateFromButton(ghwndMark, BTN_MARKIN, TBINDEX_MARK)
|
|
!= BTNST_GRAYED))
|
|
SendMessage(hwnd, WM_COMMAND, IDT_MARKIN, 0);
|
|
|
|
/* Start playing the medium */
|
|
|
|
StatusMCI(&dwPos); // get the REAL position
|
|
dwStart = SendMessage(ghwndTrackbar, TBM_GETSELSTART, 0, 0);
|
|
dwEnd = SendMessage(ghwndTrackbar, TBM_GETSELEND, 0, 0);
|
|
|
|
/* If there is no valid selection, act like PLAY */
|
|
if (dwStart == -1 || dwEnd == -1 || dwStart == dwEnd)
|
|
hwndCtl = (HWND)ID_PLAY;
|
|
|
|
// Be nice and rewind automatically if we're at the end of the media.
|
|
// Depending on the device, though, the end could be "start + len"
|
|
// or "start + len - 1"
|
|
if (hwndCtl == (HWND)ID_PLAY &&
|
|
dwPos >= gdwMediaStart + gdwMediaLength - 1) {
|
|
if (!SeekMCI(gdwMediaStart))
|
|
break;
|
|
}
|
|
|
|
if (hwndCtl == (HWND)ID_PLAYSEL) {
|
|
f = PlayMCI(dwStart, dwEnd);
|
|
gfJustPlayedSel = TRUE;
|
|
} else {
|
|
f = PlayMCI(0, 0);
|
|
gfJustPlayedSel = FALSE;
|
|
}
|
|
|
|
// get us out NOW!! or focus goes to client
|
|
if (!f && gfCloseAfterPlaying)
|
|
PostCloseMessage();
|
|
|
|
/* No longer needed - reset for next time */
|
|
gfUserStopped = FALSE;
|
|
|
|
gwStatus = (UINT)(-1); // force rewind if needed
|
|
break;
|
|
}
|
|
}
|
|
|
|
void MPlayer_OnCommand_Pause()
|
|
{
|
|
/* Pause the medium, unless we are already paused */
|
|
|
|
DPF2("MPlayer_OnCommand_Pause: gwStatus == %x\n", gwStatus);
|
|
|
|
switch(gwStatus) {
|
|
|
|
case MCI_MODE_PAUSE:
|
|
PlayMCI(0, 0);
|
|
break;
|
|
|
|
case MCI_MODE_PLAY:
|
|
case MCI_MODE_SEEK:
|
|
PauseMCI();
|
|
break;
|
|
|
|
case MCI_MODE_STOP:
|
|
case MCI_MODE_OPEN:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void MPlayer_OnCommand_Stop()
|
|
{
|
|
/* Stop the medium */
|
|
|
|
DPF2("MPlayer_OnCommand_Stop: gwStatus == %x\n", gwStatus);
|
|
|
|
switch(gwStatus) {
|
|
|
|
case MCI_MODE_PAUSE:
|
|
case MCI_MODE_PLAY:
|
|
case MCI_MODE_STOP:
|
|
case MCI_MODE_SEEK:
|
|
|
|
StopMCI();
|
|
SeekToStartMCI();
|
|
gfUserStopped = TRUE; // we did this
|
|
gfCloseAfterPlaying = FALSE; //stay up from now on
|
|
|
|
UpdateDisplay();
|
|
|
|
// Focus should go to PLAY button now
|
|
toolbarSetFocus(ghwndToolbar, BTN_PLAY);
|
|
break;
|
|
|
|
case MCI_MODE_OPEN:
|
|
break;
|
|
}
|
|
|
|
if (gfPlayingInPlace)
|
|
PostCloseMessage();
|
|
}
|
|
|
|
|
|
void MPlayer_OnCommand_Eject()
|
|
{
|
|
/*
|
|
* Eject the medium if it currently isn't ejected. If it
|
|
* is currently ejected, then load the new medium into
|
|
* the device.
|
|
*
|
|
*/
|
|
|
|
switch(gwStatus) {
|
|
|
|
case MCI_MODE_PLAY:
|
|
case MCI_MODE_PAUSE:
|
|
|
|
StopMCI();
|
|
EjectMCI(TRUE);
|
|
|
|
break;
|
|
|
|
case MCI_MODE_STOP:
|
|
case MCI_MODE_SEEK:
|
|
case MCI_MODE_NOT_READY:
|
|
|
|
EjectMCI(TRUE);
|
|
|
|
break;
|
|
|
|
case MCI_MODE_OPEN:
|
|
|
|
EjectMCI(FALSE);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void MPlayer_OnCommand_Escape()
|
|
{
|
|
MPlayer_OnCommand_Stop();
|
|
|
|
if( gfOle2IPEditing || gfOle2IPPlaying)
|
|
PostCloseMessage();
|
|
}
|
|
|
|
|
|
void MPlayer_OnCommand_Menu_Open()
|
|
{
|
|
UINT wLastScale;
|
|
UINT wLastDeviceID;
|
|
TCHAR szFile[256];
|
|
RECT rc;
|
|
|
|
wLastScale = gwCurScale; // save old scale
|
|
wLastDeviceID = gwDeviceID;
|
|
if (gfPlayingInPlace || gfOle2IPEditing || gfOle2IPPlaying)
|
|
return;
|
|
|
|
InitDeviceMenu();
|
|
WaitForDeviceMenu();
|
|
|
|
if (OpenDoc(gwCurDevice,szFile))
|
|
{
|
|
DirtyObject(FALSE);
|
|
/* Force WM_GETMINMAXINFO to be called so we'll snap */
|
|
/* to a proper size. */
|
|
GetWindowRect(ghwndApp, &rc);
|
|
MoveWindow(ghwndApp,
|
|
rc.left,
|
|
rc.top,
|
|
rc.right - rc.left,
|
|
rc.bottom - rc.top,
|
|
TRUE);
|
|
|
|
if (gfOpenDialog)
|
|
CompleteOpenDialog(TRUE);
|
|
else
|
|
gfCloseAfterPlaying = FALSE; // stay up from now on
|
|
|
|
//If the CD Audio device was opened it must have been a *.cda file.
|
|
//Try to jump to the track corresponding to the file opened.
|
|
if ((gwDeviceType & DTMCI_DEVICE) == DTMCI_CDAUDIO)
|
|
{
|
|
HandleCDAFile(szFile);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (gfOpenDialog)
|
|
CompleteOpenDialog(FALSE);
|
|
|
|
/* The previous device may or may not still be open.
|
|
* If it is, make sure we have the right scale.
|
|
*/
|
|
if (gwDeviceID == wLastDeviceID)
|
|
gwCurScale = wLastScale; // restore to last scale
|
|
|
|
InvalidateRect(ghwndMap, NULL, TRUE); //erase map area
|
|
}
|
|
|
|
// put the focus on the Play button
|
|
SetFocus(ghwndToolbar); // give focus to PLAY button
|
|
toolbarSetFocus(ghwndToolbar, BTN_PLAY);
|
|
|
|
SetMPlayerIcon();
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_Close(HWND hwnd)
|
|
{
|
|
if (gfEmbeddedObject && !gfSeenPBCloseMsg) {
|
|
// this is File.Update
|
|
#ifdef OLE1_HACK
|
|
if( gDocVersion == DOC_VERSION_OLE1 )
|
|
Ole1UpdateObject();
|
|
else
|
|
#endif /* OLE1_HACK */
|
|
UpdateObject();
|
|
}
|
|
else
|
|
{
|
|
// this is File.Close
|
|
gfSeenPBCloseMsg = TRUE;
|
|
|
|
WriteOutOptions();
|
|
InitDoc(TRUE);
|
|
SetMPlayerIcon();
|
|
gwCurDevice = 0;// force next file open dialog to say
|
|
// "all files" because CloseMCI won't.
|
|
|
|
gwCurScale = ID_NONE; // uncheck all scale types
|
|
|
|
Layout(); // Make window snap back to smaller size
|
|
// if it should.
|
|
// Don't leave us closed in play only mode
|
|
|
|
if (gfPlayOnly)
|
|
SendMessage(hwnd, WM_COMMAND, (WPARAM)IDM_WINDOW, 0);
|
|
}
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_Exit()
|
|
{
|
|
PostCloseMessage();
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_Scale(UINT id)
|
|
{
|
|
/*
|
|
* Invalidate the track map window so it will be
|
|
* redrawn with the correct positions, etc.
|
|
*/
|
|
if (gwCurScale != id - IDM_SCALE) {
|
|
|
|
// Restoring the selection doesn't work yet,
|
|
// because UpdateMCI clears the selection,
|
|
// plus we need to do some conversion.
|
|
// int SelStart = SendMessage(ghwndTrackbar, TBM_GETSELSTART, 0, 0);
|
|
// int SelEnd = SendMessage(ghwndTrackbar, TBM_GETSELEND, 0, 0);
|
|
|
|
SendMessage(ghwndTrackbar, TBM_CLEARTICS, (WPARAM)FALSE, 0L);
|
|
if (gwCurScale == ID_FRAMES || id - IDM_SCALE == ID_FRAMES)
|
|
gfValidMediaInfo = FALSE;
|
|
|
|
gwCurScale = id - IDM_SCALE;
|
|
DirtyObject(TRUE); // change scale changes PAGE UP/DOWN
|
|
CalcTicsOfDoom();
|
|
|
|
// SendMessage(ghwndTrackbar, TBM_SETSELSTART, TRUE, SelStart);
|
|
// SendMessage(ghwndTrackbar, TBM_SETSELEND, TRUE, SelEnd);
|
|
}
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_Selection(HWND hwnd)
|
|
{
|
|
if (!gfPlayingInPlace)
|
|
setselDialog(hwnd);
|
|
}
|
|
|
|
|
|
void MPlayer_OnCommand_Menu_Options(HWND hwnd)
|
|
{
|
|
if (!gfPlayingInPlace)
|
|
optionsDialog(hwnd);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_MCIString(HWND hwnd)
|
|
{
|
|
if (!gfPlayingInPlace && gwDeviceID)
|
|
mciDialog(hwnd);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_Window(HWND hwnd)
|
|
{
|
|
//
|
|
// make MPlayer small/big
|
|
//
|
|
//!! dont do this if inside client document !!
|
|
//!! or if we're not visible !!
|
|
|
|
if (!IsWindowVisible(ghwndApp) || gfPlayingInPlace || IsIconic(hwnd)
|
|
|| gfOle2IPEditing)
|
|
return;
|
|
|
|
// allowed to get out of teeny mode when no file is open
|
|
if (gwDeviceID != (UINT)0 || gfPlayOnly) {
|
|
gfPlayOnly = !gfPlayOnly;
|
|
SizeMPlayer();
|
|
}
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_Zoom(HWND hwnd, int id)
|
|
{
|
|
int dx, dy;
|
|
|
|
if (IsIconic(hwnd) ||gfPlayingInPlace || gfOle2IPPlaying || gfOle2IPEditing ||
|
|
!(gwDeviceType & DTMCI_CANWINDOW))
|
|
return;
|
|
|
|
dx = grcSize.right * (id-IDM_ZOOM);
|
|
dy = grcSize.bottom * (id-IDM_ZOOM);
|
|
|
|
//
|
|
// if the playback windows is now larger than the screen
|
|
// maximize MPlayer, this only makes sence for Tiny mode.
|
|
//
|
|
if (gfPlayOnly &&
|
|
(dx >= GetSystemMetrics(SM_CXSCREEN) ||
|
|
dy >= GetSystemMetrics(SM_CYSCREEN))) {
|
|
ClrWS(hwnd, WS_MAXIMIZE);
|
|
DefWindowProc(hwnd, WM_SYSCOMMAND, (WPARAM)SC_MAXIMIZE, 0);
|
|
}
|
|
else {
|
|
SizePlaybackWindow(dx, dy);
|
|
}
|
|
}
|
|
|
|
void DoHtmlHelp()
|
|
{
|
|
//note, using ANSI version of function because UNICODE is foobar in NT5 builds
|
|
char chDst[MAX_PATH];
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, gszHtmlHelpFileName,
|
|
-1, chDst, MAX_PATH, NULL, NULL);
|
|
HtmlHelpA(GetDesktopWindow(), chDst, HH_DISPLAY_TOPIC, 0);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_HelpTopics(HWND hwnd)
|
|
{
|
|
static TCHAR HelpFile[] = TEXT("MPLAYER.HLP");
|
|
|
|
//Handle context menu help
|
|
if(bF1InMenu)
|
|
{
|
|
switch(currMenuItem)
|
|
{
|
|
case IDM_OPEN:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_FILE_OPEN);
|
|
break;
|
|
case IDM_CLOSE:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_FILE_CLOSE);
|
|
break;
|
|
case IDM_EXIT:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_FILE_EXIT);
|
|
break;
|
|
case IDM_COPY_OBJECT:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_EDIT_COPY_OBJECT);
|
|
break;
|
|
case IDM_OPTIONS:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_EDIT_OPTIONS);
|
|
break;
|
|
case IDM_SELECTION:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_EDIT_SELECTION);
|
|
break;
|
|
case IDM_CONFIG:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_DEVICE_PROPERTIES);
|
|
break;
|
|
case IDM_VOLUME:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_DEVICE_VOLUME_CONTROL);
|
|
break;
|
|
case IDM_SCALE + ID_TIME:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_SCALE_TIME);
|
|
break;
|
|
case IDM_SCALE + ID_TRACKS:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_SCALE_TRACKS);
|
|
break;
|
|
case IDM_SCALE + ID_FRAMES:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_SCALE_FRAMES);
|
|
break;
|
|
case IDM_HELPTOPICS:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_HELP_HELP_TOPICS);
|
|
break;
|
|
case IDM_ABOUT:
|
|
WinHelp(hwnd, HelpFile, HELP_CONTEXTPOPUP, IDH_MPLYR_CS_MEDIA_PLAYER_HELP_ABOUT);
|
|
break;
|
|
default://In the default case just display the HTML Help.
|
|
DoHtmlHelp();
|
|
}
|
|
bF1InMenu = FALSE; //This flag will be set again if F1 is pressed in a menu.
|
|
}
|
|
else
|
|
DoHtmlHelp();
|
|
}
|
|
|
|
void MPlayer_OnCommand_Menu_About(HWND hwnd)
|
|
{
|
|
ShellAbout(hwnd, gachAppName, aszNULL, hiconApp);
|
|
}
|
|
|
|
void MPlayer_OnCommand_Default(HWND hwnd, int id)
|
|
{
|
|
/*
|
|
* Determine if the user selected one of the entries in
|
|
* the Device menu.
|
|
*
|
|
*/
|
|
|
|
if (id > IDM_DEVICE0 &&
|
|
(id <= (WORD)(IDM_DEVICE0 + gwNumDevices))
|
|
) {
|
|
|
|
BOOL fHasWindow, fHadWindow, fHadDevice;
|
|
|
|
fHadWindow = (gwDeviceID != (UINT)0) && (gwDeviceType & DTMCI_CANWINDOW);
|
|
fHadDevice = (gwDeviceID != (UINT)0);
|
|
|
|
//Choose and open a new device. If we are active inplace we have
|
|
//to consider the effect of the change in device on the visual appearence.
|
|
//For this we have to take into account whether the current and previous
|
|
//device had a playback window or not. We also have to consider
|
|
//whether this is the first device are opening.
|
|
//After all the crazy munging send a messages to the container about
|
|
//the changes.
|
|
if (DoChooseDevice(id-IDM_DEVICE0))
|
|
{
|
|
if (gfOpenDialog)
|
|
CompleteOpenDialog(TRUE);
|
|
|
|
fHasWindow = (gwDeviceID != (UINT)0) && (gwDeviceType & DTMCI_CANWINDOW);
|
|
if(gfOle2IPEditing)
|
|
{
|
|
if (fHasWindow && fHadWindow)
|
|
{
|
|
GetWindowRect(ghwndApp, (LPRECT)&gInPlacePosRect);
|
|
gfInPlaceResize = TRUE;
|
|
SendDocMsg((LPDOC)&docMain, OLE_SIZECHG);
|
|
SendDocMsg((LPDOC)&docMain, OLE_CHANGED);
|
|
}
|
|
|
|
else
|
|
{
|
|
RECT rc;
|
|
RECT rctmp;
|
|
|
|
ClrWS(ghwndApp,
|
|
WS_THICKFRAME|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_BORDER);
|
|
|
|
if (gwOptions & OPT_BORDER)
|
|
SetWS(ghwndApp, WS_BORDER);
|
|
|
|
GetWindowRect(ghwndApp, &rc);
|
|
|
|
if (!(gwDeviceType & DTMCI_CANWINDOW))
|
|
{
|
|
HBITMAP hbm;
|
|
BITMAP bm;
|
|
|
|
if (!fHadDevice)
|
|
GetWindowRect(ghwndIPHatch, &rc);
|
|
hbm = BitmapMCI();
|
|
GetObject(hbm,sizeof(bm),&bm);
|
|
rc.bottom = rc.top + bm.bmHeight;
|
|
rc.right = rc.left + bm.bmWidth;
|
|
DeleteObject(hbm);
|
|
}
|
|
else
|
|
{
|
|
if(!fHadDevice)
|
|
{
|
|
rc.bottom -= (GetSystemMetrics(SM_CYCAPTION)-GetSystemMetrics(SM_CYBORDER));
|
|
gwOptions |= OPT_BAR | OPT_TITLE;
|
|
}
|
|
rc.bottom += gInPlacePosRect.top - rc.top - 4*GetSystemMetrics(SM_CYBORDER) - 4 ;
|
|
rc.right += gInPlacePosRect.left - rc.left- 4*GetSystemMetrics(SM_CXBORDER) - 4 ;
|
|
rc.top = gInPlacePosRect.top;
|
|
rc.left = gInPlacePosRect.left;
|
|
}
|
|
rctmp = gPrevPosRect;
|
|
MapWindowPoints( ghwndCntr, NULL, (LPPOINT)&rctmp,2);
|
|
OffsetRect((LPRECT)&rc, rctmp.left - rc.left, rctmp.top -rc.top);
|
|
gInPlacePosRect = rc;
|
|
gfInPlaceResize = TRUE;
|
|
if(!(gwDeviceType & DTMCI_CANWINDOW) && (gwOptions & OPT_BAR))
|
|
{
|
|
rc.top = rc.bottom - gwPlaybarHeight;
|
|
}
|
|
EditInPlace(ghwndApp,ghwndIPHatch,&rc);
|
|
SendDocMsg((LPDOC)&docMain, OLE_SIZECHG);
|
|
SendDocMsg((LPDOC)&docMain, OLE_CHANGED);
|
|
if (!(gwDeviceType & DTMCI_CANWINDOW) && !(gwOptions &OPT_BAR))
|
|
ShowWindow(ghwndApp, SW_HIDE);
|
|
else
|
|
ShowWindow(ghwndApp, SW_SHOW);
|
|
}
|
|
}
|
|
|
|
DirtyObject(FALSE);
|
|
|
|
if (!gfOpenDialog)
|
|
gfCloseAfterPlaying = FALSE; // stay up from now on
|
|
|
|
SetMPlayerIcon();
|
|
}
|
|
else
|
|
if (gfOpenDialog)
|
|
CompleteOpenDialog(FALSE);
|
|
}
|
|
}
|
|
|
|
#define HANDLE_COMMAND(id, call) case (id): (call); break
|
|
|
|
void MPlayer_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
|
|
{
|
|
switch (id) {
|
|
|
|
HANDLE_COMMAND(IDT_PLAY, MPlayer_OnCommand_Toolbar_Play());
|
|
HANDLE_COMMAND(IDT_PAUSE, MPlayer_OnCommand_Toolbar_Pause());
|
|
HANDLE_COMMAND(IDT_STOP, MPlayer_OnCommand_Toolbar_Stop());
|
|
HANDLE_COMMAND(IDT_EJECT, MPlayer_OnCommand_Toolbar_Eject());
|
|
HANDLE_COMMAND(IDT_HOME, MPlayer_OnCommand_Toolbar_Home());
|
|
HANDLE_COMMAND(IDT_END, MPlayer_OnCommand_Toolbar_End());
|
|
HANDLE_COMMAND(IDT_RWD, MPlayer_OnCommand_Toolbar_Rwd(hwndCtl));
|
|
HANDLE_COMMAND(IDT_FWD, MPlayer_OnCommand_Toolbar_Fwd(hwndCtl));
|
|
HANDLE_COMMAND(IDT_MARKIN, MPlayer_OnCommand_Toolbar_MarkIn());
|
|
HANDLE_COMMAND(IDT_MARKOUT, MPlayer_OnCommand_Toolbar_MarkOut());
|
|
HANDLE_COMMAND(IDT_ARROWPREV, MPlayer_OnCommand_Toolbar_ArrowPrev(hwndCtl));
|
|
HANDLE_COMMAND(IDT_ARROWNEXT, MPlayer_OnCommand_Toolbar_ArrowNext(hwndCtl));
|
|
HANDLE_COMMAND(IDM_COPY_OBJECT, MPlayer_OnCommand_Menu_CopyObject(hwnd));
|
|
HANDLE_COMMAND(IDM_CONFIG, MPlayer_OnCommand_Menu_Config(hwnd));
|
|
HANDLE_COMMAND(IDM_VOLUME, MPlayer_OnCommand_Menu_Volume(hwnd));
|
|
HANDLE_COMMAND(ID_PLAYTOGGLE, MPlayer_OnCommand_PlayToggle(hwnd));
|
|
HANDLE_COMMAND(ID_PLAY, MPlayer_OnCommand_PlaySel(hwnd, (HWND)IntToPtr(id)));
|
|
HANDLE_COMMAND(ID_PLAYSEL, MPlayer_OnCommand_PlaySel(hwnd, (HWND)IntToPtr(id)));
|
|
HANDLE_COMMAND(ID_PAUSE, MPlayer_OnCommand_Pause());
|
|
HANDLE_COMMAND(ID_STOP, MPlayer_OnCommand_Stop());
|
|
HANDLE_COMMAND(ID_EJECT, MPlayer_OnCommand_Eject());
|
|
HANDLE_COMMAND(ID_ESCAPE, MPlayer_OnCommand_Escape());
|
|
HANDLE_COMMAND(IDM_OPEN, MPlayer_OnCommand_Menu_Open());
|
|
HANDLE_COMMAND(IDM_CLOSE, MPlayer_OnCommand_Menu_Close(hwnd));
|
|
HANDLE_COMMAND(IDM_EXIT, MPlayer_OnCommand_Menu_Exit());
|
|
HANDLE_COMMAND(IDM_SCALE + ID_TIME, MPlayer_OnCommand_Menu_Scale(id));
|
|
HANDLE_COMMAND(IDM_SCALE + ID_TRACKS, MPlayer_OnCommand_Menu_Scale(id));
|
|
HANDLE_COMMAND(IDM_SCALE + ID_FRAMES, MPlayer_OnCommand_Menu_Scale(id));
|
|
HANDLE_COMMAND(IDM_SELECTION, MPlayer_OnCommand_Menu_Selection(hwnd));
|
|
HANDLE_COMMAND(IDM_OPTIONS, MPlayer_OnCommand_Menu_Options(hwnd));
|
|
HANDLE_COMMAND(IDM_MCISTRING, MPlayer_OnCommand_Menu_MCIString(hwnd));
|
|
HANDLE_COMMAND(IDM_WINDOW, MPlayer_OnCommand_Menu_Window(hwnd));
|
|
HANDLE_COMMAND(IDM_ZOOM1, MPlayer_OnCommand_Menu_Zoom(hwnd, id));
|
|
HANDLE_COMMAND(IDM_ZOOM2, MPlayer_OnCommand_Menu_Zoom(hwnd, id));
|
|
HANDLE_COMMAND(IDM_ZOOM3, MPlayer_OnCommand_Menu_Zoom(hwnd, id));
|
|
HANDLE_COMMAND(IDM_ZOOM4, MPlayer_OnCommand_Menu_Zoom(hwnd, id));
|
|
HANDLE_COMMAND(IDM_HELPTOPICS, MPlayer_OnCommand_Menu_HelpTopics(hwnd));
|
|
HANDLE_COMMAND(IDM_ABOUT, MPlayer_OnCommand_Menu_About(hwnd));
|
|
|
|
default: MPlayer_OnCommand_Default(hwnd, id);
|
|
}
|
|
|
|
UpdateDisplay();
|
|
}
|
|
|
|
void MPlayer_OnClose(HWND hwnd)
|
|
{
|
|
int f;
|
|
|
|
DPF("WM_CLOSE received\n");
|
|
|
|
if (gfInClose) {
|
|
DPF("*** \n");
|
|
DPF("*** Trying to re-enter WM_CLOSE\n");
|
|
DPF("*** \n");
|
|
return;
|
|
}
|
|
|
|
|
|
// Ask if we want to update before we set gfInClose to TRUE or
|
|
// we won't let the dialog box up.
|
|
f = AskUpdate();
|
|
if (f == IDYES)
|
|
UpdateObject();
|
|
if (f == IDCANCEL) {
|
|
gfInClose = FALSE;
|
|
return;
|
|
}
|
|
|
|
gfInClose = TRUE;
|
|
|
|
ExitApplication();
|
|
if (gfPlayingInPlace)
|
|
EndPlayInPlace(hwnd);
|
|
if (gfOle2IPEditing)
|
|
EndEditInPlace(hwnd);
|
|
|
|
if (docMain.lpoleclient)
|
|
IOleClientSite_OnShowWindow(docMain.lpoleclient, FALSE);
|
|
|
|
SendDocMsg(&docMain,OLE_CLOSED);
|
|
DestroyDoc(&docMain);
|
|
ExitApplication();
|
|
|
|
if (hMciOle)
|
|
{
|
|
FreeLibrary(hMciOle);
|
|
hMciOle = NULL;
|
|
}
|
|
|
|
|
|
//
|
|
// set either the owner or the WS_CHILD bit so it will
|
|
// not act up because we have the palette bit set and cause the
|
|
// desktop to steal the palette.
|
|
//
|
|
// because we are being run from client apps that dont deal
|
|
// with palettes we dont want the desktop to hose the palette.
|
|
//
|
|
if (gfPlayOnly && gfCloseAfterPlaying && gfRunWithEmbeddingFlag)
|
|
SetWindowLongPtr(hwnd, GWLP_HWNDPARENT, (LPARAM)GetDesktopWindow() );
|
|
|
|
if (!ItsSafeToClose()) {
|
|
DPF("*** \n");
|
|
DPF("*** Trying to close MPLAYER with a ErrorBox up\n");
|
|
DPF("*** \n");
|
|
gfErrorDeath = WM_CLOSE;
|
|
gfInClose = FALSE;
|
|
return;
|
|
}
|
|
|
|
f = AskUpdate();
|
|
if (f == IDYES)
|
|
UpdateObject();
|
|
if (f == IDCANCEL) {
|
|
gfInClose = FALSE;
|
|
return;
|
|
}
|
|
|
|
PostMessage(ghwndApp, WM_USER_DESTROY, 0, 0);
|
|
DPF("WM_DESTROY message sent\n");
|
|
}
|
|
|
|
void MPlayer_OnEndSession(HWND hwnd, BOOL fEnding)
|
|
{
|
|
if (fEnding) {
|
|
WriteOutPosition();
|
|
WriteOutOptions();
|
|
CloseMCI(FALSE);
|
|
}
|
|
}
|
|
|
|
void MPlayer_OnDestroy(HWND hwnd)
|
|
{
|
|
/*
|
|
* Relinquish control of whatever MCI device we were using (if any). If
|
|
* this device is not shareable, then performing this action allows
|
|
* someone else to gain access to the device.
|
|
*
|
|
*/
|
|
|
|
/* Client might close us if he dies while we're Playing in Place */
|
|
if (gfPlayingInPlace) {
|
|
DPF("****\n");
|
|
DPF("**** Window destroyed while in place!\n");
|
|
DPF("****\n");
|
|
}
|
|
|
|
//Unregister the WM_DEVICECHANGE notification
|
|
DeviceChange_Cleanup();
|
|
|
|
WriteOutOptions();
|
|
CloseMCI(FALSE);
|
|
|
|
SetMenu(hwnd, NULL);
|
|
|
|
if (ghMenu)
|
|
DestroyMenu(ghMenu);
|
|
|
|
ghMenu = NULL;
|
|
|
|
WinHelp(hwnd, gszHelpFileName, HELP_QUIT, 0L);
|
|
|
|
PostQuitMessage(0);
|
|
|
|
if (IsWindow(ghwndFrame))
|
|
SetFocus(ghwndFrame);
|
|
else if (IsWindow(ghwndFocusSave))
|
|
SetFocus(ghwndFocusSave);
|
|
|
|
//Inform OLE that we are not taking any more calls.
|
|
if (gfOleInitialized)
|
|
{
|
|
#ifdef OLE1_HACK
|
|
if( gDocVersion == DOC_VERSION_OLE1 )
|
|
TerminateServer();
|
|
else
|
|
#endif /* OLE1_HACK */
|
|
/* Verify that the server was initialised by checking that one
|
|
* of the fields in docMain is non-null:
|
|
*/
|
|
if( docMain.hwnd )
|
|
CoDisconnectObject((LPUNKNOWN)&docMain, 0);
|
|
else
|
|
DPF0("An instance of the server was never created.\n");
|
|
}
|
|
}
|
|
|
|
|
|
void MPlayer_OnTimer(HWND hwnd, UINT id)
|
|
{
|
|
MSG msg;
|
|
|
|
UpdateDisplay();
|
|
PeekMessage(&msg, hwnd, WM_TIMER, WM_TIMER, PM_REMOVE);
|
|
}
|
|
|
|
|
|
#define MARK_START -1
|
|
#define MARK_NONE 0
|
|
#define MARK_END 1
|
|
void UpdateSelection(HWND hwnd, INT_PTR pos, int *pPrevMark)
|
|
{
|
|
INT_PTR SelStart;
|
|
INT_PTR SelEnd;
|
|
|
|
SelStart = SendMessage(ghwndTrackbar, TBM_GETSELSTART, 0, 0);
|
|
SelEnd = SendMessage(ghwndTrackbar, TBM_GETSELEND, 0, 0);
|
|
|
|
if (pos < SelStart)
|
|
{
|
|
SendMessage(hwnd, WM_COMMAND, IDT_MARKIN, 0);
|
|
*pPrevMark = MARK_START;
|
|
}
|
|
else if (pos > SelEnd)
|
|
{
|
|
SendMessage(hwnd, WM_COMMAND, IDT_MARKOUT, 0);
|
|
*pPrevMark = MARK_END;
|
|
}
|
|
else
|
|
{
|
|
if (*pPrevMark == MARK_START)
|
|
SendMessage(hwnd, WM_COMMAND, IDT_MARKIN, 0);
|
|
else
|
|
SendMessage(hwnd, WM_COMMAND, IDT_MARKOUT, 0);
|
|
}
|
|
}
|
|
|
|
|
|
void MPlayer_OnHScroll(HWND hwnd, HWND hwndCtl, UINT code, int pos)
|
|
{
|
|
DWORD_PTR dwPosition; /* player's current position in the medium*/
|
|
DWORD_PTR dwCurTime; /* Time a page up/down is last made */
|
|
TCHAR ach[60];
|
|
static int PrevMark;
|
|
|
|
/* If the media has no size, we can't seek. */
|
|
if (gdwMediaLength == 0L)
|
|
return;
|
|
|
|
dwPosition = SendMessage(ghwndTrackbar, TBM_GETPOS, 0, 0);
|
|
|
|
if (!gfScrollTrack) {
|
|
gfScrollTrack = TRUE;
|
|
|
|
/* If the shift key's being held down, make this the start
|
|
* of a selection:
|
|
*/
|
|
|
|
if((GetKeyState(VK_SHIFT) < 0)
|
|
&&(toolbarStateFromButton(ghwndMark, BTN_MARKIN, TBINDEX_MARK)
|
|
!= BTNST_GRAYED))
|
|
{
|
|
SendMessage(ghwndTrackbar, TBM_CLEARSEL, (WPARAM)TRUE, 0);
|
|
SendMessage(hwnd, WM_COMMAND, IDT_MARKIN, 0);
|
|
SetFocus(ghwndTrackbar); /* So that escape will go to
|
|
the trackbar's subclassed
|
|
winproc. */
|
|
}
|
|
|
|
sfSeekExact = SeekExactMCI(FALSE);
|
|
}
|
|
|
|
switch (code) {
|
|
/*
|
|
* Set the new position within the medium to be
|
|
* slightly before/after the current position if the
|
|
* left/right scroll arrow was clicked on.
|
|
*/
|
|
case TB_LINEUP: /* left scroll arrow */
|
|
dwPosition -= (gwCurScale == ID_FRAMES) ? 1L : SCROLL_GRANULARITY;
|
|
break;
|
|
|
|
case TB_LINEDOWN: /* right scroll arrow */
|
|
dwPosition += (gwCurScale == ID_FRAMES) ? 1L : SCROLL_GRANULARITY;
|
|
break;
|
|
|
|
case TB_PAGEUP: /* page-left */
|
|
|
|
/*
|
|
* If the user just did a page-left a short time ago,
|
|
* then seek to the start of the previous track.
|
|
* Otherwise, seek to the start of this track.
|
|
*
|
|
*/
|
|
if (gwCurScale != ID_TRACKS) {
|
|
dwPosition -= SCROLL_BIGGRAN;
|
|
} else {
|
|
dwCurTime = GetCurrentTime();
|
|
if (dwCurTime - dwLastPageUpTime < SKIPTRACKDELAY_MSEC)
|
|
SkipTrackMCI(-1);
|
|
else
|
|
SkipTrackMCI(0);
|
|
|
|
dwLastPageUpTime = dwCurTime;
|
|
goto BreakOut; // avoid SETPOS
|
|
}
|
|
|
|
break;
|
|
|
|
case TB_PAGEDOWN: /* page-right */
|
|
|
|
if (gwCurScale != ID_TRACKS) {
|
|
dwPosition += SCROLL_BIGGRAN;
|
|
} else {
|
|
/* Seek to the start of the next track */
|
|
SkipTrackMCI(1);
|
|
// Ensure next PageUp can't possibly do SkipTrackMCI(-1)
|
|
// which will skip back too far if you page
|
|
// left, right, left really quickly.
|
|
dwLastPageUpTime = 0;
|
|
goto BreakOut; // avoid SETPOS
|
|
}
|
|
|
|
break;
|
|
|
|
case TB_THUMBTRACK: /* track thumb movement */
|
|
//!!! we should do a "set seek exactly off"
|
|
/* Only seek while tracking for windowed devices that */
|
|
/* aren't currently playing */
|
|
if ((gwDeviceType & DTMCI_CANWINDOW) &&
|
|
!(gwStatus == MCI_MODE_PLAY)) {
|
|
SeekMCI(dwPosition);
|
|
}
|
|
|
|
break;
|
|
|
|
case TB_TOP:
|
|
dwPosition = gdwMediaStart;
|
|
break;
|
|
|
|
case TB_BOTTOM:
|
|
dwPosition = gdwMediaStart + gdwMediaLength;
|
|
break;
|
|
|
|
case TB_THUMBPOSITION: /* thumb has been positioned */
|
|
break;
|
|
|
|
case TB_ENDTRACK: /* user let go of scroll */
|
|
DPF2("TB_ENDTRACK\n");
|
|
|
|
gfScrollTrack = FALSE;
|
|
|
|
/* New as of 2/7/91: Only seek on ENDTRACK */
|
|
|
|
/*
|
|
* Calculate the new position in the medium
|
|
* corresponding to the scrollbar position, and seek
|
|
* to this new position.
|
|
*
|
|
*/
|
|
|
|
/* We really want to update our position */
|
|
if (hwndCtl) {
|
|
if (gdwSeekPosition) {
|
|
dwPosition = gdwSeekPosition;
|
|
gdwSeekPosition = 0;
|
|
}
|
|
|
|
/* Go back to the seek mode we were in before */
|
|
/* we started scrolling. */
|
|
SeekExactMCI(sfSeekExact);
|
|
SeekMCI(dwPosition);
|
|
}
|
|
|
|
PrevMark = MARK_NONE;
|
|
|
|
return;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
SendMessage(ghwndTrackbar, TBM_SETPOS, (WPARAM)TRUE, (LPARAM)dwPosition);
|
|
/* Clamp to a valid range */
|
|
dwPosition = SendMessage(ghwndTrackbar, TBM_GETPOS, 0, 0);
|
|
|
|
BreakOut:
|
|
|
|
if (GetKeyState(VK_SHIFT) < 0)
|
|
UpdateSelection(hwnd, dwPosition, &PrevMark);
|
|
|
|
if (ghwndStatic) {
|
|
FormatTime(dwPosition, NULL, ach, TRUE);
|
|
//VIJR-SBSetWindowText(ghwndStatic, ach);
|
|
WriteStatusMessage(ghwndStatic, ach);
|
|
}
|
|
|
|
// Dirty if you just move the thumb???
|
|
// if (!IsObjectDirty() && !gfCloseAfterPlaying) // don't want playing to dirty
|
|
// DirtyObject();
|
|
}
|
|
|
|
void MPlayer_OnSysCommand(HWND hwnd, UINT cmd, int x, int y)
|
|
{
|
|
RECT rc;
|
|
|
|
// The bottom four bits of wParam contain system information. They
|
|
// must be masked off in order to work out the actual command.
|
|
// See the comments section in the online help for WM_SYSCOMMAND.
|
|
|
|
switch (cmd & 0xFFF0) {
|
|
|
|
case SC_MINIMIZE:
|
|
DPF("minimized -- turn off timer\n");
|
|
ClrWS(hwnd, WS_MAXIMIZE);
|
|
EnableTimer(FALSE);
|
|
break;
|
|
|
|
case SC_MAXIMIZE:
|
|
if (gfPlayOnly && !IsIconic(hwnd)) {
|
|
(void)PostMessage(hwnd, WM_COMMAND, (WPARAM)IDM_ZOOM2, 0);
|
|
return;
|
|
}
|
|
|
|
break;
|
|
|
|
case SC_RESTORE:
|
|
if (gfPlayOnly && !IsIconic(hwnd)) {
|
|
GetWindowRect(hwnd, &rc);
|
|
if (rc.left > 0 || rc.top > 0)
|
|
(void)PostMessage(hwnd, WM_COMMAND, (WPARAM)IDM_ZOOM1, 0);
|
|
return;
|
|
}
|
|
|
|
if (gwDeviceID != (UINT)0) {
|
|
DPF("un-minimized -- turn timer back on\n");
|
|
EnableTimer(TRUE);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
FORWARD_WM_SYSCOMMAND(hwnd, cmd, x, y, DefWindowProc);
|
|
}
|
|
|
|
|
|
int MPlayer_OnMouseActivate(HWND hwnd, HWND hwndTopLevel, UINT codeHitTest, UINT msg)
|
|
{
|
|
if (gfPlayingInPlace && !gfOle2IPPlaying)
|
|
return MA_NOACTIVATE;
|
|
else
|
|
/* !!! Is this the right thing to do in this case? */
|
|
return FORWARD_WM_MOUSEACTIVATE(hwnd, hwndTopLevel, codeHitTest, msg,
|
|
DefWindowProc);
|
|
}
|
|
|
|
|
|
UINT MPlayer_OnNCHitTest(HWND hwnd, int x, int y)
|
|
{
|
|
UINT Pos;
|
|
|
|
Pos = FORWARD_WM_NCHITTEST(hwnd, x, y, DefWindowProc);
|
|
|
|
if (gfPlayingInPlace && (Pos == HTCLIENT))
|
|
Pos = HTNOWHERE;
|
|
|
|
return Pos;
|
|
}
|
|
|
|
|
|
void MPlayer_OnActivate(HWND hwnd, UINT state, HWND hwndActDeact, BOOL fMinimized)
|
|
{
|
|
HWND hwndT;
|
|
|
|
gfAppActive = (state != WA_INACTIVE);
|
|
|
|
// Put the playback window BEHIND us so it's kinda
|
|
// visible, but not on top of us (annoying).
|
|
if (gfAppActive && !ghwndMCI && !IsIconic(hwnd) &&
|
|
((hwndT = GetWindowMCI()) != NULL))
|
|
{
|
|
SetWindowPos(hwndT, hwnd, 0, 0, 0, 0,
|
|
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
}
|
|
|
|
if (gwDeviceID != (UINT)0)
|
|
EnableTimer(TRUE);
|
|
|
|
/* Remember who had focus if we're being de-activated. */
|
|
/* Give focus back to him once we're re-activated. */
|
|
/* Don't remember a window that doesn't belong to us, */
|
|
/* or when we give focus back to it, we'll never be */
|
|
/* able to activate! */
|
|
|
|
#if 0
|
|
/* Commenting this out for now. This code looks dubious.
|
|
* wParam (as was) contains state and fMinimized, so, if we're minimized,
|
|
* it will always be non-null.
|
|
*/
|
|
|
|
if (wParam && ghwndFocus) {
|
|
SetFocus(ghwndFocus);
|
|
} else if (!wParam) {
|
|
ghwndFocus = GetFocus();
|
|
}
|
|
#endif
|
|
|
|
FORWARD_WM_ACTIVATE(hwnd, state, hwndActDeact, fMinimized, DefWindowProc);
|
|
}
|
|
|
|
void MPlayer_OnSysColorChange(HWND hwnd)
|
|
{
|
|
ControlCleanup();
|
|
ControlInit(ghInst);
|
|
|
|
FORWARD_WM_SYSCOLORCHANGE(ghwndToolbar, SendMessage);
|
|
FORWARD_WM_SYSCOLORCHANGE(ghwndFSArrows, SendMessage);
|
|
FORWARD_WM_SYSCOLORCHANGE(ghwndMark, SendMessage);
|
|
FORWARD_WM_SYSCOLORCHANGE(ghwndTrackbar, SendMessage);
|
|
}
|
|
|
|
|
|
void MPlayer_OnDropFiles(HWND hwnd, HDROP hdrop)
|
|
{
|
|
doDrop(hwnd, hdrop);
|
|
}
|
|
|
|
|
|
LRESULT MPlayer_OnNotify(HWND hwnd, int idFrom, NMHDR FAR* pnmhdr)
|
|
{
|
|
LPTOOLTIPTEXT pTtt;
|
|
LPTBNOTIFY pTbn;
|
|
TCHAR ach[40];
|
|
|
|
switch(pnmhdr->code) {
|
|
|
|
case TTN_NEEDTEXT:
|
|
|
|
pTtt = (LPTOOLTIPTEXT)pnmhdr;
|
|
|
|
if (gfPlayOnly && (pTtt->hdr.idFrom != IDT_PLAY)
|
|
&& (pTtt->hdr.idFrom != IDT_PAUSE)
|
|
&& (pTtt->hdr.idFrom != IDT_STOP)
|
|
&& !gfOle2IPEditing)
|
|
break;
|
|
switch (pTtt->hdr.idFrom) {
|
|
case IDT_PLAY:
|
|
case IDT_PAUSE:
|
|
case IDT_STOP:
|
|
case IDT_EJECT:
|
|
case IDT_HOME:
|
|
case IDT_END:
|
|
case IDT_FWD:
|
|
case IDT_RWD:
|
|
case IDT_MARKIN:
|
|
case IDT_MARKOUT:
|
|
case IDT_ARROWPREV:
|
|
case IDT_ARROWNEXT:
|
|
LOADSTRING(pTtt->hdr.idFrom, ach);
|
|
lstrcpy(pTtt->szText, ach);
|
|
break;
|
|
default:
|
|
*pTtt->szText = TEXT('\0');
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case TBN_BEGINDRAG:
|
|
pTbn = (LPTBNOTIFY)pnmhdr;
|
|
if(pTbn->iItem == IDT_ARROWPREV || pTbn->iItem == IDT_ARROWNEXT)
|
|
SendMessage(ghwndFSArrows, WM_STARTTRACK, (WPARAM)pTbn->iItem, 0L);
|
|
else
|
|
SendMessage(ghwndToolbar, WM_STARTTRACK, (WPARAM)pTbn->iItem, 0L);
|
|
break;
|
|
|
|
case TBN_ENDDRAG:
|
|
pTbn = (LPTBNOTIFY)pnmhdr;
|
|
if(pTbn->iItem == IDT_ARROWPREV || pTbn->iItem == IDT_ARROWNEXT)
|
|
SendMessage(ghwndFSArrows, WM_ENDTRACK, (WPARAM)pTbn->iItem, 0L);
|
|
else
|
|
SendMessage(ghwndToolbar, WM_ENDTRACK, (WPARAM)pTbn->iItem, 0L);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
// * DeviceChange_Init
|
|
// First time initialization for WM_DEVICECHANGE messages
|
|
// This is specific to NT5
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL DeviceChange_Init(HWND hWnd)
|
|
{
|
|
DEV_BROADCAST_DEVICEINTERFACE dbi;
|
|
|
|
dbi.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
|
|
dbi.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
|
|
dbi.dbcc_reserved = 0;
|
|
dbi.dbcc_classguid = KSCATEGORY_AUDIO;
|
|
dbi.dbcc_name[0] = TEXT('\0');
|
|
|
|
MixerEventContext = RegisterDeviceNotification(hWnd,
|
|
(PVOID)&dbi,
|
|
DEVICE_NOTIFY_WINDOW_HANDLE);
|
|
if(!MixerEventContext)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
// * DeviceChange_Cleanup
|
|
// Unregister the device notification.
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
void DeviceChange_Cleanup()
|
|
{
|
|
if (MixerEventContext) {
|
|
UnregisterDeviceNotification(MixerEventContext);
|
|
MixerEventContext = NULL;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void DisplayNoMciDeviceError()
|
|
{
|
|
DWORD ErrorID;
|
|
|
|
if (!lstrcmpi(gachOpenExtension, aszKeyMID))
|
|
ErrorID = IDS_CANTPLAYMIDI;
|
|
|
|
else if (!lstrcmpi(gachOpenExtension, aszKeyAVI))
|
|
ErrorID = IDS_CANTPLAYVIDEO;
|
|
|
|
else if (!lstrcmpi(gachOpenExtension, aszKeyWAV))
|
|
ErrorID = IDS_CANTPLAYSOUND;
|
|
|
|
else
|
|
ErrorID = IDS_NOMCIDEVICES;
|
|
|
|
Error(ghwndApp, ErrorID);
|
|
}
|
|
|
|
|
|
/*
|
|
* MPlayerWndProc(hwnd, wMsg, wParam, lParam)
|
|
*
|
|
* This is the message processing routine for the MPLAYERBOX (main) dialog.
|
|
*
|
|
*/
|
|
//Harmless message-cracker because the user guys will not fix their
|
|
//windowsx.h macro which cause the irritating rip.
|
|
//This is also a wee bit faster because the message
|
|
//is forwarded only on select and not on deselects. Also we do not care
|
|
//about the params
|
|
#define HANDLE_MPLAYER_WM_MENUSELECT(hwnd, message, fn) \
|
|
case (message): if(lParam) ((fn)((hwnd), (HMENU)(lParam), (UINT)LOWORD(wParam), 0L, 0L )); break;
|
|
|
|
LRESULT FAR PASCAL MPlayerWndProc(HWND hwnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (wMsg) {
|
|
|
|
HANDLE_MSG(hwnd, WM_CREATE, MPlayer_OnCreate);
|
|
HANDLE_MSG(hwnd, WM_SHOWWINDOW, MPlayer_OnShowWindow);
|
|
HANDLE_MSG(hwnd, WM_SIZE, MPlayer_OnSize);
|
|
HANDLE_MSG(hwnd, WM_WINDOWPOSCHANGING, MPlayer_OnWindowPosChanging);
|
|
HANDLE_MSG(hwnd, WM_WINDOWPOSCHANGED, MPlayer_OnWindowPosChanged);
|
|
HANDLE_MSG(hwnd, WM_PALETTECHANGED, MPlayer_OnPaletteChanged);
|
|
HANDLE_MSG(hwnd, WM_QUERYNEWPALETTE, MPlayer_OnQueryNewPalette);
|
|
HANDLE_MSG(hwnd, WM_CTLCOLORSTATIC, MPlayer_OnCtlColor);
|
|
HANDLE_MSG(hwnd, WM_WININICHANGE, MPlayer_OnWinIniChange);
|
|
HANDLE_MPLAYER_WM_MENUSELECT(hwnd, WM_MENUSELECT, MPlayer_OnMenuSelect);
|
|
HANDLE_MSG(hwnd, WM_NCLBUTTONDOWN, MPlayer_OnNCLButtonDown);
|
|
HANDLE_MSG(hwnd, WM_NCLBUTTONDBLCLK, MPlayer_OnNCLButtonDblClk);
|
|
HANDLE_MSG(hwnd, WM_INITMENU, MPlayer_OnInitMenu);
|
|
HANDLE_MSG(hwnd, WM_INITMENUPOPUP, MPlayer_OnInitMenuPopup);
|
|
HANDLE_MSG(hwnd, WM_GETMINMAXINFO, MPlayer_OnGetMinMaxInfo);
|
|
HANDLE_MSG(hwnd, WM_PAINT, MPlayer_OnPaint);
|
|
HANDLE_MSG(hwnd, WM_COMMAND, MPlayer_OnCommand);
|
|
HANDLE_MSG(hwnd, WM_CLOSE, MPlayer_OnClose);
|
|
HANDLE_MSG(hwnd, WM_ENDSESSION, MPlayer_OnEndSession);
|
|
HANDLE_MSG(hwnd, WM_DESTROY, MPlayer_OnDestroy);
|
|
HANDLE_MSG(hwnd, WM_TIMER, MPlayer_OnTimer);
|
|
HANDLE_MSG(hwnd, WM_HSCROLL, MPlayer_OnHScroll);
|
|
HANDLE_MSG(hwnd, WM_SYSCOMMAND, MPlayer_OnSysCommand);
|
|
HANDLE_MSG(hwnd, WM_MOUSEACTIVATE, MPlayer_OnMouseActivate);
|
|
HANDLE_MSG(hwnd, WM_NCHITTEST, MPlayer_OnNCHitTest);
|
|
HANDLE_MSG(hwnd, WM_ACTIVATE, MPlayer_OnActivate);
|
|
HANDLE_MSG(hwnd, WM_SYSCOLORCHANGE, MPlayer_OnSysColorChange);
|
|
HANDLE_MSG(hwnd, WM_DROPFILES, MPlayer_OnDropFiles);
|
|
HANDLE_MSG(hwnd, WM_NOTIFY, MPlayer_OnNotify);
|
|
|
|
/* Other bits of stuff that need tidying up sometime:
|
|
*/
|
|
|
|
case WM_NOMCIDEVICES:
|
|
/* This was posted by the thread building the Device
|
|
* menu to tell us it couldn't find any MCI devices.
|
|
*/
|
|
DisplayNoMciDeviceError();
|
|
PostMessage(ghwndApp, WM_CLOSE, 0, 0);
|
|
break;
|
|
|
|
case WM_GETDIB:
|
|
return (LRESULT)GetDib();
|
|
|
|
case WM_DEVICECHANGE :
|
|
{
|
|
//if plug-and-play sends this, pass it along to the component
|
|
PDEV_BROADCAST_DEVICEINTERFACE bid = (PDEV_BROADCAST_DEVICEINTERFACE)lParam;
|
|
|
|
//Check to see if this is a audio message
|
|
if (!MixerEventContext || !bid ||
|
|
bid->dbcc_devicetype != DBT_DEVTYP_DEVICEINTERFACE ||
|
|
!IsEqualGUID(&KSCATEGORY_AUDIO, &bid->dbcc_classguid) ||
|
|
!(*bid->dbcc_name))
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
switch(wParam)
|
|
{
|
|
case DBT_DEVICEQUERYREMOVE:
|
|
CloseMCI(TRUE); //Close the MCI device
|
|
break;
|
|
|
|
case DBT_DEVICEREMOVECOMPLETE:
|
|
CloseMCI(TRUE); //Close the MCI device
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
case WM_ENTERSIZEMOVE:
|
|
if (!IsIconic(hwnd) && !gfPlayOnly && !gfOle2IPEditing && !gfOle2IPPlaying)
|
|
{
|
|
/* Save the current window position in x, y, dx, dy format:
|
|
*/
|
|
GetWindowRect(hwnd, (PRECT)&posSizeMove);
|
|
posSizeMove.cx -= posSizeMove.x;
|
|
posSizeMove.cy -= posSizeMove.y;
|
|
}
|
|
break;
|
|
|
|
case WM_EXITSIZEMOVE:
|
|
SetRectEmpty((PRECT)&posSizeMove);
|
|
break;
|
|
|
|
case WM_DOLAYOUT:
|
|
Layout();
|
|
break;
|
|
|
|
case WM_BADREG:
|
|
if ( IDYES == ErrorResBox(hwnd, NULL,
|
|
MB_YESNO | MB_ICONEXCLAMATION, IDS_APPNAME, IDS_BADREG) )
|
|
if (!SetRegValues())
|
|
Error(ghwndApp, IDS_FIXREGERROR);
|
|
break;
|
|
|
|
case WM_SEND_OLE_CHANGE:
|
|
fDocChanged = TRUE;
|
|
SendDocMsg((LPDOC)&docMain,OLE_CHANGED);
|
|
break;
|
|
|
|
case MM_MCINOTIFY:
|
|
#if 0
|
|
//
|
|
// don't do this because, some devices send notify failures
|
|
// where there really is not a error.
|
|
//
|
|
if ((WORD)wParam == MCI_NOTIFY_FAILURE) {
|
|
Error(ghwndApp, IDS_NOTIFYFAILURE);
|
|
}
|
|
#endif
|
|
UpdateDisplay();
|
|
break;
|
|
|
|
#ifdef OLE1_HACK
|
|
/* Actually do the FixLink, SetData and DoVerb we've been putting off */
|
|
/* for so long. */
|
|
case WM_DO_VERB:
|
|
/* This message comes from server.c (and goes back there too) */
|
|
DelayedFixLink(wParam, LOWORD(lParam), HIWORD(lParam)); //OK on NT. LKG
|
|
break;
|
|
#endif /* OLE1_HACK */
|
|
|
|
#ifdef LATER
|
|
// We'll need to call RegisterWindowMessage and provide a message hook proc
|
|
// for this on Win32.
|
|
|
|
case WM_HELP:
|
|
WinHelp(hwnd, TEXT("MPLAYER.HLP"), HELP_PARTIALKEY,
|
|
(DWORD)aszNULL);
|
|
return TRUE;
|
|
#endif /* LATER */
|
|
|
|
case WM_USER_DESTROY:
|
|
DPF("WM_USER_DESTROY received\n");
|
|
|
|
if (gfPlayingInPlace) {
|
|
DPF("****\n");
|
|
DPF("**** Window destroyed while in place!\n");
|
|
DPF("****\n");
|
|
EndPlayInPlace(hwnd);
|
|
}
|
|
|
|
if (gfOle2IPEditing) {
|
|
EndEditInPlace(hwnd);
|
|
}
|
|
|
|
if (!ItsSafeToClose()) {
|
|
DPF("*** \n");
|
|
DPF("*** Trying to destroy MPLAYER with an ErrorBox up\n");
|
|
DPF("*** \n");
|
|
gfErrorDeath = WM_USER_DESTROY;
|
|
return TRUE;
|
|
}
|
|
|
|
if (!gfRunWithEmbeddingFlag)
|
|
WriteOutPosition();
|
|
|
|
DestroyWindow(hwnd);
|
|
DestroyIcon(hiconApp);
|
|
return TRUE;
|
|
|
|
case WM_USER+500:
|
|
/*
|
|
** This message is sent by the HookProc inside mciole32.dll when
|
|
** it detects that it should stop playing in place of a WOW client
|
|
** application.
|
|
**
|
|
** Because the OleActivate originated in mciole16.dll,
|
|
** mciole32.dll does not know the OLE Object that is being
|
|
** played and therefore dose not know how to close that object.
|
|
** Only mplay32.exe has the necessary information, hence
|
|
** mciole32.dll sends this message to mplay32.exe.
|
|
*/
|
|
if (gfPlayingInPlace) {
|
|
EndPlayInPlace(hwnd);
|
|
}
|
|
PostMessage( hwnd, WM_CLOSE, 0L, 0L );
|
|
break;
|
|
}
|
|
|
|
return DefWindowProc(hwnd, wMsg, wParam, lParam);
|
|
}
|
|
|
|
|
|
|
|
/* InitInstance
|
|
* ------------
|
|
*
|
|
* Create brushes used by the program, the main window, and
|
|
* do any other per-instance initialization.
|
|
*
|
|
* HANDLE hInstance
|
|
*
|
|
* RETURNS: TRUE if successful
|
|
* FALSE otherwise.
|
|
*
|
|
* CUSTOMIZATION: Re-implement
|
|
*
|
|
*/
|
|
BOOL InitInstance (HANDLE hInstance)
|
|
{
|
|
HDC hDC;
|
|
|
|
static SZCODE aszNative[] = TEXT("Native");
|
|
static SZCODE aszEmbedSrc[] = TEXT("Embed Source");
|
|
static SZCODE aszObjDesc[] = TEXT("Object Descriptor");
|
|
static SZCODE aszMplayer[] = TEXT("mplayer");
|
|
static SZCODE aszClientDoc[] = TEXT("Client Document");
|
|
|
|
/* Why doesn't RegisterClipboardFormat return a value of type CLIPFORMAT (WORD)
|
|
* instead of UINT?
|
|
*/
|
|
cfNative = (CLIPFORMAT)RegisterClipboardFormat (aszNative);
|
|
cfEmbedSource = (CLIPFORMAT)RegisterClipboardFormat (aszEmbedSrc);
|
|
cfObjectDescriptor = (CLIPFORMAT)RegisterClipboardFormat (aszObjDesc);
|
|
cfMPlayer = (CLIPFORMAT)RegisterClipboardFormat (aszMplayer);
|
|
|
|
szClient[0] = TEXT('\0');
|
|
|
|
lstrcpy (szClientDoc, aszClientDoc);
|
|
|
|
// Initialize global variables with LOGPIXELSX and LOGPIXELSY
|
|
|
|
hDC = GetDC (NULL); // Get the hDC of the desktop window
|
|
giXppli = GetDeviceCaps (hDC, LOGPIXELSX);
|
|
giYppli = GetDeviceCaps (hDC, LOGPIXELSY);
|
|
ReleaseDC (NULL, hDC);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
#define COINIT_APARTMENTTHREADED 2
|
|
|
|
/* InitOLE
|
|
*
|
|
* This should be called only when we're certain that OLE is needed,
|
|
* to avoid loading loads of unnecessary stuff.
|
|
*
|
|
*/
|
|
BOOL InitOLE (PBOOL pfInit, LPMALLOC *ppMalloc)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (*pfInit)
|
|
return TRUE;
|
|
|
|
hr = (HRESULT)OleInitialize(NULL);
|
|
|
|
if (!SUCCEEDED (hr))
|
|
{
|
|
DPF0("OleInitialize failed with error 0x%08x\n", hr);
|
|
Error(NULL, IDS_OLEINIT);
|
|
return FALSE;
|
|
}
|
|
|
|
if (ppMalloc && (CoGetMalloc(MEMCTX_TASK, ppMalloc) != S_OK))
|
|
{
|
|
Error(NULL, IDS_OLENOMEM);
|
|
OleUninitialize();
|
|
return FALSE;
|
|
}
|
|
/*****************************************************************
|
|
** OLE2NOTE: we must remember the fact that OleInitialize has
|
|
** been called successfully. the very last thing an app must
|
|
** do is properly shut down OLE by calling
|
|
** OleUninitialize. This call MUST be guarded! it is only
|
|
** allowable to call OleUninitialize if OleInitialize has
|
|
** been called SUCCESSFULLY.
|
|
*****************************************************************/
|
|
|
|
*pfInit = TRUE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// This function cleans up all the OLE2 stuff. It lets the container
|
|
// save the object and informs that it is closing.
|
|
BOOL ExitApplication ()
|
|
{
|
|
|
|
DPFI("\n*******Exitapp\n");
|
|
// if we registered class factory, we must revoke it
|
|
if(gfOle2IPEditing || gfOle2IPPlaying)
|
|
DoInPlaceDeactivate((LPDOC)&docMain);
|
|
|
|
SendDocMsg((LPDOC)&docMain,OLE_CLOSED);
|
|
if (srvrMain.fEmbedding) {
|
|
HRESULT status;
|
|
srvrMain.fEmbedding = FALSE; // HACK--guard against revoking twice
|
|
status = (HRESULT)CoRevokeClassObject (srvrMain.dwRegCF);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
/* DbgGlobalLock
|
|
*
|
|
* Debug wrapper for GlobalLock
|
|
*
|
|
* Checks that the memory handle to be locked isn't already locked,
|
|
* and checks the return code from GlobalLock.
|
|
*
|
|
* andrewbe, 1 March 1995
|
|
*/
|
|
LPVOID DbgGlobalLock(HGLOBAL hglbMem)
|
|
{
|
|
LPVOID lpReturn;
|
|
|
|
if (GlobalFlags(hglbMem) & GMEM_LOCKCOUNT)
|
|
DPF0("Calling GlobalLock on already locked memory object %08x\n", hglbMem);
|
|
|
|
lpReturn = GlobalLock(hglbMem);
|
|
|
|
if (lpReturn == NULL)
|
|
DPF0("GlobalLock(%08x) failed: Error %d\n", hglbMem, GetLastError());
|
|
|
|
return lpReturn;
|
|
}
|
|
|
|
|
|
/* DbgGlobalUnlock
|
|
*
|
|
* Debug wrapper for GlobalUnlock
|
|
*
|
|
* Checks the return code from GlobalUnlock, and outputs appropriate
|
|
* error messages
|
|
*
|
|
* andrewbe, 1 March 1995
|
|
*/
|
|
BOOL DbgGlobalUnlock(HGLOBAL hglbMem)
|
|
{
|
|
BOOL boolReturn;
|
|
|
|
boolReturn = GlobalUnlock(hglbMem);
|
|
|
|
if ((boolReturn) && (GlobalFlags(hglbMem) & GMEM_LOCKCOUNT))
|
|
{
|
|
DPF0("Locks still outstanding on memory object %08x\n", hglbMem);
|
|
}
|
|
else
|
|
{
|
|
DWORD Error = GetLastError();
|
|
|
|
if (Error == ERROR_NOT_LOCKED)
|
|
{
|
|
DPF0("Attempt to unlock already unlocked memory object %08x\n", hglbMem);
|
|
}
|
|
else if (Error != NO_ERROR)
|
|
{
|
|
DPF0("Error %d attempting to unlock memory object %08x\n", Error, hglbMem);
|
|
}
|
|
}
|
|
|
|
return boolReturn;
|
|
}
|
|
|
|
|
|
/* DbgGlobalFree
|
|
*
|
|
* Debug wrapper for GlobalFree.
|
|
*
|
|
* Checks that the global handle has no locks before freeing,
|
|
* then checks that the call succeeded. Error messages output
|
|
* as appropriate.
|
|
*
|
|
* andrewbe, 1 March 1995
|
|
*
|
|
*/
|
|
HGLOBAL DbgGlobalFree(HGLOBAL hglbMem)
|
|
{
|
|
HGLOBAL hglbReturn;
|
|
|
|
if (GlobalFlags(hglbMem) & GMEM_LOCKCOUNT)
|
|
DPF0("Freeing global memory object %08x still locked\n", hglbMem);
|
|
|
|
hglbReturn = GlobalFree(hglbMem);
|
|
|
|
if (hglbReturn != NULL)
|
|
DPF0("GlobalFree(%08x) failed: Error %d\n", hglbMem, GetLastError());
|
|
|
|
return hglbReturn;
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
/* Note: This function assumes that szFormat strings are NOT unicode.
|
|
* Unicode var params may, however, be passed, as long as %ws is specified
|
|
* in the format string.
|
|
*/
|
|
#endif
|
|
void FAR cdecl dprintf(LPSTR szFormat, ...)
|
|
{
|
|
CHAR ach[_MAX_PATH * 3]; // longest I think we need
|
|
int s,d;
|
|
va_list va;
|
|
|
|
va_start(va, szFormat);
|
|
s = wvsprintfA(ach,szFormat, va);
|
|
va_end(va);
|
|
|
|
#if 0
|
|
strcat(ach,"\n");
|
|
s++;
|
|
#endif
|
|
for (d=sizeof(ach)-1; s>=0; s--)
|
|
{
|
|
if ((ach[d--] = ach[s]) == TEXT('\n'))
|
|
ach[d--] = TEXT('\r');
|
|
}
|
|
|
|
/* Not unicode */
|
|
if (*(ach+d+1) != ' ')
|
|
OutputDebugStringA("MPLAYER: ");
|
|
OutputDebugStringA(ach+d+1);
|
|
}
|
|
|
|
#endif
|