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