dlls/atl/atl_ax.c

   1 /*
   2  * Active Template Library ActiveX functions (atl.dll)
   3  *
   4  * Copyright 2006 Andrey Turkin
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29 #include "winuser.h"
  30 #include "wine/debug.h"
  31 #include "objbase.h"
  32 #include "objidl.h"
  33 #include "ole2.h"
  34 #include "exdisp.h"
  35 #include "atlbase.h"
  36 #include "atliface.h"
  37 #include "atlwin.h"
  38 #include "shlwapi.h"
  39
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(atl);
  42
  43 typedef struct IOCS {
  44     IOleClientSite            IOleClientSite_iface;
  45     IOleContainer             IOleContainer_iface;
  46     IOleInPlaceSiteWindowless IOleInPlaceSiteWindowless_iface;
  47     IOleInPlaceFrame          IOleInPlaceFrame_iface;
  48     IOleControlSite           IOleControlSite_iface;
  49
  50     LONG ref;
  51     HWND hWnd;
  52     IOleObject *control;
  53     RECT size;
  54     WNDPROC OrigWndProc;
  55     BOOL fActive, fInPlace, fWindowless;
  56 } IOCS;
  57
  58 static const WCHAR wine_atl_iocsW[] = {'_','_','W','I','N','E','_','A','T','L','_','I','O','C','S','\0'};
  59
  60 /**********************************************************************
  61  * AtlAxWin class window procedure
  62  */
  63 static LRESULT CALLBACK AtlAxWin_wndproc( HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam )
  64 {
  65     if ( wMsg == WM_CREATE )
  66     {
  67             DWORD len = GetWindowTextLengthW( hWnd ) + 1;
  68             WCHAR *ptr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
  69             if (!ptr)
  70                 return 1;
  71             GetWindowTextW( hWnd, ptr, len );
  72             AtlAxCreateControlEx( ptr, hWnd, NULL, NULL, NULL, NULL, NULL );
  73             HeapFree( GetProcessHeap(), 0, ptr );
  74             return 0;
  75     }
  76     return DefWindowProcW( hWnd, wMsg, wParam, lParam );
  77 }
  78
  79 /***********************************************************************
  80  *           AtlAxWinInit          [atl100.@]
  81  * Initializes the control-hosting code: registering the AtlAxWin,
  82  * AtlAxWin7 and AtlAxWinLic7 window classes and some messages.
  83  *
  84  * RETURNS
  85  *  TRUE or FALSE
  86  */
  87
  88 BOOL WINAPI AtlAxWinInit(void)
  89 {
  90     WNDCLASSEXW wcex;
  91
  92 #if _ATL_VER <= _ATL_VER_30
  93 #define ATL_NAME_SUFFIX 0
  94 #elif _ATL_VER == _ATL_VER_80
  95 #define ATL_NAME_SUFFIX '8','0',0
  96 #elif _ATL_VER == _ATL_VER_90
  97 #define ATL_NAME_SUFFIX '9','0',0
  98 #elif _ATL_VER == _ATL_VER_100
  99 #define ATL_NAME_SUFFIX '1','0','0',0
 100 #elif _ATL_VER == _ATL_VER_110
 101 #define ATL_NAME_SUFFIX '1','1','0',0
 102 #else
 103 #error Unsupported version
 104 #endif
 105
 106     static const WCHAR AtlAxWinW[] = {'A','t','l','A','x','W','i','n',ATL_NAME_SUFFIX};
 107
 108     FIXME("version %04x semi-stub\n", _ATL_VER);
 109
 110     if ( FAILED( OleInitialize(NULL) ) )
 111         return FALSE;
 112
 113     wcex.cbSize        = sizeof(wcex);
 114     wcex.style         = CS_GLOBALCLASS | (_ATL_VER > _ATL_VER_30 ? CS_DBLCLKS : 0);
 115     wcex.cbClsExtra    = 0;
 116     wcex.cbWndExtra    = 0;
 117     wcex.hInstance     = GetModuleHandleW( NULL );
 118     wcex.hIcon         = NULL;
 119     wcex.hCursor       = NULL;
 120     wcex.hbrBackground = NULL;
 121     wcex.lpszMenuName  = NULL;
 122     wcex.hIconSm       = 0;
 123
 124     wcex.lpfnWndProc   = AtlAxWin_wndproc;
 125     wcex.lpszClassName = AtlAxWinW;
 126     if ( !RegisterClassExW( &wcex ) )
 127         return FALSE;
 128
 129     if(_ATL_VER > _ATL_VER_30) {
 130         static const WCHAR AtlAxWinLicW[] = {'A','t','l','A','x','W','i','n','L','i','c',ATL_NAME_SUFFIX};
 131
 132         wcex.lpszClassName = AtlAxWinLicW;
 133         if ( !RegisterClassExW( &wcex ) )
 134             return FALSE;
 135     }
 136
 137     return TRUE;
 138 }
 139
 140 /***********************************************************************
 141  *  Atl container component implementation
 142  */
 143
 144 /******      IOleClientSite    *****/
 145 static inline IOCS *impl_from_IOleClientSite(IOleClientSite *iface)
 146 {
 147     return CONTAINING_RECORD(iface, IOCS, IOleClientSite_iface);
 148 }
 149
 150 static HRESULT IOCS_Detach( IOCS *This ) /* remove subclassing */
 151 {
 152     if ( This->hWnd )
 153     {
 154         SetWindowLongPtrW( This->hWnd, GWLP_WNDPROC, (ULONG_PTR) This->OrigWndProc );
 155         RemovePropW( This->hWnd, wine_atl_iocsW);
 156         This->hWnd = NULL;
 157     }
 158     if ( This->control )
 159     {
 160         IOleObject *control = This->control;
 161
 162         This->control = NULL;
 163         IOleObject_Close( control, OLECLOSE_NOSAVE );
 164         IOleObject_SetClientSite( control, NULL );
 165         IOleObject_Release( control );
 166     }
 167     return S_OK;
 168 }
 169
 170 static HRESULT WINAPI OleClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
 171 {
 172     IOCS *This = impl_from_IOleClientSite(iface);
 173
 174     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 175
 176     *ppv = NULL;
 177
 178     if (IsEqualIID(&IID_IUnknown, riid) ||
 179         IsEqualIID(&IID_IOleClientSite, riid))
 180     {
 181         *ppv = iface;
 182     }
 183     else if (IsEqualIID(&IID_IOleContainer, riid))
 184     {
 185         *ppv = &This->IOleContainer_iface;
 186     }
 187     else if (IsEqualIID(&IID_IOleInPlaceSite, riid) ||
 188              IsEqualIID(&IID_IOleInPlaceSiteEx, riid) ||
 189              IsEqualIID(&IID_IOleInPlaceSiteWindowless, riid))
 190     {
 191         *ppv = &This->IOleInPlaceSiteWindowless_iface;
 192     }
 193     else if (IsEqualIID(&IID_IOleInPlaceFrame, riid))
 194     {
 195         *ppv = &This->IOleInPlaceFrame_iface;
 196     }
 197     else if (IsEqualIID(&IID_IOleControlSite, riid))
 198     {
 199         *ppv = &This->IOleControlSite_iface;
 200     }
 201
 202     if (*ppv)
 203     {
 204         IOleClientSite_AddRef(iface);
 205         return S_OK;
 206     }
 207
 208     WARN("unsupported interface %s\n", debugstr_guid(riid));
 209     return E_NOINTERFACE;
 210 }
 211
 212 static ULONG WINAPI OleClientSite_AddRef(IOleClientSite *iface)
 213 {
 214     IOCS *This = impl_from_IOleClientSite(iface);
 215     ULONG ref = InterlockedIncrement(&This->ref);
 216     TRACE("(%p)->(%d)\n", This, ref);
 217     return ref;
 218 }
 219
 220 static ULONG WINAPI OleClientSite_Release(IOleClientSite *iface)
 221 {
 222     IOCS *This = impl_from_IOleClientSite(iface);
 223     ULONG ref = InterlockedDecrement(&This->ref);
 224
 225     TRACE("(%p)->(%d)\n", This, ref);
 226
 227     if (!ref)
 228     {
 229         IOCS_Detach( This );
 230         HeapFree( GetProcessHeap(), 0, This );
 231     }
 232
 233     return ref;
 234 }
 235
 236 static HRESULT WINAPI OleClientSite_SaveObject(IOleClientSite *iface)
 237 {
 238     IOCS *This = impl_from_IOleClientSite(iface);
 239     FIXME( "(%p) - stub\n", This );
 240     return E_NOTIMPL;
 241 }
 242
 243 static HRESULT WINAPI OleClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
 244 {
 245     IOCS *This = impl_from_IOleClientSite(iface);
 246
 247     FIXME( "(%p, 0x%x, 0x%x, %p)\n", This, dwAssign, dwWhichMoniker, ppmk );
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI OleClientSite_GetContainer(IOleClientSite *iface, IOleContainer **container)
 252 {
 253     IOCS *This = impl_from_IOleClientSite(iface);
 254     TRACE("(%p, %p)\n", This, container);
 255     return IOleClientSite_QueryInterface(iface, &IID_IOleContainer, (void**)container);
 256 }
 257
 258 static HRESULT WINAPI OleClientSite_ShowObject(IOleClientSite *iface)
 259 {
 260     IOCS *This = impl_from_IOleClientSite(iface);
 261     FIXME( "(%p) - stub\n", This );
 262     return S_OK;
 263 }
 264
 265 static HRESULT WINAPI OleClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
 266 {
 267     IOCS *This = impl_from_IOleClientSite(iface);
 268     FIXME( "(%p, %s) - stub\n", This, fShow ? "TRUE" : "FALSE" );
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT WINAPI OleClientSite_RequestNewObjectLayout(IOleClientSite *iface)
 273 {
 274     IOCS *This = impl_from_IOleClientSite(iface);
 275     FIXME( "(%p) - stub\n", This );
 276     return E_NOTIMPL;
 277 }
 278
 279
 280 /******      IOleContainer     *****/
 281 static inline IOCS *impl_from_IOleContainer(IOleContainer *iface)
 282 {
 283     return CONTAINING_RECORD(iface, IOCS, IOleContainer_iface);
 284 }
 285
 286 static HRESULT WINAPI OleContainer_QueryInterface( IOleContainer* iface, REFIID riid, void** ppv)
 287 {
 288     IOCS *This = impl_from_IOleContainer(iface);
 289     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
 290 }
 291
 292 static ULONG WINAPI OleContainer_AddRef(IOleContainer* iface)
 293 {
 294     IOCS *This = impl_from_IOleContainer(iface);
 295     return IOleClientSite_AddRef(&This->IOleClientSite_iface);
 296 }
 297
 298 static ULONG WINAPI OleContainer_Release(IOleContainer* iface)
 299 {
 300     IOCS *This = impl_from_IOleContainer(iface);
 301     return IOleClientSite_Release(&This->IOleClientSite_iface);
 302 }
 303
 304 static HRESULT WINAPI OleContainer_ParseDisplayName(IOleContainer* iface, IBindCtx* pbc,
 305         LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut)
 306 {
 307     IOCS *This = impl_from_IOleContainer(iface);
 308     FIXME( "(%p,%p,%s,%p,%p) - stub\n", This, pbc, debugstr_w(pszDisplayName), pchEaten, ppmkOut );
 309     return E_NOTIMPL;
 310 }
 311
 312 static HRESULT WINAPI OleContainer_EnumObjects(IOleContainer* iface, DWORD grfFlags, IEnumUnknown** ppenum)
 313 {
 314     IOCS *This = impl_from_IOleContainer(iface);
 315     FIXME( "(%p, %u, %p) - stub\n", This, grfFlags, ppenum );
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI OleContainer_LockContainer(IOleContainer* iface, BOOL fLock)
 320 {
 321     IOCS *This = impl_from_IOleContainer(iface);
 322     FIXME( "(%p, %s) - stub\n", This, fLock?"TRUE":"FALSE" );
 323     return E_NOTIMPL;
 324 }
 325
 326
 327 /******    IOleInPlaceSiteWindowless   *******/
 328 static inline IOCS *impl_from_IOleInPlaceSiteWindowless(IOleInPlaceSiteWindowless *iface)
 329 {
 330     return CONTAINING_RECORD(iface, IOCS, IOleInPlaceSiteWindowless_iface);
 331 }
 332
 333 static HRESULT WINAPI OleInPlaceSiteWindowless_QueryInterface(IOleInPlaceSiteWindowless *iface, REFIID riid, void **ppv)
 334 {
 335     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 336     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
 337 }
 338
 339 static ULONG WINAPI OleInPlaceSiteWindowless_AddRef(IOleInPlaceSiteWindowless *iface)
 340 {
 341     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 342     return IOleClientSite_AddRef(&This->IOleClientSite_iface);
 343 }
 344
 345 static ULONG WINAPI OleInPlaceSiteWindowless_Release(IOleInPlaceSiteWindowless *iface)
 346 {
 347     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 348     return IOleClientSite_Release(&This->IOleClientSite_iface);
 349 }
 350
 351 static HRESULT WINAPI OleInPlaceSiteWindowless_GetWindow(IOleInPlaceSiteWindowless* iface, HWND* phwnd)
 352 {
 353     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 354
 355     TRACE("(%p,%p)\n", This, phwnd);
 356     *phwnd = This->hWnd;
 357     return S_OK;
 358 }
 359
 360 static HRESULT WINAPI OleInPlaceSiteWindowless_ContextSensitiveHelp(IOleInPlaceSiteWindowless* iface, BOOL fEnterMode)
 361 {
 362     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 363     FIXME("(%p,%d) - stub\n", This, fEnterMode);
 364     return E_NOTIMPL;
 365 }
 366
 367 static HRESULT WINAPI OleInPlaceSiteWindowless_CanInPlaceActivate(IOleInPlaceSiteWindowless *iface)
 368 {
 369     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 370     TRACE("(%p)\n", This);
 371     return S_OK;
 372 }
 373
 374 static HRESULT WINAPI OleInPlaceSiteWindowless_OnInPlaceActivate(IOleInPlaceSiteWindowless *iface)
 375 {
 376     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 377
 378     TRACE("(%p)\n", This);
 379
 380     This->fInPlace = TRUE;
 381     return S_OK;
 382 }
 383
 384 static HRESULT WINAPI OleInPlaceSiteWindowless_OnUIActivate(IOleInPlaceSiteWindowless *iface)
 385 {
 386     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 387
 388     TRACE("(%p)\n", This);
 389
 390     return S_OK;
 391 }
 392 static HRESULT WINAPI OleInPlaceSiteWindowless_GetWindowContext(IOleInPlaceSiteWindowless *iface,
 393         IOleInPlaceFrame **frame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
 394         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
 395 {
 396     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 397
 398     TRACE("(%p,%p,%p,%p,%p,%p)\n", This, frame, ppDoc, lprcPosRect, lprcClipRect, lpFrameInfo);
 399
 400     if ( lprcClipRect )
 401         *lprcClipRect = This->size;
 402     if ( lprcPosRect )
 403         *lprcPosRect = This->size;
 404
 405     if ( frame )
 406     {
 407         *frame = &This->IOleInPlaceFrame_iface;
 408         IOleInPlaceFrame_AddRef(*frame);
 409     }
 410
 411     if ( ppDoc )
 412         *ppDoc = NULL;
 413
 414     if ( lpFrameInfo )
 415     {
 416         lpFrameInfo->fMDIApp = FALSE;
 417         lpFrameInfo->hwndFrame = This->hWnd;
 418         lpFrameInfo->haccel = NULL;
 419         lpFrameInfo->cAccelEntries = 0;
 420     }
 421
 422     return S_OK;
 423 }
 424
 425 static HRESULT WINAPI OleInPlaceSiteWindowless_Scroll(IOleInPlaceSiteWindowless *iface, SIZE scrollExtent)
 426 {
 427     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 428     FIXME("(%p) - stub\n", This);
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI OleInPlaceSiteWindowless_OnUIDeactivate(IOleInPlaceSiteWindowless *iface, BOOL fUndoable)
 433 {
 434     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 435     FIXME("(%p,%d) - stub\n", This, fUndoable);
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI OleInPlaceSiteWindowless_OnInPlaceDeactivate(IOleInPlaceSiteWindowless *iface)
 440 {
 441     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 442
 443     TRACE("(%p)\n", This);
 444
 445     This->fInPlace = This->fWindowless = FALSE;
 446     return S_OK;
 447 }
 448
 449 static HRESULT WINAPI OleInPlaceSiteWindowless_DiscardUndoState(IOleInPlaceSiteWindowless *iface)
 450 {
 451     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 452     FIXME("(%p) - stub\n", This);
 453     return E_NOTIMPL;
 454 }
 455
 456 static HRESULT WINAPI OleInPlaceSiteWindowless_DeactivateAndUndo(IOleInPlaceSiteWindowless *iface)
 457 {
 458     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 459     FIXME("(%p) - stub\n", This);
 460     return E_NOTIMPL;
 461 }
 462
 463 static HRESULT WINAPI OleInPlaceSiteWindowless_OnPosRectChange(IOleInPlaceSiteWindowless *iface, LPCRECT lprcPosRect)
 464 {
 465     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 466     FIXME("(%p,%p) - stub\n", This, lprcPosRect);
 467     return E_NOTIMPL;
 468 }
 469
 470 static HRESULT WINAPI OleInPlaceSiteWindowless_OnInPlaceActivateEx( IOleInPlaceSiteWindowless *iface, BOOL* pfNoRedraw, DWORD dwFlags)
 471 {
 472     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 473
 474     TRACE("\n");
 475
 476     This->fActive = This->fInPlace = TRUE;
 477     if ( dwFlags & ACTIVATE_WINDOWLESS )
 478         This->fWindowless = TRUE;
 479     return S_OK;
 480 }
 481
 482 static HRESULT WINAPI OleInPlaceSiteWindowless_OnInPlaceDeactivateEx( IOleInPlaceSiteWindowless *iface, BOOL fNoRedraw)
 483 {
 484     IOCS *This = impl_from_IOleInPlaceSiteWindowless(iface);
 485
 486     TRACE("\n");
 487
 488     This->fActive = This->fInPlace = This->fWindowless = FALSE;
 489     return S_OK;
 490 }
 491 static HRESULT WINAPI OleInPlaceSiteWindowless_RequestUIActivate( IOleInPlaceSiteWindowless *iface)
 492 {
 493     FIXME("\n");
 494     return E_NOTIMPL;
 495 }
 496 static HRESULT WINAPI OleInPlaceSiteWindowless_CanWindowlessActivate( IOleInPlaceSiteWindowless *iface)
 497 {
 498     FIXME("\n");
 499     return S_OK;
 500 }
 501 static HRESULT WINAPI OleInPlaceSiteWindowless_GetCapture( IOleInPlaceSiteWindowless *iface)
 502 {
 503     FIXME("\n");
 504     return E_NOTIMPL;
 505 }
 506 static HRESULT WINAPI OleInPlaceSiteWindowless_SetCapture( IOleInPlaceSiteWindowless *iface, BOOL fCapture)
 507 {
 508     FIXME("\n");
 509     return E_NOTIMPL;
 510 }
 511 static HRESULT WINAPI OleInPlaceSiteWindowless_GetFocus( IOleInPlaceSiteWindowless *iface)
 512 {
 513     FIXME("\n");
 514     return E_NOTIMPL;
 515 }
 516 static HRESULT WINAPI OleInPlaceSiteWindowless_SetFocus( IOleInPlaceSiteWindowless *iface, BOOL fFocus)
 517 {
 518     FIXME("\n");
 519     return E_NOTIMPL;
 520 }
 521 static HRESULT WINAPI OleInPlaceSiteWindowless_GetDC( IOleInPlaceSiteWindowless *iface, LPCRECT pRect, DWORD grfFlags, HDC* phDC)
 522 {
 523     FIXME("\n");
 524     return E_NOTIMPL;
 525 }
 526 static HRESULT WINAPI OleInPlaceSiteWindowless_ReleaseDC( IOleInPlaceSiteWindowless *iface, HDC hDC)
 527 {
 528     FIXME("\n");
 529     return E_NOTIMPL;
 530 }
 531 static HRESULT WINAPI OleInPlaceSiteWindowless_InvalidateRect( IOleInPlaceSiteWindowless *iface, LPCRECT pRect, BOOL fErase)
 532 {
 533     FIXME("\n");
 534     return E_NOTIMPL;
 535 }
 536 static HRESULT WINAPI OleInPlaceSiteWindowless_InvalidateRgn( IOleInPlaceSiteWindowless *iface, HRGN hRGN, BOOL fErase)
 537 {
 538     FIXME("\n");
 539     return E_NOTIMPL;
 540 }
 541 static HRESULT WINAPI OleInPlaceSiteWindowless_ScrollRect( IOleInPlaceSiteWindowless *iface, INT dx, INT dy, LPCRECT pRectScroll, LPCRECT pRectClip)
 542 {
 543     FIXME("\n");
 544     return E_NOTIMPL;
 545 }
 546 static HRESULT WINAPI OleInPlaceSiteWindowless_AdjustRect( IOleInPlaceSiteWindowless *iface, LPRECT prc)
 547 {
 548     FIXME("\n");
 549     return E_NOTIMPL;
 550 }
 551 static HRESULT WINAPI OleInPlaceSiteWindowless_OnDefWindowMessage( IOleInPlaceSiteWindowless *iface, UINT msg, WPARAM wParam, LPARAM lParam, LRESULT* plResult)
 552 {
 553     FIXME("\n");
 554     return E_NOTIMPL;
 555 }
 556
 557
 558 /******    IOleInPlaceFrame   *******/
 559 static inline IOCS *impl_from_IOleInPlaceFrame(IOleInPlaceFrame *iface)
 560 {
 561     return CONTAINING_RECORD(iface, IOCS, IOleInPlaceFrame_iface);
 562 }
 563
 564 static HRESULT WINAPI OleInPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
 565 {
 566     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 567     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
 568 }
 569
 570 static ULONG WINAPI OleInPlaceFrame_AddRef(IOleInPlaceFrame *iface)
 571 {
 572     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 573     return IOleClientSite_AddRef(&This->IOleClientSite_iface);
 574 }
 575
 576 static ULONG WINAPI OleInPlaceFrame_Release(IOleInPlaceFrame *iface)
 577 {
 578     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 579     return IOleClientSite_Release(&This->IOleClientSite_iface);
 580 }
 581
 582 static HRESULT WINAPI OleInPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phWnd)
 583 {
 584     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 585
 586     TRACE( "(%p,%p)\n", This, phWnd );
 587
 588     *phWnd = This->hWnd;
 589     return S_OK;
 590 }
 591
 592 static HRESULT WINAPI OleInPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
 593 {
 594     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 595
 596     FIXME( "(%p,%d) - stub\n", This, fEnterMode );
 597     return E_NOTIMPL;
 598 }
 599
 600 static HRESULT WINAPI OleInPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
 601 {
 602     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 603
 604     FIXME( "(%p,%p) - stub\n", This, lprectBorder );
 605     return E_NOTIMPL;
 606 }
 607
 608 static HRESULT WINAPI OleInPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface, LPCBORDERWIDTHS pborderwidths)
 609 {
 610     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 611
 612     FIXME( "(%p,%p) - stub\n", This, pborderwidths );
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI OleInPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface, LPCBORDERWIDTHS pborderwidths)
 617 {
 618     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 619
 620     FIXME( "(%p,%p) - stub\n", This, pborderwidths );
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI OleInPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface, IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 625 {
 626     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 627
 628     FIXME( "(%p,%p,%s) - stub\n", This, pActiveObject, debugstr_w(pszObjName) );
 629     return S_OK;
 630 }
 631
 632 static HRESULT WINAPI OleInPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths)
 633 {
 634     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 635
 636     FIXME( "(%p,%p,%p) - stub\n", This, hmenuShared, lpMenuWidths );
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT WINAPI OleInPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject)
 641 {
 642     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 643
 644     FIXME( "(%p,%p,%p,%p) - stub\n", This, hmenuShared, holemenu, hwndActiveObject );
 645     return E_NOTIMPL;
 646 }
 647
 648 static HRESULT WINAPI OleInPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
 649 {
 650     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 651
 652     FIXME( "(%p, %p) - stub\n", This, hmenuShared );
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI OleInPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
 657 {
 658     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 659
 660     FIXME( "(%p, %s) - stub\n", This, debugstr_w( pszStatusText ) );
 661     return E_NOTIMPL;
 662 }
 663
 664 static HRESULT WINAPI OleInPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
 665 {
 666     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 667
 668     FIXME( "(%p, %d) - stub\n", This, fEnable );
 669     return E_NOTIMPL;
 670 }
 671
 672 static HRESULT WINAPI OleInPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
 673 {
 674     IOCS *This = impl_from_IOleInPlaceFrame(iface);
 675
 676     FIXME( "(%p, %p, %x) - stub\n", This, lpmsg, wID );
 677     return E_NOTIMPL;
 678 }
 679
 680
 681 /******    IOleControlSite    *******/
 682 static inline IOCS *impl_from_IOleControlSite(IOleControlSite *iface)
 683 {
 684     return CONTAINING_RECORD(iface, IOCS, IOleControlSite_iface);
 685 }
 686
 687 static HRESULT WINAPI OleControlSite_QueryInterface(IOleControlSite *iface, REFIID riid, void **ppv)
 688 {
 689     IOCS *This = impl_from_IOleControlSite(iface);
 690     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, riid, ppv);
 691 }
 692
 693 static ULONG WINAPI OleControlSite_AddRef(IOleControlSite *iface)
 694 {
 695     IOCS *This = impl_from_IOleControlSite(iface);
 696     return IOleClientSite_AddRef(&This->IOleClientSite_iface);
 697 }
 698
 699 static ULONG WINAPI OleControlSite_Release(IOleControlSite *iface)
 700 {
 701     IOCS *This = impl_from_IOleControlSite(iface);
 702     return IOleClientSite_Release(&This->IOleClientSite_iface);
 703 }
 704
 705 static HRESULT WINAPI OleControlSite_OnControlInfoChanged( IOleControlSite* This)
 706 {
 707     FIXME( "\n" );
 708     return E_NOTIMPL;
 709 }
 710 static HRESULT WINAPI OleControlSite_LockInPlaceActive( IOleControlSite* This, BOOL fLock)
 711 {
 712     FIXME( "\n" );
 713     return E_NOTIMPL;
 714 }
 715 static HRESULT WINAPI OleControlSite_GetExtendedControl( IOleControlSite* This, IDispatch** ppDisp)
 716 {
 717     FIXME( "\n" );
 718     return E_NOTIMPL;
 719 }
 720 static HRESULT WINAPI OleControlSite_TransformCoords( IOleControlSite* This, POINTL* pPtlHimetric, POINTF* pPtfContainer, DWORD dwFlags)
 721 {
 722     FIXME( "\n" );
 723     return E_NOTIMPL;
 724 }
 725 static HRESULT WINAPI OleControlSite_TranslateAccelerator( IOleControlSite* This, MSG* pMsg, DWORD grfModifiers)
 726 {
 727     FIXME( "\n" );
 728     return E_NOTIMPL;
 729 }
 730 static HRESULT WINAPI OleControlSite_OnFocus( IOleControlSite* This, BOOL fGotFocus)
 731 {
 732     FIXME( "\n" );
 733     return E_NOTIMPL;
 734 }
 735 static HRESULT WINAPI OleControlSite_ShowPropertyFrame( IOleControlSite* This)
 736 {
 737     FIXME( "\n" );
 738     return E_NOTIMPL;
 739 }
 740
 741
 742 static const IOleClientSiteVtbl OleClientSite_vtbl = {
 743     OleClientSite_QueryInterface,
 744     OleClientSite_AddRef,
 745     OleClientSite_Release,
 746     OleClientSite_SaveObject,
 747     OleClientSite_GetMoniker,
 748     OleClientSite_GetContainer,
 749     OleClientSite_ShowObject,
 750     OleClientSite_OnShowWindow,
 751     OleClientSite_RequestNewObjectLayout
 752 };
 753 static const IOleContainerVtbl OleContainer_vtbl = {
 754     OleContainer_QueryInterface,
 755     OleContainer_AddRef,
 756     OleContainer_Release,
 757     OleContainer_ParseDisplayName,
 758     OleContainer_EnumObjects,
 759     OleContainer_LockContainer
 760 };
 761 static const IOleInPlaceSiteWindowlessVtbl OleInPlaceSiteWindowless_vtbl = {
 762     OleInPlaceSiteWindowless_QueryInterface,
 763     OleInPlaceSiteWindowless_AddRef,
 764     OleInPlaceSiteWindowless_Release,
 765     OleInPlaceSiteWindowless_GetWindow,
 766     OleInPlaceSiteWindowless_ContextSensitiveHelp,
 767     OleInPlaceSiteWindowless_CanInPlaceActivate,
 768     OleInPlaceSiteWindowless_OnInPlaceActivate,
 769     OleInPlaceSiteWindowless_OnUIActivate,
 770     OleInPlaceSiteWindowless_GetWindowContext,
 771     OleInPlaceSiteWindowless_Scroll,
 772     OleInPlaceSiteWindowless_OnUIDeactivate,
 773     OleInPlaceSiteWindowless_OnInPlaceDeactivate,
 774     OleInPlaceSiteWindowless_DiscardUndoState,
 775     OleInPlaceSiteWindowless_DeactivateAndUndo,
 776     OleInPlaceSiteWindowless_OnPosRectChange,
 777     OleInPlaceSiteWindowless_OnInPlaceActivateEx,
 778     OleInPlaceSiteWindowless_OnInPlaceDeactivateEx,
 779     OleInPlaceSiteWindowless_RequestUIActivate,
 780     OleInPlaceSiteWindowless_CanWindowlessActivate,
 781     OleInPlaceSiteWindowless_GetCapture,
 782     OleInPlaceSiteWindowless_SetCapture,
 783     OleInPlaceSiteWindowless_GetFocus,
 784     OleInPlaceSiteWindowless_SetFocus,
 785     OleInPlaceSiteWindowless_GetDC,
 786     OleInPlaceSiteWindowless_ReleaseDC,
 787     OleInPlaceSiteWindowless_InvalidateRect,
 788     OleInPlaceSiteWindowless_InvalidateRgn,
 789     OleInPlaceSiteWindowless_ScrollRect,
 790     OleInPlaceSiteWindowless_AdjustRect,
 791     OleInPlaceSiteWindowless_OnDefWindowMessage
 792 };
 793 static const IOleInPlaceFrameVtbl OleInPlaceFrame_vtbl =
 794 {
 795     OleInPlaceFrame_QueryInterface,
 796     OleInPlaceFrame_AddRef,
 797     OleInPlaceFrame_Release,
 798     OleInPlaceFrame_GetWindow,
 799     OleInPlaceFrame_ContextSensitiveHelp,
 800     OleInPlaceFrame_GetBorder,
 801     OleInPlaceFrame_RequestBorderSpace,
 802     OleInPlaceFrame_SetBorderSpace,
 803     OleInPlaceFrame_SetActiveObject,
 804     OleInPlaceFrame_InsertMenus,
 805     OleInPlaceFrame_SetMenu,
 806     OleInPlaceFrame_RemoveMenus,
 807     OleInPlaceFrame_SetStatusText,
 808     OleInPlaceFrame_EnableModeless,
 809     OleInPlaceFrame_TranslateAccelerator
 810 };
 811 static const IOleControlSiteVtbl OleControlSite_vtbl =
 812 {
 813     OleControlSite_QueryInterface,
 814     OleControlSite_AddRef,
 815     OleControlSite_Release,
 816     OleControlSite_OnControlInfoChanged,
 817     OleControlSite_LockInPlaceActive,
 818     OleControlSite_GetExtendedControl,
 819     OleControlSite_TransformCoords,
 820     OleControlSite_TranslateAccelerator,
 821     OleControlSite_OnFocus,
 822     OleControlSite_ShowPropertyFrame
 823 };
 824
 825 static void IOCS_OnSize( IOCS* This, LPCRECT rect )
 826 {
 827     SIZEL inPix, inHi;
 828
 829     This->size = *rect;
 830
 831     if ( !This->control )
 832         return;
 833
 834     inPix.cx = rect->right - rect->left;
 835     inPix.cy = rect->bottom - rect->top;
 836     AtlPixelToHiMetric( &inPix, &inHi );
 837     IOleObject_SetExtent( This->control, DVASPECT_CONTENT, &inHi );
 838
 839     if ( This->fInPlace )
 840     {
 841         IOleInPlaceObject *wl;
 842
 843         if ( SUCCEEDED( IOleObject_QueryInterface( This->control, &IID_IOleInPlaceObject, (void**)&wl ) ) )
 844         {
 845             IOleInPlaceObject_SetObjectRects( wl, rect, rect );
 846             IOleInPlaceObject_Release( wl );
 847         }
 848     }
 849 }
 850
 851 static void IOCS_OnShow( IOCS *This, BOOL fShow )
 852 {
 853     if (!This->control || This->fActive || !fShow )
 854         return;
 855
 856     This->fActive = TRUE;
 857 }
 858
 859 static void IOCS_OnDraw( IOCS *This )
 860 {
 861     IViewObject *view;
 862
 863     if ( !This->control || !This->fWindowless )
 864         return;
 865
 866     if ( SUCCEEDED( IOleObject_QueryInterface( This->control, &IID_IViewObject, (void**)&view ) ) )
 867     {
 868         HDC dc = GetDC( This->hWnd );
 869         RECTL rect;
 870
 871         rect.left = This->size.left; rect.top = This->size.top;
 872         rect.bottom = This->size.bottom; rect.right = This->size.right;
 873
 874         IViewObject_Draw( view, DVASPECT_CONTENT, ~0, NULL, NULL, 0, dc, &rect, &rect, NULL, 0 );
 875         IViewObject_Release( view );
 876         ReleaseDC( This->hWnd, dc );
 877     }
 878 }
 879
 880 static LRESULT IOCS_OnWndProc( IOCS *This, HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
 881 {
 882     WNDPROC OrigWndProc = This->OrigWndProc;
 883
 884     switch( uMsg )
 885     {
 886         case WM_DESTROY:
 887             IOCS_Detach( This );
 888             break;
 889         case WM_SIZE:
 890             {
 891                 RECT r;
 892                 SetRect(&r, 0, 0, LOWORD(lParam), HIWORD(lParam));
 893                 IOCS_OnSize( This, &r );
 894             }
 895             break;
 896         case WM_SHOWWINDOW:
 897             IOCS_OnShow( This, (BOOL) wParam );
 898             break;
 899         case WM_PAINT:
 900             IOCS_OnDraw( This );
 901             break;
 902     }
 903
 904     return CallWindowProcW( OrigWndProc, hWnd, uMsg, wParam, lParam );
 905 }
 906
 907 static LRESULT CALLBACK AtlHost_wndproc( HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam )
 908 {
 909     IOCS *This = (IOCS*) GetPropW( hWnd, wine_atl_iocsW );
 910     return IOCS_OnWndProc( This, hWnd, wMsg, wParam, lParam );
 911 }
 912
 913 static HRESULT IOCS_Attach( IOCS *This, HWND hWnd, IUnknown *pUnkControl ) /* subclass hWnd */
 914 {
 915     This->hWnd = hWnd;
 916     IUnknown_QueryInterface( pUnkControl, &IID_IOleObject, (void**)&This->control );
 917     IOleObject_SetClientSite( This->control, &This->IOleClientSite_iface );
 918     SetPropW( hWnd, wine_atl_iocsW, This );
 919     This->OrigWndProc = (WNDPROC)SetWindowLongPtrW( hWnd, GWLP_WNDPROC, (ULONG_PTR) AtlHost_wndproc );
 920
 921     return S_OK;
 922 }
 923
 924 static HRESULT IOCS_Init( IOCS *This )
 925 {
 926     RECT rect;
 927     static const WCHAR AXWIN[] = {'A','X','W','I','N',0};
 928
 929     IOleObject_SetHostNames( This->control, AXWIN, AXWIN );
 930
 931     GetClientRect( This->hWnd, &rect );
 932     IOCS_OnSize( This, &rect );
 933     IOleObject_DoVerb( This->control, OLEIVERB_INPLACEACTIVATE, NULL, &This->IOleClientSite_iface,
 934                        0, This->hWnd, &rect );
 935
 936     return S_OK;
 937 }
 938
 939 /**********************************************************************
 940  * Create new instance of Atl host component and attach it to window  *
 941  */
 942 static HRESULT IOCS_Create( HWND hWnd, IUnknown *pUnkControl, IUnknown **container )
 943 {
 944     HRESULT hr;
 945     IOCS *This;
 946
 947     if (!container)
 948         return S_OK;
 949
 950     *container = NULL;
 951     This = HeapAlloc(GetProcessHeap(), 0, sizeof(IOCS));
 952
 953     if (!This)
 954         return E_OUTOFMEMORY;
 955
 956     This->IOleClientSite_iface.lpVtbl = &OleClientSite_vtbl;
 957     This->IOleContainer_iface.lpVtbl = &OleContainer_vtbl;
 958     This->IOleInPlaceSiteWindowless_iface.lpVtbl = &OleInPlaceSiteWindowless_vtbl;
 959     This->IOleInPlaceFrame_iface.lpVtbl = &OleInPlaceFrame_vtbl;
 960     This->IOleControlSite_iface.lpVtbl = &OleControlSite_vtbl;
 961     This->ref = 1;
 962
 963     This->OrigWndProc = NULL;
 964     This->hWnd = NULL;
 965     This->fWindowless = This->fActive = This->fInPlace = FALSE;
 966
 967     hr = IOCS_Attach( This, hWnd, pUnkControl );
 968     if ( SUCCEEDED( hr ) )
 969         hr = IOCS_Init( This );
 970     if ( SUCCEEDED( hr ) )
 971         *container = (IUnknown*)&This->IOleClientSite_iface;
 972     else
 973     {
 974         IOCS_Detach( This );
 975         HeapFree(GetProcessHeap(), 0, This);
 976     }
 977
 978     return hr;
 979 }
 980
 981
 982 /***********************************************************************
 983  *           AtlAxCreateControl           [atl100.@]
 984  */
 985 HRESULT WINAPI AtlAxCreateControl(LPCOLESTR lpszName, HWND hWnd,
 986         IStream *pStream, IUnknown **ppUnkContainer)
 987 {
 988     return AtlAxCreateControlEx( lpszName, hWnd, pStream, ppUnkContainer,
 989             NULL, NULL, NULL );
 990 }
 991
 992 enum content
 993 {
 994     IsEmpty = 0,
 995     IsGUID = 1,
 996     IsHTML = 2,
 997     IsURL = 3,
 998     IsUnknown = 4
 999 };
1000
1001 static enum content get_content_type(LPCOLESTR name, CLSID *control_id)
1002 {
1003     static const WCHAR mshtml_prefixW[] = {'m','s','h','t','m','l',':',0};
1004     WCHAR new_urlW[MAX_PATH];
1005     DWORD size = MAX_PATH;
1006
1007     if (!name || !name[0])
1008     {
1009         WARN("name %s\n", wine_dbgstr_w(name));
1010         return IsEmpty;
1011     }
1012
1013     if (CLSIDFromString(name, control_id) == S_OK ||
1014         CLSIDFromProgID(name, control_id) == S_OK)
1015         return IsGUID;
1016
1017     if (PathIsURLW (name) ||
1018         UrlApplySchemeW(name, new_urlW, &size, URL_APPLY_GUESSSCHEME|URL_APPLY_GUESSFILE) == S_OK)
1019     {
1020         *control_id = CLSID_WebBrowser;
1021         return IsURL;
1022     }
1023
1024     if (!wcsnicmp(name, mshtml_prefixW, 7))
1025     {
1026         FIXME("mshtml prefix not implemented\n");
1027         *control_id = CLSID_WebBrowser;
1028         return IsHTML;
1029     }
1030
1031     return IsUnknown;
1032 }
1033
1034 /***********************************************************************
1035  *           AtlAxCreateControlLicEx         [atl100.@]
1036  *
1037  * REMARKS
1038  *   See http://www.codeproject.com/com/cwebpage.asp for some background
1039  *
1040  */
1041 HRESULT WINAPI AtlAxCreateControlLicEx(LPCOLESTR lpszName, HWND hWnd,
1042         IStream *pStream, IUnknown **ppUnkContainer, IUnknown **ppUnkControl,
1043         REFIID iidSink, IUnknown *punkSink, BSTR lic)
1044 {
1045     CLSID controlId;
1046     HRESULT hRes;
1047     IOleObject *pControl;
1048     IUnknown *pUnkControl = NULL;
1049     IPersistStreamInit *pPSInit;
1050     IUnknown *pContainer = NULL;
1051     enum content content;
1052
1053     TRACE("(%s %p %p %p %p %p %p %s)\n", debugstr_w(lpszName), hWnd, pStream,
1054             ppUnkContainer, ppUnkControl, iidSink, punkSink, debugstr_w(lic));
1055
1056     if (lic)
1057         FIXME("semi stub\n");
1058
1059     if (ppUnkContainer) *ppUnkContainer = NULL;
1060     if (ppUnkControl) *ppUnkControl = NULL;
1061
1062     content = get_content_type(lpszName, &controlId);
1063
1064     if (content == IsEmpty)
1065         return S_OK;
1066
1067     if (content == IsUnknown)
1068         return CO_E_CLASSSTRING;
1069
1070     hRes = CoCreateInstance( &controlId, 0, CLSCTX_ALL, &IID_IOleObject,
1071             (void**) &pControl );
1072     if ( FAILED( hRes ) )
1073     {
1074         WARN( "cannot create ActiveX control %s instance - error 0x%08x\n",
1075                 debugstr_guid( &controlId ), hRes );
1076         return hRes;
1077     }
1078
1079     hRes = IOleObject_QueryInterface( pControl, &IID_IPersistStreamInit, (void**) &pPSInit );
1080     if ( SUCCEEDED( hRes ) )
1081     {
1082         if (!pStream)
1083             IPersistStreamInit_InitNew( pPSInit );
1084         else
1085             IPersistStreamInit_Load( pPSInit, pStream );
1086         IPersistStreamInit_Release( pPSInit );
1087     } else
1088         WARN("cannot get IID_IPersistStreamInit out of control\n");
1089
1090     IOleObject_QueryInterface( pControl, &IID_IUnknown, (void**) &pUnkControl );
1091     IOleObject_Release( pControl );
1092
1093
1094     hRes = AtlAxAttachControl( pUnkControl, hWnd, &pContainer );
1095     if ( FAILED( hRes ) )
1096         WARN("cannot attach control to window\n");
1097
1098     if ( content == IsURL )
1099     {
1100         IWebBrowser2 *browser;
1101
1102         hRes = IOleObject_QueryInterface( pControl, &IID_IWebBrowser2, (void**) &browser );
1103         if ( !browser )
1104             WARN( "Cannot query IWebBrowser2 interface: %08x\n", hRes );
1105         else {
1106             VARIANT url;
1107
1108             IWebBrowser2_put_Visible( browser, VARIANT_TRUE ); /* it seems that native does this on URL (but do not on MSHTML:! why? */
1109
1110             V_VT(&url) = VT_BSTR;
1111             V_BSTR(&url) = SysAllocString( lpszName );
1112
1113             hRes = IWebBrowser2_Navigate2( browser, &url, NULL, NULL, NULL, NULL );
1114             if ( FAILED( hRes ) )
1115                 WARN( "IWebBrowser2::Navigate2 failed: %08x\n", hRes );
1116             SysFreeString( V_BSTR(&url) );
1117
1118             IWebBrowser2_Release( browser );
1119         }
1120     }
1121
1122     if (ppUnkContainer)
1123     {
1124         *ppUnkContainer = pContainer;
1125         if ( pContainer )
1126             IUnknown_AddRef( pContainer );
1127     }
1128     if (ppUnkControl)
1129     {
1130         *ppUnkControl = pUnkControl;
1131         if ( pUnkControl )
1132             IUnknown_AddRef( pUnkControl );
1133     }
1134
1135     if ( pUnkControl )
1136         IUnknown_Release( pUnkControl );
1137     if ( pContainer )
1138         IUnknown_Release( pContainer );
1139
1140     return S_OK;
1141 }
1142
1143 /***********************************************************************
1144  *           AtlAxAttachControl           [atl100.@]
1145  */
1146 HRESULT WINAPI AtlAxAttachControl(IUnknown *control, HWND hWnd, IUnknown **container)
1147 {
1148     HRESULT hr;
1149
1150     TRACE("(%p %p %p)\n", control, hWnd, container);
1151
1152     if (!control)
1153         return E_INVALIDARG;
1154
1155     hr = IOCS_Create( hWnd, control, container );
1156     return hWnd ? hr : S_FALSE;
1157 }
1158
1159 /**********************************************************************
1160  * Helper function for AX_ConvertDialogTemplate
1161  */
1162 static inline BOOL advance_array(WORD **pptr, DWORD *palloc, DWORD *pfilled, const WORD *data, DWORD size)
1163 {
1164     if ( (*pfilled + size) > *palloc )
1165     {
1166         *palloc = ((*pfilled+size) + 0xFF) & ~0xFF;
1167         *pptr = HeapReAlloc( GetProcessHeap(), 0, *pptr, *palloc * sizeof(WORD) );
1168         if (!*pptr)
1169             return FALSE;
1170     }
1171     RtlMoveMemory( *pptr+*pfilled, data, size * sizeof(WORD) );
1172     *pfilled += size;
1173     return TRUE;
1174 }
1175
1176 /**********************************************************************
1177  * Convert ActiveX control templates to AtlAxWin class instances
1178  */
1179 static LPDLGTEMPLATEW AX_ConvertDialogTemplate(LPCDLGTEMPLATEW src_tmpl)
1180 {
1181 #define GET_WORD(x)  (*(const  WORD *)(x))
1182 #define GET_DWORD(x) (*(const DWORD *)(x))
1183 #define PUT_BLOCK(x,y) do {if (!advance_array(&output, &allocated, &filled, (x), (y))) return NULL;} while (0)
1184 #define PUT_WORD(x)  do {WORD w = (x);PUT_BLOCK(&w, 1);} while(0)
1185     const WORD *tmp, *src = (const WORD *)src_tmpl;
1186     WORD *output;
1187     DWORD allocated, filled; /* in WORDs */
1188     BOOL ext;
1189     WORD signature, dlgver, rescount;
1190     DWORD style;
1191
1192     filled = 0; allocated = 256;
1193     output = HeapAlloc( GetProcessHeap(), 0, allocated * sizeof(WORD) );
1194     if (!output)
1195         return NULL;
1196
1197     /* header */
1198     tmp = src;
1199     signature = GET_WORD(src);
1200     dlgver = GET_WORD(src + 1);
1201     if (signature == 1 && dlgver == 0xFFFF)
1202     {
1203         ext = TRUE;
1204         src += 6;
1205         style = GET_DWORD(src);
1206         src += 2;
1207         rescount = GET_WORD(src++);
1208         src += 4;
1209         if ( GET_WORD(src) == 0xFFFF ) /* menu */
1210             src += 2;
1211         else
1212             src += lstrlenW(src) + 1;
1213         if ( GET_WORD(src) == 0xFFFF ) /* class */
1214             src += 2;
1215         else
1216             src += lstrlenW(src) + 1;
1217         src += lstrlenW(src) + 1; /* title */
1218         if ( style & (DS_SETFONT | DS_SHELLFONT) )
1219         {
1220             src += 3;
1221             src += lstrlenW(src) + 1;
1222         }
1223     } else {
1224         ext = FALSE;
1225         style = GET_DWORD(src);
1226         src += 4;
1227         rescount = GET_WORD(src++);
1228         src += 4;
1229         if ( GET_WORD(src) == 0xFFFF ) /* menu */
1230             src += 2;
1231         else
1232             src += lstrlenW(src) + 1;
1233         if ( GET_WORD(src) == 0xFFFF ) /* class */
1234             src += 2;
1235         else
1236             src += lstrlenW(src) + 1;
1237         src += lstrlenW(src) + 1; /* title */
1238         if ( style & DS_SETFONT )
1239         {
1240             src++;
1241             src += lstrlenW(src) + 1;
1242         }
1243     }
1244     PUT_BLOCK(tmp, src-tmp);
1245
1246     while(rescount--)
1247     {
1248         src = (const WORD *)( ( ((ULONG_PTR)src) + 3) & ~3); /* align on DWORD boundary */
1249         filled = (filled + 1) & ~1; /* depends on DWORD-aligned allocation unit */
1250
1251         tmp = src;
1252         if (ext)
1253             src += 12;
1254         else
1255             src += 9;
1256         PUT_BLOCK(tmp, src-tmp);
1257
1258         tmp = src;
1259         if ( GET_WORD(src) == 0xFFFF ) /* class */
1260         {
1261             src += 2;
1262         } else
1263         {
1264             src += lstrlenW(src) + 1;
1265         }
1266         src += lstrlenW(src) + 1; /* title */
1267         if ( GET_WORD(tmp) == '{' ) /* all this mess created because of this line */
1268         {
1269             static const WCHAR AtlAxWin[] = {'A','t','l','A','x','W','i','n', 0};
1270             PUT_BLOCK(AtlAxWin, ARRAY_SIZE(AtlAxWin));
1271             PUT_BLOCK(tmp, lstrlenW(tmp)+1);
1272         } else
1273             PUT_BLOCK(tmp, src-tmp);
1274
1275         if ( GET_WORD(src) )
1276         {
1277             WORD size = (GET_WORD(src)+sizeof(WORD)-1) / sizeof(WORD); /* quite ugly :( Maybe use BYTE* instead of WORD* everywhere ? */
1278             PUT_BLOCK(src, size);
1279             src+=size;
1280         }
1281         else
1282         {
1283             PUT_WORD(0);
1284             src++;
1285         }
1286     }
1287     return (LPDLGTEMPLATEW) output;
1288 }
1289
1290 /***********************************************************************
1291  *           AtlAxCreateDialogA           [atl100.@]
1292  *
1293  * Creates a dialog window
1294  *
1295  * PARAMS
1296  *  hInst   [I] Application instance
1297  *  name    [I] Dialog box template name
1298  *  owner   [I] Dialog box parent HWND
1299  *  dlgProc [I] Dialog box procedure
1300  *  param   [I] This value will be passed to dlgProc as WM_INITDIALOG's message lParam
1301  *
1302  * RETURNS
1303  *  Window handle of dialog window.
1304  */
1305 HWND WINAPI AtlAxCreateDialogA(HINSTANCE hInst, LPCSTR name, HWND owner, DLGPROC dlgProc ,LPARAM param)
1306 {
1307     HWND res = NULL;
1308     int length;
1309     WCHAR *nameW;
1310
1311     if (IS_INTRESOURCE(name))
1312         return AtlAxCreateDialogW( hInst, (LPCWSTR) name, owner, dlgProc, param );
1313
1314     length = MultiByteToWideChar( CP_ACP, 0, name, -1, NULL, 0 );
1315     nameW = HeapAlloc( GetProcessHeap(), 0, length * sizeof(WCHAR) );
1316     if (nameW)
1317     {
1318         MultiByteToWideChar( CP_ACP, 0, name, -1, nameW, length );
1319         res = AtlAxCreateDialogW( hInst, nameW, owner, dlgProc, param );
1320         HeapFree( GetProcessHeap(), 0, nameW );
1321     }
1322     return res;
1323 }
1324
1325 /***********************************************************************
1326  *           AtlAxCreateDialogW           [atl100.@]
1327  *
1328  * See AtlAxCreateDialogA
1329  *
1330  */
1331 HWND WINAPI AtlAxCreateDialogW(HINSTANCE hInst, LPCWSTR name, HWND owner, DLGPROC dlgProc ,LPARAM param)
1332 {
1333     HRSRC hrsrc;
1334     HGLOBAL hgl;
1335     LPCDLGTEMPLATEW ptr;
1336     LPDLGTEMPLATEW newptr;
1337     HWND res;
1338
1339     TRACE("(%p %s %p %p %lx)\n", hInst, debugstr_w(name), owner, dlgProc, param);
1340
1341     hrsrc = FindResourceW( hInst, name, (LPWSTR)RT_DIALOG );
1342     if ( !hrsrc )
1343         return NULL;
1344     hgl = LoadResource (hInst, hrsrc);
1345     if ( !hgl )
1346         return NULL;
1347     ptr = LockResource ( hgl );
1348     if (!ptr)
1349     {
1350         FreeResource( hgl );
1351         return NULL;
1352     }
1353     newptr = AX_ConvertDialogTemplate( ptr );
1354     if ( newptr )
1355     {
1356             res = CreateDialogIndirectParamW( hInst, newptr, owner, dlgProc, param );
1357             HeapFree( GetProcessHeap(), 0, newptr );
1358     } else
1359         res = NULL;
1360     FreeResource ( hrsrc );
1361     return res;
1362 }
1363
1364 /***********************************************************************
1365  *           AtlAxGetHost                 [atl100.@]
1366  *
1367  */
1368 HRESULT WINAPI AtlAxGetHost(HWND hWnd, IUnknown **host)
1369 {
1370     IOCS *This;
1371
1372     TRACE("(%p, %p)\n", hWnd, host);
1373
1374     *host = NULL;
1375
1376     This = (IOCS*) GetPropW( hWnd, wine_atl_iocsW );
1377     if ( !This )
1378     {
1379         WARN("No container attached to %p\n", hWnd );
1380         return E_FAIL;
1381     }
1382
1383     return IOleClientSite_QueryInterface(&This->IOleClientSite_iface, &IID_IUnknown, (void**)host);
1384 }
1385
1386 /***********************************************************************
1387  *           AtlAxGetControl              [atl100.@]
1388  *
1389  */
1390 HRESULT WINAPI AtlAxGetControl(HWND hWnd, IUnknown **pUnk)
1391 {
1392     IOCS *This;
1393
1394     TRACE( "(%p, %p)\n", hWnd, pUnk );
1395
1396     *pUnk = NULL;
1397
1398     This = (IOCS*) GetPropW( hWnd, wine_atl_iocsW );
1399     if ( !This || !This->control )
1400     {
1401         WARN("No control attached to %p\n", hWnd );
1402         return E_FAIL;
1403     }
1404
1405     return IOleObject_QueryInterface( This->control, &IID_IUnknown, (void**) pUnk );
1406 }
1407
1408 /***********************************************************************
1409  *           AtlAxDialogBoxW              [atl100.35]
1410  *
1411  */
1412 INT_PTR WINAPI AtlAxDialogBoxW(HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogProc,
1413         LPARAM dwInitParam)
1414 {
1415     FIXME("(%p %s %p %p %lx)\n", hInstance, debugstr_w(lpTemplateName), hWndParent, lpDialogProc, dwInitParam);
1416     return 0;
1417 }
1418
1419 /***********************************************************************
1420  *           AtlAxDialogBoxA              [atl100.36]
1421  *
1422  */
1423 INT_PTR WINAPI AtlAxDialogBoxA(HINSTANCE hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogProc,
1424         LPARAM dwInitParam)
1425 {
1426     FIXME("(%p %s %p %p %lx)\n", hInstance, debugstr_a(lpTemplateName), hWndParent, lpDialogProc, dwInitParam);
1427     return 0;
1428 }
1429
1430 /***********************************************************************
1431  *           AtlAxCreateControlLic        [atl100.59]
1432  *
1433  */
1434 HRESULT WINAPI AtlAxCreateControlLic(const WCHAR *lpTricsData, HWND hwnd, IStream *stream, IUnknown **container, BSTR lic)
1435 {
1436     return AtlAxCreateControlLicEx(lpTricsData, hwnd, stream, container, NULL, NULL, NULL, lic);
1437 }
1438
1439 /***********************************************************************
1440  *           AtlAxCreateControlEx         [atl100.@]
1441  *
1442  */
1443 HRESULT WINAPI AtlAxCreateControlEx(const WCHAR *lpTricsData, HWND hwnd, IStream *stream,
1444         IUnknown **container, IUnknown **control, REFIID iidSink, IUnknown *punkSink)
1445 {
1446     return AtlAxCreateControlLicEx(lpTricsData, hwnd, stream, container, control, iidSink, punkSink, NULL);
1447 }