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     *ppv = NULL;
 223
 224     if(IsEqualGUID(riid, &IID_IUnknown)) {
 225         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 226         *ppv = &This->IOleObject_iface;
 227     }else if(IsEqualGUID(riid, &IID_IOleObject)) {
 228         TRACE("(%p)->(IID_IOleObject %p)\n", This, ppv);
 229         *ppv = &This->IOleObject_iface;
 230     }else if(IsEqualGUID(riid, &IID_IProvideClassInfo)) {
 231         TRACE("(%p)->(IID_IProvideClassInfo %p)\n", This, ppv);
 232         *ppv = &This->IProvideClassInfo2_iface;
 233     }else if(IsEqualGUID(riid, &IID_IProvideClassInfo2)) {
 234         TRACE("(%p)->(IID_IProvideClassInfo2 %p)\n", This, ppv);
 235         *ppv = &This->IProvideClassInfo2_iface;
 236     }else if(IsEqualGUID(riid, &IID_IPersist)) {
 237         TRACE("(%p)->(IID_IPersist %p)\n", This, ppv);
 238         *ppv = &This->IPersistStreamInit_iface;
 239     }else if(IsEqualGUID(riid, &IID_IPersistStreamInit)) {
 240         TRACE("(%p)->(IID_IPersistStreamInit %p)\n", This, ppv);
 241         *ppv = &This->IPersistStreamInit_iface;
 242     }else if(IsEqualGUID(riid, &IID_IOleWindow)) {
 243         TRACE("(%p)->(IID_IOleWindow %p)\n", This, ppv);
 244         *ppv = &This->IOleInPlaceObjectWindowless_iface;
 245     }else if(IsEqualGUID(riid, &IID_IOleInPlaceObject)) {
 246         TRACE("(%p)->(IID_IOleInPlaceObject %p)\n", This, ppv);
 247         *ppv = &This->IOleInPlaceObjectWindowless_iface;
 248     }else if(IsEqualGUID(riid, &IID_IOleInPlaceObjectWindowless)) {
 249         TRACE("(%p)->(IID_IOleInPlaceObjectWindowless %p)\n", This, ppv);
 250         *ppv = &This->IOleInPlaceObjectWindowless_iface;
 251     }else if(IsEqualGUID(riid, &IID_IConnectionPointContainer)) {
 252         TRACE("(%p)->(IID_IConnectionPointContainer %p)\n", This, ppv);
 253         *ppv = &This->IConnectionPointContainer_iface;
 254     }else if(IsEqualGUID(riid, &IID_IWMPCore)) {
 255         TRACE("(%p)->(IID_IWMPCore %p)\n", This, ppv);
 256         *ppv = &This->IWMPPlayer4_iface;
 257     }else if(IsEqualGUID(riid, &IID_IWMPCore2)) {
 258         TRACE("(%p)->(IID_IWMPCore2 %p)\n", This, ppv);
 259         *ppv = &This->IWMPPlayer4_iface;
 260     }else if(IsEqualGUID(riid, &IID_IWMPCore3)) {
 261         TRACE("(%p)->(IID_IWMPCore3 %p)\n", This, ppv);
 262         *ppv = &This->IWMPPlayer4_iface;
 263     }else if(IsEqualGUID(riid, &IID_IWMPPlayer4)) {
 264         TRACE("(%p)->(IID_IWMPPlayer4 %p)\n", This, ppv);
 265         *ppv = &This->IWMPPlayer4_iface;
 266     }else if(IsEqualGUID(riid, &IID_IWMPSettings)) {
 267         TRACE("(%p)->(IID_IWMPSettings %p)\n", This, ppv);
 268         *ppv = &This->IWMPSettings_iface;
 269     }else if(IsEqualGUID(riid, &IID_IOleControl)) {
 270         TRACE("(%p)->(IID_IOleControl %p)\n", This, ppv);
 271         *ppv = &This->IOleControl_iface;
 272     }else if(IsEqualGUID(riid, &IID_IMarshal)) {
 273         TRACE("(%p)->(IID_IMarshal %p)\n", This, ppv);
 274         return E_NOINTERFACE;
 275     }else if(IsEqualGUID(riid, &IID_IQuickActivate)) {
 276         TRACE("(%p)->(IID_IQuickActivate %p)\n", This, ppv);
 277         return E_NOINTERFACE;
 278     }else {
 279         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 280         return E_NOINTERFACE;
 281     }
 282
 283     IUnknown_AddRef((IUnknown*)*ppv);
 284     return S_OK;
 285 }
 286
 287 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
 288 {
 289     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 290     LONG ref = InterlockedIncrement(&This->ref);
 291
 292     TRACE("(%p) ref=%d\n", This, ref);
 293
 294     return ref;
 295 }
 296
 297 static ULONG WINAPI OleObject_Release(IOleObject *iface)
 298 {
 299     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 300     LONG ref = InterlockedDecrement(&This->ref);
 301
 302     TRACE("(%p) ref=%d\n", This, ref);
 303
 304     if(!ref) {
 305         release_client_site(This);
 306         heap_free(This);
 307     }
 308
 309     return ref;
 310 }
 311
 312 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
 313 {
 314     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 315     IOleControlSite *control_site;
 316     HRESULT hres;
 317
 318     TRACE("(%p)->(%p)\n", This, pClientSite);
 319
 320     release_client_site(This);
 321     if(!pClientSite)
 322         return S_OK;
 323
 324     IOleClientSite_AddRef(pClientSite);
 325     This->client_site = pClientSite;
 326
 327     hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleControlSite, (void**)&control_site);
 328     if(SUCCEEDED(hres)) {
 329         IDispatch *disp;
 330
 331         hres = IOleControlSite_GetExtendedControl(control_site, &disp);
 332         if(SUCCEEDED(hres) && disp) {
 333             FIXME("Use extended control\n");
 334             IDispatch_Release(disp);
 335         }
 336
 337         IOleControlSite_Release(control_site);
 338     }
 339
 340     return S_OK;
 341 }
 342
 343 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
 344 {
 345     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 346
 347     TRACE("(%p)->(%p)\n", This, ppClientSite);
 348
 349     *ppClientSite = This->client_site;
 350     return This->client_site ? S_OK : E_FAIL;
 351 }
 352
 353 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
 354 {
 355     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 356     FIXME("(%p)->(%s %s)\n", This, debugstr_w(szContainerApp), debugstr_w(szContainerObj));
 357     return E_NOTIMPL;
 358 }
 359
 360 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
 361 {
 362     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 363
 364     TRACE("(%p)->(%08x)\n", This, dwSaveOption);
 365
 366     if(dwSaveOption)
 367         FIXME("Unsupported option %d\n", dwSaveOption);
 368
 369     if(This->hwnd) /* FIXME: Possibly hide window */
 370         deactivate_window(This);
 371     return S_OK;
 372 }
 373
 374 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
 375 {
 376     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 377     FIXME("(%p %d %p)->()\n", This, dwWhichMoniker, pmk);
 378     return E_NOTIMPL;
 379 }
 380
 381 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
 382 {
 383     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 384     FIXME("(%p)->(%d %d %p)\n", This, dwAssign, dwWhichMoniker, ppmk);
 385     return E_NOTIMPL;
 386 }
 387
 388 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
 389                                         DWORD dwReserved)
 390 {
 391     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 392     FIXME("(%p)->(%p %x %d)\n", This, pDataObject, fCreation, dwReserved);
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
 397 {
 398     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 399     FIXME("(%p)->(%d %p)\n", This, dwReserved, ppDataObject);
 400     return E_NOTIMPL;
 401 }
 402
 403 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
 404                                         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
 405 {
 406     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 407
 408     switch(iVerb) {
 409     case OLEIVERB_INPLACEACTIVATE:
 410         TRACE("(%p)->(OLEIVERB_INPLACEACTIVATE)\n", This);
 411         return activate_inplace(This);
 412
 413     case OLEIVERB_HIDE:
 414         if(!This->hwnd) {
 415             FIXME("No window to hide\n");
 416             return E_UNEXPECTED;
 417         }
 418
 419         ShowWindow(This->hwnd, SW_HIDE);
 420         return S_OK;
 421
 422     default:
 423         FIXME("Unsupported iVerb %d\n", iVerb);
 424     }
 425
 426     return E_NOTIMPL;
 427 }
 428
 429 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
 430 {
 431     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 432     FIXME("(%p)->(%p)\n", This, ppEnumOleVerb);
 433     return E_NOTIMPL;
 434 }
 435
 436 static HRESULT WINAPI OleObject_Update(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_IsUpToDate(IOleObject *iface)
 444 {
 445     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 446     FIXME("(%p)\n", This);
 447     return E_NOTIMPL;
 448 }
 449
 450 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
 451 {
 452     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 453     FIXME("(%p)->(%p)\n", This, pClsid);
 454     return E_NOTIMPL;
 455 }
 456
 457 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
 458 {
 459     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 460     FIXME("(%p)->(%d %p)\n", This, dwFormOfType, pszUserType);
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 465 {
 466     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 467
 468     TRACE("(%p)->(%d %p)\n", This, dwDrawAspect, psizel);
 469
 470     if(dwDrawAspect != DVASPECT_CONTENT)
 471         return DV_E_DVASPECT;
 472
 473     This->extent = *psizel;
 474     return S_OK;
 475 }
 476
 477 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 478 {
 479     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 480
 481     TRACE("(%p)->(%d %p)\n", This, dwDrawAspect, psizel);
 482
 483     if(dwDrawAspect != DVASPECT_CONTENT)
 484         return E_FAIL;
 485
 486     *psizel = This->extent;
 487     return S_OK;
 488 }
 489
 490 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
 491 {
 492     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 493     FIXME("(%p)->(%p %p)\n", This, pAdvSink, pdwConnection);
 494     return E_NOTIMPL;
 495 }
 496
 497 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
 498 {
 499     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 500     FIXME("(%p)->(%d)\n", This, dwConnection);
 501     return E_NOTIMPL;
 502 }
 503
 504 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
 505 {
 506     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 507     FIXME("(%p)->(%p)\n", This, ppenumAdvise);
 508     return E_NOTIMPL;
 509 }
 510
 511 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
 512 {
 513     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 514
 515     TRACE("(%p)->(%d %p)\n", This, dwAspect, pdwStatus);
 516
 517     switch(dwAspect) {
 518     case DVASPECT_CONTENT:
 519         *pdwStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
 520             |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
 521         break;
 522     default:
 523         FIXME("Unhandled aspect %d\n", dwAspect);
 524         return E_NOTIMPL;
 525     }
 526
 527     return S_OK;
 528 }
 529
 530 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
 531 {
 532     WindowsMediaPlayer *This = impl_from_IOleObject(iface);
 533     FIXME("(%p)->(%p)\n", This, pLogpal);
 534     return E_NOTIMPL;
 535 }
 536
 537 static const IOleObjectVtbl OleObjectVtbl = {
 538     OleObject_QueryInterface,
 539     OleObject_AddRef,
 540     OleObject_Release,
 541     OleObject_SetClientSite,
 542     OleObject_GetClientSite,
 543     OleObject_SetHostNames,
 544     OleObject_Close,
 545     OleObject_SetMoniker,
 546     OleObject_GetMoniker,
 547     OleObject_InitFromData,
 548     OleObject_GetClipboardData,
 549     OleObject_DoVerb,
 550     OleObject_EnumVerbs,
 551     OleObject_Update,
 552     OleObject_IsUpToDate,
 553     OleObject_GetUserClassID,
 554     OleObject_GetUserType,
 555     OleObject_SetExtent,
 556     OleObject_GetExtent,
 557     OleObject_Advise,
 558     OleObject_Unadvise,
 559     OleObject_EnumAdvise,
 560     OleObject_GetMiscStatus,
 561     OleObject_SetColorScheme
 562 };
 563
 564 static inline WindowsMediaPlayer *impl_from_IOleInPlaceObjectWindowless(IOleInPlaceObjectWindowless *iface)
 565 {
 566     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IOleInPlaceObjectWindowless_iface);
 567 }
 568
 569 static HRESULT WINAPI OleInPlaceObjectWindowless_QueryInterface(IOleInPlaceObjectWindowless *iface,
 570         REFIID riid, void **ppv)
 571 {
 572     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 573     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 574 }
 575
 576 static ULONG WINAPI OleInPlaceObjectWindowless_AddRef(IOleInPlaceObjectWindowless *iface)
 577 {
 578     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 579     return IOleObject_AddRef(&This->IOleObject_iface);
 580 }
 581
 582 static ULONG WINAPI OleInPlaceObjectWindowless_Release(IOleInPlaceObjectWindowless *iface)
 583 {
 584     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 585     return IOleObject_Release(&This->IOleObject_iface);
 586 }
 587
 588 static HRESULT WINAPI OleInPlaceObjectWindowless_GetWindow(IOleInPlaceObjectWindowless *iface, HWND *phwnd)
 589 {
 590     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 591
 592     TRACE("(%p)->(%p)\n", This, phwnd);
 593
 594     *phwnd = This->hwnd;
 595     return This->hwnd ? S_OK : E_UNEXPECTED;
 596 }
 597
 598 static HRESULT WINAPI OleInPlaceObjectWindowless_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
 599         BOOL fEnterMode)
 600 {
 601     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 602     FIXME("(%p)->(%x)\n", This, fEnterMode);
 603     return E_NOTIMPL;
 604 }
 605
 606 static HRESULT WINAPI OleInPlaceObjectWindowless_InPlaceDeactivate(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_UIDeactivate(IOleInPlaceObjectWindowless *iface)
 614 {
 615     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 616     FIXME("(%p)\n", This);
 617     return E_NOTIMPL;
 618 }
 619
 620 static HRESULT WINAPI OleInPlaceObjectWindowless_SetObjectRects(IOleInPlaceObjectWindowless *iface,
 621         LPCRECT lprcPosRect, LPCRECT lprcClipRect)
 622 {
 623     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 624
 625     TRACE("(%p)->(%s %s)\n", This, wine_dbgstr_rect(lprcPosRect), wine_dbgstr_rect(lprcClipRect));
 626
 627     if(This->hwnd) {
 628        SetWindowPos(This->hwnd, NULL, lprcPosRect->left, lprcPosRect->top,
 629                lprcPosRect->right-lprcPosRect->left, lprcPosRect->bottom-lprcPosRect->top,
 630                SWP_NOZORDER | SWP_NOACTIVATE);
 631     }
 632
 633     return S_OK;
 634 }
 635
 636 static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
 637 {
 638     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 639     FIXME("(%p)\n", This);
 640     return E_NOTIMPL;
 641 }
 642
 643 static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
 644         UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
 645 {
 646     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 647     FIXME("(%p)->(%u %lu %lu %p)\n", This, msg, wParam, lParam, lpResult);
 648     return E_NOTIMPL;
 649 }
 650
 651 static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
 652         IDropTarget **ppDropTarget)
 653 {
 654     WindowsMediaPlayer *This = impl_from_IOleInPlaceObjectWindowless(iface);
 655     FIXME("(%p)->(%p)\n", This, ppDropTarget);
 656     return E_NOTIMPL;
 657 }
 658
 659 static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
 660     OleInPlaceObjectWindowless_QueryInterface,
 661     OleInPlaceObjectWindowless_AddRef,
 662     OleInPlaceObjectWindowless_Release,
 663     OleInPlaceObjectWindowless_GetWindow,
 664     OleInPlaceObjectWindowless_ContextSensitiveHelp,
 665     OleInPlaceObjectWindowless_InPlaceDeactivate,
 666     OleInPlaceObjectWindowless_UIDeactivate,
 667     OleInPlaceObjectWindowless_SetObjectRects,
 668     OleInPlaceObjectWindowless_ReactivateAndUndo,
 669     OleInPlaceObjectWindowless_OnWindowMessage,
 670     OleInPlaceObjectWindowless_GetDropTarget
 671 };
 672
 673 static inline WindowsMediaPlayer *impl_from_IOleControl(IOleControl *iface)
 674 {
 675     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IOleControl_iface);
 676 }
 677
 678 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 679 {
 680     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 681     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 682 }
 683
 684 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 685 {
 686     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 687     return IOleObject_AddRef(&This->IOleObject_iface);
 688 }
 689
 690 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 691 {
 692     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 693     return IOleObject_Release(&This->IOleObject_iface);
 694 }
 695
 696 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 697 {
 698     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 699     FIXME("(%p)->(%p)\n", This, pCI);
 700     return E_NOTIMPL;
 701 }
 702
 703 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *msg)
 704 {
 705     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 706     FIXME("(%p)->(%p)\n", This, msg);
 707     return E_NOTIMPL;
 708 }
 709
 710 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 711 {
 712     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 713     FIXME("(%p)->(%d)\n", This, dispID);
 714     return E_NOTIMPL;
 715 }
 716
 717 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL freeze)
 718 {
 719     WindowsMediaPlayer *This = impl_from_IOleControl(iface);
 720     FIXME("(%p)->(%x)\n", This, freeze);
 721     return E_NOTIMPL;
 722 }
 723
 724 static const IOleControlVtbl OleControlVtbl = {
 725     OleControl_QueryInterface,
 726     OleControl_AddRef,
 727     OleControl_Release,
 728     OleControl_GetControlInfo,
 729     OleControl_OnMnemonic,
 730     OleControl_OnAmbientPropertyChange,
 731     OleControl_FreezeEvents
 732 };
 733
 734 static inline WindowsMediaPlayer *impl_from_IProvideClassInfo2(IProvideClassInfo2 *iface)
 735 {
 736     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IProvideClassInfo2_iface);
 737 }
 738
 739 static HRESULT WINAPI ProvideClassInfo2_QueryInterface(IProvideClassInfo2 *iface, REFIID riid, void **ppv)
 740 {
 741     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 742     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 743 }
 744
 745 static ULONG WINAPI ProvideClassInfo2_AddRef(IProvideClassInfo2 *iface)
 746 {
 747     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 748     return IOleObject_AddRef(&This->IOleObject_iface);
 749 }
 750
 751 static ULONG WINAPI ProvideClassInfo2_Release(IProvideClassInfo2 *iface)
 752 {
 753     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 754     return IOleObject_Release(&This->IOleObject_iface);
 755 }
 756
 757 static HRESULT WINAPI ProvideClassInfo2_GetClassInfo(IProvideClassInfo2 *iface, ITypeInfo **ppTI)
 758 {
 759     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 760     FIXME("(%p)->(%p)\n", This, ppTI);
 761     return E_NOTIMPL;
 762 }
 763
 764 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideClassInfo2 *iface, DWORD dwGuidKind, GUID *pGUID)
 765 {
 766     WindowsMediaPlayer *This = impl_from_IProvideClassInfo2(iface);
 767
 768     TRACE("(%p)->(%d %p)\n", This, dwGuidKind, pGUID);
 769
 770     if(dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID) {
 771         FIXME("Unexpected dwGuidKind %d\n", dwGuidKind);
 772         return E_INVALIDARG;
 773     }
 774
 775     *pGUID = IID__WMPOCXEvents;
 776     return S_OK;
 777 }
 778
 779 static const IProvideClassInfo2Vtbl ProvideClassInfo2Vtbl = {
 780     ProvideClassInfo2_QueryInterface,
 781     ProvideClassInfo2_AddRef,
 782     ProvideClassInfo2_Release,
 783     ProvideClassInfo2_GetClassInfo,
 784     ProvideClassInfo2_GetGUID
 785 };
 786
 787 static inline WindowsMediaPlayer *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
 788 {
 789     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IPersistStreamInit_iface);
 790 }
 791
 792 static HRESULT WINAPI PersistStreamInit_QueryInterface(IPersistStreamInit *iface,
 793                                                        REFIID riid, void **ppv)
 794 {
 795     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 796     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 797 }
 798
 799 static ULONG WINAPI PersistStreamInit_AddRef(IPersistStreamInit *iface)
 800 {
 801     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 802     return IOleObject_AddRef(&This->IOleObject_iface);
 803 }
 804
 805 static ULONG WINAPI PersistStreamInit_Release(IPersistStreamInit *iface)
 806 {
 807     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 808     return IOleObject_Release(&This->IOleObject_iface);
 809 }
 810
 811 static HRESULT WINAPI PersistStreamInit_GetClassID(IPersistStreamInit *iface, CLSID *pClassID)
 812 {
 813     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 814     FIXME("(%p)->(%p)\n", This, pClassID);
 815     return E_NOTIMPL;
 816 }
 817
 818 static HRESULT WINAPI PersistStreamInit_IsDirty(IPersistStreamInit *iface)
 819 {
 820     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 821     FIXME("(%p)\n", This);
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT WINAPI PersistStreamInit_Load(IPersistStreamInit *iface, LPSTREAM pStm)
 826 {
 827     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 828     FIXME("(%p)->(%p)\n", This, pStm);
 829     return E_NOTIMPL;
 830 }
 831
 832 static HRESULT WINAPI PersistStreamInit_Save(IPersistStreamInit *iface, LPSTREAM pStm,
 833                                              BOOL fClearDirty)
 834 {
 835     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 836     FIXME("(%p)->(%p %x)\n", This, pStm, fClearDirty);
 837     return E_NOTIMPL;
 838 }
 839
 840 static HRESULT WINAPI PersistStreamInit_GetSizeMax(IPersistStreamInit *iface,
 841                                                    ULARGE_INTEGER *pcbSize)
 842 {
 843     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 844     FIXME("(%p)->(%p)\n", This, pcbSize);
 845     return E_NOTIMPL;
 846 }
 847
 848 static HRESULT WINAPI PersistStreamInit_InitNew(IPersistStreamInit *iface)
 849 {
 850     WindowsMediaPlayer *This = impl_from_IPersistStreamInit(iface);
 851
 852     TRACE("(%p)\n", This);
 853
 854     if(!This->client_site)
 855         return E_FAIL;
 856
 857     /* Nothing to do, yet. */
 858     get_container_hwnd(This);
 859     return S_OK;
 860 }
 861
 862 static const IPersistStreamInitVtbl PersistStreamInitVtbl = {
 863     PersistStreamInit_QueryInterface,
 864     PersistStreamInit_AddRef,
 865     PersistStreamInit_Release,
 866     PersistStreamInit_GetClassID,
 867     PersistStreamInit_IsDirty,
 868     PersistStreamInit_Load,
 869     PersistStreamInit_Save,
 870     PersistStreamInit_GetSizeMax,
 871     PersistStreamInit_InitNew
 872 };
 873
 874 static inline WindowsMediaPlayer *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
 875 {
 876     return CONTAINING_RECORD(iface, WindowsMediaPlayer, IConnectionPointContainer_iface);
 877 }
 878
 879 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
 880         REFIID riid, LPVOID *ppv)
 881 {
 882     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 883     return IOleObject_QueryInterface(&This->IOleObject_iface, riid, ppv);
 884 }
 885
 886 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
 887 {
 888     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 889     return IOleObject_AddRef(&This->IOleObject_iface);
 890 }
 891
 892 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
 893 {
 894     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 895     return IOleObject_Release(&This->IOleObject_iface);
 896 }
 897
 898 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
 899         IEnumConnectionPoints **ppEnum)
 900 {
 901     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 902     FIXME("(%p)->(%p)\n", This, ppEnum);
 903     return E_NOTIMPL;
 904 }
 905
 906 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
 907         REFIID riid, IConnectionPoint **ppCP)
 908 {
 909     WindowsMediaPlayer *This = impl_from_IConnectionPointContainer(iface);
 910     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppCP);
 911     return CONNECT_E_NOCONNECTION;
 912 }
 913
 914 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl =
 915 {
 916     ConnectionPointContainer_QueryInterface,
 917     ConnectionPointContainer_AddRef,
 918     ConnectionPointContainer_Release,
 919     ConnectionPointContainer_EnumConnectionPoints,
 920     ConnectionPointContainer_FindConnectionPoint
 921 };
 922
 923 HRESULT WINAPI WMPFactory_CreateInstance(IClassFactory *iface, IUnknown *outer,
 924         REFIID riid, void **ppv)
 925 {
 926     WindowsMediaPlayer *wmp;
 927     DWORD dpi_x, dpi_y;
 928     HDC hdc;
 929     HRESULT hres;
 930
 931     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
 932
 933     wmp = heap_alloc_zero(sizeof(*wmp));
 934     if(!wmp)
 935         return E_OUTOFMEMORY;
 936
 937     wmp->IOleObject_iface.lpVtbl = &OleObjectVtbl;
 938     wmp->IProvideClassInfo2_iface.lpVtbl = &ProvideClassInfo2Vtbl;
 939     wmp->IPersistStreamInit_iface.lpVtbl = &PersistStreamInitVtbl;
 940     wmp->IOleInPlaceObjectWindowless_iface.lpVtbl = &OleInPlaceObjectWindowlessVtbl;
 941     wmp->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
 942     wmp->IOleControl_iface.lpVtbl = &OleControlVtbl;
 943
 944     wmp->ref = 1;
 945
 946     init_player_ifaces(wmp);
 947
 948     hdc = GetDC(0);
 949     dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
 950     dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
 951     ReleaseDC(0, hdc);
 952
 953     wmp->extent.cx = MulDiv(192, 2540, dpi_x);
 954     wmp->extent.cy = MulDiv(192, 2540, dpi_y);
 955
 956     hres = IOleObject_QueryInterface(&wmp->IOleObject_iface, riid, ppv);
 957     IOleObject_Release(&wmp->IOleObject_iface);
 958     return hres;
 959 }