dlls/strmbase/window.c

   1 /*
   2  * Generic Implementation of strmbase window classes
   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 #define COBJMACROS
  22
  23 #include "dshow.h"
  24 #include "wine/debug.h"
  25 #include "wine/unicode.h"
  26 #include "wine/strmbase.h"
  27 #include "uuids.h"
  28 #include "vfwmsgs.h"
  29 #include <assert.h>
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(strmbase);
  32
  33 static inline BaseControlWindow *impl_from_IVideoWindow( IVideoWindow *iface)
  34 {
  35     return CONTAINING_RECORD(iface, BaseControlWindow, IVideoWindow_iface);
  36 }
  37
  38 static inline BaseControlWindow *impl_from_BaseWindow(BaseWindow *iface)
  39 {
  40     return CONTAINING_RECORD(iface, BaseControlWindow, baseWindow);
  41 }
  42
  43 static LRESULT CALLBACK WndProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  44 {
  45     BaseWindow* This = (BaseWindow*)GetWindowLongPtrW(hwnd, 0);
  46
  47     if (!This)
  48         return DefWindowProcW(hwnd, uMsg, wParam, lParam);
  49
  50     if (This->pFuncsTable->pfnOnReceiveMessage)
  51         return This->pFuncsTable->pfnOnReceiveMessage(This, hwnd, uMsg, wParam, lParam);
  52     else
  53         return BaseWindowImpl_OnReceiveMessage(This, hwnd, uMsg, wParam, lParam);
  54 }
  55
  56 LRESULT WINAPI BaseWindowImpl_OnReceiveMessage(BaseWindow *This, HWND hwnd, INT uMsg, WPARAM wParam, LPARAM lParam)
  57 {
  58     if (This->pFuncsTable->pfnPossiblyEatMessage && This->pFuncsTable->pfnPossiblyEatMessage(This, uMsg, wParam, lParam))
  59         return 0;
  60
  61     switch (uMsg)
  62     {
  63         case WM_SIZE:
  64             if (This->pFuncsTable->pfnOnSize)
  65                 return This->pFuncsTable->pfnOnSize(This, LOWORD(lParam), HIWORD(lParam));
  66             else
  67                 return BaseWindowImpl_OnSize(This, LOWORD(lParam), HIWORD(lParam));
  68     }
  69
  70     return DefWindowProcW(hwnd, uMsg, wParam, lParam);
  71 }
  72
  73 BOOL WINAPI BaseWindowImpl_OnSize(BaseWindow *This, LONG Width, LONG Height)
  74 {
  75     This->Width = Width;
  76     This->Height = Height;
  77     return TRUE;
  78 }
  79
  80 HRESULT WINAPI BaseWindow_Init(BaseWindow *pBaseWindow, const BaseWindowFuncTable* pFuncsTable)
  81 {
  82     if (!pFuncsTable)
  83         return E_INVALIDARG;
  84
  85     ZeroMemory(pBaseWindow,sizeof(BaseWindow));
  86     pBaseWindow->pFuncsTable = pFuncsTable;
  87
  88     return S_OK;
  89 }
  90
  91 HRESULT WINAPI BaseWindow_Destroy(BaseWindow *This)
  92 {
  93     if (This->hWnd)
  94         BaseWindowImpl_DoneWithWindow(This);
  95
  96     HeapFree(GetProcessHeap(), 0, This);
  97     return S_OK;
  98 }
  99
 100 HRESULT WINAPI BaseWindowImpl_PrepareWindow(BaseWindow *This)
 101 {
 102     WNDCLASSW winclass;
 103     static const WCHAR windownameW[] = { 'A','c','t','i','v','e','M','o','v','i','e',' ','W','i','n','d','o','w',0 };
 104
 105     This->pClassName = This->pFuncsTable->pfnGetClassWindowStyles(This, &This->ClassStyles, &This->WindowStyles, &This->WindowStylesEx);
 106
 107     winclass.style = This->ClassStyles;
 108     winclass.lpfnWndProc = WndProcW;
 109     winclass.cbClsExtra = 0;
 110     winclass.cbWndExtra = sizeof(BaseWindow*);
 111     winclass.hInstance = This->hInstance;
 112     winclass.hIcon = NULL;
 113     winclass.hCursor = NULL;
 114     winclass.hbrBackground = GetStockObject(BLACK_BRUSH);
 115     winclass.lpszMenuName = NULL;
 116     winclass.lpszClassName = This->pClassName;
 117     if (!RegisterClassW(&winclass) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
 118     {
 119         ERR("Unable to register window class: %u\n", GetLastError());
 120         return E_FAIL;
 121     }
 122
 123     This->hWnd = CreateWindowExW(This->WindowStylesEx,
 124                                  This->pClassName, windownameW,
 125                                  This->WindowStyles,
 126                                  CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 127                                  CW_USEDEFAULT, NULL, NULL, This->hInstance,
 128                                  NULL);
 129
 130     if (!This->hWnd)
 131     {
 132         ERR("Unable to create window\n");
 133         return E_FAIL;
 134     }
 135
 136     SetWindowLongPtrW(This->hWnd, 0, (LONG_PTR)This);
 137
 138     This->hDC = GetDC(This->hWnd);
 139
 140     return S_OK;
 141 }
 142
 143 HRESULT WINAPI BaseWindowImpl_DoneWithWindow(BaseWindow *This)
 144 {
 145     if (!This->hWnd)
 146         return S_OK;
 147
 148     if (This->hDC)
 149         ReleaseDC(This->hWnd, This->hDC);
 150     This->hDC = NULL;
 151
 152     DestroyWindow(This->hWnd);
 153     This->hWnd = NULL;
 154
 155     return S_OK;
 156 }
 157
 158 RECT WINAPI BaseWindowImpl_GetDefaultRect(BaseWindow *This)
 159 {
 160     static RECT defRect = {0, 0, 800, 600};
 161     return defRect;
 162 }
 163
 164 BOOL WINAPI BaseControlWindowImpl_PossiblyEatMessage(BaseWindow *This, UINT uMsg, WPARAM wParam, LPARAM lParam)
 165 {
 166     BaseControlWindow* pControlWindow = impl_from_BaseWindow(This);
 167
 168     if (pControlWindow->hwndDrain)
 169     {
 170         switch(uMsg)
 171         {
 172             case WM_KEYDOWN:
 173             case WM_KEYUP:
 174             case WM_LBUTTONDBLCLK:
 175             case WM_LBUTTONDOWN:
 176             case WM_LBUTTONUP:
 177             case WM_MBUTTONDBLCLK:
 178             case WM_MBUTTONDOWN:
 179             case WM_MBUTTONUP:
 180             case WM_MOUSEACTIVATE:
 181             case WM_MOUSEMOVE:
 182             case WM_NCLBUTTONDBLCLK:
 183             case WM_NCLBUTTONDOWN:
 184             case WM_NCLBUTTONUP:
 185             case WM_NCMBUTTONDBLCLK:
 186             case WM_NCMBUTTONDOWN:
 187             case WM_NCMBUTTONUP:
 188             case WM_NCMOUSEMOVE:
 189             case WM_NCRBUTTONDBLCLK:
 190             case WM_NCRBUTTONDOWN:
 191             case WM_NCRBUTTONUP:
 192             case WM_RBUTTONDBLCLK:
 193             case WM_RBUTTONDOWN:
 194             case WM_RBUTTONUP:
 195                 PostMessageW(pControlWindow->hwndDrain, uMsg, wParam, lParam);
 196                 return TRUE;
 197             default:
 198                 break;
 199         }
 200     }
 201     return FALSE;
 202 }
 203
 204 HRESULT WINAPI BaseControlWindow_Init(BaseControlWindow *pControlWindow, const IVideoWindowVtbl *lpVtbl, BaseFilter *owner, CRITICAL_SECTION *lock, BasePin* pPin,const BaseWindowFuncTable *pFuncsTable)
 205 {
 206     HRESULT hr;
 207
 208     hr = BaseWindow_Init(&pControlWindow->baseWindow, pFuncsTable);
 209     if (SUCCEEDED(hr))
 210     {
 211         BaseDispatch_Init(&pControlWindow->baseDispatch, &IID_IVideoWindow);
 212         pControlWindow->IVideoWindow_iface.lpVtbl = lpVtbl;
 213         pControlWindow->AutoShow = TRUE;
 214         pControlWindow->hwndDrain = NULL;
 215         pControlWindow->hwndOwner = NULL;
 216         pControlWindow->pFilter = owner;
 217         pControlWindow->pInterfaceLock = lock;
 218         pControlWindow->pPin = pPin;
 219     }
 220     return hr;
 221 }
 222
 223 HRESULT WINAPI BaseControlWindow_Destroy(BaseControlWindow *pControlWindow)
 224 {
 225     BaseWindowImpl_DoneWithWindow(&pControlWindow->baseWindow);
 226     return BaseDispatch_Destroy(&pControlWindow->baseDispatch);
 227 }
 228
 229 HRESULT WINAPI BaseControlWindowImpl_GetTypeInfoCount(IVideoWindow *iface, UINT *pctinfo)
 230 {
 231     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 232
 233     return BaseDispatchImpl_GetTypeInfoCount(&This->baseDispatch, pctinfo);
 234 }
 235
 236 HRESULT WINAPI BaseControlWindowImpl_GetTypeInfo(IVideoWindow *iface, UINT iTInfo, LCID lcid, ITypeInfo**ppTInfo)
 237 {
 238     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 239
 240     return BaseDispatchImpl_GetTypeInfo(&This->baseDispatch, &IID_NULL, iTInfo, lcid, ppTInfo);
 241 }
 242
 243 HRESULT WINAPI BaseControlWindowImpl_GetIDsOfNames(IVideoWindow *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 244  {
 245     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 246
 247     return BaseDispatchImpl_GetIDsOfNames(&This->baseDispatch, riid, rgszNames, cNames, lcid, rgDispId);
 248 }
 249
 250 HRESULT WINAPI BaseControlWindowImpl_Invoke(IVideoWindow *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo, UINT *puArgErr)
 251 {
 252     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 253     HRESULT hr = S_OK;
 254     ITypeInfo *pTypeInfo;
 255
 256     hr = BaseDispatchImpl_GetTypeInfo(&This->baseDispatch, riid, 1, lcid, &pTypeInfo);
 257     if (SUCCEEDED(hr))
 258     {
 259         hr = ITypeInfo_Invoke(pTypeInfo, &This->IVideoWindow_iface, dispIdMember, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
 260         ITypeInfo_Release(pTypeInfo);
 261     }
 262
 263     return hr;
 264 }
 265
 266 HRESULT WINAPI BaseControlWindowImpl_put_Caption(IVideoWindow *iface, BSTR strCaption)
 267 {
 268     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 269
 270     TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strCaption), strCaption);
 271
 272     if (!SetWindowTextW(This->baseWindow.hWnd, strCaption))
 273         return E_FAIL;
 274
 275     return S_OK;
 276 }
 277
 278 HRESULT WINAPI BaseControlWindowImpl_get_Caption(IVideoWindow *iface, BSTR *strCaption)
 279 {
 280     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 281
 282     TRACE("(%p/%p)->(%p)\n", This, iface, strCaption);
 283
 284     GetWindowTextW(This->baseWindow.hWnd, (LPWSTR)strCaption, 100);
 285
 286     return S_OK;
 287 }
 288
 289 HRESULT WINAPI BaseControlWindowImpl_put_WindowStyle(IVideoWindow *iface, LONG WindowStyle)
 290 {
 291     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 292     LONG old;
 293
 294     old = GetWindowLongW(This->baseWindow.hWnd, GWL_STYLE);
 295
 296     TRACE("(%p/%p)->(%x -> %x)\n", This, iface, old, WindowStyle);
 297
 298     if (WindowStyle & (WS_DISABLED|WS_HSCROLL|WS_ICONIC|WS_MAXIMIZE|WS_MINIMIZE|WS_VSCROLL))
 299         return E_INVALIDARG;
 300
 301     SetWindowLongW(This->baseWindow.hWnd, GWL_STYLE, WindowStyle);
 302     SetWindowPos(This->baseWindow.hWnd,0,0,0,0,0,SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOZORDER);
 303     This->baseWindow.WindowStyles = WindowStyle;
 304
 305     return S_OK;
 306 }
 307
 308 HRESULT WINAPI BaseControlWindowImpl_get_WindowStyle(IVideoWindow *iface, LONG *WindowStyle)
 309 {
 310     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 311
 312     TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyle);
 313
 314     *WindowStyle = This->baseWindow.WindowStyles;
 315
 316     return S_OK;
 317 }
 318
 319 HRESULT WINAPI BaseControlWindowImpl_put_WindowStyleEx(IVideoWindow *iface, LONG WindowStyleEx)
 320 {
 321     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 322
 323     TRACE("(%p/%p)->(%d)\n", This, iface, WindowStyleEx);
 324
 325     if (!SetWindowLongW(This->baseWindow.hWnd, GWL_EXSTYLE, WindowStyleEx))
 326         return E_FAIL;
 327
 328     return S_OK;
 329 }
 330
 331 HRESULT WINAPI BaseControlWindowImpl_get_WindowStyleEx(IVideoWindow *iface, LONG *WindowStyleEx)
 332 {
 333     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 334
 335     TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyleEx);
 336
 337     *WindowStyleEx = GetWindowLongW(This->baseWindow.hWnd, GWL_EXSTYLE);
 338
 339     return S_OK;
 340 }
 341
 342 HRESULT WINAPI BaseControlWindowImpl_put_AutoShow(IVideoWindow *iface, LONG AutoShow)
 343 {
 344     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 345
 346     TRACE("(%p/%p)->(%d)\n", This, iface, AutoShow);
 347
 348     This->AutoShow = AutoShow;
 349
 350     return S_OK;
 351 }
 352
 353 HRESULT WINAPI BaseControlWindowImpl_get_AutoShow(IVideoWindow *iface, LONG *AutoShow)
 354 {
 355     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 356
 357     TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
 358
 359     *AutoShow = This->AutoShow;
 360
 361     return S_OK;
 362 }
 363
 364 HRESULT WINAPI BaseControlWindowImpl_put_WindowState(IVideoWindow *iface, LONG WindowState)
 365 {
 366     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 367
 368     TRACE("(%p/%p)->(%d)\n", This, iface, WindowState);
 369     ShowWindow(This->baseWindow.hWnd, WindowState);
 370     return S_OK;
 371 }
 372
 373 HRESULT WINAPI BaseControlWindowImpl_get_WindowState(IVideoWindow *iface, LONG *WindowState)
 374 {
 375     WINDOWPLACEMENT place;
 376     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 377
 378     place.length = sizeof(place);
 379     GetWindowPlacement(This->baseWindow.hWnd, &place);
 380     TRACE("(%p/%p)->(%p)\n", This, iface, WindowState);
 381     *WindowState = place.showCmd;
 382
 383     return S_OK;
 384 }
 385
 386 HRESULT WINAPI BaseControlWindowImpl_put_BackgroundPalette(IVideoWindow *iface, LONG BackgroundPalette)
 387 {
 388     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 389
 390     FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, BackgroundPalette);
 391
 392     return S_OK;
 393 }
 394
 395 HRESULT WINAPI BaseControlWindowImpl_get_BackgroundPalette(IVideoWindow *iface, LONG *pBackgroundPalette)
 396 {
 397     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 398
 399     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBackgroundPalette);
 400
 401     return S_OK;
 402 }
 403
 404 HRESULT WINAPI BaseControlWindowImpl_put_Visible(IVideoWindow *iface, LONG Visible)
 405 {
 406     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 407
 408     TRACE("(%p/%p)->(%d)\n", This, iface, Visible);
 409
 410     ShowWindow(This->baseWindow.hWnd, Visible ? SW_SHOW : SW_HIDE);
 411
 412     return S_OK;
 413 }
 414
 415 HRESULT WINAPI BaseControlWindowImpl_get_Visible(IVideoWindow *iface, LONG *pVisible)
 416 {
 417     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 418
 419     TRACE("(%p/%p)->(%p)\n", This, iface, pVisible);
 420
 421     *pVisible = IsWindowVisible(This->baseWindow.hWnd);
 422
 423     return S_OK;
 424 }
 425
 426 HRESULT WINAPI BaseControlWindowImpl_put_Left(IVideoWindow *iface, LONG Left)
 427 {
 428     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 429     RECT WindowPos;
 430
 431     TRACE("(%p/%p)->(%d)\n", This, iface, Left);
 432
 433     GetWindowRect(This->baseWindow.hWnd, &WindowPos);
 434     if (!SetWindowPos(This->baseWindow.hWnd, NULL, Left, WindowPos.top, 0, 0, SWP_NOZORDER|SWP_NOSIZE))
 435         return E_FAIL;
 436
 437     return S_OK;
 438 }
 439
 440 HRESULT WINAPI BaseControlWindowImpl_get_Left(IVideoWindow *iface, LONG *pLeft)
 441 {
 442     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 443     RECT WindowPos;
 444
 445     TRACE("(%p/%p)->(%p)\n", This, iface, pLeft);
 446     GetWindowRect(This->baseWindow.hWnd, &WindowPos);
 447
 448     *pLeft = WindowPos.left;
 449
 450     return S_OK;
 451 }
 452
 453 HRESULT WINAPI BaseControlWindowImpl_put_Width(IVideoWindow *iface, LONG Width)
 454 {
 455     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 456
 457     TRACE("(%p/%p)->(%d)\n", This, iface, Width);
 458
 459     if (!SetWindowPos(This->baseWindow.hWnd, NULL, 0, 0, Width, This->baseWindow.Height, SWP_NOZORDER|SWP_NOMOVE))
 460         return E_FAIL;
 461
 462     This->baseWindow.Width = Width;
 463
 464     return S_OK;
 465 }
 466
 467 HRESULT WINAPI BaseControlWindowImpl_get_Width(IVideoWindow *iface, LONG *pWidth)
 468 {
 469     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 470
 471     TRACE("(%p/%p)->(%p)\n", This, iface, pWidth);
 472
 473     *pWidth = This->baseWindow.Width;
 474
 475     return S_OK;
 476 }
 477
 478 HRESULT WINAPI BaseControlWindowImpl_put_Top(IVideoWindow *iface, LONG Top)
 479 {
 480     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 481     RECT WindowPos;
 482
 483     TRACE("(%p/%p)->(%d)\n", This, iface, Top);
 484     GetWindowRect(This->baseWindow.hWnd, &WindowPos);
 485
 486     if (!SetWindowPos(This->baseWindow.hWnd, NULL, WindowPos.left, Top, 0, 0, SWP_NOZORDER|SWP_NOSIZE))
 487         return E_FAIL;
 488
 489     return S_OK;
 490 }
 491
 492 HRESULT WINAPI BaseControlWindowImpl_get_Top(IVideoWindow *iface, LONG *pTop)
 493 {
 494     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 495     RECT WindowPos;
 496
 497     TRACE("(%p/%p)->(%p)\n", This, iface, pTop);
 498     GetWindowRect(This->baseWindow.hWnd, &WindowPos);
 499
 500     *pTop = WindowPos.top;
 501
 502     return S_OK;
 503 }
 504
 505 HRESULT WINAPI BaseControlWindowImpl_put_Height(IVideoWindow *iface, LONG Height)
 506 {
 507     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 508
 509     TRACE("(%p/%p)->(%d)\n", This, iface, Height);
 510
 511     if (!SetWindowPos(This->baseWindow.hWnd, NULL, 0, 0, This->baseWindow.Width, Height, SWP_NOZORDER|SWP_NOMOVE))
 512         return E_FAIL;
 513
 514     This->baseWindow.Height = Height;
 515
 516     return S_OK;
 517 }
 518
 519 HRESULT WINAPI BaseControlWindowImpl_get_Height(IVideoWindow *iface, LONG *pHeight)
 520 {
 521     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 522
 523     TRACE("(%p/%p)->(%p)\n", This, iface, pHeight);
 524
 525     *pHeight = This->baseWindow.Height;
 526
 527     return S_OK;
 528 }
 529
 530 HRESULT WINAPI BaseControlWindowImpl_put_Owner(IVideoWindow *iface, OAHWND Owner)
 531 {
 532     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 533
 534     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Owner);
 535
 536     This->hwndOwner = (HWND)Owner;
 537     SetParent(This->baseWindow.hWnd, This->hwndOwner);
 538     if (This->baseWindow.WindowStyles & WS_CHILD)
 539     {
 540         LONG old = GetWindowLongW(This->baseWindow.hWnd, GWL_STYLE);
 541         if (old != This->baseWindow.WindowStyles)
 542         {
 543             SetWindowLongW(This->baseWindow.hWnd, GWL_STYLE, This->baseWindow.WindowStyles);
 544             SetWindowPos(This->baseWindow.hWnd,0,0,0,0,0,SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOZORDER);
 545         }
 546     }
 547
 548     return S_OK;
 549 }
 550
 551 HRESULT WINAPI BaseControlWindowImpl_get_Owner(IVideoWindow *iface, OAHWND *Owner)
 552 {
 553     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 554
 555     TRACE("(%p/%p)->(%p)\n", This, iface, Owner);
 556
 557     *(HWND*)Owner = This->hwndOwner;
 558
 559     return S_OK;
 560 }
 561
 562 HRESULT WINAPI BaseControlWindowImpl_put_MessageDrain(IVideoWindow *iface, OAHWND Drain)
 563 {
 564     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 565
 566     TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Drain);
 567
 568     This->hwndDrain = (HWND)Drain;
 569
 570     return S_OK;
 571 }
 572
 573 HRESULT WINAPI BaseControlWindowImpl_get_MessageDrain(IVideoWindow *iface, OAHWND *Drain)
 574 {
 575     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 576
 577     TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
 578
 579     *Drain = (OAHWND)This->hwndDrain;
 580
 581     return S_OK;
 582 }
 583
 584 HRESULT WINAPI BaseControlWindowImpl_get_BorderColor(IVideoWindow *iface, LONG *Color)
 585 {
 586     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 587
 588     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, Color);
 589
 590     return S_OK;
 591 }
 592
 593 HRESULT WINAPI BaseControlWindowImpl_put_BorderColor(IVideoWindow *iface, LONG Color)
 594 {
 595     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 596
 597     FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, Color);
 598
 599     return S_OK;
 600 }
 601
 602 HRESULT WINAPI BaseControlWindowImpl_get_FullScreenMode(IVideoWindow *iface, LONG *FullScreenMode)
 603 {
 604     TRACE("(%p)->(%p)\n", iface, FullScreenMode);
 605
 606     return E_NOTIMPL;
 607 }
 608
 609 HRESULT WINAPI BaseControlWindowImpl_put_FullScreenMode(IVideoWindow *iface, LONG FullScreenMode)
 610 {
 611     TRACE("(%p)->(%d)\n", iface, FullScreenMode);
 612     return E_NOTIMPL;
 613 }
 614
 615 HRESULT WINAPI BaseControlWindowImpl_SetWindowForeground(IVideoWindow *iface, LONG Focus)
 616 {
 617     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 618     BOOL ret;
 619     IPin* pPin;
 620     HRESULT hr;
 621
 622     TRACE("(%p/%p)->(%d)\n", This, iface, Focus);
 623
 624     if ((Focus != FALSE) && (Focus != TRUE))
 625         return E_INVALIDARG;
 626
 627     hr = IPin_ConnectedTo(&This->pPin->IPin_iface, &pPin);
 628     if ((hr != S_OK) || !pPin)
 629         return VFW_E_NOT_CONNECTED;
 630
 631     if (Focus)
 632         ret = SetForegroundWindow(This->baseWindow.hWnd);
 633     else
 634         ret = SetWindowPos(This->baseWindow.hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
 635
 636     if (!ret)
 637         return E_FAIL;
 638
 639     return S_OK;
 640 }
 641
 642 HRESULT WINAPI BaseControlWindowImpl_SetWindowPosition(IVideoWindow *iface, LONG Left, LONG Top, LONG Width, LONG Height)
 643 {
 644     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 645
 646     TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
 647
 648     if (!SetWindowPos(This->baseWindow.hWnd, NULL, Left, Top, Width, Height, SWP_NOZORDER))
 649         return E_FAIL;
 650
 651     This->baseWindow.Width = Width;
 652     This->baseWindow.Height = Height;
 653
 654     return S_OK;
 655 }
 656
 657 HRESULT WINAPI BaseControlWindowImpl_GetWindowPosition(IVideoWindow *iface, LONG *pLeft, LONG *pTop, LONG *pWidth, LONG *pHeight)
 658 {
 659     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 660     RECT WindowPos;
 661
 662     TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
 663     GetWindowRect(This->baseWindow.hWnd, &WindowPos);
 664
 665     *pLeft = WindowPos.left;
 666     *pTop = WindowPos.top;
 667     *pWidth = This->baseWindow.Width;
 668     *pHeight = This->baseWindow.Height;
 669
 670     return S_OK;
 671 }
 672
 673 HRESULT WINAPI BaseControlWindowImpl_NotifyOwnerMessage(IVideoWindow *iface, OAHWND hwnd, LONG uMsg, LONG_PTR wParam, LONG_PTR lParam)
 674 {
 675     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 676
 677     TRACE("(%p/%p)->(%08lx, %d, %08lx, %08lx)\n", This, iface, hwnd, uMsg, wParam, lParam);
 678
 679     if (!PostMessageW(This->baseWindow.hWnd, uMsg, wParam, lParam))
 680         return E_FAIL;
 681
 682     return S_OK;
 683 }
 684
 685 HRESULT WINAPI BaseControlWindowImpl_GetMinIdealImageSize(IVideoWindow *iface, LONG *pWidth, LONG *pHeight)
 686 {
 687     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 688     RECT defaultRect;
 689
 690     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
 691     defaultRect = This->baseWindow.pFuncsTable->pfnGetDefaultRect(&This->baseWindow);
 692
 693     *pWidth = defaultRect.right - defaultRect.left;
 694     *pHeight = defaultRect.bottom - defaultRect.top;
 695
 696     return S_OK;
 697 }
 698
 699 HRESULT WINAPI BaseControlWindowImpl_GetMaxIdealImageSize(IVideoWindow *iface, LONG *pWidth, LONG *pHeight)
 700 {
 701     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 702     RECT defaultRect;
 703
 704     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
 705     defaultRect = This->baseWindow.pFuncsTable->pfnGetDefaultRect(&This->baseWindow);
 706
 707     *pWidth = defaultRect.right - defaultRect.left;
 708     *pHeight = defaultRect.bottom - defaultRect.top;
 709
 710     return S_OK;
 711 }
 712
 713 HRESULT WINAPI BaseControlWindowImpl_GetRestorePosition(IVideoWindow *iface, LONG *pLeft, LONG *pTop, LONG *pWidth, LONG *pHeight)
 714 {
 715     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 716
 717     FIXME("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight);
 718
 719     return S_OK;
 720 }
 721
 722 HRESULT WINAPI BaseControlWindowImpl_HideCursor(IVideoWindow *iface, LONG HideCursor)
 723 {
 724     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 725
 726     FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, HideCursor);
 727
 728     return S_OK;
 729 }
 730
 731 HRESULT WINAPI BaseControlWindowImpl_IsCursorHidden(IVideoWindow *iface, LONG *CursorHidden)
 732 {
 733     BaseControlWindow*  This = impl_from_IVideoWindow(iface);
 734
 735     FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, CursorHidden);
 736
 737     return S_OK;
 738 }