IE 实现代码示例

IE 是 CE 的一个标准功能，但 很多人想定制 IE 浏览器，以实现某此特殊的需求。

以早以前看过 MS 提供的 IE 示例，研究了一下，现将代码分享出来，大家一起学习。
需要注意的是，IESIMPLE 做为窗体的类名不能修改，详细见代码中的注释。

resource.h 头文件：

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
#define IDC_STATIC                      -1

#define IDR_ACCELERATOR             100

#define IDD_OPEN_DIALOG             1000

#define IDC_URL_EDIT                3000
#define IDC_BROWSE              3001
#define IDC_NEWWINDOW               3002

#define IDS_IE                  20000
#define IDS_ADDRESS             20001
#define IDS_FILESCHEME              20002
#define IDS_HYPHEN              20003
#define IDS_BROWSEFILTER            20010

#define ID_VIEW_STOP                500
#define ID_VIEW_REFRESH             501
#define ID_GO_BACK              502
#define ID_GO_FORWARD               503
#define ID_FOCUS_URL                504
#define ID_OPEN                 505
#define ID_GO_HOME              506
#define ID_GO_SEARCH                507
#define ID_FULLSCREEN               508
#define ID_INTERNET_OPTIONS         509
#define ID_FIND                 510
#define ID_CLOSE                            511
#define ID_ZOOMUP                        512
#define ID_ZOOMDOWN                  513

mainwnd.h 头文件：

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:  mainwnd.h

Abstract:  Implements the main window, the container for the webbrowser

Functions:

Notes: This class implements the container and its interaction with the webbrowser control,
commandbar, statusbar etc.

--*/

#ifndef _MAINWND_H
#define _MAINWND_H_

#include "mshtmhst.h"
#include "interned.h"

#define MAX_URL  2048

class CMainWnd :
public IOleContainer,
public IOleClientSite,
public IOleInPlaceSite,
public IServiceProvider,
public DWebBrowserEvents2,
public IDocHostUIHandler,
public IDocHostShowUI,              // msgbox, help window
public IHTMLOMWindowServices   // for window move, resize events
{

public:
CMainWnd();
~CMainWnd();

BOOL Create();

//IUnknown methods
STDMETHOD(QueryInterface) (REFIID riid, LPVOID * ppv)
{
if ((riid == IID_IOleContainer) || (riid == IID_IUnknown))
{
*ppv = (IOleContainer *) this;
}
else if (riid == IID_IOleClientSite)
{
*ppv = (IOleClientSite *)this;
}
else if (riid == IID_IOleInPlaceSite)
{
*ppv = (IOleInPlaceSite *)this;
}
else if (riid == IID_IOleWindow)
{
*ppv = (IOleWindow *)this;
}
else if ((riid == DIID_DWebBrowserEvents2) || (riid == IID_IDispatch))
{
*ppv = (DWebBrowserEvents2 *)this;
}
else if(riid == IID_IServiceProvider)
{
*ppv = (IServiceProvider *)this;
}
else if (riid == IID_IDocHostUIHandler)
{
*ppv = (IDocHostUIHandler *)this;
}
else if (riid == IID_IDocHostShowUI)
{
*ppv = (IDocHostShowUI *)this;
}
else if (riid == IID_IHTMLOMWindowServices)
{
*ppv = (IHTMLOMWindowServices *)this;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}

STDMETHOD_(ULONG, AddRef) (void)
{
InterlockedIncrement((LONG*)&m_unRefs);
return m_unRefs;
}

STDMETHOD_(ULONG, Release) (void)
{
ULONG ulRefs = m_unRefs;
if (InterlockedDecrement((LONG*)&m_unRefs) == 0)
{
delete this;
return 0;
}
return ulRefs - 1;
}

// IOleContainer methods
STDMETHOD(ParseDisplayName)(IBindCtx *, LPOLESTR, ULONG *, IMoniker **) { return E_NOTIMPL;}
STDMETHOD(EnumObjects)(DWORD, IEnumUnknown **)
{
return E_NOTIMPL;
}
STDMETHOD(LockContainer)(BOOL)                          { return S_OK;}

// IOleClientSite methods
STDMETHOD(SaveObject) (void)                            { return E_NOTIMPL;}
STDMETHOD(GetMoniker) (DWORD dwAssign, DWORD dwWhichMoniker, LPMONIKER * ppmk) { return E_NOTIMPL;}
STDMETHOD(GetContainer) (LPOLECONTAINER * ppContainer)
{
return E_NOINTERFACE;
}
STDMETHOD(ShowObject) (void)                            { return E_NOTIMPL;}
STDMETHOD(OnShowWindow) (BOOL fShow)                    { return E_NOTIMPL;}
STDMETHOD(RequestNewObjectLayout) (void)                { return E_NOTIMPL;}

// IOleWindow methods
STDMETHOD(GetWindow)(HWND *phwnd)
{
*phwnd = m_hWndMain;
return S_OK;
}
STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode)        { return E_NOTIMPL;}

// IOleInPlaceSite methods
STDMETHOD(CanInPlaceActivate)   (void)                  { return S_OK;}
STDMETHOD(OnInPlaceActivate)    (void)
{
m_bInPlaceActive = TRUE;
return S_OK;
}

STDMETHOD(OnUIActivate)         (void)                  { return E_NOTIMPL;}
STDMETHOD(GetWindowContext) (
LPOLEINPLACEFRAME FAR *     lplpFrame,
LPOLEINPLACEUIWINDOW FAR *  lplpDoc,
LPRECT                      lprcPosRect,
LPRECT                      lprcClipRect,
LPOLEINPLACEFRAMEINFO       lpFrameInfo)
{

GetClientRect(m_hWndMain, lprcPosRect);
GetClientRect(m_hWndMain, lprcClipRect);

return S_OK;
}

STDMETHOD(Scroll)               (SIZE scrollExtent)     { return E_NOTIMPL;}
STDMETHOD(OnUIDeactivate)       (BOOL fUndoable)        { return E_NOTIMPL;}
STDMETHOD(OnInPlaceDeactivate)  (void)
{
m_bInPlaceActive = FALSE;
return S_OK;
}

STDMETHOD(DiscardUndoState)     (void)                  { return E_NOTIMPL;}
STDMETHOD(DeactivateAndUndo)    (void)                  { return E_NOTIMPL;}
STDMETHOD(OnPosRectChange)      (LPCRECT lprcPosRect)   { return E_NOTIMPL;}

// IServiceProvider

STDMETHOD(QueryService)(REFGUID guidService, REFIID riid, void **ppvObj)
{
if(guidService == IID_IHTMLOMWindowServices)
{
return QueryInterface(riid, ppvObj);
}
else
return E_FAIL;
}

//DWebBrowserEvents
//IDispatch methods
STDMETHOD(GetTypeInfoCount)(UINT FAR* pctinfo)          { return E_NOTIMPL;}

STDMETHOD(GetTypeInfo)(UINT itinfo,LCID lcid,ITypeInfo FAR* FAR* pptinfo)   { return E_NOTIMPL;}

STDMETHOD(GetIDsOfNames)(REFIID riid,OLECHAR FAR* FAR* rgszNames,UINT cNames,
LCID lcid, DISPID FAR* rgdispid)                  { return E_NOTIMPL;}

STDMETHOD(Invoke)(DISPID dispidMember,REFIID riid,LCID lcid,WORD wFlags,
DISPPARAMS FAR* pdispparams, VARIANT FAR* pvarResult,
EXCEPINFO FAR* pexcepinfo,UINT FAR* puArgErr);

// IDocHostUIHandler methods
STDMETHOD(EnableModeless)(BOOL fEnable) { return E_NOTIMPL; }
STDMETHOD(FilterDataObject)(IDataObject *pDO, IDataObject **ppDORet) { return E_NOTIMPL; }
STDMETHOD(GetDropTarget)(IDropTarget *pDropTarget, IDropTarget **ppDropTarget) { return E_NOTIMPL; }
STDMETHOD(GetExternal)(IDispatch **ppDispatch) { return E_NOTIMPL; }
STDMETHOD(GetHostInfo)(DOCHOSTUIINFO *pInfo);
STDMETHOD(GetOptionKeyPath)(LPOLESTR *pchKey, DWORD dw) { return E_NOTIMPL; }
STDMETHOD(HideUI)(void) { return E_NOTIMPL; }
STDMETHOD(OnDocWindowActivate)(BOOL fActivate) { return E_NOTIMPL; }
STDMETHOD(OnFrameWindowActivate)(BOOL fActivate) { return E_NOTIMPL; }
STDMETHOD(ResizeBorder)(LPCRECT prcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fFrameWindow) { return E_NOTIMPL; }
STDMETHOD(ShowContextMenu)(DWORD dwID, POINT *ppt, IUnknown *pcmdtReserved, IDispatch *pdispReserved) { return E_NOTIMPL; }
STDMETHOD(ShowUI)(DWORD dwID, IOleInPlaceActiveObject *pActiveObject,
IOleCommandTarget *pCommandTarget, IOleInPlaceFrame *pFrame,
IOleInPlaceUIWindow *pDoc) { return E_NOTIMPL; }
STDMETHOD(TranslateAccelerator)(LPMSG lpMsg, const GUID *pgudCmdGroup, DWORD nCmdID) { return E_NOTIMPL; }
STDMETHOD(TranslateUrl)(DWORD dwTranslate, OLECHAR *pchURLIn, OLECHAR **ppchURLOut) { return E_NOTIMPL; }
STDMETHOD(UpdateUI)(void) { return E_NOTIMPL; }

// IDocHostShowUI methods
STDMETHOD(ShowHelp)( HWND hwnd, LPOLESTR pszHelpFile, UINT uCommand,
DWORD dwData, POINT ptMouse, IDispatch *pDispatchObjectHit)
{ return E_NOTIMPL; }

STDMETHOD(ShowMessage)( HWND hwnd, LPOLESTR lpstrText, LPOLESTR lpstrCaption, DWORD dwType,
LPOLESTR lpstrHelpFile, DWORD dwHelpContext, LRESULT *plResult)
{
int iRes = MessageBox(hwnd, lpstrText, lpstrCaption, dwType);
if(plResult)
*plResult = iRes;
return S_OK;
}

// IHTMLOMWindowServices methods
STDMETHOD(moveTo)( LONG x, LONG y);
STDMETHOD(moveBy)( LONG x, LONG y);
STDMETHOD(resizeTo)( LONG x,LONG y);
STDMETHOD(resizeBy)( LONG x, LONG y);

public:
BOOL                    PreTranslateMessage(LPMSG pMsg);
VOID                    Close();
HWND                    GetWindow() {   return m_hWndMain;}
LRESULT                 HandleCommand(WPARAM wParam, LPARAM lParam);

HANDLE                  m_hEvent;
IWebBrowser2            *m_pBrowser;

static LRESULT  CALLBACK MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);

protected:

//Added for HTML Find Dialogs
HRESULT                 FindString();

VOID CMainWnd::ChangeFontSize(BOOL fInit);

BOOL                    RegisterMainWnd();
HWND                    CreateBrowser();
HRESULT                 Activate(IOleObject *pObject);
HRESULT                 InitEvents();

public:
LPTSTR                 m_lpszUrl;
BOOL                   m_bEmpty;
BOOL                   m_bFullScreen;
RECT                   m_rcWnd;
protected:
HACCEL                  m_hAccelTbl;            //a handle to the accelerator table
HWND                    m_hWndMain;         //the main window

ULONG                   m_unRefs;            //reference count for the interfaces supported by the container

HWND                    m_hWndBrowser;       //handle to the browser window

IOleObject              *m_pObject;
IConnectionPoint        *m_pCP;
IOleInPlaceActiveObject *m_pIPActiveObj;
BOOL                    m_bInPlaceActive;
DWORD                   m_dwEventCookie;

TCHAR                   m_tcTitle[MAX_URL];   //title of the current document
HWND                    m_hWndProgress;          // progress bar
RECT                    m_rcProgress;

int                     m_iZoom;
int                     m_iDLCCounter;

};

#endif  //_MAINWND_H_

mainwnd.cpp 源文件：

/*++

Module Name:  mainwnd.cpp

Abstract:  Implements the main window, the container for the webbrowser

Functions:

Notes: Most of the code resides here. The container and its interaction with the webbrowser control,
commandbar, statusbar etc.

--*/
#include <windows.h>
// Include the automation definitions...
#include <exdisp.h>
#include <exdispid.h>
#include <mshtmdid.h> // AMBIENT_DLCONTROL

#include <objbase.h>

#include <tchar.h>

#include <wininet.h>
#include <afdfunc.h>  //ras stuff
#include <pkfuncs.h>  // GetOwnerProcess
#include <mshtml.h>
#include <commctrl.h>
#include <commdlg.h>
#include "MainWnd.h"
#include "resource.h"

#define INITGUID
#include "initguid.h"
#include <hshell.h>

#define START_FULLSCREEN // Remove this if you don't want IESIMPLE to be full-screen at startup

DEFINE_GUID(CLSID_WebBrowser,       0x8856F961L, 0x340A, 0x11D0, 0xA9, 0x6B, 0x00, 0xC0, 0x4F, 0xD7, 0x05, 0xA2);
DEFINE_GUID(IID_IWebBrowser,        0xEAB22AC1L, 0x30C1, 0x11CF, 0xA7, 0xEB, 0x00, 0x00, 0xC0, 0x5B, 0xAE, 0x0B);
DEFINE_GUID(IID_IWebBrowser2,       0xD30C1661L, 0xCDAF, 0x11D0, 0x8A, 0x3E, 0x00, 0xC0, 0x4F, 0xC9, 0xE2, 0x6E);
DEFINE_GUID(DIID_DWebBrowserEvents, 0xEAB22AC2L, 0x30C1, 0x11CF, 0xA7, 0xEB, 0x00, 0x00, 0xC0, 0x5B, 0xAE, 0x0B);
DEFINE_GUID(DIID_DWebBrowserEvents2, 0x34A715A0L, 0x6587, 0x11D0, 0x92, 0x4A, 0x00, 0x20, 0xAF, 0xC7, 0xAC, 0x4D);
DEFINE_GUID(IID_IWebBrowserApp,     0x0002DF05L, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);

const GUID SID_SDocHost = { 0xc6504990, 0xd43e, 0x11cf, { 0x89, 0x3b, 0x00, 0xaa, 0x00, 0xbd, 0xce, 0x1a}};

#define MAX(a,b)  (a > b) ? a : b
#define MIN(a,b)  (a > b) ? b : a

LONG        glThreadCount   = 0;
HWND        ghWndAddressEdit= NULL;
HANDLE      ghExitEvent     = NULL;
HINSTANCE   g_hInstance     = NULL;
DWORD      g_dwMainWindowStackSize = 0x20000;

void GetProxyOption();

static HRESULT FindString();
HRESULT HandleNewWindow2(LPTSTR lpszUrl, DISPPARAMS FAR* pdparams);
BOOL RegisterMainWnd();

DWORD WINAPI NewWindow(LPVOID pParam)
{
CMainWnd *pWnd = (CMainWnd *)pParam;
MSG msg;
BOOL fRet;

HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);

fRet = pWnd->Create();

SetEvent(pWnd->m_hEvent);

if(!fRet)
{
pWnd->m_pBrowser = NULL;
return 0;
}

while(GetMessage( &msg, NULL, 0, 0 ) )
{
if(msg.message == WM_QUIT)
break;

if(!pWnd->PreTranslateMessage(&msg) && !(msg.message == WM_CHAR && msg.wParam == VK_TAB))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}

pWnd->Release();

CoUninitialize();

InterlockedDecrement(&glThreadCount);
SetEvent(ghExitEvent);

return msg.wParam;
}

int APIENTRY WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPTSTR lpCmdLine, int nCmdShow)
{
INITCOMMONCONTROLSEX iccsex;
HKEY hKey;
DWORD dwSize = sizeof(DWORD);
MSG msg;

// HKCU is where IE\Main settings are
if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("SOFTWARE\\Microsoft\\Internet Explorer\\Main"), 0, 0, &hKey))
{
RegQueryValueEx(hKey, TEXT("StackRes"), NULL, NULL, (LPBYTE)&g_dwMainWindowStackSize, &dwSize);
RegCloseKey(hKey);
}

// provide a default stack size if the one given is too small or too large.
if(g_dwMainWindowStackSize < 0x10000 || g_dwMainWindowStackSize > 0x80000)
{
// default to 128k
g_dwMainWindowStackSize = 0x20000;
}
RETAILMSG(1,(L"IESIMPLE Using Stack size: 0x%x\r\n", g_dwMainWindowStackSize));

HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
if(FAILED(hr))
{
return FALSE;
}

if(!RegisterMainWnd())
{
return FALSE;
}

ghExitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if(!ghExitEvent)
{
return FALSE;
}

iccsex.dwSize = sizeof(INITCOMMONCONTROLSEX);
iccsex.dwICC = ICC_COOL_CLASSES;

InitCommonControlsEx(&iccsex);

g_hInstance = hInst;

// Create a message queue on this thread
PeekMessage(&msg, NULL, 0,0,PM_NOREMOVE);

if(FAILED(HandleNewWindow2(lpCmdLine, NULL)))
{
goto Cleanup;
}

while(glThreadCount > 0)
{
WaitForSingleObject(ghExitEvent, INFINITE);
}

Cleanup:
CoUninitialize();

RETAILMSG(1, (L"IESIMPLE exited. Cmdline was: %s\r\n",lpCmdLine ? lpCmdLine : L""));

return TRUE;
}

CMainWnd::CMainWnd()
{
m_unRefs = 1;
m_hWndMain = NULL;
m_pBrowser = NULL;
m_pObject = NULL;
m_pCP = NULL;
m_lpszUrl = NULL;
m_bFullScreen = FALSE;
m_bEmpty = FALSE;
m_tcTitle[0] = 0;

m_iZoom = 2; // default zoom
m_iDLCCounter = 0; // counter for Download Completes

}

CMainWnd::~CMainWnd()
{
RETAILMSG(1,(L"IESIMPLE Exiting ~CMainWnd\r\n"));

if(m_pBrowser)
m_pBrowser->Release();
}

BOOL RegisterMainWnd()
{
WNDCLASS        wc;
wc.style         = 0;
wc.lpfnWndProc   = (WNDPROC)CMainWnd::MainWndProc;
wc.cbClsExtra    = 0;
wc.cbWndExtra    = 0;
wc.hInstance     = g_hInstance;
wc.hIcon         = NULL; // LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_IE));
wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetSysColorBrush(COLOR_WINDOW);
wc.lpszMenuName  = NULL;
wc.lpszClassName = TEXT("IESIMPLE");

if(!(RegisterClass(&wc)))
return FALSE;

return TRUE;
}

BOOL CMainWnd::Create()
{
RECT rcArea;
DWORD dwTick;

DWORD dwStyle = WS_VISIBLE | WS_OVERLAPPED | WS_THICKFRAME | WS_SYSMENU;
/*|WS_OVERLAPPED|WS_BORDER|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX*/
DWORD dwExStyle = 0/*WS_EX_OVERLAPPEDWINDOW*/;

HMENU hMenu = NULL;

SystemParametersInfo(SPI_GETWORKAREA, 0, &rcArea, 0);

m_hWndMain = ::CreateWindowEx(dwExStyle,
TEXT("IESIMPLE"),       // Add ZH  - Leo 不能修改此名称,否则创建窗体失败
(WCHAR *)LoadString(g_hInstance, IDS_IE, NULL, 0),
dwStyle,
rcArea.left + 20,
rcArea.top + 20,
rcArea.right - rcArea.left - 40,
rcArea.bottom - rcArea.top - 30,
NULL, hMenu, g_hInstance, 0);
if(!m_hWndMain)
{
return FALSE;
}

SetWindowLong(m_hWndMain, GWL_USERDATA, (DWORD)this);
GetWindowRect(m_hWndMain, &m_rcWnd);

// create a progress bar
m_rcProgress.left = 5;
m_rcProgress.right = m_rcProgress.left + (m_rcWnd.right - m_rcWnd.left)/3;
m_rcProgress.top = 5;
m_rcProgress.bottom = m_rcProgress.top  + 15;

m_hWndProgress = CreateWindowEx(WS_EX_NOACTIVATE, PROGRESS_CLASS, _T(""), WS_CHILD|PBS_SMOOTH|WS_BORDER,
m_rcProgress.left, m_rcProgress.top, m_rcProgress.right-m_rcProgress.left, m_rcProgress.bottom-m_rcProgress.top,
m_hWndMain, NULL, g_hInstance, NULL);
if(m_hWndProgress)
{
SendMessage(m_hWndProgress, PBM_SETRANGE32, 0, 1000);
}
// /progress bar

dwTick = GetTickCount();
if(!(m_hWndBrowser = CreateBrowser()))
return FALSE;
RETAILMSG(1,(L"Create browser tick count: %d\r\n",GetTickCount() - dwTick));        // 约 2 秒

// LONG lStyle = GetWindowLong(_hWndBrowser, GWL_STYLE);
// SetWindowLong(_hWndBrowser, GWL_STYLE, lStyle|WS_BORDER);

SetFocus(m_hWndMain);

m_hAccelTbl = LoadAccelerators(g_hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR));

#ifdef START_FULLSCREEN
HandleCommand( ID_FULLSCREEN, 0 );
#endif

return TRUE;
}

void GetProxyOption()
{
INTERNET_PER_CONN_OPTION_LIST   iOptionList;
INTERNET_PER_CONN_OPTION        iOptions[3];
ULONG                           uSize = sizeof(iOptionList);

iOptionList.dwSize          = uSize;
iOptionList.pszConnection   = NULL;
iOptionList.dwOptionCount   = 3;
iOptionList.pOptions        = iOptions;

// set proxy type direct or proxy server
iOptions[0].dwOption    = INTERNET_PER_CONN_FLAGS;
iOptions[1].dwOption    = INTERNET_PER_CONN_PROXY_SERVER;
iOptions[2].dwOption    = INTERNET_PER_CONN_PROXY_BYPASS;

if(InternetQueryOption(NULL,INTERNET_OPTION_PER_CONNECTION_OPTION ,(LPVOID)(&iOptionList),&uSize))
{
GlobalFree(iOptionList.pOptions[1].Value.pszValue);
GlobalFree(iOptionList.pOptions[2].Value.pszValue);
}
}

HWND CMainWnd::CreateBrowser()
{
HRESULT hr;
IUnknown *pUnk = NULL;
IOleObject *pObject = NULL;

if(!m_pBrowser)
{
GetProxyOption();
hr = CoCreateInstance(CLSID_WebBrowser, NULL,
CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER,
IID_IUnknown, (LPVOID *)(&pUnk));
if(FAILED(hr))
return FALSE;

hr = pUnk->QueryInterface(IID_IOleObject, (LPVOID *)(&pObject));
if(FAILED(hr))
goto Cleanup;

DWORD dwFlags;
hr = pObject->GetMiscStatus(DVASPECT_CONTENT, &dwFlags);
if(FAILED(hr))
goto Cleanup;

if(dwFlags & OLEMISC_SETCLIENTSITEFIRST)
{
IOleClientSite *pClientSite;
hr = QueryInterface(IID_IOleClientSite, (LPVOID *)(&pClientSite));
if(FAILED(hr))
goto Cleanup;

hr = pObject->SetClientSite(pClientSite);
pClientSite->Release();
if(FAILED(hr))
goto Cleanup;
}

hr = Activate(pObject);
if(FAILED(hr))
goto Cleanup;

hr = m_pObject->QueryInterface(IID_IWebBrowser2, (void **)&m_pBrowser);
if(FAILED(hr))
goto Cleanup;

// See if there might be a url in lpszUrl
hr = pUnk->QueryInterface(IID_IOleInPlaceActiveObject, (LPVOID *)(&m_pIPActiveObj));
if(FAILED(hr))
m_pIPActiveObj = NULL;

hr = S_FALSE;

if(m_bEmpty)
{
// Leo Test: m_lpszUrl = L"http://www.baidu.com";

BSTR bstrURL = SysAllocString(m_lpszUrl);
if(bstrURL && bstrURL[0])
m_pBrowser->Navigate(bstrURL, NULL, NULL, NULL, NULL);
else
m_pBrowser->GoHome();

SysFreeString(bstrURL);

}
hr = InitEvents();
}

Cleanup:
if(pUnk)
pUnk->Release();
if(pObject)
pObject->Release();

IOleWindow *pWnd = NULL;
HWND hwndBrowser = NULL;

if(m_pBrowser)
{
hr = m_pBrowser->QueryInterface(IID_IOleWindow, (LPVOID *)(&pWnd));
if(FAILED(hr))
return NULL;
}

if(pWnd)
{
hr = pWnd->GetWindow(&hwndBrowser);
pWnd->Release();
}
return hwndBrowser;
}

HRESULT CMainWnd::Activate(IOleObject *pObject)
{
m_pObject = pObject;
m_pObject->AddRef();

RECT rc;
::GetClientRect(m_hWndMain, &rc);

HRESULT hr;
hr    =    m_pObject->DoVerb(   OLEIVERB_UIACTIVATE,    NULL,    this,    0,    m_hWndMain,    &rc);

if(FAILED(hr))
goto Cleanup;

Cleanup:
return hr;
}

HRESULT CMainWnd::InitEvents()
{
HRESULT                     hr;
IConnectionPointContainer  *pCPCont = NULL;
DWebBrowserEvents          *pEvents = NULL;

if(!m_pBrowser)
return S_FALSE;
hr = m_pBrowser->QueryInterface(IID_IConnectionPointContainer, (LPVOID *)&pCPCont);
if(FAILED(hr))
return S_FALSE;
hr = pCPCont->FindConnectionPoint(DIID_DWebBrowserEvents2, &m_pCP);
if(FAILED(hr))
{
m_pCP = NULL;
goto Cleanup;
}

hr = QueryInterface(DIID_DWebBrowserEvents2, (LPVOID *)(&pEvents));
if(FAILED(hr))
goto Cleanup;
hr = m_pCP->Advise(pEvents, &(m_dwEventCookie));
if(FAILED(hr))
goto Cleanup;

Cleanup:
if(pCPCont)
pCPCont->Release();
if(pEvents)
pEvents->Release();
return hr;
}

HRESULT HandleNewWindow2(LPTSTR lpszUrl, DISPPARAMS FAR* pdparams)
{
HANDLE hThread;
CMainWnd *pNewWnd;
IDispatch *pDispatch;
HRESULT hr = S_OK;
DWORD dwThreadID = 0;

pNewWnd = new CMainWnd;

if(!pNewWnd)
{
return E_OUTOFMEMORY;
}

pNewWnd->m_lpszUrl = lpszUrl;
if(!pdparams)
pNewWnd->m_bEmpty = TRUE;

pNewWnd->m_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

if(!pNewWnd->m_hEvent)
{
}

InterlockedIncrement(&glThreadCount);

hThread = CreateThread(NULL, g_dwMainWindowStackSize, NewWindow, (LPVOID)pNewWnd, STACK_SIZE_PARAM_IS_A_RESERVATION, &dwThreadID);
if(!hThread)
{
delete pNewWnd;
InterlockedDecrement(&glThreadCount);
return E_OUTOFMEMORY;
}
RETAILMSG(1,(L"[HandleNewWindow2]Create thread,ID is: 0x%x\r\n",dwThreadID));

WaitForSingleObject(pNewWnd->m_hEvent, INFINITE);
CloseHandle(hThread);
if(pdparams)
{
if(pNewWnd->m_pBrowser)
{
hr = pNewWnd->m_pBrowser->QueryInterface(IID_IDispatch, (LPVOID *)(&pDispatch));
}
else
{
hr = E_FAIL;
pDispatch = NULL;
}

*(pdparams->rgvarg[0].pboolVal) = 0;
*(pdparams->rgvarg[1].ppdispVal) = pDispatch;
}
return hr;
}

STDMETHODIMP CMainWnd::GetHostInfo(DOCHOSTUIINFO *pInfo)
{

pInfo->cbSize = sizeof(DOCHOSTUIINFO);
//pInfo->dwFlags = DOCHOSTUIFLAG_NO3DBORDER|DOCHOSTUIFLAG_FLAT_SCROLLBAR;
//pInfo->dwFlags |= DOCHOSTUIFLAG_SCROLL_NO;

return S_OK;

}

STDMETHODIMP CMainWnd::Invoke (
DISPID dispidMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS FAR* pdparams,
VARIANT FAR* pvarResult,
EXCEPINFO FAR* pexcepinfo,
UINT FAR* puArgErr
)
{
switch (dispidMember)
{
case DISPID_AMBIENT_DLCONTROL:
if(pvarResult)
{
V_VT(pvarResult) = VT_I4;
// always set these three unless they should be disabled
pvarResult->lVal = DLCTL_DLIMAGES|DLCTL_VIDEOS|DLCTL_BGSOUNDS;

// put the browser in download only mode
// pvarResult->lVal |= DLCTL_DOWNLOADONLY;
}
break;

case DISPID_STATUSTEXTCHANGE:
{
}
break;

case DISPID_SETSECURELOCKICON:
{
}
break;

case DISPID_PROGRESSCHANGE:
{
LONG lProgMax = pdparams->rgvarg[0].lVal;
LONG lProg = pdparams->rgvarg[1].lVal;
UINT nPos = (lProg == -1) ? 999 : ((lProg-1)%1000);

SendMessage(m_hWndProgress, PBM_SETPOS, nPos, 0);
}
break;

// notification for file download
case DISPID_FILEDOWNLOAD:
break;

case DISPID_NAVIGATECOMPLETE2:
break;

case DISPID_COMMANDSTATECHANGE:
break;

case DISPID_TITLECHANGE:
if(pdparams && pdparams->rgvarg[0].vt == VT_BSTR)
{
TCHAR szTitle[85];
int len = wcslen(pdparams->rgvarg[0].bstrVal);

_tcsncpy(m_tcTitle, pdparams->rgvarg[0].bstrVal, MAX_URL-1);
_tcsncpy(szTitle, pdparams->rgvarg[0].bstrVal, 80);
if(len > 80)
_tcscat(szTitle, L"...");

SetWindowText(m_hWndMain, szTitle);
}
break;

case DISPID_ONQUIT:
PostMessage(m_hWndMain, WM_CLOSE, 0, 0L);
break;

case DISPID_DOWNLOADBEGIN:
m_iDLCCounter++;
SetWindowPos(m_hWndProgress, HWND_TOP, 0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_SHOWWINDOW);
break;
case DISPID_DOWNLOADCOMPLETE:
case DISPID_DOCUMENTCOMPLETE:
m_iDLCCounter--;
if(m_iDLCCounter <= 0)
{
SetWindowPos(m_hWndProgress,NULL, 0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_HIDEWINDOW);
ChangeFontSize(TRUE);
m_iDLCCounter = 0;
}
break;

case DISPID_NEWWINDOW2:
//pdparams->rgvarg[1].boolVal = VARIANT_TRUE;
//break;
return HandleNewWindow2(NULL, pdparams);
break;

case DISPID_PROPERTYCHANGE:
case DISPID_BEFORENAVIGATE2:
break;
default:
return DISP_E_MEMBERNOTFOUND;
}
return S_OK;
}

STDMETHODIMP CMainWnd::moveTo( LONG x, LONG y)
{
SetWindowPos(m_hWndMain, NULL, x, y, 0, 0, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE);
return S_OK;
}

STDMETHODIMP CMainWnd::moveBy( LONG x, LONG y)
{
RECT rcWindow;

GetWindowRect(m_hWndMain, &rcWindow);

SetWindowPos(m_hWndMain, NULL, rcWindow.left + x, rcWindow.top + y, 0, 0,
SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE);
return S_OK;
}

STDMETHODIMP CMainWnd::resizeTo( LONG x, LONG y)
{
// We do not want the size to be less then 100 for top level windows in browser
if(x < 100)
x = 100;

if(y < 100)
y = 100;

SetWindowPos(m_hWndMain, NULL, 0, 0, x, y, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);

return S_OK;
}

STDMETHODIMP CMainWnd::resizeBy( LONG x, LONG y)
{
RECT rcWindow;
long w, h;

GetWindowRect(m_hWndMain, &rcWindow);

w = rcWindow.right - rcWindow.left + x;
h = rcWindow.bottom - rcWindow.top + y;

if(w < 100)
w = 100;

if(h < 100)
h = 100;

SetWindowPos(m_hWndMain, NULL, 0, 0, w, h, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
return S_OK;
}

EXTERN_C const GUID CGID_MSHTML;
extern "C" BOOL APIENTRY OpenURLDlgProc (HWND hDlg, UINT message, UINT wParam, LONG lParam);

LRESULT CMainWnd::HandleCommand(WPARAM wParam, LPARAM lParam)
{
UINT nID = LOWORD(wParam);
switch (nID)
{
case ID_INTERNET_OPTIONS:
{
SHELLEXECUTEINFO sei;
sei.cbSize = sizeof(sei);
sei.fMask = SEE_MASK_FLAG_NO_UI;
sei.hwnd = m_hWndMain;
sei.lpVerb = NULL;
sei.lpFile = L"ctlpnl";
sei.lpParameters = L"inetcpl.cpl";
sei.lpDirectory = NULL;
sei.nShow = SW_SHOWNORMAL;

ShellExecuteEx(&sei);
}
break;
case ID_FIND:
FindString();
break;
case ID_GO_BACK:
m_pBrowser->GoBack();
return 0;
case ID_GO_FORWARD:
m_pBrowser->GoForward();
return 0;
case ID_GO_HOME:
m_pBrowser->GoHome();
return 0;
case ID_GO_SEARCH:
m_pBrowser->GoSearch();
return 0;
case ID_VIEW_REFRESH:
m_pBrowser->Refresh();
return 0;
case ID_VIEW_STOP:
m_pBrowser->Stop();
return 0;

case ID_ZOOMUP:
m_iZoom++;
if(m_iZoom > 4)
m_iZoom = 4;
ChangeFontSize(FALSE);
return 0;

case ID_ZOOMDOWN:
m_iZoom--;
if(m_iZoom < 0)
m_iZoom = 0;
ChangeFontSize(FALSE);
return 0;
case ID_CLOSE:
m_pBrowser->ExecWB(OLECMDID_CLOSE, OLECMDEXECOPT_DODEFAULT, NULL, NULL);
return 0;
case ID_FOCUS_URL:
case ID_OPEN:
{
WCHAR *szURL = new TCHAR[MAX_URL];
if(szURL)
{
int nRet = 0;
BSTR bstrURL = NULL;
m_pBrowser->get_LocationURL(&bstrURL);
nRet = StringCchCopy(szURL, MAX_URL, (LPCTSTR)bstrURL);
SysFreeString(bstrURL);

nRet =  DialogBoxParam(g_hInstance, MAKEINTRESOURCE(IDD_OPEN_DIALOG), m_hWndMain, OpenURLDlgProc, (long)szURL);
bstrURL = SysAllocString(szURL);
if(nRet == 1)
{
m_pBrowser->Navigate(bstrURL, NULL, NULL, NULL, NULL);
}
else if(nRet == 2)
{
HandleNewWindow2(bstrURL,NULL);
}
SysFreeString(bstrURL);
delete[] szURL;
}
}
return 0;
case ID_FULLSCREEN:
{
DWORD dwStyle = GetWindowLong(m_hWndMain, GWL_STYLE);
if(m_bFullScreen)
{
dwStyle |= (WS_OVERLAPPED | WS_SYSMENU | WS_THICKFRAME);
SetWindowLong(m_hWndMain, GWL_STYLE, dwStyle);
SetWindowPos(m_hWndMain,NULL,  m_rcWnd.left, m_rcWnd.top, m_rcWnd.right-m_rcWnd.left, m_rcWnd.bottom-m_rcWnd.top, SWP_NOZORDER);
m_bFullScreen = FALSE;
}
else
{
RECT rcWorkArea;

SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWorkArea, 0);
m_bFullScreen = TRUE;
dwStyle &= ~(WS_OVERLAPPED | WS_SYSMENU | WS_THICKFRAME);

SetWindowLong(m_hWndMain, GWL_STYLE, dwStyle);
SetWindowPos(m_hWndMain,NULL,  rcWorkArea.left, rcWorkArea.top, rcWorkArea.right-rcWorkArea.left, rcWorkArea.bottom-rcWorkArea.top, SWP_NOZORDER);

}
}
return 0;
}
return 0;
}

EXTERN_C const GUID CGID_ShellDocView;

LRESULT CALLBACK CMainWnd::MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
CMainWnd *pMainWnd = (CMainWnd*)GetWindowLong(hwnd, GWL_USERDATA);

if(pMainWnd)
{
switch (message)
{
case WM_CLOSE:
case WM_DESTROY:
if(pMainWnd)
pMainWnd->Close();
SetWindowLong(hwnd, GWL_USERDATA, (DWORD)0);
::PostQuitMessage(0);
break;
case WM_SETFOCUS:
if(pMainWnd->m_pIPActiveObj)
{
pMainWnd->m_pIPActiveObj->OnFrameWindowActivate(LOWORD(wParam) != WA_INACTIVE);
}
return 0;
case WM_SIZE:
{
RECT rcWnd;
GetClientRect(hwnd, &rcWnd);
SetWindowPos(pMainWnd->m_hWndBrowser,
NULL,
0,
0,
rcWnd.right-rcWnd.left,
rcWnd.bottom - rcWnd.top,
SWP_NOZORDER);
}
// FALL THROUGH
case  WM_MOVE:
if(!pMainWnd->m_bFullScreen)
GetWindowRect(hwnd, &pMainWnd->m_rcWnd);
break;
case WM_COMMAND:
return pMainWnd->HandleCommand(wParam, lParam);
break;

case WM_NOTIFY:
break;

case WM_INITMENUPOPUP:
break;

case WM_SETTINGCHANGE:
if(wParam == SPI_SETWORKAREA)
{
if(pMainWnd->m_bFullScreen)
{
RECT rcWorkArea;
// no need to change the window style here, just adjust for the new work-area.
SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWorkArea, 0);
SetWindowPos(pMainWnd->m_hWndMain,NULL,  rcWorkArea.left, rcWorkArea.top, rcWorkArea.right-rcWorkArea.left, rcWorkArea.bottom-rcWorkArea.top, SWP_NOZORDER);
}
}
break;
default:
break;
}
}
return DefWindowProc(hwnd, message, wParam, lParam);
}

BOOL CMainWnd::PreTranslateMessage(LPMSG pMsg)
{
if(::TranslateAccelerator(m_hWndMain, m_hAccelTbl, pMsg))  //first shot to the main frame
return TRUE;

//then to mshtml
if(m_pIPActiveObj && pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST)
{
HRESULT hr = m_pIPActiveObj->TranslateAccelerator(pMsg);
return (hr != S_FALSE);
}
return FALSE;
}

VOID CMainWnd::ChangeFontSize(BOOL fInit)
{
VARIANT vaSize;
vaSize.vt = VT_I4;

if(fInit) {
// Setting initial value
vaSize.vt = 0;
HRESULT hr = m_pBrowser->ExecWB(OLECMDID_ZOOM, OLECMDEXECOPT_DONTPROMPTUSER,
NULL, &vaSize);
m_iZoom = vaSize.lVal;
} else {
vaSize.lVal = m_iZoom;
HRESULT hr = m_pBrowser->ExecWB(OLECMDID_ZOOM, OLECMDEXECOPT_DONTPROMPTUSER,
&vaSize, NULL);
}
}

VOID CMainWnd::Close()
{
RETAILMSG(1,(L"IESIMPLE CMainWnd::Close"));

// Tell the shell to die off
SendMessage(m_hWndBrowser, WM_CLOSE, 0,0);

if(m_pIPActiveObj)
{
m_pIPActiveObj->Release();
}
m_pIPActiveObj = NULL;
if(m_pCP)
{
m_pCP->Unadvise(m_dwEventCookie);
m_pCP->Release();
}
m_pCP = NULL;
if(m_pObject)
{
m_pObject->Close(FALSE);
m_pObject->Release();
}
m_pObject = NULL;
if(m_pBrowser)
m_pBrowser->Release();
m_pBrowser = NULL;

}

HRESULT CMainWnd::FindString()
{
LPDISPATCH pDisp = NULL;
LPOLECOMMANDTARGET pCmdTarg = NULL;
HRESULT sts = S_OK;
VARIANTARG var;

#define GOERROR_S(bNotCond)  {if(!(bNotCond)) goto errorS; }

if(!m_pBrowser)
return S_OK;
sts = m_pBrowser->get_Document(&pDisp);
GOERROR_S(pDisp);
sts = pDisp->QueryInterface(IID_IOleCommandTarget, (LPVOID*)&pCmdTarg);
GOERROR_S(pCmdTarg);

var.vt   = VT_I4;
var.lVal = 0;
sts = pCmdTarg->Exec(
NULL,
OLECMDID_FIND,
MSOCMDEXECOPT_PROMPTUSER,
NULL,
&var);

errorS:
if(pCmdTarg)
pCmdTarg->Release(); // release document's command target
if(pDisp)
pDisp->Release();    // release document's dispatch interface
return sts;
}

BOOL HandleBrowse(HWND hwndOwner, WCHAR *szURL);

extern "C" BOOL APIENTRY OpenURLDlgProc (HWND hDlg, UINT message, UINT wParam, LONG lParam)
{

WCHAR *szURL = (WCHAR *)GetWindowLong(hDlg,DWL_USER);
int         nRet = 4;

switch(message)
{

case WM_INITDIALOG:
{
if(!lParam)
{
EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_BROWSE), FALSE);
}
else
{
szURL = (WCHAR *)lParam;
SetWindowLong(hDlg, DWL_USER, (LONG)szURL);
SendMessage(GetDlgItem(hDlg, IDC_URL_EDIT), EM_LIMITTEXT, MAX_URL-1, 0);
if(szURL[0])
{

SetDlgItemText(hDlg, IDC_URL_EDIT, szURL);
}
}

}
return TRUE;

case WM_COMMAND:
switch (LOWORD(wParam))
{

case IDOK:
{
GetDlgItemText(hDlg, IDC_URL_EDIT, szURL, MAX_URL-1);
BOOL bNewWnd = SendMessage(GetDlgItem(hDlg, IDC_NEWWINDOW), BM_GETCHECK, 0L, 0L);
nRet = (bNewWnd) ? 2 : 1;
}
case IDCANCEL:
EndDialog(hDlg, nRet);
return TRUE;

case IDC_BROWSE:
if(HandleBrowse(hDlg, szURL))
{
SetDlgItemText(hDlg, IDC_URL_EDIT, szURL);
}

default:
return (TRUE);
}
break;

case WM_DESTROY:
SetWindowLong(hDlg, DWL_USER, 0);
break;

}
return (FALSE);

}

extern HINSTANCE   g_hInstance;
BOOL HandleBrowse(HWND hwndOwner, WCHAR *szURL)
{

OPENFILENAME    ofn;
WCHAR           wchFilter[MAX_PATH];
WCHAR           wchFile[MAX_PATH+8];
int             cbLen;

// Initialize ofn struct
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize     = sizeof(ofn);
ofn.hwndOwner       = hwndOwner;
ofn.Flags           = OFN_FILEMUSTEXIST |
OFN_PATHMUSTEXIST   |
OFN_OVERWRITEPROMPT |
OFN_HIDEREADONLY;

cbLen = LoadString(g_hInstance, IDS_BROWSEFILTER,
wchFilter, MAX_PATH-2);

if(cbLen>0)
{
for (; cbLen >= 0; cbLen--)
{
if(wchFilter[cbLen]== L'@')
{
wchFilter[cbLen] = 0;
}
}
}
else
{
return FALSE;
}

ofn.lpstrFilter = wchFilter;
ofn.nFilterIndex = 1;
wcscpy(wchFile, L"file://");

ofn.lpstrFile = wchFile+wcslen(wchFile);  // prefix the string with "file://"
ofn.nMaxFile = MAX_PATH;
if(GetOpenFileName(&ofn))
{
wcsncpy(szURL, wchFile, MAX_URL-1);
return TRUE;
}

return FALSE;

}