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