cEXWB.cs

//************************************************************************************
// csEXWB control - The most complete C# Webbrowser control.
//
// Auther: MH
// Email: mehr13@hotmail.com
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, and/or sell copies of the Software, and to permit persons
// to whom the Software is furnished to do so.
//
// Although reasonable care has been taken to ensure the correctness of this
// implementation, this code should never be used in
// any application without proper verification and testing.
//************************************************************************************


using System;
using System.ComponentModel;
using System.Windows.Forms;
using System.Drawing;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Security;
using IfacesEnumsStructsClasses;
using System.Diagnostics;
using System.Threading;

namespace csExWB
{
    public class cEXWB : 
        Control,
        IOleClientSite,
        IOleInPlaceSite,
        IDocHostShowUI,
        IDocHostUIHandler,
        DWebBrowserEvents2,
        IfacesEnumsStructsClasses.IDropTarget,
        IfacesEnumsStructsClasses.IServiceProvider,
        IHttpSecurity,
        IWindowForBindingUI,
        INewWindowManager, //WinXP sp2 and up
        IAuthenticate,
        IOleCommandTarget,
        IInternetSecurityManager,
        IHTMLEventCallBack,
        IProtectFocus, //IE7 + Vista
        IHTMLOMWindowServices, //WinXP sp2 and up
        IHTMLEditHost //Please refer to IHTMLEditHost.cs for description
    {

#region Events and EventArgs Memebrs

        public event csExWB.DocumentCompleteEventHandler DocumentComplete = null;
        public event csExWB.BeforeNavigate2EventHandler BeforeNavigate2 = null;
        public event csExWB.ClientToHostWindowEventHandler ClientToHostWindow = null;
        public event csExWB.CommandStateChangeEventHandler CommandStateChange = null;
        public event csExWB.DownloadBeginEventHandler DownloadBegin = null;
        public event csExWB.DownloadCompleteEventHandler DownloadComplete = null;
        public event csExWB.FileDownloadEventHandler FileDownload = null;
        public event csExWB.NavigateComplete2EventHandler NavigateComplete2 = null;
        public event csExWB.NavigateErrorEventHandler NavigateError = null;
        public event csExWB.NewWindow2EventHandler NewWindow2 = null;
        public event csExWB.NewWindow3EventHandler NewWindow3 = null;
        public event csExWB.PrintTemplateInstantiationEventHandler PrintTemplateInstantiation = null;
        public event csExWB.PrintTemplateTeardownEventHandler PrintTemplateTeardown = null;
        public event csExWB.PrivacyImpactedStateChangeEventHandler PrivacyImpactedStateChange = null;
        public event csExWB.ProgressChangeEventHandler ProgressChange = null;
        public event csExWB.PropertyChangeEventHandler PropertyChange = null;
        public event csExWB.SetSecureLockIconEventHandler SetSecureLockIcon = null;
        public event csExWB.StatusTextChangeEventHandler StatusTextChange = null;
        public event csExWB.TitleChangeEventHandler TitleChange = null;
        public event csExWB.WindowClosingEventHandler WindowClosing = null;
        public event csExWB.WindowSetHeightEventHandler WindowSetHeight = null;
        public event csExWB.WindowSetLeftEventHandler WindowSetLeft = null;
        public event csExWB.WindowSetResizableEventHandler WindowSetResizable = null;
        public event csExWB.WindowSetTopEventHandler WindowSetTop = null;
        public event csExWB.WindowSetWidthEventHandler WindowSetWidth = null;
        public event csExWB.WBDragEnterEventHandler WBDragEnter = null;
        public event csExWB.WBDragLeaveEventHandler WBDragLeave = null;
        public event csExWB.WBDragOverEventHandler WBDragOver = null;
        public event csExWB.WBDropEventHandler WBDragDrop = null;
        public event csExWB.WBKeyDownEventHandler WBKeyDown = null;
        public event csExWB.WBKeyUpEventHandler WBKeyUp = null;
        public event csExWB.ContextMenuEventHandler WBContextMenu = null;
        public event csExWB.GetOptionKeyPathEventHandler WBGetOptionKeyPath = null;
        public event csExWB.DocHostShowUIShowMessageEventHandler WBDocHostShowUIShowMessage = null;
        public event csExWB.DocumentCompleteExEventHandler DocumentCompleteEX = null;
        public event csExWB.AuthenticateEventHandler WBAuthenticate = null;
        public event csExWB.SecurityProblemEventHandler WBSecurityProblem = null;
        public event csExWB.EvaluateNewWindowEventHandler WBEvaluteNewWindow = null;
        public event csExWB.ScriptErrorEventHandler ScriptError = null;
        public event csExWB.UpdatePageStatusEventHandler UpdatePageStatus = null;
        public event csExWB.RefreshBeginEventHandler RefreshBegin = null;
        public event csExWB.RefreshEndEventHandler RefreshEnd = null;
        public event csExWB.ProcessUrlActionEventHandler ProcessUrlAction = null;
        public event csExWB.AllowFocusChangeEventHandler AllowFocusChange = null;
        public event csExWB.HTMLOMWindowServicesEventHandler HTMLOMWindowServices_moveTo = null;
        public event csExWB.HTMLOMWindowServicesEventHandler HTMLOMWindowServices_moveBy = null;
        public event csExWB.HTMLOMWindowServicesEventHandler HTMLOMWindowServices_resizeTo = null;
        public event csExWB.HTMLOMWindowServicesEventHandler HTMLOMWindowServices_resizeBy = null;

        public event csExWB.HTMLEventHandler HTMLEvent = null;
        private HTMLEventArgs HtmlEventArg = new HTMLEventArgs();

        private TitleChangeEventArgs TitleChangeEvent = new TitleChangeEventArgs();
        private DocumentCompleteEventArgs DocumentCompleteEvent = new DocumentCompleteEventArgs();
        private DocumentCompleteExEventArgs DocumentCompleteExEvent = new DocumentCompleteExEventArgs();
        private StatusTextChangeEventArgs StatusTextChangeEvent = new StatusTextChangeEventArgs();
        private ProgressChangeEventArgs ProgressChangeEvent = new ProgressChangeEventArgs();
        private CommandStateChangeEventArgs CommandStateChangeEvent = new CommandStateChangeEventArgs();
        private PropertyChangeEventArgs PropertyChangeEvent = new PropertyChangeEventArgs();
        private BeforeNavigate2EventArgs BeforeNavigate2Event = new BeforeNavigate2EventArgs();
        private NavigateComplete2EventArgs NavigateComplete2Event = new NavigateComplete2EventArgs();
        private NewWindow2EventArgs NewWindow2Event = new NewWindow2EventArgs();
        private NewWindow3EventArgs NewWindow3Event = new NewWindow3EventArgs();
        private WindowSetResizableEventArgs WindowSetResizableEvent = new WindowSetResizableEventArgs();
        private WindowSetLeftEventArgs WindowSetLeftEvent = new WindowSetLeftEventArgs();
        private WindowSetTopEventArgs WindowSetTopEvent = new WindowSetTopEventArgs();
        private WindowSetWidthEventArgs WindowSetWidthEvent = new WindowSetWidthEventArgs();
        private WindowSetHeightEventArgs WindowSetHeightEvent = new WindowSetHeightEventArgs();
        private WindowClosingEventArgs WindowClosingEvent = new WindowClosingEventArgs();
        private ClientToHostWindowEventArgs ClientToHostWindowEvent = new ClientToHostWindowEventArgs();
        private SetSecureLockIconEventArgs SetSecureLockIconEvent = new SetSecureLockIconEventArgs();
        private FileDownloadEventArgs FileDownloadEvent = new FileDownloadEventArgs();
        private NavigateErrorEventArgs NavigateErrorEvent = new NavigateErrorEventArgs();
        private PrintTemplateInstantiationEventArgs PrintTemplateInstantiationEvent = new PrintTemplateInstantiationEventArgs();
        private PrintTemplateTeardownEventArgs PrintTemplateTeardownEvent = new PrintTemplateTeardownEventArgs();
        private PrivacyImpactedStateChangeEventArgs PrivacyImpactedStateChangeEvent = new PrivacyImpactedStateChangeEventArgs();
        private UpdatePageStatusEventArgs UpdatePageStatusEvent = new UpdatePageStatusEventArgs();

        private DocHostShowUIShowMessageEventArgs DocHostShowUIShowMessageEvent = new DocHostShowUIShowMessageEventArgs();
        private ContextMenuEventArgs ContextMenuEvent = new ContextMenuEventArgs();
        private GetOptionKeyPathEventArgs GetOptionKeyPathEvent = new GetOptionKeyPathEventArgs();
        private WBKeyDownEventArgs WBKeyDownEvent = new WBKeyDownEventArgs();
        private WBKeyUpEventArgs WBKeyUpEvent = new WBKeyUpEventArgs();
        private EvaluateNewWindowEventArgs EvaluateNewWindowEvent = new EvaluateNewWindowEventArgs();
        private SecurityProblemEventArgs SecurityProblemEvent = new SecurityProblemEventArgs();
        private AuthenticateEventArgs AuthenticateEvent = new AuthenticateEventArgs();
        private WBDragEnterEventArgs WBDragEnterEvent = new WBDragEnterEventArgs();
        private WBDragOverEventArgs WBDragOverEvent = new WBDragOverEventArgs();
        private WBDropEventArgs WBDropEvent = new WBDropEventArgs();
        private ScriptErrorEventArgs ScriptErrorEvent = new ScriptErrorEventArgs();
        private ProcessUrlActionEventArgs ProcessUrlActionEvent = new ProcessUrlActionEventArgs();
        private AllowFocusChangeEventArgs AllowFocusChangeEvent = new AllowFocusChangeEventArgs();
        private HTMLOMWindowServicesEventArgs HTMLOMWindowServicesEvent = new HTMLOMWindowServicesEventArgs();

#endregion //Events and EventArgs Memebrs

#region Local members

        //Required by designer
        private System.ComponentModel.IContainer components = null;

        //Use the internal dragdrop in combination with WBDrag/Drop events
        private bool m_bUseInternalDragDrop = true;
        //Fires DocumentCompleteEx, with an additional parameter "docsource"
        //containning the source of the incoming document before any scripts
        //are executed.
        private bool m_bSendSourceOnDocumentCompleteWBEx = false;
        //this.Control->ShellEmbedding->ShellDocObj->IEServer
        private IntPtr m_hWBServerHandle = (IntPtr)0;
        private IntPtr m_hWBShellDocObjHandle = (IntPtr)0;
        private IntPtr m_hWBShellEmbeddingHandle = (IntPtr)0;
        //Startup URL + LocationUrl
        private const string m_AboutBlank = "about:blank";
        private string m_sUrl = "about:blank";
        private bool m_bCanGoBack = false;
        private bool m_bCanGoForward = false;
        private TextSizeWB m_enumTextSize = TextSizeWB.Medium; //default
        //Default, selecttext+no3dborder+flatscrollbars+themes(xp look)
        private DOCHOSTUIFLAG m_DocHostUiFlags = DOCHOSTUIFLAG.NO3DBORDER | 
            DOCHOSTUIFLAG.FLAT_SCROLLBAR | DOCHOSTUIFLAG.THEME;
        private DOCHOSTUIDBLCLK m_DocHostUiDbClkFlag = DOCHOSTUIDBLCLK.DEFAULT;
        //DLCTL_DLIMAGES
        private DOCDOWNLOADCTLFLAG m_DLCtlFlags = DOCDOWNLOADCTLFLAG.DLIMAGES |
            DOCDOWNLOADCTLFLAG.BGSOUNDS | DOCDOWNLOADCTLFLAG.VIDEOS;

        //Used in find
        private IHTMLTxtRange m_txtrange = null;
        private string m_sLastSearch = string.Empty;
        //Pointer to our browser interface
        private IWebBrowser2 m_WBWebBrowser2 = null;
        //IntPtr.Zero
        private IntPtr m_NullPointer = IntPtr.Zero;
        private tagMSG m_NullMsg = new tagMSG();
        private object m_NullObject = null;
        //ConnectionPoint Cookie
        private int m_dwCookie = 0;
        //Keep track of our location + size
        private tagRECT m_WBRect = new tagRECT(0, 0, 0, 0);
        //WB IUnknown and other ifaces
        private object m_WBUnknown = null;
        private IOleObject m_WBOleObject = null;
        private IOleInPlaceObject m_WBOleInPlaceObject = null;
        private IOleCommandTarget m_WBOleCommandTarget = null;
///Taken from article:
///Invoke Hidden Commands in Your Web Browser
///http://www.codeguru.com/cpp/i-n/ieprogram/openfaq/article.php/c8163/
///As I stated above, the IDocHostUIHandler::ShowContextMenu demo of
///"WebBrowser Customization" in the MSDN shows a way to manually build
///IE's context menu from correlative resource file "SHDOCLC.DLL".
///So, open the file "SHDOCLC.DLL" by using some resource explorer software
///such as "eXeScope", we can find all the Command IDs (also menu item IDs)
///used by the WebBrowser Control under menu resources, and all of them are
///the same in IE 4.x/5.x/6.x according to my tesing.

        //command send to IE server hwnd
        private const int ID_IE_CONTEXTMENU_ADDFAV = 2261;
        //comands send to shelldocobject hwnd
        private const int ID_IE_FIND                     = 67;
        private const int ID_IE_PAGESETUP                = 259;
        private const int ID_IE_PRINT                    = 260;
        private const int ID_IE_PRINTPREVIEW             = 277;
        private const int ID_IE_FILE_NEWMAIL             = 279;
        private const int ID_IE_FILE_SENDPAGE            = 282;
        private const int ID_IE_FILE_SENDLINK            = 283;
        private const int ID_IE_FILE_SENDDESKTOPSHORTCUT = 284;
        private const int ID_IE_FILE_IMPORTEXPORT        = 374;
        private const int ID_IE_FILE_ADDTRUST            = 376;
        private const int ID_IE_FILE_ADDLOCAL            = 377;
        private const int ID_IE_FILE_NEWCALL             = 395; //Internet call
        //To catch Refresh event!
        // counter to monitor number of requests to BeforeNavigate2 vs number of requests to DownloadBegin.
        private int m_nPageCounter = 0;
        // counter to monitor number of DownloadBegin and DownloadEnd calls.
        private int m_nObjCounter = 0;
        // variable to tell us whether a refresh request has started.	
        private bool m_bIsRefresh = false;
        //browser thumb image cache
        private Image m_WBThumbImg = null;

        //Used to handle HtmlDocument and HtmlWindow events
        private bool m_WantHTMLEvents = false;
        private bool m_WantHtmlDocumentEvents = false;
        private bool m_WantHtmlWindowEvents = false;
        //These instances take care of the toplevel document and window
        //For frameset sites, we use a collection of below classes
        private cHTMLDocumentEvents m_TopLevelHtmlDocumentevents = new cHTMLDocumentEvents();
        private cHTMLWindowEvents m_TopLevelHtmlWindowEvents = new cHTMLWindowEvents();
        //Template based lists
        private List<cHTMLDocumentEvents> m_HtmlDocumentEventsList = new List<cHTMLDocumentEvents>();
        private List<cHTMLWindowEvents> m_HtmlWindowEventsList = new List<cHTMLWindowEvents>();

        private int m_SecureLockIcon = (int)SecureLockIconConstants.secureLockIconUnsecure;

        private object m_WinExternal = null;

        //allow or disallow HTML dialogs launched using showModelessDialog() + showModalDialog() methods!
        //Using CBT window hook
        private WindowsHookUtil.HookInfo m_CBT = new WindowsHookUtil.HookInfo(CSEXWBDLMANLib.WINDOWSHOOK_TYPES.WHT_CBT);
        private const string m_HTMLDlgClassName = "Internet Explorer_TridentDlgFrame";
        private IntPtr m_HookHandled = IntPtr.Zero;
        private string m_strTemp = string.Empty;
        private int m_NCode = 0;

        //To subclass Internet Explorer_Server handle in order to catch back and forward buttons
        private IEServerWindow m_ieServerWindow = null;
        private bool m_DocDone = false;

#endregion //Local members

#region Properties list

        [Category("ExWB")]
        public bool MainDocumentFullyLoaded
        {
            get { return m_DocDone; }
        }

        [Category("DOCDOWNLOADCTLFLAG")]
        public int WBDOCDOWNLOADCTLFLAG
        {
            get { return (int)m_DLCtlFlags; }
            set
            {
                m_DLCtlFlags = (DOCDOWNLOADCTLFLAG)value;
                if( ( m_WBUnknown != null ) && (m_WBWebBrowser2 != null) )
                {
                    //Signal change of DL property
                    //so MSHTML call our Invoke method through Dispatch
                    //Otherwise refreshing the page will have no effect
                    //MSHTML does not know of new flags set by us
                    //QI for IOleControl
                    IOleControl pOC = m_WBUnknown as IOleControl;
                    if(pOC != null)
                        pOC.OnAmbientPropertyChange(HTMLDispIDs.DISPID_AMBIENT_DLCONTROL);
                }
            }
        }

        [Category("DOCDOWNLOADCTLFLAG")]
        public bool DownloadImages
        {
            get { return ((m_DLCtlFlags & DOCDOWNLOADCTLFLAG.DLIMAGES) != 0); }
            set { SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.DLIMAGES, value); }
        }

        [Category("DOCDOWNLOADCTLFLAG")]
        public bool DownloadSounds
        {
            get { return ((m_DLCtlFlags & DOCDOWNLOADCTLFLAG.BGSOUNDS) != 0); }
            set { SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.BGSOUNDS, value); }
        }

        [Category("DOCDOWNLOADCTLFLAG")]
        public bool DownloadVideo
        {
            get { return ((m_DLCtlFlags & DOCDOWNLOADCTLFLAG.VIDEOS) != 0); }
            set { SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.VIDEOS, value); }
        }

        [Category("DOCDOWNLOADCTLFLAG")]
        public bool DownloadActiveX
        {
            get { return ((m_DLCtlFlags & DOCDOWNLOADCTLFLAG.NO_DLACTIVEXCTLS) == 0); }
            set
            {
                if (value)
                    SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.NO_DLACTIVEXCTLS, false);
                else
                    SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.NO_DLACTIVEXCTLS, true);
            }
        }

        [Category("DOCDOWNLOADCTLFLAG")]
        public bool DownloadJava
        {
            get { return ((m_DLCtlFlags & DOCDOWNLOADCTLFLAG.NO_JAVA) == 0); }
            set
            {
                if (value)
                    SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.NO_JAVA, false);
                else
                    SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.NO_JAVA, true);
            }
        }

        [Category("DOCDOWNLOADCTLFLAG")]
        public bool DownloadFrames
        {
            get { return ((m_DLCtlFlags & DOCDOWNLOADCTLFLAG.NO_FRAMEDOWNLOAD) == 0); }
            set
            {
                if (value)
                    SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.NO_FRAMEDOWNLOAD, false);
                else
                    SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.NO_FRAMEDOWNLOAD, true);
            }
        }

        [Category("DOCDOWNLOADCTLFLAG")]
        public bool DownloadScripts
        {
            get { return ((m_DLCtlFlags & DOCDOWNLOADCTLFLAG.NO_SCRIPTS) == 0); }
            set
            {
                if (value)
                    SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.NO_SCRIPTS, false);
                else
                    SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG.NO_SCRIPTS, true);
            }
        }

        [Category("DOCHOSTUIFLAG")]
        public int WBDOCHOSTUIFLAG
        {
            get { return (int)m_DocHostUiFlags; }
            set { m_DocHostUiFlags = (DOCHOSTUIFLAG)value; }
        }

        [Category("DOCHOSTUIFLAG")]
        public bool Border3DEnabled
        {
            get { return ((m_DocHostUiFlags & DOCHOSTUIFLAG.NO3DBORDER) == 0); }
            set 
            {
                if(value)
                    SynchDOCHOSTUIFLAG(DOCHOSTUIFLAG.NO3DBORDER, false);
                else
                    SynchDOCHOSTUIFLAG(DOCHOSTUIFLAG.NO3DBORDER, true);
            }
        }

        [Category("DOCHOSTUIFLAG")]
        public bool ScrollBarsEnabled
        {
            get { return ((m_DocHostUiFlags & DOCHOSTUIFLAG.SCROLL_NO) == 0); }
            set
            {
                if (value)
                {
                    SynchDOCHOSTUIFLAG(DOCHOSTUIFLAG.SCROLL_NO, false);
                    SynchDOCHOSTUIFLAG(DOCHOSTUIFLAG.FLAT_SCROLLBAR, value);
                }
                else
                {
                    SynchDOCHOSTUIFLAG(DOCHOSTUIFLAG.FLAT_SCROLLBAR, false);
                    SynchDOCHOSTUIFLAG(DOCHOSTUIFLAG.SCROLL_NO, true);                    
                }
            }
        }

        [Category("DOCHOSTUIDBLCLK")]
        public DOCHOSTUIDBLCLK WBDOCHOSTUIDBLCLK
        {
            get { return m_DocHostUiDbClkFlag; }
            set { m_DocHostUiDbClkFlag = value; }
        }

        [Category("ExWB")]
        public SecureLockIconConstants SecureLockIcon
        {
            get
            {
                return (SecureLockIconConstants)m_SecureLockIcon;
            }
        }

        [Category("ExWB")]
        public TextSizeWB TextSize
        {
            get
            {
                if (m_WBOleCommandTarget != null)
                {
                    object retVal = new object(); //VT_NULL
                    IntPtr pRet = m_NullPointer;
                    int iZoom = (int)5;
                    try
                    {
                        pRet = Marshal.AllocCoTaskMem((int)1024);
                        Marshal.GetNativeVariantForObject(retVal, pRet);

                        //NULL to specify the standard group
                        int hr = m_WBOleCommandTarget.Exec(m_NullPointer,
                            (uint)OLECMDID.OLECMDID_ZOOM,
                            (uint)OLECMDEXECOPT.OLECMDEXECOPT_DONTPROMPTUSER,
                            m_NullPointer, pRet);

                        retVal = Marshal.GetObjectForNativeVariant(pRet);
                        Marshal.FreeCoTaskMem(pRet);
                        pRet = m_NullPointer;
                        if (Type.GetTypeCode(retVal.GetType()) == TypeCode.Int32)
                            iZoom = int.Parse(retVal.ToString());
                        //else
                        //    Debug.Write("Incorrect TypeCode!", "Get_TextSizeWB");
                    }
                    catch (Exception)
                    {
                    }
                    finally
                    {
                        if (pRet != m_NullPointer)
                            Marshal.FreeCoTaskMem(pRet);
                    }
                    if((iZoom > -1) && (iZoom < 5) )
                        m_enumTextSize = (TextSizeWB)iZoom;
                }
                return m_enumTextSize;
            }

            set
            {
                if (m_WBOleCommandTarget != null)
                {
                    if (((int)value > (int)-1) && ((int)value < (int)5))
                    {
                        IntPtr pRet = m_NullPointer;
                        try
                        {
                            pRet = Marshal.AllocCoTaskMem((int)1024);
                            Marshal.GetNativeVariantForObject((int)value, pRet);

                            int hr = m_WBOleCommandTarget.Exec(m_NullPointer,
                                (uint)OLECMDID.OLECMDID_ZOOM,
                                (uint)OLECMDEXECOPT.OLECMDEXECOPT_DONTPROMPTUSER,
                                pRet, m_NullPointer);
                            Marshal.FreeCoTaskMem(pRet);
                            pRet = m_NullPointer;
                            if (hr == Hresults.S_OK)
                                m_enumTextSize = (TextSizeWB)value;
                        }
                        catch (Exception)
                        {
                        }
                        finally
                        {
                            if (pRet != m_NullPointer)
                                Marshal.FreeCoTaskMem(pRet);
                        }
                    }
                }
            }
        }

        [Category("ExWB")]
        public bool CanGoBack
        {
            get { return m_bCanGoBack; }
        }

        [Category("ExWB")]
        public bool CanGoForward
        {
            get { return m_bCanGoForward; }
        }

        [Category("ExWB")]
        public IWebBrowser2 WebbrowserObject
        {
            get { return m_WBWebBrowser2; }
        }

        [Category("ExWB"), Description("true, fires DocumentCompleteEX instead of DocumentComplete passing source of the pDisp Document.")]
        public bool SendSourceOnDocumentCompleteWBEx
        {
            get { return m_bSendSourceOnDocumentCompleteWBEx; }
            set { m_bSendSourceOnDocumentCompleteWBEx = value; }
        }

        [Category("ExWB"), Description("Internet Explorer_Server HWND")]
        public IntPtr IEServerHwnd
        {
            get {return WBIEServerHandle();}
        }

        [Category("ExWB"), Description("ShellEmbedding HWND")]
        public IntPtr ShellEmbedingHwnd
        {
            get { return WBShellEmbedingHandle(); }
        }

        [Category("ExWB"), Description("ShellDocObject HWND")]
        public IntPtr ShellDocObjectHwnd
        {
            get { return WBShellDocObjHandle(); }
        }

        [Category("ExWB"),
        Description("Allows default drag drop operations. Default false. To use internal drag drop, set RegisterForInternalDragDrop to true. Setting this property to true will deactivate internal drag drop.")]
        public bool RegisterAsDropTarget
        {
            get 
            {
                if (m_WBWebBrowser2 != null)
                    return m_WBWebBrowser2.RegisterAsDropTarget;
                else
                    return false;
            }
            set
            {
                if (m_WBWebBrowser2 != null)
                    m_WBWebBrowser2.RegisterAsDropTarget = value;
                if (value)
                    this.RegisterForInternalDragDrop = false;
            }
        }

        [Category("ExWB"),
        Description("Uses internal drag drop events to notify the client. Default true.")]
        public bool RegisterForInternalDragDrop
        {
            get
            {
                return m_bUseInternalDragDrop;
            }
            set
            {
                m_bUseInternalDragDrop = value;
                //Make sure we set RegisterAsDropTarget to false
                if( (m_bUseInternalDragDrop) && (m_WBWebBrowser2 != null) )
                    this.RegisterAsDropTarget = false;
            }
        }

        [ Category("ExWB") ]
        public bool RegisterAsBrowser
        {
            //MessageBox(IntPtr.Zero, "", "", 0);
            get 
            {
                if (m_WBWebBrowser2 != null)
                    return m_WBWebBrowser2.RegisterAsBrowser;
                else
                    return false;
            }
            set
            {
                if (m_WBWebBrowser2 != null)
                    m_WBWebBrowser2.RegisterAsBrowser = value;
            }
        }

        [Category("ExWB")]
        public bool Silent
        {
            get
            {
                if (m_WBWebBrowser2 != null)
                    return m_WBWebBrowser2.Silent;
                else
                    return false;
            }
            set
            {
                if (m_WBWebBrowser2 != null)
                    m_WBWebBrowser2.Silent = value;
            }
        }

        [Category("ExWB")]
        public string LocationName
        {
            get
            {
                if (m_WBWebBrowser2 != null)
                    return m_WBWebBrowser2.LocationName;
                else
                    return "Unavailable";
            }
        }

        [Category("ExWB"), Description("Set or get current LocationURL. Works in design mode as well.")]
        public string LocationUrl
        {
            //Treat it as URL
            get
            {
                if( (!DesignMode) && (m_WBWebBrowser2 != null) )
                    m_sUrl = m_WBWebBrowser2.LocationURL;

                if (m_sUrl.Length == 0)
                    m_sUrl = "about:blank";
                return m_sUrl;
            }
            set
            {
                m_sUrl = value;
                if( (m_WBWebBrowser2 != null) && (m_sLastSearch.Length > 0) )
                   this.Navigate(m_sUrl);
            }
        }

        [Category("ExWB")]
        public bool Busy
        {
            get
            {
                if (m_WBWebBrowser2 != null)
                    return m_WBWebBrowser2.Busy;
                else
                    return false;
            }
        }

        [Category("ExWB")]
        public bool OffLine
        {
            get
            {
                if (m_WBWebBrowser2 != null)
                    return m_WBWebBrowser2.Offline;
                else
                    return false;
            }
            set
            {
                if (m_WBWebBrowser2 != null)
                    m_WBWebBrowser2.Offline = value;
            }
        }

        [Category("ExWB")]
        public tagREADYSTATE ReadyState
        {
            get
            {
                if (m_WBWebBrowser2 != null)
                    return m_WBWebBrowser2.ReadyState;
                else
                    return tagREADYSTATE.READYSTATE_UNINITIALIZED;
            }
        }
        
        [Category("ExWB")]
        public Image ThumbImage
        {
            get
            {
                if (m_WBThumbImg != null)
                    return m_WBThumbImg;
                else
                    return new Bitmap(16, 16);
            }
        }

        [Category("ExWB"), Description("Offers same functionality as ObjectForScripting of C# webbrowser wrapper control.")]
        public object ObjectForScripting
        {
            get
            {
                return m_WinExternal;
            }
            set
            {
                m_WinExternal = value;
            }
        }

        [Category("ExWB"), Description("Sets or retrieves the title of the document")]
        public string DocumentTitle
        {
            get { return this.GetTitle(true); }
            set
            {
                if( (this.m_WBWebBrowser2 != null) &&
                    (m_WBWebBrowser2.Document != null) )
                {
                    IHTMLDocument2 doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
                    if (doc2 != null)
                        doc2.title = value;
                }
            }
        }

        [Category("ExWB"), Description("Sets or retrives the HTML source of the document")]
        public string DocumentSource
        {
            get { return this.GetSource(true); }
            set { this.LoadHtmlIntoBrowser(value); }
        }

        #endregion

#region Overriden members

        public cEXWB()
        {
            ////Set some styles in regard to painting. We don't
            //this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            //this.SetStyle(ControlStyles.ResizeRedraw, true);
            //this.SetStyle(ControlStyles.UserPaint, true);
            //this.SetStyle(ControlStyles.Selectable, true);
            //this.SetStyle(ControlStyles.StandardClick, true);
            //this.SetStyle(ControlStyles.Opaque, true);
            //this.SetStyle(ControlStyles.ContainerControl, true);


            //components = new System.ComponentModel.Container();
            //this.SuspendLayout();
            // 
            // csEXWB
            // 
            //this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            //this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            //this.Name = "csEXWB";
            //this.Size = new System.Drawing.Size(287, 239);
            //this.ResumeLayout(false);
        }

        protected override void OnGotFocus(EventArgs e)
        {
            base.OnGotFocus(e);
            if (!this.DesignMode)
                SetFocus();
        }

        //protected override void OnPaint(PaintEventArgs e)
        //{
        //    e.Graphics.Clear(this.BackColor);
        //    //base.OnPaint(e);
        //}

        protected override void Dispose(bool disposing)
        {
            if( (disposing) && (!this.DesignMode) )
            {
                if (m_HookHandled != IntPtr.Zero)
                    Marshal.FreeHGlobal(m_HookHandled);
                if (m_WBThumbImg != null)
                    m_WBThumbImg.Dispose();
                InternalFreeWB();
                if((components != null))
                    components.Dispose();
            }
            base.Dispose(disposing);
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            this.SetLocation();
        }

        public override bool PreProcessMessage(ref Message msg)
        {
            bool handled = false;
            if ((msg.Msg >= WindowsMessages.WM_KEYFIRST) && (msg.Msg <= WindowsMessages.WM_KEYLAST_NT501))
            {
                // If it's a key down, first see if the key combo is a command key
                if (msg.Msg == WindowsMessages.WM_KEYDOWN)
                {
                    handled = ProcessCmdKey(ref msg, (Keys)(int)msg.WParam | ModifierKeys);
                }

                if (!handled)
                {
                    int keyCode = (int)msg.WParam;
                    // Don't let Trident eat Ctrl-PgUp/PgDn
                    if (((keyCode != (int)Keys.PageUp) && 
                        (keyCode != (int)Keys.PageDown)) || 
                        ((ModifierKeys & Keys.Control) == 0))
                    {
                        tagMSG cm = new tagMSG();

                        cm.hwnd = msg.HWnd;
                        cm.message = msg.Msg;
                        cm.wParam = msg.WParam;
                        cm.lParam = msg.LParam;

                        IOleInPlaceActiveObject accele = m_WBUnknown as IOleInPlaceActiveObject;
                        if( (accele != null) && 
                            (accele.TranslateAccelerator(ref cm) == Hresults.S_OK) )
                            handled = true;
                    }
                    else
                    {
                        // WndProc for Ctrl-PgUp/PgDn is never called so call it directly here
                        WndProc(ref msg);
                        handled = true;
                    }
                }
            }
            if (!handled)
            {
                handled = base.PreProcessMessage(ref msg);
            }
            return handled;
        }

        //private int m_wparam = 0;
        //private KBDLLHOOKSTRUCT m_KBLL = new KBDLLHOOKSTRUCT();
        //How to handle LLKeyboardHook
        /*
            if (m.Msg == m_KEYBOARD_LL.UniqueMsgID)
            {
                //To stop, set to handled
                //m.Result = m_HookHandled;
                m_wparam = (int)m.WParam;

                //Get the structure
                m_KBLL.Reset();
                Marshal.PtrToStructure(m.LParam, m_KBLL);

                //bCtlPressed = (Control.ModifierKeys & Keys.Control) != 0);
                if (m_wparam == WindowsMessages.WM_KEYDOWN)
                    AppendText("KEYBOARD_LL_KEYDOWN=" + m_KBLL.vkCode.ToString() + "\r\n");
                else if (m_wparam == WindowsMessages.WM_KEYUP)
                    AppendText("KEYBOARD_LL_KEYUP=" + m_KBLL.vkCode.ToString() + "\r\n");
                else if (m_wparam == WindowsMessages.WM_SYSKEYDOWN)
                    AppendText("KEYBOARD_LL_SYSKEYDOWN=" + m_KBLL.vkCode.ToString() + "\r\n");
                else if (m_wparam == WindowsMessages.WM_SYSKEYUP)
                    AppendText("KEYBOARD_LL_SYSKEYUP=" + m_KBLL.vkCode.ToString() + "\r\n");
            }
        */

        //private WindowsHookUtil.CBT_CREATEWND m_CBT_CREATEWND = new CBT_CREATEWND();
        //private WindowsHookUtil.CREATESTRUCT m_CREATESTRUCT = new CREATESTRUCT();
        protected override void WndProc(ref Message m)
        {
            if (m.Msg == m_CBT.UniqueMsgID)
            {
                m_csexwbCOMLib.HookProcNCode(CSEXWBDLMANLib.WINDOWSHOOK_TYPES.WHT_CBT, 
                    ref m_NCode);
                if (m_NCode == WindowsHookUtil.HCBT_CREATEWND)
                {
                    //m.WParam contains handle to the new window

                    //One method of getting new window information
                    //Marshal.PtrToStructure(m.LParam, m_CBT_CREATEWND);
                    //Marshal.PtrToStructure(m_CBT_CREATEWND.lpcs, m_CREATESTRUCT);
                    //if (m_CREATESTRUCT.lpszClass != IntPtr.Zero)
                    //{
                    m_strTemp = WinApis.GetWindowClass(m.WParam); //Marshal.PtrToStringAnsi(m_CREATESTRUCT.lpszClass);
                    if (!string.IsNullOrEmpty(m_strTemp))
                    {
                        if (m_strTemp.Equals(m_HTMLDlgClassName, StringComparison.CurrentCultureIgnoreCase))
                            m.Result = m_HookHandled; //dismiss it
                    }
                    //}
                }
            }
            else
                base.WndProc(ref m);
        }

        //public override string ToString()
        //{
        //    return "csEXWB 1.0.0.4";
        //    //return base.ToString();
        //}

        protected override void OnVisibleChanged(EventArgs e)
        {
            base.OnVisibleChanged(e);
            if(m_WBOleObject == null)
                return;
            if(this.Visible)
                m_WBOleObject.DoVerb((int)OLEDOVERB.OLEIVERB_SHOW, ref m_NullMsg, this, 0, this.Handle, ref m_WBRect);
            else
                m_WBOleObject.DoVerb((int)OLEDOVERB.OLEIVERB_HIDE, ref m_NullMsg, this, 0, this.Handle, ref m_WBRect);
        }

        protected override void OnHandleCreated(EventArgs e)
        {
            base.OnHandleCreated(e);
            if (this.IsHandleCreated)
            {
                if (!this.DesignMode)
                {
                    //CBT hook return value to stop an HTMLDialog
                    m_HookHandled = Marshal.AllocHGlobal(Marshal.SizeOf((Int32)1) + 1);
                    Marshal.WriteInt32(m_HookHandled, 1);
                    InitCOMLibrary();
                }
                InternalCreateWB();
            }
        }

        public override void Refresh()
        {
            base.Refresh();
            if( (m_WBWebBrowser2 != null) && (!this.DesignMode) )
                m_WBWebBrowser2.Refresh();
        }

        #endregion

#region Private Method Members

        //Called from resize event to adjust the size of browser
        private void SetLocation()
        {
            if (m_WBOleInPlaceObject == null)
                return;
            bool brect = WinApis.GetClientRect(this.Handle, out m_WBRect);
            //Setup H+W
            m_WBRect.Right = m_WBRect.Right - m_WBRect.Left; //W
            m_WBRect.Bottom = m_WBRect.Bottom - m_WBRect.Top; //H
            m_WBRect.Left = 0;
            m_WBRect.Top = 0;

            m_WBOleInPlaceObject.SetObjectRects(ref m_WBRect, ref m_WBRect);
        }

        //Returns corresponding string for an HRESULT
        private string HresultAsString(int iHRESULT)
        {
            string sRet = "S_OK";
            if (iHRESULT == Hresults.S_OK)
            {
                return sRet;
            }
            else if (iHRESULT == Hresults.S_FALSE)
            {
                sRet = "S_FALSE";
            }
            else if (iHRESULT == Hresults.E_INVALIDARG)
            {
                sRet = "E_INVALIDARG";
            }
            else if (iHRESULT == Hresults.E_NOTIMPL)
            {
                sRet = "E_NOTIMPL";
            }
            else if (iHRESULT == Hresults.E_ABORT)
            {
                sRet = "E_ABORT";
            }
            else if (iHRESULT == Hresults.E_ACCESSDENIED)
            {
                sRet = "E_ACCESSDENIED";
            }
            else if (iHRESULT == Hresults.E_FAIL)
            {
                sRet = "E_FAIL";
            }
            else if (iHRESULT == Hresults.E_FLAGS)
            {
                sRet = "E_FLAGS";
            }
            else if (iHRESULT == Hresults.E_HANDLE)
            {
                sRet = "E_HANDLE";
            }
            else if (iHRESULT == Hresults.E_NOINTERFACE)
            {
                sRet = "E_NOINTERFACE";
            }
            else if (iHRESULT == Hresults.E_OUTOFMEMORY)
            {
                sRet = "E_OUTOFMEMORY";
            }
            else if (iHRESULT == Hresults.E_PENDING)
            {
                sRet = "E_PENDING";
            }
            else if (iHRESULT == Hresults.E_POINTER)
            {
                sRet = "E_POINTER";
            }
            else if (iHRESULT == Hresults.E_UNEXPECTED)
            {
                sRet = "E_UNEXPECTED";
            }
            else if (iHRESULT == Hresults.DV_E_LINDEX)
            {
                sRet = "DV_E_LINDEX";
            }
            else if (iHRESULT == Hresults.OLEOBJ_S_CANNOT_DOVERB_NOW)
            {
                sRet = "OLEOBJ_S_CANNOT_DOVERB_NOW";
            }
            else if (iHRESULT == Hresults.OLEOBJ_S_INVALIDHWND)
            {
                sRet = "OLEOBJ_S_INVALIDHWND";
            }
            else if (iHRESULT == Hresults.OLEOBJ_S_INVALIDVERB)
            {
                sRet = "OLEOBJ_S_INVALIDVERB";
            }
            else if (iHRESULT == Hresults.OLEOBJ_E_NOVERBS)
            {
                sRet = "OLEOBJ_E_NOVERBS";
            }
            else if (iHRESULT == Hresults.OLE_E_NOT_INPLACEACTIVE)
            {
                sRet = "OLE_E_NOT_INPLACEACTIVE";
            }
            else if (iHRESULT == Hresults.OLE_E_CANT_BINDTOSOURCE)
            {
                sRet = "OLE_E_CANT_BINDTOSOURCE";
            }
            else if (iHRESULT == Hresults.OLE_E_CLASSDIFF)
            {
                sRet = "OLE_E_CLASSDIFF";
            }
            else if (iHRESULT == Hresults.OLECMDERR_E_UNKNOWNGROUP)
            {
                sRet = "OLECMDERR_E_UNKNOWNGROUP";
            }
            else if (iHRESULT == Hresults.OLECMDERR_E_NOTSUPPORTED)
            {
                sRet = "OLECMDERR_E_NOTSUPPORTED";
            }
            else if (iHRESULT == Hresults.OLECMDERR_E_DISABLED)
            {
                sRet = "OLECMDERR_E_DISABLED";
            }
            else if (iHRESULT == Hresults.OLECMDERR_E_CANCELED)
            {
                sRet = "OLECMDERR_E_CANCELED";
            }
            else
            {
                sRet = "UNKNOWN-VALUE: " + iHRESULT.ToString();
            }
            return sRet;
        }

        //To retreive ShellEmbeding + ShellDocObj + IEServer HWNDs
        private IntPtr WBShellEmbedingHandle()
        {
            if (m_WBUnknown == null)
                return m_NullPointer;

            if( (!m_hWBShellEmbeddingHandle.Equals(m_NullPointer)) &&
                (WinApis.IsWindow(m_hWBShellEmbeddingHandle)))
                return m_hWBShellEmbeddingHandle;

            m_hWBShellEmbeddingHandle = m_NullPointer;
        
            IOleWindow pWin = m_WBUnknown as IOleWindow;
            if(pWin != null)
                pWin.GetWindow(ref m_hWBShellEmbeddingHandle);

            return m_hWBShellEmbeddingHandle;
        }
        private IntPtr WBShellDocObjHandle()
        {
            if ((!m_hWBShellDocObjHandle.Equals(m_NullPointer)) &&
                (WinApis.IsWindow(m_hWBShellDocObjHandle)))
                return m_hWBShellDocObjHandle;
            m_hWBShellDocObjHandle = m_NullPointer;
            if (!WBShellEmbedingHandle().Equals(m_NullPointer))
            {
                m_hWBShellDocObjHandle = WinApis.GetWindow(m_hWBShellEmbeddingHandle, (uint)GetWindow_Cmd.GW_CHILD);
            }
            return m_hWBShellDocObjHandle;
        }
        private IntPtr WBIEServerHandle()
        {
            if ((!m_hWBServerHandle.Equals(m_NullPointer)) &&
                (WinApis.IsWindow(m_hWBServerHandle)))
                return m_hWBServerHandle;
            if (!WBShellDocObjHandle().Equals(m_NullPointer))
            {
                m_hWBServerHandle = WinApis.GetWindow(m_hWBShellDocObjHandle, (uint)GetWindow_Cmd.GW_CHILD);
            }
            return m_hWBServerHandle;
        }

        //Registers clipboard formats that we can handle
        //Registered Dragdrop formats
        //private short m_CFHTML = 0;
        //private short m_CFRTF = 0;
        //private short m_CFURL = 0;
        //private short m_CFNETRESOURCE = 0;
        //private short m_CFUNTRUSTEDDRAGDROP = 0;
        //private short m_CFFILEGROUPDESCRIPTOR = 0;
        //private short m_CFFILECONTENTS = 0;
        //private void RegisterClipboardFormatsForDragDrop()
        //{
        //    m_CFHTML = (short)WinApis.RegisterClipboardFormat("HTML Format");
        //    m_CFRTF = (short)WinApis.RegisterClipboardFormat("Rich Text Format");
        //    m_CFFILEGROUPDESCRIPTOR = (short)WinApis.RegisterClipboardFormat("FileGroupDescriptor");
        //    m_CFFILECONTENTS = (short)WinApis.RegisterClipboardFormat("FileContents");
        //    m_CFUNTRUSTEDDRAGDROP = (short)WinApis.RegisterClipboardFormat("UntrustedDragDrop");
        //    m_CFURL = (short)WinApis.RegisterClipboardFormat("UniformResourceLocator");
        //    m_CFNETRESOURCE = (short)WinApis.RegisterClipboardFormat("Net Resource");
        //}

        private void InternalFreeWB()
        {
            if( (!DesignMode) && (m_WBUnknown != null) )
            {
                //Get connectionpointcontainer
                IConnectionPointContainer cpCont = m_WBUnknown as IConnectionPointContainer;

                //Find connection point
                if (cpCont != null)
                {
                    Guid guid = typeof(DWebBrowserEvents2).GUID;
                    IConnectionPoint m_WBConnectionPoint = null;
                    cpCont.FindConnectionPoint(ref guid, out m_WBConnectionPoint);
                    //UnAdvice
                    if ((m_WBConnectionPoint != null) && (m_dwCookie > 0))
                        m_WBConnectionPoint.Unadvise(m_dwCookie);
                }

                //UI and Inplace deactivate
                if (m_WBOleInPlaceObject != null)
                {
                    m_WBOleInPlaceObject.UIDeactivate();
                    m_WBOleInPlaceObject.InPlaceDeactivate();
                }

                //Disconnect from ole
                if (m_WBOleObject != null)
                {
                    m_WBOleObject.Close((uint)OLEDOVERB.OLECLOSE_NOSAVE);
                    m_WBOleObject.SetClientSite(null);
                }
            }
            if (m_TravelLogStg != null)
            {
                Marshal.ReleaseComObject(m_TravelLogStg);
                m_TravelLogStg = null;
            }
            if (m_txtrange != null)
            {
                Marshal.ReleaseComObject(m_txtrange);
                m_txtrange = null;
            }
            if (m_WBOleCommandTarget != null)
            {
                Marshal.ReleaseComObject(m_WBOleCommandTarget);
                m_WBOleCommandTarget = null;
            }
            if (m_WBWebBrowser2 != null)
            {
                Marshal.ReleaseComObject(m_WBWebBrowser2);
                m_WBWebBrowser2 = null;
            }
            if (m_WBOleInPlaceObject != null)
            {
                Marshal.ReleaseComObject(m_WBOleInPlaceObject);
                m_WBOleCommandTarget = null;
            }
            if (m_WBOleObject != null)
            {
                Marshal.ReleaseComObject(m_WBOleObject);
                m_WBOleObject = null;
            }
            if (m_WBUnknown != null)
            {
                Marshal.ReleaseComObject(m_WBUnknown);
                m_WBUnknown = null;
            }

            if (m_WantHtmlDocumentEvents)
            {
                m_TopLevelHtmlDocumentevents.DisconnectHtmlEvents();
                DisconnectHtmlDocumentEvents();
            }
            if (m_WantHtmlWindowEvents)
            {
                m_TopLevelHtmlWindowEvents.DisconnectHtmlEvents();
                DisconnectHtmlWindowEvnets();
            }
        }

        /// <summary>
        /// Create Webbrowser control and set up it's events
        /// called from OnHandleCreated
        /// Webbrowser control hosting requires an HWND
        /// </summary>
        /// <returns></returns>
        private void InternalCreateWB()
        {
            //Create a new WB, throws exception if fails
            Type webbrowsertype = Type.GetTypeFromCLSID(Iid_Clsids.CLSID_WebBrowser, true);
            //Using Activator inplace of CoCreateInstance, returns IUnknown
            m_WBUnknown = System.Activator.CreateInstance(webbrowsertype);

            //Get the IOleObject
            m_WBOleObject = (IOleObject)m_WBUnknown;
            //Set client site
            int iret = m_WBOleObject.SetClientSite(this);
            //Set hostnames
            iret = m_WBOleObject.SetHostNames("csEXWB", string.Empty);

            //Get client rect
            bool brect = WinApis.GetClientRect(this.Handle, out m_WBRect);
            //Setup H+W
            m_WBRect.Right = m_WBRect.Right - m_WBRect.Left; //W
            m_WBRect.Bottom = m_WBRect.Bottom - m_WBRect.Top; //H
            m_WBRect.Left = 0;
            m_WBRect.Top = 0;

            //Get the IOleInPlaceObject
            m_WBOleInPlaceObject = (IOleInPlaceObject)m_WBUnknown;
            tagRECT trect = new tagRECT();
            WinApis.CopyRect(ref trect, ref m_WBRect);
            //Set WB rects
            iret = m_WBOleInPlaceObject.SetObjectRects(ref m_WBRect, ref trect);

            //INPLACEACTIVATE the WB
            iret = m_WBOleObject.DoVerb((int)OLEDOVERB.OLEIVERB_INPLACEACTIVATE, ref m_NullMsg, this, 0, this.Handle, ref m_WBRect);

            //Get the IWebBrowser2
            m_WBWebBrowser2 = (IWebBrowser2)m_WBUnknown;

            //By default, we handle dragdrops
            m_WBWebBrowser2.RegisterAsDropTarget = false;
            if (!DesignMode)
            {
                //Get connectionpointcontainer
                IConnectionPointContainer cpCont = (IConnectionPointContainer)m_WBUnknown;
                //Find connection point
                Guid guid = typeof(DWebBrowserEvents2).GUID;
                IConnectionPoint m_WBConnectionPoint = null;
                cpCont.FindConnectionPoint(ref guid, out m_WBConnectionPoint);
                //Advice
                m_WBConnectionPoint.Advise(this, out m_dwCookie);

                //Get the IOleComandTarget
                m_WBOleCommandTarget = (IOleCommandTarget)m_WBUnknown;

                //Reguster clipborad format for internal drag drop
                //RegisterClipboardFormatsForDragDrop();
            }

            if (!string.IsNullOrEmpty(m_sUrl))
                this.Navigate(m_sUrl);
            else
                this.Navigate(m_AboutBlank);

            //Get the shell embedding, ...
            WBIEServerHandle();
        }

        //Wrappers for Webbrowser.ExecWB and IOleCommand.Exec methods
        private void ExecWB(OLECMDID command)
        {
            if (m_WBWebBrowser2 != null)
            {
                m_WBWebBrowser2.ExecWB(command,
                    OLECMDEXECOPT.OLECMDEXECOPT_DODEFAULT,
                    ref m_NullObject, ref m_NullObject);
            }
        }
        private int WBOleCommandExec(OLECMDID command)
        {
            //Execute the command using default group NULL
            int hr = Hresults.S_FALSE; //1
            if(m_WBOleCommandTarget != null) 
            {
                //should return S_OK 0
                hr = m_WBOleCommandTarget.Exec(m_NullPointer,
                    (uint)command, (uint)OLECMDEXECOPT.OLECMDEXECOPT_DONTPROMPTUSER,
                    m_NullPointer, m_NullPointer);
                
            }
            return hr;
        }
        private int WBOleCommandExec(OLECMDID command, OLECMDEXECOPT cmdopt)
        {
            //Execute the command using default group NULL
            int hr = Hresults.S_FALSE;
            if (m_WBOleCommandTarget != null)
            {
                hr = m_WBOleCommandTarget.Exec(m_NullPointer,
                    (uint)command, (uint)cmdopt,
                    m_NullPointer, m_NullPointer);
            }
            return hr;
        }

        //Utility, used in Findxxx methods
        //MakeRGB(Color.FromName(Color));
        private int MakeRGB(Color cColor)
        {
            try
            {
                //Taken from RGB macro in wingdi.h
                return (int)((cColor.R | (((short)cColor.G) << 8)) | (((int)cColor.B) << 16));

            }
            catch (Exception)
            {
                return 0;
            }
        }

        private void SynchDOCDOWNLOADCTLFLAG(DOCDOWNLOADCTLFLAG flag, bool add)
        {
            if (add)
            {
                if ((m_DLCtlFlags & flag) == 0)
                    m_DLCtlFlags |= flag;
            }
            else
            {
                if ((m_DLCtlFlags & flag) != 0)
                    m_DLCtlFlags -= flag;
            }

            if ((m_WBUnknown != null) && (m_WBWebBrowser2 != null))
            {
                try
                {
                    //Signal change of DL property
                    //so MSHTML call our Invoke method through Dispatch
                    //Otherwise refreshing the page will have no effect
                    //MSHTML does not know of new flags set by us
                    //QI for IOleControl
                    IOleControl pOC = (IOleControl)m_WBUnknown;
                    pOC.OnAmbientPropertyChange(HTMLDispIDs.DISPID_AMBIENT_DLCONTROL);
                }
                finally
                {
                }
            }
        }

        private void SynchDOCHOSTUIFLAG(DOCHOSTUIFLAG flag, bool add)
        {
            if (add)
            {
                if ((m_DocHostUiFlags & flag) == 0)
                    m_DocHostUiFlags |= flag;
            }
            else
            {
                if ((m_DocHostUiFlags & flag) != 0)
                    m_DocHostUiFlags -= flag;
            }
        }

#endregion

#region Public Method Members

        //Using IWebBrowser2 interface
        public void Navigate(string URL)
        {
            if (m_WBWebBrowser2 != null)
                m_WBWebBrowser2.Navigate(URL, ref m_NullObject, ref m_NullObject, ref m_NullObject, ref m_NullObject);
        }
        //http://msdn2.microsoft.com/en-us/library/2x07fbw8.aspx
        public void Navigate(string URL, BrowserNavConstants Flags)
        {
            if (m_WBWebBrowser2 != null)
            {
                //At runtime, outobj data type is determined and passed as
                //variant of that type. Used for simple data types
                object outobj = (int)Flags;
                object outtarget = null;
                if(Flags == BrowserNavConstants.navOpenInNewWindow)
                    outtarget = "_BLANK";
                m_WBWebBrowser2.Navigate(URL, ref outobj, ref outtarget , ref m_NullObject, ref m_NullObject);
            }
        }
        public void Navigate(string URL, BrowserNavConstants Flags, string TargetFrameName, string PostData)
        {
            if (m_WBWebBrowser2 != null)
            {
                object vFlags = (int)Flags;
                object vTargetFrameName = TargetFrameName;
                object vPostData = ASCIIEncoding.ASCII.GetBytes(PostData);
                object vHeaders = "Content-Type: application/x-www-form-urlencoded\r\n";
                m_WBWebBrowser2.Navigate(URL, ref vFlags, ref vTargetFrameName, ref vPostData, ref vHeaders);
            }
         }
        public void Navigate(string URL, BrowserNavConstants Flags, string PostData)
        {
            if (m_WBWebBrowser2 != null)
            {
                object vFlags = (int)Flags;
                object vPostData = ASCIIEncoding.ASCII.GetBytes(PostData);
                object vHeaders = "Content-Type: application/x-www-form-urlencoded\r\n";
                m_WBWebBrowser2.Navigate(URL, ref vFlags, ref m_NullObject, ref vPostData, ref vHeaders);
            }
        }
        //PostData: Flav=red&taste=good
        public void Navigate(string URL, string PostData)
        {
            if (m_WBWebBrowser2 != null)
            {
                object vPostData = ASCIIEncoding.ASCII.GetBytes(PostData);
                object vHeaders = "Content-Type: application/x-www-form-urlencoded\r\n";
                m_WBWebBrowser2.Navigate(URL, ref m_NullObject, ref m_NullObject, ref vPostData, ref vHeaders);
            }
        }
        public void Navigate(string URL, byte[] PostData)
        {
            if (m_WBWebBrowser2 != null)
            {
                object vPostData = PostData;
                object vHeaders = "Content-Type: application/x-www-form-urlencoded\r\n";
                m_WBWebBrowser2.Navigate(URL, ref m_NullObject, ref m_NullObject, ref vPostData, ref vHeaders);
            }
        }
        public void Navigate2(string URL)
        {
            if (m_WBWebBrowser2 != null)
            {
                object outobj = URL;
                m_WBWebBrowser2.Navigate2(ref outobj, ref m_NullObject, ref m_NullObject, ref m_NullObject, ref m_NullObject);
            }
        }
        public void NavToBlank()
        {
            if (m_WBWebBrowser2 != null)
                m_WBWebBrowser2.Navigate(m_AboutBlank, ref m_NullObject, ref m_NullObject, ref m_NullObject, ref m_NullObject);

        }

        public void Stop()
        {
            if (m_WBWebBrowser2 != null)
                m_WBWebBrowser2.Stop();
        }
        public bool GoBack()
        {
            if ((m_WBWebBrowser2 != null) && (m_bCanGoBack))
            {
                m_WBWebBrowser2.GoBack();
                return true;
            }
            return false;
        }
        public bool GoForward()
        {
            if ((m_WBWebBrowser2 != null) && (m_bCanGoForward))
            {
                m_WBWebBrowser2.GoForward();
                return true;
            }
            return false;
        }
        public void GoHome()
        {
            if (m_WBWebBrowser2 != null)
                m_WBWebBrowser2.GoHome();
        }
        public void GoSearch()
        {
            if (m_WBWebBrowser2 != null)
                m_WBWebBrowser2.GoSearch();
        }
        public void Refresh2(RefreshConstants Level)
        { 
            if (m_WBWebBrowser2 != null)
            {
                object outobj = (Int32)Level;
                m_WBWebBrowser2.Refresh2(ref outobj);
            }
        }

        //Using IOleCommandTarget interface
        public bool SelectAll()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_SELECTALL) == Hresults.S_OK) ? true : false;
        }
        public bool Clear()
        {
            if (m_WBWebBrowser2 == null)
                return false;
            IHTMLDocument2 doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            if (doc2 == null)
                return false;
            if (doc2.body == null)
                return false;
            doc2.body.innerHTML = "";
            return true;
        }
        public bool ClearSelection()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_CLEARSELECTION) == Hresults.S_OK) ? true : false;
        }
        public bool Copy()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_COPY) == Hresults.S_OK) ? true : false;
        }
        public bool Paste()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_PASTE) == Hresults.S_OK) ? true : false;
        }
        public bool Cut()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_CUT) == Hresults.S_OK) ? true : false;
        }
        public bool Undo()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_UNDO) == Hresults.S_OK) ? true : false;
        }
        public bool Redo()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_REDO) == Hresults.S_OK) ? true : false;
        }
        public bool Delete()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_DELETE) == Hresults.S_OK) ? true : false;
        }
        public bool PasteSpecial()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_PASTESPECIAL) == Hresults.S_OK) ? true : false;
        }
        public bool Spell()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_SPELL) == Hresults.S_OK) ? true : false;
        }
        public bool NewWindow()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_NEW) == Hresults.S_OK) ? true : false;
        }
        public bool Print()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_PRINT) == Hresults.S_OK) ? true : false;
        }
        public bool Print2()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_PRINT2) == Hresults.S_OK) ? true : false;
        }
        public bool Properties()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_PROPERTIES) == Hresults.S_OK) ? true : false;
        }
        public bool PrintPreview()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_PRINTPREVIEW) == Hresults.S_OK) ? true : false;
        }
        public bool PrintPreview2()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_PRINTPREVIEW2) == Hresults.S_OK) ? true : false;
        }
        public bool PageSetup()
        {
            return (this.WBOleCommandExec(OLECMDID.OLECMDID_PAGESETUP) == Hresults.S_OK) ? true : false;
        }
        public void SaveAs()
        {
            //displays the old style saveas
            //returns notsupported if user clicks cancel
            //m_iTmpRet = this.WBOleCommandExec(OLECMDID.OLECMDID_SAVEAS);
            
            //if (m_iTmpRet != Hresults.S_OK)
            this.ExecWB(OLECMDID.OLECMDID_SAVEAS); //displays modern style
        }

        //using CGI_IWebBrowser group
        private int ShowMiscCommands(WB_MiscCommandTarget command)
        {
            int hr = Hresults.S_FALSE;
            uint uicommand = (uint)command;
            if (m_WBOleCommandTarget != null)
            {
                IntPtr pPt = m_NullPointer;
                try
                {
                    byte[] guidbytes = Iid_Clsids.CLSID_CGI_IWebBrowser.ToByteArray();
                    pPt = Marshal.AllocCoTaskMem((int)(guidbytes.Length * 2));
                    Marshal.Copy(guidbytes, 0, pPt, guidbytes.Length);
                    
                    hr = m_WBOleCommandTarget.Exec(pPt,
                        uicommand,
                        (uint)OLECMDEXECOPT.OLECMDEXECOPT_DODEFAULT,
                        m_NullPointer, m_NullPointer);

                    Marshal.FreeCoTaskMem(pPt);
                    pPt = m_NullPointer;
                    //if (hr != Hresults.S_OK)
                    //    MessageBox(m_NullPointer, HresultAsString(hr),"ShowFindWB",0);
                }
                finally
                {
                    if (pPt != m_NullPointer)
                        Marshal.FreeCoTaskMem(pPt);
                }
            }
            return hr;
        }
        public bool Find()
        {
            return (this.ShowMiscCommands(WB_MiscCommandTarget.Find) == Hresults.S_OK) ? true : false;
        }
        public bool IEOptions()
        {
            return (this.ShowMiscCommands(WB_MiscCommandTarget.Options) == Hresults.S_OK) ? true : false;
        }
        public bool ViewSource()
        {
            return (this.ShowMiscCommands(WB_MiscCommandTarget.ViewSource) == Hresults.S_OK) ? true : false;
        }

        //Using IShellUIHelper
        //If not working use API:
        //DoOrganizeFavDlg
        //AddUrlToFavorites
        private int ShellUIHelperMiscCommands(string scommand)
        {

            #region C++ version
            //    HRESULT hr;
            //    IShellUIHelper* pShellUI = NULL;
            //    hr = CoCreateInstance(CLSID_ShellUIHelper, NULL, CLSCTX_INPROC_SERVER, IID_IShellUIHelper, (void **)&pShellUI);
            //    if(FAILED(hr) || !pShellUI) return Hresults.S_FALSE;
            //
            //LanguageDialog
            //    Opens the Language Preference dialog box.
            //OrganizeFavorites
            //    Opens the Organize Favorites dialog box.
            //PrivacySettings
            //    Microsoft® Internet Explorer 6 and later. Opens the Privacy Preferences dialog box.
            //ProgramAccessAndDefaults
            //    Microsoft Windows® XP Service Pack 1 (SP1) and later. Opens the Set Program Access and Defaults dialog box.
            //
            //    pShellUI->ShowBrowserUI(CComBSTR(L"OrganizeFavorites"), NULL, NULL);
            //    pShellUI->Release(); 
            #endregion

            int hr = Hresults.S_FALSE;
            //Create a new ShellUiHelper
            Type shelluitype = Type.GetTypeFromCLSID(Iid_Clsids.CLSID_ShellUIHelper, true);
            //Using Activator inplace of CoCreateInstance, returns IUnknown
            IShellUIHelper uihelper = System.Activator.CreateInstance(shelluitype) as IShellUIHelper;
            if (uihelper == null)
                return hr;
            uihelper.ShowBrowserUI(scommand,ref m_NullObject);
            return hr;
        }
        public void OrganizeFavorites()
        {
            ShellUIHelperMiscCommands("OrganizeFavorites");
        }
        public void PrivacySettings()
        {
            ShellUIHelperMiscCommands("PrivacySettings");
        }
        public void LanguageDialog()
        {
            ShellUIHelperMiscCommands("LanguageDialog");
        }
        public void ProgramAccessAndDefaults()
        {
            ShellUIHelperMiscCommands("ProgramAccessAndDefaults");
        }

        //Using IE Server hwnd and shelldocobject hwnd directly
        //Do not work in Vista IE7, COMMANDID values have changed
        public void AddToFavorites()
        {
            if (!WBIEServerHandle().Equals(m_NullPointer))
            {
                HandleRef hhwnd = new HandleRef(this, m_hWBServerHandle);
                WinApis.SendMessage(hhwnd, (uint)WindowsMessages.WM_COMMAND, 
                    (IntPtr)ID_IE_CONTEXTMENU_ADDFAV, m_NullPointer);
            }
        }
        public void ImportExport()
        {
            if (!WBShellDocObjHandle().Equals(m_NullPointer))
            {
                HandleRef hhwnd = new HandleRef(this, m_hWBShellDocObjHandle);
                WinApis.SendMessage(hhwnd, (uint)WindowsMessages.WM_COMMAND, 
                    (IntPtr)ID_IE_FILE_IMPORTEXPORT, m_NullPointer);
            }
        }
        public void SendLinkByEmail()
        {
            if (!WBShellDocObjHandle().Equals(m_NullPointer))
            {
                HandleRef hhwnd = new HandleRef(this, m_hWBShellDocObjHandle);
                WinApis.SendMessage(hhwnd, (uint)WindowsMessages.WM_COMMAND, 
                    (IntPtr)ID_IE_FILE_SENDLINK, m_NullPointer);
            }
        }
        public void SendPageByEmail()
        {
            if (!WBShellDocObjHandle().Equals(m_NullPointer))
            {
                HandleRef hhwnd = new HandleRef(this, m_hWBShellDocObjHandle);
                WinApis.SendMessage(hhwnd, (uint)WindowsMessages.WM_COMMAND, 
                    (IntPtr)ID_IE_FILE_SENDPAGE, m_NullPointer);
            }
        }
        public void SendShortcutToDesktop()
        {

            if (!WBShellDocObjHandle().Equals(m_NullPointer))
            {
                HandleRef hhwnd = new HandleRef(this, m_hWBShellDocObjHandle);
                WinApis.SendMessage(hhwnd, (uint)WindowsMessages.WM_COMMAND, 
                    (IntPtr)ID_IE_FILE_SENDDESKTOPSHORTCUT, m_NullPointer);
            }
        }

        //Using IWebbrowser2
        //Loads a URL into browser using IPersistMoniker interface
        public bool LoadUrlIntoBrowser(String url) 
        {
            bool ret = false;
            if( (m_WBWebBrowser2 == null) || (url.Length == 0) )
               return ret;

            IPersistMoniker persistMoniker = m_WBWebBrowser2.Document as IPersistMoniker;
            if (persistMoniker == null) 
               return ret;
            IMoniker moniker = null;
            IBindCtx bindContext = null;
            WinApis.CreateBindCtx((uint)0, out bindContext);
            if (bindContext == null)
               return ret;
            //need our own implementation of moniker
            //moniker.BindToStorage(bindContext, null,ref IID_IStream,out new object(stream));            
            WinApis.CreateURLMoniker(null, url, out moniker);
            if (moniker == null)
               return ret;
            persistMoniker.Load(1, moniker, bindContext, 0);
            return true;
        }
        public bool LoadHtmlIntoBrowser(string html, string sBaseUrl) 
        {
            bool ret = false;
            if ((m_WBWebBrowser2 == null) || (html.Length == 0))
                return ret;

            IStream stream = null;
            //Use Marshal.StringToHGlobalAnsi to get ANSI
            int hr = WinApis.CreateStreamOnHGlobal(Marshal.StringToHGlobalAuto(html), true, out stream);
            if ((hr != Hresults.S_OK) || (stream == null))
                return ret;

            IPersistMoniker pPM = m_WBWebBrowser2.Document as IPersistMoniker;

            if (pPM == null)
                return ret;
            IBindCtx bindctx = null;
            WinApis.CreateBindCtx((uint)0, out bindctx);
            if (bindctx == null)
                return ret;
            LoadHTMLMoniker loader = new LoadHTMLMoniker();
            if (string.IsNullOrEmpty(sBaseUrl))
                sBaseUrl = m_WBWebBrowser2.LocationURL;
            loader.InitLoader(html, sBaseUrl);
            pPM.Load(1, loader, bindctx, WinApis.STGM_READ);
            stream = null;
            return true;
        }
        public bool LoadHtmlIntoBrowser(string html)
        {
            bool ret = false;
            if ((m_WBWebBrowser2 == null) || 
                (m_WBWebBrowser2.Document == null) ||
                (html.Length == 0)
               )
                return ret;
            //pWebBrowser->get_Document( &pHTMLDocDisp );
            //pHTMLDocDisp->QueryInterface( IID_IPersistStreamInit,  (void**)&pPersistStreamInit );
            IStream stream = null;
            //Use Marshal.StringToHGlobalAnsi to get ANSI
            //or Marshal.StringToHGlobalUni to get UNICODE
            //or Marshal.StringToHGlobalAuto to default to ANSI
            //define UNICODE in build config to get UNICODE HGlobal
            int hr = WinApis.CreateStreamOnHGlobal(Marshal.StringToHGlobalAuto(html), true, out stream);
            if ((hr != Hresults.S_OK) || (stream == null))
                return ret;
            
            IPersistStreamInit persistentStreamInit = m_WBWebBrowser2.Document as IPersistStreamInit;
            if (persistentStreamInit != null)
            {
                persistentStreamInit.InitNew();
                persistentStreamInit.Load(stream);
                persistentStreamInit = null;
                ret = true;
            }
            stream = null; 
            return ret;
        }

        private bool ThumbnailCallback() { return false; }

        /// <summary>
        /// Faster than DrawThumb, but
        /// does not work if a window is hidden
        /// or is not on top of the zorder
        /// </summary>
        /// <param name="W"></param>
        /// <param name="H"></param>
        /// <param name="pixFormat"></param>
        /// <returns></returns>
        public Image DrawThumb2(int W, int H, System.Drawing.Imaging.PixelFormat pixFormat)
        {
            if (WBIEServerHandle().Equals(IntPtr.Zero))
                return m_WBThumbImg;
            Bitmap bmp1 = null;
            try
            {
                if (m_WBThumbImg != null)
                {
                    m_WBThumbImg.Dispose();
                    m_WBThumbImg = null;
                }

                IntPtr wbhdc = WinApis.GetWindowDC(m_hWBServerHandle);
                if (wbhdc == IntPtr.Zero)
                    return m_WBThumbImg;

                bmp1 = new Bitmap(m_WBRect.Right, m_WBRect.Bottom, pixFormat);
                using (Graphics grl = Graphics.FromImage(bmp1))
                {
                    IntPtr ghdc = grl.GetHdc();
                    //blt it to the hdc
                    WinApis.BitBlt(ghdc, 0, 0, bmp1.Width, bmp1.Height,
                        wbhdc, 0, 0, TernaryRasterOperations.SRCCOPY);
                    grl.ReleaseHdc();
                }
                m_WBThumbImg = bmp1.GetThumbnailImage(W, H, new Image.GetThumbnailImageAbort(ThumbnailCallback), IntPtr.Zero);
                bmp1.Dispose();
                bmp1 = null;
            }
            finally
            {
                if (bmp1 != null)
                    bmp1.Dispose();
            }
            return m_WBThumbImg;
        }
        public Image DrawThumb(int W, int H, System.Drawing.Imaging.PixelFormat pixFormat)
        {
            Bitmap bmp = null;
            try
            {
                if (m_WBThumbImg != null)
                {
                    m_WBThumbImg.Dispose();
                    m_WBThumbImg = null;
                }
                if (m_WBWebBrowser2 == null)
                    return m_WBThumbImg;

                //Frameset
                //http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/samples/internet/libraries/ie6_lib/default.asp
                if (IsWBFrameset(this.m_WBWebBrowser2))
                {
                    //Not the best but works as long as the browser
                    //is in front of Zorder
                    //an alternative approach would be to get
                    //the frames collection using GetFrames() method
                    //Make a bitmap size of the webbrowser,
                    //draw each frame on a seperate bitmap and then
                    //transfer it to the main bitmap according to their
                    //left and top offsets. A bit lenghty and messy.
                    //If you are looking for a challange then go no further than
                    //MSDN homepage, http://msdn.microsoft.com/library/default.asp
                    //This page has a total of six frames, but some of the frames
                    //are contained within other frames and so on. Getting the
                    //width and height is easy, but finding where to start drawing
                    //frames is not.
                    return DrawThumb2(W, H, pixFormat);
                }

                //Get doc2, and viewobject
                IHTMLDocument2 pDoc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
                if (pDoc2 == null)
                    return m_WBThumbImg;

                IViewObject pViewObject = pDoc2 as IViewObject;
                if (pViewObject == null)
                    return m_WBThumbImg;

                IHTMLBodyElement pBody = null;
                IHTMLElement pElem = null;
                IHTMLStyle pStyle = null;
                string strStyle = string.Empty;

                //get the IHtmlelement
                pElem = pDoc2.body;
                if (pElem != null)
                {
                    //Get the IHTMLStyle
                    pStyle = pElem.style;
                    //Get the borderstyle so we can reset it
                    strStyle = pStyle.borderStyle;
                    //Hide 3D border
                    pStyle.borderStyle = "none";

                    pBody = pElem as IHTMLBodyElement;
                    //No scrollbars
                    if(pBody != null)
                        pBody.scroll = "no";
                }
                //Create bmp
                bmp = new Bitmap(m_WBRect.Right, m_WBRect.Bottom, pixFormat);

                //draw
                int hr = Hresults.S_FALSE;

                using (Graphics gr = Graphics.FromImage(bmp))
                {
                    //get hdc
                    IntPtr hdc = gr.GetHdc();
                    hr = pViewObject.Draw(
                        (uint)DVASPECT.DVASPECT_CONTENT,
                        (int)-1, m_NullPointer, m_NullPointer,
                        m_NullPointer, hdc, ref m_WBRect, ref m_WBRect,
                        m_NullPointer, (uint)0);
                    //if (hr == Hresults.S_OK)
                    //{
                    //    //Transfer to target hdc - TargetHdc = picturebox.image hdc
                    //    StretchBlt(TargetHdc, X, Y, W, H,
                    //        hdc, 0, 0, bmp.Width, bmp.Height,
                    //        TernaryRasterOperations.SRCCOPY);
                    //}
                    gr.ReleaseHdc();
                    //gr.Dispose();
                }

                if (!string.IsNullOrEmpty(strStyle))
                    pStyle.borderStyle = strStyle;
                if (pBody != null)
                    pBody.scroll = "auto";

                m_WBThumbImg = bmp.GetThumbnailImage(W, H, 
                    new Image.GetThumbnailImageAbort(ThumbnailCallback), 
                    IntPtr.Zero);

                bmp.Dispose();
                bmp = null;
            }
            finally
            {
                if (bmp != null)
                    bmp.Dispose();
            }
            return m_WBThumbImg;
        }
        public void SaveBrowserImage(string sFileName, 
            System.Drawing.Imaging.PixelFormat pixFormat,
            System.Drawing.Imaging.ImageFormat format)
        {
            if (m_WBWebBrowser2 == null)
                return;
            Bitmap bmp = null;
            try
            {
                //Get doc2, doc3, and viewobject
                IHTMLDocument2 pDoc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
                if (pDoc2 == null) return;
                IHTMLDocument3 pDoc3 = m_WBWebBrowser2.Document as IHTMLDocument3;
                if (pDoc3 == null) return;
                IViewObject pViewObject = pDoc2 as IViewObject;
                if (pViewObject == null) return;

                IHTMLBodyElement pBody = null;
                IHTMLElement pElem = null;
                IHTMLElement2 pBodyElem = null;
                IHTMLStyle pStyle = null;
                string strStyle;
                int bodyHeight = 0;
                int bodyWidth = 0;
                int rootHeight = 0;
                int rootWidth = 0;
                int height = 0;
                int width = 0;

                //get the IHtmlelement
                pElem = pDoc2.body;

                //Get the IHTMLStyle
                if(pElem != null)
                    pStyle = pElem.style;

                //Get the borderstyle so we can reset it
                strStyle = pStyle.borderStyle;
                //Hide 3D border
                pStyle.borderStyle = "none";
                pBody = pElem as IHTMLBodyElement;
                //No scrollbars
                if(pBody != null)
                    pBody.scroll = "no";

                //Get root scroll h + w
                //QI for IHTMLElement2
                pBodyElem = pElem as IHTMLElement2;
                if (pBodyElem != null)
                {
                    bodyWidth = pBodyElem.scrollWidth;
                    bodyHeight = pBodyElem.scrollHeight;
                }

                //release
                pElem = null;
                pBodyElem = null;
                //Get docelem
                pElem = pDoc3.documentElement;
                //QI for IHTMLElement2
                if (pElem != null)
                {
                    pBodyElem = pElem as IHTMLElement2;
                    //Get scroll H + W
                    if (pBodyElem != null)
                    {
                        rootWidth = pBodyElem.scrollWidth;
                        rootHeight = pBodyElem.scrollHeight;
                    }
                    //calc actual W + H
                    width = rootWidth > bodyWidth ? rootWidth : bodyWidth;
                    height = rootHeight > bodyHeight ? rootHeight : bodyHeight;
                }
                //Set up a rect
                tagRECT rWPos = new tagRECT(0, 0, width, height);

                //Size browser
                if (m_WBOleInPlaceObject != null)
                    m_WBOleInPlaceObject.SetObjectRects(ref rWPos, ref rWPos);

                //Create bmp
                bmp = new Bitmap(width, height, pixFormat);

                //draw
                int hr = Hresults.S_FALSE;
                using (Graphics gr = Graphics.FromImage(bmp))
                {
                    //get hdc
                    IntPtr hdc = gr.GetHdc();
                    hr = pViewObject.Draw(
                        (uint)DVASPECT.DVASPECT_CONTENT,
                        (int)-1, m_NullPointer, m_NullPointer,
                        m_NullPointer, hdc, ref rWPos, ref rWPos,
                        m_NullPointer, (uint)0);
                    gr.ReleaseHdc(hdc);
                }

                //reset
                this.SetLocation();
                if (!string.IsNullOrEmpty(strStyle))
                    pStyle.borderStyle = strStyle;
                if(pBody != null)
                    pBody.scroll = "auto";

                if (hr == Hresults.S_OK)
                {
                    //save
                    bmp.Save(sFileName, format);
                }
                bmp.Dispose();
                bmp = null;
            }
            finally
            {
                if (bmp != null)
                    bmp.Dispose();
            }
        }

        //Using CGID_ShellDocView
        public void ShowCertificateDialog()
        {
            if (m_WBOleCommandTarget == null)
                return;
            IntPtr pPt = m_NullPointer;
            int hr = Hresults.S_OK;
            try
            {
                byte[] guidbytes = Iid_Clsids.CGID_ShellDocView.ToByteArray();
                pPt = Marshal.AllocCoTaskMem((int)(guidbytes.Length * 2));
                Marshal.Copy(guidbytes, 0, pPt, guidbytes.Length);

                hr = m_WBOleCommandTarget.Exec(pPt,
                    WinApis.SHDVID_SSLSTATUS,
                    (uint)OLECMDEXECOPT.OLECMDEXECOPT_DODEFAULT,
                    m_NullPointer, m_NullPointer);

                Marshal.FreeCoTaskMem(pPt);
                pPt = m_NullPointer;
            }
            finally
            {
                if (pPt != m_NullPointer)
                    Marshal.FreeCoTaskMem(pPt);
            }
        }
        
        public bool HasFocus()
        {
            if (m_WBWebBrowser2 != null)
            {
                IHTMLDocument4 doc4 = m_WBWebBrowser2.Document as IHTMLDocument4;
                if (doc4 != null)
                    return doc4.hasFocus();
            }
            return false;
        }
        public void SetFocus()
        {
            if (m_WBWebBrowser2 == null)
                return;

            //UI activate first
            if (m_WBOleObject != null)
                m_WBOleObject.DoVerb((int)OLEDOVERB.OLEIVERB_UIACTIVATE, 
                    ref m_NullMsg, this, 0, this.Handle, ref m_WBRect);

            //Check to see if frameset
//            if (IsWBFrameset(this.m_WBWebBrowser2))
//            {
                IHTMLDocument4 doc4 = m_WBWebBrowser2.Document as IHTMLDocument4;
                if (doc4 != null)
                    doc4.focus();
//            }
//            else //Use body elem to set focus
//                SetFocusBody();

            //    if (!WBIEServerHandle().Equals(m_NullPointer))
            //        SetFocus(m_hWBServerHandle);
        }
        private void SetFocusBody()
        {
            if (m_WBWebBrowser2 == null)
                return;

            IHTMLDocument2 doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            if (doc2 == null)
                return;
            IHTMLElement2 elem2 = doc2.body as IHTMLElement2;
            if (elem2 == null)
                return;
            elem2.focus();
        }

        //We don't have access to IDispatch::Invoke
        //Fired when IOleControl::OnAmbientPropertyChange is called
        //from WBDOCDOWNLOADCTLFLAG property in response to DLCtl flag changing
        [DispId(HTMLDispIDs.DISPID_AMBIENT_DLCONTROL)]
        public int Idispatch_AmbiantDlControl_Invoke_Handler()
        {
            return (int)m_DLCtlFlags;
        }

        //Find + Find and highlight
        public bool FindInPage(string sFind, bool DownWard, bool MatchWholeWord, bool MatchCase, bool ScrollIntoView)
        {
            bool success = false;
            if (m_WBWebBrowser2 == null)
                return success;

            if (sFind.Length == 0)
            {
                m_sLastSearch = "";
                m_txtrange = null;
                return success;
            }
            else
                m_sLastSearch = sFind;

            int searchdir = (DownWard) ? 1000000 : -1000000;
            int searchcase = 0; //default

            //Set up search case
            if ((MatchWholeWord) && (MatchCase))
                searchcase = 6;
            else if (MatchWholeWord)
                searchcase = 2;
            else if (MatchCase)
                searchcase = 4;

            if (m_txtrange != null)
            {
                if (sFind == m_sLastSearch)
                {
                    if (DownWard)
                        m_txtrange.collapse(false);
                    else
                        m_txtrange.collapse(true);
                }
                else
                    m_txtrange = null;
            }

            IHTMLDocument2 pDoc2 = GetActiveDocument();
            if (pDoc2 == null)
                return success;

            IHTMLElement pElem = pDoc2.body;
            IHTMLBodyElement pBodyelem = pElem as IHTMLBodyElement;
            if (pBodyelem == null)
                return success;

            if (m_txtrange == null)
                m_txtrange = pBodyelem.createTextRange();
            if (m_txtrange == null)
                return success;

            success = m_txtrange.findText(sFind, searchdir, searchcase);
            if (success)
            {
                m_txtrange.select();
                if (ScrollIntoView)
                    m_txtrange.scrollIntoView(true);
            }
            return success;
        }
        public int FindAndHightAllInPage(string sFind, bool MatchWholeWord, bool MatchCase, int cbackColor, int cForeColor)
        {
            int iMatches = 0;
            if ((sFind.Length == 0) || (m_WBWebBrowser2 == null))
                return iMatches;

            int searchdir = 0;
            int searchcase = 0; //default
            const string strbg = "BackColor";
            const string strf = "ForeColor";
            const string sword = "Character";
            const string stextedit = "Textedit";

            //Set up search case
            if ((MatchWholeWord) && (MatchCase))
                searchcase = 6;
            else if (MatchWholeWord)
                searchcase = 2;
            else if (MatchCase)
                searchcase = 4;

            IHTMLDocument2 pDoc2 = GetActiveDocument();
            if (pDoc2 == null)
                return iMatches;

            IHTMLElement pElem = pDoc2.body;
            IHTMLBodyElement pBodyelem = pElem as IHTMLBodyElement;
            if (pBodyelem == null)
                return iMatches;

            IHTMLTxtRange pTxtRange = pBodyelem.createTextRange();
            if (pTxtRange == null)
                return iMatches;

            //Can also QI pTxtRange for IOleCommand and use Exec method
            //is recommanded by MSDN.
            while (pTxtRange.findText(sFind, searchdir, searchcase))
            {
                if(cbackColor != 0)
                    pTxtRange.execCommand(strbg, false, cbackColor);
                if(cForeColor != 0)
                    pTxtRange.execCommand(strf, false, cForeColor);
                pTxtRange.moveStart(sword, 1);
                pTxtRange.moveEnd(stextedit, 1);
                iMatches = iMatches + 1;
            }
            return iMatches;
        }
        public int FindAndHightAllInPage(string sFind, bool MatchWholeWord, bool MatchCase, string cbackColor, string cForeColor)
        {
            int b = 0;
            int f = 0;
            //You may be tempted to use Color.Yellow.ToArgb(). But,
            //the value returned includes the A value which
            //causes confusion for MSHTML. i.e. Color.Cyan is interpreted as yellow
            if (cbackColor.Length > 0)
                b = MakeRGB(Color.FromName(cbackColor));
            if (cForeColor.Length > 0)
                f = MakeRGB(Color.FromName(cForeColor));
            return this.FindAndHightAllInPage(sFind, MatchWholeWord, MatchCase, b, f);
        }
        public int FindAndHightAllInPage(string sFind, bool MatchWholeWord, bool MatchCase, Color cbackColor, Color cForeColor)
        {
            int b = 0;
            int f = 0;
            if (cbackColor != Color.Empty)
                b = MakeRGB(cbackColor);
            if (cForeColor != Color.Empty)
                f = MakeRGB(cForeColor);
            return this.FindAndHightAllInPage(sFind, MatchWholeWord, MatchCase,b, f);
        }

        //"Cut", "Copy", "Paste", ...
        public bool IsCommandEnabled(string sCmdId)
        {
            if (m_WBWebBrowser2 == null)
                return false;
            IHTMLDocument2 doc2 = this.m_WBWebBrowser2.Document as IHTMLDocument2;
            if (doc2 != null)
                return doc2.queryCommandEnabled(sCmdId);
            return false;
        }
        public bool SetDesignMode(string sMode)
        {
            if (m_WBWebBrowser2 == null)
                return false;

            IHTMLDocument2 doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            if (doc2 != null)
            {
                doc2.designMode = sMode;
                return true;
            }
            return false;
        }
        public string GetDesignMode()
        {
            if (m_WBWebBrowser2 == null)
                return string.Empty;
            IHTMLDocument2 doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            if (doc2 != null)
                return doc2.designMode;
            return string.Empty;
        }

        //Frames Proof methods
        public IHTMLDocument2 GetActiveDocument()
        {
            IHTMLDocument2 doc2 = null;
            IHTMLElement elem = null;
            IWebBrowser2 wb = null;
            if (this.m_WBWebBrowser2 == null)
                return doc2;

            //Get document
            doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            if (doc2 == null) return doc2;

            if (!IsWBFrameset(doc2))
                return doc2;

            //Get active element
            elem = doc2.activeElement;

            IntPtr pelem = Marshal.GetIUnknownForObject(elem);
            if (pelem != IntPtr.Zero)
            {
                IntPtr pWB = IntPtr.Zero;
                int iRet = Marshal.QueryInterface(pelem, 
                    ref Iid_Clsids.IID_IWebBrowser2, out pWB);
                //GetIUnknownForObject AddRefs so Release                        
                Marshal.Release(pelem);

                while (pWB != IntPtr.Zero)
                {
                    wb = Marshal.GetObjectForIUnknown(pWB) as IWebBrowser2;

                    //QueryInterface AddRefs so Release
                    Marshal.Release(pWB);
                    pWB = IntPtr.Zero;

                    if (wb == null) break;

                    doc2 = wb.Document as IHTMLDocument2;
                    if (doc2 == null) break;

                    elem = doc2.activeElement;
                    if (elem == null) break;

                    pelem = Marshal.GetIUnknownForObject(elem);
                    if (pelem != IntPtr.Zero)
                        iRet = Marshal.QueryInterface(pelem, 
                            ref Iid_Clsids.IID_IWebBrowser2, out pWB);
                    Marshal.Release(pelem);
                }
            }

            //Here is the C# version. Raises exception

            ////QI for IWebbrowser2 iface
            //wb = (IWebBrowser2)elem;
            ////Continue till no more frames to traverse
            //while (wb != null)
            //{
            //    doc2 = (IHTMLDocument2)wb.Document;
            //    elem = doc2.activeElement;
            //    wb = (IWebBrowser2)elem;
            //}

            return doc2;
        }
        public IHTMLElement GetActiveElement()
        {
            IHTMLElement elem = null;
            IHTMLDocument2 doc2 = GetActiveDocument();
            if (doc2 != null)
                elem = doc2.activeElement;
            return elem;
        }

        //if(bTopLevel == true) we use the toplevel document (Not frameset)
        //if(bTopLevel == false) we find the activedocument and use it's document
        //Use IsFrameset method in conjunction with these methods
        public string GetTitle(bool bTopLevel)
        {
            if (this.m_WBWebBrowser2 == null)
                return string.Empty;
            IHTMLDocument2 doc2 = null;
            if (bTopLevel)
                doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            else
                doc2 = this.GetActiveDocument();
            if (doc2 != null)
                return doc2.title;
            else
                return string.Empty;
        }
        public string GetTitle(IWebBrowser2 thisBrowser)
        {
            if (thisBrowser == null)
                return string.Empty;
            IHTMLDocument2 doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            if (doc2 != null)
                return doc2.title;
            else
                return string.Empty;
        }
        public string GetText(bool bTopLevel)
        {
            if (this.m_WBWebBrowser2 == null)
                return string.Empty;
            IHTMLDocument3 doc3 = null;
            if (bTopLevel)
            {
                doc3 = m_WBWebBrowser2.Document as IHTMLDocument3;
                if (doc3 != null)
                    return doc3.documentElement.outerText;
            }
            else
            {
                doc3 = this.GetActiveDocument() as IHTMLDocument3;
                if (doc3 != null)
                    return doc3.documentElement.outerText;
            }
            return string.Empty;
        }
        public string GetText(IWebBrowser2 thisBrowser)
        {
            if (thisBrowser == null)
                return string.Empty;
            IHTMLDocument3 doc3 = thisBrowser.Document as IHTMLDocument3;
            if (doc3 != null)
                return doc3.documentElement.outerText;
            else
                return string.Empty;
        }
        public string GetSource(bool bTopLevel)
        {
            if(this.m_WBWebBrowser2 == null)
                return string.Empty;
            
            IHTMLDocument3 doc3 = null;
            if( bTopLevel )
                doc3 = this.m_WBWebBrowser2.Document as IHTMLDocument3;
                //return GetSource(this.m_WBWebBrowser2);
            else
                doc3 = this.GetActiveDocument() as IHTMLDocument3;
            if ((doc3 != null) && (doc3.documentElement != null))
                return doc3.documentElement.outerHTML; //innerHTML;
            return string.Empty;
        }
        public string GetSource(IWebBrowser2 thisBrowser)
        {
            if ((thisBrowser == null) || (thisBrowser.Document == null))
                return string.Empty;

            //Declare vars
            int hr = Hresults.S_OK;
            IStream pStream = null;
            IPersistStreamInit pPersistStreamInit = null;

            // Query for IPersistStreamInit.
            pPersistStreamInit = thisBrowser.Document as IPersistStreamInit;
            if (pPersistStreamInit == null)
                return string.Empty;

            //Create stream, delete on release
            hr = WinApis.CreateStreamOnHGlobal(m_NullPointer, true, out pStream);
            if ((pStream == null) || (hr != Hresults.S_OK))
                return string.Empty;

            //Save
            hr = pPersistStreamInit.Save(pStream, false);
            if (hr != Hresults.S_OK)
                return string.Empty;

            //Now read from stream....

            //First get the size
            long ulSizeRequired = (long)0;
            //LARGE_INTEGER
            long liBeggining = (long)0;
            System.Runtime.InteropServices.ComTypes.STATSTG statstg = new System.Runtime.InteropServices.ComTypes.STATSTG();
            pStream.Seek(liBeggining, (int)tagSTREAM_SEEK.STREAM_SEEK_SET, m_NullPointer);
            pStream.Stat(out statstg, (int)tagSTATFLAG.STATFLAG_NONAME);

            //Size
            ulSizeRequired = statstg.cbSize;
            if (ulSizeRequired == (long)0)
                return string.Empty;

            //Allocate buffer + read
            byte[] pSource = new byte[ulSizeRequired];
            pStream.Read(pSource, (int)ulSizeRequired, m_NullPointer);

            //Added by schlaup to handle UTF8 and UNICODE pages
            //Convert
            //ASCIIEncoding asce = new ASCIIEncoding();
            //return asce.GetString(pSource);
            Encoding enc = null;

            if (pSource.Length > 8)
            {
                // Check byte order mark
                if ((pSource[0] == 0xFF) && (pSource[1] == 0xFE)) // UTF16LE
                    enc = Encoding.Unicode;

                if ((pSource[0] == 0xFE) && (pSource[1] == 0xFF)) // UTF16BE
                    enc = Encoding.BigEndianUnicode;

                if ((pSource[0] == 0xEF) && (pSource[1] == 0xBB) && (pSource[2] == 0xBF)) //UTF8
                    enc = Encoding.UTF8;

                if (enc == null)
                {
                    // Check for alternating zero bytes which might indicate Unicode
                    if ((pSource[1] == 0) && (pSource[3] == 0) && (pSource[5] == 0) && (pSource[7] == 0))
                        enc = Encoding.Unicode;
                }
            }

            if (enc == null)
                enc = Encoding.Default;

            int bomLength = enc.GetPreamble().Length;

            return enc.GetString(pSource, bomLength, pSource.Length - bomLength);
        }
        public IHTMLElementCollection GetImages(bool bTopLevel)
        {
            if (this.m_WBWebBrowser2 == null)
                return null;
            IHTMLDocument2 doc2 = null;
            if (bTopLevel)
                doc2 = this.m_WBWebBrowser2.Document as IHTMLDocument2;
            else
                doc2 = this.GetActiveDocument() as IHTMLDocument2;
            if (doc2 == null)
                return null;
            return doc2.images as IHTMLElementCollection;
        }
        public IHTMLElementCollection GetAnchors(bool bTopLevel)
        {
            if (this.m_WBWebBrowser2 == null)
                return null;
            IHTMLDocument2 doc2 = null;
            if (bTopLevel)
                doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            else
                doc2 = this.GetActiveDocument() as IHTMLDocument2;
            if (doc2 == null)
                return null;
            return doc2.anchors as IHTMLElementCollection;
        }
        public string GetSelectedText(bool bTopLevel, bool ReturnAsHTML)
        {
            if (this.m_WBWebBrowser2 == null)
                return string.Empty;

            IHTMLDocument2 doc2 = null;
            IHTMLSelectionObject selobj = null;
            IHTMLTxtRange range = null;

            if (bTopLevel)
                doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            else
                doc2 = this.GetActiveDocument();
            if( (doc2 == null) || (doc2.selection == null) )
                return string.Empty;

            selobj = doc2.selection as IHTMLSelectionObject;
            if (selobj == null)
                return string.Empty;

            if( (selobj.EventType == "none") || (selobj.EventType == "control") )
                return string.Empty;

            range = selobj.createRange() as IHTMLTxtRange;
            if (range == null)
                return string.Empty;

            if (ReturnAsHTML)
                return range.htmlText;
            else
                return range.text;

        }
        public IHTMLElement ElementFromPoint(bool bTopLevel, int X, int Y)
        {
            if (this.m_WBWebBrowser2 == null)
                return null;

            IHTMLDocument2 doc2 = null;
            if (bTopLevel)
                doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            else
                doc2 = this.GetActiveDocument();
            if (doc2 != null)
                return doc2.elementFromPoint(X, Y);
            else
                return null;
        }
        //execCommand(true, "insertimage", false, null)
        public bool ExecCommand(bool bTopLevel, string CmdId, bool showUI, object CmdValue)
        {
            if (this.m_WBWebBrowser2 == null)
                return false;

            IHTMLDocument2 doc2 = null;
            if (bTopLevel)
                doc2 = this.m_WBWebBrowser2.Document as IHTMLDocument2;
            else
                doc2 = this.GetActiveDocument();
            if (doc2 != null)
                return doc2.execCommand(CmdId, showUI, CmdValue);
            else
                return false;
        }
        //OleCommandExec(true, MSHTML_COMMAND_IDS.IDM_HTMLEDITMODE, true);
        //OleCommandExec(true, MSHTML_COMMAND_IDS.IDM_COMPOSESETTINGS, "0,0,0,2,0.0.0,255.255.255,Arial");
        public bool OleCommandExec(bool bTopLevel, MSHTML_COMMAND_IDS CmdID, object pvaIn)
        {
            if (this.m_WBWebBrowser2 == null)
                return false;
            IOleCommandTarget m_Doc2OleCommandTraget = null;
            IntPtr m_Guid_MSHTML = m_NullPointer;
            bool bret = false;
            IntPtr pIn = IntPtr.Zero;
            try
            {
                byte[] guidbytes = Iid_Clsids.Guid_MSHTML.ToByteArray();
                m_Guid_MSHTML = Marshal.AllocCoTaskMem((int)(guidbytes.Length * 2));
                Marshal.Copy(guidbytes, 0, m_Guid_MSHTML, guidbytes.Length);

                IHTMLDocument2 doc2 = null;
                if (bTopLevel)
                    doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
                else
                    doc2 = this.GetActiveDocument();
                if (doc2 == null)
                    return false;
                m_Doc2OleCommandTraget = doc2 as IOleCommandTarget;
                if (m_Doc2OleCommandTraget == null)
                    return false;
                    
                pIn = Marshal.AllocCoTaskMem((int)1024);
                Marshal.GetNativeVariantForObject(pvaIn, pIn);

                bret = (m_Doc2OleCommandTraget.Exec(m_Guid_MSHTML, (uint)CmdID,
                    (uint)OLECMDEXECOPT.OLECMDEXECOPT_DODEFAULT,
                    pIn, m_NullPointer) == Hresults.S_OK) ? true : false;

                Marshal.FreeCoTaskMem(m_Guid_MSHTML);
                m_Guid_MSHTML = m_NullPointer;
                Marshal.FreeCoTaskMem(pIn);
                pIn = IntPtr.Zero;
            }
            finally
            {
                if (m_Guid_MSHTML != m_NullPointer)
                    Marshal.FreeCoTaskMem(m_Guid_MSHTML);
                if(pIn != IntPtr.Zero)
                    Marshal.FreeCoTaskMem(pIn);
            }
            return bret;
        }
        public bool OleCommandExec(bool bTopLevel, MSHTML_COMMAND_IDS CmdID)
        {
            if (this.m_WBWebBrowser2 == null)
                return false;
            IOleCommandTarget m_Doc2OleCommandTraget = null;
            IntPtr m_Guid_MSHTML = m_NullPointer;
            bool bret = false;
            try
            {
                byte[] guidbytes = Iid_Clsids.Guid_MSHTML.ToByteArray();
                m_Guid_MSHTML = Marshal.AllocCoTaskMem((int)(guidbytes.Length * 2));
                Marshal.Copy(guidbytes, 0, m_Guid_MSHTML, guidbytes.Length);

                IHTMLDocument2 doc2 = null;
                if (bTopLevel)
                    doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
                else
                    doc2 = this.GetActiveDocument();
                if (doc2 == null)
                    return false;
                m_Doc2OleCommandTraget = doc2 as IOleCommandTarget;
                if (m_Doc2OleCommandTraget == null)
                    return false;

                bret = (m_Doc2OleCommandTraget.Exec(m_Guid_MSHTML, (uint)CmdID,
                    (uint)OLECMDEXECOPT.OLECMDEXECOPT_DODEFAULT,
                    m_NullPointer, m_NullPointer) == Hresults.S_OK) ? true : false;

                Marshal.FreeCoTaskMem(m_Guid_MSHTML);
                m_Guid_MSHTML = m_NullPointer;
            }
            finally
            {
                if (m_Guid_MSHTML != m_NullPointer)
                    Marshal.FreeCoTaskMem(m_Guid_MSHTML);
            }
            return bret;
        }
        public object QueryCommandValue(string CmdID)
        {
            if (this.m_WBWebBrowser2 == null)
                return null;

            IHTMLDocument2 doc2 = null;
            doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            if (doc2 != null)
                return doc2.queryCommandValue(CmdID);

            return null;
        }
        public bool QueryCommandState(bool bTopLevel, string CmdId)
        {
            if (this.m_WBWebBrowser2 == null)
                return false;

            IHTMLDocument2 doc2 = null;
            if (bTopLevel)
                doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            else
                doc2 = this.GetActiveDocument();
            if (doc2 != null)
                return doc2.queryCommandState(CmdId);
            else
                return false;
        }
        public IHTMLElement GetElementByID(bool bTopLevel, string idval)
        {
            if (this.m_WBWebBrowser2 == null)
                return null;
            IHTMLDocument3 doc3 = null;
            if (bTopLevel)
                doc3 = m_WBWebBrowser2.Document as IHTMLDocument3;
            else
                doc3 = GetActiveDocument() as IHTMLDocument3;
            if (doc3 != null)
                return doc3.getElementById(idval);
            else
                return null;
        }
        public IHTMLElementCollection GetElementsByName(bool bTopLevel, string elemname)
        {
            if (this.m_WBWebBrowser2 == null)
                return null;
            IHTMLDocument3 doc3 = null;
            if (bTopLevel)
                doc3 = m_WBWebBrowser2.Document as IHTMLDocument3;
            else
                doc3 = GetActiveDocument() as IHTMLDocument3;
            if (doc3 != null)
                return doc3.getElementsByName(elemname) as IHTMLElementCollection;
            else
                return null;
        }
        public IHTMLElementCollection GetElementsByTagName(bool bTopLevel, String tagname)
        {
            if (this.m_WBWebBrowser2 == null)
                return null;
            IHTMLDocument3 doc3 = null;
            if (bTopLevel)
                doc3 = m_WBWebBrowser2.Document as IHTMLDocument3;
            else
                doc3 = GetActiveDocument() as IHTMLDocument3;
            if (doc3 != null)
                return doc3.getElementsByTagName(tagname) as IHTMLElementCollection;
            else
                return null;
        }
        //m_CurWB.execScript(true, "javascript:__doPostBack('NY,412800013,09/15/2007,10010,18,C,165,0','false')", "JavaScript");
        public object execScript(bool bTopLevel, string ScriptName, string ScriptLanguage)
        {
            if ((this.m_WBWebBrowser2 == null) || (ScriptName.Length == 0))
                return null;

            IHTMLDocument2 doc2 = null;
            IHTMLWindow2 win2 = null;

            if (bTopLevel)
                doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            else
                doc2 = this.GetActiveDocument();
            if (doc2 == null)
                return null;

            win2 = doc2.parentWindow as IHTMLWindow2;
            if (win2 == null) //change from !=
                return null;

            //MSDN, JScript is MSHTML default
            if (ScriptLanguage.Length == 0)
                ScriptLanguage = "JavaScript";
            return win2.execScript(ScriptName, ScriptLanguage);
        }
        /// <summary>
        /// Invokes a script within the HTML page
        /// </summary>
        /// <param name="ScriptName"></param>
        /// <param name="Data"></param>
        /// <returns></returns>
        public object InvokeScript(string ScriptName, object[] Data)
        {
            object oRet = null;

            if (m_WBWebBrowser2 == null)
                return oRet;

            IHTMLDocument doc = m_WBWebBrowser2.Document as IHTMLDocument;
            if (doc == null)
                return oRet;
            object oScript = doc.Script;
            if (oScript == null)
                return oRet;
            //Invoke script
            if (Data == null)
                Data = new object[] { };
            //http://msdn2.microsoft.com/en-us/library/system.reflection.bindingflags.aspx
            oRet = oScript.GetType().InvokeMember(ScriptName,
                System.Reflection.BindingFlags.InvokeMethod, null, oScript, Data);
            return oRet;
        }
        public object InvokeScript(IWebBrowser2 wb, string ScriptName, object[] Data)
        {
            object oRet = null;

            if (wb == null)
                return oRet;

            IHTMLDocument doc = wb.Document as IHTMLDocument;
            if (doc == null)
                return oRet;
            object oScript = doc.Script;
            if (oScript == null)
                return oRet;
            //Invoke script
            if (Data == null)
                Data = new object[] { };
            //http://msdn2.microsoft.com/en-us/library/system.reflection.bindingflags.aspx
            oRet = oScript.GetType().InvokeMember(ScriptName,
                System.Reflection.BindingFlags.InvokeMethod, null, oScript, Data);
            return oRet;
        }

        //Frames related
        public bool IsFrameset()
        {
            return IsWBFrameset(this.m_WBWebBrowser2);
        }
        public int FramesCount()
        {
            return WBFramesCount(this.m_WBWebBrowser2);
        }
        public List<IWebBrowser2> GetFrames()
        {
            return GetFrames(this.m_WBWebBrowser2);
        }
        private List<IWebBrowser2> GetFrames(IWebBrowser2 pWB)
        {
            List<IWebBrowser2> wbFrames = new List<IWebBrowser2>();

            IOleContainer oc = pWB.Document as IOleContainer;
            if (oc == null)
                return null;

            //get the OLE enumerator for the embedded objects
            int hr = 0;
            IEnumUnknown eu;

            hr = oc.EnumObjects(tagOLECONTF.OLECONTF_EMBEDDINGS, out eu); //EU ALLOC
            Marshal.ReleaseComObject(oc);                                 //OC FREE
            Marshal.ThrowExceptionForHR(hr);

            object pUnk = null;
            int fetched = 0;
            const int MAX_FETCH_COUNT = 1;

            //get the first ebmedded object
            hr = eu.Next(MAX_FETCH_COUNT, out pUnk, out fetched);         //PUNK ALLOC
            Marshal.ThrowExceptionForHR(hr);
            //while sucessfully get a new embedding, continue
            for (int i = 0; Hresults.S_OK == hr; i++)
            {
                //QI pUnk for the IWebBrowser2 interface
                IWebBrowser2 brow = pUnk as IWebBrowser2;
                if (brow != null)
                {
                    if (IsWBFrameset(brow))
                    {
                        List<IWebBrowser2> frames = GetFrames(brow);
                        if ((frames != null) && (frames.Count > 0))
                        {
                            wbFrames.AddRange(frames);
                            frames.Clear();
                        }
                    }
                    else
                    {
                        wbFrames.Add(brow);
                        //Marshal.ReleaseComObject(brow);                         //PUNK FREE
                    }
                } //if(brow != null)

                //get the next ebmedded object
                hr = eu.Next(MAX_FETCH_COUNT, out pUnk, out fetched);       //PUNK ALLOC
                Marshal.ThrowExceptionForHR(hr);

            } //for(int i = 0; HRESULTS.S_OK == hr; i++)
            Marshal.ReleaseComObject(eu);                                 //EU FREE

            return wbFrames;
        }
        private bool IsWBFrameset(IWebBrowser2 pWB)
        {
            bool bRet = true;

            IHTMLDocument2 doc2 = pWB.Document as IHTMLDocument2;
            if (doc2 == null)
                return bRet;

            IHTMLElement elem = doc2.body;
            if (elem != null)
            {
                //QI for IHtmlBodyElement
                IntPtr pbody = Marshal.GetIUnknownForObject(elem);
                IntPtr pbodyelem = IntPtr.Zero;
                if (pbody != IntPtr.Zero)
                {
                    int iRet = Marshal.QueryInterface(pbody, 
                        ref Iid_Clsids.IID_IHTMLBodyElement, out pbodyelem);
                    Marshal.Release(pbody);
                    if( pbodyelem != IntPtr.Zero )
                    {
                        bRet = false;
                        Marshal.Release(pbodyelem);
                    }
                }
                //IHTMLBodyElement bodyelem = (IHTMLBodyElement)elem;
                //MSDN, If no body present then this is a frameset
                //if (bodyelem != null)
                //    bRet = false;
            }

            return bRet;
        }
        private bool IsWBFrameset(IHTMLDocument2 doc2)
        {
            bool bRet = true;
            if (doc2 == null)
                return bRet;

            IHTMLElement elem = doc2.body;
            if (elem != null)
            {
                //QI for IHtmlBodyElement
                IntPtr pbody = Marshal.GetIUnknownForObject(elem);
                IntPtr pbodyelem = IntPtr.Zero;
                if (pbody != IntPtr.Zero)
                {
                    int iRet = Marshal.QueryInterface(pbody,
                        ref Iid_Clsids.IID_IHTMLBodyElement, out pbodyelem);
                    Marshal.Release(pbody);
                    if (pbodyelem != IntPtr.Zero)
                    {
                        bRet = false;
                        Marshal.Release(pbodyelem);
                    }
                }
            }

            return bRet;
        }
        private int WBFramesCount(IWebBrowser2 pWB)
        {
            int lRet = 0;

            IOleContainer oc = pWB.Document as IOleContainer;
            if (oc == null)
                return lRet;

            //get the OLE enumerator for the embedded objects
            int hr = 0;
            IEnumUnknown eu;

            hr = oc.EnumObjects(tagOLECONTF.OLECONTF_EMBEDDINGS, out eu); //EU ALLOC
            Marshal.ReleaseComObject(oc);                                 //OC FREE
            Marshal.ThrowExceptionForHR(hr);

            object pUnk = null;
            int fetched = 0;
            const int MAX_FETCH_COUNT = 1;

            //get the first ebmedded object
            hr = eu.Next(MAX_FETCH_COUNT, out pUnk, out fetched);         //PUNK ALLOC
            Marshal.ThrowExceptionForHR(hr);
            //while sucessfully get a new embedding, continue
            for (int i = 0; Hresults.S_OK == hr; i++)
            {
                //QI pUnk for the IWebBrowser2 interface
                IWebBrowser2 brow = pUnk as IWebBrowser2;
                if (brow != null)
                {
                    if (IsWBFrameset(brow))
                        lRet += WBFramesCount(brow);
                    else
                    {
                        lRet++;
                        Marshal.ReleaseComObject(brow);                         //PUNK FREE
                    }
                } //if(brow != null)

                //get the next ebmedded object
                hr = eu.Next(MAX_FETCH_COUNT, out pUnk, out fetched);       //PUNK ALLOC
                Marshal.ThrowExceptionForHR(hr);

            } //for(int i = 0; HRESULTS.S_OK == hr; i++)
            Marshal.ReleaseComObject(eu);                                 //EU FREE

            return lRet;
        }

        //Internet shortcuts
        public bool CreateInternetShortCut(string LocalFileName, string URL, string Description, string IconFileName, int IconIndex)
        {
            bool bRet = false;
            Type iURL = Type.GetTypeFromCLSID(Iid_Clsids.CLSID_InternetShortcut);
//#if UNICODE
            IUniformResourceLocatorW pURL = System.Activator.CreateInstance(iURL) as IUniformResourceLocatorW;
//#else
//            IUniformResourceLocatorA pURL = (IUniformResourceLocatorA)System.Activator.CreateInstance(iURL);
//#endif
            if (pURL == null)
                return bRet;

            IPersistFile pPF = pURL as IPersistFile;
            if (pPF == null)
                return bRet;
//#if UNICODE
            IShellLinkW pSL = pURL as IShellLinkW;
//#else
//            IShellLinkA pSL = (IShellLinkA)pURL;
//#endif
            if (pSL == null)
                return bRet;

            int hr = pURL.SetURL(URL, (uint)0);
            if (hr != Hresults.S_OK)
                return bRet;

            if (Description.Length > 0)
                pSL.SetDescription(Description);
            if (IconFileName.Length > 0)
                pSL.SetIconLocation(IconFileName, IconIndex);

            //Save
            pPF.Save(LocalFileName, true);

            return bRet;
        }
        public string ResolveInternetShortCut(string InternetShortCutPath)
        {
            string URL = string.Empty;
            Type iURL = Type.GetTypeFromCLSID(Iid_Clsids.CLSID_InternetShortcut);
//#if UNICODE
            IUniformResourceLocatorW pURL = System.Activator.CreateInstance(iURL) as IUniformResourceLocatorW;
//#else
//            IUniformResourceLocatorA pURL = (IUniformResourceLocatorA)System.Activator.CreateInstance(iURL);
//#endif
            if (pURL == null)
                return URL;

            IPersistFile pPF = pURL as IPersistFile;
            if (pPF == null)
                return URL;

            pPF.Load(InternetShortCutPath, (int)WinApis.STGM_READ);

            IntPtr str = IntPtr.Zero;
            int hr = pURL.GetURL(out str);
            
            if (str == m_NullPointer)
                return URL;

            //IntPtr hIcon, hInst;
            //Icon ico, clone;
            //StringBuilder sb = new StringBuilder(MAX_PATH);
            //int nIconIdx;
////#if UNICODE
//            IShellLinkW pSL = (IShellLinkW)pURL;
////#else
////            IShellLinkA pSL = (IShellLinkA)pURL;
////#endif
            //pSL.GetIconLocation(sb, sb.Capacity, out nIconIdx);
            ////Icon Path: sb.ToString();
            ////Icon index: nIconIdx
            //hInst = Marshal.GetHINSTANCE(this.GetType().Module);
            //hIcon = WinApis.ExtractIcon(hInst, sb.ToString(), nIconIdx);
            //if (hIcon == IntPtr.Zero)
            //    return null;

            //// Return a cloned Icon, because we have to free the original ourselves.
            //ico = Icon.FromHandle(hIcon);
            //clone = (Icon)ico.Clone();
            //ico.Dispose();
            //WinApis.DestroyIcon(hIcon);
            ////clone: Url icon

//#if UNICODE
            URL = Marshal.PtrToStringUni(str);
//#else
//            URL = Marshal.PtrToStringAnsi(str);
//#endif
            Marshal.FreeCoTaskMem(str);

            return URL;
        }

        public bool ClearHistory()
        {
            int hr = Hresults.S_OK;
            Type urlhistorystg2type = Type.GetTypeFromCLSID(Iid_Clsids.CLSID_CUrlHistory, true);
            IUrlHistoryStg2 urlhistorystg2 = System.Activator.CreateInstance(urlhistorystg2type) as IUrlHistoryStg2;
            if (urlhistorystg2 == null)
                return false;
            hr = urlhistorystg2.ClearHistory();
            return (hr == Hresults.S_OK) ? true : false;
        }

        /// <summary>
        /// Call this only once, as other calls are ignored by library.
        /// Allow or disallow HTML dialogs launched using showModelessDialog() 
        /// and showModalDialog() methods using CBT Window Hook.
        /// Default, allow = true
        /// </summary>
        /// <param name="bAllow"></param>
        public void SetAllowHTMLDialogs(bool bAllow)
        {
            if (this.DesignMode)
                return;
            if (bAllow)
            {
                if (m_CBT.IsHooked) //Unhook
                {
                    m_CBT.IsHooked = false;
                    m_csexwbCOMLib.SetupWindowsHook(
                        CSEXWBDLMANLib.WINDOWSHOOK_TYPES.WHT_CBT,
                        (int)this.Handle.ToInt32(),
                        m_CBT.IsHooked,
                        ref m_CBT.UniqueMsgID);
                }
            }
            else
            {
                if (!m_CBT.IsHooked) //Hook
                {
                    m_CBT.IsHooked = true;
                    m_csexwbCOMLib.SetupWindowsHook(
                        CSEXWBDLMANLib.WINDOWSHOOK_TYPES.WHT_CBT,
                        (int)this.Handle.ToInt32(),
                        m_CBT.IsHooked,
                        ref m_CBT.UniqueMsgID);
                }
            }
        }
        public bool GetAllowHTMLDialogs()
        {
            return (m_CBT.IsHooked) ? false : true;
        }

        /// <summary>
        /// Attempts to convert UNICODE chars to their numeric values
        /// to be used with LoadHtmlIntoBrowser methods. sample
        /// "&#1581;&#1602;&#1608;&#1602; &#1575;&#1604;&#1591;&#1576;&#1593;"
        /// </summary>
        /// <param name="html"></param>
        /// <returns></returns>
        public string UnicodeToHTMLEncoding(string html)
        {
            StringBuilder sb = new StringBuilder(html.Length * 7);
            int i = 0;
            const string pre = "&#";
            const string post = ";";
            foreach (char c in html)
            {
                i = (int)c;
                if (i > 127) //Unicode
                {
                    sb.Append(pre);
                    sb.Append(i.ToString()); //Use numeric value 1581
                    sb.Append(post);
                }
                else
                    sb.Append(c);
            }
            if (sb.Length > 0)
                return sb.ToString();
            else
                return string.Empty;
        }

        /// <summary>
        /// Clears session cookies
        /// </summary>
        /// <returns></returns>
        public bool ClearSessionCookies()
        {
            return WinApis.InternetSetOption(IntPtr.Zero, 
                InternetSetOptionFlags.INTERNET_OPTION_END_BROWSER_SESSION,
                IntPtr.Zero, 0);
        }

        /// <summary>
        /// Adds a given url to the Internet explorer trusted zone
        /// </summary>
        /// <param name="url">format: http://msdn.microsoft.com</param>
        /// <returns></returns>
        public int AddUrlToTrustedZone(string url)
        {
            //Create a new InternetSecurityManager
            Type ismtype = Type.GetTypeFromCLSID(Iid_Clsids.CLSID_InternetSecurityManager, true);
            //Using Activator inplace of CoCreateInstance, returns IUnknown
            IInternetSecurityManager ismhelper = System.Activator.CreateInstance(ismtype) as IInternetSecurityManager;
            if (ismhelper == null)
                return Hresults.S_FALSE;
            return ismhelper.SetZoneMapping(
                (int)(tagURLZONE.URLZONE_ESC_FLAG | tagURLZONE.URLZONE_TRUSTED), 
                url, (int)SZM_FLAGS.SZM_CREATE);
        }

        /// <summary>
        /// Attempts to retreive UserAgent from
        /// IHTMLWindow2.navigator object
        /// </summary>
        /// <returns></returns>
        public string UserAgnet()
        {
            if (this.m_WBWebBrowser2 == null)
                return string.Empty;

            IHTMLDocument2 doc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            IHTMLWindow2 win2 = null;
            IOmNavigator navigator = null;

            if (doc2 == null)
                return string.Empty;

            win2 = doc2.parentWindow as IHTMLWindow2;
            if (win2 == null)
                return string.Empty;

            navigator = win2.navigator;
            if (navigator == null)
                return string.Empty;
            return navigator.userAgent;
        }

        /// <summary>
        /// Attempts to set the optical zoom value. Example: 
        /// <code>
        /// m_CurWB.SetOpticalZoomValue(300);
        /// </code>
        /// </summary>
        /// <param name="zoomvalue">Must be in the range 10 - 1000 percent</param>
        /// <returns>One of Hresults.S_OK or S_FALSE</returns>
        public int SetOpticalZoomValue(int zoomvalue)
        {
            if ((zoomvalue < 10) || (zoomvalue > 1000) || (m_WBOleCommandTarget == null))
                return Hresults.S_FALSE;
            IntPtr pRet = m_NullPointer;
            int hr = Hresults.S_FALSE;

            try
            {
                pRet = Marshal.AllocCoTaskMem((int)1024);
                Marshal.GetNativeVariantForObject((int)zoomvalue, pRet);

                hr = m_WBOleCommandTarget.Exec(m_NullPointer,
                    (uint)OLECMDID.OLECMDID_OPTICAL_ZOOM,
                    (uint)OLECMDEXECOPT.OLECMDEXECOPT_DONTPROMPTUSER,
                    pRet, m_NullPointer);
                Marshal.FreeCoTaskMem(pRet);
                pRet = m_NullPointer;
            }
            catch (Exception)
            {
            }
            finally
            {
                if (pRet != m_NullPointer)
                    Marshal.FreeCoTaskMem(pRet);
            }
            return hr;
        }

        /// <summary>
        /// Attempts to retreive optical zoom range. Example: 
        /// <code>
        /// int[] range = m_CurWB.GetOpticalZoomRange();
        /// AllForms.m_frmLog.AppendToLog(
        /// "Min==>" + range[0].ToString() + 
        /// "\r\nMax==>" + range[1].ToString());
        /// </code>
        /// </summary>
        /// <returns>Return int array index 0 = Min and index 1 = Max</returns>
        public int[] GetOpticalZoomRange()
        {
            object retVal = new object(); //VT_NULL
            IntPtr pRet = m_NullPointer;
            int iZoom = (int)0;
            int[] range = { 0, 0 };

            if (m_WBOleCommandTarget == null)
                return range;

            try
            {
                pRet = Marshal.AllocCoTaskMem((int)1024);
                Marshal.GetNativeVariantForObject(retVal, pRet);

                //NULL to specify the standard group
                int hr = m_WBOleCommandTarget.Exec(m_NullPointer,
                    (uint)OLECMDID.OLECMDID_OPTICAL_GETZOOMRANGE,
                    (uint)OLECMDEXECOPT.OLECMDEXECOPT_DONTPROMPTUSER,
                    m_NullPointer, pRet);

                retVal = Marshal.GetObjectForNativeVariant(pRet);
                Marshal.FreeCoTaskMem(pRet);
                pRet = m_NullPointer;
                if (Type.GetTypeCode(retVal.GetType()) == TypeCode.Int32)
                    iZoom = int.Parse(retVal.ToString());
            }
            catch (Exception)
            {
            }
            finally
            {
                if (pRet != m_NullPointer)
                    Marshal.FreeCoTaskMem(pRet);
            }
            if (iZoom > 0)
            {
                range[0] = WinApis.LoWord(iZoom); //Min
                range[1] = WinApis.HiWord(iZoom); //Max
            }
            return range;
        }

        #endregion

#region Interfaces Implementation

        #region IOleClientSite Members

        int IOleClientSite.SaveObject()
        {
            return Hresults.E_NOTIMPL;
            //throw new Exception("The method or operation is not implemented.");
        }

        int IOleClientSite.GetMoniker(uint dwAssign, uint dwWhichMoniker, out IMoniker ppmk)
        {
            ppmk = null;
            return Hresults.E_NOTIMPL;
        }

        int IOleClientSite.GetContainer(out IOleContainer ppContainer)
        {
            ppContainer = null;
            return Hresults.E_NOTIMPL;
        }

        int IOleClientSite.ShowObject()
        {
            return Hresults.S_OK;
        }

        int IOleClientSite.OnShowWindow(bool fShow)
        {
            return Hresults.E_NOTIMPL;
        }

        int IOleClientSite.RequestNewObjectLayout()
        {
            return Hresults.E_NOTIMPL;
        }

        #endregion

        #region IOleInPlaceSite Members

        int IOleInPlaceSite.GetWindow(ref IntPtr phwnd)
        {
            phwnd = IntPtr.Zero;
            if (this.IsHandleCreated)
            {
                phwnd = this.Handle;
                return Hresults.S_OK;
            }
            else
                return Hresults.E_FAIL;
        }

        int IOleInPlaceSite.ContextSensitiveHelp(bool fEnterMode)
        {
            return Hresults.E_NOTIMPL;
        }

        int IOleInPlaceSite.CanInPlaceActivate()
        {
            return Hresults.S_OK;
        }

        int IOleInPlaceSite.OnInPlaceActivate()
        {
            return Hresults.S_OK;
        }

        int IOleInPlaceSite.OnUIActivate()
        {
            if (!this.DesignMode)
                m_ieServerWindow = new IEServerWindow(this);
            return Hresults.S_OK;
        }

        int IOleInPlaceSite.GetWindowContext(out IOleInPlaceFrame ppFrame, out IOleInPlaceUIWindow ppDoc, ref tagRECT lprcPosRect, ref tagRECT lprcClipRect, ref tagOIFI lpFrameInfo)
        {
            ppDoc = null;
            ppFrame = null;
            return Hresults.E_NOTIMPL;
        }

        int IOleInPlaceSite.Scroll(ref tagSIZE scrollExtent)
        {
            return Hresults.E_NOTIMPL;
        }

        int IOleInPlaceSite.OnUIDeactivate(bool fUndoable)
        {
            if( (!this.DesignMode) && (m_ieServerWindow != null) )
            {
                m_ieServerWindow.Release();
                m_ieServerWindow = null;
            }
            return Hresults.E_NOTIMPL;
        }

        int IOleInPlaceSite.OnInPlaceDeactivate()
        {
            return Hresults.E_NOTIMPL;
        }

        int IOleInPlaceSite.DiscardUndoState()
        {
            return Hresults.E_NOTIMPL;
        }

        int IOleInPlaceSite.DeactivateAndUndo()
        {
            return Hresults.E_NOTIMPL;
        }

        int IOleInPlaceSite.OnPosRectChange(ref tagRECT lprcPosRect)
        {
            return Hresults.E_NOTIMPL;
        }

        #endregion

        #region IDocHostShowUI Members
        //Can not catch VBScript MsgBox and InputBox functions and javascript prompt
        //This does catch alert and confirm (VBScript as well)
        int IDocHostShowUI.ShowMessage(IntPtr hwnd, string lpstrText, 
            string lpstrCaption, uint dwType, 
            string lpstrHelpFile, uint dwHelpContext, ref int lpResult)
        {
            //Initially
            //lpResult is set 0 //S_OK
            
            //Host did not display its UI. MSHTML displays its message box.
            int iRet = Hresults.S_FALSE;
            
            //raise event?
            if (WBDocHostShowUIShowMessage != null)
            {
                //Refer to http://msdn2.microsoft.com/en-us/library/ms645505.aspx
                //for possible values of dwType
                DocHostShowUIShowMessageEvent.SetParameters(hwnd, lpstrText, lpstrCaption, dwType, lpstrHelpFile, dwHelpContext, lpResult);
                WBDocHostShowUIShowMessage(this, DocHostShowUIShowMessageEvent);
                if (DocHostShowUIShowMessageEvent.handled)
                {
                    //Host displayed its user interface (UI). MSHTML does not display its message box.
                    iRet = Hresults.S_OK;
                    lpResult = DocHostShowUIShowMessageEvent.result;
                }
                DocHostShowUIShowMessageEvent.Reset();
            }
            ////uncomment to use
            //else
            //{
            //  lpResult = (int)WinApis.MessageBox(hwnd, lpstrText, lpstrCaption, dwType);
            //  iRet = Hresults.S_OK;
            //}
            return iRet;
        }

        int IDocHostShowUI.ShowHelp(IntPtr hwnd, string pszHelpFile, uint uCommand, uint dwData, tagPOINT ptMouse, object pDispatchObjectHit)
        {
            return Hresults.E_NOTIMPL;
        }

        #endregion

        #region IDocHostUIHandler Members

        int IDocHostUIHandler.ShowContextMenu(uint dwID, ref tagPOINT pt, object pcmdtReserved, object pdispReserved)
        {
            //    return Hresults.S_OK; //Do not display context menu
            //    return Hresults.S_FALSE; //Default IE ctxmnu

            Point outpt = new Point(pt.X, pt.Y);
            //Raise event
            if (WBContextMenu != null)
            {
                ContextMenuEvent.SetParameters((WB_CONTEXTMENU_TYPES)dwID, outpt, pdispReserved);
                WBContextMenu(this, ContextMenuEvent);
                if (ContextMenuEvent.displaydefault == false) //Handled or don't display
                    return Hresults.S_OK;
                ContextMenuEvent.dispctxmenuobj = null;
            }
            return Hresults.S_FALSE;
        }

        int IDocHostUIHandler.GetHostInfo(ref DOCHOSTUIINFO info)
        {
            //Default, selecttext+no3dborder+flatscrollbars+themes(xp look)
            //Size has be set
            info.cbSize = (uint)Marshal.SizeOf(info);
            info.dwDoubleClick = (uint)m_DocHostUiDbClkFlag;
            info.dwFlags = (uint)m_DocHostUiFlags;
            //info.pchHostCss = "BODY {background-color:#ffcccc}";
            return Hresults.S_OK;
        }

        int IDocHostUIHandler.ShowUI(int dwID, IOleInPlaceActiveObject activeObject, IOleCommandTarget commandTarget, IOleInPlaceFrame frame, IOleInPlaceUIWindow doc)
        {
            //activeObject.GetWindow should return Internet Explorer_Server hwnd
            if (activeObject != null)
                activeObject.GetWindow(ref m_hWBServerHandle);
            return Hresults.S_OK;
        }

        int IDocHostUIHandler.HideUI()
        {
            return Hresults.S_OK;
        }

        int IDocHostUIHandler.UpdateUI()
        {
            return Hresults.S_OK;
        }

        int IDocHostUIHandler.EnableModeless(bool fEnable)
        {
            return Hresults.E_NOTIMPL;
        }

        int IDocHostUIHandler.OnDocWindowActivate(bool fActivate)
        {
            return Hresults.E_NOTIMPL;
        }

        int IDocHostUIHandler.OnFrameWindowActivate(bool fActivate)
        {
            return Hresults.E_NOTIMPL;
        }

        int IDocHostUIHandler.ResizeBorder(ref tagRECT rect, IOleInPlaceUIWindow doc, bool fFrameWindow)
        {
            return Hresults.E_NOTIMPL;
        }

        int IDocHostUIHandler.TranslateAccelerator(ref tagMSG msg, ref Guid group, uint nCmdID)
        {
            //    return Hresults.S_OK; //Cancel
            //    return Hresults.S_FALSE; //IE default action
            Keys nVirtExtKey = Keys.None; // (int)0;
            if ((ModifierKeys & Keys.Control) != 0)
                nVirtExtKey = Keys.ControlKey; //CONTROL 17
            if ((ModifierKeys & Keys.ShiftKey) != 0)
                nVirtExtKey = Keys.ShiftKey; //SHIFT 16
            if ((ModifierKeys & Keys.Menu) != 0)
                nVirtExtKey = Keys.Menu; //ALT 18
            Keys keyCode = (Keys)msg.wParam;

            if ((msg.message == WindowsMessages.WM_KEYDOWN) && (WBKeyDown != null))
            {
                WBKeyDownEvent.SetParameters(keyCode, nVirtExtKey);
                WBKeyDown(this, WBKeyDownEvent);
                if (WBKeyDownEvent.handled)
                    return Hresults.S_OK;
            }
            if ((msg.message == WindowsMessages.WM_KEYUP) && (WBKeyUp != null))
            {
                WBKeyUpEvent.SetParameters(keyCode, nVirtExtKey);
                WBKeyUp(this, WBKeyUpEvent);
                if (WBKeyUpEvent.handled == true)
                    return Hresults.S_OK;
            }
            //IE default action
            return Hresults.S_FALSE;
        }

        int IDocHostUIHandler.GetOptionKeyPath(out string pbstrKey, uint dw)
        {
            //pbstrKey[0] = null;
            pbstrKey = null;
            if (WBGetOptionKeyPath != null)
            {
                GetOptionKeyPathEvent.SetParameters();
                WBGetOptionKeyPath(this, GetOptionKeyPathEvent);
                if (GetOptionKeyPathEvent.handled == true)
                {
                    pbstrKey = GetOptionKeyPathEvent.keypath;
                    GetOptionKeyPathEvent.SetParameters();
                    return Hresults.S_OK;
                }
            }
            return Hresults.E_NOTIMPL;
        }

        int IDocHostUIHandler.GetDropTarget(IfacesEnumsStructsClasses.IDropTarget pDropTarget, out IfacesEnumsStructsClasses.IDropTarget ppDropTarget)
        {
            int hret = Hresults.E_NOTIMPL;
            ppDropTarget = null;
            if (m_bUseInternalDragDrop)
            {
                ppDropTarget = this as IfacesEnumsStructsClasses.IDropTarget;
                if(ppDropTarget != null)
                    hret = Hresults.S_OK;
            }
            return hret;
        }

        int IDocHostUIHandler.GetExternal(out object ppDispatch)
        {
            if (m_WinExternal != null)
            {
                ppDispatch = m_WinExternal;
                return Hresults.S_OK;
            }
            else
            {
                ppDispatch = null;
                return Hresults.E_NOTIMPL;
            }
        }

        int IDocHostUIHandler.TranslateUrl(uint dwTranslate, string strURLIn, out string pstrURLOut)
        {
            pstrURLOut = null;
            return Hresults.E_NOTIMPL;
        }

        int IDocHostUIHandler.FilterDataObject(System.Runtime.InteropServices.ComTypes.IDataObject pDO, out System.Runtime.InteropServices.ComTypes.IDataObject ppDORet)
        {
            ppDORet = null;
            return Hresults.E_NOTIMPL;
        }

        #endregion

        #region DWebBrowserEvents2 Members

        [System.Runtime.InteropServices.DispId(250)]
        void DWebBrowserEvents2.BeforeNavigate2(object pDisp, ref object URL, ref object Flags, ref object TargetFrameName, ref object PostData, ref object Headers, ref bool Cancel)
        {
            //For catching Refresh and coordinating events
            m_nPageCounter++;
            bool bTopFrame = m_WBWebBrowser2.Equals(pDisp);

            if(bTopFrame)
                m_DocDone = false;

            //Want events
            if( m_WantHTMLEvents )
            {
                //Top level
                if (bTopFrame)
                {
                    if (m_WantHtmlDocumentEvents)
                        m_TopLevelHtmlDocumentevents.DisconnectHtmlEvents();
                    if (m_WantHtmlWindowEvents)
                        m_TopLevelHtmlWindowEvents.DisconnectHtmlEvents();
                }
                else //Secondary pages (frameset)
                {
                    //Want events and we don't bother with navigation within framesets
                    if ((m_WantHtmlDocumentEvents) && (m_nPageCounter > 1) )
                        DisconnectHtmlDocumentEvents();

                    if( (m_WantHtmlWindowEvents) && (m_nPageCounter > 1) )
                        DisconnectHtmlWindowEvnets();
                }
            }

            if (BeforeNavigate2 != null)
            {
                //Reserved, must be set to null
                Flags = null;
                BeforeNavigate2Event.SetParameters(pDisp, URL.ToString(), TargetFrameName, PostData, Headers, bTopFrame);
                BeforeNavigate2(this, BeforeNavigate2Event);
                Cancel = BeforeNavigate2Event.Cancel;
                BeforeNavigate2Event.Reset();
            }
        }

        [DispId(268)]
        void DWebBrowserEvents2.ClientToHostWindow(ref int CX, ref int CY)
        {
            if (ClientToHostWindow != null)
            {
                ClientToHostWindowEvent.SetParameters(CX, CY);
                ClientToHostWindow(this, ClientToHostWindowEvent);
                if (ClientToHostWindowEvent.handled == true)
                {
                    CX = ClientToHostWindowEvent.cx;
                    CY = ClientToHostWindowEvent.cy;
                }
            }
        }

        [DispId(105)]
        void DWebBrowserEvents2.CommandStateChange(int Command, bool Enable)
        {
            if (Command == (int)CommandStateChangeConstants.CSC_NAVIGATEBACK)
                m_bCanGoBack = Enable;
            else if (Command == (int)CommandStateChangeConstants.CSC_NAVIGATEFORWARD)
                m_bCanGoForward = Enable;

            if (CommandStateChange != null)
            {
                CommandStateChangeEvent.SetParameters(Command, Enable);
                CommandStateChange(this, CommandStateChangeEvent);
            }
        }

        [DispId(104)]
        void DWebBrowserEvents2.DocumentComplete(object pDisp, ref object URL)
        {
            m_nPageCounter--;

            bool bTopFrame = m_WBWebBrowser2.Equals(pDisp);
            if(bTopFrame)
                m_DocDone = true;

            if (m_WantHTMLEvents)
            {
                IHTMLDocument2 doc2 = null;
                if (bTopFrame)
                {
                    doc2 = (IHTMLDocument2)m_WBWebBrowser2.Document;
                    if(m_WantHtmlDocumentEvents)
                        m_TopLevelHtmlDocumentevents.ConnectToHtmlEvents(doc2);
                    if (m_WantHtmlWindowEvents)
                    {
                        IHTMLWindow2 win2 = (IHTMLWindow2)doc2.parentWindow;
                        m_TopLevelHtmlWindowEvents.ConnectToHtmlEvents(win2);
                    }
                }
                else
                {
                    //Nav within frameset, don't bother
                    //Uses the same document object
                    if (m_nPageCounter > 0)
                    {
                        IWebBrowser2 wb2 = (IWebBrowser2)pDisp;
                        doc2 = (IHTMLDocument2)wb2.Document;
                        if (m_WantHtmlDocumentEvents)
                        {
                            cHTMLDocumentEvents doceve = null;
                            ActivateSecondaryHtmlDocumentEvents(ref doceve);
                            if (doceve != null)
                                doceve.ConnectToHtmlEvents(doc2);
                        }
                        if (m_WantHtmlWindowEvents)
                        {
                            cHTMLWindowEvents wineve = null;
                            IHTMLWindow2 win2 = (IHTMLWindow2)doc2.parentWindow;
                            ActivateSecondaryHtmlWindowEvents(ref wineve);
                            if (wineve != null)
                                wineve.ConnectToHtmlEvents(win2);
                        }
                    }
                }
            }

            if (m_bSendSourceOnDocumentCompleteWBEx) //want source?
            {
                if (DocumentCompleteEX != null)
                {
                    //Declare vars
                    string strSource = "";
                    IWebBrowser2 thisBrowser = null;

                    //Reset event object parameters
                    DocumentCompleteExEvent.SetParameters(pDisp, URL.ToString(), bTopFrame, strSource);

                    //Attempt to get a IWebBrowser2 iface from disp
                    //throws an exception if not an html doc
                    thisBrowser = (IWebBrowser2)pDisp;
                    if (thisBrowser == null)
                        return;

                    strSource = GetSource(thisBrowser);
                    DocumentCompleteExEvent.docsource = strSource;
                    DocumentCompleteEX(this, DocumentCompleteExEvent);
                    DocumentCompleteExEvent.Reset();
                }
            }
            else if (DocumentComplete != null) //Do not want source
            {
                DocumentCompleteEvent.SetParameters(pDisp, URL.ToString(), bTopFrame);
                DocumentComplete(this, DocumentCompleteEvent);
                DocumentCompleteEvent.Reset();
            }
            //Go to MSDN library(archive) + stop + refresh
            //without this, refresh end hits somewhere in between documentCompletes
            if ((m_bIsRefresh) && (m_nPageCounter == 0) && (m_nObjCounter == 0))
            {
                m_bIsRefresh = false;
                if (RefreshEnd != null)
                    RefreshEnd(this);
            }
        }

        [DispId(106)]
        void DWebBrowserEvents2.DownloadBegin()
        {
            m_nObjCounter++;
            if (DownloadBegin != null)
                DownloadBegin(this);
            if (m_nPageCounter == 0)
            {
                m_bIsRefresh = true;
                if (RefreshBegin != null)
                    RefreshBegin(this);
            }
        }

        [DispId(259)]
        void DWebBrowserEvents2.DownloadComplete()
        {
            m_nObjCounter--;
            if (DownloadComplete != null)
                DownloadComplete(this);
            if ((m_bIsRefresh) && (m_nPageCounter == 0) && (m_nObjCounter == 0))
            {
                m_bIsRefresh = false;
                if (RefreshEnd != null)
                    RefreshEnd(this);
            }
        }

        [DispId(270)]
        void DWebBrowserEvents2.FileDownload(bool ActiveDocument, ref bool Cancel)
        {
            if ((FileDownload != null) && (m_UseInternalDownloadManager == false))
            {
                FileDownloadEvent.Cancel = false;
                FileDownloadEvent.ActiveDocument = ActiveDocument;
                FileDownload(this, FileDownloadEvent);
                Cancel = FileDownloadEvent.Cancel;
            }
        }

        [DispId(252)]
        void DWebBrowserEvents2.NavigateComplete2(object pDisp, ref object URL)
        {
            if (NavigateComplete2 != null)
            {
                NavigateComplete2Event.SetParameters(pDisp, URL.ToString());
                NavigateComplete2(this, NavigateComplete2Event);
                NavigateComplete2Event.Reset();
            }
        }

        [DispId(271)]
        void DWebBrowserEvents2.NavigateError(object pDisp, ref object URL, ref object Frame, ref object StatusCode, ref bool Cancel)
        {
            if (NavigateError != null)
            {
                if (Frame != null) //Thank you Arjan
                    NavigateErrorEvent.SetParameters(pDisp, URL.ToString(), Frame.ToString(), (int)StatusCode);
                else
                    NavigateErrorEvent.SetParameters(pDisp, URL.ToString(), string.Empty, (int)StatusCode);
                NavigateError(this,NavigateErrorEvent);
                Cancel = NavigateErrorEvent.Cancel;
                NavigateErrorEvent.Reset();
            }
        }

        [DispId(251)]
        void DWebBrowserEvents2.NewWindow2(ref object ppDisp, ref bool Cancel)
        {
            if (NewWindow2 != null)
            {
                NewWindow2Event.SetParameters();
                NewWindow2(this, NewWindow2Event);
                Cancel = NewWindow2Event.Cancel;
                if ((!Cancel) && (NewWindow2Event.browser != null))
                {
                    ppDisp = NewWindow2Event.browser;
                }
                NewWindow2Event.SetParameters();
            }
        }
        
        [DispId(0x111)]
        void DWebBrowserEvents2.NewWindow3(ref object ppDisp, ref bool Cancel, uint dwFlags, string bstrUrlContext, string bstrUrl)
        {
            
            if (NewWindow3 != null)
            {
                NewWindow3Event.SetParameters(bstrUrlContext, bstrUrl,(NWMF)dwFlags);
                NewWindow3(this, NewWindow3Event);
                Cancel = NewWindow3Event.Cancel;
                if ((!Cancel) && (NewWindow3Event.browser != null))
                {
                    ppDisp = NewWindow3Event.browser;
                }
                NewWindow3Event.Reset();
            }
        }

        #region Unused Events
        void DWebBrowserEvents2.OnFullScreen(bool FullScreen)
        {
            //
        }

        void DWebBrowserEvents2.OnMenuBar(bool MenuBar)
        {
            //
        }

        void DWebBrowserEvents2.OnQuit()
        {
            //
        }

        void DWebBrowserEvents2.OnStatusBar(bool StatusBar)
        {
            //
        }

        void DWebBrowserEvents2.OnTheaterMode(bool TheaterMode)
        {
            //
        }

        void DWebBrowserEvents2.OnToolBar(bool ToolBar)
        {
            //
        }

        void DWebBrowserEvents2.OnVisible(bool Visible)
        {
            //
        }
        #endregion
        
        [DispId(227)]
        void DWebBrowserEvents2.UpdatePageStatus(object pDisp, ref object nPage, ref object fDone)
        {
            if (UpdatePageStatus != null)
            {
                if(nPage != null)
                    UpdatePageStatusEvent.SetParameters(pDisp, (int)nPage, (bool)fDone);
                else
                    UpdatePageStatusEvent.SetParameters(pDisp, 0, (bool)fDone);
                UpdatePageStatus(this, UpdatePageStatusEvent);
                UpdatePageStatusEvent.Reset();
            }
        }

        [DispId(225)]
        void DWebBrowserEvents2.PrintTemplateInstantiation(object pDisp)
        {
            if (PrintTemplateInstantiation != null)
            {
                PrintTemplateInstantiationEvent.browser = pDisp;
                PrintTemplateInstantiation(this, PrintTemplateInstantiationEvent);
                PrintTemplateInstantiationEvent.browser = null;
            }
        }

        [DispId(226)]
        void DWebBrowserEvents2.PrintTemplateTeardown(object pDisp)
        {
            if (PrintTemplateTeardown != null)
            {
                PrintTemplateTeardownEvent.browser = pDisp;
                PrintTemplateTeardown(this, PrintTemplateTeardownEvent);
                PrintTemplateTeardownEvent.browser = null;
            }
        }

        [DispId(272)]
        void DWebBrowserEvents2.PrivacyImpactedStateChange(bool bImpacted)
        {
            if (PrivacyImpactedStateChange != null)
            {
                PrivacyImpactedStateChangeEvent.impacted = bImpacted;
                PrivacyImpactedStateChange(this, PrivacyImpactedStateChangeEvent);
            }
        }

        [DispId(108)]
        void DWebBrowserEvents2.ProgressChange(int Progress, int ProgressMax)
        {
            if (ProgressChange != null)
            {
                ProgressChangeEvent.SetParameters(Progress, ProgressMax);
                ProgressChange(this, ProgressChangeEvent);
            }
        }

        [DispId(112)]
        void DWebBrowserEvents2.PropertyChange(string szProperty)
        {
            if (PropertyChange != null)
            {
                PropertyChangeEvent.szproperty = szProperty;
                PropertyChange(this, PropertyChangeEvent);
                PropertyChangeEvent.szproperty = string.Empty;
            }
        }

        [DispId(269)]
        void DWebBrowserEvents2.SetSecureLockIcon(int SecureLockIcon)
        {
            m_SecureLockIcon = SecureLockIcon;
            if (SetSecureLockIcon != null)
            {
                SetSecureLockIconEvent.SetParameters(SecureLockIcon);
                SetSecureLockIcon(this, SetSecureLockIconEvent);
            }
        }

        [DispId(102)]
        void DWebBrowserEvents2.StatusTextChange(string Text)
        {
            if (StatusTextChange != null)
            {
                StatusTextChangeEvent.text = Text;
                StatusTextChange(this, StatusTextChangeEvent);
                StatusTextChangeEvent.text = string.Empty;
            }
        }

        [DispId(113)]
        void DWebBrowserEvents2.TitleChange(string Text)
        {
            if (TitleChange != null)
            {
                TitleChangeEvent.title = Text;
                TitleChange(this, TitleChangeEvent);
                TitleChangeEvent.title = "";
            }
        }

        //DWebBrowserEvents2.WindowClosing is never called?
        //So here is the workaround
        [DispId(263)]
        public void DISPATCH_WindowClosing(bool IsChildWindow, ref bool Cancel)
        {
            if (WindowClosing != null)
            {
                WindowClosingEvent.SetParameters(IsChildWindow);
                WindowClosing(this, WindowClosingEvent);
                Cancel = WindowClosingEvent.Cancel;
            }
        }

        [DispId(263)]
        void DWebBrowserEvents2.WindowClosing(bool IsChildWindow, ref bool Cancel)
        {
        }

        [DispId(267)]
        void DWebBrowserEvents2.WindowSetHeight(int Height)
        {
            if (WindowSetHeight != null)
            {
                WindowSetHeightEvent.height = Height;
                WindowSetHeight(this, WindowSetHeightEvent);
            }
        }

        [DispId(264)]
        void DWebBrowserEvents2.WindowSetLeft(int Left)
        {
            if (WindowSetLeft != null)
            {
                WindowSetLeftEvent.left = Left;
                WindowSetLeft(this, WindowSetLeftEvent);
            }
        }

        [DispId(262)]
        void DWebBrowserEvents2.WindowSetResizable(bool Resizable)
        {
            if (WindowSetResizable != null)
            {
                WindowSetResizableEvent.resizable = Resizable;
                WindowSetResizable(this, WindowSetResizableEvent);
            }
        }

        [DispId(265)]
        void DWebBrowserEvents2.WindowSetTop(int Top)
        {
            if (WindowSetTop != null)
            {
                WindowSetTopEvent.top = Top;
                WindowSetTop(this, WindowSetTopEvent);
            }
        }

        [DispId(266)]
        void DWebBrowserEvents2.WindowSetWidth(int Width)
        {
            if (WindowSetWidth != null)
            {
                WindowSetWidthEvent.width = Width;
                WindowSetWidth(this, WindowSetWidthEvent);
            }
        }

        #endregion

        #region IDropTarget Members

        int IfacesEnumsStructsClasses.IDropTarget.DragEnter(System.Runtime.InteropServices.ComTypes.IDataObject pDataObj, uint grfKeyState, tagPOINT pt, ref uint pdwEffect)
        {
            if (WBDragEnter != null)
            {
                DataObject obja = null;
                if (pDataObj != null)
                    obja = new DataObject(pDataObj);
                Point ppt = new Point(pt.X, pt.Y);
                WBDragEnterEvent.SetParameters(obja, grfKeyState, ppt, pdwEffect);
                WBDragEnter(this, WBDragEnterEvent);
                if (WBDragEnterEvent.handled == true)
                    pdwEffect = (uint)WBDragEnterEvent.dropeffect;
            }
            return Hresults.S_OK;
        }
        int IfacesEnumsStructsClasses.IDropTarget.DragOver(uint grfKeyState, tagPOINT pt, ref uint pdwEffect)
        {
            if (WBDragOver != null)
            {
                Point ppt = new Point(pt.X, pt.Y);
                WBDragOverEvent.SetParameters(grfKeyState, ppt, pdwEffect);
                WBDragOver(this, WBDragOverEvent);
                if (WBDragOverEvent.handled == true)
                    pdwEffect = (uint)WBDragOverEvent.dropeffect;
            }
            return Hresults.S_OK;
        }
        int IfacesEnumsStructsClasses.IDropTarget.DragLeave()
        {
            if (WBDragLeave != null)
                WBDragLeave(this);
            return Hresults.S_OK;
        }
        int IfacesEnumsStructsClasses.IDropTarget.Drop(System.Runtime.InteropServices.ComTypes.IDataObject pDataObj, uint grfKeyState, tagPOINT pt, ref uint pdwEffect)
        {
            if (pDataObj == null)
                return Hresults.S_OK;
            if (WBDragDrop != null)
            {
                DataObject obja = new DataObject(pDataObj);
                Point ppt = new Point(pt.X, pt.Y);
                WBDropEvent.SetParameters(grfKeyState, ppt, obja, pdwEffect);
                WBDragDrop(this, WBDropEvent);
                if (WBDropEvent.handled == true)
                    pdwEffect = (uint)WBDropEvent.dropeffect;
            }
            return Hresults.S_OK;
        }

        #endregion

        #region IOleCommandTarget Members

        int IOleCommandTarget.QueryStatus(IntPtr pguidCmdGroup, uint cCmds, ref tagOLECMD prgCmds, IntPtr pCmdText)
        {
            //int hr = Hresults.S_OK;
            //if (m_WBOleCommandTarget != null)
            //{
            //    try
            //    {
            //        hr = m_WBOleCommandTarget.QueryStatus(pguidCmdGroup,
            //            cCmds, ref prgCmds, ref pCmdText);
            //    }
            //    finally
            //    {
            //    }
            //}
            //else
            //    hr = OLECMDERR_E_NOTSUPPORTED;
            return Hresults.OLECMDERR_E_NOTSUPPORTED;
        }

        //pguidCmdGroup must be declared as IntPtr not a GUID, as pguidCmdGroup may be null, hence generating execption
        int IOleCommandTarget.Exec(IntPtr pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
        {
            int hr = Hresults.S_OK;
            
            if ((pguidCmdGroup != m_NullPointer) &&
                (Type.GetTypeCode(pguidCmdGroup.GetType()) != TypeCode.Empty))
            {
                try
                {
                    ////Allocate mem for a GUID
                    //byte[] bguid = Guid.Empty.ToByteArray();
                    ////Copy incoming into byte array
                    //Marshal.Copy(pguidCmdGroup, bguid, 0, bguid.Length);
                    ////back to GUID
                    //Guid guid = new Guid(bguid);

                    Guid guid = (Guid)Marshal.PtrToStructure(pguidCmdGroup, typeof(Guid));

                    //Only group we are interested
                    if (guid == Iid_Clsids.CLSID_CGID_DocHostCommandHandler)
                    {
                        //http://support.microsoft.com/kb/261003
                        if (nCmdID == (int)OLECMDID.OLECMDID_SHOWSCRIPTERROR)
                        {
                            //Default Continue running scripts
                            if (pvaOut != IntPtr.Zero)
                                Marshal.GetNativeVariantForObject(true, pvaOut);
                            //false -> stop running scripts
                            if (ScriptError != null)
                            {
                                ScriptErrorEvent.SetParameters();
                                try
                                {
                                    IHTMLDocument2 doc2 = (IHTMLDocument2)Marshal.GetObjectForNativeVariant(pvaIn);
                                    IHTMLWindow2 win2 = (IHTMLWindow2)doc2.parentWindow;
                                    IHTMLEventObj2 eveobj = (IHTMLEventObj2)win2.eventobj;

                                    if (eveobj != null)
                                    {
                                        ScriptErrorEvent.lineNumber = (int)eveobj.getAttribute("errorLine", 0);
                                        ScriptErrorEvent.characterNumber = (int)eveobj.getAttribute("errorCharacter", 0);
                                        ScriptErrorEvent.errorCode = (int)eveobj.getAttribute("errorCode", 0);
                                        ScriptErrorEvent.errorMessage = eveobj.getAttribute("errorMessage", 0) as string;
                                        ScriptErrorEvent.url = eveobj.getAttribute("errorUrl", 0) as string;
                                    }
                                }
                                catch (Exception)
                                {
                                }
                                ScriptError(this, ScriptErrorEvent);
                                if (pvaOut != IntPtr.Zero)
                                    Marshal.GetNativeVariantForObject(ScriptErrorEvent.continueScripts, pvaOut);
                                ScriptErrorEvent.SetParameters();
                           }
                        }
                        else
                            hr = Hresults.OLECMDERR_E_NOTSUPPORTED;
                    }
                    else
                        hr = Hresults.OLECMDERR_E_UNKNOWNGROUP;
                }
                catch (Exception)
                {
                    hr = Hresults.OLECMDERR_E_UNKNOWNGROUP;
                }
            }
            else
                hr = Hresults.OLECMDERR_E_UNKNOWNGROUP;
            return hr;
        }

        #endregion

        #region IServiceProvider Members

        int IfacesEnumsStructsClasses.IServiceProvider.QueryService(ref Guid guidService, ref Guid riid, out IntPtr ppvObject)
        {
            int hr = Hresults.E_NOINTERFACE;
            ppvObject = m_NullPointer;

            if ((guidService == Iid_Clsids.SID_SDownloadManager) &&
                (riid == Iid_Clsids.IID_IDownloadManager) &&
                (m_UseInternalDownloadManager))
            {
                AddThisIEServerHwndToComLib();
                //QI for IDownloadManager interface from our COM object
                ppvObject = Marshal.GetComInterfaceForObject(m_csexwbCOMLib, typeof(IDownloadManager));
                hr = Hresults.S_OK;
            }
            else if (riid == Iid_Clsids.IID_IHttpSecurity)
            {
                ppvObject = Marshal.GetComInterfaceForObject(this, typeof(IHttpSecurity));
                hr = Hresults.S_OK;

                //Ulternative
                //try
                //{
                //    m_pUnk = IntPtr.Zero;
                //    m_pTargetIface = IntPtr.Zero;
                //    m_pUnk = Marshal.GetIUnknownForObject(this);
                //    Marshal.QueryInterface(m_pUnk, ref IID_IHttpSecurity, out m_pTargetIface);
                //    Marshal.Release(m_pUnk);
                //    ppvObject = m_pTargetIface;
                //    hr = Hresults.S_OK;
                //}
                //catch (Exception)
                //{
                //}
            }
            else if (riid == Iid_Clsids.IID_INewWindowManager) //xpsp2
            {
                ppvObject = Marshal.GetComInterfaceForObject(this, typeof(INewWindowManager));
                hr = Hresults.S_OK;
            }
            else if (riid == Iid_Clsids.IID_IWindowForBindingUI)
            {
                ppvObject = Marshal.GetComInterfaceForObject(this, typeof(IWindowForBindingUI));
                hr = Hresults.S_OK;
            }
            else if (guidService == Iid_Clsids.IID_IInternetSecurityManager)
            {
                ppvObject = Marshal.GetComInterfaceForObject(this, typeof(IInternetSecurityManager));
                hr = Hresults.S_OK;
            }
            else if ((guidService == Iid_Clsids.IID_IAuthenticate)
               && (riid == Iid_Clsids.IID_IAuthenticate))
            {
                ppvObject = Marshal.GetComInterfaceForObject(this, typeof(IAuthenticate));
                hr = Hresults.S_OK;
            }
            else if (riid == Iid_Clsids.IID_IProtectFocus) //IE7 + Vista
            {
                ppvObject = Marshal.GetComInterfaceForObject(this, typeof(IProtectFocus));
                hr = Hresults.S_OK;
            }
            else if ((riid == Iid_Clsids.IID_IHTMLOMWindowServices) &&
                (guidService == Iid_Clsids.IID_IHTMLOMWindowServices))
            {
                ppvObject = Marshal.GetComInterfaceForObject(this, typeof(IHTMLOMWindowServices));
                hr = Hresults.S_OK;
            }
            else if ((riid == Iid_Clsids.IID_IHTMLEditHost) &&
                (guidService == Iid_Clsids.SID_SHTMLEditHost))
            {
                ppvObject = Marshal.GetComInterfaceForObject(this, typeof(IHTMLEditHost));
                hr = Hresults.S_OK;
            }

            return hr;
        }

        #endregion

        #region IHttpSecurity Members

        int IHttpSecurity.GetWindow(ref Guid rguidReason, ref IntPtr phwnd)
        {
            phwnd = m_NullPointer;
            int hr = Hresults.S_FALSE;
            if ((rguidReason == Iid_Clsids.IID_IHttpSecurity) || (rguidReason == Iid_Clsids.IID_IAuthenticate))
            {
                if (!WBIEServerHandle().Equals(m_NullPointer))
                {
                    phwnd = m_hWBServerHandle;
                    hr = Hresults.S_OK;
                }
            }
            return hr;
        }
        int IHttpSecurity.OnSecurityProblem(uint dwProblem)
        {
            /*
            IHttpSecurity, Some possible problems:
                ERROR_INTERNET_SEC_CERT_DATE_INVALID
                ERROR_INTERNET_SEC_CERT_CN_INVALID
                ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR
                ERROR_INTERNET_HTTPS_TO_HTTP_ON_REDIR
                ERROR_HTTP_REDIRECT_NEEDS_CONFIRMATION
                ERROR_INTERNET_INVALID_CA
                ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED
            Implementing this method incorrectly can compromise the security of your application.
            Returning a value of RPC_E_RETRY can potentially leave users of your application exposed
            to unwanted information disclosure. RPC_E_RETRY should only be returned when
            the application is running on a known trusted server or after you have verified
            information from the user.
            
		    Returning S_FALSE implies that you have asked the user
		    if it is ok to proceed despite a security problem and they have agreed
		    return RPC_E_RETRY;
		    Retries using Registry options and most likely fails again
            */

            //dwProblem one of WinInetErrors enum (need more additions)
            int iRet = Hresults.S_FALSE;
            int hr = iRet;
            if (WBSecurityProblem != null)
            {
                SecurityProblemEvent.SetParameters((int)dwProblem);
                WBSecurityProblem(this, SecurityProblemEvent);
                //Possible ret values
                if (SecurityProblemEvent.handled == true)
                {
                    iRet = SecurityProblemEvent.retvalue;
                    if ((iRet == Hresults.RPC_E_RETRY) || (iRet == Hresults.S_FALSE) || (iRet == Hresults.E_ABORT))
                        hr = iRet;
                }
            }
            //Possible return values;
            //RPC_E_RETRY (cautious) The calling application should continue or retry the download. 
            //S_FALSE The calling application should open a dialog box to warn the user. 
            //E_ABORT The calling application should abort the download.
            return hr;
        }

        #endregion

        #region IWindowForBindingUI Members

        int IWindowForBindingUI.GetWindow(ref Guid rguidReason, ref IntPtr phwnd)
        {
            phwnd = m_NullPointer;
            int hr = Hresults.S_FALSE;
            if ((rguidReason == Iid_Clsids.IID_IHttpSecurity) || (rguidReason == Iid_Clsids.IID_IAuthenticate))
            {
                if (!WBIEServerHandle().Equals(m_NullPointer))
                {
                    phwnd = m_hWBServerHandle;
                    hr = Hresults.S_OK;
                }
            }
            return hr;
        }

        #endregion

        #region INewWindowManager Members

        int INewWindowManager.EvaluateNewWindow(string pszUrl, string pszName,
            string pszUrlContext, string pszFeatures, bool fReplace, uint dwFlags, uint dwUserActionTime)
        {
            int hr = Hresults.E_FAIL; //To perform default IE action - Calls NewWindow3 else NewWindow2 else shows popup
            if (WBEvaluteNewWindow != null)
            {
                EvaluateNewWindowEvent.SetParameters(pszUrl, pszName, pszUrlContext, pszFeatures, fReplace, (int)dwFlags, (int)dwUserActionTime);
                WBEvaluteNewWindow(this, EvaluateNewWindowEvent);
                if (EvaluateNewWindowEvent.Cancel == true)
                    hr = Hresults.S_FALSE; //Block
                    //hr = Hresults.S_OK; //Allow all
                EvaluateNewWindowEvent.Reset();
            }
            return hr;
        }

        #endregion

        #region IAuthenticate Members

        //To pass a doamin as in a NTLM authentication scheme, use this format: Username = Domain\username
        int IAuthenticate.Authenticate(ref IntPtr phwnd, ref IntPtr pszUsername, ref IntPtr pszPassword)
        {
            int hr = Hresults.E_ACCESSDENIED; //to abort, to proceed Hresults.S_OK
            int iRet = hr; //Assume failure
            phwnd = this.Handle;
            pszUsername = IntPtr.Zero;
            pszPassword = IntPtr.Zero;
            if (WBAuthenticate != null)
            {
                AuthenticateEvent.SetParameters();
                WBAuthenticate(this, AuthenticateEvent);
                if (AuthenticateEvent.handled == true)
                {
                    //Marshal.StringToCoTaskMemAuto
                    pszUsername = Marshal.StringToCoTaskMemUni(AuthenticateEvent.username);
                    pszPassword = Marshal.StringToCoTaskMemUni(AuthenticateEvent.password);
                    iRet = AuthenticateEvent.retvalue; //Should be 0
                }
                //Reset
                AuthenticateEvent.SetParameters();
                //accepted return values
                if ((iRet == Hresults.S_OK) || (iRet == Hresults.E_INVALIDARG) || (iRet == Hresults.E_ACCESSDENIED))
                    hr = iRet;
            }
            return hr;
        }

        #endregion
        
        #region IInternetSecurityManager Members

        int IInternetSecurityManager.SetSecuritySite(IntPtr pSite)
        {
            return (int)WinInetErrors.INET_E_DEFAULT_ACTION;
        }

        int IInternetSecurityManager.GetSecuritySite(out IntPtr pSite)
        {
            pSite = IntPtr.Zero;
            return (int)WinInetErrors.INET_E_DEFAULT_ACTION;
        }

        int IInternetSecurityManager.MapUrlToZone(string pwszUrl, out uint pdwZone, uint dwFlags)
        {
            // All URLs are on the local machine - most trusted and return S_OK;
            //pdwZone = (uint)tagURLZONE.URLZONE_LOCAL_MACHINE;
            //pdwZone =  (uint)tagURLZONE.URLZONE_INTRANET;
            //pdwZone =  (uint)tagURLZONE.URLZONE_TRUSTED; //....
            //return Hresults.S_OK;

            pdwZone = 0;
            return (int)WinInetErrors.INET_E_DEFAULT_ACTION;
        }

        //private const string m_strSecurity = "None:localhost+My Computer";
        int IInternetSecurityManager.GetSecurityId(string pwszUrl, IntPtr pbSecurityId, ref uint pcbSecurityId, ref uint dwReserved)
        {
            //pbSecurityId = Marshal.StringToCoTaskMemAnsi(m_strSecurity);
            //pcbSecurityId = (uint)m_strSecurity.Length;
            //return Hresults.S_OK;
            return (int)WinInetErrors.INET_E_DEFAULT_ACTION;
        }

        /*
        MSDN:
        The current list of URLACTION that will not be passed to the custom security manager
        in most circumstances by Internet Explorer 5 are:
	        URLACTION_SHELL_FILE_DOWNLOAD 
	        URLACTION_COOKIES 
	        URLACTION_JAVA_PERMISSIONS 
	        URLACTION_SCRIPT_PASTE 
        There is no workaround for this problem. The behavior for the URLACTION can only be
        changed for all browser clients on the system by altering the security zone settings
        from Internet Options.
        */
        int IInternetSecurityManager.ProcessUrlAction(string pwszUrl, uint dwAction, IntPtr pPolicy, uint cbPolicy, IntPtr pContext, uint cbContext, uint dwFlags, uint dwReserved)
        {
            if(ProcessUrlAction == null)
                return (int)WinInetErrors.INET_E_DEFAULT_ACTION;

            try
            {
                URLACTION action = (URLACTION)dwAction;
                ProcessUrlActionFlags flags = (ProcessUrlActionFlags)dwFlags;
                bool hasUrlPolicy = (cbPolicy >= unchecked((uint)Marshal.SizeOf(typeof(int))));
                URLPOLICY urlPolicy = (hasUrlPolicy) ? urlPolicy = (URLPOLICY)Marshal.ReadInt32(pPolicy) : URLPOLICY.ALLOW;
                bool hasContext = (cbContext >= unchecked((uint)Marshal.SizeOf(typeof(Guid))));
                Guid context = (hasContext) ? (Guid)Marshal.PtrToStructure(pContext, typeof(Guid)) : Guid.Empty;

                ProcessUrlActionEvent.SetParameters(pwszUrl, action, urlPolicy, context, flags, hasContext);
                ProcessUrlAction(this, ProcessUrlActionEvent);

                if (ProcessUrlActionEvent.handled && hasUrlPolicy)
                {
                    Marshal.WriteInt32(pPolicy, (int)ProcessUrlActionEvent.urlPolicy);
                    return (ProcessUrlActionEvent.Cancel) ? Hresults.S_FALSE : Hresults.S_OK;
                }
            }
            finally
            {
                ProcessUrlActionEvent.ResetParameters();
            }
            
            return (int)WinInetErrors.INET_E_DEFAULT_ACTION;
        }

        int IInternetSecurityManager.QueryCustomPolicy(string pwszUrl, ref Guid guidKey, out IntPtr ppPolicy, out uint pcbPolicy, IntPtr pContext, uint cbContext, uint dwReserved)
        {
            ppPolicy = IntPtr.Zero;
            pcbPolicy = 0;
            return (int)WinInetErrors.INET_E_DEFAULT_ACTION;
        }

        int IInternetSecurityManager.SetZoneMapping(uint dwZone, string lpszPattern, uint dwFlags)
        {
            return (int)WinInetErrors.INET_E_DEFAULT_ACTION;
        }

        int IInternetSecurityManager.GetZoneMappings(uint dwZone, out IEnumString ppenumString, uint dwFlags)
        {
            ppenumString = null;
            return (int)WinInetErrors.INET_E_DEFAULT_ACTION;
        }

        #endregion

        #region IProtectFocus Members

            void IProtectFocus.AllowFocusChange(ref bool pfAllow)
            {
                if (AllowFocusChange != null)
                {
                    AllowFocusChangeEvent.Cancel = false;
                    AllowFocusChange(this, AllowFocusChangeEvent);
                    if (AllowFocusChangeEvent.Cancel)
                        pfAllow = false;
                }
            }

        #endregion

        #region IHTMLOMWindowServices Members

        void IHTMLOMWindowServices.moveTo(int x, int y)
        {
            if (HTMLOMWindowServices_moveTo != null)
            {
                HTMLOMWindowServicesEvent.SetParameters(x, y);
                HTMLOMWindowServices_moveTo(this, HTMLOMWindowServicesEvent);
            }
        }

        void IHTMLOMWindowServices.moveBy(int x, int y)
        {
            if (HTMLOMWindowServices_moveBy != null)
            {
                HTMLOMWindowServicesEvent.SetParameters(x, y);
                HTMLOMWindowServices_moveBy(this, HTMLOMWindowServicesEvent);
            }
        }

        void IHTMLOMWindowServices.resizeTo(int x, int y)
        {
            if (HTMLOMWindowServices_resizeTo != null)
            {
                HTMLOMWindowServicesEvent.SetParameters(x, y);
                HTMLOMWindowServices_resizeTo(this, HTMLOMWindowServicesEvent);
            }
        }

        void IHTMLOMWindowServices.resizeBy(int x, int y)
        {
            if (HTMLOMWindowServices_resizeBy != null)
            {
                HTMLOMWindowServicesEvent.SetParameters(x, y);
                HTMLOMWindowServices_resizeBy(this, HTMLOMWindowServicesEvent);
            }
        }

        #endregion

#endregion //Interfaces Implementation

#region HTML Document and Window Events

        //For now, only HtmlDocumentEvents and HtmlWindowEvents2 are supported
        public void ActivateHTMLEvents(HTMLEventType EventType, int[] HTMLEventDispIds)
        {
            if (EventType == HTMLEventType.HTMLDocumentEvent)
            {
                m_TopLevelHtmlDocumentevents.InitHTMLEvents(this, HTMLEventDispIds, Iid_Clsids.DIID_HTMLDocumentEvents2);
                m_WantHtmlDocumentEvents = true;
            }
            else if (EventType == HTMLEventType.HTMLWindowEvent)
            {
                m_TopLevelHtmlWindowEvents.InitHTMLEvents(this, HTMLEventDispIds, Iid_Clsids.DIID_HTMLWindowEvents2);
                m_WantHtmlWindowEvents = true;
            }
            else
                return;
            m_WantHTMLEvents = true;
        }

        private void ActivateSecondaryHtmlDocumentEvents(ref cHTMLDocumentEvents doceve)
        {
            if (m_HtmlDocumentEventsList.Count == 0) //first one
            {
                doceve = new cHTMLDocumentEvents();
            }
            else
            {
                //Search for an idle one
                foreach (cHTMLDocumentEvents eve in m_HtmlDocumentEventsList)
                {
                    if (!eve.m_IsCOnnected)
                    {
                        doceve = eve;
                        break;
                    }
                }
                //Did we find any
                if (doceve == null)
                    doceve = new cHTMLDocumentEvents();
            }

            if (doceve != null)
            {
                doceve.InitHTMLEvents(this, m_TopLevelHtmlDocumentevents.m_dispIds, m_TopLevelHtmlDocumentevents.m_guid);
                m_HtmlDocumentEventsList.Add(doceve);
            }
        }

        private void ActivateSecondaryHtmlWindowEvents(ref cHTMLWindowEvents wineve)
        {
            if (m_HtmlWindowEventsList.Count == 0)
            {
                wineve = new cHTMLWindowEvents();
            }
            else
            {
                foreach (cHTMLWindowEvents eve in m_HtmlWindowEventsList)
                {
                    if (!eve.m_IsCOnnected)
                    {
                        wineve = eve;
                        break;
                    }
                }
                if (wineve == null)
                    wineve = new cHTMLWindowEvents();
            }

            if (wineve != null)
            {
                wineve.InitHTMLEvents(this, m_TopLevelHtmlWindowEvents.m_dispIds, m_TopLevelHtmlWindowEvents.m_guid);
                m_HtmlWindowEventsList.Add(wineve);
            }
        }

        private void DisconnectHtmlDocumentEvents()
        {
            if (m_HtmlDocumentEventsList.Count > 0)
            {
                foreach (cHTMLDocumentEvents doceve in m_HtmlDocumentEventsList)
                {
                    doceve.DisconnectHtmlEvents();
                }
            }
        }

        private void DisconnectHtmlWindowEvnets()
        {
            if (m_HtmlWindowEventsList.Count > 0)
            {
                foreach (cHTMLWindowEvents wineven in m_HtmlWindowEventsList)
                {
                    wineven.DisconnectHtmlEvents();
                }
            }
        }

        public void DeactivateHTMLEvents(HTMLEventType EventType)
        {
            m_WantHTMLEvents = false;
            if (EventType == HTMLEventType.HTMLDocumentEvent)
            {
                m_WantHtmlDocumentEvents = false;
                m_TopLevelHtmlDocumentevents.DisconnectHtmlEvents();
                DisconnectHtmlDocumentEvents();
            }
            else
            {
                m_WantHtmlWindowEvents = false;
                m_TopLevelHtmlWindowEvents.DisconnectHtmlEvents();
                DisconnectHtmlWindowEvnets();
            }
        }

        bool IHTMLEventCallBack.HandleHTMLEvent(HTMLEventType EventType, HTMLEventDispIds EventDispId, IHTMLEventObj pEvtObj)
        {
            bool bret = true; //always allow default processing
            if (HTMLEvent != null)
            {
                HtmlEventArg.ResetParameters(EventType, EventDispId, pEvtObj);
                HTMLEvent(this, HtmlEventArg);
                //Not all events are cancellable
                if (HtmlEventArg.Cancel)
                    bret = false;
                HtmlEventArg.ResetParameters(HTMLEventType.HTMLEventNone, 0, null);
            }
            return bret;
        }

#endregion //HTML Document and Window Events

#region Subclassing IEServer
    
    /// <summary>
    /// Class to enable this control to catch back and forward mouse buttons
    /// and call webbrowser GoBack and GoForward methods.
    /// Contributed by logan1337 - Aug 13 2007
    /// http://www.codeproject.com/cs/miscctrl/csEXWB.asp?df=100&forumid=422031&select=2180453#xx2180453xx
    /// </summary>
    [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")]
    internal class IEServerWindow : NativeWindow
    {

        private cEXWB browser;

        public IEServerWindow(cEXWB wb)
        {
            this.browser = wb;

            if (!wb.IEServerHwnd.Equals(IntPtr.Zero))
            {
                AssignHandle(wb.IEServerHwnd);
            }
        }

        public void Release()
        {
            ReleaseHandle();
        }

        [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")]
        protected override void WndProc(ref Message m)
        {
            switch (m.Msg)
            {
                case WindowsMessages.WM_XBUTTONDOWN:
                    if (m.WParam.ToInt32() >> 16 == 1) // back button
                    {
                        if(browser.CanGoBack)
                            browser.GoBack();
                    }
                    else if (m.WParam.ToInt32() >> 16 == 2) // forward button
                    {
                        if (browser.CanGoForward)
                            browser.GoForward();
                    }
                    break;
                default:
                    break;
            }
            base.WndProc(ref m);
        }
    }

#endregion

#region Downloader + Asynchronous pluggable protocols (APP), via CSEXWBDLMAN COM assembly

    private string m_DownloadDir = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + System.IO.Path.DirectorySeparatorChar.ToString();
    private bool m_UseInternalDownloadManager = true;
    private CSEXWBDLMANLib.csDLManClass m_csexwbCOMLib = null;

    public event csExWB.FileDownloadExEventHandler FileDownloadExStart = null;
    public event csExWB.FileDownloadExEndEventHandler FileDownloadExEnd = null;
    public event csExWB.FileDownloadExProgressEventHandler FileDownloadExProgress = null;
    public event csExWB.FileDownloadExAuthenticateEventHandler FileDownloadExAuthenticate = null;
    public event csExWB.FileDownloadExErrorEventHandler FileDownloadExError = null;
    public event csExWB.ProtocolHandlerOnBeginTransactionEventHandler ProtocolHandlerOnBeginTransaction = null;
    public event csExWB.ProtocolHandlerOnResponseEventHandler ProtocolHandlerOnResponse = null;

    private FileDownloadExEventArgs FileDownloadExEventArg = new FileDownloadExEventArgs();
    private FileDownloadExEndEventArgs FileDownloadExEndEventArg = new FileDownloadExEndEventArgs();
    private FileDownloadExProgressEventArgs FileDownloadExProgressEventArg = new FileDownloadExProgressEventArgs();
    private FileDownloadExAuthenticateEventArgs FileDownloadExAuthenticateEventArg = new FileDownloadExAuthenticateEventArgs();
    private FileDownloadExErrorEventArgs FileDownloadExErrorEventArg = new FileDownloadExErrorEventArgs();
    private ProtocolHandlerOnBeginTransactionEventArgs ProtocolHandlerOnBeginTransactionEventArg = new ProtocolHandlerOnBeginTransactionEventArgs();
    private ProtocolHandlerOnResponseEventArgs ProtocolHandlerOnResponseEventArg = new ProtocolHandlerOnResponseEventArgs();

    [Category("ExWB"), Description("Set to true, default, to allow the control to take over file downloads. FileDownloadExxxx events are fired instead of FileDownload.")]
    public bool UseInternalDownloadManager
    {
        get
        {
            return m_UseInternalDownloadManager;
        }

        set
        {
            m_UseInternalDownloadManager = value;
        }
    }

    [Category("ExWB"), Description("Default file download directory. Set to MyDocuments by default. Used only if UseInternalDownloadManager property is set to true.")]
    public string FileDownloadDirectory
    {
        get
        {
            return m_DownloadDir;
        }

        set
        {
            if (!string.IsNullOrEmpty(value))
            {
                if (value.EndsWith(System.IO.Path.DirectorySeparatorChar.ToString()))
                    m_DownloadDir = value;
                else
                    m_DownloadDir = value + System.IO.Path.DirectorySeparatorChar;
            }
        }
    }

    /// <summary>
    /// Checks to determine if m_DownloadManager object has been set up.
    /// </summary>
    private void InitCOMLibrary()
    {
        //if (m_DownloadManager == null)
        //{
            m_csexwbCOMLib = new CSEXWBDLMANLib.csDLManClass();
            m_csexwbCOMLib.ProtocolHandlerOnBeginTransaction += new CSEXWBDLMANLib._IcsDLManEvents_ProtocolHandlerOnBeginTransactionEventHandler(dlman_ProtocolHandlerOnBeginTransaction);
            m_csexwbCOMLib.ProtocolHandlerOnResponse += new CSEXWBDLMANLib._IcsDLManEvents_ProtocolHandlerOnResponseEventHandler(dlman_ProtocolHandlerOnResponse);
            m_csexwbCOMLib.FileDownloadEx += new CSEXWBDLMANLib._IcsDLManEvents_FileDownloadExEventHandler(dl_FileDownloadEx);
            m_csexwbCOMLib.OnFileDLEndDownload += new CSEXWBDLMANLib._IcsDLManEvents_OnFileDLEndDownloadEventHandler(dl_OnFileDLEndDownload);
            m_csexwbCOMLib.OnFileDLDownloadError += new CSEXWBDLMANLib._IcsDLManEvents_OnFileDLDownloadErrorEventHandler(dl_OnFileDLDownloadError);
            m_csexwbCOMLib.OnFileDLAuthenticate += new CSEXWBDLMANLib._IcsDLManEvents_OnFileDLAuthenticateEventHandler(m_DownloadManager_OnFileDLAuthenticate);
            m_csexwbCOMLib.OnFileDLProgress += new CSEXWBDLMANLib._IcsDLManEvents_OnFileDLProgressEventHandler(m_DownloadManager_OnFileDLProgress);
            //m_DownloadManager.OnFileDLBeginningTransaction += new CSEXWBDLMANLib._IcsDLManEvents_OnFileDLBeginningTransactionEventHandler(m_DownloadManager_OnFileDLBeginningTransaction);
            //m_DownloadManager.OnFileDLResponse += new CSEXWBDLMANLib._IcsDLManEvents_OnFileDLResponseEventHandler(m_DownloadManager_OnFileDLResponse);
        //}
    }

    private void AddThisIEServerHwndToComLib()
    {
        if (m_hWBServerHandle != IntPtr.Zero)
            m_csexwbCOMLib.HWNDInternetExplorerServer = m_hWBServerHandle.ToInt32();
        else if (WBIEServerHandle() != IntPtr.Zero)
                m_csexwbCOMLib.HWNDInternetExplorerServer = m_hWBServerHandle.ToInt32();
    }

    /// <summary>
    /// Attempts to download a file asynch.
    /// FileDownloadExxxx events are used for notifications.
    /// </summary>
    /// <param name="Url"></param>
    /// <returns>A unique id assigned to this file download.
    /// Can be used to cancel a download.</returns>
    public int DownloadFile(string Url)
    {
        AddThisIEServerHwndToComLib();
        int i = 0;
        m_csexwbCOMLib.DownloadUrlAsync(Url, ref i);
        return i;
    }

    /// <summary>
    /// Stops a file download
    /// </summary>
    /// <param name="dlUID">Unique id for this file download</param>
    public void StopFileDownload(int dlUID)
    {
        if (m_csexwbCOMLib == null)
            return;
        m_csexwbCOMLib.CancelFileDownload(dlUID);
    }

    /// <summary>
    /// Monitor and/or cancel every HTTP protocol request and responde
    /// including images, sounds, scripts, ... 
    /// Notifications are send via ProtocolHandlerOnResponse and
    /// ProtocolHandlerOnBeginTransaction events
    /// </summary>
    public void StartHTTPAPP()
    {
        AddThisIEServerHwndToComLib();
        if (!m_csexwbCOMLib.HTTPprotocol)
        {
            m_csexwbCOMLib.HTTPprotocol = true;
        }
    }

    public void StopHTTPAPP()
    {
        if (m_csexwbCOMLib.HTTPprotocol)
        {
            m_csexwbCOMLib.HTTPprotocol = false;
        }
    }

    public void StopHTTPSAPP()
    {
        if (m_csexwbCOMLib.HTTPSprotocol)
        {
            m_csexwbCOMLib.HTTPSprotocol = false;
        }
    }

    /// <summary>
    /// Monitor and/or cancel every HTTPS protocol request and responde
    /// including images, sounds, scripts, ... 
    /// Notifications are send via ProtocolHandlerOnResponse and
    /// ProtocolHandlerOnBeginTransaction events
    /// </summary>
    public void StartHTTPSAPP()
    {
        AddThisIEServerHwndToComLib();
        if (!m_csexwbCOMLib.HTTPSprotocol)
        {
            m_csexwbCOMLib.HTTPSprotocol = true;
        }
    }

    //
    //EVENTS
    //

    void dlman_ProtocolHandlerOnResponse(int IEServerHwnd, string sURL, string sResponseHeaders, string sRedirectedUrl, string sRedirectHeaders, ref bool Cancel)
    {
        if (ProtocolHandlerOnResponse != null)
        {
            ProtocolHandlerOnResponseEventArg.SetParameters(sURL, sResponseHeaders, sRedirectedUrl, sRedirectHeaders);
            ProtocolHandlerOnResponse(this, ProtocolHandlerOnResponseEventArg);
            if (ProtocolHandlerOnResponseEventArg.Cancel)
                Cancel = true;
            ProtocolHandlerOnResponseEventArg.Reset();
        }
    }

    void dlman_ProtocolHandlerOnBeginTransaction(int IEServerHwnd, string sURL, string sRequestHeaders, ref string sAdditionalHeaders, ref bool Cancel)
    {
        if (ProtocolHandlerOnBeginTransaction != null)
        {
            ProtocolHandlerOnBeginTransactionEventArg.SetParameters(sURL, sRequestHeaders);
            ProtocolHandlerOnBeginTransaction(this, ProtocolHandlerOnBeginTransactionEventArg);
            if (!ProtocolHandlerOnBeginTransactionEventArg.Cancel)
            {
                //Additional headers can be added to what is already
                //being send by Webbrowser control
                if (!string.IsNullOrEmpty(ProtocolHandlerOnBeginTransactionEventArg.m_AdditionalHeadersToAdd))
                    sAdditionalHeaders = ProtocolHandlerOnBeginTransactionEventArg.m_AdditionalHeadersToAdd;
            }
            else
                Cancel = true;
            ProtocolHandlerOnBeginTransactionEventArg.Reset();
        }
    }

    void dl_OnFileDLDownloadError(int dlUID, string sURL, string sErrorMsg)
    {
        if (FileDownloadExError != null)
        {
            FileDownloadExErrorEventArg.SetParameters(dlUID, sURL, sErrorMsg);
            FileDownloadExError(this, FileDownloadExErrorEventArg);
            FileDownloadExErrorEventArg.Reset();
        }
    }

    void m_DownloadManager_OnFileDLProgress(int dlUID, string sURL, int lProgress, int lProgressMax, ref bool CancelDl)
    {
        if (this.FileDownloadExProgress != null)
        {
            FileDownloadExProgressEventArg.SetParameters(dlUID, sURL, lProgress, lProgressMax);
            FileDownloadExProgress(this, FileDownloadExProgressEventArg);
            if (FileDownloadExProgressEventArg.Cancel)
                CancelDl = FileDownloadExProgressEventArg.Cancel;
            FileDownloadExProgressEventArg.Reset();
        }
    }

    //Default value of Cancel = false
    void m_DownloadManager_OnFileDLAuthenticate(int dlUID, ref string sUsername, ref string sPassword, ref bool Cancel)
    {
        if (FileDownloadExAuthenticate != null)
        {
            FileDownloadExAuthenticateEventArg.SetParameters(dlUID);
            FileDownloadExAuthenticate(this, FileDownloadExAuthenticateEventArg);
            if (!FileDownloadExAuthenticateEventArg.Cancel)
            {
                sUsername = FileDownloadExAuthenticateEventArg.username;
                sPassword = FileDownloadExAuthenticateEventArg.password;
            }
            FileDownloadExAuthenticateEventArg.Reset();
        }
    }

    void dl_OnFileDLEndDownload(int dlUID, string sURL, string sSavedFilePath)
    {
        if (FileDownloadExEnd != null)
        {
            FileDownloadExEndEventArg.SetParameters(dlUID, sURL, sSavedFilePath);
            FileDownloadExEnd(this, FileDownloadExEndEventArg);
            FileDownloadExEndEventArg.Reset();
        }
        else
        {
            //Just let user know for now
            WinApis.MessageBox(this.Handle, "Download URL:\r\n" + sURL + "Saved To:\r\n" + sSavedFilePath, "File Download Completed", 0);
        }
    }

    void dl_FileDownloadEx(int dlUID, string sURL, string sFilename, string sExt, string sFileSize, string sExtraHeaders, string sRedirURL, ref bool SendProgressEvents, ref bool bStopDownload, ref string sPathToSave)
    {
        if (FileDownloadExStart != null)
        {
            FileDownloadExEventArg.SetParameters(dlUID, sURL, sFilename, sExt, sFileSize, sExtraHeaders, sRedirURL);
            FileDownloadExStart(this, FileDownloadExEventArg);
            if (!FileDownloadExEventArg.Cancel)
            {
                //Otherwise file will be saved in the same dir as exe
                //with the sFilename (file.zip)
                if (!string.IsNullOrEmpty(FileDownloadExEventArg.m_PathToSave))
                    sPathToSave = FileDownloadExEventArg.m_PathToSave;
                SendProgressEvents = FileDownloadExEventArg.m_SendProgressEvents;
            }
            else
                bStopDownload = true;
            FileDownloadExEventArg.Reset();
        }
        else
        {
            SendProgressEvents = false;
            //Save it in the downloaddir
            if (!string.IsNullOrEmpty(m_DownloadDir)) //Users MyDocument
                sPathToSave = m_DownloadDir + sFilename;
        }
    }

    //void m_DownloadManager_OnFileDLResponse(int dlUID, string sURL, int lResponseCode, string sResponseHeaders, ref bool CancelDl)
    //{
    //    //Check against WinInetErrors enum
    //    if( (lResponseCode == 301) || (lResponseCode > 399) ) //abort and notify the user 
    //}

    ////Only fired if file download is initiated using DownloadFile method
    ////gives the client a chnace to add extra headers. Example: resume header
    ////Syntax: Range: bytes=n-m
    ////bResuming = true;
    ////sAdditionalRequestHeaders = "Range: bytes=" + iLocalFileSize.ToString() + "-\r\n"
    //void m_DownloadManager_OnFileDLBeginningTransaction(int dlUID, string sURL, string sRequestHeaders, ref string sAdditionalRequestHeaders, ref bool bResuming, ref bool bCancel)
    //{
    //    
    //}

#endregion

#region Automation of webbrowser control

        //All elements are searched by id and name for a match
        //If frameset, it will search all frames for given element name or id.
        //Please refer to frmAutomation for an example of usage

        private enum AutomationTasks
        {
            ClickButton = 0,
            ClickLink,
            EnterData,
            EnterDataTextArea,
            SelectListItem,
            SelectRadioButton,
            SubmitForm
        }
        
        private bool GetElementByName(AutomationTasks task, string elemname, string data)
        {
            if( (this.m_WBWebBrowser2 == null) ||
                string.IsNullOrEmpty(elemname) )
                return false;
            bool result = false;

            IHTMLDocument2 doc2 = this.m_WBWebBrowser2.Document as IHTMLDocument2;
            if (doc2 == null)
                return false;
            IHTMLElementCollection col = null;

            if (this.IsWBFrameset(doc2))
            {
                List<IWebBrowser2> frames = this.GetFrames(this.m_WBWebBrowser2);
                if (frames == null)
                    return false;
                foreach (IWebBrowser2 wb in frames)
                {
                    if (task == AutomationTasks.ClickLink)
                    {
                        IHTMLDocument2 framedoc = wb.Document as IHTMLDocument2;
                        if (framedoc == null)
                            continue;
                        col = framedoc.anchors as IHTMLElementCollection;
                    }
                    else if (task == AutomationTasks.SelectListItem)
                    {
                        IHTMLDocument3 doc3 = wb.Document as IHTMLDocument3;
                        if (doc3 == null)
                            continue;
                        col = doc3.getElementsByTagName("select") as IHTMLElementCollection;
                    }
                    else if (task == AutomationTasks.EnterDataTextArea)
                    {
                        IHTMLDocument3 doc3 = wb.Document as IHTMLDocument3;
                        if (doc3 == null)
                            continue;
                        col = doc3.getElementsByTagName("textarea") as IHTMLElementCollection;
                    }
                    else if (task == AutomationTasks.SubmitForm)
                    {
                        IHTMLDocument2 framedoc = wb.Document as IHTMLDocument2;
                        if (framedoc == null)
                            continue;
                        col = framedoc.forms as IHTMLElementCollection;
                    }
                    else
                    {
                        IHTMLDocument3 doc3 = wb.Document as IHTMLDocument3;
                        if (doc3 == null)
                            continue;
                        col = doc3.getElementsByTagName("input") as IHTMLElementCollection;
                    }

                    if (col == null)
                        continue;
                    result = this.PerformAutomationTask(col, task, elemname, data);
                    if (result)
                        return result;
                }
            }
            else
            {
                if (task == AutomationTasks.ClickLink)
                {
                    col = doc2.anchors as IHTMLElementCollection;
                    //IHTMLElement elem = col.item(elemname, 0) as IHTMLElement;
                    //if (elem != null)
                    //    elem.click();
                    //return true;
                }
                else if (task == AutomationTasks.SelectListItem)
                {
                    //IHTMLDocument2 framedoc = this.m_WBWebBrowser2.Document as IHTMLDocument2;
                    //if (framedoc == null)
                    //    return result;
                    //col = framedoc.all as IHTMLElementCollection;
                    
                    //IHTMLElement elem = col.item(elemname, 0) as IHTMLElement;
                    //if (elem != null)
                    //{
                    //    IHTMLSelectElement selelem = elem as IHTMLSelectElement;
                    //    if (selelem != null)
                    //        selelem.value = data;
                    //}
                    //return true;
                    IHTMLDocument3 doc3 = this.m_WBWebBrowser2.Document as IHTMLDocument3;
                    if (doc3 == null)
                        return result;
                    col = doc3.getElementsByTagName("select") as IHTMLElementCollection;
                }
                else if (task == AutomationTasks.EnterDataTextArea)
                {
                    IHTMLDocument3 doc3 = this.m_WBWebBrowser2.Document as IHTMLDocument3;
                    if (doc3 == null)
                        return result;
                    col = doc3.getElementsByTagName("textarea") as IHTMLElementCollection;
                }
                else if (task == AutomationTasks.SubmitForm)
                {
                    IHTMLDocument2 framedoc = this.m_WBWebBrowser2.Document as IHTMLDocument2;
                    if (framedoc == null)
                        return result;
                    col = framedoc.forms as IHTMLElementCollection;
                }
                else
                {
                    IHTMLDocument3 doc3 = this.m_WBWebBrowser2.Document as IHTMLDocument3;
                    if (doc3 == null)
                        return result;
                    col = doc3.getElementsByTagName("input") as IHTMLElementCollection;
                }
                if (col == null)
                    return result;
                result = this.PerformAutomationTask(col, task, elemname, data);
            }
            return result;
        }

        private bool PerformAutomationTask(IHTMLElementCollection col, AutomationTasks task, string elemname, string data)
        {
            bool bret = false;

            if (col == null) return bret;

            foreach (IHTMLElement elem in col)
            {
                if (elem != null)
                {
                    switch (task)
                    {
                        case AutomationTasks.ClickButton:
                            {
                                IHTMLInputElement btn = elem as IHTMLInputElement;
                                if ((btn != null) &&
                                    ((elem.id == elemname) ||(btn.name == elemname))
                                    )
                                {
                                    elem.click();
                                    return true;
                                }
                            }
                            break;
                        case AutomationTasks.ClickLink:
                            {
                                IHTMLAnchorElement anchor = elem as IHTMLAnchorElement;
                                if( (anchor != null) &&
                                    ((elem.id == elemname) ||(anchor.name == elemname))
                                    )
                                {
                                    elem.click();
                                    return true;
                                }
                            }
                            break;
                        case AutomationTasks.EnterData:
                            {
                                IHTMLInputElement inputelem = elem as IHTMLInputElement;
                                if( (inputelem != null) &&
                                    ((elem.id == elemname) ||(inputelem.name == elemname))
                                    )
                                {
                                    inputelem.value = data;
                                    return true;
                                }
                            }
                            break;
                        case AutomationTasks.EnterDataTextArea:
                            {
                                IHTMLTextAreaElement txtarea = elem as IHTMLTextAreaElement;
                                if ((txtarea != null) &&
                                    ((elem.id == elemname) ||(txtarea.name == elemname))
                                    )
                                {
                                    txtarea.value = data;
                                    return true;
                                }
                            }
                            break;
                        case AutomationTasks.SelectListItem:
                            {
                                IHTMLSelectElement selelem = elem as IHTMLSelectElement;
                                if( (selelem != null) &&
                                    ((elem.id == elemname) || (selelem.name == elemname))
                                    )
                                {
                                    //data can be value or text of the htmloptionelement
                                    // Obtain the number of option objects in the select object.
                                    int icount = selelem.length;
                                    IHTMLOptionElement optelem = null;
                                    for (int i = 0; i < icount; i++)
                                    {
                                        optelem = selelem.item(i, i) as IHTMLOptionElement;
                                        if (optelem != null)
                                        {
                                            if ((optelem.text == data) ||
                                                (optelem.value == data))
                                            {
                                                optelem.selected = true;
                                                return true;
                                            }
                                        }
                                    }
                                    return false;
                                }
                            }
                            break;
                        case AutomationTasks.SelectRadioButton:
                            {
                                IHTMLInputElement inputelem = elem as IHTMLInputElement;
                                if( (inputelem != null) && 
                                    ((elem.id == elemname) ||(inputelem.name == elemname))
                                    )
                                {
                                    inputelem.checkeda = true;
                                    return true;
                                }
                            }
                            break;
                        case AutomationTasks.SubmitForm:
                            {
                                IHTMLFormElement form = elem as IHTMLFormElement;
                                if ((form != null) &&
                                   ((elem.id == elemname) ||(form.name == elemname))
                                    )
                                {
                                    form.submit();
                                    return true;
                                }
                            }
                            break;
                        default:
                            break;
                    }
                }
            } //End foreach

            return bret;
        }

        /// <summary>
        /// Performs a click on a Button element with given name
        /// </summary>
        /// <param name="elemname">Name of Button element</param>
        /// <returns></returns>
        public bool AutomationTask_PerformClickButton(string btnnameorid)
        {
            return this.GetElementByName(AutomationTasks.ClickButton, btnnameorid, string.Empty);
        }

        public bool AutomationTask_PerformClickLink(string linknameorid)
        {
            return this.GetElementByName(AutomationTasks.ClickLink, linknameorid, string.Empty);
        }

        public bool AutomationTask_PerformEnterData(string inputnameorid, string strValue)
        {
            return this.GetElementByName(AutomationTasks.EnterData, inputnameorid, strValue);
        }

        public bool AutomationTask_PerformEnterDataTextArea(string inputnameorid, string strValue)
        {
            return this.GetElementByName(AutomationTasks.EnterDataTextArea, inputnameorid, strValue);
        }

        /// <summary>
        /// Attempts to select an item from a selection list
        /// based on the item value or text
        /// </summary>
        /// <param name="selectnameorid"></param>
        /// <param name="listitemvalueortext"></param>
        /// <returns></returns>
        public bool AutomationTask_PerformSelectList(string selectnameorid, string listitemvalueortext)
        {
            return this.GetElementByName(AutomationTasks.SelectListItem, selectnameorid, listitemvalueortext);
        }

        public bool AutomationTask_PerformSelectRadio(string radionameorid)
        {
            return this.GetElementByName(AutomationTasks.SelectRadioButton, radionameorid, string.Empty);
        }

        public bool AutomationTask_PerformSubmitForm(string formnameorid)
        {
            return this.GetElementByName(AutomationTasks.SubmitForm, formnameorid, string.Empty);
        }

        /// <summary>
        /// Attempts to scroll into view a link given it's name or id
        /// </summary>
        /// <param name="nameorid"></param>
        public bool AutomationTask_NamedLinkScrollIntoView(string nameorid)
        {
            IHTMLDocument2 pdoc2 = m_WBWebBrowser2.Document as IHTMLDocument2;
            if (pdoc2 != null)
            {
                IHTMLElementCollection hrefs = pdoc2.anchors as IHTMLElementCollection;

                if (hrefs != null)
                {
                    ////If there are two elements by the same name exists
                    ////we receive the item based on the index passed (0)
                    //IHTMLElement elem = hrefs.item(namedLink, 0) as IHTMLElement;
                    //if (elem != null)
                    //    elem.scrollIntoView(true);
                    foreach (IHTMLElement elem in hrefs)
                    {
                        if (elem != null)
                        {
                            IHTMLAnchorElement anchor = elem as IHTMLAnchorElement;
                            if ( (anchor != null) &&
                                ((elem.id == nameorid) || (anchor.name == nameorid)) )
                            {
                                elem.scrollIntoView(true);
                                return true;
                            }
                        }
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// Simulates a keystroke. The targetelement must have focus
        /// </summary>
        /// <param name="keycode">One of Keys enum</param>
        public void AutomationTask_SimulateKeyStroke(Keys keycode)
        {
            WinApis.keybd_event((byte)keycode, 0, 0, UIntPtr.Zero); //keydown
            WinApis.keybd_event((byte)keycode, 0, WinApis.KEYEVENTF_KEYUP, UIntPtr.Zero); //Keydown
        }

        /// <summary>
        /// Attempts to select all the items within a given select list
        /// </summary>
        /// <param name="selects">A List of MultiSelectHTMLList classes containning a list of
        /// items to select</param>
        public void AutomationTask_PerformMultiSelectListItems(List<MultiSelectHTMLList> selects)
        {
            if ((this.m_WBWebBrowser2 == null) ||
                (selects == null) || (selects.Count == 0))
                return;
            //throw new Exception("

            //get the select collection from IHTMLDocument3
            IHTMLDocument3 doc3 = this.m_WBWebBrowser2.Document as IHTMLDocument3;
            if (doc3 == null)
                return;
            IHTMLElementCollection col = doc3.getElementsByTagName("select") as IHTMLElementCollection;

            if (col == null)
                return;

            int icount = 0;
            int i = 0;
            IHTMLOptionElement optelem = null;
            IHTMLSelectElement selelem = null;

            //Loop through
            foreach (MultiSelectHTMLList list in selects)
            {
                if ((list != null) && (!string.IsNullOrEmpty(list.m_SelectNameOrId)) &&
                    (list.m_ListItemsNamesOrIds != null) && (list.m_ListItemsNamesOrIds.Count > 0))
                {
                    //find the list in the collection
                    foreach (IHTMLElement elem in col)
                    {
                        if (elem != null)
                        {
                            selelem = elem as IHTMLSelectElement;
                            if ((selelem != null) &&
                                ((elem.id == list.m_SelectNameOrId) || //check id
                                (selelem.name == list.m_SelectNameOrId)) //check name as well
                                )
                            {
                                //data can be value or text of the htmloptionelement
                                // Obtain the number of option objects in the select object.
                                icount = selelem.length;
                                //loop through all items
                                for (i = 0; i < icount; i++)
                                {
                                    optelem = selelem.item(i, i) as IHTMLOptionElement;
                                    if (optelem != null)
                                    {
                                        //see if this the one
                                        foreach (string data in list.m_ListItemsNamesOrIds)
                                        {
                                            if ((optelem.text == data) ||
                                                (optelem.value == data))
                                            {
                                                optelem.selected = true;
                                                //selected this item, break and
                                                //continue with the rest of the items
                                                break;
                                            }
                                        }
                                    }
                                }
                                //Checked this select, break and continue with the next select in the list
                                break;
                            }
                        }
                    }
                }
            }
        }

        public bool AutomationTask_PerformAuthentication(string txtUserNameOrId, string txtPasswordNameOrId, string strUserName, string strPassword, bool bForceNewValue, bool bAutoSubmit)
        {
            bool result = false;
            bool doneusername = false;
            bool donepassword = false;
            //checks
            if (this.m_WBWebBrowser2 == null)
                return result;

            //get the select collection from IHTMLDocument3
            IHTMLDocument3 doc3 = this.m_WBWebBrowser2.Document as IHTMLDocument3;
            if (doc3 == null)
                return result;
            IHTMLElementCollection col = doc3.getElementsByTagName("input") as IHTMLElementCollection;

            if (col == null)
                return result;

            IHTMLInputElement inputelem = null;
            foreach (IHTMLElement elem in col)
            {
                if (elem != null)
                {
                    inputelem = elem as IHTMLInputElement;
                    if (inputelem != null)                        
                    {
                        if ((elem.id == txtUserNameOrId) || 
                            (inputelem.name == txtUserNameOrId))
                        {
                            if ((string.IsNullOrEmpty(inputelem.value)) ||
                                (bForceNewValue))
                            {
                                doneusername = true;
                                inputelem.value = strUserName;
                            }
                        }
                        else if ((elem.id == txtPasswordNameOrId) ||
                            (inputelem.name == txtPasswordNameOrId))
                        {
                            //To make sure this is the one we 
                            //can also check for hidden or password 
                            //value indicated by type property.
                            if ((string.IsNullOrEmpty(inputelem.value)) ||
                                (bForceNewValue))
                            {
                                donepassword = true;
                                inputelem.value = strPassword;
                            }
                        }
                    }
                    if ((doneusername) && (donepassword))
                        break;
                }
            }
            if (((doneusername) && (donepassword)) && bAutoSubmit)
            {
                this.AutomationTask_SimulateKeyStroke(Keys.Enter);
                //if ((inputelem != null) && (inputelem.form != null))
                //{
                //    IHTMLFormElement form = inputelem.form as IHTMLFormElement;
                //    if (form != null)
                //        form.submit();
                //}
            }
            return ((doneusername) && (donepassword)) ? true : false;
        }

#endregion

#region TravelLog - this webbrowser session history

        private ITravelLogStg m_TravelLogStg = null;

        private bool GetHistorySession()
        {
            if (m_TravelLogStg != null)
                return true;
            //QI for serviceprovider
            IfacesEnumsStructsClasses.IServiceProvider psp = m_WBUnknown as IfacesEnumsStructsClasses.IServiceProvider;
            if (psp == null)
                return false;

            IntPtr oret = IntPtr.Zero;
            //QueryService for ITravelLogStg
            int hr = psp.QueryService(ref Iid_Clsids.SID_STravelLogCursor, ref Iid_Clsids.IID_ITravelLogStg, out oret);
            if ((oret == IntPtr.Zero) || (hr != Hresults.S_OK))
                return false;
            Marshal.ReleaseComObject(psp);
            m_TravelLogStg = Marshal.GetObjectForIUnknown(oret) as ITravelLogStg;
            return (m_TravelLogStg != null) ? true : false;
        }

        public int GetTravelLogCount()
        {
            int iret = 0;
            if (!GetHistorySession())
                return iret;
            m_TravelLogStg.GetCount((int)TLMENUF.TLEF_ABSOLUTE, out iret);
            return iret;
        }

        //If there is no title, the method returns the URL of the page.
        //The method returns zero length string for the 
        //current page's title and url
        public List<TravelLogStruct> GetTraveLogEntries()
        {
            List<TravelLogStruct> entries = new List<TravelLogStruct>();
            if (!GetHistorySession())
                return entries;

            //Enum the travel log entries
            IEnumTravelLogEntry penumtle = null;
            m_TravelLogStg.EnumEntries((int)TLMENUF.TLEF_ABSOLUTE, out penumtle);
            if (penumtle == null)
                return entries;

            int hr = 0;
            ITravelLogEntry ptle = null;
            int fetched = 0;
            IntPtr pTitle = IntPtr.Zero;
            IntPtr pUrl = IntPtr.Zero;
            const int MAX_FETCH_COUNT = 1;

            hr = penumtle.Next(MAX_FETCH_COUNT, out ptle, out fetched);
            Marshal.ThrowExceptionForHR(hr);
            //while sucess, continue
            for (int i = 0; Hresults.S_OK == hr; i++)
            {
                if (ptle != null)
                {
                    pTitle = IntPtr.Zero;
                    pUrl = IntPtr.Zero;
                    ptle.GetTitle(out pTitle);
                    TravelLogStruct tlg = new TravelLogStruct();
                    if (pTitle != IntPtr.Zero)
                        tlg.Title = Marshal.PtrToStringUni(pTitle);
                    else
                        tlg.Title = string.Empty;

                    ptle.GetURL(out pUrl);
                    if (pUrl != IntPtr.Zero)
                        tlg.URL = Marshal.PtrToStringUni(pUrl);
                    else
                        tlg.URL = string.Empty;

                    entries.Add(tlg);
                    //We are responsible to free the memory
                    Marshal.FreeCoTaskMem(pTitle);
                    Marshal.FreeCoTaskMem(pUrl);
                    //http://msdn2.microsoft.com/en-us/library/aa753624.aspx
                }
                hr = penumtle.Next(MAX_FETCH_COUNT, out ptle, out fetched);
                Marshal.ThrowExceptionForHR(hr);
            }
            Marshal.ReleaseComObject(penumtle);
            return entries;
        }

        public ITravelLogEntry AddTravelLogEntry(string url, string title)
        {
            ITravelLogEntry ptle = null;
            if (!GetHistorySession())
                return ptle;
            
            m_TravelLogStg.CreateEntry(url, title, null, true, out ptle);
            return ptle;
        }

        /// <summary>
        /// Removes all travel log entries for this webbrowser instance
        /// </summary>
        /// <returns></returns>
        public bool RemoveAllTravelLogEntries()
        {
            if (!GetHistorySession())
                return false;

            int hr = 0;
            int fetched = 0;
            const int MAX_FETCH_COUNT = 1;
            IntPtr pTitle = IntPtr.Zero;
            ITravelLogEntry ptle = null;
            IEnumTravelLogEntry penumtle = null;
            //Find entries
            m_TravelLogStg.EnumEntries((int)TLMENUF.TLEF_ABSOLUTE, out penumtle);
            if (penumtle == null)
                return false;

            hr = penumtle.Next(MAX_FETCH_COUNT, out ptle, out fetched);
            Marshal.ThrowExceptionForHR(hr);
            //while sucess, continue
            for (int i = 0; Hresults.S_OK == hr; i++)
            {
                if (ptle != null)
                {
                    pTitle = IntPtr.Zero;
                    ptle.GetTitle(out pTitle);
                    if (pTitle != IntPtr.Zero) //Current entry?
                    {
                        Marshal.FreeCoTaskMem(pTitle);
                        m_TravelLogStg.RemoveEntry(ptle);
                    }
                }
                hr = penumtle.Next(MAX_FETCH_COUNT, out ptle, out fetched);
                Marshal.ThrowExceptionForHR(hr);
            }
            Marshal.ReleaseComObject(penumtle);
            return true;
        }

        /// <summary>
        /// Removes all entries matching given url
        /// The current entry cannot be deleted.
        /// </summary>
        /// <param name="url"></param>
        /// <param name="title"></param>
        /// <returns></returns>
        public bool RemoveTravelLogEntries(string url)
        {
            if (!GetHistorySession())
                return false;

            int hr = 0;
            int fetched = 0;
            const int MAX_FETCH_COUNT = 1;
            IntPtr pUrl = IntPtr.Zero;
            string targeturl = string.Empty;
            ITravelLogEntry ptle = null;
            IEnumTravelLogEntry penumtle = null;
            //Find entries
            m_TravelLogStg.EnumEntries((int)TLMENUF.TLEF_ABSOLUTE, out penumtle);
            if (penumtle == null)
                return false;

            hr = penumtle.Next(MAX_FETCH_COUNT, out ptle, out fetched);
            Marshal.ThrowExceptionForHR(hr);
            //while sucess, continue
            for (int i = 0; Hresults.S_OK == hr; i++)
            {
                if (ptle != null)
                {
                    pUrl = IntPtr.Zero;
                    ptle.GetURL(out pUrl);
                    if (pUrl != IntPtr.Zero)
                    {
                        targeturl = Marshal.PtrToStringUni(pUrl);
                        Marshal.FreeCoTaskMem(pUrl);
                        if( (!string.IsNullOrEmpty(targeturl)) &&
                            (targeturl == url) )
                            m_TravelLogStg.RemoveEntry(ptle);
                    }
                }
                hr = penumtle.Next(MAX_FETCH_COUNT, out ptle, out fetched);
                Marshal.ThrowExceptionForHR(hr);
            }
            Marshal.ReleaseComObject(penumtle);

            return true;
        }

        /// <summary>
        /// Removes first entry matching given url and title
        /// </summary>
        /// <param name="url"></param>
        /// <param name="title"></param>
        /// <returns></returns>
        public bool RemoveTravelLogEntry(string url, string title)
        {
            if (!GetHistorySession())
                return false;

            int hr = 0;
            int fetched = 0;
            const int MAX_FETCH_COUNT = 1;
            IntPtr pTitle = IntPtr.Zero;
            IntPtr pUrl = IntPtr.Zero;
            string targeturl = string.Empty;
            string targettitle = string.Empty;
            ITravelLogEntry ptle = null;
            IEnumTravelLogEntry penumtle = null;
            //Find entries
            m_TravelLogStg.EnumEntries((int)TLMENUF.TLEF_ABSOLUTE, out penumtle);
            if (penumtle == null)
                return false;

            hr = penumtle.Next(MAX_FETCH_COUNT, out ptle, out fetched);
            Marshal.ThrowExceptionForHR(hr);
            //while sucess, continue
            for (int i = 0; Hresults.S_OK == hr; i++)
            {
                if (ptle != null)
                {
                    pTitle = IntPtr.Zero;
                    pUrl = IntPtr.Zero;
                    ptle.GetURL(out pUrl);
                    ptle.GetTitle(out pTitle);
                    if( (pUrl != IntPtr.Zero) &&
                        (pTitle != IntPtr.Zero) )
                    {
                        targeturl = Marshal.PtrToStringUni(pUrl);
                        targettitle = Marshal.PtrToStringUni(pTitle);
                        Marshal.FreeCoTaskMem(pTitle);
                        Marshal.FreeCoTaskMem(pUrl);
                        if ((!string.IsNullOrEmpty(targettitle)) &&
                            (targettitle == title) &&
                            (!string.IsNullOrEmpty(targeturl)) &&
                            (targeturl == url))
                        {
                            m_TravelLogStg.RemoveEntry(ptle);
                            return true;
                        }
                    }
                }
                hr = penumtle.Next(MAX_FETCH_COUNT, out ptle, out fetched);
                Marshal.ThrowExceptionForHR(hr);
            }
            Marshal.ReleaseComObject(penumtle);

            return false;
        }

        /// <summary>
        /// Removes one entry based on index
        /// Can not delete current entry
        /// </summary>
        /// <param name="index">0 based index</param>
        /// <returns></returns>
        public bool RemoveTravelLogEntry(int index)
        {
            if (!GetHistorySession())
                return false;

            int hr = 0;
            int fetched = 0;
            const int MAX_FETCH_COUNT = 1;
            IntPtr pTitle = IntPtr.Zero;
            ITravelLogEntry ptle = null;
            IEnumTravelLogEntry penumtle = null;
            //Find entries
            m_TravelLogStg.EnumEntries((int)TLMENUF.TLEF_ABSOLUTE, out penumtle);
            if (penumtle == null)
                return false;

            hr = penumtle.Next(MAX_FETCH_COUNT, out ptle, out fetched);
            Marshal.ThrowExceptionForHR(hr);
            //while sucess, continue
            for (int i = 0; Hresults.S_OK == hr; i++)
            {
                if( (ptle != null) &&
                    (i == index) )
                {
                    pTitle = IntPtr.Zero;
                    ptle.GetTitle(out pTitle);
                    if (pTitle != IntPtr.Zero) //Current entry?
                    {
                        Marshal.FreeCoTaskMem(pTitle);
                        m_TravelLogStg.RemoveEntry(ptle);
                        return true;
                    }
                    else
                        return false;
                }
                hr = penumtle.Next(MAX_FETCH_COUNT, out ptle, out fetched);
                Marshal.ThrowExceptionForHR(hr);
            }
            Marshal.ReleaseComObject(penumtle);
            return false;
        }

#endregion

#region IHTMLEditHost Members

    public event HTMLEditHostSnapRectEventHandler HTMLEditHostSnapRect = null;
    private HTMLEditHostSnapRectEventArgs HTMLEditHostSnapRectEvent = new HTMLEditHostSnapRectEventArgs();

    int IHTMLEditHost.SnapRect(IHTMLElement pIElement, ref tagRECT prcNew, int eHandle)
    {
        if (HTMLEditHostSnapRect != null)
        {
            HTMLEditHostSnapRectEvent.SetParameters(pIElement, prcNew, eHandle);
            HTMLEditHostSnapRect(this, HTMLEditHostSnapRectEvent);
            //if things changed
            prcNew = HTMLEditHostSnapRectEvent.ElemRect;
        }
        return Hresults.S_OK;
    }

#endregion

    } //class cEXWB

} //csExWB


