349 lines
9.8 KiB
C
349 lines
9.8 KiB
C
/*
|
|
* Copyright 2000 Eric Pouech
|
|
*
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#define COM_NO_WINDOWS_H
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "winbase.h"
|
|
#include "windef.h"
|
|
#include "winnls.h"
|
|
#include "wingdi.h"
|
|
#include "winuser.h"
|
|
#include "vfw.h"
|
|
#include "digitalv.h"
|
|
#include "commctrl.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(mci);
|
|
|
|
typedef struct {
|
|
DWORD dwStyle;
|
|
MCIDEVICEID mci;
|
|
LPSTR lpName;
|
|
HWND hWnd;
|
|
UINT uTimer;
|
|
} MCIWndInfo;
|
|
|
|
static LRESULT WINAPI MCIWndProc(HWND hWnd, UINT wMsg, WPARAM lParam1, LPARAM lParam2);
|
|
|
|
#define CTL_PLAYSTOP 0x3200
|
|
#define CTL_MENU 0x3201
|
|
#define CTL_TRACKBAR 0x3202
|
|
|
|
/***********************************************************************
|
|
* MCIWndRegisterClass [MSVFW32.@]
|
|
*/
|
|
BOOL WINAPI MCIWndRegisterClass(HINSTANCE hInst)
|
|
{
|
|
WNDCLASSA wc;
|
|
|
|
/* since window creation will also require some common controls, init them */
|
|
InitCommonControls();
|
|
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = MCIWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = sizeof(MCIWndInfo*);
|
|
wc.hInstance = hInst;
|
|
wc.hIcon = 0;
|
|
wc.hCursor = 0;
|
|
wc.hbrBackground = 0;
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = "MCIWndClass";
|
|
|
|
return RegisterClassA(&wc);
|
|
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MCIWndCreate [MSVFW32.@]
|
|
* MCIWndCreateA [MSVFW32.@]
|
|
*/
|
|
HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
|
|
DWORD dwStyle, LPCSTR szFile)
|
|
{
|
|
DWORD wndStyle;
|
|
MCIWndInfo* mwi;
|
|
|
|
TRACE("%p %p %lx %s\n", hwndParent, hInstance, dwStyle, szFile);
|
|
|
|
MCIWndRegisterClass(hInstance);
|
|
|
|
mwi = HeapAlloc(GetProcessHeap(), 0, sizeof(*mwi));
|
|
if (!mwi) return 0;
|
|
|
|
mwi->dwStyle = dwStyle;
|
|
if (szFile)
|
|
mwi->lpName = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(szFile) + 1), szFile);
|
|
else
|
|
mwi->lpName = NULL;
|
|
mwi->uTimer = 0;
|
|
|
|
wndStyle = ((hwndParent) ? (WS_CHILD|WS_BORDER) : WS_OVERLAPPEDWINDOW) |
|
|
WS_VISIBLE | (dwStyle & 0xFFFF0000);
|
|
|
|
if (CreateWindowExA(0, "MCIWndClass", NULL, wndStyle,
|
|
CW_USEDEFAULT, CW_USEDEFAULT,
|
|
CW_USEDEFAULT, CW_USEDEFAULT,
|
|
hwndParent, NULL, hInstance, mwi))
|
|
return mwi->hWnd;
|
|
|
|
if(mwi->lpName) HeapFree(GetProcessHeap(), 0, mwi->lpName);
|
|
HeapFree(GetProcessHeap(), 0, mwi);
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MCIWndCreateW [MSVFW32.@]
|
|
*/
|
|
HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
|
|
DWORD dwStyle, LPCWSTR szFile)
|
|
{
|
|
FIXME("%p %p %lx %s\n", hwndParent, hInstance, dwStyle, debugstr_w(szFile));
|
|
|
|
MCIWndRegisterClass(hInstance);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static DWORD MCIWND_GetStatus(MCIWndInfo* mwi)
|
|
{
|
|
MCI_DGV_STATUS_PARMSA mdsp;
|
|
|
|
memset(&mdsp, 0, sizeof(mdsp));
|
|
mdsp.dwItem = MCI_STATUS_MODE;
|
|
if (mciSendCommandA(mwi->mci, MCI_STATUS, MCI_WAIT|MCI_STATUS_ITEM, (DWORD)&mdsp))
|
|
return MCI_MODE_NOT_READY;
|
|
if (mdsp.dwReturn == MCI_MODE_STOP && mwi->uTimer) {
|
|
TRACE("Killing timer\n");
|
|
KillTimer(mwi->hWnd, 0);
|
|
mwi->uTimer = 0;
|
|
}
|
|
return mdsp.dwReturn;
|
|
}
|
|
|
|
static DWORD MCIWND_Get(MCIWndInfo* mwi, DWORD what)
|
|
{
|
|
MCI_DGV_STATUS_PARMSA mdsp;
|
|
|
|
memset(&mdsp, 0, sizeof(mdsp));
|
|
mdsp.dwItem = what;
|
|
if (mciSendCommandA(mwi->mci, MCI_STATUS, MCI_WAIT|MCI_STATUS_ITEM, (DWORD)&mdsp))
|
|
return 0;
|
|
return mdsp.dwReturn;
|
|
}
|
|
|
|
static void MCIWND_SetText(MCIWndInfo* mwi)
|
|
{
|
|
char buffer[1024];
|
|
|
|
if (mwi->dwStyle & MCIWNDF_SHOWNAME) {
|
|
strcpy(buffer, mwi->lpName);
|
|
} else {
|
|
*buffer = 0;
|
|
}
|
|
|
|
if (mwi->dwStyle & (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE)) {
|
|
if (*buffer) strcat(buffer, " ");
|
|
strcat(buffer, "(");
|
|
}
|
|
|
|
if (mwi->dwStyle & MCIWNDF_SHOWPOS) {
|
|
sprintf(buffer + strlen(buffer), "%ld", MCIWND_Get(mwi, MCI_STATUS_POSITION));
|
|
}
|
|
|
|
if ((mwi->dwStyle & (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE)) == (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE)) {
|
|
strcat(buffer, " - ");
|
|
}
|
|
|
|
if (mwi->dwStyle & MCIWNDF_SHOWMODE) {
|
|
switch (MCIWND_GetStatus(mwi)) {
|
|
case MCI_MODE_NOT_READY: strcat(buffer, "not ready"); break;
|
|
case MCI_MODE_PAUSE: strcat(buffer, "paused"); break;
|
|
case MCI_MODE_PLAY: strcat(buffer, "playing"); break;
|
|
case MCI_MODE_STOP: strcat(buffer, "stopped"); break;
|
|
case MCI_MODE_OPEN: strcat(buffer, "open"); break;
|
|
case MCI_MODE_RECORD: strcat(buffer, "recording"); break;
|
|
case MCI_MODE_SEEK: strcat(buffer, "seeking"); break;
|
|
default: strcat(buffer, "???"); break;
|
|
}
|
|
}
|
|
if (mwi->dwStyle & (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE)) {
|
|
strcat(buffer, " )");
|
|
}
|
|
TRACE("=> '%s'\n", buffer);
|
|
SetWindowTextA(mwi->hWnd, buffer);
|
|
}
|
|
|
|
static void MCIWND_Create(HWND hWnd, LPCREATESTRUCTA cs)
|
|
{
|
|
MCI_DGV_OPEN_PARMSA mdopn;
|
|
MCI_DGV_RECT_PARMS mdrct;
|
|
MMRESULT mmr;
|
|
int cx, cy;
|
|
HWND hChld;
|
|
MCIWndInfo* mwi = (MCIWndInfo*)cs->lpCreateParams;
|
|
|
|
SetWindowLongA(hWnd, 0, (LPARAM)mwi);
|
|
mwi->hWnd = hWnd;
|
|
|
|
/* now open MCI player for AVI file */
|
|
memset(&mdopn, 0, sizeof(mdopn));
|
|
mdopn.lpstrElementName = mwi->lpName;
|
|
mdopn.dwStyle = WS_VISIBLE|WS_CHILD;
|
|
mdopn.hWndParent = hWnd;
|
|
|
|
mmr = mciSendCommandA(0, MCI_OPEN, MCI_OPEN_ELEMENT|MCI_DGV_OPEN_PARENT|MCI_DGV_OPEN_WS, (LPARAM)&mdopn);
|
|
if (mmr) {
|
|
MessageBoxA(GetTopWindow(hWnd), "Cannot open file", "MciWnd", MB_OK);
|
|
return;
|
|
}
|
|
mwi->mci = mdopn.wDeviceID;
|
|
|
|
/* grab AVI window size */
|
|
memset(&mdrct, 0, sizeof(mdrct));
|
|
mmr = mciSendCommandA(mwi->mci, MCI_WHERE, MCI_DGV_WHERE_DESTINATION, (LPARAM)&mdrct);
|
|
if (mmr) {
|
|
WARN("Cannot get window rect\n");
|
|
return;
|
|
}
|
|
cx = mdrct.rc.right - mdrct.rc.left;
|
|
cy = mdrct.rc.bottom - mdrct.rc.top;
|
|
|
|
AdjustWindowRect(&mdrct.rc, GetWindowLongA(hWnd, GWL_STYLE), FALSE);
|
|
SetWindowPos(hWnd, 0, 0, 0, mdrct.rc.right - mdrct.rc.left,
|
|
mdrct.rc.bottom - mdrct.rc.top + 32, SWP_NOMOVE|SWP_NOZORDER);
|
|
|
|
/* adding the other elements: play/stop button, menu button, status */
|
|
hChld = CreateWindowExA(0, "BUTTON", "Play", WS_CHILD|WS_VISIBLE, 0, cy, 32, 32,
|
|
hWnd, (HMENU)CTL_PLAYSTOP,
|
|
(HINSTANCE)GetWindowLongA(hWnd, GWL_HINSTANCE), 0L);
|
|
TRACE("Get Button1: %p\n", hChld);
|
|
hChld = CreateWindowExA(0, "BUTTON", "Menu", WS_CHILD|WS_VISIBLE, 32, cy, 32, 32,
|
|
hWnd, (HMENU)CTL_MENU,
|
|
(HINSTANCE)GetWindowLongA(hWnd, GWL_HINSTANCE), 0L);
|
|
TRACE("Get Button2: %p\n", hChld);
|
|
hChld = CreateWindowExA(0, TRACKBAR_CLASSA, "", WS_CHILD|WS_VISIBLE, 64, cy, cx - 64, 32,
|
|
hWnd, (HMENU)CTL_TRACKBAR,
|
|
(HINSTANCE)GetWindowLongA(hWnd, GWL_HINSTANCE), 0L);
|
|
TRACE("Get status: %p\n", hChld);
|
|
SendMessageA(hChld, TBM_SETRANGEMIN, 0L, 0L);
|
|
SendMessageA(hChld, TBM_SETRANGEMAX, 1L, MCIWND_Get(mwi, MCI_STATUS_LENGTH));
|
|
|
|
/* FIXME: no need to set it if child window */
|
|
MCIWND_SetText(mwi);
|
|
}
|
|
|
|
static void MCIWND_Paint(MCIWndInfo* mwi, WPARAM wParam)
|
|
{
|
|
HDC hdc;
|
|
PAINTSTRUCT ps;
|
|
|
|
hdc = (wParam) ? (HDC)wParam : BeginPaint(mwi->hWnd, &ps);
|
|
/* something to do ? */
|
|
if (!wParam) EndPaint(mwi->hWnd, &ps);
|
|
}
|
|
|
|
static void MCIWND_ToggleState(MCIWndInfo* mwi)
|
|
{
|
|
MCI_GENERIC_PARMS mgp;
|
|
MCI_DGV_PLAY_PARMS mdply;
|
|
|
|
memset(&mgp, 0, sizeof(mgp));
|
|
memset(&mdply, 0, sizeof(mdply));
|
|
|
|
switch (MCIWND_GetStatus(mwi)) {
|
|
case MCI_MODE_NOT_READY:
|
|
case MCI_MODE_RECORD:
|
|
case MCI_MODE_SEEK:
|
|
case MCI_MODE_OPEN:
|
|
TRACE("Cannot do much...\n");
|
|
break;
|
|
case MCI_MODE_PAUSE:
|
|
mciSendCommandA(mwi->mci, MCI_RESUME, MCI_WAIT, (LPARAM)&mgp);
|
|
break;
|
|
case MCI_MODE_PLAY:
|
|
mciSendCommandA(mwi->mci, MCI_PAUSE, MCI_WAIT, (LPARAM)&mgp);
|
|
break;
|
|
case MCI_MODE_STOP:
|
|
mdply.dwFrom = 0L;
|
|
mciSendCommandA(mwi->mci, MCI_PLAY, MCI_FROM, (LPARAM)&mdply);
|
|
mwi->uTimer = SetTimer(mwi->hWnd, 0, 333, 0L);
|
|
TRACE("Timer=%u\n", mwi->uTimer);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static LRESULT MCIWND_Command(MCIWndInfo* mwi, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (LOWORD(wParam)) {
|
|
case CTL_PLAYSTOP: MCIWND_ToggleState(mwi); break;
|
|
case CTL_MENU:
|
|
case CTL_TRACKBAR:
|
|
default:
|
|
MessageBoxA(0, "ooch", "NIY", MB_OK);
|
|
}
|
|
return 0L;
|
|
}
|
|
|
|
static void MCIWND_Timer(MCIWndInfo* mwi, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
TRACE("%ld\n", MCIWND_Get(mwi, MCI_STATUS_POSITION));
|
|
SendDlgItemMessageA(mwi->hWnd, CTL_TRACKBAR, TBM_SETPOS, 1, MCIWND_Get(mwi, MCI_STATUS_POSITION));
|
|
MCIWND_SetText(mwi);
|
|
}
|
|
|
|
static void MCIWND_Close(MCIWndInfo* mwi)
|
|
{
|
|
MCI_GENERIC_PARMS mgp;
|
|
|
|
memset(&mgp, 0, sizeof(mgp));
|
|
|
|
mciSendCommandA(mwi->mci, MCI_CLOSE, 0, (LPARAM)&mgp);
|
|
}
|
|
|
|
static LRESULT WINAPI MCIWndProc(HWND hWnd, UINT wMsg, WPARAM lParam1, LPARAM lParam2)
|
|
{
|
|
MCIWndInfo* mwi = (MCIWndInfo*)GetWindowLongA(hWnd, 0);
|
|
|
|
if (mwi || wMsg == WM_CREATE) {
|
|
switch (wMsg) {
|
|
case WM_CREATE:
|
|
MCIWND_Create(hWnd, (CREATESTRUCTA*)lParam2);
|
|
return 0;
|
|
case WM_DESTROY:
|
|
MCIWND_Close(mwi);
|
|
HeapFree(GetProcessHeap(), 0, mwi->lpName);
|
|
HeapFree(GetProcessHeap(), 0, mwi);
|
|
break;
|
|
case WM_PAINT:
|
|
MCIWND_Paint(mwi, lParam1);
|
|
break;
|
|
case WM_COMMAND:
|
|
return MCIWND_Command(mwi, lParam1, lParam2);
|
|
case WM_TIMER:
|
|
MCIWND_Timer(mwi, lParam1, lParam2);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return DefWindowProcA(hWnd, wMsg, lParam1, lParam2);
|
|
}
|