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