Re: CHtmlView document.returnValue

On 21 May 2007 05:16:31 -0700, Francesco Vitale

<francesco.vit...@gmail.com> wrote:


Calling JavaScript from C++ it's not trivial, because - for what I
know - you have to do the job using COM/OLE.
ATL smart pointers like CComPtr and some MFC classes like
COleDispatchDriver may help a bit.

Here you can find some code that might be useful for you.
I tested it on my machine (using a test web page you can find after
the C++ function code) and it works.

It just calls a JavaScript function which returns a double value, and
then displays the value in MessageBox.

The basic idea is to get the IHTMLDocument2 interface from the
CHtmlView derived class (note that GetHtmlDocument() method returns an
IDispatch, so you have to QueryInterface from IDispatch to get the
IHTMLDocument2 interface).

Once you have the IHTMLDocument2 interface you can access the Script
engine (via IHTMLDocument2::get_Script method), and then "Invoke" the
JavaScript function using the classical Invoke mechanism of IDispatch
associated to Script engine.

The code follows:

<CODE language="C++">
void OnTestCallJavascript( CMyHtmlView * pHtmlView )
{
    // pHtmlView is a pointer to CHtmlView derived class

    //
    // Hungarian Notation here:
    //
    // sp : smart-pointer (CComPtr)
    //

    // COM operations return code
    HRESULT hr;

    //
    // Access the IHTMLDocument2 interface from the HTML view
    //

    // Get IDispatch for HTML Document from HTML view
    CComPtr< IDispatch > spDispatch = pHtmlView->GetHtmlDocument();

    // Get IHTMLDocument2 interface from the above IDispatch
    CComPtr< IHTMLDocument2 > spDocument;
    hr = spDispatch->QueryInterface(
           IID_IHTMLDocument2,
           (void **) &spDocument );
    if ( FAILED(hr) )
    {
        MessageBox( _T("Can't get IHTMLDocument2 interface."),
            _T("*** ERROR ***"),
            MB_OK|MB_ICONERROR );
        return;
    }

    //
    // Given the IHTMLDocument2, access the Script Engine
    //

    // Get script engine from HTML document
    CComPtr< IDispatch > spScript;
    hr = spDocument->get_Script( &spScript );
    if ( FAILED(hr) )
    {
        MessageBox( _T("Can't access the Script Engine."),
            _T("*** ERROR ***"),
            MB_OK|MB_ICONERROR );
        return;
    }

    //
    // Call the JavaScript function
    //

    //
    // In this example, the function name is "testReturnValue";
    // the function takes no argument, and
    // returns a double precision floating-point.
    //

    // Name of the function to call
    const CString strFunctionName = "testReturnValue";

    // Convert it to COM BSTR string
    CComBSTR bstrFunction( strFunctionName );

    // ID associated to function
    DISPID dispid = NULL;

    // Map the function name to its numerical ID
    hr = spScript->GetIDsOfNames(
        IID_NULL, // (reserved)
        &bstrFunction, // name to get ID of
        1, // only 1 name
        LOCALE_SYSTEM_DEFAULT, // default locale context
        &dispid // will return the ID associated
                                // to given name
    );
    if ( FAILED(hr) )
    {
        MessageBox( _T("Can't get the ID of function."),
            _T("*** ERROR ***"),
            MB_OK|MB_ICONERROR );
        return;

    }

    // Return value of the function (stored in OLE variant)
    COleVariant result;

    // This function takes no argument
    const BYTE noArgument[] = { '\0' };

    // Use the helper class to invoke the function
    COleDispatchDriver dispatchDriver(
        spScript, // Script Engine
        FALSE // Don't automatically release it
    );
    dispatchDriver.InvokeHelper(
        dispid, // Function ID
        DISPATCH_METHOD, // We're invoking a method
        VT_VARIANT, // Type of return value
        (void *) &result, // Where to store return value
        noArgument // Argument descriptions
    );
    // NOTE: InvokeHelper may throw exceptions on error...
    // So we could catch them here or in other context...
    // A different approach would be to use spScript->Invoke
    // and prepare DISPPARAMS structures, but is is a bit
    // more complicated...

    //
    // Convert the OLE variant value to C++ double,
    // and show it
    //

    double dResult = result.dblVal;
    CString msg;
    msg.Format( _T("Function returned: %g"), dResult );
    MessageBox( msg );

}

</CODE>

And this is the web page with JavaScript I used for test:

<CODE language="HTML">
<html>

  <head>

    <title>JavaScript called from C++</title>

    <script type="text/javascript">
    <!--
    function testReturnValue() {
      alert("testReturnValue called");
      return 3.1415;
    }
    // -->
    </script>

  </head>

  <body>

    <h1>Test JavaScript from C++</h1>

    <a href="#" onclick="testReturnValue();">Test function</a>

  </body>

</html>
</CODE>

MrAsm