dlls/wmp/oleobj.c

   1 /*
   2  * Copyright 2014 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "wmp_private.h"
  20 #include "olectl.h"
  21
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(wmp);
  25
  26 static HWND get_container_hwnd(WindowsMediaPlayer *This)
  27 {
  28     IOleWindow *ole_window;
  29     HWND hwnd = NULL;
  30     HRESULT hres;
  31
  32     /* IOleInPlaceSite (which inherits from IOleWindow) is prefered. */
  33     hres = IOleClientSite_QueryInterface(This->client_site, &IID_IOleInPlaceSite, (void**)&ole_window);
  34     if(FAILED(hres)) {
  35         hres = IOleClientSite_QueryInterface(This->client_site, &IID_IOleWindow, (void**)&ole_window);
  36         if(FAILED(hres)) {
  37             IOleContainer *container = NULL;
  38
  39             hres = IOleClientSite_GetContainer(This->client_site, &container);
  40             if(SUCCEEDED(hres)) {
  41                 hres = IOleContainer_QueryInterface(container, &IID_IOleWindow, (void**)&ole_window);
  42                 IOleContainer_Release(container);
  43             }
  44         }
  45     }
  46
  47     if(FAILED(hres))
  48         return NULL;
  49
  50     hres = IOleWindow_GetWindow(ole_window, &hwnd);
  51     IOleWindow_Release(ole_window);
  52     if(FAILED(hres))
  53         return NULL;
  54
  55     TRACE("Got window %p\n", hwnd);
  56     return hwnd;
  57 }
  58
  59 static LRESULT WINAPI wmp_wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  60 {
  61     switch(msg) {
  62     case WM_PAINT: {
  63         PAINTSTRUCT ps;
  64         HFONT font;
  65         RECT rect;
  66         HDC hdc;
  67
  68         TRACE("WM_PAINT\n");
  69
  70         GetClientRect(hwnd, &rect);
  71         hdc = BeginPaint(hwnd, &ps);
  72
  73         SelectObject(hdc, GetStockObject(DC_BRUSH));
  74         SetDCBrushColor(hdc, RGB(255,0,0));
  75         SetBkColor(hdc, RGB(255,0,0));
  76
  77         font = CreateFontA(25,0,0,0,400,0,0,0,ANSI_CHARSET,0,0,DEFAULT_QUALITY,DEFAULT_PITCH,NULL);
  78         SelectObject(hdc, font);
  79
  80         Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
  81         DrawTextA(hdc, "FIXME: WMP", -1, &rect, DT_CENTER | DT_SINGLELINE | DT_VCENTER);
  82
  83         DeleteObject(font);
  84         EndPaint(hwnd, &ps);
  85         break;
  86     }
  87     }
  88
  89     return DefWindowProcW(hwnd, msg, wParam, lParam);
  90
  91 }
  92
  93 static ATOM wmp_class;
  94
  95 static BOOL WINAPI register_wmp_class(INIT_ONCE *once, void *param, void **context)
  96 {
  97     /* It seems that native uses ATL for this. We use a fake name to make tests happy. */
  98     static const WCHAR atl_wmpW[] = {'A','T','L',':','W','M','P',0};
  99
 100     static WNDCLASSEXW wndclass = {
 101         sizeof(wndclass), CS_DBLCLKS, wmp_wnd_proc, 0, 0,
 102         NULL, NULL, NULL, NULL, NULL,
 103         atl_wmpW, NULL
 104     };
 105
 106     wndclass.hInstance = wmp_instance;
 107     wmp_class = RegisterClassExW(&wndclass);
 108     return TRUE;
 109 }
 110
 111 void unregister_wmp_class(void)
 112 {
 113     if(wmp_class)
 114         UnregisterClassW(MAKEINTRESOURCEW(wmp_class), wmp_instance);
 115 }
 116
 117 static HWND create_wmp_window(WindowsMediaPlayer *wmp, const RECT *posrect)
 118 {
 119     static INIT_ONCE class_init_once = INIT_ONCE_STATIC_INIT;
 120
 121     InitOnceExecuteOnce(&class_init_once, register_wmp_class, NULL, NULL);
 122     if(!wmp_class)
 123         return NULL;
 124
 125     return CreateWindowExW(0, MAKEINTRESOURCEW(wmp_class), NULL, WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_VISIBLE|WS_CHILD,
 126             posrect->left, posrect->top, posrect->right-posrect->left, posrect->bottom-posrect->top,
 127             get_container_hwnd(wmp), NULL, wmp_instance, NULL);
 128 }
 129
 130 static HRESULT activate_inplace(WindowsMediaPlayer *This)
 131 {
 132     IOleInPlaceSiteWindowless *ipsite_windowless;
 133     IOleInPlaceSiteEx *ipsiteex = NULL;
 134     IOleInPlaceSite *ipsite;
 135     IOleInPlaceUIWindow *ip_window = NULL;
 136     IOleInPlaceFrame *ip_frame = NULL;
 137     RECT posrect = {0}, cliprect = {0};
 138     OLEINPLACEFRAMEINFO frameinfo = { sizeof(frameinfo) };
 139     HRESULT hres;
 140
 141     if(This->hwnd) {
 142         FIXME("Already activated\n");
 143         return E_UNEXPECTED;
 144     }
 145
 146     hres = IOleClientSite_QueryInterface(This->client_site, &IID_IOleInPlaceSiteWindowless, (void**)&ipsite_windowless);
 147     if(SUCCEEDED(hres)) {
 148         hres = IOleInPlaceSiteWindowless_CanWindowlessActivate(ipsite_windowless);
 149         IOleInPlaceSiteWindowless_Release(ipsite_windowless);
 150         if(hres == S_OK)
 151             FIXME("Windowless activation not supported\n");
 152         ipsiteex = (IOleInPlaceSiteEx*)ipsite_windowless;
 153     }else {
 154         IOleClientSite_QueryInterface(This->client_site, &IID_IOleInPlaceSiteEx, (void**)&ipsiteex);
 155     }
 156
 157     if(ipsiteex) {
 158         BOOL redraw = FALSE; /* Not really used. */
 159         IOleInPlaceSiteEx_OnInPlaceActivateEx(ipsiteex, &redraw, 0);
 160         ipsite = (IOleInPlaceSite*)ipsiteex;
 161     }else {
 162         IOleClientSite_QueryInterface(This->client_site, &IID_IOleInPlaceSite, (void**)&ipsite);
 163         if(FAILED(hres)) {
 164             FIXME("No IOleInPlaceSite instance\n");
 165             return hres;
 166         }
 167
 168         IOleInPlaceSite_OnInPlaceActivate(ipsite);
 169     }
 170
 171     hres = IOleInPlaceSite_GetWindowContext(ipsite, &ip_frame, &ip_window, &posrect, &cliprect, &frameinfo);
 172     IOleInPlaceSite_Release(ipsite);
 173     if(FAILED(hres)) {
 174         FIXME("GetWindowContext failed: %08x\n", hres);
 175         return hres;
 176     }
 177
 178     This->hwnd = create_wmp_window(This, &posrect);
 179     if(!This->hwnd)
 180         return E_FAIL;
 181
 182     IOleClientSite_ShowObject(This->client_site);
 183     return S_OK;
 184 }
 185
 186 static void deactivate_window(WindowsMediaPlayer *This)
 187 {
 188     IOleInPlaceSite *ip_site;
 189     HRESULT hres;
 190
 191     hres = IOleClientSite_QueryInterface(This->client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
 192     if(SUCCEEDED(hres)) {
 193         IOleInPlaceSite_OnInPlaceDeactivate(ip_site);
 194         IOleInPlaceSite_Release(ip_site);
 195     }
 196
 197     DestroyWindow(This->hwnd);
 198     This->hwnd = NULL;
 199 }
 200
 201 static void release_client_site(WindowsMediaPlayer *This)
 202 {
 203     if(!This->client_site)
 204         return;
 205
 206     if(This->hwnd)
 207         deactivate_window(This);
 208
 209     IOleClientSite_Release(This->client_site);
 210     This->client_site = NULL;
 211 }
 212
 213 static inline WindowsMediaPlayer *impl_from_IOleObject(IOleObject *iface)
 214 {
 215     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IOleObject_iface);
 216 }
 217
 218 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
 219 {
 220     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 221
 222     if(IsEqualGUID(riid, &IID_IUnknown)) {
 223         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 224         *ppv = &This->IOleObject_iface;
 225     }else if(IsEqualGUID(riid, &IID_IOleObject)) {
 226         TRACE("(%p)->(IID_IOleObject %p)\n", This, ppv);
 227         *ppv = &This->IOleObject_iface;
 228     }else if(IsEqualGUID(riid, &IID_IProvideClassInfo)) {
 229         TRACE("(%p)->(IID_IProvideClassInfo %p)\n", This, ppv);
 230         *ppv = &This->IProvideClassInfo2_iface;
 231     }else if(IsEqualGUID(riid, &IID_IProvideClassInfo2)) {
 232         TRACE("(%p)->(IID_IProvideClassInfo2 %p)\n", This, ppv);
 233         *ppv = &This->IProvideClassInfo2_iface;
 234     }else if(IsEqualGUID(riid, &IID_IPersist)) {
 235         TRACE("(%p)->(IID_IPersist %p)\n", This, ppv);
 236         *ppv = &This->IPersistStreamInit_iface;
 237     }else if(IsEqualGUID(riid, &IID_IPersistStreamInit)) {
 238         TRACE("(%p)->(IID_IPersistStreamInit %p)\n", This, ppv);
 239         *ppv = &This->IPersistStreamInit_iface;
 240     }else if(IsEqualGUID(riid, &IID_IOleWindow)) {
 241         TRACE("(%p)->(IID_IOleWindow %p)\n", This, ppv);
 242         *ppv = &This->IOleInPlaceObjectWindowless_iface;
 243     }else if(IsEqualGUID(riid, &IID_IOleInPlaceObject)) {
 244         TRACE("(%p)->(IID_IOleInPlaceObject %p)\n", This, ppv);
 245         *ppv = &This->IOleInPlaceObjectWindowless_iface;
 246     }else if(IsEqualGUID(riid, &IID_IOleInPlaceObjectWindowless)) {
 247         TRACE("(%p)->(IID_IOleInPlaceObjectWindowless %p)\n", This, ppv);
 248         *ppv = &This->IOleInPlaceObjectWindowless_iface;
 249     }else if(IsEqualGUID(riid, &IID_IConnectionPointContainer)) {
 250         TRACE("(%p)->(IID_IConnectionPointContainer %p)\n", This, ppv);
 251         *ppv = &This->IConnectionPointContainer_iface;
 252     }else if(IsEqualGUID(riid, &IID_IWMPCore)) {
 253         TRACE("(%p)->(IID_IWMPCore %p)\n", This, ppv);
 254         *ppv = &This->IWMPPlayer4_iface;
 255     }else if(IsEqualGUID(riid, &IID_IWMPCore2)) {
 256         TRACE("(%p)->(IID_IWMPCore2 %p)\n", This, ppv);
 257         *ppv = &This->IWMPPlayer4_iface;
 258     }else if(IsEqualGUID(riid, &IID_IWMPCore3)) {
 259         TRACE("(%p)->(IID_IWMPCore3 %p)\n", This, ppv);
 260         *ppv = &This->IWMPPlayer4_iface;
 261     }else if(IsEqualGUID(riid, &IID_IWMPPlayer4)) {
 262         TRACE("(%p)->(IID_IWMPPlayer4 %p)\n", This, ppv);
 263         *ppv = &This->IWMPPlayer4_iface;
 264     }else if(IsEqualGUID(riid, &IID_IWMPSettings)) {
 265         TRACE("(%p)->(IID_IWMPSettings %p)\n", This, ppv);
 266         *ppv = &This->IWMPSettings_iface;
 267     }else if(IsEqualGUID(riid, &IID_IOleControl)) {
 268         TRACE("(%p)->(IID_IOleControl %p)\n", This, ppv);
 269         *ppv = &This->IOleControl_iface;
 270     }else {
 271         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 272         *ppv = NULL;
 273         return E_NOINTERFACE;
 274     }
 275
 276     IUnknown_AddRef((IUnknown*)*ppv);
 277     return S_OK;
 278 }
 279
 280 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
 281 {
 282     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 283     LONG ref = InterlockedIncrement(&This->ref);
 284
 285     TRACE("(%p) ref=%d\n", This, ref);
 286
 287     return ref;
 288 }
 289
 290 static ULONG WINAPI OleObject_Release(IOleObject *iface)
 291 {
 292     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 293     LONG ref = InterlockedDecrement(&This->ref);
 294
 295     TRACE("(%p) ref=%d\n", This, ref);
 296
 297     if(!ref) {
 298         release_client_site(This);
 299         heap_free(This);
 300     }
 301
 302     return ref;
 303 }
 304
 305 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
 306 {
 307     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 308     IOleControlSite *control_site;
 309     HRESULT hres;
 310
 311     TRACE("(%p)->(%p)\n", This, pClientSite);
 312
 313     release_client_site(This);
 314     if(!pClientSite)
 315         return S_OK;
 316
 317     IOleClientSite_AddRef(pClientSite);
 318     This->client_site = pClientSite;
 319
 320     hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleControlSite, (void**)&control_site);
 321     if(SUCCEEDED(hres)) {
 322         IDispatch *disp;
 323
 324         hres = IOleControlSite_GetExtendedControl(control_site, &disp);
 325         if(SUCCEEDED(hres) && disp) {
 326             FIXME("Use extended control\n");
 327             IDispatch_Release(disp);
 328         }
 329
 330         IOleControlSite_Release(control_site);
 331     }
 332
 333     return S_OK;
 334 }
 335
 336 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
 337 {
 338     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 339
 340     TRACE("(%p)->(%p)\n", This, ppClientSite);
 341
 342     *ppClientSite = This->client_site;
 343     return This->client_site ? S_OK : E_FAIL;
 344 }
 345
 346 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
 347 {
 348     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 349     FIXME("(%p)->(%s %s)\n", This, debugstr_w(szContainerApp), debugstr_w(szContainerObj));
 350     return E_NOTIMPL;
 351 }
 352
 353 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
 354 {
 355     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 356
 357     TRACE("(%p)->(%08x)\n", This, dwSaveOption);
 358
 359     if(dwSaveOption)
 360         FIXME("Unsupported option %d\n", dwSaveOption);
 361
 362     if(This->hwnd) /* FIXME: Possibly hide window */
 363         deactivate_window(This);
 364     return S_OK;
 365 }
 366
 367 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
 368 {
 369     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 370     FIXME("(%p %d %p)->()\n", This, dwWhichMoniker, pmk);
 371     return E_NOTIMPL;
 372 }
 373
 374 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
 375 {
 376     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 377     FIXME("(%p)->(%d %d %p)\n", This, dwAssign, dwWhichMoniker, ppmk);
 378     return E_NOTIMPL;
 379 }
 380
 381 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
 382                                         DWORD dwReserved)
 383 {
 384     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 385     FIXME("(%p)->(%p %x %d)\n", This, pDataObject, fCreation, dwReserved);
 386     return E_NOTIMPL;
 387 }
 388
 389 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
 390 {
 391     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 392     FIXME("(%p)->(%d %p)\n", This, dwReserved, ppDataObject);
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
 397                                         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
 398 {
 399     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 400
 401     switch(iVerb) {
 402     case OLEIVERB_INPLACEACTIVATE:
 403         TRACE("(%p)->(OLEIVERB_INPLACEACTIVATE)\n", This);
 404         return activate_inplace(This);
 405
 406     case OLEIVERB_HIDE:
 407         if(!This->hwnd) {
 408             FIXME("No window to hide\n");
 409             return E_UNEXPECTED;
 410         }
 411
 412         ShowWindow(This->hwnd, SW_HIDE);
 413         return S_OK;
 414
 415     default:
 416         FIXME("Unsupported iVerb %d\n", iVerb);
 417     }
 418
 419     return E_NOTIMPL;
 420 }
 421
 422 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
 423 {
 424     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 425     FIXME("(%p)->(%p)\n", This, ppEnumOleVerb);
 426     return E_NOTIMPL;
 427 }
 428
 429 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
 430 {
 431     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 432     FIXME("(%p)\n", This);
 433     return E_NOTIMPL;
 434 }
 435
 436 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
 437 {
 438     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 439     FIXME("(%p)\n", This);
 440     return E_NOTIMPL;
 441 }
 442
 443 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
 444 {
 445     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 446     FIXME("(%p)->(%p)\n", This, pClsid);
 447     return E_NOTIMPL;
 448 }
 449
 450 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
 451 {
 452     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 453     FIXME("(%p)->(%d %p)\n", This, dwFormOfType, pszUserType);
 454     return E_NOTIMPL;
 455 }
 456
 457 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 458 {
 459     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 460     FIXME("(%p)->(%d %p)\n", This, dwDrawAspect, psizel);
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 465 {
 466     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 467     FIXME("(%p)->(%d %p)\n", This, dwDrawAspect, psizel);
 468     return E_NOTIMPL;
 469 }
 470
 471 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
 472 {
 473     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 474     FIXME("(%p)->(%p %p)\n", This, pAdvSink, pdwConnection);
 475     return E_NOTIMPL;
 476 }
 477
 478 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
 479 {
 480     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 481     FIXME("(%p)->(%d)\n", This, dwConnection);
 482     return E_NOTIMPL;
 483 }
 484
 485 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
 486 {
 487     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 488     FIXME("(%p)->(%p)\n", This, ppenumAdvise);
 489     return E_NOTIMPL;
 490 }
 491
 492 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
 493 {
 494     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 495
 496     TRACE("(%p)->(%d %p)\n", This, dwAspect, pdwStatus);
 497
 498     switch(dwAspect) {
 499     case DVASPECT_CONTENT:
 500         *pdwStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
 501             |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
 502         break;
 503     default:
 504         FIXME("Unhandled aspect %d\n", dwAspect);
 505         return E_NOTIMPL;
 506     }
 507
 508     return S_OK;
 509 }
 510
 511 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
 512 {
 513     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 514     FIXME("(%p)->(%p)\n", This, pLogpal);
 515     return E_NOTIMPL;
 516 }
 517
 518 static const IOleObjectVtbl OleObjectVtbl = {
 519     OleObject_QueryInterface,
 520     OleObject_AddRef,
 521     OleObject_Release,
 522     OleObject_SetClientSite,
 523     OleObject_GetClientSite,
 524     OleObject_SetHostNames,
 525     OleObject_Close,
 526     OleObject_SetMoniker,
 527     OleObject_GetMoniker,
 528     OleObject_InitFromData,
 529     OleObject_GetClipboardData,
 530     OleObject_DoVerb,
 531     OleObject_EnumVerbs,
 532     OleObject_Update,
 533     OleObject_IsUpToDate,
 534     OleObject_GetUserClassID,
 535     OleObject_GetUserType,
 536     OleObject_SetExtent,
 537     OleObject_GetExtent,
 538     OleObject_Advise,
 539     OleObject_Unadvise,
 540     OleObject_EnumAdvise,
 541     OleObject_GetMiscStatus,
 542     OleObject_SetColorScheme
 543 };
 544
 545 static inline WindowsMediaPlayer *impl_from_IOleInPlaceObjectWindowless(IOleInPlaceObjectWindowless *iface)
 546 {
 547     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IOleInPlaceObjectWindowless_iface);
 548 }
 549
 550 static HRESULT WINAPI OleInPlaceObjectWindowless_QueryInterface(IOleInPlaceObjectWindowless *iface,
 551         REFIID riid, void **ppv)
 552 {
 553     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 554     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 555 }
 556
 557 static ULONG WINAPI OleInPlaceObjectWindowless_AddRef(IOleInPlaceObjectWindowless *iface)
 558 {
 559     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 560     return IOleObject_AddRef(&This->IOleObject_iface);
 561 }
 562
 563 static ULONG WINAPI OleInPlaceObjectWindowless_Release(IOleInPlaceObjectWindowless *iface)
 564 {
 565     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 566     return IOleObject_Release(&This->IOleObject_iface);
 567 }
 568
 569 static HRESULT WINAPI OleInPlaceObjectWindowless_GetWindow(IOleInPlaceObjectWindowless *iface, HWND *phwnd)
 570 {
 571     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 572
 573     TRACE("(%p)->(%p)\n", This, phwnd);
 574
 575     *phwnd = This->hwnd;
 576     return This->hwnd ? S_OK : E_UNEXPECTED;
 577 }
 578
 579 static HRESULT WINAPI OleInPlaceObjectWindowless_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
 580         BOOL fEnterMode)
 581 {
 582     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 583     FIXME("(%p)->(%x)\n", This, fEnterMode);
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT WINAPI OleInPlaceObjectWindowless_InPlaceDeactivate(IOleInPlaceObjectWindowless *iface)
 588 {
 589     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 590     FIXME("(%p)\n", This);
 591     return E_NOTIMPL;
 592 }
 593
 594 static HRESULT WINAPI OleInPlaceObjectWindowless_UIDeactivate(IOleInPlaceObjectWindowless *iface)
 595 {
 596     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 597     FIXME("(%p)\n", This);
 598     return E_NOTIMPL;
 599 }
 600
 601 static HRESULT WINAPI OleInPlaceObjectWindowless_SetObjectRects(IOleInPlaceObjectWindowless *iface,
 602         LPCRECT lprcPosRect, LPCRECT lprcClipRect)
 603 {
 604     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 605
 606     TRACE("(%p)->(%s %s)\n", This, wine_dbgstr_rect(lprcPosRect), wine_dbgstr_rect(lprcClipRect));
 607
 608     if(This->hwnd) {
 609        SetWindowPos(This->hwnd, NULL, lprcPosRect->left, lprcPosRect->top,
 610                lprcPosRect->right-lprcPosRect->left, lprcPosRect->bottom-lprcPosRect->top,
 611                SWP_NOZORDER | SWP_NOACTIVATE);
 612     }
 613
 614     return S_OK;
 615 }
 616
 617 static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
 618 {
 619     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 620     FIXME("(%p)\n", This);
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
 625         UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
 626 {
 627     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 628     FIXME("(%p)->(%u %lu %lu %p)\n", This, msg, wParam, lParam, lpResult);
 629     return E_NOTIMPL;
 630 }
 631
 632 static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
 633         IDropTarget **ppDropTarget)
 634 {
 635     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 636     FIXME("(%p)->(%p)\n", This, ppDropTarget);
 637     return E_NOTIMPL;
 638 }
 639
 640 static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
 641     OleInPlaceObjectWindowless_QueryInterface,
 642     OleInPlaceObjectWindowless_AddRef,
 643     OleInPlaceObjectWindowless_Release,
 644     OleInPlaceObjectWindowless_GetWindow,
 645     OleInPlaceObjectWindowless_ContextSensitiveHelp,
 646     OleInPlaceObjectWindowless_InPlaceDeactivate,
 647     OleInPlaceObjectWindowless_UIDeactivate,
 648     OleInPlaceObjectWindowless_SetObjectRects,
 649     OleInPlaceObjectWindowless_ReactivateAndUndo,
 650     OleInPlaceObjectWindowless_OnWindowMessage,
 651     OleInPlaceObjectWindowless_GetDropTarget
 652 };
 653
 654 static inline WindowsMediaPlayer *impl_from_IOleControl(IOleControl *iface)
 655 {
 656     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IOleControl_iface);
 657 }
 658
 659 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 660 {
 661     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 662     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 663 }
 664
 665 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 666 {
 667     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 668     return IOleObject_AddRef(&This->IOleObject_iface);
 669 }
 670
 671 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 672 {
 673     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 674     return IOleObject_AddRef(&This->IOleObject_iface);
 675 }
 676
 677 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 678 {
 679     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 680     FIXME("(%p)->(%p)\n", This, pCI);
 681     return E_NOTIMPL;
 682 }
 683
 684 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *msg)
 685 {
 686     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 687     FIXME("(%p)->(%p)\n", This, msg);
 688     return E_NOTIMPL;
 689 }
 690
 691 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 692 {
 693     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 694     FIXME("(%p)->(%d)\n", This, dispID);
 695     return E_NOTIMPL;
 696 }
 697
 698 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL freeze)
 699 {
 700     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 701     FIXME("(%p)->(%x)\n", This, freeze);
 702     return E_NOTIMPL;
 703 }
 704
 705 static const IOleControlVtbl OleControlVtbl = {
 706     OleControl_QueryInterface,
 707     OleControl_AddRef,
 708     OleControl_Release,
 709     OleControl_GetControlInfo,
 710     OleControl_OnMnemonic,
 711     OleControl_OnAmbientPropertyChange,
 712     OleControl_FreezeEvents
 713 };
 714
 715 static inline WindowsMediaPlayer *impl_from_IProvideClassInfo2(IProvideClassInfo2 *iface)
 716 {
 717     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IProvideClassInfo2_iface);
 718 }
 719
 720 static HRESULT WINAPI ProvideClassInfo2_QueryInterface(IProvideClassInfo2 *iface, REFIID riid, void **ppv)
 721 {
 722     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 723     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 724 }
 725
 726 static ULONG WINAPI ProvideClassInfo2_AddRef(IProvideClassInfo2 *iface)
 727 {
 728     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 729     return IOleObject_AddRef(&This->IOleObject_iface);
 730 }
 731
 732 static ULONG WINAPI ProvideClassInfo2_Release(IProvideClassInfo2 *iface)
 733 {
 734     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 735     return IOleObject_Release(&This->IOleObject_iface);
 736 }
 737
 738 static HRESULT WINAPI ProvideClassInfo2_GetClassInfo(IProvideClassInfo2 *iface, ITypeInfo **ppTI)
 739 {
 740     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 741     FIXME("(%p)->(%p)\n", This, ppTI);
 742     return E_NOTIMPL;
 743 }
 744
 745 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideClassInfo2 *iface, DWORD dwGuidKind, GUID *pGUID)
 746 {
 747     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 748
 749     TRACE("(%p)->(%d %p)\n", This, dwGuidKind, pGUID);
 750
 751     if(dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID) {
 752         FIXME("Unexpected dwGuidKind %d\n", dwGuidKind);
 753         return E_INVALIDARG;
 754     }
 755
 756     *pGUID = IID__WMPOCXEvents;
 757     return S_OK;
 758 }
 759
 760 static const IProvideClassInfo2Vtbl ProvideClassInfo2Vtbl = {
 761     ProvideClassInfo2_QueryInterface,
 762     ProvideClassInfo2_AddRef,
 763     ProvideClassInfo2_Release,
 764     ProvideClassInfo2_GetClassInfo,
 765     ProvideClassInfo2_GetGUID
 766 };
 767
 768 static inline WindowsMediaPlayer *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
 769 {
 770     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IPersistStreamInit_iface);
 771 }
 772
 773 static HRESULT WINAPI PersistStreamInit_QueryInterface(IPersistStreamInit *iface,
 774                                                        REFIID riid, void **ppv)
 775 {
 776     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 777     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 778 }
 779
 780 static ULONG WINAPI PersistStreamInit_AddRef(IPersistStreamInit *iface)
 781 {
 782     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 783     return IOleObject_AddRef(&This->IOleObject_iface);
 784 }
 785
 786 static ULONG WINAPI PersistStreamInit_Release(IPersistStreamInit *iface)
 787 {
 788     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 789     return IOleObject_Release(&This->IOleObject_iface);
 790 }
 791
 792 static HRESULT WINAPI PersistStreamInit_GetClassID(IPersistStreamInit *iface, CLSID *pClassID)
 793 {
 794     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 795     FIXME("(%p)->(%p)\n", This, pClassID);
 796     return E_NOTIMPL;
 797 }
 798
 799 static HRESULT WINAPI PersistStreamInit_IsDirty(IPersistStreamInit *iface)
 800 {
 801     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 802     FIXME("(%p)\n", This);
 803     return E_NOTIMPL;
 804 }
 805
 806 static HRESULT WINAPI PersistStreamInit_Load(IPersistStreamInit *iface, LPSTREAM pStm)
 807 {
 808     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 809     FIXME("(%p)->(%p)\n", This, pStm);
 810     return E_NOTIMPL;
 811 }
 812
 813 static HRESULT WINAPI PersistStreamInit_Save(IPersistStreamInit *iface, LPSTREAM pStm,
 814                                              BOOL fClearDirty)
 815 {
 816     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 817     FIXME("(%p)->(%p %x)\n", This, pStm, fClearDirty);
 818     return E_NOTIMPL;
 819 }
 820
 821 static HRESULT WINAPI PersistStreamInit_GetSizeMax(IPersistStreamInit *iface,
 822                                                    ULARGE_INTEGER *pcbSize)
 823 {
 824     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 825     FIXME("(%p)->(%p)\n", This, pcbSize);
 826     return E_NOTIMPL;
 827 }
 828
 829 static HRESULT WINAPI PersistStreamInit_InitNew(IPersistStreamInit *iface)
 830 {
 831     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 832
 833     TRACE("(%p)\n", This);
 834
 835     if(!This->client_site)
 836         return E_FAIL;
 837
 838     /* Nothing to do, yet. */
 839     get_container_hwnd(This);
 840     return S_OK;
 841 }
 842
 843 static const IPersistStreamInitVtbl PersistStreamInitVtbl = {
 844     PersistStreamInit_QueryInterface,
 845     PersistStreamInit_AddRef,
 846     PersistStreamInit_Release,
 847     PersistStreamInit_GetClassID,
 848     PersistStreamInit_IsDirty,
 849     PersistStreamInit_Load,
 850     PersistStreamInit_Save,
 851     PersistStreamInit_GetSizeMax,
 852     PersistStreamInit_InitNew
 853 };
 854
 855 static inline WindowsMediaPlayer *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
 856 {
 857     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IConnectionPointContainer_iface);
 858 }
 859
 860 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
 861         REFIID riid, LPVOID *ppv)
 862 {
 863     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 864     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 865 }
 866
 867 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
 868 {
 869     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 870     return IOleObject_AddRef(&This->IOleObject_iface);
 871 }
 872
 873 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
 874 {
 875     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 876     return IOleObject_Release(&This->IOleObject_iface);
 877 }
 878
 879 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
 880         IEnumConnectionPoints **ppEnum)
 881 {
 882     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 883     FIXME("(%p)->(%p)\n", This, ppEnum);
 884     return E_NOTIMPL;
 885 }
 886
 887 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
 888         REFIID riid, IConnectionPoint **ppCP)
 889 {
 890     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 891     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppCP);
 892     return CONNECT_E_NOCONNECTION;
 893 }
 894
 895 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl =
 896 {
 897     ConnectionPointContainer_QueryInterface,
 898     ConnectionPointContainer_AddRef,
 899     ConnectionPointContainer_Release,
 900     ConnectionPointContainer_EnumConnectionPoints,
 901     ConnectionPointContainer_FindConnectionPoint
 902 };
 903
 904 HRESULT WINAPI WMPFactory_CreateInstance(IClassFactory *iface, IUnknown *outer,
 905         REFIID riid, void **ppv)
 906 {
 907     WindowsMediaPlayer *wmp;
 908     HRESULT hres;
 909
 910     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
 911
 912     wmp = heap_alloc_zero(sizeof(*wmp));
 913     if(!wmp)
 914         return E_OUTOFMEMORY;
 915
 916     wmp->IOleObject_iface.lpVtbl = &OleObjectVtbl;
 917     wmp->IProvideClassInfo2_iface.lpVtbl = &ProvideClassInfo2Vtbl;
 918     wmp->IPersistStreamInit_iface.lpVtbl = &PersistStreamInitVtbl;
 919     wmp->IOleInPlaceObjectWindowless_iface.lpVtbl = &OleInPlaceObjectWindowlessVtbl;
 920     wmp->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
 921     wmp->IOleControl_iface.lpVtbl = &OleControlVtbl;
 922
 923     wmp->ref = 1;
 924
 925     init_player_ifaces(wmp);
 926
 927     hres = IOleObject_QueryInterface(&wmp->IOleObject_iface, riid, ppv);
 928     IOleObject_Release(&wmp->IOleObject_iface);
 929     return hres;
 930 }