public:
    IWebBrowser2* pWebBrowser; //IE浏览器
    IHTMLDocument2* pHTMLDocument; //包含此控件的web页面

void CMyActiveXCtrl::OnSetClientSite()
{
    HRESULT hr = S_OK;
    IServiceProvider *isp, *isp2 = NULL;
    if (!m_pClientSite)
    {
        COMRELEASE(pWebBrowser);
    }  
    else
    {
        hr = m_pClientSite->QueryInterface(IID_IServiceProvider, reinterpret_cast<void **>(&isp));
        if (FAILED(hr)) 
        {
            hr = S_OK;
            goto cleanup;
        }
        hr = isp->QueryService(SID_STopLevelBrowser, IID_IServiceProvider, reinterpret_cast<void **>(&isp2));
        if (FAILED(hr))
        {
            hr = S_OK;
            goto cleanup;
        }
        hr = isp2->QueryService(SID_SWebBrowserApp, IID_IWebBrowser2, reinterpret_cast<void **>(&pWebBrowser)); //查询IE浏览器接口
        if (FAILED(hr)) 
        {
            hr = S_OK;
            goto cleanup;
        }
        hr   =   pWebBrowser->get_Document((IDispatch**)&pHTMLDocument); //查询Web页面接口  
        if(FAILED(hr))   
        {   
            hr = S_OK;
            goto cleanup;
        }   
    cleanup:
        // Free resources.
        COMRELEASE(isp);
        COMRELEASE(isp2);
    }
}

bool CMyActiveXCtrl::GetJScript(CComPtr<IDispatch>& spDisp)
{
    CHECK_POINTER(pHTMLDocument);
    HRESULT hr = pHTMLDocument->get_Script(&spDisp);
    ATLASSERT(SUCCEEDED(hr));
    return SUCCEEDED(hr);
}

bool CMyActiveXCtrl::GetJScripts(CComPtr<IHTMLElementCollection>& spColl)
{
    CHECK_POINTER(pHTMLDocument);
    HRESULT hr = pHTMLDocument->get_scripts(&spColl);
    ATLASSERT(SUCCEEDED(hr));
    return SUCCEEDED(hr);
}

bool CMyActiveXCtrl::CallJScript(const CString strFunc,CComVariant* pVarResult)
{
    CStringArray paramArray;
    return CallJScript(strFunc,paramArray,pVarResult);
}

bool CMyActiveXCtrl::CallJScript(const CString strFunc,const CString strArg1,CComVariant* pVarResult)
{
    CStringArray paramArray;
    paramArray.Add(strArg1);
    return CallJScript(strFunc,paramArray,pVarResult);
}

bool CMyActiveXCtrl::CallJScript(const CString strFunc,const CString strArg1,const CString strArg2,CComVariant* pVarResult)
{
    CStringArray paramArray;
    paramArray.Add(strArg1);
    paramArray.Add(strArg2);
    return CallJScript(strFunc,paramArray,pVarResult);
}

bool CMyActiveXCtrl::CallJScript(const CString strFunc,const CString strArg1,const CString strArg2,const CString strArg3,CComVariant* pVarResult)
{
    CStringArray paramArray;
    paramArray.Add(strArg1);
    paramArray.Add(strArg2);
    paramArray.Add(strArg3);
    return CallJScript(strFunc,paramArray,pVarResult);
}

bool CMyActiveXCtrl::CallJScript(const CString strFunc, const CStringArray& paramArray,CComVariant* pVarResult)
{
    CComPtr<IDispatch> spScript;
    if(!GetJScript(spScript))
    {
        //ShowError("Cannot GetScript");
        return false;
    }
    CComBSTR bstrMember(strFunc);
    DISPID dispid = NULL;
    HRESULT hr = spScript->GetIDsOfNames(IID_NULL,&bstrMember,1,
        LOCALE_SYSTEM_DEFAULT,&dispid);
    if(FAILED(hr))
    {
        //ShowError(GetSystemErrorMessage(hr));
        return false;
    }
    const int arraySize = paramArray.GetSize();
    DISPPARAMS dispparams;
    memset(&dispparams, 0, sizeof dispparams);
    dispparams.cArgs = arraySize;
    dispparams.rgvarg = new VARIANT[dispparams.cArgs];
    for( int i = 0; i < arraySize; i++)
    {
        CComBSTR bstr = paramArray.GetAt(arraySize - 1 - i); // back reading
        bstr.CopyTo(&dispparams.rgvarg[i].bstrVal);
        dispparams.rgvarg[i].vt = VT_BSTR;
    }
    dispparams.cNamedArgs = 0;
    EXCEPINFO excepInfo;
    memset(&excepInfo, 0, sizeof excepInfo);
    CComVariant vaResult;
    UINT nArgErr = (UINT)-1;  // initialize to invalid arg
    hr = spScript->Invoke(dispid,IID_NULL,0,
        DISPATCH_METHOD,&dispparams,&vaResult,&excepInfo,&nArgErr);
    delete [] dispparams.rgvarg;
    if(FAILED(hr))
    {
        //ShowError(GetSystemErrorMessage(hr));
        return false;
    }
    if(pVarResult)
    {
        *pVarResult = vaResult;
    }
    return true;
}

void CMyActiveXCtrl::LoadParameter(void)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    m_OutputParameter = m_InputParameter;
    // Fire an event to notify web page
    FireParameterLoaded();
    CString strOnLoaded("OnLoaded");
    this->CallJScript(strOnLoaded);
}

function OnLoaded()
{
    alert("phinecos");
}

class ICallBack
{
public:
    virtual void OnSuccesful() = 0;//操作成功
    virtual void OnFailed() = 0;//操作失败
};

class CMyThread
{
public:
    CMyThread()
    { 
        m_pThreadFunction = CMyThread::EntryPoint;
        m_runthread = FALSE;
    }
    virtual ~CMyThread()
    {
        if ( m_hThread )
            Stop(true);                    //thread still running, so force the thread to stop!
    }
    DWORD Start(DWORD dwCreationFlags = 0)
    {
        m_runthread = true;
        m_hThread = CreateThread(NULL, 0, m_pThreadFunction, this, dwCreationFlags,&m_dwTID);
        m_dwExitCode = (DWORD)-1;
        return GetLastError();
    }
    /**//**
        * Stops the thread.
        *    
        * @param bForceKill        if true, the Thread is killed immediately
        */
    DWORD Stop ( bool bForceKill = false )
    {
        if ( m_hThread )
        {
            //尝试"温柔地"结束线程
            if (m_runthread == TRUE)
                m_runthread = FALSE;        //first, try to stop the thread nice
            GetExitCodeThread(m_hThread, &m_dwExitCode);
            if ( m_dwExitCode == STILL_ACTIVE && bForceKill )
            {//强制杀死线程
                TerminateThread(m_hThread, DWORD(-1));
                m_hThread = NULL;
            }
        }
        return m_dwExitCode;
    }
    /**//**
        * Stops the thread. first tell the thread to stop itself and wait for the thread to stop itself.
        * if timeout occurs and the thread hasn't stopped yet, then the thread is killed.
        * @param timeout    milliseconds to wait for the thread to stop itself
        */
    DWORD Stop ( WORD timeout )
    {
        Stop(false);
        WaitForSingleObject(m_hThread, timeout);//等待一段时间
        return Stop(true);
    }
    /**//**
        * suspends the thread. i.e. the thread is halted but not killed. To start a suspended thread call Resume().
        */
    DWORD Suspend()
    {//挂起线程
        return SuspendThread(m_hThread);
    }
    /**//** 
        * resumes the thread. this method starts a created and suspended thread again.
        */
    DWORD Resume()
    {//恢复线程
        return ResumeThread(m_hThread);
    }
    /**//**
        * sets the priority of the thread.
        * @param priority    the priority. see SetThreadPriority() in windows sdk for possible values.
        * @return true if successful
        */
    BOOL SetPriority(int priority)
    {//设置线程优先级
        return SetThreadPriority(m_hThread, priority);
    }
    /**//**
        * gets the current priority value of the thread.
        * @return the current priority value
        */
    int GetPriority()
    {//获取线程优先级
        return GetThreadPriority(m_hThread);
    }
    void SetICallBack(ICallBack* pCallBack)
    {
        this->pCallBack = pCallBack;
    }
protected:
    /**
        * 子类应该重写此方法，这个方法是实际的工作线程函数
        */
    virtual DWORD ThreadMethod() = 0;
private:

/**//**
        * DONT override this method.
        *
        * this method is the "function" used when creating the thread. it is static so that way
        * a pointer to it is available inside the class. this method calls then the virtual 
        * method of the parent class.
        */
    static DWORD WINAPI EntryPoint( LPVOID pArg)
    {
        CMyThread *pParent = reinterpret_cast<CMyThread*>(pArg);
        pParent->ThreadMethod();//多态性，调用子类的实际工作函数
        return 0;
    }
private:
    HANDLE    m_hThread;                    //线程句柄
    DWORD    m_dwTID;                    //线程ID
    LPVOID    m_pParent;                    //this pointer of the parent CThread object
    DWORD    m_dwExitCode;                //线程退出码
protected:
    LPTHREAD_START_ROUTINE    m_pThreadFunction;   //工作线程指针
    BOOL    m_runthread;                //线程是否继续运行的标志
    ICallBack* pCallBack; //主线程的回调函数接口
};

class CMyTaskThread :public CMyThread

DWORD CMyTaskThread::ThreadMethod()
{
    while(m_runthread)   
    {   
        this->pCallBack->OnSuccesful();//模拟操作成功，回调主线程
        Sleep(5000); //休息会再模拟   
    } 
    return 0;
}

    void CMyActiveXCtrl::OnSuccesful()
{//操作成功
        //FireParameterLoaded();
        CString strOnLoaded("OnLoaded");
        this->CallJScript(strOnLoaded);

}