dlls/msvfw32/mciwnd.c

   1 /*
   2  * Copyright 2000 Eric Pouech
   3  * Copyright 2003 Dmitry Timoshkov
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  *
  19  * FIXME:
  20  * Add support for all remaining MCI_ commands and MCIWNDM_ messages.
  21  * Add support for MCIWNDF_RECORD.
  22  */
  23
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winnls.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "winternl.h"
  32 #include "vfw.h"
  33 #include "digitalv.h"
  34 #include "commctrl.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(mci);
  38
  39 extern HMODULE MSVFW32_hModule;
  40 static const WCHAR mciWndClassW[] = {'M','C','I','W','n','d','C','l','a','s','s',0};
  41
  42 typedef struct
  43 {
  44     DWORD       dwStyle;
  45     MCIDEVICEID mci;
  46     HDRVR       hdrv;
  47     int         alias;
  48     UINT        dev_type;
  49     UINT        mode;
  50     LONG        position;
  51     SIZE        size; /* size of the original frame rect */
  52     int         zoom;
  53     LPWSTR      lpName;
  54     HWND        hWnd, hwndOwner;
  55     UINT        uTimer;
  56     MCIERROR    lasterror;
  57     WCHAR       return_string[128];
  58     WORD        active_timer, inactive_timer;
  59 } MCIWndInfo;
  60
  61 static LRESULT WINAPI MCIWndProc(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam);
  62
  63 #define CTL_PLAYSTOP    0x3200
  64 #define CTL_MENU        0x3201
  65 #define CTL_TRACKBAR    0x3202
  66
  67 /***********************************************************************
  68  *                MCIWndRegisterClass                [MSVFW32.@]
  69  *
  70  * NOTE: Native always uses its own hInstance
  71  */
  72 BOOL VFWAPIV MCIWndRegisterClass(void)
  73 {
  74     WNDCLASSW wc;
  75
  76     /* Since we are going to register a class belonging to MSVFW32
  77      * and later we will create windows with a different hInstance
  78      * CS_GLOBALCLASS is needed. And because the second attempt
  79      * to register a global class will fail we need to test whether
  80      * the class was already registered.
  81      */
  82     wc.style = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS | CS_OWNDC | CS_GLOBALCLASS;
  83     wc.lpfnWndProc = MCIWndProc;
  84     wc.cbClsExtra = 0;
  85     wc.cbWndExtra = sizeof(MCIWndInfo*);
  86     wc.hInstance = MSVFW32_hModule;
  87     wc.hIcon = 0;
  88     wc.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
  89     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  90     wc.lpszMenuName = NULL;
  91     wc.lpszClassName = mciWndClassW;
  92
  93     if (RegisterClassW(&wc)) return TRUE;
  94     if (GetLastError() == ERROR_CLASS_ALREADY_EXISTS) return TRUE;
  95
  96     return FALSE;
  97 }
  98
  99 /***********************************************************************
 100  *                MCIWndCreateW                                [MSVFW32.@]
 101  */
 102 HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
 103                            DWORD dwStyle, LPCWSTR szFile)
 104 {
 105     TRACE("%p %p %x %s\n", hwndParent, hInstance, dwStyle, debugstr_w(szFile));
 106
 107     MCIWndRegisterClass();
 108
 109     if (!hInstance) hInstance = GetModuleHandleW(0);
 110
 111     if (hwndParent)
 112         dwStyle |= WS_VISIBLE | WS_BORDER /*| WS_CHILD*/;
 113     else
 114         dwStyle |= WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
 115
 116     return CreateWindowExW(0, mciWndClassW, NULL,
 117                            dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
 118                            0, 0, 300, 0,
 119                            hwndParent, 0, hInstance, (LPVOID)szFile);
 120 }
 121
 122 /***********************************************************************
 123  *                MCIWndCreate                [MSVFW32.@]
 124  *                MCIWndCreateA                [MSVFW32.@]
 125  */
 126 HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
 127                            DWORD dwStyle, LPCSTR szFile)
 128 {
 129     HWND ret;
 130     UNICODE_STRING fileW;
 131
 132     if (szFile)
 133         RtlCreateUnicodeStringFromAsciiz(&fileW, szFile);
 134     else
 135         fileW.Buffer = NULL;
 136
 137     ret = MCIWndCreateW(hwndParent, hInstance, dwStyle, fileW.Buffer);
 138
 139     RtlFreeUnicodeString(&fileW);
 140     return ret;
 141 }
 142
 143 static inline void MCIWND_notify_mode(MCIWndInfo *mwi)
 144 {
 145     if (mwi->dwStyle & MCIWNDF_NOTIFYMODE)
 146     {
 147         UINT new_mode = SendMessageW(mwi->hWnd, MCIWNDM_GETMODEW, 0, 0);
 148         if (new_mode != mwi->mode)
 149         {
 150             mwi->mode = new_mode;
 151             SendMessageW(mwi->hwndOwner, MCIWNDM_NOTIFYMODE, (WPARAM)mwi->hWnd, new_mode);
 152         }
 153     }
 154 }
 155
 156 static inline void MCIWND_notify_pos(MCIWndInfo *mwi)
 157 {
 158     if (mwi->dwStyle & MCIWNDF_NOTIFYPOS)
 159     {
 160         LONG new_pos = SendMessageW(mwi->hWnd, MCIWNDM_GETPOSITIONW, 0, 0);
 161         if (new_pos != mwi->position)
 162         {
 163             mwi->position = new_pos;
 164             SendMessageW(mwi->hwndOwner, MCIWNDM_NOTIFYPOS, (WPARAM)mwi->hWnd, new_pos);
 165         }
 166     }
 167 }
 168
 169 static inline void MCIWND_notify_size(MCIWndInfo *mwi)
 170 {
 171     if (mwi->dwStyle & MCIWNDF_NOTIFYSIZE)
 172         SendMessageW(mwi->hwndOwner, MCIWNDM_NOTIFYSIZE, (WPARAM)mwi->hWnd, 0);
 173 }
 174
 175 static inline void MCIWND_notify_error(MCIWndInfo *mwi)
 176 {
 177     if (mwi->dwStyle & MCIWNDF_NOTIFYERROR)
 178         SendMessageW(mwi->hwndOwner, MCIWNDM_NOTIFYERROR, (WPARAM)mwi->hWnd, (LPARAM)mwi->lasterror);
 179 }
 180
 181 static void MCIWND_UpdateState(MCIWndInfo *mwi)
 182 {
 183     WCHAR buffer[1024];
 184
 185     if (!mwi->mci)
 186     {
 187         /* FIXME: get this from resources */
 188         static const WCHAR no_deviceW[] = {'N','o',' ','D','e','v','i','c','e',0};
 189         SetWindowTextW(mwi->hWnd, no_deviceW);
 190         return;
 191     }
 192
 193     MCIWND_notify_pos(mwi);
 194
 195     if (!(mwi->dwStyle & MCIWNDF_NOPLAYBAR))
 196         SendDlgItemMessageW(mwi->hWnd, CTL_TRACKBAR, TBM_SETPOS, TRUE, mwi->position);
 197
 198     if (!(mwi->dwStyle & MCIWNDF_SHOWALL))
 199         return;
 200
 201     if ((mwi->dwStyle & MCIWNDF_SHOWNAME) && mwi->lpName)
 202         lstrcpyW(buffer, mwi->lpName);
 203     else
 204         *buffer = 0;
 205
 206     if (mwi->dwStyle & (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE))
 207     {
 208         static const WCHAR spaceW[] = {' ',0};
 209         static const WCHAR l_braceW[] = {'(',0};
 210
 211         if (*buffer) lstrcatW(buffer, spaceW);
 212         lstrcatW(buffer, l_braceW);
 213     }
 214
 215     if (mwi->dwStyle & MCIWNDF_SHOWPOS)
 216     {
 217         WCHAR posW[64];
 218
 219         posW[0] = 0;
 220         SendMessageW(mwi->hWnd, MCIWNDM_GETPOSITIONW, 64, (LPARAM)posW);
 221         lstrcatW(buffer, posW);
 222     }
 223
 224     if ((mwi->dwStyle & (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE)) == (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE))
 225     {
 226         static const WCHAR dashW[] = {' ','-',' ',0};
 227         lstrcatW(buffer, dashW);
 228     }
 229
 230     if (mwi->dwStyle & MCIWNDF_SHOWMODE)
 231     {
 232         WCHAR modeW[64];
 233
 234         modeW[0] = 0;
 235         SendMessageW(mwi->hWnd, MCIWNDM_GETMODEW, 64, (LPARAM)modeW);
 236         lstrcatW(buffer, modeW);
 237     }
 238
 239     if (mwi->dwStyle & (MCIWNDF_SHOWPOS|MCIWNDF_SHOWMODE))
 240     {
 241         static const WCHAR r_braceW[] = {')',0};
 242         lstrcatW(buffer, r_braceW);
 243     }
 244
 245     TRACE("=> %s\n", debugstr_w(buffer));
 246     SetWindowTextW(mwi->hWnd, buffer);
 247 }
 248
 249 static LRESULT MCIWND_Create(HWND hWnd, LPCREATESTRUCTW cs)
 250 {
 251     HWND hChld;
 252     MCIWndInfo *mwi;
 253     static const WCHAR buttonW[] = {'b','u','t','t','o','n',0};
 254
 255     mwi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*mwi));
 256     if (!mwi) return -1;
 257
 258     SetWindowLongW(hWnd, 0, (LPARAM)mwi);
 259
 260     mwi->dwStyle = cs->style;
 261     /* There is no need to show stats if there is no caption */
 262     if ((mwi->dwStyle & WS_CAPTION) != WS_CAPTION)
 263         mwi->dwStyle &= ~MCIWNDF_SHOWALL;
 264
 265     mwi->hWnd = hWnd;
 266     mwi->hwndOwner = cs->hwndParent;
 267     mwi->active_timer = 500;
 268     mwi->inactive_timer = 2000;
 269     mwi->mode = MCI_MODE_NOT_READY;
 270     mwi->position = -1;
 271     mwi->zoom = 100;
 272
 273     if (!(mwi->dwStyle & MCIWNDF_NOMENU))
 274     {
 275         static const WCHAR menuW[] = {'M','e','n','u',0};
 276
 277         hChld = CreateWindowExW(0, buttonW, menuW, WS_CHILD|WS_VISIBLE, 32, cs->cy, 32, 32,
 278                                 hWnd, (HMENU)CTL_MENU, cs->hInstance, 0L);
 279         TRACE("Get Button2: %p\n", hChld);
 280     }
 281
 282     if (!(mwi->dwStyle & MCIWNDF_NOPLAYBAR))
 283     {
 284         INITCOMMONCONTROLSEX init;
 285         static const WCHAR playW[] = {'P','l','a','y',0};
 286
 287         /* adding the other elements: play/stop button, menu button, status */
 288         hChld = CreateWindowExW(0, buttonW, playW, WS_CHILD|WS_VISIBLE, 0, cs->cy, 32, 32,
 289                                 hWnd, (HMENU)CTL_PLAYSTOP, cs->hInstance, 0L);
 290         TRACE("Get Button1: %p\n", hChld);
 291
 292         init.dwSize = sizeof(init);
 293         init.dwICC = ICC_BAR_CLASSES;
 294         InitCommonControlsEx(&init);
 295
 296         hChld = CreateWindowExW(0, TRACKBAR_CLASSW, NULL, WS_CHILD|WS_VISIBLE, 64, cs->cy, cs->cx - 64, 32,
 297                                 hWnd, (HMENU)CTL_TRACKBAR, cs->hInstance, 0L);
 298         TRACE("Get status: %p\n", hChld);
 299     }
 300
 301     /* This sets the default window size */
 302     SendMessageW(hWnd, MCI_CLOSE, 0, 0);
 303
 304     if (cs->lpCreateParams)
 305     {
 306         LPARAM lParam;
 307
 308         /* MCI wnd class is prepared to be embedded as an MDI child window */
 309         if (cs->dwExStyle & WS_EX_MDICHILD)
 310         {
 311             MDICREATESTRUCTW *mdics = cs->lpCreateParams;
 312             lParam = mdics->lParam;
 313         }
 314         else
 315             lParam = (LPARAM)cs->lpCreateParams;
 316
 317         /* If it's our internal class pointer, file name is a unicode string */
 318         if (cs->lpszClass == mciWndClassW)
 319             SendMessageW(hWnd, MCIWNDM_OPENW, 0, lParam);
 320         else
 321         {
 322             /* Otherwise let's try to figure out what string format is used */
 323             HWND parent = cs->hwndParent;
 324             if (!parent) parent = GetWindow(hWnd, GW_OWNER);
 325
 326             SendMessageW(hWnd, IsWindowUnicode(parent) ? MCIWNDM_OPENW : MCIWNDM_OPENA, 0, lParam);
 327         }
 328     }
 329
 330     return 0;
 331 }
 332
 333 static void MCIWND_ToggleState(MCIWndInfo *mwi)
 334 {
 335     switch (SendMessageW(mwi->hWnd, MCIWNDM_GETMODEW, 0, 0))
 336     {
 337     case MCI_MODE_NOT_READY:
 338     case MCI_MODE_RECORD:
 339     case MCI_MODE_SEEK:
 340     case MCI_MODE_OPEN:
 341         TRACE("Cannot do much...\n");
 342         break;
 343
 344     case MCI_MODE_PAUSE:
 345         SendMessageW(mwi->hWnd, MCI_RESUME, 0, 0);
 346         break;
 347
 348     case MCI_MODE_PLAY:
 349         SendMessageW(mwi->hWnd, MCI_PAUSE, 0, 0);
 350         break;
 351
 352     case MCI_MODE_STOP:
 353         SendMessageW(mwi->hWnd, MCI_STOP, 0, 0);
 354         break;
 355     }
 356 }
 357
 358 static LRESULT MCIWND_Command(MCIWndInfo *mwi, WPARAM wParam, LPARAM lParam)
 359 {
 360     switch (LOWORD(wParam))
 361     {
 362     case CTL_PLAYSTOP: MCIWND_ToggleState(mwi); break;
 363     case CTL_MENU:
 364     case CTL_TRACKBAR:
 365     default:
 366         FIXME("support for command %04x not implement yet\n", LOWORD(wParam));
 367     }
 368     return 0L;
 369 }
 370
 371 static void MCIWND_notify_media(MCIWndInfo *mwi)
 372 {
 373     if (mwi->dwStyle & (MCIWNDF_NOTIFYMEDIAA | MCIWNDF_NOTIFYMEDIAW))
 374     {
 375         if (!mwi->lpName)
 376         {
 377             static const WCHAR empty_str[1];
 378             SendMessageW(mwi->hwndOwner, MCIWNDM_NOTIFYMEDIA, (WPARAM)mwi->hWnd, (LPARAM)empty_str);
 379         }
 380         else
 381         {
 382             if (mwi->dwStyle & MCIWNDF_NOTIFYANSI)
 383             {
 384                 char *ansi_name;
 385                 int len;
 386
 387                 len = WideCharToMultiByte(CP_ACP, 0, mwi->lpName, -1, NULL, 0, NULL, NULL);
 388                 ansi_name = HeapAlloc(GetProcessHeap(), 0, len);
 389                 WideCharToMultiByte(CP_ACP, 0, mwi->lpName, -1, ansi_name, len, NULL, NULL);
 390
 391                 SendMessageW(mwi->hwndOwner, MCIWNDM_NOTIFYMEDIA, (WPARAM)mwi->hWnd, (LPARAM)ansi_name);
 392
 393                 HeapFree(GetProcessHeap(), 0, ansi_name);
 394             }
 395             else
 396                 SendMessageW(mwi->hwndOwner, MCIWNDM_NOTIFYMEDIA, (WPARAM)mwi->hWnd, (LPARAM)mwi->lpName);
 397         }
 398     }
 399 }
 400
 401 static MCIERROR mci_generic_command(MCIWndInfo *mwi, UINT cmd)
 402 {
 403     MCI_GENERIC_PARMS mci_generic;
 404
 405     mci_generic.dwCallback = 0;
 406     mwi->lasterror = mciSendCommandW(mwi->mci, cmd, 0, (DWORD_PTR)&mci_generic);
 407
 408     if (mwi->lasterror)
 409         return mwi->lasterror;
 410
 411     MCIWND_notify_mode(mwi);
 412     MCIWND_UpdateState(mwi);
 413     return 0;
 414 }
 415
 416 static LRESULT mci_get_devcaps(MCIWndInfo *mwi, UINT cap)
 417 {
 418     MCI_GETDEVCAPS_PARMS mci_devcaps;
 419
 420     mci_devcaps.dwItem = cap;
 421     mwi->lasterror = mciSendCommandW(mwi->mci, MCI_GETDEVCAPS,
 422                                    MCI_GETDEVCAPS_ITEM,
 423                                    (DWORD_PTR)&mci_devcaps);
 424     if (mwi->lasterror)
 425         return 0;
 426
 427     return mci_devcaps.dwReturn;
 428 }
 429
 430 static LRESULT MCIWND_KeyDown(MCIWndInfo *mwi, UINT key)
 431 {
 432     TRACE("%p, key %04x\n", mwi->hWnd, key);
 433
 434     switch(key)
 435     {
 436     case VK_ESCAPE:
 437         SendMessageW(mwi->hWnd, MCI_STOP, 0, 0);
 438         return 0;
 439
 440     default:
 441         return 0;
 442     }
 443 }
 444
 445 static LRESULT WINAPI MCIWndProc(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
 446 {
 447     MCIWndInfo *mwi;
 448
 449     TRACE("%p %04x %08lx %08lx\n", hWnd, wMsg, wParam, lParam);
 450
 451     mwi = (MCIWndInfo*)GetWindowLongPtrW(hWnd, 0);
 452     if (!mwi && wMsg != WM_CREATE)
 453         return DefWindowProcW(hWnd, wMsg, wParam, lParam);
 454
 455     switch (wMsg)
 456     {
 457     case WM_CREATE:
 458         MCIWND_Create(hWnd, (CREATESTRUCTW *)lParam);
 459         break;
 460
 461     case WM_DESTROY:
 462         if (mwi->uTimer)
 463             KillTimer(hWnd, mwi->uTimer);
 464
 465         if (mwi->mci)
 466             SendMessageW(hWnd, MCI_CLOSE, 0, 0);
 467
 468         HeapFree(GetProcessHeap(), 0, mwi);
 469
 470         DestroyWindow(GetDlgItem(hWnd, CTL_MENU));
 471         DestroyWindow(GetDlgItem(hWnd, CTL_PLAYSTOP));
 472         DestroyWindow(GetDlgItem(hWnd, CTL_TRACKBAR));
 473         break;
 474
 475     case WM_PAINT:
 476         {
 477             MCI_DGV_UPDATE_PARMS mci_update;
 478             PAINTSTRUCT ps;
 479
 480             mci_update.hDC = (wParam) ? (HDC)wParam : BeginPaint(hWnd, &ps);
 481
 482             mciSendCommandW(mwi->mci, MCI_UPDATE,
 483                             MCI_DGV_UPDATE_HDC | MCI_DGV_UPDATE_PAINT,
 484                             (DWORD_PTR)&mci_update);
 485
 486             if (!wParam) EndPaint(hWnd, &ps);
 487             return 1;
 488         }
 489
 490     case WM_COMMAND:
 491         return MCIWND_Command(mwi, wParam, lParam);
 492
 493     case WM_KEYDOWN:
 494         return MCIWND_KeyDown(mwi, wParam);
 495
 496     case WM_NCACTIVATE:
 497         if (mwi->uTimer)
 498         {
 499             KillTimer(hWnd, mwi->uTimer);
 500             mwi->uTimer = SetTimer(hWnd, 1, wParam ? mwi->active_timer : mwi->inactive_timer, NULL);
 501         }
 502         break;
 503
 504     case WM_TIMER:
 505         MCIWND_UpdateState(mwi);
 506         return 0;
 507
 508     case WM_SIZE:
 509         SetWindowPos(GetDlgItem(hWnd, CTL_PLAYSTOP), 0, 0, HIWORD(lParam) - 32, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
 510         SetWindowPos(GetDlgItem(hWnd, CTL_MENU), 0, 32, HIWORD(lParam) - 32, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE);
 511         SetWindowPos(GetDlgItem(hWnd, CTL_TRACKBAR), 0, 64, HIWORD(lParam) - 32, LOWORD(lParam) - 64, 32, SWP_NOACTIVATE);
 512
 513         if (!(mwi->dwStyle & MCIWNDF_NOAUTOSIZEMOVIE))
 514         {
 515             RECT rc;
 516
 517             rc.left = rc.top = 0;
 518             rc.right = LOWORD(lParam);
 519             rc.bottom = HIWORD(lParam);
 520             if (!(mwi->dwStyle & MCIWNDF_NOPLAYBAR))
 521                 rc.bottom -= 32; /* subtract the height of the playbar */
 522             SendMessageW(hWnd, MCIWNDM_PUT_DEST, 0, (LPARAM)&rc);
 523         }
 524         MCIWND_notify_size(mwi);
 525         break;
 526
 527     case MM_MCINOTIFY:
 528         MCIWND_notify_mode(mwi);
 529         MCIWND_UpdateState(mwi);
 530         return 0;
 531
 532     case MCIWNDM_OPENA:
 533         {
 534             UNICODE_STRING nameW;
 535             TRACE("MCIWNDM_OPENA %s\n", debugstr_a((LPSTR)lParam));
 536             RtlCreateUnicodeStringFromAsciiz(&nameW, (LPCSTR)lParam);
 537             lParam = (LPARAM)nameW.Buffer;
 538         }
 539         /* fall through */
 540     case MCIWNDM_OPENW:
 541         {
 542             RECT rc;
 543             HCURSOR hCursor;
 544             MCI_OPEN_PARMSW mci_open;
 545             MCI_GETDEVCAPS_PARMS mci_devcaps;
 546             WCHAR aliasW[64];
 547             WCHAR drv_name[MAX_PATH];
 548             static const WCHAR formatW[] = {'%','d',0};
 549             static const WCHAR mci32W[] = {'m','c','i','3','2',0};
 550             static const WCHAR system_iniW[] = {'s','y','s','t','e','m','.','i','n','i',0};
 551
 552             TRACE("MCIWNDM_OPENW %s\n", debugstr_w((LPWSTR)lParam));
 553
 554             if (wParam == MCIWNDOPENF_NEW)
 555             {
 556                 SendMessageW(hWnd, MCIWNDM_NEWW, 0, lParam);
 557                 goto end_of_mci_open;
 558             }
 559
 560             if (mwi->uTimer)
 561             {
 562                 KillTimer(hWnd, mwi->uTimer);
 563                 mwi->uTimer = 0;
 564             }
 565
 566             hCursor = LoadCursorW(0, (LPWSTR)IDC_WAIT);
 567             hCursor = SetCursor(hCursor);
 568
 569             mci_open.lpstrElementName = (LPWSTR)lParam;
 570             wsprintfW(aliasW, formatW, HandleToLong(hWnd) + 1);
 571             mci_open.lpstrAlias = aliasW;
 572             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_OPEN,
 573                                              MCI_OPEN_ELEMENT | MCI_OPEN_ALIAS | MCI_WAIT,
 574                                              (DWORD_PTR)&mci_open);
 575             SetCursor(hCursor);
 576
 577             if (mwi->lasterror && !(mwi->dwStyle & MCIWNDF_NOERRORDLG))
 578             {
 579                 /* FIXME: get the caption from resources */
 580                 static const WCHAR caption[] = {'M','C','I',' ','E','r','r','o','r',0};
 581                 WCHAR error_str[MAXERRORLENGTH];
 582
 583                 mciGetErrorStringW(mwi->lasterror, error_str, MAXERRORLENGTH);
 584                 MessageBoxW(hWnd, error_str, caption, MB_ICONEXCLAMATION | MB_OK);
 585                 MCIWND_notify_error(mwi);
 586                 goto end_of_mci_open;
 587             }
 588
 589             mwi->mci = mci_open.wDeviceID;
 590             mwi->alias = HandleToLong(hWnd) + 1;
 591
 592             mwi->lpName = HeapAlloc(GetProcessHeap(), 0, (lstrlenW((LPWSTR)lParam) + 1) * sizeof(WCHAR));
 593             lstrcpyW(mwi->lpName, (LPWSTR)lParam);
 594
 595             MCIWND_UpdateState(mwi);
 596
 597             mci_devcaps.dwItem = MCI_GETDEVCAPS_DEVICE_TYPE;
 598             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_GETDEVCAPS,
 599                                              MCI_GETDEVCAPS_ITEM,
 600                                              (DWORD_PTR)&mci_devcaps);
 601             if (mwi->lasterror)
 602             {
 603                 MCIWND_notify_error(mwi);
 604                 goto end_of_mci_open;
 605             }
 606
 607             mwi->dev_type = mci_devcaps.dwReturn;
 608
 609             drv_name[0] = 0;
 610             SendMessageW(hWnd, MCIWNDM_GETDEVICEW, 256, (LPARAM)drv_name);
 611             if (drv_name[0] && GetPrivateProfileStringW(mci32W, drv_name, NULL,
 612                                             drv_name, MAX_PATH, system_iniW))
 613                 mwi->hdrv = OpenDriver(drv_name, NULL, 0);
 614
 615             if (mwi->dev_type == MCI_DEVTYPE_DIGITAL_VIDEO)
 616             {
 617                 MCI_DGV_WINDOW_PARMSW mci_window;
 618
 619                 mci_window.hWnd = hWnd;
 620                 mwi->lasterror = mciSendCommandW(mwi->mci, MCI_WINDOW,
 621                                                  MCI_DGV_WINDOW_HWND,
 622                                                  (DWORD_PTR)&mci_window);
 623                 if (mwi->lasterror)
 624                 {
 625                     MCIWND_notify_error(mwi);
 626                     goto end_of_mci_open;
 627                 }
 628             }
 629
 630             if (SendMessageW(hWnd, MCIWNDM_GET_DEST, 0, (LPARAM)&rc) == 0)
 631             {
 632                 mwi->size.cx = rc.right - rc.left;
 633                 mwi->size.cy = rc.bottom - rc.top;
 634
 635                 rc.right = MulDiv(mwi->size.cx, mwi->zoom, 100);
 636                 rc.bottom = MulDiv(mwi->size.cy, mwi->zoom, 100);
 637                 SendMessageW(hWnd, MCIWNDM_PUT_DEST, 0, (LPARAM)&rc);
 638             }
 639             else
 640             {
 641                 GetClientRect(hWnd, &rc);
 642                 rc.bottom = rc.top;
 643             }
 644
 645             if (!(mwi->dwStyle & MCIWNDF_NOPLAYBAR))
 646                 rc.bottom += 32; /* add the height of the playbar */
 647             AdjustWindowRect(&rc, GetWindowLongW(hWnd, GWL_STYLE), FALSE);
 648             SetWindowPos(hWnd, 0, 0, 0, rc.right - rc.left,
 649                          rc.bottom - rc.top, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
 650
 651             SendDlgItemMessageW(hWnd, CTL_TRACKBAR, TBM_SETRANGEMIN, 0L, 0L);
 652             SendDlgItemMessageW(hWnd, CTL_TRACKBAR, TBM_SETRANGEMAX, 1,
 653                                 SendMessageW(hWnd, MCIWNDM_GETLENGTH, 0, 0));
 654             mwi->uTimer = SetTimer(hWnd, 1, mwi->active_timer, NULL);
 655
 656             MCIWND_notify_media(mwi);
 657
 658 end_of_mci_open:
 659             if (wMsg == MCIWNDM_OPENA)
 660                 HeapFree(GetProcessHeap(), 0, (void *)lParam);
 661             return mwi->lasterror;
 662         }
 663
 664     case MCIWNDM_GETDEVICEID:
 665         TRACE("MCIWNDM_GETDEVICEID\n");
 666         return mwi->mci;
 667
 668     case MCIWNDM_GETALIAS:
 669         TRACE("MCIWNDM_GETALIAS\n");
 670         return mwi->alias;
 671
 672     case MCIWNDM_GET_SOURCE:
 673         {
 674             MCI_DGV_RECT_PARMS mci_rect;
 675
 676             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_WHERE,
 677                                              MCI_DGV_WHERE_SOURCE,
 678                                              (DWORD_PTR)&mci_rect);
 679             if (mwi->lasterror)
 680             {
 681                 MCIWND_notify_error(mwi);
 682                 return mwi->lasterror;
 683             }
 684             *(RECT *)lParam = mci_rect.rc;
 685             TRACE("MCIWNDM_GET_SOURCE: %s\n", wine_dbgstr_rect(&mci_rect.rc));
 686             return 0;
 687         }
 688
 689     case MCIWNDM_GET_DEST:
 690         {
 691             MCI_DGV_RECT_PARMS mci_rect;
 692
 693             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_WHERE,
 694                                              MCI_DGV_WHERE_DESTINATION,
 695                                              (DWORD_PTR)&mci_rect);
 696             if (mwi->lasterror)
 697             {
 698                 MCIWND_notify_error(mwi);
 699                 return mwi->lasterror;
 700             }
 701             *(RECT *)lParam = mci_rect.rc;
 702             TRACE("MCIWNDM_GET_DEST: %s\n", wine_dbgstr_rect(&mci_rect.rc));
 703             return 0;
 704         }
 705
 706     case MCIWNDM_PUT_SOURCE:
 707         {
 708             MCI_DGV_PUT_PARMS mci_put;
 709
 710             mci_put.rc = *(RECT *)lParam;
 711             TRACE("MCIWNDM_PUT_SOURCE: %s\n", wine_dbgstr_rect(&mci_put.rc));
 712             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_PUT,
 713                                              MCI_DGV_PUT_SOURCE,
 714                                              (DWORD_PTR)&mci_put);
 715             if (mwi->lasterror)
 716             {
 717                 MCIWND_notify_error(mwi);
 718                 return mwi->lasterror;
 719             }
 720             return 0;
 721         }
 722
 723     case MCIWNDM_PUT_DEST:
 724         {
 725             MCI_DGV_PUT_PARMS mci_put;
 726
 727             mci_put.rc = *(RECT *)lParam;
 728             TRACE("MCIWNDM_PUT_DEST: %s\n", wine_dbgstr_rect(&mci_put.rc));
 729
 730             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_PUT,
 731                                              MCI_DGV_PUT_DESTINATION | MCI_DGV_RECT,
 732                                              (DWORD_PTR)&mci_put);
 733             if (mwi->lasterror)
 734             {
 735                 MCIWND_notify_error(mwi);
 736                 return mwi->lasterror;
 737             }
 738             return 0;
 739         }
 740
 741     case MCIWNDM_GETLENGTH:
 742         {
 743             MCI_STATUS_PARMS mci_status;
 744
 745             mci_status.dwItem = MCI_STATUS_LENGTH;
 746             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_STATUS,
 747                                              MCI_STATUS_ITEM,
 748                                              (DWORD_PTR)&mci_status);
 749             if (mwi->lasterror)
 750             {
 751                 MCIWND_notify_error(mwi);
 752                 return 0;
 753             }
 754             TRACE("MCIWNDM_GETLENGTH: %ld\n", mci_status.dwReturn);
 755             return mci_status.dwReturn;
 756         }
 757
 758     case MCIWNDM_GETSTART:
 759         {
 760             MCI_STATUS_PARMS mci_status;
 761
 762             mci_status.dwItem = MCI_STATUS_POSITION;
 763             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_STATUS,
 764                                              MCI_STATUS_ITEM | MCI_STATUS_START,
 765                                              (DWORD_PTR)&mci_status);
 766             if (mwi->lasterror)
 767             {
 768                 MCIWND_notify_error(mwi);
 769                 return 0;
 770             }
 771             TRACE("MCIWNDM_GETSTART: %ld\n", mci_status.dwReturn);
 772             return mci_status.dwReturn;
 773         }
 774
 775     case MCIWNDM_GETEND:
 776         {
 777             LRESULT start, length;
 778
 779             start = SendMessageW(hWnd, MCIWNDM_GETSTART, 0, 0);
 780             length = SendMessageW(hWnd, MCIWNDM_GETLENGTH, 0, 0);
 781             TRACE("MCIWNDM_GETEND: %ld\n", start + length);
 782             return (start + length);
 783         }
 784
 785     case MCIWNDM_GETPOSITIONA:
 786     case MCIWNDM_GETPOSITIONW:
 787         {
 788             MCI_STATUS_PARMS mci_status;
 789
 790             TRACE("MCIWNDM_GETPOSITION\n");
 791
 792             /* get position string if requested */
 793             if (wParam && lParam)
 794             {
 795                 if (wMsg == MCIWNDM_GETPOSITIONA)
 796                 {
 797                     char cmd[64];
 798
 799                     wsprintfA(cmd, "status %d position", mwi->alias);
 800                     mwi->lasterror = mciSendStringA(cmd, (LPSTR)lParam, wParam, 0);
 801                 }
 802                 else
 803                 {
 804
 805                     WCHAR cmdW[64];
 806                     static const WCHAR formatW[] = {'s','t','a','t','u','s',' ','%','d',' ','p','o','s','i','t','i','o','n',0};
 807
 808                     wsprintfW(cmdW, formatW, mwi->alias);
 809                     mwi->lasterror = mciSendStringW(cmdW, (LPWSTR)lParam, wParam, 0);
 810                 }
 811
 812                 if (mwi->lasterror)
 813                     return 0;
 814             }
 815
 816             mci_status.dwItem = MCI_STATUS_POSITION;
 817             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_STATUS,
 818                                              MCI_STATUS_ITEM,
 819                                              (DWORD_PTR)&mci_status);
 820             if (mwi->lasterror)
 821                 return 0;
 822
 823             return mci_status.dwReturn;
 824         }
 825
 826     case MCIWNDM_GETMODEA:
 827     case MCIWNDM_GETMODEW:
 828         {
 829             MCI_STATUS_PARMS mci_status;
 830
 831             TRACE("MCIWNDM_GETMODE\n");
 832
 833             if (!mwi->mci)
 834                 return MCI_MODE_NOT_READY;
 835
 836             /* get mode string if requested */
 837             if (wParam && lParam)
 838             {
 839                 if (wMsg == MCIWNDM_GETMODEA)
 840                 {
 841                     char cmd[64];
 842
 843                     wsprintfA(cmd, "status %d mode", mwi->alias);
 844                     mwi->lasterror = mciSendStringA(cmd, (LPSTR)lParam, wParam, 0);
 845                 }
 846                 else
 847                 {
 848
 849                     WCHAR cmdW[64];
 850                     static const WCHAR formatW[] = {'s','t','a','t','u','s',' ','%','d',' ','m','o','d','e',0};
 851
 852                     wsprintfW(cmdW, formatW, mwi->alias);
 853                     mwi->lasterror = mciSendStringW(cmdW, (LPWSTR)lParam, wParam, 0);
 854                 }
 855
 856                 if (mwi->lasterror)
 857                     return MCI_MODE_NOT_READY;
 858             }
 859
 860             mci_status.dwItem = MCI_STATUS_MODE;
 861             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_STATUS,
 862                                              MCI_STATUS_ITEM,
 863                                              (DWORD_PTR)&mci_status);
 864             if (mwi->lasterror)
 865                 return MCI_MODE_NOT_READY;
 866
 867             return mci_status.dwReturn;
 868         }
 869
 870     case MCIWNDM_PLAYFROM:
 871         {
 872             MCI_PLAY_PARMS mci_play;
 873
 874             TRACE("MCIWNDM_PLAYFROM %08lx\n", lParam);
 875
 876             mci_play.dwCallback = (DWORD_PTR)hWnd;
 877             mci_play.dwFrom = lParam;
 878             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_PLAY,
 879                                              MCI_FROM | MCI_NOTIFY,
 880                                              (DWORD_PTR)&mci_play);
 881             if (mwi->lasterror)
 882             {
 883                 MCIWND_notify_error(mwi);
 884                 return mwi->lasterror;
 885             }
 886
 887             MCIWND_notify_mode(mwi);
 888             MCIWND_UpdateState(mwi);
 889             return 0;
 890         }
 891
 892     case MCIWNDM_PLAYTO:
 893         {
 894             MCI_PLAY_PARMS mci_play;
 895
 896             TRACE("MCIWNDM_PLAYTO %08lx\n", lParam);
 897
 898             mci_play.dwCallback = (DWORD_PTR)hWnd;
 899             mci_play.dwTo = lParam;
 900             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_PLAY,
 901                                              MCI_TO | MCI_NOTIFY,
 902                                              (DWORD_PTR)&mci_play);
 903             if (mwi->lasterror)
 904             {
 905                 MCIWND_notify_error(mwi);
 906                 return mwi->lasterror;
 907             }
 908
 909             MCIWND_notify_mode(mwi);
 910             MCIWND_UpdateState(mwi);
 911             return 0;
 912         }
 913
 914     case MCIWNDM_PLAYREVERSE:
 915         {
 916             MCI_PLAY_PARMS mci_play;
 917             DWORD flags = MCI_NOTIFY;
 918
 919             TRACE("MCIWNDM_PLAYREVERSE %08lx\n", lParam);
 920
 921             mci_play.dwCallback = (DWORD_PTR)hWnd;
 922             mci_play.dwFrom = lParam;
 923             switch (mwi->dev_type)
 924             {
 925             default:
 926             case MCI_DEVTYPE_ANIMATION:
 927                 flags |= MCI_ANIM_PLAY_REVERSE;
 928                 break;
 929
 930             case MCI_DEVTYPE_DIGITAL_VIDEO:
 931                 flags |= MCI_DGV_PLAY_REVERSE;
 932                 break;
 933
 934 #ifdef MCI_VCR_PLAY_REVERSE
 935             case MCI_DEVTYPE_VCR:
 936                 flags |= MCI_VCR_PLAY_REVERSE;
 937                 break;
 938 #endif
 939
 940             case MCI_DEVTYPE_VIDEODISC:
 941                 flags |= MCI_VD_PLAY_REVERSE;
 942                 break;
 943
 944             }
 945             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_PLAY,
 946                                              flags, (DWORD_PTR)&mci_play);
 947             if (mwi->lasterror)
 948             {
 949                 MCIWND_notify_error(mwi);
 950                 return mwi->lasterror;
 951             }
 952
 953             MCIWND_notify_mode(mwi);
 954             MCIWND_UpdateState(mwi);
 955             return 0;
 956         }
 957
 958     case MCIWNDM_GETERRORA:
 959         mciGetErrorStringA(mwi->lasterror, (LPSTR)lParam, wParam);
 960         TRACE("MCIWNDM_GETERRORA: %s\n", debugstr_an((LPSTR)lParam, wParam));
 961         return mwi->lasterror;
 962
 963     case MCIWNDM_GETERRORW:
 964         mciGetErrorStringW(mwi->lasterror, (LPWSTR)lParam, wParam);
 965         TRACE("MCIWNDM_GETERRORW: %s\n", debugstr_wn((LPWSTR)lParam, wParam));
 966         return mwi->lasterror;
 967
 968     case MCIWNDM_SETOWNER:
 969         TRACE("MCIWNDM_SETOWNER %p\n", (HWND)wParam);
 970         mwi->hwndOwner = (HWND)wParam;
 971         return 0;
 972
 973     case MCIWNDM_SENDSTRINGA:
 974         {
 975             UNICODE_STRING stringW;
 976
 977             TRACE("MCIWNDM_SENDSTRINGA %s\n", debugstr_a((LPCSTR)lParam));
 978
 979             RtlCreateUnicodeStringFromAsciiz(&stringW, (LPCSTR)lParam);
 980             lParam = (LPARAM)stringW.Buffer;
 981         }
 982         /* fall through */
 983     case MCIWNDM_SENDSTRINGW:
 984         {
 985             WCHAR *cmdW, *p;
 986
 987             TRACE("MCIWNDM_SENDSTRINGW %s\n", debugstr_w((LPCWSTR)lParam));
 988
 989             p = wcschr((LPCWSTR)lParam, ' ');
 990             if (p)
 991             {
 992                 static const WCHAR formatW[] = {'%','d',' ',0};
 993                 int len, pos;
 994
 995                 pos = p - (WCHAR *)lParam + 1;
 996                 len = lstrlenW((LPCWSTR)lParam) + 64;
 997
 998                 cmdW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 999
1000                 memcpy(cmdW, (void *)lParam, pos * sizeof(WCHAR));
1001                 wsprintfW(cmdW + pos, formatW, mwi->alias);
1002                 lstrcatW(cmdW, (WCHAR *)lParam + pos);
1003             }
1004             else
1005                 cmdW = (LPWSTR)lParam;
1006
1007             mwi->lasterror = mciSendStringW(cmdW, mwi->return_string,
1008                                             ARRAY_SIZE(mwi->return_string), 0);
1009             if (mwi->lasterror)
1010                 MCIWND_notify_error(mwi);
1011
1012             if (cmdW != (LPWSTR)lParam)
1013                 HeapFree(GetProcessHeap(), 0, cmdW);
1014
1015             if (wMsg == MCIWNDM_SENDSTRINGA)
1016                 HeapFree(GetProcessHeap(), 0, (void *)lParam);
1017
1018             MCIWND_UpdateState(mwi);
1019             return mwi->lasterror;
1020         }
1021
1022     case MCIWNDM_RETURNSTRINGA:
1023         WideCharToMultiByte(CP_ACP, 0, mwi->return_string, -1, (LPSTR)lParam, wParam, NULL, NULL);
1024         TRACE("MCIWNDM_RETURNTRINGA %s\n", debugstr_an((LPSTR)lParam, wParam));
1025         return mwi->lasterror;
1026
1027     case MCIWNDM_RETURNSTRINGW:
1028         lstrcpynW((LPWSTR)lParam, mwi->return_string, wParam);
1029         TRACE("MCIWNDM_RETURNTRINGW %s\n", debugstr_wn((LPWSTR)lParam, wParam));
1030         return mwi->lasterror;
1031
1032     case MCIWNDM_SETTIMERS:
1033         TRACE("MCIWNDM_SETTIMERS active %d ms, inactive %d ms\n", (int)wParam, (int)lParam);
1034         mwi->active_timer = (WORD)wParam;
1035         mwi->inactive_timer = (WORD)lParam;
1036         return 0;
1037
1038     case MCIWNDM_SETACTIVETIMER:
1039         TRACE("MCIWNDM_SETACTIVETIMER %d ms\n", (int)wParam);
1040         mwi->active_timer = (WORD)wParam;
1041         return 0;
1042
1043     case MCIWNDM_SETINACTIVETIMER:
1044         TRACE("MCIWNDM_SETINACTIVETIMER %d ms\n", (int)wParam);
1045         mwi->inactive_timer = (WORD)wParam;
1046         return 0;
1047
1048     case MCIWNDM_GETACTIVETIMER:
1049         TRACE("MCIWNDM_GETACTIVETIMER: %d ms\n", mwi->active_timer);
1050         return mwi->active_timer;
1051
1052     case MCIWNDM_GETINACTIVETIMER:
1053         TRACE("MCIWNDM_GETINACTIVETIMER: %d ms\n", mwi->inactive_timer);
1054         return mwi->inactive_timer;
1055
1056     case MCIWNDM_CHANGESTYLES:
1057         TRACE("MCIWNDM_CHANGESTYLES mask %08lx, set %08lx\n", wParam, lParam);
1058         /* FIXME: update the visual window state as well:
1059          * add/remove trackbar, autosize, etc.
1060          */
1061         mwi->dwStyle &= ~wParam;
1062         mwi->dwStyle |= lParam & wParam;
1063         return 0;
1064
1065     case MCIWNDM_GETSTYLES:
1066         TRACE("MCIWNDM_GETSTYLES: %08x\n", mwi->dwStyle & 0xffff);
1067         return mwi->dwStyle & 0xffff;
1068
1069     case MCIWNDM_GETDEVICEA:
1070         {
1071             int len = 0;
1072             char *str = (char *)lParam;
1073             MCI_SYSINFO_PARMSA mci_sysinfo;
1074
1075             mci_sysinfo.lpstrReturn = str;
1076             mci_sysinfo.dwRetSize = wParam;
1077             mwi->lasterror = mciSendCommandA(mwi->mci, MCI_SYSINFO,
1078                                              MCI_SYSINFO_INSTALLNAME,
1079                                              (DWORD_PTR)&mci_sysinfo);
1080             while(len < wParam && str[len]) len++;
1081             TRACE("MCIWNDM_GETDEVICEA: %s\n", debugstr_an(str, len));
1082             return 0;
1083         }
1084
1085     case MCIWNDM_GETDEVICEW:
1086         {
1087             int len = 0;
1088             WCHAR *str = (WCHAR *)lParam;
1089             MCI_SYSINFO_PARMSW mci_sysinfo;
1090
1091             mci_sysinfo.lpstrReturn = str;
1092             mci_sysinfo.dwRetSize = wParam;
1093             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_SYSINFO,
1094                                              MCI_SYSINFO_INSTALLNAME,
1095                                              (DWORD_PTR)&mci_sysinfo);
1096             while(len < wParam && str[len]) len++;
1097             TRACE("MCIWNDM_GETDEVICEW: %s\n", debugstr_wn(str, len));
1098             return 0;
1099         }
1100
1101     case MCIWNDM_VALIDATEMEDIA:
1102         TRACE("MCIWNDM_VALIDATEMEDIA\n");
1103         if (mwi->mci)
1104         {
1105             SendMessageW(hWnd, MCIWNDM_GETSTART, 0, 0);
1106             SendMessageW(hWnd, MCIWNDM_GETLENGTH, 0, 0);
1107         }
1108         return 0;
1109
1110     case MCIWNDM_GETFILENAMEA:
1111         TRACE("MCIWNDM_GETFILENAMEA: %s\n", debugstr_w(mwi->lpName));
1112         if (mwi->lpName)
1113             WideCharToMultiByte(CP_ACP, 0, mwi->lpName, -1, (LPSTR)lParam, wParam, NULL, NULL);
1114         return 0;
1115
1116     case MCIWNDM_GETFILENAMEW:
1117         TRACE("MCIWNDM_GETFILENAMEW: %s\n", debugstr_w(mwi->lpName));
1118         if (mwi->lpName)
1119             lstrcpynW((LPWSTR)lParam, mwi->lpName, wParam);
1120         return 0;
1121
1122     case MCIWNDM_GETTIMEFORMATA:
1123     case MCIWNDM_GETTIMEFORMATW:
1124         {
1125             MCI_STATUS_PARMS mci_status;
1126
1127             TRACE("MCIWNDM_GETTIMEFORMAT %08lx %08lx\n", wParam, lParam);
1128
1129             /* get format string if requested */
1130             if (wParam && lParam)
1131             {
1132                 if (wMsg == MCIWNDM_GETTIMEFORMATA)
1133                 {
1134                     char cmd[64];
1135
1136                     wsprintfA(cmd, "status %d time format", mwi->alias);
1137                     mwi->lasterror = mciSendStringA(cmd, (LPSTR)lParam, wParam, 0);
1138                     if (mwi->lasterror)
1139                         return 0;
1140                 }
1141                 else
1142                 {
1143                     WCHAR cmdW[64];
1144                     static const WCHAR formatW[] = {'s','t','a','t','u','s',' ','%','d',' ','t','i','m','e',' ','f','o','r','m','a','t',0};
1145
1146                     wsprintfW(cmdW, formatW, mwi->alias);
1147                     mwi->lasterror = mciSendStringW(cmdW, (LPWSTR)lParam, wParam, 0);
1148                     if (mwi->lasterror)
1149                         return 0;
1150                 }
1151             }
1152
1153             mci_status.dwItem = MCI_STATUS_TIME_FORMAT ;
1154             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_STATUS,
1155                                              MCI_STATUS_ITEM,
1156                                              (DWORD_PTR)&mci_status);
1157             if (mwi->lasterror)
1158                 return 0;
1159
1160             return mci_status.dwReturn;
1161         }
1162
1163     case MCIWNDM_SETTIMEFORMATA:
1164         {
1165             UNICODE_STRING stringW;
1166
1167             TRACE("MCIWNDM_SETTIMEFORMATA %s\n", debugstr_a((LPSTR)lParam));
1168
1169             RtlCreateUnicodeStringFromAsciiz(&stringW, (LPCSTR)lParam);
1170             lParam = (LPARAM)stringW.Buffer;
1171         }
1172         /* fall through */
1173     case MCIWNDM_SETTIMEFORMATW:
1174         {
1175             static const WCHAR formatW[] = {'s','e','t',' ','%','d',' ','t','i','m','e',' ','f','o','r','m','a','t',' ',0};
1176             WCHAR *cmdW;
1177
1178             TRACE("MCIWNDM_SETTIMEFORMATW %s\n", debugstr_w((LPWSTR)lParam));
1179
1180             if (mwi->mci)
1181             {
1182                 cmdW = HeapAlloc(GetProcessHeap(), 0, (lstrlenW((LPCWSTR)lParam) + 64) * sizeof(WCHAR));
1183                 wsprintfW(cmdW, formatW, mwi->alias);
1184                 lstrcatW(cmdW, (WCHAR *)lParam);
1185
1186                 mwi->lasterror = mciSendStringW(cmdW, NULL, 0, 0);
1187
1188                 /* fix the range tracking according to the new time format */
1189                 if (!mwi->lasterror)
1190                     SendDlgItemMessageW(hWnd, CTL_TRACKBAR, TBM_SETRANGEMAX, 1,
1191                                         SendMessageW(hWnd, MCIWNDM_GETLENGTH, 0, 0));
1192
1193                 HeapFree(GetProcessHeap(), 0, cmdW);
1194             }
1195
1196             if (wMsg == MCIWNDM_SETTIMEFORMATA)
1197                 HeapFree(GetProcessHeap(), 0, (void *)lParam);
1198
1199             return 0;
1200         }
1201
1202     case MCIWNDM_CAN_PLAY:
1203         TRACE("MCIWNDM_CAN_PLAY\n");
1204         if (mwi->mci)
1205             return mci_get_devcaps(mwi, MCI_GETDEVCAPS_CAN_PLAY);
1206         return 0;
1207
1208     case MCIWNDM_CAN_RECORD:
1209         TRACE("MCIWNDM_CAN_RECORD\n");
1210         if (mwi->mci)
1211             return mci_get_devcaps(mwi, MCI_GETDEVCAPS_CAN_RECORD);
1212         return 0;
1213
1214     case MCIWNDM_CAN_SAVE:
1215         TRACE("MCIWNDM_CAN_SAVE\n");
1216         if (mwi->mci)
1217             return mci_get_devcaps(mwi, MCI_GETDEVCAPS_CAN_SAVE);
1218         return 0;
1219
1220     case MCIWNDM_CAN_EJECT:
1221         TRACE("MCIWNDM_CAN_EJECT\n");
1222         if (mwi->mci)
1223             return mci_get_devcaps(mwi, MCI_GETDEVCAPS_CAN_EJECT);
1224         return 0;
1225
1226     case MCIWNDM_CAN_WINDOW:
1227         TRACE("MCIWNDM_CAN_WINDOW\n");
1228         switch (mwi->dev_type)
1229         {
1230         case MCI_DEVTYPE_ANIMATION:
1231         case MCI_DEVTYPE_DIGITAL_VIDEO:
1232         case MCI_DEVTYPE_OVERLAY:
1233             return 1;
1234         }
1235         return 0;
1236
1237     case MCIWNDM_CAN_CONFIG:
1238         TRACE("MCIWNDM_CAN_CONFIG\n");
1239         if (mwi->hdrv)
1240             return SendDriverMessage(mwi->hdrv, DRV_QUERYCONFIGURE, 0, 0);
1241         return 0;
1242
1243     case MCIWNDM_SETZOOM:
1244         TRACE("MCIWNDM_SETZOOM %ld\n", lParam);
1245         mwi->zoom = lParam;
1246
1247         if (mwi->mci && !(mwi->dwStyle & MCIWNDF_NOAUTOSIZEWINDOW))
1248         {
1249             RECT rc;
1250
1251             rc.left = rc.top = 0;
1252             rc.right = MulDiv(mwi->size.cx, mwi->zoom, 100);
1253             rc.bottom = MulDiv(mwi->size.cy, mwi->zoom, 100);
1254
1255             if (!(mwi->dwStyle & MCIWNDF_NOPLAYBAR))
1256                 rc.bottom += 32; /* add the height of the playbar */
1257             AdjustWindowRect(&rc, GetWindowLongW(hWnd, GWL_STYLE), FALSE);
1258             SetWindowPos(hWnd, 0, 0, 0, rc.right - rc.left, rc.bottom - rc.top,
1259                          SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
1260         }
1261         return 0;
1262
1263     case MCIWNDM_GETZOOM:
1264         TRACE("MCIWNDM_GETZOOM: %d\n", mwi->zoom);
1265         return mwi->zoom;
1266
1267     case MCIWNDM_EJECT:
1268         {
1269             MCI_SET_PARMS mci_set;
1270
1271             TRACE("MCIWNDM_EJECT\n");
1272
1273             mci_set.dwCallback = (DWORD_PTR)hWnd;
1274             mwi->lasterror = mciSendCommandW(mwi->mci, MCI_SET,
1275                                              MCI_SET_DOOR_OPEN | MCI_NOTIFY,
1276                                              (DWORD_PTR)&mci_set);
1277             MCIWND_notify_mode(mwi);
1278             MCIWND_UpdateState(mwi);
1279             return mwi->lasterror;
1280         }
1281
1282     case MCIWNDM_SETVOLUME:
1283     case MCIWNDM_GETVOLUME:
1284     case MCIWNDM_SETSPEED:
1285     case MCIWNDM_GETSPEED:
1286     case MCIWNDM_SETREPEAT:
1287     case MCIWNDM_GETREPEAT:
1288     case MCIWNDM_REALIZE:
1289     case MCIWNDM_GETPALETTE:
1290     case MCIWNDM_SETPALETTE:
1291     case MCIWNDM_NEWA:
1292     case MCIWNDM_NEWW:
1293     case MCIWNDM_PALETTEKICK:
1294     case MCIWNDM_OPENINTERFACE:
1295         FIXME("support for MCIWNDM_ message WM_USER+%d not implemented\n", wMsg - WM_USER);
1296         return 0;
1297
1298     case MCI_PLAY:
1299         {
1300             LRESULT end = SendMessageW(hWnd, MCIWNDM_GETEND, 0, 0);
1301             return SendMessageW(hWnd, MCIWNDM_PLAYTO, 0, end);
1302         }
1303
1304     case MCI_SEEK:
1305     case MCI_STEP:
1306         {
1307             MCI_SEEK_PARMS mci_seek; /* Layout is usable as MCI_XYZ_STEP_PARMS */
1308             DWORD flags = MCI_STEP == wMsg ? 0 :
1309                           MCIWND_START == lParam ? MCI_SEEK_TO_START :
1310                           MCIWND_END   == lParam ? MCI_SEEK_TO_END : MCI_TO;
1311
1312             mci_seek.dwTo = lParam;
1313             mwi->lasterror = mciSendCommandW(mwi->mci, wMsg,
1314                                              flags, (DWORD_PTR)&mci_seek);
1315             if (mwi->lasterror)
1316             {
1317                 MCIWND_notify_error(mwi);
1318                 return mwi->lasterror;
1319             }
1320             /* update window to reflect the state */
1321             else InvalidateRect(hWnd, NULL, TRUE);
1322             return 0;
1323         }
1324
1325     case MCI_CLOSE:
1326         {
1327             RECT rc;
1328             MCI_GENERIC_PARMS mci_generic;
1329
1330             if (mwi->hdrv)
1331             {
1332                 CloseDriver(mwi->hdrv, 0, 0);
1333                 mwi->hdrv = 0;
1334             }
1335
1336             if (mwi->mci)
1337             {
1338                 mci_generic.dwCallback = 0;
1339                 mwi->lasterror = mciSendCommandW(mwi->mci, MCI_CLOSE,
1340                                                  0, (DWORD_PTR)&mci_generic);
1341                 mwi->mci = 0;
1342             }
1343
1344             mwi->mode = MCI_MODE_NOT_READY;
1345             mwi->position = -1;
1346
1347             HeapFree(GetProcessHeap(), 0, mwi->lpName);
1348             mwi->lpName = NULL;
1349             MCIWND_UpdateState(mwi);
1350
1351             GetClientRect(hWnd, &rc);
1352             rc.bottom = rc.top;
1353             if (!(mwi->dwStyle & MCIWNDF_NOPLAYBAR))
1354                 rc.bottom += 32; /* add the height of the playbar */
1355             AdjustWindowRect(&rc, GetWindowLongW(hWnd, GWL_STYLE), FALSE);
1356             SetWindowPos(hWnd, 0, 0, 0, rc.right - rc.left,
1357                          rc.bottom - rc.top, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
1358
1359             MCIWND_notify_media(mwi);
1360             return 0;
1361         }
1362
1363     case MCI_PAUSE:
1364     case MCI_STOP:
1365     case MCI_RESUME:
1366         mci_generic_command(mwi, wMsg);
1367         return mwi->lasterror;
1368
1369     case MCI_CONFIGURE:
1370         if (mwi->hdrv)
1371             SendDriverMessage(mwi->hdrv, DRV_CONFIGURE, (LPARAM)hWnd, 0);
1372         return 0;
1373
1374     case MCI_BREAK:
1375     case MCI_CAPTURE:
1376     case MCI_COPY:
1377     case MCI_CUE:
1378     case MCI_CUT:
1379     case MCI_DELETE:
1380     case MCI_ESCAPE:
1381     case MCI_FREEZE:
1382     case MCI_GETDEVCAPS:
1383     /*case MCI_INDEX:*/
1384     case MCI_INFO:
1385     case MCI_LIST:
1386     case MCI_LOAD:
1387     /*case MCI_MARK:*/
1388     case MCI_MONITOR:
1389     case MCI_OPEN:
1390     case MCI_PASTE:
1391     case MCI_PUT:
1392     case MCI_QUALITY:
1393     case MCI_REALIZE:
1394     case MCI_RECORD:
1395     case MCI_RESERVE:
1396     case MCI_RESTORE:
1397     case MCI_SAVE:
1398     case MCI_SET:
1399     case MCI_SETAUDIO:
1400     /*case MCI_SETTIMECODE:*/
1401     /*case MCI_SETTUNER:*/
1402     case MCI_SETVIDEO:
1403     case MCI_SIGNAL:
1404     case MCI_SPIN:
1405     case MCI_STATUS:
1406     case MCI_SYSINFO:
1407     case MCI_UNDO:
1408     case MCI_UNFREEZE:
1409     case MCI_UPDATE:
1410     case MCI_WHERE:
1411     case MCI_WINDOW:
1412         FIXME("support for MCI_ command %04x not implemented\n", wMsg);
1413         return 0;
1414     }
1415
1416     if (wMsg >= WM_USER)
1417     {
1418         FIXME("support for MCIWNDM_ message WM_USER+%d not implemented\n", wMsg - WM_USER);
1419         return 0;
1420     }
1421
1422     if (GetWindowLongW(hWnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
1423         return DefMDIChildProcW(hWnd, wMsg, wParam, lParam);
1424
1425     return DefWindowProcW(hWnd, wMsg, wParam, lParam);
1426 }