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 "winuser.h"
  29 #include "winerror.h"
  30 #include "winuser.h"
  31 #include "wine/debug.h"
  32 #include "objbase.h"
  33 #include "objidl.h"
  34 #include "ole2.h"
  35 #include "exdisp.h"
  36 #include "atlbase.h"
  37 #include "atliface.h"
  38 #include "atlwin.h"
  39
  40 #include "wine/unicode.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(atl);
  43
  44 typedef struct IOCS {
  45     const IOleClientSiteVtbl *lpOleClientSiteVtbl;
  46
  47     LONG ref;
  48     HWND hWnd;
  49     IOleObject *control;
  50     WNDPROC OrigWndProc;
  51 } IOCS;
  52
  53 /**********************************************************************
  54  * AtlAxWin class window procedure
  55  */
  56 static LRESULT CALLBACK AtlAxWin_wndproc( HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam )
  57 {
  58     if ( wMsg == WM_CREATE )
  59     {
  60             DWORD len = GetWindowTextLengthW( hWnd ) + 1;
  61             WCHAR *ptr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
  62             if (!ptr)
  63                 return 1;
  64             GetWindowTextW( hWnd, ptr, len );
  65             AtlAxCreateControlEx( ptr, hWnd, NULL, NULL, NULL, NULL, NULL );
  66             HeapFree( GetProcessHeap(), 0, ptr );
  67             return 0;
  68     }
  69     return DefWindowProcW( hWnd, wMsg, wParam, lParam );
  70 }
  71
  72 /***********************************************************************
  73  *           AtlAxWinInit          [ATL.@]
  74  * Initializes the control-hosting code: registering the AtlAxWin,
  75  * AtlAxWin7 and AtlAxWinLic7 window classes and some messages.
  76  *
  77  * RETURNS
  78  *  TRUE or FALSE
  79  */
  80
  81 BOOL WINAPI AtlAxWinInit(void)
  82 {
  83     WNDCLASSEXW wcex;
  84     const WCHAR AtlAxWin[] = {'A','t','l','A','x','W','i','n',0};
  85
  86     FIXME("semi-stub\n");
  87
  88     if ( FAILED( OleInitialize(NULL) ) )
  89         return FALSE;
  90
  91     wcex.cbSize        = sizeof(wcex);
  92     wcex.style         = 0;
  93     wcex.cbClsExtra    = 0;
  94     wcex.cbWndExtra    = 0;
  95     wcex.hInstance     = GetModuleHandleW( NULL );
  96     wcex.hIcon         = NULL;
  97     wcex.hCursor       = NULL;
  98     wcex.hbrBackground = NULL;
  99     wcex.lpszMenuName  = NULL;
 100     wcex.hIconSm       = 0;
 101
 102     wcex.lpfnWndProc   = AtlAxWin_wndproc;
 103     wcex.lpszClassName = AtlAxWin;
 104     if ( !RegisterClassExW( &wcex ) )
 105         return FALSE;
 106
 107     return TRUE;
 108 }
 109
 110 /***********************************************************************
 111  *  Atl container component implementation
 112  */
 113
 114
 115 static ULONG WINAPI IOCS_AddRef(IOCS *This)
 116 {
 117     ULONG ref = InterlockedIncrement(&This->ref);
 118
 119     TRACE( "(%p) : AddRef from %d\n", This, ref - 1 );
 120
 121     return ref;
 122 }
 123
 124 #define THIS2IOLECLIENTSITE(This) ((IOleClientSite*)&This->lpOleClientSiteVtbl)
 125
 126 static HRESULT WINAPI IOCS_QueryInterface(IOCS *This, REFIID riid, void **ppv)
 127 {
 128     *ppv = NULL;
 129
 130     if ( IsEqualIID( &IID_IUnknown, riid )
 131       || IsEqualIID( &IID_IOleClientSite, riid ) )
 132     {
 133         *ppv = THIS2IOLECLIENTSITE(This);
 134     }
 135
 136     if (*ppv)
 137     {
 138         IOCS_AddRef( This );
 139         return S_OK;
 140     }
 141
 142     WARN("unsupported interface %s\n", debugstr_guid( riid ) );
 143     *ppv = NULL;
 144     return E_NOINTERFACE;
 145 }
 146
 147 static HRESULT IOCS_Detach( IOCS *This );
 148 static ULONG WINAPI IOCS_Release(IOCS *This)
 149 {
 150     ULONG ref = InterlockedDecrement(&This->ref);
 151
 152     TRACE( "(%p) : ReleaseRef to %d\n", This, ref );
 153
 154     if (!ref)
 155     {
 156         IOCS_Detach( This );
 157         HeapFree( GetProcessHeap(), 0, This );
 158     }
 159
 160     return ref;
 161 }
 162
 163 #define DEFINE_THIS(cls,ifc,iface) ((cls*)((BYTE*)(iface)-offsetof(cls,lp ## ifc ## Vtbl)))
 164
 165 #undef  IFACE2THIS
 166 #define IFACE2THIS(iface) DEFINE_THIS(IOCS,OleClientSite, iface)
 167 static HRESULT WINAPI OleClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
 168 {
 169     IOCS *This = IFACE2THIS(iface);
 170     return IOCS_QueryInterface(This, riid, ppv);
 171 }
 172 static ULONG WINAPI OleClientSite_AddRef(IOleClientSite *iface)
 173 {
 174     IOCS *This = IFACE2THIS(iface);
 175     return IOCS_AddRef(This);
 176 }
 177 static ULONG WINAPI OleClientSite_Release(IOleClientSite *iface)
 178 {
 179     IOCS *This = IFACE2THIS(iface);
 180     return IOCS_Release(This);
 181 }
 182 static HRESULT WINAPI OleClientSite_SaveObject(IOleClientSite *iface)
 183 {
 184     IOCS *This = IFACE2THIS(iface);
 185     FIXME( "(%p) - stub\n", This );
 186     return E_NOTIMPL;
 187 }
 188 static HRESULT WINAPI OleClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
 189 {
 190     IOCS *This = IFACE2THIS(iface);
 191
 192     FIXME( "(%p, 0x%x, 0x%x, %p)\n", This, dwAssign, dwWhichMoniker, ppmk );
 193     return E_NOTIMPL;
 194 }
 195 static HRESULT WINAPI OleClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
 196 {
 197     IOCS *This = IFACE2THIS(iface);
 198     FIXME( "(%p, %p)\n", This, ppContainer );
 199     return E_NOTIMPL;
 200 }
 201 static HRESULT WINAPI OleClientSite_ShowObject(IOleClientSite *iface)
 202 {
 203     IOCS *This = IFACE2THIS(iface);
 204     FIXME( "(%p) - stub\n", This );
 205     return S_OK;
 206 }
 207 static HRESULT WINAPI OleClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
 208 {
 209     IOCS *This = IFACE2THIS(iface);
 210     FIXME( "(%p, %s) - stub\n", This, fShow ? "TRUE" : "FALSE" );
 211     return E_NOTIMPL;
 212 }
 213 static HRESULT WINAPI OleClientSite_RequestNewObjectLayout(IOleClientSite *iface)
 214 {
 215     IOCS *This = IFACE2THIS(iface);
 216     FIXME( "(%p) - stub\n", This );
 217     return E_NOTIMPL;
 218 }
 219 #undef IFACE2THIS
 220
 221
 222
 223 static const IOleClientSiteVtbl OleClientSite_vtbl = {
 224     OleClientSite_QueryInterface,
 225     OleClientSite_AddRef,
 226     OleClientSite_Release,
 227     OleClientSite_SaveObject,
 228     OleClientSite_GetMoniker,
 229     OleClientSite_GetContainer,
 230     OleClientSite_ShowObject,
 231     OleClientSite_OnShowWindow,
 232     OleClientSite_RequestNewObjectLayout
 233 };
 234
 235 static HRESULT IOCS_Detach( IOCS *This ) /* remove subclassing */
 236 {
 237     if ( This->hWnd )
 238     {
 239         SetWindowLongPtrW( This->hWnd, GWLP_WNDPROC, (ULONG_PTR) This->OrigWndProc );
 240         SetWindowLongPtrW( This->hWnd, GWLP_USERDATA, (LONG_PTR) NULL );
 241         This->hWnd = NULL;
 242     }
 243     if ( This->control )
 244     {
 245         IOleObject *control = This->control;
 246
 247         This->control = NULL;
 248         IOleObject_SetClientSite( control, NULL );
 249         IOleObject_Release( control );
 250     }
 251     return S_OK;
 252 }
 253
 254 static void IOCS_OnSize( IOCS* This, LPCRECT rect )
 255 {
 256     SIZEL inPix, inHi;
 257
 258     if ( !This->control )
 259         return;
 260
 261     inPix.cx = rect->right - rect->left;
 262     inPix.cy = rect->bottom - rect->top;
 263     AtlPixelToHiMetric( &inPix, &inHi );
 264     IOleObject_SetExtent( This->control, DVASPECT_CONTENT, &inHi );
 265 }
 266
 267 static LRESULT IOCS_OnWndProc( IOCS *This, HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
 268 {
 269     WNDPROC OrigWndProc = This->OrigWndProc;
 270
 271     switch( uMsg )
 272     {
 273         case WM_DESTROY:
 274             IOCS_Detach( This );
 275             break;
 276         case WM_SIZE:
 277             {
 278                 RECT r;
 279                 r.left = r.top = 0;
 280                 r.right = LOWORD( lParam );
 281                 r.bottom = HIWORD( lParam );
 282                 IOCS_OnSize( This, &r );
 283             }
 284             break;
 285     }
 286
 287     return OrigWndProc( hWnd, uMsg, wParam, lParam );
 288 }
 289
 290 static LRESULT CALLBACK AtlHost_wndproc( HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam )
 291 {
 292     IOCS *This = (IOCS*) GetWindowLongPtrW( hWnd, GWLP_USERDATA );
 293     return IOCS_OnWndProc( This, hWnd, wMsg, wParam, lParam );
 294 }
 295
 296 static HRESULT IOCS_Attach( IOCS *This, HWND hWnd, IUnknown *pUnkControl ) /* subclass hWnd */
 297 {
 298     This->hWnd = hWnd;
 299     IUnknown_QueryInterface( pUnkControl, &IID_IOleObject, (void**)&This->control );
 300     IOleObject_SetClientSite( This->control, THIS2IOLECLIENTSITE( This ) );
 301     This->OrigWndProc = (WNDPROC) GetWindowLongPtrW( This->hWnd, GWLP_WNDPROC );
 302     SetWindowLongPtrW( hWnd, GWLP_USERDATA, (ULONG_PTR) This );
 303     SetWindowLongPtrW( hWnd, GWLP_WNDPROC, (ULONG_PTR) AtlHost_wndproc );
 304
 305     return S_OK;
 306 }
 307
 308 static HRESULT IOCS_Init( IOCS *This )
 309 {
 310     RECT rect;
 311     static const WCHAR AXWIN[] = {'A','X','W','I','N',0};
 312
 313     IOleObject_SetHostNames( This->control, AXWIN, AXWIN );
 314
 315     GetClientRect( This->hWnd, &rect );
 316     IOCS_OnSize( This, &rect );
 317
 318     return S_OK;
 319 }
 320
 321 /**********************************************************************
 322  * Create new instance of Atl host component and attach it to window  *
 323  */
 324 static HRESULT IOCS_Create( HWND hWnd, IUnknown *pUnkControl, IOCS **ppSite )
 325 {
 326     HRESULT hr;
 327     IOCS *This;
 328
 329     *ppSite = NULL;
 330     This = HeapAlloc(GetProcessHeap(), 0, sizeof(IOCS));
 331
 332     if (!This)
 333         return E_OUTOFMEMORY;
 334
 335     This->lpOleClientSiteVtbl = &OleClientSite_vtbl;
 336     This->ref = 1;
 337
 338     This->OrigWndProc = NULL;
 339     This->hWnd = NULL;
 340
 341     hr = IOCS_Attach( This, hWnd, pUnkControl );
 342     if ( SUCCEEDED( hr ) )
 343         hr = IOCS_Init( This );
 344     if ( SUCCEEDED( hr ) )
 345         *ppSite = This;
 346     else
 347         IOCS_Release( This );
 348
 349     return hr;
 350 }
 351
 352
 353 /***********************************************************************
 354  *           AtlAxCreateControl           [ATL.@]
 355  */
 356 HRESULT WINAPI AtlAxCreateControl(LPCOLESTR lpszName, HWND hWnd,
 357         IStream *pStream, IUnknown **ppUnkContainer)
 358 {
 359     return AtlAxCreateControlEx( lpszName, hWnd, pStream, ppUnkContainer,
 360             NULL, NULL, NULL );
 361 }
 362
 363 /***********************************************************************
 364  *           AtlAxCreateControlEx            [ATL.@]
 365  *
 366  * REMARKS
 367  *   See http://www.codeproject.com/com/cwebpage.asp for some background
 368  *
 369  */
 370 HRESULT WINAPI AtlAxCreateControlEx(LPCOLESTR lpszName, HWND hWnd,
 371         IStream *pStream, IUnknown **ppUnkContainer, IUnknown **ppUnkControl,
 372         REFIID iidSink, IUnknown *punkSink)
 373 {
 374     CLSID controlId;
 375     HRESULT hRes;
 376     IOleObject *pControl;
 377     IUnknown *pUnkControl;
 378     IPersistStreamInit *pPSInit;
 379     IUnknown *pContainer;
 380     enum {IsGUID=0,IsHTML=1,IsURL=2} content;
 381
 382     TRACE("(%s %p %p %p %p %p %p)\n", debugstr_w(lpszName), hWnd, pStream,
 383             ppUnkContainer, ppUnkControl, iidSink, punkSink);
 384
 385     hRes = CLSIDFromString( (LPOLESTR) lpszName, &controlId );
 386     if ( FAILED(hRes) )
 387         hRes = CLSIDFromProgID( lpszName, &controlId );
 388     if ( SUCCEEDED( hRes ) )
 389         content = IsGUID;
 390     else {
 391         /* FIXME - check for MSHTML: prefix! */
 392         content = IsURL;
 393         memcpy( &controlId, &CLSID_WebBrowser, sizeof(controlId) );
 394     }
 395
 396     hRes = CoCreateInstance( &controlId, 0, CLSCTX_ALL, &IID_IOleObject,
 397             (void**) &pControl );
 398     if ( FAILED( hRes ) )
 399     {
 400         WARN( "cannot create ActiveX control %s instance - error 0x%08x\n",
 401                 debugstr_guid( &controlId ), hRes );
 402         return hRes;
 403     }
 404
 405     hRes = IOleObject_QueryInterface( pControl, &IID_IPersistStreamInit, (void**) &pPSInit );
 406     if ( SUCCEEDED( hRes ) )
 407     {
 408         if (!pStream)
 409             IPersistStreamInit_InitNew( pPSInit );
 410         else
 411             IPersistStreamInit_Load( pPSInit, pStream );
 412         IPersistStreamInit_Release( pPSInit );
 413     } else
 414         WARN("cannot get IID_IPersistStreamInit out of control\n");
 415
 416     IOleObject_QueryInterface( pControl, &IID_IUnknown, (void**) &pUnkControl );
 417     IOleObject_Release( pControl );
 418
 419
 420     hRes = AtlAxAttachControl( pUnkControl, hWnd, &pContainer );
 421     if ( FAILED( hRes ) )
 422         WARN("cannot attach control to window\n");
 423
 424     if ( content == IsURL )
 425     {
 426         IWebBrowser2 *browser;
 427
 428         hRes = IOleObject_QueryInterface( pControl, &IID_IWebBrowser2, (void**) &browser );
 429         if ( !browser )
 430             WARN( "Cannot query IWebBrowser2 interface: %08x\n", hRes );
 431         else {
 432             VARIANT url;
 433
 434             IWebBrowser2_put_Visible( browser, VARIANT_TRUE ); /* it seems that native does this on URL (but do not on MSHTML:! why? */
 435
 436             V_VT(&url) = VT_BSTR;
 437             V_BSTR(&url) = SysAllocString( lpszName );
 438
 439             hRes = IWebBrowser2_Navigate2( browser, &url, NULL, NULL, NULL, NULL );
 440             if ( FAILED( hRes ) )
 441                 WARN( "IWebBrowser2::Navigate2 failed: %08x\n", hRes );
 442             SysFreeString( V_BSTR(&url) );
 443
 444             IWebBrowser2_Release( browser );
 445         }
 446     }
 447
 448     if (ppUnkContainer)
 449     {
 450         *ppUnkContainer = pContainer;
 451         if ( pContainer )
 452             IUnknown_AddRef( pContainer );
 453     }
 454     if (ppUnkControl)
 455     {
 456         *ppUnkControl = pUnkControl;
 457         if ( pUnkControl )
 458             IUnknown_AddRef( pUnkControl );
 459     }
 460
 461     IUnknown_Release( pUnkControl );
 462     if ( pContainer )
 463         IUnknown_Release( pContainer );
 464
 465     return S_OK;
 466 }
 467
 468 /***********************************************************************
 469  *           AtlAxAttachControl           [ATL.@]
 470  */
 471 HRESULT WINAPI AtlAxAttachControl(IUnknown* pControl, HWND hWnd, IUnknown** ppUnkContainer)
 472 {
 473     FIXME( "(%p %p %p) - stub\n", pControl, hWnd, ppUnkContainer );
 474     return E_NOTIMPL;
 475 }
 476
 477 /**********************************************************************
 478  * Helper function for AX_ConvertDialogTemplate
 479  */
 480 static inline BOOL advance_array(WORD **pptr, DWORD *palloc, DWORD *pfilled, const WORD *data, DWORD size)
 481 {
 482     if ( (*pfilled + size) > *palloc )
 483     {
 484         *palloc = ((*pfilled+size) + 0xFF) & ~0xFF;
 485         *pptr = HeapReAlloc( GetProcessHeap(), 0, *pptr, *palloc * sizeof(WORD) );
 486         if (!*pptr)
 487             return FALSE;
 488     }
 489     RtlMoveMemory( *pptr+*pfilled, data, size * sizeof(WORD) );
 490     *pfilled += size;
 491     return TRUE;
 492 }
 493
 494 /**********************************************************************
 495  * Convert ActiveX control templates to AtlAxWin class instances
 496  */
 497 static LPDLGTEMPLATEW AX_ConvertDialogTemplate(LPCDLGTEMPLATEW src_tmpl)
 498 {
 499 #define GET_WORD(x)  (*(const  WORD *)(x))
 500 #define GET_DWORD(x) (*(const DWORD *)(x))
 501 #define PUT_BLOCK(x,y) do {if (!advance_array(&output, &allocated, &filled, (x), (y))) return NULL;} while (0)
 502 #define PUT_WORD(x)  do {WORD w = (x);PUT_BLOCK(&w, 1);} while(0)
 503 #define PUT_DWORD(x)  do {DWORD w = (x);PUT_BLOCK(&w, 2);} while(0)
 504     const WORD *tmp, *src = (const WORD *)src_tmpl;
 505     WORD *output;
 506     DWORD allocated, filled; /* in WORDs */
 507     BOOL ext;
 508     WORD signature, dlgver, rescount;
 509     DWORD style;
 510
 511     filled = 0; allocated = 256;
 512     output = HeapAlloc( GetProcessHeap(), 0, allocated * sizeof(WORD) );
 513     if (!output)
 514         return NULL;
 515
 516     /* header */
 517     tmp = src;
 518     signature = GET_WORD(src);
 519     dlgver = GET_WORD(src + 1);
 520     if (signature == 1 && dlgver == 0xFFFF)
 521     {
 522         ext = TRUE;
 523         src += 6;
 524         style = GET_DWORD(src);
 525         src += 2;
 526         rescount = GET_WORD(src++);
 527         src += 4;
 528         if ( GET_WORD(src) == 0xFFFF ) /* menu */
 529             src += 2;
 530         else
 531             src += strlenW(src) + 1;
 532         if ( GET_WORD(src) == 0xFFFF ) /* class */
 533             src += 2;
 534         else
 535             src += strlenW(src) + 1;
 536         src += strlenW(src) + 1; /* title */
 537         if ( style & (DS_SETFONT | DS_SHELLFONT) )
 538         {
 539             src += 3;
 540             src += strlenW(src) + 1;
 541         }
 542     } else {
 543         ext = FALSE;
 544         style = GET_DWORD(src);
 545         src += 4;
 546         rescount = GET_WORD(src++);
 547         src += 4;
 548         if ( GET_WORD(src) == 0xFFFF ) /* menu */
 549             src += 2;
 550         else
 551             src += strlenW(src) + 1;
 552         if ( GET_WORD(src) == 0xFFFF ) /* class */
 553             src += 2;
 554         else
 555             src += strlenW(src) + 1;
 556         src += strlenW(src) + 1; /* title */
 557         if ( style & DS_SETFONT )
 558         {
 559             src++;
 560             src += strlenW(src) + 1;
 561         }
 562     }
 563     PUT_BLOCK(tmp, src-tmp);
 564
 565     while(rescount--)
 566     {
 567         src = (const WORD *)( ( ((ULONG)src) + 3) & ~3); /* align on DWORD boundary */
 568                 filled = (filled + 1) & ~1; /* depends on DWORD-aligned allocation unit */
 569
 570         tmp = src;
 571         if (ext)
 572             src += 11;
 573         else
 574             src += 9;
 575         PUT_BLOCK(tmp, src-tmp);
 576
 577         tmp = src;
 578         if ( GET_WORD(src) == 0xFFFF ) /* class */
 579         {
 580             src += 2;
 581         } else
 582         {
 583             src += strlenW(src) + 1;
 584         }
 585         src += strlenW(src) + 1; /* title */
 586         if ( GET_WORD(tmp) == '{' ) /* all this mess created because of this line */
 587         {
 588             const WCHAR AtlAxWin[9]={'A','t','l','A','x','W','i','n',0};
 589             PUT_BLOCK(AtlAxWin, sizeof(AtlAxWin)/sizeof(WORD));
 590             PUT_BLOCK(tmp, strlenW(tmp)+1);
 591         } else
 592             PUT_BLOCK(tmp, src-tmp);
 593
 594         if ( GET_WORD(src) )
 595         {
 596             WORD size = (GET_WORD(src)+sizeof(WORD)-1) / sizeof(WORD); /* quite ugly :( Maybe use BYTE* instead of WORD* everywhere ? */
 597             PUT_BLOCK(src, size);
 598             src+=size;
 599         }
 600         else
 601         {
 602             PUT_WORD(0);
 603             src++;
 604         }
 605     }
 606     return (LPDLGTEMPLATEW) output;
 607 }
 608
 609 /***********************************************************************
 610  *           AtlAxCreateDialogA           [ATL.@]
 611  *
 612  * Creates a dialog window
 613  *
 614  * PARAMS
 615  *  hInst   [I] Application instance
 616  *  name    [I] Dialog box template name
 617  *  owner   [I] Dialog box parent HWND
 618  *  dlgProc [I] Dialog box procedure
 619  *  param   [I] This value will be passed to dlgProc as WM_INITDIALOG's message lParam
 620  *
 621  * RETURNS
 622  *  Window handle of dialog window.
 623  */
 624 HWND WINAPI AtlAxCreateDialogA(HINSTANCE hInst, LPCSTR name, HWND owner, DLGPROC dlgProc ,LPARAM param)
 625 {
 626     HWND res = NULL;
 627     int length;
 628     WCHAR *nameW;
 629
 630     if ( HIWORD(name) == 0 )
 631         return AtlAxCreateDialogW( hInst, (LPCWSTR) name, owner, dlgProc, param );
 632
 633     length = MultiByteToWideChar( CP_ACP, 0, name, -1, NULL, 0 );
 634     nameW = HeapAlloc( GetProcessHeap(), 0, length * sizeof(WCHAR) );
 635     if (nameW)
 636     {
 637         MultiByteToWideChar( CP_ACP, 0, name, -1, nameW, length );
 638         res = AtlAxCreateDialogW( hInst, nameW, owner, dlgProc, param );
 639         HeapFree( GetProcessHeap(), 0, nameW );
 640     }
 641     return res;
 642 }
 643
 644 /***********************************************************************
 645  *           AtlAxCreateDialogW           [ATL.@]
 646  *
 647  * See AtlAxCreateDialogA
 648  *
 649  */
 650 HWND WINAPI AtlAxCreateDialogW(HINSTANCE hInst, LPCWSTR name, HWND owner, DLGPROC dlgProc ,LPARAM param)
 651 {
 652     HRSRC hrsrc;
 653     HGLOBAL hgl;
 654     LPCDLGTEMPLATEW ptr;
 655     LPDLGTEMPLATEW newptr;
 656     HWND res;
 657
 658     FIXME("(%p %s %p %p %lx) - not tested\n", hInst, debugstr_w(name), owner, dlgProc, param);
 659
 660     hrsrc = FindResourceW( hInst, name, (LPWSTR)RT_DIALOG );
 661     if ( !hrsrc )
 662         return NULL;
 663     hgl = LoadResource (hInst, hrsrc);
 664     if ( !hgl )
 665         return NULL;
 666     ptr = (LPCDLGTEMPLATEW)LockResource ( hgl );
 667     if (!ptr)
 668     {
 669         FreeResource( hgl );
 670         return NULL;
 671     }
 672     newptr = AX_ConvertDialogTemplate( ptr );
 673     if ( newptr )
 674     {
 675             res = CreateDialogIndirectParamW( hInst, newptr, owner, dlgProc, param );
 676             HeapFree( GetProcessHeap(), 0, newptr );
 677     } else
 678         res = NULL;
 679     FreeResource ( hrsrc );
 680     return res;
 681 }