dlls/quartz/window.c

   1 /*
   2  * Common implementation of IVideoWindow
   3  *
   4  * Copyright 2012 Aric Stewart, CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "quartz_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  24
  25 static const WCHAR class_name[] = L"wine_quartz_window";
  26
  27 static inline struct video_window *impl_from_IVideoWindow(IVideoWindow *iface)
  28 {
  29     return CONTAINING_RECORD(iface, struct video_window, IVideoWindow_iface);
  30 }
  31
  32 static LRESULT CALLBACK WndProcW(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
  33 {
  34     struct video_window *window = (struct video_window *)GetWindowLongPtrW(hwnd, 0);
  35
  36     if (!window)
  37         return DefWindowProcW(hwnd, message, wparam, lparam);
  38
  39     switch (message)
  40     {
  41     case WM_KEYDOWN:
  42     case WM_KEYUP:
  43     case WM_LBUTTONDBLCLK:
  44     case WM_LBUTTONDOWN:
  45     case WM_LBUTTONUP:
  46     case WM_MBUTTONDBLCLK:
  47     case WM_MBUTTONDOWN:
  48     case WM_MBUTTONUP:
  49     case WM_MOUSEACTIVATE:
  50     case WM_MOUSEMOVE:
  51     case WM_NCLBUTTONDBLCLK:
  52     case WM_NCLBUTTONDOWN:
  53     case WM_NCLBUTTONUP:
  54     case WM_NCMBUTTONDBLCLK:
  55     case WM_NCMBUTTONDOWN:
  56     case WM_NCMBUTTONUP:
  57     case WM_NCMOUSEMOVE:
  58     case WM_NCRBUTTONDBLCLK:
  59     case WM_NCRBUTTONDOWN:
  60     case WM_NCRBUTTONUP:
  61     case WM_RBUTTONDBLCLK:
  62     case WM_RBUTTONDOWN:
  63     case WM_RBUTTONUP:
  64         if (window->hwndDrain)
  65         {
  66             PostMessageW(window->hwndDrain, message, wparam, lparam);
  67             return 0;
  68         }
  69         break;
  70     case WM_SIZE:
  71         if (window->default_dst)
  72             GetClientRect(window->hwnd, &window->dst);
  73         break;
  74     }
  75
  76     return DefWindowProcW(hwnd, message, wparam, lparam);
  77 }
  78
  79 HRESULT video_window_create_window(struct video_window *window)
  80 {
  81     WNDCLASSW winclass = {0};
  82
  83     winclass.lpfnWndProc = WndProcW;
  84     winclass.cbWndExtra = sizeof(window);
  85     winclass.hbrBackground = GetStockObject(BLACK_BRUSH);
  86     winclass.lpszClassName = class_name;
  87     if (!RegisterClassW(&winclass) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
  88     {
  89         ERR("Unable to register window class: %u\n", GetLastError());
  90         return E_FAIL;
  91     }
  92
  93     if (!(window->hwnd = CreateWindowExW(0, class_name, L"ActiveMovie Window",
  94             WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
  95             CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  96             NULL, NULL, NULL, NULL)))
  97     {
  98         ERR("Unable to create window\n");
  99         return E_FAIL;
 100     }
 101
 102     SetWindowLongPtrW(window->hwnd, 0, (LONG_PTR)window);
 103
 104     return S_OK;
 105 }
 106
 107 HRESULT WINAPI BaseControlWindowImpl_QueryInterface(IVideoWindow *iface, REFIID iid, void **out)
 108 {
 109     struct video_window *window = impl_from_IVideoWindow(iface);
 110     return IUnknown_QueryInterface(window->pFilter->outer_unk, iid, out);
 111 }
 112
 113 ULONG WINAPI BaseControlWindowImpl_AddRef(IVideoWindow *iface)
 114 {
 115     struct video_window *window = impl_from_IVideoWindow(iface);
 116     return IUnknown_AddRef(window->pFilter->outer_unk);
 117 }
 118
 119 ULONG WINAPI BaseControlWindowImpl_Release(IVideoWindow *iface)
 120 {
 121     struct video_window *window = impl_from_IVideoWindow(iface);
 122     return IUnknown_Release(window->pFilter->outer_unk);
 123 }
 124
 125 HRESULT WINAPI BaseControlWindowImpl_GetTypeInfoCount(IVideoWindow *iface, UINT *count)
 126 {
 127     TRACE("iface %p, count %p.\n", iface, count);
 128     *count = 1;
 129     return S_OK;
 130 }
 131
 132 HRESULT WINAPI BaseControlWindowImpl_GetTypeInfo(IVideoWindow *iface, UINT index,
 133         LCID lcid, ITypeInfo **typeinfo)
 134 {
 135     TRACE("iface %p, index %u, lcid %#x, typeinfo %p.\n", iface, index, lcid, typeinfo);
 136     return strmbase_get_typeinfo(IVideoWindow_tid, typeinfo);
 137 }
 138
 139 HRESULT WINAPI BaseControlWindowImpl_GetIDsOfNames(IVideoWindow *iface, REFIID iid,
 140         LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
 141 {
 142     ITypeInfo *typeinfo;
 143     HRESULT hr;
 144
 145     TRACE("iface %p, iid %s, names %p, count %u, lcid %#x, ids %p.\n",
 146             iface, debugstr_guid(iid), names, count, lcid, ids);
 147
 148     if (SUCCEEDED(hr = strmbase_get_typeinfo(IVideoWindow_tid, &typeinfo)))
 149     {
 150         hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
 151         ITypeInfo_Release(typeinfo);
 152     }
 153     return hr;
 154 }
 155
 156 HRESULT WINAPI BaseControlWindowImpl_Invoke(IVideoWindow *iface, DISPID id, REFIID iid, LCID lcid,
 157         WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
 158 {
 159     ITypeInfo *typeinfo;
 160     HRESULT hr;
 161
 162     TRACE("iface %p, id %d, iid %s, lcid %#x, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
 163             iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
 164
 165     if (SUCCEEDED(hr = strmbase_get_typeinfo(IVideoWindow_tid, &typeinfo)))
 166     {
 167         hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
 168         ITypeInfo_Release(typeinfo);
 169     }
 170     return hr;
 171 }
 172
 173 HRESULT WINAPI BaseControlWindowImpl_put_Caption(IVideoWindow *iface, BSTR caption)
 174 {
 175     struct video_window *window = impl_from_IVideoWindow(iface);
 176
 177     TRACE("window %p, caption %s.\n", window, debugstr_w(caption));
 178
 179     if (!SetWindowTextW(window->hwnd, caption))
 180         return E_FAIL;
 181
 182     return S_OK;
 183 }
 184
 185 HRESULT WINAPI BaseControlWindowImpl_get_Caption(IVideoWindow *iface, BSTR *caption)
 186 {
 187     struct video_window *window = impl_from_IVideoWindow(iface);
 188     WCHAR *str;
 189     int len;
 190
 191     TRACE("window %p, caption %p.\n", window, caption);
 192
 193     *caption = NULL;
 194
 195     len = GetWindowTextLengthW(window->hwnd) + 1;
 196     if (!(str = heap_alloc(len * sizeof(WCHAR))))
 197         return E_OUTOFMEMORY;
 198
 199     GetWindowTextW(window->hwnd, str, len);
 200     *caption = SysAllocString(str);
 201     heap_free(str);
 202     return *caption ? S_OK : E_OUTOFMEMORY;
 203 }
 204
 205 HRESULT WINAPI BaseControlWindowImpl_put_WindowStyle(IVideoWindow *iface, LONG style)
 206 {
 207     struct video_window *window = impl_from_IVideoWindow(iface);
 208
 209     TRACE("window %p, style %#x.\n", window, style);
 210
 211     if (style & (WS_DISABLED|WS_HSCROLL|WS_MAXIMIZE|WS_MINIMIZE|WS_VSCROLL))
 212         return E_INVALIDARG;
 213
 214     SetWindowLongW(window->hwnd, GWL_STYLE, style);
 215     SetWindowPos(window->hwnd, 0, 0, 0, 0, 0,
 216             SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
 217     return S_OK;
 218 }
 219
 220 HRESULT WINAPI BaseControlWindowImpl_get_WindowStyle(IVideoWindow *iface, LONG *style)
 221 {
 222     struct video_window *window = impl_from_IVideoWindow(iface);
 223
 224     TRACE("window %p, style %p.\n", window, style);
 225
 226     *style = GetWindowLongW(window->hwnd, GWL_STYLE);
 227     return S_OK;
 228 }
 229
 230 HRESULT WINAPI BaseControlWindowImpl_put_WindowStyleEx(IVideoWindow *iface, LONG style)
 231 {
 232     struct video_window *window = impl_from_IVideoWindow(iface);
 233
 234     TRACE("window %p, style %#x.\n", window, style);
 235
 236     if (!SetWindowLongW(window->hwnd, GWL_EXSTYLE, style))
 237         return E_FAIL;
 238     return S_OK;
 239 }
 240
 241 HRESULT WINAPI BaseControlWindowImpl_get_WindowStyleEx(IVideoWindow *iface, LONG *style)
 242 {
 243     struct video_window *window = impl_from_IVideoWindow(iface);
 244
 245     TRACE("window %p, style %p.\n", window, style);
 246
 247     *style = GetWindowLongW(window->hwnd, GWL_EXSTYLE);
 248     return S_OK;
 249 }
 250
 251 HRESULT WINAPI BaseControlWindowImpl_put_AutoShow(IVideoWindow *iface, LONG AutoShow)
 252 {
 253     struct video_window *This = impl_from_IVideoWindow(iface);
 254
 255     TRACE("(%p/%p)->(%d)\n", This, iface, AutoShow);
 256
 257     This->AutoShow = AutoShow;
 258
 259     return S_OK;
 260 }
 261
 262 HRESULT WINAPI BaseControlWindowImpl_get_AutoShow(IVideoWindow *iface, LONG *AutoShow)
 263 {
 264     struct video_window *This = impl_from_IVideoWindow(iface);
 265
 266     TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
 267
 268     *AutoShow = This->AutoShow;
 269
 270     return S_OK;
 271 }
 272
 273 HRESULT WINAPI BaseControlWindowImpl_put_WindowState(IVideoWindow *iface, LONG state)
 274 {
 275     struct video_window *window = impl_from_IVideoWindow(iface);
 276
 277     TRACE("window %p, state %#x.\n", window, state);
 278
 279     ShowWindow(window->hwnd, state);
 280     return S_OK;
 281 }
 282
 283 HRESULT WINAPI BaseControlWindowImpl_get_WindowState(IVideoWindow *iface, LONG *state)
 284 {
 285     struct video_window *window = impl_from_IVideoWindow(iface);
 286     DWORD style;
 287
 288     TRACE("window %p, state %p.\n", window, state);
 289
 290     style = GetWindowLongPtrW(window->hwnd, GWL_STYLE);
 291     if (!(style & WS_VISIBLE))
 292         *state = SW_HIDE;
 293     else if (style & WS_MINIMIZE)
 294         *state = SW_MINIMIZE;
 295     else if (style & WS_MAXIMIZE)
 296         *state = SW_MAXIMIZE;
 297     else
 298         *state = SW_SHOW;
 299
 300     return S_OK;
 301 }
 302
 303 HRESULT WINAPI BaseControlWindowImpl_put_BackgroundPalette(IVideoWindow *iface, LONG BackgroundPalette)
 304 {
 305     struct video_window *This = impl_from_IVideoWindow(iface);
 306
 307     FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, BackgroundPalette);
 308
 309     return S_OK;
 310 }
 311
 312 HRESULT WINAPI BaseControlWindowImpl_get_BackgroundPalette(IVideoWindow *iface, LONG *pBackgroundPalette)
 313 {
 314     struct video_window *This = impl_from_IVideoWindow(iface);
 315
 316     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBackgroundPalette);
 317
 318     return S_OK;
 319 }
 320
 321 HRESULT WINAPI BaseControlWindowImpl_put_Visible(IVideoWindow *iface, LONG visible)
 322 {
 323     struct video_window *window = impl_from_IVideoWindow(iface);
 324
 325     TRACE("window %p, visible %d.\n", window, visible);
 326
 327     ShowWindow(window->hwnd, visible ? SW_SHOW : SW_HIDE);
 328     return S_OK;
 329 }
 330
 331 HRESULT WINAPI BaseControlWindowImpl_get_Visible(IVideoWindow *iface, LONG *visible)
 332 {
 333     struct video_window *window = impl_from_IVideoWindow(iface);
 334
 335     TRACE("window %p, visible %p.\n", window, visible);
 336
 337     if (!visible)
 338         return E_POINTER;
 339
 340     *visible = IsWindowVisible(window->hwnd) ? OATRUE : OAFALSE;
 341     return S_OK;
 342 }
 343
 344 HRESULT WINAPI BaseControlWindowImpl_put_Left(IVideoWindow *iface, LONG left)
 345 {
 346     struct video_window *window = impl_from_IVideoWindow(iface);
 347     RECT rect;
 348
 349     TRACE("window %p, left %d.\n", window, left);
 350
 351     GetWindowRect(window->hwnd, &rect);
 352     if (!SetWindowPos(window->hwnd, NULL, left, rect.top, 0, 0,
 353             SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE))
 354         return E_FAIL;
 355
 356     return S_OK;
 357 }
 358
 359 HRESULT WINAPI BaseControlWindowImpl_get_Left(IVideoWindow *iface, LONG *left)
 360 {
 361     struct video_window *window = impl_from_IVideoWindow(iface);
 362     RECT rect;
 363
 364     TRACE("window %p, left %p.\n", window, left);
 365
 366     GetWindowRect(window->hwnd, &rect);
 367     *left = rect.left;
 368     return S_OK;
 369 }
 370
 371 HRESULT WINAPI BaseControlWindowImpl_put_Width(IVideoWindow *iface, LONG width)
 372 {
 373     struct video_window *window = impl_from_IVideoWindow(iface);
 374     RECT rect;
 375
 376     TRACE("window %p, width %d.\n", window, width);
 377
 378     GetWindowRect(window->hwnd, &rect);
 379     if (!SetWindowPos(window->hwnd, NULL, 0, 0, width, rect.bottom - rect.top,
 380             SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE))
 381         return E_FAIL;
 382
 383     return S_OK;
 384 }
 385
 386 HRESULT WINAPI BaseControlWindowImpl_get_Width(IVideoWindow *iface, LONG *width)
 387 {
 388     struct video_window *window = impl_from_IVideoWindow(iface);
 389     RECT rect;
 390
 391     TRACE("window %p, width %p.\n", window, width);
 392
 393     GetWindowRect(window->hwnd, &rect);
 394     *width = rect.right - rect.left;
 395     return S_OK;
 396 }
 397
 398 HRESULT WINAPI BaseControlWindowImpl_put_Top(IVideoWindow *iface, LONG top)
 399 {
 400     struct video_window *window = impl_from_IVideoWindow(iface);
 401     RECT rect;
 402
 403     TRACE("window %p, top %d.\n", window, top);
 404
 405     GetWindowRect(window->hwnd, &rect);
 406     if (!SetWindowPos(window->hwnd, NULL, rect.left, top, 0, 0,
 407             SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE))
 408         return E_FAIL;
 409
 410     return S_OK;
 411 }
 412
 413 HRESULT WINAPI BaseControlWindowImpl_get_Top(IVideoWindow *iface, LONG *top)
 414 {
 415     struct video_window *window = impl_from_IVideoWindow(iface);
 416     RECT rect;
 417
 418     TRACE("window %p, top %p.\n", window, top);
 419
 420     GetWindowRect(window->hwnd, &rect);
 421     *top = rect.top;
 422     return S_OK;
 423 }
 424
 425 HRESULT WINAPI BaseControlWindowImpl_put_Height(IVideoWindow *iface, LONG height)
 426 {
 427     struct video_window *window = impl_from_IVideoWindow(iface);
 428     RECT rect;
 429
 430     TRACE("window %p, height %d.\n", window, height);
 431
 432     GetWindowRect(window->hwnd, &rect);
 433     if (!SetWindowPos(window->hwnd, NULL, 0, 0, rect.right - rect.left,
 434             height, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE))
 435         return E_FAIL;
 436
 437     return S_OK;
 438 }
 439
 440 HRESULT WINAPI BaseControlWindowImpl_get_Height(IVideoWindow *iface, LONG *height)
 441 {
 442     struct video_window *window = impl_from_IVideoWindow(iface);
 443     RECT rect;
 444
 445     TRACE("window %p, height %p.\n", window, height);
 446
 447     GetWindowRect(window->hwnd, &rect);
 448     *height = rect.bottom - rect.top;
 449     return S_OK;
 450 }
 451
 452 HRESULT WINAPI BaseControlWindowImpl_put_Owner(IVideoWindow *iface, OAHWND owner)
 453 {
 454     struct video_window *window = impl_from_IVideoWindow(iface);
 455     HWND hwnd = window->hwnd;
 456
 457     TRACE("window %p, owner %#lx.\n", window, owner);
 458
 459     /* Make sure we are marked as WS_CHILD before reparenting ourselves, so that
 460      * we do not steal focus. LEGO Island depends on this. */
 461
 462     window->hwndOwner = (HWND)owner;
 463     if (owner)
 464         SetWindowLongPtrW(hwnd, GWL_STYLE, GetWindowLongPtrW(hwnd, GWL_STYLE) | WS_CHILD);
 465     else
 466         SetWindowLongPtrW(hwnd, GWL_STYLE, GetWindowLongPtrW(hwnd, GWL_STYLE) & ~WS_CHILD);
 467     SetParent(hwnd, (HWND)owner);
 468
 469     return S_OK;
 470 }
 471
 472 HRESULT WINAPI BaseControlWindowImpl_get_Owner(IVideoWindow *iface, OAHWND *Owner)
 473 {
 474     struct video_window *This = impl_from_IVideoWindow(iface);
 475
 476     TRACE("(%p/%p)->(%p)\n", This, iface, Owner);
 477
 478     *(HWND*)Owner = This->hwndOwner;
 479
 480     return S_OK;
 481 }
 482
 483 HRESULT WINAPI BaseControlWindowImpl_put_MessageDrain(IVideoWindow *iface, OAHWND Drain)
 484 {
 485     struct video_window *This = impl_from_IVideoWindow(iface);
 486
 487     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Drain);
 488
 489     This->hwndDrain = (HWND)Drain;
 490
 491     return S_OK;
 492 }
 493
 494 HRESULT WINAPI BaseControlWindowImpl_get_MessageDrain(IVideoWindow *iface, OAHWND *Drain)
 495 {
 496     struct video_window *This = impl_from_IVideoWindow(iface);
 497
 498     TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
 499
 500     *Drain = (OAHWND)This->hwndDrain;
 501
 502     return S_OK;
 503 }
 504
 505 HRESULT WINAPI BaseControlWindowImpl_get_BorderColor(IVideoWindow *iface, LONG *Color)
 506 {
 507     struct video_window *This = impl_from_IVideoWindow(iface);
 508
 509     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, Color);
 510
 511     return S_OK;
 512 }
 513
 514 HRESULT WINAPI BaseControlWindowImpl_put_BorderColor(IVideoWindow *iface, LONG Color)
 515 {
 516     struct video_window *This = impl_from_IVideoWindow(iface);
 517
 518     FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, Color);
 519
 520     return S_OK;
 521 }
 522
 523 HRESULT WINAPI BaseControlWindowImpl_get_FullScreenMode(IVideoWindow *iface, LONG *FullScreenMode)
 524 {
 525     TRACE("(%p)->(%p)\n", iface, FullScreenMode);
 526
 527     return E_NOTIMPL;
 528 }
 529
 530 HRESULT WINAPI BaseControlWindowImpl_put_FullScreenMode(IVideoWindow *iface, LONG FullScreenMode)
 531 {
 532     TRACE("(%p)->(%d)\n", iface, FullScreenMode);
 533     return E_NOTIMPL;
 534 }
 535
 536 HRESULT WINAPI BaseControlWindowImpl_SetWindowForeground(IVideoWindow *iface, LONG focus)
 537 {
 538     struct video_window *window = impl_from_IVideoWindow(iface);
 539     UINT flags = SWP_NOMOVE | SWP_NOSIZE;
 540
 541     TRACE("window %p, focus %d.\n", window, focus);
 542
 543     if (focus != OAFALSE && focus != OATRUE)
 544         return E_INVALIDARG;
 545
 546     if (!window->pPin->peer)
 547         return VFW_E_NOT_CONNECTED;
 548
 549     if (!focus)
 550         flags |= SWP_NOACTIVATE;
 551     SetWindowPos(window->hwnd, HWND_TOP, 0, 0, 0, 0, flags);
 552
 553     return S_OK;
 554 }
 555
 556 HRESULT WINAPI BaseControlWindowImpl_SetWindowPosition(IVideoWindow *iface,
 557         LONG left, LONG top, LONG width, LONG height)
 558 {
 559     struct video_window *window = impl_from_IVideoWindow(iface);
 560
 561     TRACE("window %p, left %d, top %d, width %d, height %d.\n", window, left, top, width, height);
 562
 563     if (!SetWindowPos(window->hwnd, NULL, left, top, width, height, SWP_NOACTIVATE | SWP_NOZORDER))
 564         return E_FAIL;
 565     return S_OK;
 566 }
 567
 568 HRESULT WINAPI BaseControlWindowImpl_GetWindowPosition(IVideoWindow *iface,
 569         LONG *left, LONG *top, LONG *width, LONG *height)
 570 {
 571     struct video_window *window = impl_from_IVideoWindow(iface);
 572     RECT rect;
 573
 574     TRACE("window %p, left %p, top %p, width %p, height %p.\n", window, left, top, width, height);
 575
 576     GetWindowRect(window->hwnd, &rect);
 577     *left = rect.left;
 578     *top = rect.top;
 579     *width = rect.right - rect.left;
 580     *height = rect.bottom - rect.top;
 581     return S_OK;
 582 }
 583
 584 HRESULT WINAPI BaseControlWindowImpl_NotifyOwnerMessage(IVideoWindow *iface,
 585         OAHWND hwnd, LONG message, LONG_PTR wparam, LONG_PTR lparam)
 586 {
 587     struct video_window *window = impl_from_IVideoWindow(iface);
 588
 589     TRACE("window %p, hwnd %#lx, message %#x, wparam %#lx, lparam %#lx.\n",
 590             window, hwnd, message, wparam, lparam);
 591
 592     /* That these messages are forwarded, and no others, is stated by the
 593      * DirectX documentation, and supported by manual testing. */
 594     switch (message)
 595     {
 596     case WM_ACTIVATEAPP:
 597     case WM_DEVMODECHANGE:
 598     case WM_DISPLAYCHANGE:
 599     case WM_PALETTECHANGED:
 600     case WM_PALETTEISCHANGING:
 601     case WM_QUERYNEWPALETTE:
 602     case WM_SYSCOLORCHANGE:
 603         SendMessageW(window->hwnd, message, wparam, lparam);
 604         break;
 605     }
 606
 607     return S_OK;
 608 }
 609
 610 HRESULT WINAPI BaseControlWindowImpl_GetMinIdealImageSize(IVideoWindow *iface, LONG *width, LONG *height)
 611 {
 612     struct video_window *window = impl_from_IVideoWindow(iface);
 613     RECT rect;
 614
 615     TRACE("window %p, width %p, height %p.\n", window, width, height);
 616
 617     rect = window->ops->get_default_rect(window);
 618     *width = rect.right - rect.left;
 619     *height = rect.bottom - rect.top;
 620     return S_OK;
 621 }
 622
 623 HRESULT WINAPI BaseControlWindowImpl_GetMaxIdealImageSize(IVideoWindow *iface, LONG *width, LONG *height)
 624 {
 625     struct video_window *window = impl_from_IVideoWindow(iface);
 626     RECT rect;
 627
 628     TRACE("window %p, width %p, height %p.\n", window, width, height);
 629
 630     rect = window->ops->get_default_rect(window);
 631     *width = rect.right - rect.left;
 632     *height = rect.bottom - rect.top;
 633     return S_OK;
 634 }
 635
 636 HRESULT WINAPI BaseControlWindowImpl_GetRestorePosition(IVideoWindow *iface, LONG *pLeft, LONG *pTop, LONG *pWidth, LONG *pHeight)
 637 {
 638     struct video_window *This = impl_from_IVideoWindow(iface);
 639
 640     FIXME("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
 641
 642     return S_OK;
 643 }
 644
 645 HRESULT WINAPI BaseControlWindowImpl_HideCursor(IVideoWindow *iface, LONG HideCursor)
 646 {
 647     struct video_window *This = impl_from_IVideoWindow(iface);
 648
 649     FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, HideCursor);
 650
 651     return S_OK;
 652 }
 653
 654 HRESULT WINAPI BaseControlWindowImpl_IsCursorHidden(IVideoWindow *iface, LONG *CursorHidden)
 655 {
 656     struct video_window *This = impl_from_IVideoWindow(iface);
 657
 658     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, CursorHidden);
 659
 660     return S_OK;
 661 }
 662
 663 static inline struct video_window *impl_from_IBasicVideo(IBasicVideo *iface)
 664 {
 665     return CONTAINING_RECORD(iface, struct video_window, IBasicVideo_iface);
 666 }
 667
 668 static HRESULT WINAPI basic_video_QueryInterface(IBasicVideo *iface, REFIID iid, void **out)
 669 {
 670     struct video_window *window = impl_from_IBasicVideo(iface);
 671     return IUnknown_QueryInterface(window->pFilter->outer_unk, iid, out);
 672 }
 673
 674 static ULONG WINAPI basic_video_AddRef(IBasicVideo *iface)
 675 {
 676     struct video_window *window = impl_from_IBasicVideo(iface);
 677     return IUnknown_AddRef(window->pFilter->outer_unk);
 678 }
 679
 680 static ULONG WINAPI basic_video_Release(IBasicVideo *iface)
 681 {
 682     struct video_window *window = impl_from_IBasicVideo(iface);
 683     return IUnknown_Release(window->pFilter->outer_unk);
 684 }
 685
 686 static HRESULT WINAPI basic_video_GetTypeInfoCount(IBasicVideo *iface, UINT *count)
 687 {
 688     TRACE("iface %p, count %p.\n", iface, count);
 689     *count = 1;
 690     return S_OK;
 691 }
 692
 693 static HRESULT WINAPI basic_video_GetTypeInfo(IBasicVideo *iface, UINT index,
 694         LCID lcid, ITypeInfo **typeinfo)
 695 {
 696     TRACE("iface %p, index %u, lcid %#x, typeinfo %p.\n", iface, index, lcid, typeinfo);
 697     return strmbase_get_typeinfo(IBasicVideo_tid, typeinfo);
 698 }
 699
 700 static HRESULT WINAPI basic_video_GetIDsOfNames(IBasicVideo *iface, REFIID iid,
 701         LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
 702 {
 703     ITypeInfo *typeinfo;
 704     HRESULT hr;
 705
 706     TRACE("iface %p, iid %s, names %p, count %u, lcid %#x, ids %p.\n",
 707             iface, debugstr_guid(iid), names, count, lcid, ids);
 708
 709     if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicVideo_tid, &typeinfo)))
 710     {
 711         hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
 712         ITypeInfo_Release(typeinfo);
 713     }
 714     return hr;
 715 }
 716
 717 static HRESULT WINAPI basic_video_Invoke(IBasicVideo *iface, DISPID id, REFIID iid, LCID lcid,
 718         WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
 719 {
 720     ITypeInfo *typeinfo;
 721     HRESULT hr;
 722
 723     TRACE("iface %p, id %d, iid %s, lcid %#x, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
 724             iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
 725
 726     if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicVideo_tid, &typeinfo)))
 727     {
 728         hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
 729         ITypeInfo_Release(typeinfo);
 730     }
 731     return hr;
 732 }
 733
 734 static const VIDEOINFOHEADER *get_video_format(struct video_window *window)
 735 {
 736     /* Members of VIDEOINFOHEADER up to bmiHeader are identical to those of
 737      * VIDEOINFOHEADER2. */
 738     return (const VIDEOINFOHEADER *)window->pPin->mt.pbFormat;
 739 }
 740
 741 static const BITMAPINFOHEADER *get_bitmap_header(struct video_window *window)
 742 {
 743     const AM_MEDIA_TYPE *mt = &window->pPin->mt;
 744     if (IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo))
 745         return &((VIDEOINFOHEADER *)mt->pbFormat)->bmiHeader;
 746     else
 747         return &((VIDEOINFOHEADER2 *)mt->pbFormat)->bmiHeader;
 748 }
 749
 750 static HRESULT WINAPI basic_video_get_AvgTimePerFrame(IBasicVideo *iface, REFTIME *reftime)
 751 {
 752     struct video_window *window = impl_from_IBasicVideo(iface);
 753
 754     if (!reftime)
 755         return E_POINTER;
 756     if (!window->pPin->peer)
 757         return VFW_E_NOT_CONNECTED;
 758
 759     TRACE("window %p, reftime %p.\n", window, reftime);
 760
 761     *reftime = (double)get_video_format(window)->AvgTimePerFrame / 1e7;
 762     return S_OK;
 763 }
 764
 765 static HRESULT WINAPI basic_video_get_BitRate(IBasicVideo *iface, LONG *rate)
 766 {
 767     struct video_window *window = impl_from_IBasicVideo(iface);
 768
 769     TRACE("window %p, rate %p.\n", window, rate);
 770
 771     if (!rate)
 772         return E_POINTER;
 773     if (!window->pPin->peer)
 774         return VFW_E_NOT_CONNECTED;
 775
 776     *rate = get_video_format(window)->dwBitRate;
 777     return S_OK;
 778 }
 779
 780 static HRESULT WINAPI basic_video_get_BitErrorRate(IBasicVideo *iface, LONG *rate)
 781 {
 782     struct video_window *window = impl_from_IBasicVideo(iface);
 783
 784     TRACE("window %p, rate %p.\n", window, rate);
 785
 786     if (!rate)
 787         return E_POINTER;
 788     if (!window->pPin->peer)
 789         return VFW_E_NOT_CONNECTED;
 790
 791     *rate = get_video_format(window)->dwBitErrorRate;
 792     return S_OK;
 793 }
 794
 795 static HRESULT WINAPI basic_video_get_VideoWidth(IBasicVideo *iface, LONG *width)
 796 {
 797     struct video_window *window = impl_from_IBasicVideo(iface);
 798
 799     TRACE("window %p, width %p.\n", window, width);
 800
 801     if (!width)
 802         return E_POINTER;
 803
 804     *width = get_bitmap_header(window)->biWidth;
 805
 806     return S_OK;
 807 }
 808
 809 static HRESULT WINAPI basic_video_get_VideoHeight(IBasicVideo *iface, LONG *height)
 810 {
 811     struct video_window *window = impl_from_IBasicVideo(iface);
 812
 813     TRACE("window %p, height %p.\n", window, height);
 814
 815     if (!height)
 816         return E_POINTER;
 817
 818     *height = abs(get_bitmap_header(window)->biHeight);
 819
 820     return S_OK;
 821 }
 822
 823 static HRESULT WINAPI basic_video_put_SourceLeft(IBasicVideo *iface, LONG left)
 824 {
 825     struct video_window *window = impl_from_IBasicVideo(iface);
 826
 827     TRACE("window %p, left %d.\n", window, left);
 828
 829     if (left < 0 || window->src.right + left - window->src.left > get_bitmap_header(window)->biWidth)
 830         return E_INVALIDARG;
 831
 832     OffsetRect(&window->src, left - window->src.left, 0);
 833     return S_OK;
 834 }
 835
 836 static HRESULT WINAPI basic_video_get_SourceLeft(IBasicVideo *iface, LONG *left)
 837 {
 838     struct video_window *window = impl_from_IBasicVideo(iface);
 839
 840     TRACE("window %p, left %p.\n", window, left);
 841
 842     if (!left)
 843         return E_POINTER;
 844
 845     *left = window->src.left;
 846     return S_OK;
 847 }
 848
 849 static HRESULT WINAPI basic_video_put_SourceWidth(IBasicVideo *iface, LONG width)
 850 {
 851     struct video_window *window = impl_from_IBasicVideo(iface);
 852
 853     TRACE("window %p, width %d.\n", window, width);
 854
 855     if (width <= 0 || window->src.left + width > get_bitmap_header(window)->biWidth)
 856         return E_INVALIDARG;
 857
 858     window->src.right = window->src.left + width;
 859     return S_OK;
 860 }
 861
 862 static HRESULT WINAPI basic_video_get_SourceWidth(IBasicVideo *iface, LONG *width)
 863 {
 864     struct video_window *window = impl_from_IBasicVideo(iface);
 865
 866     TRACE("window %p, width %p.\n", window, width);
 867
 868     if (!width)
 869         return E_POINTER;
 870
 871     *width = window->src.right - window->src.left;
 872     return S_OK;
 873 }
 874
 875 static HRESULT WINAPI basic_video_put_SourceTop(IBasicVideo *iface, LONG top)
 876 {
 877     struct video_window *window = impl_from_IBasicVideo(iface);
 878
 879     TRACE("window %p, top %d.\n", window, top);
 880
 881     if (top < 0 || window->src.bottom + top - window->src.top > get_bitmap_header(window)->biHeight)
 882         return E_INVALIDARG;
 883
 884     OffsetRect(&window->src, 0, top - window->src.top);
 885     return S_OK;
 886 }
 887
 888 static HRESULT WINAPI basic_video_get_SourceTop(IBasicVideo *iface, LONG *top)
 889 {
 890     struct video_window *window = impl_from_IBasicVideo(iface);
 891
 892     TRACE("window %p, top %p.\n", window, top);
 893
 894     if (!top)
 895         return E_POINTER;
 896
 897     *top = window->src.top;
 898     return S_OK;
 899 }
 900
 901 static HRESULT WINAPI basic_video_put_SourceHeight(IBasicVideo *iface, LONG height)
 902 {
 903     struct video_window *window = impl_from_IBasicVideo(iface);
 904
 905     TRACE("window %p, height %d.\n", window, height);
 906
 907     if (height <= 0 || window->src.top + height > get_bitmap_header(window)->biHeight)
 908         return E_INVALIDARG;
 909
 910     window->src.bottom = window->src.top + height;
 911     return S_OK;
 912 }
 913
 914 static HRESULT WINAPI basic_video_get_SourceHeight(IBasicVideo *iface, LONG *height)
 915 {
 916     struct video_window *window = impl_from_IBasicVideo(iface);
 917
 918     TRACE("window %p, height %p\n", window, height);
 919
 920     if (!height)
 921         return E_POINTER;
 922
 923     *height = window->src.bottom - window->src.top;
 924     return S_OK;
 925 }
 926
 927 static HRESULT WINAPI basic_video_put_DestinationLeft(IBasicVideo *iface, LONG left)
 928 {
 929     struct video_window *window = impl_from_IBasicVideo(iface);
 930
 931     TRACE("window %p, left %d.\n", window, left);
 932
 933     window->default_dst = FALSE;
 934     OffsetRect(&window->dst, left - window->dst.left, 0);
 935     return S_OK;
 936 }
 937
 938 static HRESULT WINAPI basic_video_get_DestinationLeft(IBasicVideo *iface, LONG *left)
 939 {
 940     struct video_window *window = impl_from_IBasicVideo(iface);
 941
 942     TRACE("window %p, left %p.\n", window, left);
 943
 944     if (!left)
 945         return E_POINTER;
 946
 947     *left = window->dst.left;
 948     return S_OK;
 949 }
 950
 951 static HRESULT WINAPI basic_video_put_DestinationWidth(IBasicVideo *iface, LONG width)
 952 {
 953     struct video_window *window = impl_from_IBasicVideo(iface);
 954
 955     TRACE("window %p, width %d.\n", window, width);
 956
 957     if (width <= 0)
 958         return E_INVALIDARG;
 959
 960     window->default_dst = FALSE;
 961     window->dst.right = window->dst.left + width;
 962     return S_OK;
 963 }
 964
 965 static HRESULT WINAPI basic_video_get_DestinationWidth(IBasicVideo *iface, LONG *width)
 966 {
 967     struct video_window *window = impl_from_IBasicVideo(iface);
 968
 969     TRACE("window %p, width %p.\n", window, width);
 970
 971     if (!width)
 972         return E_POINTER;
 973
 974     *width = window->dst.right - window->dst.left;
 975     return S_OK;
 976 }
 977
 978 static HRESULT WINAPI basic_video_put_DestinationTop(IBasicVideo *iface, LONG top)
 979 {
 980     struct video_window *window = impl_from_IBasicVideo(iface);
 981
 982     TRACE("window %p, top %d.\n", window, top);
 983
 984     window->default_dst = FALSE;
 985     OffsetRect(&window->dst, 0, top - window->dst.top);
 986     return S_OK;
 987 }
 988
 989 static HRESULT WINAPI basic_video_get_DestinationTop(IBasicVideo *iface, LONG *top)
 990 {
 991     struct video_window *window = impl_from_IBasicVideo(iface);
 992
 993     TRACE("window %p, top %p.\n", window, top);
 994
 995     if (!top)
 996         return E_POINTER;
 997
 998     *top = window->dst.top;
 999     return S_OK;
1000 }
1001
1002 static HRESULT WINAPI basic_video_put_DestinationHeight(IBasicVideo *iface, LONG height)
1003 {
1004     struct video_window *window = impl_from_IBasicVideo(iface);
1005
1006     TRACE("window %p, height %d.\n", window, height);
1007
1008     if (height <= 0)
1009         return E_INVALIDARG;
1010
1011     window->default_dst = FALSE;
1012     window->dst.bottom = window->dst.top + height;
1013     return S_OK;
1014 }
1015
1016 static HRESULT WINAPI basic_video_get_DestinationHeight(IBasicVideo *iface, LONG *height)
1017 {
1018     struct video_window *window = impl_from_IBasicVideo(iface);
1019
1020     TRACE("window %p, height %p.\n", window, height);
1021
1022     if (!height)
1023         return E_POINTER;
1024
1025     *height = window->dst.bottom - window->dst.top;
1026     return S_OK;
1027 }
1028
1029 static HRESULT WINAPI basic_video_SetSourcePosition(IBasicVideo *iface,
1030         LONG left, LONG top, LONG width, LONG height)
1031 {
1032     struct video_window *window = impl_from_IBasicVideo(iface);
1033     const BITMAPINFOHEADER *bitmap_header = get_bitmap_header(window);
1034
1035     TRACE("window %p, left %d, top %d, width %d, height %d.\n", window, left, top, width, height);
1036
1037     if (left < 0 || left + width > bitmap_header->biWidth || width <= 0)
1038         return E_INVALIDARG;
1039     if (top < 0 || top + height > bitmap_header->biHeight || height <= 0)
1040         return E_INVALIDARG;
1041
1042     SetRect(&window->src, left, top, left + width, top + height);
1043     return S_OK;
1044 }
1045
1046 static HRESULT WINAPI basic_video_GetSourcePosition(IBasicVideo *iface,
1047         LONG *left, LONG *top, LONG *width, LONG *height)
1048 {
1049     struct video_window *window = impl_from_IBasicVideo(iface);
1050
1051     TRACE("window %p, left %p, top %p, width %p, height %p.\n", window, left, top, width, height);
1052
1053     if (!left || !top || !width || !height)
1054         return E_POINTER;
1055
1056     *left = window->src.left;
1057     *top = window->src.top;
1058     *width = window->src.right - window->src.left;
1059     *height = window->src.bottom - window->src.top;
1060     return S_OK;
1061 }
1062
1063 static HRESULT WINAPI basic_video_SetDefaultSourcePosition(IBasicVideo *iface)
1064 {
1065     struct video_window *window = impl_from_IBasicVideo(iface);
1066     const BITMAPINFOHEADER *bitmap_header = get_bitmap_header(window);
1067
1068     TRACE("window %p.\n", window);
1069
1070     SetRect(&window->src, 0, 0, bitmap_header->biWidth, bitmap_header->biHeight);
1071     return S_OK;
1072 }
1073
1074 static HRESULT WINAPI basic_video_SetDestinationPosition(IBasicVideo *iface,
1075         LONG left, LONG top, LONG width, LONG height)
1076 {
1077     struct video_window *window = impl_from_IBasicVideo(iface);
1078
1079     TRACE("window %p, left %d, top %d, width %d, height %d.\n", window, left, top, width, height);
1080
1081     if (width <= 0 || height <= 0)
1082         return E_INVALIDARG;
1083
1084     window->default_dst = FALSE;
1085     SetRect(&window->dst, left, top, left + width, top + height);
1086     return S_OK;
1087 }
1088
1089 static HRESULT WINAPI basic_video_GetDestinationPosition(IBasicVideo *iface,
1090         LONG *left, LONG *top, LONG *width, LONG *height)
1091 {
1092     struct video_window *window = impl_from_IBasicVideo(iface);
1093
1094     TRACE("window %p, left %p, top %p, width %p, height %p.\n", window, left, top, width, height);
1095
1096     if (!left || !top || !width || !height)
1097         return E_POINTER;
1098
1099     *left = window->dst.left;
1100     *top = window->dst.top;
1101     *width = window->dst.right - window->dst.left;
1102     *height = window->dst.bottom - window->dst.top;
1103     return S_OK;
1104 }
1105
1106 static HRESULT WINAPI basic_video_SetDefaultDestinationPosition(IBasicVideo *iface)
1107 {
1108     struct video_window *window = impl_from_IBasicVideo(iface);
1109
1110     TRACE("window %p.\n", window);
1111
1112     window->default_dst = TRUE;
1113     GetClientRect(window->hwnd, &window->dst);
1114     return S_OK;
1115 }
1116
1117 static HRESULT WINAPI basic_video_GetVideoSize(IBasicVideo *iface, LONG *width, LONG *height)
1118 {
1119     struct video_window *window = impl_from_IBasicVideo(iface);
1120     const BITMAPINFOHEADER *bitmap_header = get_bitmap_header(window);
1121
1122     TRACE("window %p, width %p, height %p.\n", window, width, height);
1123
1124     if (!width || !height)
1125         return E_POINTER;
1126
1127     *width = bitmap_header->biWidth;
1128     *height = bitmap_header->biHeight;
1129     return S_OK;
1130 }
1131
1132 static HRESULT WINAPI basic_video_GetVideoPaletteEntries(IBasicVideo *iface,
1133         LONG start, LONG count, LONG *ret_count, LONG *palette)
1134 {
1135     struct video_window *window = impl_from_IBasicVideo(iface);
1136
1137     FIXME("window %p, start %d, count %d, ret_count %p, palette %p, stub!\n",
1138             window, start, count, ret_count, palette);
1139
1140     if (!ret_count || !palette)
1141         return E_POINTER;
1142
1143     *ret_count = 0;
1144     return VFW_E_NO_PALETTE_AVAILABLE;
1145 }
1146
1147 static HRESULT WINAPI basic_video_GetCurrentImage(IBasicVideo *iface, LONG *size, LONG *image)
1148 {
1149     struct video_window *window = impl_from_IBasicVideo(iface);
1150
1151     TRACE("window %p, size %p, image %p.\n", window, size, image);
1152
1153     if (!size || !image)
1154         return E_POINTER;
1155
1156     return window->ops->get_current_image(window, size, image);
1157 }
1158
1159 static HRESULT WINAPI basic_video_IsUsingDefaultSource(IBasicVideo *iface)
1160 {
1161     struct video_window *window = impl_from_IBasicVideo(iface);
1162     const BITMAPINFOHEADER *bitmap_header = get_bitmap_header(window);
1163
1164     TRACE("window %p.\n", window);
1165
1166     if (!window->src.left && !window->src.top
1167             && window->src.right == bitmap_header->biWidth
1168             && window->src.bottom == bitmap_header->biHeight)
1169         return S_OK;
1170     return S_FALSE;
1171 }
1172
1173 static HRESULT WINAPI basic_video_IsUsingDefaultDestination(IBasicVideo *iface)
1174 {
1175     struct video_window *window = impl_from_IBasicVideo(iface);
1176
1177     TRACE("window %p.\n", window);
1178
1179     return window->default_dst ? S_OK : S_FALSE;
1180 }
1181
1182 static const IBasicVideoVtbl basic_video_vtbl =
1183 {
1184     basic_video_QueryInterface,
1185     basic_video_AddRef,
1186     basic_video_Release,
1187     basic_video_GetTypeInfoCount,
1188     basic_video_GetTypeInfo,
1189     basic_video_GetIDsOfNames,
1190     basic_video_Invoke,
1191     basic_video_get_AvgTimePerFrame,
1192     basic_video_get_BitRate,
1193     basic_video_get_BitErrorRate,
1194     basic_video_get_VideoWidth,
1195     basic_video_get_VideoHeight,
1196     basic_video_put_SourceLeft,
1197     basic_video_get_SourceLeft,
1198     basic_video_put_SourceWidth,
1199     basic_video_get_SourceWidth,
1200     basic_video_put_SourceTop,
1201     basic_video_get_SourceTop,
1202     basic_video_put_SourceHeight,
1203     basic_video_get_SourceHeight,
1204     basic_video_put_DestinationLeft,
1205     basic_video_get_DestinationLeft,
1206     basic_video_put_DestinationWidth,
1207     basic_video_get_DestinationWidth,
1208     basic_video_put_DestinationTop,
1209     basic_video_get_DestinationTop,
1210     basic_video_put_DestinationHeight,
1211     basic_video_get_DestinationHeight,
1212     basic_video_SetSourcePosition,
1213     basic_video_GetSourcePosition,
1214     basic_video_SetDefaultSourcePosition,
1215     basic_video_SetDestinationPosition,
1216     basic_video_GetDestinationPosition,
1217     basic_video_SetDefaultDestinationPosition,
1218     basic_video_GetVideoSize,
1219     basic_video_GetVideoPaletteEntries,
1220     basic_video_GetCurrentImage,
1221     basic_video_IsUsingDefaultSource,
1222     basic_video_IsUsingDefaultDestination
1223 };
1224
1225 void video_window_unregister_class(void)
1226 {
1227     if (!UnregisterClassW(class_name, NULL) && GetLastError() != ERROR_CLASS_DOES_NOT_EXIST)
1228         ERR("Failed to unregister class, error %u.\n", GetLastError());
1229 }
1230
1231 void video_window_init(struct video_window *window, const IVideoWindowVtbl *vtbl,
1232         struct strmbase_filter *owner, struct strmbase_pin *pin, const struct video_window_ops *ops)
1233 {
1234     memset(window, 0, sizeof(*window));
1235     window->ops = ops;
1236     window->IVideoWindow_iface.lpVtbl = vtbl;
1237     window->IBasicVideo_iface.lpVtbl = &basic_video_vtbl;
1238     window->default_dst = TRUE;
1239     window->AutoShow = OATRUE;
1240     window->pFilter = owner;
1241     window->pPin = pin;
1242 }
1243
1244 void video_window_cleanup(struct video_window *window)
1245 {
1246     if (window->hwnd)
1247     {
1248         /* Media Player Classic deadlocks if WM_PARENTNOTIFY is sent, so clear
1249          * the child style first. Just like Windows, we don't actually unparent
1250          * the window, to prevent extra focus events from being generated since
1251          * it would become top-level for a brief period before being destroyed. */
1252         SetWindowLongW(window->hwnd, GWL_STYLE, GetWindowLongW(window->hwnd, GWL_STYLE) & ~WS_CHILD);
1253
1254         SendMessageW(window->hwnd, WM_CLOSE, 0, 0);
1255         window->hwnd = NULL;
1256     }
1257 }