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     static WNDCLASSEXW wndclass = {
  98         sizeof(wndclass), CS_DBLCLKS, wmp_wnd_proc, 0, 0,
  99         NULL, NULL, NULL, NULL, NULL,
 100         /* It seems that native uses ATL for this. We use a fake name to make tests happy. */
 101         L"ATL:WMP", NULL
 102     };
 103
 104     wndclass.hInstance = wmp_instance;
 105     wmp_class = RegisterClassExW(&wndclass);
 106     return TRUE;
 107 }
 108
 109 void unregister_wmp_class(void)
 110 {
 111     if(wmp_class)
 112         UnregisterClassW(MAKEINTRESOURCEW(wmp_class), wmp_instance);
 113 }
 114
 115 static HWND create_wmp_window(WindowsMediaPlayer *wmp, const RECT *posrect)
 116 {
 117     static INIT_ONCE class_init_once = INIT_ONCE_STATIC_INIT;
 118
 119     InitOnceExecuteOnce(&class_init_once, register_wmp_class, NULL, NULL);
 120     if(!wmp_class)
 121         return NULL;
 122
 123     return CreateWindowExW(0, MAKEINTRESOURCEW(wmp_class), NULL, WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_VISIBLE|WS_CHILD,
 124             posrect->left, posrect->top, posrect->right-posrect->left, posrect->bottom-posrect->top,
 125             get_container_hwnd(wmp), NULL, wmp_instance, NULL);
 126 }
 127
 128 static HRESULT activate_inplace(WindowsMediaPlayer *This)
 129 {
 130     IOleInPlaceSiteWindowless *ipsite_windowless;
 131     IOleInPlaceSiteEx *ipsiteex = NULL;
 132     IOleInPlaceSite *ipsite;
 133     IOleInPlaceUIWindow *ip_window = NULL;
 134     IOleInPlaceFrame *ip_frame = NULL;
 135     RECT posrect = {0}, cliprect = {0};
 136     OLEINPLACEFRAMEINFO frameinfo = { sizeof(frameinfo) };
 137     HRESULT hres;
 138
 139     if(This->hwnd) {
 140         FIXME("Already activated\n");
 141         return E_UNEXPECTED;
 142     }
 143
 144     hres = IOleClientSite_QueryInterface(This->client_site, &IID_IOleInPlaceSiteWindowless, (void**)&ipsite_windowless);
 145     if(SUCCEEDED(hres)) {
 146         hres = IOleInPlaceSiteWindowless_CanWindowlessActivate(ipsite_windowless);
 147         IOleInPlaceSiteWindowless_Release(ipsite_windowless);
 148         if(hres == S_OK)
 149             FIXME("Windowless activation not supported\n");
 150         ipsiteex = (IOleInPlaceSiteEx*)ipsite_windowless;
 151     }else {
 152         IOleClientSite_QueryInterface(This->client_site, &IID_IOleInPlaceSiteEx, (void**)&ipsiteex);
 153     }
 154
 155     if(ipsiteex) {
 156         BOOL redraw = FALSE; /* Not really used. */
 157         IOleInPlaceSiteEx_OnInPlaceActivateEx(ipsiteex, &redraw, 0);
 158         ipsite = (IOleInPlaceSite*)ipsiteex;
 159     }else {
 160         IOleClientSite_QueryInterface(This->client_site, &IID_IOleInPlaceSite, (void**)&ipsite);
 161         if(FAILED(hres)) {
 162             FIXME("No IOleInPlaceSite instance\n");
 163             return hres;
 164         }
 165
 166         IOleInPlaceSite_OnInPlaceActivate(ipsite);
 167     }
 168
 169     hres = IOleInPlaceSite_GetWindowContext(ipsite, &ip_frame, &ip_window, &posrect, &cliprect, &frameinfo);
 170     IOleInPlaceSite_Release(ipsite);
 171     if(FAILED(hres)) {
 172         FIXME("GetWindowContext failed: %08lx\n", hres);
 173         return hres;
 174     }
 175
 176     This->hwnd = create_wmp_window(This, &posrect);
 177     if(!This->hwnd)
 178         return E_FAIL;
 179
 180     IOleClientSite_ShowObject(This->client_site);
 181     return S_OK;
 182 }
 183
 184 static void deactivate_window(WindowsMediaPlayer *This)
 185 {
 186     IOleInPlaceSite *ip_site;
 187     HRESULT hres;
 188
 189     hres = IOleClientSite_QueryInterface(This->client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
 190     if(SUCCEEDED(hres)) {
 191         IOleInPlaceSite_OnInPlaceDeactivate(ip_site);
 192         IOleInPlaceSite_Release(ip_site);
 193     }
 194
 195     DestroyWindow(This->hwnd);
 196     This->hwnd = NULL;
 197 }
 198
 199 static void release_client_site(WindowsMediaPlayer *This)
 200 {
 201     if(!This->client_site)
 202         return;
 203
 204     if(This->hwnd)
 205         deactivate_window(This);
 206
 207     IOleClientSite_Release(This->client_site);
 208     This->client_site = NULL;
 209 }
 210
 211 static inline WindowsMediaPlayer *impl_from_IOleObject(IOleObject *iface)
 212 {
 213     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IOleObject_iface);
 214 }
 215
 216 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
 217 {
 218     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 219
 220     *ppv = NULL;
 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_IWMPPlayer)) {
 265         TRACE("(%p)->(IID_IWMPPlayer %p)\n", This, ppv);
 266         *ppv = &This->IWMPPlayer_iface;
 267     }else if(IsEqualGUID(riid, &IID_IWMPSettings)) {
 268         TRACE("(%p)->(IID_IWMPSettings %p)\n", This, ppv);
 269         *ppv = &This->IWMPSettings_iface;
 270     }else if(IsEqualGUID(riid, &IID_IOleControl)) {
 271         TRACE("(%p)->(IID_IOleControl %p)\n", This, ppv);
 272         *ppv = &This->IOleControl_iface;
 273     }else if(IsEqualGUID(riid, &IID_IMarshal)) {
 274         TRACE("(%p)->(IID_IMarshal %p)\n", This, ppv);
 275         return E_NOINTERFACE;
 276     }else if(IsEqualGUID(riid, &IID_IQuickActivate)) {
 277         TRACE("(%p)->(IID_IQuickActivate %p)\n", This, ppv);
 278         return E_NOINTERFACE;
 279     }else {
 280         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 281         return E_NOINTERFACE;
 282     }
 283
 284     IUnknown_AddRef((IUnknown*)*ppv);
 285     return S_OK;
 286 }
 287
 288 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
 289 {
 290     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 291     LONG ref = InterlockedIncrement(&This->ref);
 292
 293     TRACE("(%p) ref=%ld\n", This, ref);
 294
 295     return ref;
 296 }
 297
 298 static ULONG WINAPI OleObject_Release(IOleObject *iface)
 299 {
 300     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 301     LONG ref = InterlockedDecrement(&This->ref);
 302
 303     TRACE("(%p) ref=%ld\n", This, ref);
 304
 305     if(!ref) {
 306         release_client_site(This);
 307         destroy_player(This);
 308         ConnectionPointContainer_Destroy(This);
 309         free(This);
 310     }
 311
 312     return ref;
 313 }
 314
 315 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
 316 {
 317     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 318     IOleControlSite *control_site;
 319     HRESULT hres;
 320
 321     TRACE("(%p)->(%p)\n", This, pClientSite);
 322
 323     release_client_site(This);
 324     if(!pClientSite)
 325         return S_OK;
 326
 327     IOleClientSite_AddRef(pClientSite);
 328     This->client_site = pClientSite;
 329
 330     hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleControlSite, (void**)&control_site);
 331     if(SUCCEEDED(hres)) {
 332         IDispatch *disp;
 333
 334         hres = IOleControlSite_GetExtendedControl(control_site, &disp);
 335         if(SUCCEEDED(hres) && disp) {
 336             FIXME("Use extended control\n");
 337             IDispatch_Release(disp);
 338         }
 339
 340         IOleControlSite_Release(control_site);
 341     }
 342
 343     return S_OK;
 344 }
 345
 346 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
 347 {
 348     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 349
 350     TRACE("(%p)->(%p)\n", This, ppClientSite);
 351
 352     *ppClientSite = This->client_site;
 353     return This->client_site ? S_OK : E_FAIL;
 354 }
 355
 356 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
 357 {
 358     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 359     FIXME("(%p)->(%s %s)\n", This, debugstr_w(szContainerApp), debugstr_w(szContainerObj));
 360     return E_NOTIMPL;
 361 }
 362
 363 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
 364 {
 365     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 366
 367     TRACE("(%p)->(%08lx)\n", This, dwSaveOption);
 368
 369     if(dwSaveOption)
 370         FIXME("Unsupported option %ld\n", dwSaveOption);
 371
 372     if(This->hwnd) /* FIXME: Possibly hide window */
 373         deactivate_window(This);
 374     return S_OK;
 375 }
 376
 377 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
 378 {
 379     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 380     FIXME("(%p %ld %p)->()\n", This, dwWhichMoniker, pmk);
 381     return E_NOTIMPL;
 382 }
 383
 384 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
 385 {
 386     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 387     FIXME("(%p)->(%ld %ld %p)\n", This, dwAssign, dwWhichMoniker, ppmk);
 388     return E_NOTIMPL;
 389 }
 390
 391 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
 392                                         DWORD dwReserved)
 393 {
 394     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 395     FIXME("(%p)->(%p %x %ld)\n", This, pDataObject, fCreation, dwReserved);
 396     return E_NOTIMPL;
 397 }
 398
 399 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
 400 {
 401     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 402     FIXME("(%p)->(%ld %p)\n", This, dwReserved, ppDataObject);
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
 407                                         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
 408 {
 409     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 410
 411     switch(iVerb) {
 412     case OLEIVERB_INPLACEACTIVATE:
 413         TRACE("(%p)->(OLEIVERB_INPLACEACTIVATE)\n", This);
 414         return activate_inplace(This);
 415
 416     case OLEIVERB_HIDE:
 417         if(!This->hwnd) {
 418             FIXME("No window to hide\n");
 419             return E_UNEXPECTED;
 420         }
 421
 422         ShowWindow(This->hwnd, SW_HIDE);
 423         return S_OK;
 424
 425     default:
 426         FIXME("Unsupported iVerb %ld\n", iVerb);
 427     }
 428
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
 433 {
 434     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 435     FIXME("(%p)->(%p)\n", This, ppEnumOleVerb);
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
 440 {
 441     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 442     FIXME("(%p)\n", This);
 443     return E_NOTIMPL;
 444 }
 445
 446 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
 447 {
 448     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 449     FIXME("(%p)\n", This);
 450     return E_NOTIMPL;
 451 }
 452
 453 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
 454 {
 455     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 456     FIXME("(%p)->(%p)\n", This, pClsid);
 457     return E_NOTIMPL;
 458 }
 459
 460 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
 461 {
 462     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 463     FIXME("(%p)->(%ld %p)\n", This, dwFormOfType, pszUserType);
 464     return E_NOTIMPL;
 465 }
 466
 467 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 468 {
 469     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 470
 471     TRACE("(%p)->(%ld %p)\n", This, dwDrawAspect, psizel);
 472
 473     if(dwDrawAspect != DVASPECT_CONTENT)
 474         return DV_E_DVASPECT;
 475
 476     This->extent = *psizel;
 477     return S_OK;
 478 }
 479
 480 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 481 {
 482     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 483
 484     TRACE("(%p)->(%ld %p)\n", This, dwDrawAspect, psizel);
 485
 486     if(dwDrawAspect != DVASPECT_CONTENT)
 487         return E_FAIL;
 488
 489     *psizel = This->extent;
 490     return S_OK;
 491 }
 492
 493 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
 494 {
 495     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 496     FIXME("(%p)->(%p %p)\n", This, pAdvSink, pdwConnection);
 497     return E_NOTIMPL;
 498 }
 499
 500 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
 501 {
 502     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 503     FIXME("(%p)->(%ld)\n", This, dwConnection);
 504     return E_NOTIMPL;
 505 }
 506
 507 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
 508 {
 509     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 510     FIXME("(%p)->(%p)\n", This, ppenumAdvise);
 511     return E_NOTIMPL;
 512 }
 513
 514 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
 515 {
 516     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 517
 518     TRACE("(%p)->(%ld %p)\n", This, dwAspect, pdwStatus);
 519
 520     switch(dwAspect) {
 521     case DVASPECT_CONTENT:
 522         *pdwStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
 523             |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
 524         break;
 525     default:
 526         FIXME("Unhandled aspect %ld\n", dwAspect);
 527         return E_NOTIMPL;
 528     }
 529
 530     return S_OK;
 531 }
 532
 533 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
 534 {
 535     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 536     FIXME("(%p)->(%p)\n", This, pLogpal);
 537     return E_NOTIMPL;
 538 }
 539
 540 static const IOleObjectVtbl OleObjectVtbl = {
 541     OleObject_QueryInterface,
 542     OleObject_AddRef,
 543     OleObject_Release,
 544     OleObject_SetClientSite,
 545     OleObject_GetClientSite,
 546     OleObject_SetHostNames,
 547     OleObject_Close,
 548     OleObject_SetMoniker,
 549     OleObject_GetMoniker,
 550     OleObject_InitFromData,
 551     OleObject_GetClipboardData,
 552     OleObject_DoVerb,
 553     OleObject_EnumVerbs,
 554     OleObject_Update,
 555     OleObject_IsUpToDate,
 556     OleObject_GetUserClassID,
 557     OleObject_GetUserType,
 558     OleObject_SetExtent,
 559     OleObject_GetExtent,
 560     OleObject_Advise,
 561     OleObject_Unadvise,
 562     OleObject_EnumAdvise,
 563     OleObject_GetMiscStatus,
 564     OleObject_SetColorScheme
 565 };
 566
 567 static inline WindowsMediaPlayer *impl_from_IOleInPlaceObjectWindowless(IOleInPlaceObjectWindowless *iface)
 568 {
 569     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IOleInPlaceObjectWindowless_iface);
 570 }
 571
 572 static HRESULT WINAPI OleInPlaceObjectWindowless_QueryInterface(IOleInPlaceObjectWindowless *iface,
 573         REFIID riid, void **ppv)
 574 {
 575     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 576     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 577 }
 578
 579 static ULONG WINAPI OleInPlaceObjectWindowless_AddRef(IOleInPlaceObjectWindowless *iface)
 580 {
 581     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 582     return IOleObject_AddRef(&This->IOleObject_iface);
 583 }
 584
 585 static ULONG WINAPI OleInPlaceObjectWindowless_Release(IOleInPlaceObjectWindowless *iface)
 586 {
 587     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 588     return IOleObject_Release(&This->IOleObject_iface);
 589 }
 590
 591 static HRESULT WINAPI OleInPlaceObjectWindowless_GetWindow(IOleInPlaceObjectWindowless *iface, HWND *phwnd)
 592 {
 593     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 594
 595     TRACE("(%p)->(%p)\n", This, phwnd);
 596
 597     *phwnd = This->hwnd;
 598     return This->hwnd ? S_OK : E_UNEXPECTED;
 599 }
 600
 601 static HRESULT WINAPI OleInPlaceObjectWindowless_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
 602         BOOL fEnterMode)
 603 {
 604     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 605     FIXME("(%p)->(%x)\n", This, fEnterMode);
 606     return E_NOTIMPL;
 607 }
 608
 609 static HRESULT WINAPI OleInPlaceObjectWindowless_InPlaceDeactivate(IOleInPlaceObjectWindowless *iface)
 610 {
 611     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 612     FIXME("(%p)\n", This);
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI OleInPlaceObjectWindowless_UIDeactivate(IOleInPlaceObjectWindowless *iface)
 617 {
 618     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 619     FIXME("(%p)\n", This);
 620     return E_NOTIMPL;
 621 }
 622
 623 static HRESULT WINAPI OleInPlaceObjectWindowless_SetObjectRects(IOleInPlaceObjectWindowless *iface,
 624         LPCRECT lprcPosRect, LPCRECT lprcClipRect)
 625 {
 626     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 627
 628     TRACE("(%p)->(%s %s)\n", This, wine_dbgstr_rect(lprcPosRect), wine_dbgstr_rect(lprcClipRect));
 629
 630     if(This->hwnd) {
 631        SetWindowPos(This->hwnd, NULL, lprcPosRect->left, lprcPosRect->top,
 632                lprcPosRect->right-lprcPosRect->left, lprcPosRect->bottom-lprcPosRect->top,
 633                SWP_NOZORDER | SWP_NOACTIVATE);
 634     }
 635
 636     return S_OK;
 637 }
 638
 639 static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
 640 {
 641     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 642     FIXME("(%p)\n", This);
 643     return E_NOTIMPL;
 644 }
 645
 646 static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
 647         UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
 648 {
 649     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 650     FIXME("(%p)->(%u %Iu %Iu %p)\n", This, msg, wParam, lParam, lpResult);
 651     return E_NOTIMPL;
 652 }
 653
 654 static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
 655         IDropTarget **ppDropTarget)
 656 {
 657     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 658     FIXME("(%p)->(%p)\n", This, ppDropTarget);
 659     return E_NOTIMPL;
 660 }
 661
 662 static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
 663     OleInPlaceObjectWindowless_QueryInterface,
 664     OleInPlaceObjectWindowless_AddRef,
 665     OleInPlaceObjectWindowless_Release,
 666     OleInPlaceObjectWindowless_GetWindow,
 667     OleInPlaceObjectWindowless_ContextSensitiveHelp,
 668     OleInPlaceObjectWindowless_InPlaceDeactivate,
 669     OleInPlaceObjectWindowless_UIDeactivate,
 670     OleInPlaceObjectWindowless_SetObjectRects,
 671     OleInPlaceObjectWindowless_ReactivateAndUndo,
 672     OleInPlaceObjectWindowless_OnWindowMessage,
 673     OleInPlaceObjectWindowless_GetDropTarget
 674 };
 675
 676 static inline WindowsMediaPlayer *impl_from_IOleControl(IOleControl *iface)
 677 {
 678     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IOleControl_iface);
 679 }
 680
 681 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 682 {
 683     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 684     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 685 }
 686
 687 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 688 {
 689     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 690     return IOleObject_AddRef(&This->IOleObject_iface);
 691 }
 692
 693 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 694 {
 695     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 696     return IOleObject_Release(&This->IOleObject_iface);
 697 }
 698
 699 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 700 {
 701     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 702     FIXME("(%p)->(%p)\n", This, pCI);
 703     return E_NOTIMPL;
 704 }
 705
 706 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *msg)
 707 {
 708     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 709     FIXME("(%p)->(%p)\n", This, msg);
 710     return E_NOTIMPL;
 711 }
 712
 713 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 714 {
 715     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 716     FIXME("(%p)->(%ld)\n", This, dispID);
 717     return E_NOTIMPL;
 718 }
 719
 720 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL freeze)
 721 {
 722     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 723     FIXME("(%p)->(%x)\n", This, freeze);
 724     return E_NOTIMPL;
 725 }
 726
 727 static const IOleControlVtbl OleControlVtbl = {
 728     OleControl_QueryInterface,
 729     OleControl_AddRef,
 730     OleControl_Release,
 731     OleControl_GetControlInfo,
 732     OleControl_OnMnemonic,
 733     OleControl_OnAmbientPropertyChange,
 734     OleControl_FreezeEvents
 735 };
 736
 737 static inline WindowsMediaPlayer *impl_from_IProvideClassInfo2(IProvideClassInfo2 *iface)
 738 {
 739     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IProvideClassInfo2_iface);
 740 }
 741
 742 static HRESULT WINAPI ProvideClassInfo2_QueryInterface(IProvideClassInfo2 *iface, REFIID riid, void **ppv)
 743 {
 744     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 745     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 746 }
 747
 748 static ULONG WINAPI ProvideClassInfo2_AddRef(IProvideClassInfo2 *iface)
 749 {
 750     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 751     return IOleObject_AddRef(&This->IOleObject_iface);
 752 }
 753
 754 static ULONG WINAPI ProvideClassInfo2_Release(IProvideClassInfo2 *iface)
 755 {
 756     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 757     return IOleObject_Release(&This->IOleObject_iface);
 758 }
 759
 760 static HRESULT WINAPI ProvideClassInfo2_GetClassInfo(IProvideClassInfo2 *iface, ITypeInfo **ti)
 761 {
 762     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 763
 764     TRACE("(%p)->(%p)\n", This, ti);
 765
 766     if (!ti)
 767         return E_POINTER;
 768
 769     return get_typeinfo(WindowsMediaPlayer_tid, ti);
 770 }
 771
 772 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideClassInfo2 *iface, DWORD dwGuidKind, GUID *pGUID)
 773 {
 774     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 775
 776     TRACE("(%p)->(%ld %p)\n", This, dwGuidKind, pGUID);
 777
 778     if(dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID) {
 779         FIXME("Unexpected dwGuidKind %ld\n", dwGuidKind);
 780         return E_INVALIDARG;
 781     }
 782
 783     *pGUID = IID__WMPOCXEvents;
 784     return S_OK;
 785 }
 786
 787 static const IProvideClassInfo2Vtbl ProvideClassInfo2Vtbl = {
 788     ProvideClassInfo2_QueryInterface,
 789     ProvideClassInfo2_AddRef,
 790     ProvideClassInfo2_Release,
 791     ProvideClassInfo2_GetClassInfo,
 792     ProvideClassInfo2_GetGUID
 793 };
 794
 795 static inline WindowsMediaPlayer *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
 796 {
 797     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IPersistStreamInit_iface);
 798 }
 799
 800 static HRESULT WINAPI PersistStreamInit_QueryInterface(IPersistStreamInit *iface,
 801                                                        REFIID riid, void **ppv)
 802 {
 803     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 804     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 805 }
 806
 807 static ULONG WINAPI PersistStreamInit_AddRef(IPersistStreamInit *iface)
 808 {
 809     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 810     return IOleObject_AddRef(&This->IOleObject_iface);
 811 }
 812
 813 static ULONG WINAPI PersistStreamInit_Release(IPersistStreamInit *iface)
 814 {
 815     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 816     return IOleObject_Release(&This->IOleObject_iface);
 817 }
 818
 819 static HRESULT WINAPI PersistStreamInit_GetClassID(IPersistStreamInit *iface, CLSID *pClassID)
 820 {
 821     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 822     FIXME("(%p)->(%p)\n", This, pClassID);
 823     return E_NOTIMPL;
 824 }
 825
 826 static HRESULT WINAPI PersistStreamInit_IsDirty(IPersistStreamInit *iface)
 827 {
 828     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 829     FIXME("(%p)\n", This);
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT WINAPI PersistStreamInit_Load(IPersistStreamInit *iface, LPSTREAM pStm)
 834 {
 835     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 836     FIXME("(%p)->(%p)\n", This, pStm);
 837     return E_NOTIMPL;
 838 }
 839
 840 static HRESULT WINAPI PersistStreamInit_Save(IPersistStreamInit *iface, LPSTREAM pStm,
 841                                              BOOL fClearDirty)
 842 {
 843     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 844     FIXME("(%p)->(%p %x)\n", This, pStm, fClearDirty);
 845     return E_NOTIMPL;
 846 }
 847
 848 static HRESULT WINAPI PersistStreamInit_GetSizeMax(IPersistStreamInit *iface,
 849                                                    ULARGE_INTEGER *pcbSize)
 850 {
 851     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 852     FIXME("(%p)->(%p)\n", This, pcbSize);
 853     return E_NOTIMPL;
 854 }
 855
 856 static HRESULT WINAPI PersistStreamInit_InitNew(IPersistStreamInit *iface)
 857 {
 858     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 859
 860     TRACE("(%p)\n", This);
 861
 862     if(!This->client_site)
 863         return E_FAIL;
 864
 865     /* Nothing to do, yet. */
 866     get_container_hwnd(This);
 867     return S_OK;
 868 }
 869
 870 static const IPersistStreamInitVtbl PersistStreamInitVtbl = {
 871     PersistStreamInit_QueryInterface,
 872     PersistStreamInit_AddRef,
 873     PersistStreamInit_Release,
 874     PersistStreamInit_GetClassID,
 875     PersistStreamInit_IsDirty,
 876     PersistStreamInit_Load,
 877     PersistStreamInit_Save,
 878     PersistStreamInit_GetSizeMax,
 879     PersistStreamInit_InitNew
 880 };
 881
 882 HRESULT WINAPI WMPFactory_CreateInstance(IClassFactory *iface, IUnknown *outer,
 883         REFIID riid, void **ppv)
 884 {
 885     WindowsMediaPlayer *wmp;
 886     DWORD dpi_x, dpi_y;
 887     HDC hdc;
 888     HRESULT hres;
 889
 890     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
 891
 892     wmp = calloc(1, sizeof(*wmp));
 893     if(!wmp)
 894         return E_OUTOFMEMORY;
 895
 896     wmp->IOleObject_iface.lpVtbl = &OleObjectVtbl;
 897     wmp->IProvideClassInfo2_iface.lpVtbl = &ProvideClassInfo2Vtbl;
 898     wmp->IPersistStreamInit_iface.lpVtbl = &PersistStreamInitVtbl;
 899     wmp->IOleInPlaceObjectWindowless_iface.lpVtbl = &OleInPlaceObjectWindowlessVtbl;
 900     wmp->IOleControl_iface.lpVtbl = &OleControlVtbl;
 901
 902     wmp->ref = 1;
 903
 904     if (init_player(wmp)) {
 905         ConnectionPointContainer_Init(wmp);
 906         hdc = GetDC(0);
 907         dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
 908         dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
 909         ReleaseDC(0, hdc);
 910
 911         wmp->extent.cx = MulDiv(192, 2540, dpi_x);
 912         wmp->extent.cy = MulDiv(192, 2540, dpi_y);
 913
 914         hres = IOleObject_QueryInterface(&wmp->IOleObject_iface, riid, ppv);
 915     } else {
 916         hres = E_FAIL;
 917     }
 918     IOleObject_Release(&wmp->IOleObject_iface);
 919     return hres;
 920 }