dlls/msvideo/mciwnd.c

   1 /*
   2  * Copyright 2000 Eric Pouech
   3  *
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #define COM_NO_WINDOWS_H
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winnls.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "vfw.h"
  31 #include "digitalv.h"
  32 #include "commctrl.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(mci);
  36
  37 typedef struct {
  38    DWORD        dwStyle;
  39    MCIDEVICEID  mci;
  40    LPSTR        lpName;
  41    HWND         hWnd;
  42    UINT         uTimer;
  43 } MCIWndInfo;
  44
  45 static LRESULT WINAPI   MCIWndProc(HWND hWnd, UINT wMsg, WPARAM lParam1, LPARAM lParam2);
  46
  47 #define CTL_PLAYSTOP    0x3200
  48 #define CTL_MENU        0x3201
  49 #define CTL_TRACKBAR    0x3202
  50
  51 /***********************************************************************
  52  *              MCIWndRegisterClass             [MSVFW32.@]
  53  */
  54 BOOL WINAPI MCIWndRegisterClass(HINSTANCE hInst)
  55 {
  56    WNDCLASSA            wc;
  57
  58    wc.style = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS | CS_OWNDC;
  59    wc.lpfnWndProc = MCIWndProc;
  60    wc.cbClsExtra = 0;
  61    wc.cbWndExtra = sizeof(MCIWndInfo*);
  62    wc.hInstance = hInst;
  63    wc.hIcon = 0;
  64    wc.hCursor = LoadCursorW(0, MAKEINTRESOURCEW(IDC_ARROW));
  65    wc.hbrBackground = 0;
  66    wc.lpszMenuName = NULL;
  67    wc.lpszClassName = "MCIWndClass";
  68
  69    return RegisterClassA(&wc);
  70 }
  71
  72 /***********************************************************************
  73  *              MCIWndCreate            [MSVFW32.@]
  74  *              MCIWndCreateA           [MSVFW32.@]
  75  */
  76 HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
  77                            DWORD dwStyle, LPCSTR szFile)
  78 {
  79    DWORD        wndStyle;
  80    MCIWndInfo*  mwi;
  81
  82    TRACE("%p %p %lx %s\n", hwndParent, hInstance, dwStyle, szFile);
  83
  84    MCIWndRegisterClass(hInstance);
  85
  86    mwi = HeapAlloc(GetProcessHeap(), 0, sizeof(*mwi));
  87    if (!mwi) return 0;
  88
  89    mwi->dwStyle = dwStyle;
  90    if (szFile)
  91      mwi->lpName = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(szFile) + 1), szFile);
  92    else
  93      mwi->lpName = NULL;
  94    mwi->uTimer = 0;
  95
  96    wndStyle = ((hwndParent) ? (WS_CHILD|WS_BORDER) : WS_OVERLAPPEDWINDOW) |
  97               WS_VISIBLE | (dwStyle & 0xFFFF0000);
  98
  99    if (CreateWindowExA(0, "MCIWndClass", NULL, wndStyle,
 100                        CW_USEDEFAULT, CW_USEDEFAULT,
 101                        CW_USEDEFAULT, CW_USEDEFAULT,
 102                        hwndParent, NULL, hInstance, mwi))
 103       return mwi->hWnd;
 104
 105    if(mwi->lpName) HeapFree(GetProcessHeap(), 0, mwi->lpName);
 106    HeapFree(GetProcessHeap(), 0, mwi);
 107    return 0;
 108 }
 109
 110 /***********************************************************************
 111  *              MCIWndCreateW                           [MSVFW32.@]
 112  */
 113 HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
 114                            DWORD dwStyle, LPCWSTR szFile)
 115 {
 116    FIXME("%p %p %lx %s\n", hwndParent, hInstance, dwStyle, debugstr_w(szFile));
 117
 118    MCIWndRegisterClass(hInstance);
 119
 120    return 0;
 121 }
 122
 123 static DWORD MCIWND_GetStatus(MCIWndInfo* mwi)
 124 {
 125    MCI_DGV_STATUS_PARMSA        mdsp;
 126
 127    memset(&mdsp, 0, sizeof(mdsp));
 128    mdsp.dwItem = MCI_STATUS_MODE;
 129    if (mciSendCommandA(mwi->mci, MCI_STATUS, MCI_WAIT|MCI_STATUS_ITEM, (DWORD)&mdsp))
 130       return MCI_MODE_NOT_READY;
 131    if (mdsp.dwReturn == MCI_MODE_STOP && mwi->uTimer) {
 132       TRACE("Killing timer\n");
 133       KillTimer(mwi->hWnd, 0);
 134       mwi->uTimer = 0;
 135    }
 136    return mdsp.dwReturn;
 137 }
 138
 139 static DWORD MCIWND_Get(MCIWndInfo* mwi, DWORD what)
 140 {
 141    MCI_DGV_STATUS_PARMSA        mdsp;
 142
 143    memset(&mdsp, 0, sizeof(mdsp));
 144    mdsp.dwItem = what;
 145    if (mciSendCommandA(mwi->mci, MCI_STATUS, MCI_WAIT|MCI_STATUS_ITEM, (DWORD)&mdsp))
 146       return 0;
 147    return mdsp.dwReturn;
 148 }
 149
 150 static void MCIWND_SetText(MCIWndInfo* mwi)
 151 {
 152    char buffer[1024];
 153
 154    if (mwi->dwStyle & MCIWNDF_SHOWNAME) {
 155       strcpy(buffer, mwi->lpName);
 156    } else {
 157       *buffer = 0;
 158    }
 159
 160    if (mwi->dwStyle & (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE)) {
 161       if (*buffer) strcat(buffer, " ");
 162       strcat(buffer, "(");
 163    }
 164
 165    if (mwi->dwStyle & MCIWNDF_SHOWPOS) {
 166       sprintf(buffer + strlen(buffer), "%ld", MCIWND_Get(mwi, MCI_STATUS_POSITION));
 167    }
 168
 169    if ((mwi->dwStyle & (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE)) == (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE)) {
 170       strcat(buffer, " - ");
 171    }
 172
 173    if (mwi->dwStyle & MCIWNDF_SHOWMODE) {
 174       switch (MCIWND_GetStatus(mwi)) {
 175       case MCI_MODE_NOT_READY:  strcat(buffer, "not ready");    break;
 176       case MCI_MODE_PAUSE:      strcat(buffer, "paused");       break;
 177       case MCI_MODE_PLAY:       strcat(buffer, "playing");      break;
 178       case MCI_MODE_STOP:       strcat(buffer, "stopped");      break;
 179       case MCI_MODE_OPEN:       strcat(buffer, "open");         break;
 180       case MCI_MODE_RECORD:     strcat(buffer, "recording");    break;
 181       case MCI_MODE_SEEK:       strcat(buffer, "seeking");      break;
 182       default:                  strcat(buffer, "???");          break;
 183       }
 184    }
 185    if (mwi->dwStyle & (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE)) {
 186       strcat(buffer, " )");
 187    }
 188    TRACE("=> '%s'\n", buffer);
 189    SetWindowTextA(mwi->hWnd, buffer);
 190 }
 191
 192 static void MCIWND_Create(HWND hWnd, LPCREATESTRUCTA cs)
 193 {
 194    MCI_DGV_OPEN_PARMSA  mdopn;
 195    MCI_DGV_RECT_PARMS   mdrct;
 196    MMRESULT             mmr;
 197    int                  cx, cy;
 198    HWND                 hChld;
 199    MCIWndInfo*          mwi = (MCIWndInfo*)cs->lpCreateParams;
 200
 201    SetWindowLongA(hWnd, 0, (LPARAM)mwi);
 202    mwi->hWnd = hWnd;
 203
 204    /* now open MCI player for AVI file */
 205    memset(&mdopn, 0, sizeof(mdopn));
 206    mdopn.lpstrElementName = mwi->lpName;
 207    mdopn.dwStyle = WS_VISIBLE|WS_CHILD;
 208    mdopn.hWndParent = hWnd;
 209
 210    mmr = mciSendCommandA(0,  MCI_OPEN, MCI_OPEN_ELEMENT|MCI_DGV_OPEN_PARENT|MCI_DGV_OPEN_WS, (LPARAM)&mdopn);
 211    if (mmr) {
 212       MessageBoxA(GetTopWindow(hWnd), "Cannot open file", "MciWnd", MB_OK);
 213       return;
 214    }
 215    mwi->mci = mdopn.wDeviceID;
 216
 217    /* grab AVI window size */
 218    memset(&mdrct, 0, sizeof(mdrct));
 219    mmr = mciSendCommandA(mwi->mci,  MCI_WHERE, MCI_DGV_WHERE_DESTINATION, (LPARAM)&mdrct);
 220    if (mmr) {
 221       WARN("Cannot get window rect\n");
 222       return;
 223    }
 224    cx = mdrct.rc.right - mdrct.rc.left;
 225    cy = mdrct.rc.bottom - mdrct.rc.top;
 226
 227    AdjustWindowRect(&mdrct.rc, GetWindowLongA(hWnd, GWL_STYLE), FALSE);
 228    SetWindowPos(hWnd, 0, 0, 0, mdrct.rc.right - mdrct.rc.left,
 229                 mdrct.rc.bottom - mdrct.rc.top + 32, SWP_NOMOVE|SWP_NOZORDER);
 230
 231    if (!(mwi->dwStyle & MCIWNDF_NOMENU))
 232    {
 233        hChld = CreateWindowExA(0, "BUTTON", "Menu", WS_CHILD|WS_VISIBLE, 32, cy, 32, 32,
 234                            hWnd, (HMENU)CTL_MENU,
 235                            (HINSTANCE)GetWindowLongA(hWnd, GWL_HINSTANCE), 0L);
 236        TRACE("Get Button2: %p\n", hChld);
 237    }
 238
 239    if (!(mwi->dwStyle & MCIWNDF_NOPLAYBAR))
 240    {
 241        INITCOMMONCONTROLSEX init;
 242
 243        /* adding the other elements: play/stop button, menu button, status */
 244        hChld = CreateWindowExA(0, "BUTTON", "Play", WS_CHILD|WS_VISIBLE, 0, cy, 32, 32,
 245                            hWnd, (HMENU)CTL_PLAYSTOP,
 246                            (HINSTANCE)GetWindowLongA(hWnd, GWL_HINSTANCE), 0L);
 247        TRACE("Get Button1: %p\n", hChld);
 248
 249        init.dwSize = sizeof(init);
 250        init.dwICC = ICC_BAR_CLASSES;
 251        InitCommonControlsEx(&init);
 252
 253        hChld = CreateWindowExA(0, TRACKBAR_CLASSA, "", WS_CHILD|WS_VISIBLE, 64, cy, cx - 64, 32,
 254                            hWnd, (HMENU)CTL_TRACKBAR,
 255                            (HINSTANCE)GetWindowLongA(hWnd, GWL_HINSTANCE), 0L);
 256        TRACE("Get status: %p\n", hChld);
 257        SendMessageA(hChld, TBM_SETRANGEMIN, 0L, 0L);
 258        SendMessageA(hChld, TBM_SETRANGEMAX, 1L, MCIWND_Get(mwi, MCI_STATUS_LENGTH));
 259    }
 260
 261    /* FIXME: no need to set it if child window */
 262    if (mwi->dwStyle & MCIWNDF_SHOWNAME)
 263        MCIWND_SetText(mwi);
 264 }
 265
 266 static void MCIWND_Paint(MCIWndInfo* mwi, WPARAM wParam)
 267 {
 268    HDC          hdc;
 269    PAINTSTRUCT  ps;
 270
 271    hdc = (wParam) ? (HDC)wParam : BeginPaint(mwi->hWnd, &ps);
 272    /* something to do ? */
 273    if (!wParam) EndPaint(mwi->hWnd, &ps);
 274 }
 275
 276 static void MCIWND_ToggleState(MCIWndInfo* mwi)
 277 {
 278    MCI_GENERIC_PARMS    mgp;
 279    MCI_DGV_PLAY_PARMS   mdply;
 280
 281    memset(&mgp, 0, sizeof(mgp));
 282    memset(&mdply, 0, sizeof(mdply));
 283
 284    switch (MCIWND_GetStatus(mwi)) {
 285    case MCI_MODE_NOT_READY:
 286    case MCI_MODE_RECORD:
 287    case MCI_MODE_SEEK:
 288    case MCI_MODE_OPEN:
 289       TRACE("Cannot do much...\n");
 290       break;
 291    case MCI_MODE_PAUSE:
 292       mciSendCommandA(mwi->mci, MCI_RESUME, MCI_WAIT, (LPARAM)&mgp);
 293       break;
 294    case MCI_MODE_PLAY:
 295       mciSendCommandA(mwi->mci, MCI_PAUSE, MCI_WAIT, (LPARAM)&mgp);
 296       break;
 297    case MCI_MODE_STOP:
 298       mdply.dwFrom = 0L;
 299       mciSendCommandA(mwi->mci, MCI_PLAY, MCI_FROM, (LPARAM)&mdply);
 300       mwi->uTimer = SetTimer(mwi->hWnd, 0, 333, 0L);
 301       TRACE("Timer=%u\n", mwi->uTimer);
 302       break;
 303    }
 304 }
 305
 306 static LRESULT MCIWND_Command(MCIWndInfo* mwi, WPARAM wParam, LPARAM lParam)
 307 {
 308    switch (LOWORD(wParam)) {
 309    case CTL_PLAYSTOP:   MCIWND_ToggleState(mwi);        break;
 310    case CTL_MENU:
 311    case CTL_TRACKBAR:
 312    default:
 313       MessageBoxA(0, "ooch", "NIY", MB_OK);
 314    }
 315    return 0L;
 316 }
 317
 318 static void MCIWND_Timer(MCIWndInfo* mwi, WPARAM wParam, LPARAM lParam)
 319 {
 320    TRACE("%ld\n", MCIWND_Get(mwi, MCI_STATUS_POSITION));
 321    SendDlgItemMessageA(mwi->hWnd, CTL_TRACKBAR, TBM_SETPOS, 1, MCIWND_Get(mwi, MCI_STATUS_POSITION));
 322    MCIWND_SetText(mwi);
 323 }
 324
 325 static void MCIWND_Close(MCIWndInfo* mwi)
 326 {
 327    MCI_GENERIC_PARMS    mgp;
 328
 329    memset(&mgp, 0, sizeof(mgp));
 330
 331    mciSendCommandA(mwi->mci, MCI_CLOSE, 0, (LPARAM)&mgp);
 332 }
 333
 334 static LRESULT WINAPI   MCIWndProc(HWND hWnd, UINT wMsg, WPARAM lParam1, LPARAM lParam2)
 335 {
 336    MCIWndInfo*  mwi = (MCIWndInfo*)GetWindowLongA(hWnd, 0);
 337
 338    if (mwi || wMsg == WM_CREATE) {
 339       switch (wMsg) {
 340       case WM_CREATE:
 341          MCIWND_Create(hWnd, (CREATESTRUCTA*)lParam2);
 342          return 0;
 343       case WM_DESTROY:
 344          MCIWND_Close(mwi);
 345          HeapFree(GetProcessHeap(), 0, mwi->lpName);
 346          HeapFree(GetProcessHeap(), 0, mwi);
 347          break;
 348       case WM_PAINT:
 349          MCIWND_Paint(mwi, lParam1);
 350          break;
 351       case WM_COMMAND:
 352          return MCIWND_Command(mwi, lParam1, lParam2);
 353       case WM_TIMER:
 354          MCIWND_Timer(mwi, lParam1, lParam2);
 355          return TRUE;
 356       }
 357    }
 358
 359    if ((wMsg >= WM_USER) && (wMsg < WM_APP))
 360    {
 361         FIXME("support for MCIWNDM_ message WM_USER+%d not implemented\n", wMsg - WM_USER);
 362         return 0;
 363    }
 364
 365    return DefWindowProcA(hWnd, wMsg, lParam1, lParam2);
 366 }