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