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 preferred. */
  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
 461     TRACE("(%p)->(%d %p)\n", This, dwDrawAspect, psizel);
 462
 463     if(dwDrawAspect != DVASPECT_CONTENT)
 464         return DV_E_DVASPECT;
 465
 466     This->extent = *psizel;
 467     return S_OK;
 468 }
 469
 470 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 471 {
 472     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 473
 474     TRACE("(%p)->(%d %p)\n", This, dwDrawAspect, psizel);
 475
 476     if(dwDrawAspect != DVASPECT_CONTENT)
 477         return E_FAIL;
 478
 479     *psizel = This->extent;
 480     return S_OK;
 481 }
 482
 483 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
 484 {
 485     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 486     FIXME("(%p)->(%p %p)\n", This, pAdvSink, pdwConnection);
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
 491 {
 492     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 493     FIXME("(%p)->(%d)\n", This, dwConnection);
 494     return E_NOTIMPL;
 495 }
 496
 497 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
 498 {
 499     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 500     FIXME("(%p)->(%p)\n", This, ppenumAdvise);
 501     return E_NOTIMPL;
 502 }
 503
 504 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
 505 {
 506     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 507
 508     TRACE("(%p)->(%d %p)\n", This, dwAspect, pdwStatus);
 509
 510     switch(dwAspect) {
 511     case DVASPECT_CONTENT:
 512         *pdwStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
 513             |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
 514         break;
 515     default:
 516         FIXME("Unhandled aspect %d\n", dwAspect);
 517         return E_NOTIMPL;
 518     }
 519
 520     return S_OK;
 521 }
 522
 523 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
 524 {
 525     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 526     FIXME("(%p)->(%p)\n", This, pLogpal);
 527     return E_NOTIMPL;
 528 }
 529
 530 static const IOleObjectVtbl OleObjectVtbl = {
 531     OleObject_QueryInterface,
 532     OleObject_AddRef,
 533     OleObject_Release,
 534     OleObject_SetClientSite,
 535     OleObject_GetClientSite,
 536     OleObject_SetHostNames,
 537     OleObject_Close,
 538     OleObject_SetMoniker,
 539     OleObject_GetMoniker,
 540     OleObject_InitFromData,
 541     OleObject_GetClipboardData,
 542     OleObject_DoVerb,
 543     OleObject_EnumVerbs,
 544     OleObject_Update,
 545     OleObject_IsUpToDate,
 546     OleObject_GetUserClassID,
 547     OleObject_GetUserType,
 548     OleObject_SetExtent,
 549     OleObject_GetExtent,
 550     OleObject_Advise,
 551     OleObject_Unadvise,
 552     OleObject_EnumAdvise,
 553     OleObject_GetMiscStatus,
 554     OleObject_SetColorScheme
 555 };
 556
 557 static inline WindowsMediaPlayer *impl_from_IOleInPlaceObjectWindowless(IOleInPlaceObjectWindowless *iface)
 558 {
 559     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IOleInPlaceObjectWindowless_iface);
 560 }
 561
 562 static HRESULT WINAPI OleInPlaceObjectWindowless_QueryInterface(IOleInPlaceObjectWindowless *iface,
 563         REFIID riid, void **ppv)
 564 {
 565     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 566     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 567 }
 568
 569 static ULONG WINAPI OleInPlaceObjectWindowless_AddRef(IOleInPlaceObjectWindowless *iface)
 570 {
 571     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 572     return IOleObject_AddRef(&This->IOleObject_iface);
 573 }
 574
 575 static ULONG WINAPI OleInPlaceObjectWindowless_Release(IOleInPlaceObjectWindowless *iface)
 576 {
 577     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 578     return IOleObject_Release(&This->IOleObject_iface);
 579 }
 580
 581 static HRESULT WINAPI OleInPlaceObjectWindowless_GetWindow(IOleInPlaceObjectWindowless *iface, HWND *phwnd)
 582 {
 583     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 584
 585     TRACE("(%p)->(%p)\n", This, phwnd);
 586
 587     *phwnd = This->hwnd;
 588     return This->hwnd ? S_OK : E_UNEXPECTED;
 589 }
 590
 591 static HRESULT WINAPI OleInPlaceObjectWindowless_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
 592         BOOL fEnterMode)
 593 {
 594     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 595     FIXME("(%p)->(%x)\n", This, fEnterMode);
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI OleInPlaceObjectWindowless_InPlaceDeactivate(IOleInPlaceObjectWindowless *iface)
 600 {
 601     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 602     FIXME("(%p)\n", This);
 603     return E_NOTIMPL;
 604 }
 605
 606 static HRESULT WINAPI OleInPlaceObjectWindowless_UIDeactivate(IOleInPlaceObjectWindowless *iface)
 607 {
 608     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 609     FIXME("(%p)\n", This);
 610     return E_NOTIMPL;
 611 }
 612
 613 static HRESULT WINAPI OleInPlaceObjectWindowless_SetObjectRects(IOleInPlaceObjectWindowless *iface,
 614         LPCRECT lprcPosRect, LPCRECT lprcClipRect)
 615 {
 616     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 617
 618     TRACE("(%p)->(%s %s)\n", This, wine_dbgstr_rect(lprcPosRect), wine_dbgstr_rect(lprcClipRect));
 619
 620     if(This->hwnd) {
 621        SetWindowPos(This->hwnd, NULL, lprcPosRect->left, lprcPosRect->top,
 622                lprcPosRect->right-lprcPosRect->left, lprcPosRect->bottom-lprcPosRect->top,
 623                SWP_NOZORDER | SWP_NOACTIVATE);
 624     }
 625
 626     return S_OK;
 627 }
 628
 629 static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
 630 {
 631     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 632     FIXME("(%p)\n", This);
 633     return E_NOTIMPL;
 634 }
 635
 636 static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
 637         UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
 638 {
 639     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 640     FIXME("(%p)->(%u %lu %lu %p)\n", This, msg, wParam, lParam, lpResult);
 641     return E_NOTIMPL;
 642 }
 643
 644 static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
 645         IDropTarget **ppDropTarget)
 646 {
 647     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 648     FIXME("(%p)->(%p)\n", This, ppDropTarget);
 649     return E_NOTIMPL;
 650 }
 651
 652 static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
 653     OleInPlaceObjectWindowless_QueryInterface,
 654     OleInPlaceObjectWindowless_AddRef,
 655     OleInPlaceObjectWindowless_Release,
 656     OleInPlaceObjectWindowless_GetWindow,
 657     OleInPlaceObjectWindowless_ContextSensitiveHelp,
 658     OleInPlaceObjectWindowless_InPlaceDeactivate,
 659     OleInPlaceObjectWindowless_UIDeactivate,
 660     OleInPlaceObjectWindowless_SetObjectRects,
 661     OleInPlaceObjectWindowless_ReactivateAndUndo,
 662     OleInPlaceObjectWindowless_OnWindowMessage,
 663     OleInPlaceObjectWindowless_GetDropTarget
 664 };
 665
 666 static inline WindowsMediaPlayer *impl_from_IOleControl(IOleControl *iface)
 667 {
 668     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IOleControl_iface);
 669 }
 670
 671 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 672 {
 673     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 674     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 675 }
 676
 677 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 678 {
 679     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 680     return IOleObject_AddRef(&This->IOleObject_iface);
 681 }
 682
 683 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 684 {
 685     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 686     return IOleObject_Release(&This->IOleObject_iface);
 687 }
 688
 689 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 690 {
 691     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 692     FIXME("(%p)->(%p)\n", This, pCI);
 693     return E_NOTIMPL;
 694 }
 695
 696 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *msg)
 697 {
 698     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 699     FIXME("(%p)->(%p)\n", This, msg);
 700     return E_NOTIMPL;
 701 }
 702
 703 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 704 {
 705     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 706     FIXME("(%p)->(%d)\n", This, dispID);
 707     return E_NOTIMPL;
 708 }
 709
 710 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL freeze)
 711 {
 712     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 713     FIXME("(%p)->(%x)\n", This, freeze);
 714     return E_NOTIMPL;
 715 }
 716
 717 static const IOleControlVtbl OleControlVtbl = {
 718     OleControl_QueryInterface,
 719     OleControl_AddRef,
 720     OleControl_Release,
 721     OleControl_GetControlInfo,
 722     OleControl_OnMnemonic,
 723     OleControl_OnAmbientPropertyChange,
 724     OleControl_FreezeEvents
 725 };
 726
 727 static inline WindowsMediaPlayer *impl_from_IProvideClassInfo2(IProvideClassInfo2 *iface)
 728 {
 729     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IProvideClassInfo2_iface);
 730 }
 731
 732 static HRESULT WINAPI ProvideClassInfo2_QueryInterface(IProvideClassInfo2 *iface, REFIID riid, void **ppv)
 733 {
 734     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 735     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 736 }
 737
 738 static ULONG WINAPI ProvideClassInfo2_AddRef(IProvideClassInfo2 *iface)
 739 {
 740     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 741     return IOleObject_AddRef(&This->IOleObject_iface);
 742 }
 743
 744 static ULONG WINAPI ProvideClassInfo2_Release(IProvideClassInfo2 *iface)
 745 {
 746     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 747     return IOleObject_Release(&This->IOleObject_iface);
 748 }
 749
 750 static HRESULT WINAPI ProvideClassInfo2_GetClassInfo(IProvideClassInfo2 *iface, ITypeInfo **ppTI)
 751 {
 752     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 753     FIXME("(%p)->(%p)\n", This, ppTI);
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideClassInfo2 *iface, DWORD dwGuidKind, GUID *pGUID)
 758 {
 759     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 760
 761     TRACE("(%p)->(%d %p)\n", This, dwGuidKind, pGUID);
 762
 763     if(dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID) {
 764         FIXME("Unexpected dwGuidKind %d\n", dwGuidKind);
 765         return E_INVALIDARG;
 766     }
 767
 768     *pGUID = IID__WMPOCXEvents;
 769     return S_OK;
 770 }
 771
 772 static const IProvideClassInfo2Vtbl ProvideClassInfo2Vtbl = {
 773     ProvideClassInfo2_QueryInterface,
 774     ProvideClassInfo2_AddRef,
 775     ProvideClassInfo2_Release,
 776     ProvideClassInfo2_GetClassInfo,
 777     ProvideClassInfo2_GetGUID
 778 };
 779
 780 static inline WindowsMediaPlayer *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
 781 {
 782     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IPersistStreamInit_iface);
 783 }
 784
 785 static HRESULT WINAPI PersistStreamInit_QueryInterface(IPersistStreamInit *iface,
 786                                                        REFIID riid, void **ppv)
 787 {
 788     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 789     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 790 }
 791
 792 static ULONG WINAPI PersistStreamInit_AddRef(IPersistStreamInit *iface)
 793 {
 794     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 795     return IOleObject_AddRef(&This->IOleObject_iface);
 796 }
 797
 798 static ULONG WINAPI PersistStreamInit_Release(IPersistStreamInit *iface)
 799 {
 800     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 801     return IOleObject_Release(&This->IOleObject_iface);
 802 }
 803
 804 static HRESULT WINAPI PersistStreamInit_GetClassID(IPersistStreamInit *iface, CLSID *pClassID)
 805 {
 806     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 807     FIXME("(%p)->(%p)\n", This, pClassID);
 808     return E_NOTIMPL;
 809 }
 810
 811 static HRESULT WINAPI PersistStreamInit_IsDirty(IPersistStreamInit *iface)
 812 {
 813     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 814     FIXME("(%p)\n", This);
 815     return E_NOTIMPL;
 816 }
 817
 818 static HRESULT WINAPI PersistStreamInit_Load(IPersistStreamInit *iface, LPSTREAM pStm)
 819 {
 820     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 821     FIXME("(%p)->(%p)\n", This, pStm);
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT WINAPI PersistStreamInit_Save(IPersistStreamInit *iface, LPSTREAM pStm,
 826                                              BOOL fClearDirty)
 827 {
 828     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 829     FIXME("(%p)->(%p %x)\n", This, pStm, fClearDirty);
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT WINAPI PersistStreamInit_GetSizeMax(IPersistStreamInit *iface,
 834                                                    ULARGE_INTEGER *pcbSize)
 835 {
 836     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 837     FIXME("(%p)->(%p)\n", This, pcbSize);
 838     return E_NOTIMPL;
 839 }
 840
 841 static HRESULT WINAPI PersistStreamInit_InitNew(IPersistStreamInit *iface)
 842 {
 843     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 844
 845     TRACE("(%p)\n", This);
 846
 847     if(!This->client_site)
 848         return E_FAIL;
 849
 850     /* Nothing to do, yet. */
 851     get_container_hwnd(This);
 852     return S_OK;
 853 }
 854
 855 static const IPersistStreamInitVtbl PersistStreamInitVtbl = {
 856     PersistStreamInit_QueryInterface,
 857     PersistStreamInit_AddRef,
 858     PersistStreamInit_Release,
 859     PersistStreamInit_GetClassID,
 860     PersistStreamInit_IsDirty,
 861     PersistStreamInit_Load,
 862     PersistStreamInit_Save,
 863     PersistStreamInit_GetSizeMax,
 864     PersistStreamInit_InitNew
 865 };
 866
 867 static inline WindowsMediaPlayer *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
 868 {
 869     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IConnectionPointContainer_iface);
 870 }
 871
 872 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
 873         REFIID riid, LPVOID *ppv)
 874 {
 875     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 876     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 877 }
 878
 879 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
 880 {
 881     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 882     return IOleObject_AddRef(&This->IOleObject_iface);
 883 }
 884
 885 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
 886 {
 887     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 888     return IOleObject_Release(&This->IOleObject_iface);
 889 }
 890
 891 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
 892         IEnumConnectionPoints **ppEnum)
 893 {
 894     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 895     FIXME("(%p)->(%p)\n", This, ppEnum);
 896     return E_NOTIMPL;
 897 }
 898
 899 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
 900         REFIID riid, IConnectionPoint **ppCP)
 901 {
 902     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 903     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppCP);
 904     return CONNECT_E_NOCONNECTION;
 905 }
 906
 907 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl =
 908 {
 909     ConnectionPointContainer_QueryInterface,
 910     ConnectionPointContainer_AddRef,
 911     ConnectionPointContainer_Release,
 912     ConnectionPointContainer_EnumConnectionPoints,
 913     ConnectionPointContainer_FindConnectionPoint
 914 };
 915
 916 HRESULT WINAPI WMPFactory_CreateInstance(IClassFactory *iface, IUnknown *outer,
 917         REFIID riid, void **ppv)
 918 {
 919     WindowsMediaPlayer *wmp;
 920     DWORD dpi_x, dpi_y;
 921     HDC hdc;
 922     HRESULT hres;
 923
 924     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
 925
 926     wmp = heap_alloc_zero(sizeof(*wmp));
 927     if(!wmp)
 928         return E_OUTOFMEMORY;
 929
 930     wmp->IOleObject_iface.lpVtbl = &OleObjectVtbl;
 931     wmp->IProvideClassInfo2_iface.lpVtbl = &ProvideClassInfo2Vtbl;
 932     wmp->IPersistStreamInit_iface.lpVtbl = &PersistStreamInitVtbl;
 933     wmp->IOleInPlaceObjectWindowless_iface.lpVtbl = &OleInPlaceObjectWindowlessVtbl;
 934     wmp->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
 935     wmp->IOleControl_iface.lpVtbl = &OleControlVtbl;
 936
 937     wmp->ref = 1;
 938
 939     init_player_ifaces(wmp);
 940
 941     hdc = GetDC(0);
 942     dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
 943     dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
 944     ReleaseDC(0, hdc);
 945
 946     wmp->extent.cx = MulDiv(192, 2540, dpi_x);
 947     wmp->extent.cy = MulDiv(192, 2540, dpi_y);
 948
 949     hres = IOleObject_QueryInterface(&wmp->IOleObject_iface, riid, ppv);
 950     IOleObject_Release(&wmp->IOleObject_iface);
 951     return hres;
 952 }