How to add support for hosing VBScript to your MFC application


You can add VBA-like scripting capability to your MFC application with little overhead that uses Microsoft ActiveX Scripting technologies. This article demonstrates how to create a new MFC application, or modify an existing one, that incorporates support for VBScript.

More Information

Follow the steps below to build and run the example:
  1. Create a new MFC dialog-based application, or use an application you already have to which you would like to add scripting support.
  2. Add an edit box and button to your dialog, and enable the "Want return" and "Multiline" styles in the properties for the edit box.
  3. Use ClassWizard (CTRL-W), under the Member Variables tab, to associate IDC_EDIT1 with a member variable of type CEdit named m_edit1.
  4. Use ClassWizard to create a new class called MyScriptObject, derived from CCmdTarget, with support for Automation. Click OK if you see a warning about an ODL file.
  5. Under the Automation tab in ClassWizard, select MyScriptObject, and add the following methods:

    long gcd(long a, long b);
    void HelpAbout();
    void ShowValue(LPCTSTR prompt, long n);
  6. Implement gcd, HelpAbout, and ShowValue as follows:
       long MyScriptObject::gcd(long a, long b) 
    int l, h, t;
    if(a < b) {
    l = a;
    h = b;
    else if(a > b) {
    l = b;
    h = a;
    else return a;

    while(h%l != 0) {
    t = l;
    l = (h%l);
    h = t;
    return l;

    void MyScriptObject::HelpAbout()
    AfxMessageBox("HelpAbout: My Script Object!", 0x10000);

    void MyScriptObject::ShowValue(LPCTSTR prompt, long n)
    CString str;
    str.Format("%s%d", prompt, n);
    AfxMessageBox(str, MB_SETFOREGROUND);
  7. Open MyScriptObject.h, and move the virtual destructor ~MyScriptObject from the protected section of the class to a public section.
  8. Double-click the dialog button to create a handler function for it, and implement it as follows:
       // Initialize our IActiveScriptSite implementation with your
    // script object's IUnknown interface...
    g_iActiveScriptSite.m_pUnkScriptObject =

    // Start inproc script engine, VBSCRIPT.DLL
    IID_IActiveScript, (void **)&m_iActiveScript),
    "CoCreateInstance() for CLSID_VBScript");

    // Get engine's IActiveScriptParse interface.
    (void **)&m_iActiveScriptParse),
    "QueryInterface() for IID_IActiveScriptParse");

    // Give engine our IActiveScriptSite interface...

    // Give the engine a chance to initialize itself...

    // Add a root-level item to the engine's name space...

    // Get script code...
    CString csScriptText;

    // Parse the code scriptlet...
    BSTR pParseText = csScriptText.AllocSysString();
    m_iActiveScriptParse->ParseScriptText(pParseText, L"MyObject", NULL,
    NULL, 0, 0, 0L, NULL, &ei);

    // Set the engine state. This line actually triggers the execution
    // of the script.

    // Release engine...
  9. Open your [projectname]Dlg.h file and add the following member variables to a public section of your class:
       MyScriptObject m_myScriptObject;
    IActiveScript *m_iActiveScript;
    IActiveScriptParse *m_iActiveScriptParse;
  10. Also in [projectname]Dlg.h, add the following #include statements, just before the declaration of your class:
       // Include ActiveX Script definitions...
    #include <activscp.h>
    // Include definition for MyScriptObject...
    #include "MyScriptObject.h"
  11. Add the following code to your [projectname]Dlg.cpp file, just before the implementation of your button handler:
    // Your IActiveScriptSite implementation...
    class MyActiveScriptSite : public IActiveScriptSite {
    ULONG m_dwRef; // Reference count
    IUnknown *m_pUnkScriptObject; // Pointer to your object that is exposed
    // to the script engine in GetItemInfo().

    MyActiveScriptSite::MyActiveScriptSite() {m_dwRef = 1;}
    MyActiveScriptSite::~MyActiveScriptSite() {}

    // IUnknown methods...
    virtual HRESULT _stdcall QueryInterface(REFIID riid, void **ppvObject) {
    *ppvObject = NULL;
    return E_NOTIMPL;
    virtual ULONG _stdcall AddRef(void) {
    return ++m_dwRef;
    virtual ULONG _stdcall Release(void) {
    if(--m_dwRef == 0) return 0;
    return m_dwRef;

    // IActiveScriptSite methods...
    virtual HRESULT _stdcall GetLCID(LCID *plcid) {
    return S_OK;

    virtual HRESULT _stdcall GetItemInfo(LPCOLESTR pstrName,
    DWORD dwReturnMask, IUnknown **ppunkItem, ITypeInfo **ppti) {

    // Is it expecting an ITypeInfo?
    if(ppti) {
    // Default to NULL.
    *ppti = NULL;

    // Return if asking about ITypeInfo...
    if(dwReturnMask & SCRIPTINFO_ITYPEINFO)

    // Is the engine passing an IUnknown buffer?
    if(ppunkItem) {
    // Default to NULL.
    *ppunkItem = NULL;

    // Is Script Engine looking for an IUnknown for our object?
    if(dwReturnMask & SCRIPTINFO_IUNKNOWN) {
    // Check for our object name...
    if (!_wcsicmp(L"MyObject", pstrName)) {
    // Provide our object.
    *ppunkItem = m_pUnkScriptObject;
    // Addref our object...

    return S_OK;

    virtual HRESULT __stdcall GetDocVersionString(BSTR *pbstrVersion) {
    return S_OK;

    virtual HRESULT __stdcall OnScriptTerminate(const VARIANT *pvarResult,
    const EXCEPINFO *pexcepInfo) {
    return S_OK;

    virtual HRESULT __stdcall OnStateChange(SCRIPTSTATE ssScriptState) {
    return S_OK;

    virtual HRESULT __stdcall OnScriptError(
    IActiveScriptError *pscriptError) {
    static BSTR pwcErrorText;

    CString("IActiveScriptSite::OnScriptError()\n") +
    CString("Line: ") +
    return S_OK;

    virtual HRESULT __stdcall OnEnterScript(void) {
    return S_OK;

    virtual HRESULT __stdcall OnLeaveScript(void) {
    return S_OK;

    // Global instance of our IActiveScriptSite implementation.
    MyActiveScriptSite g_iActiveScriptSite;

    // Script Engine CLSIDs...
    #include <initguid.h>
    DEFINE_GUID(CLSID_VBScript, 0xb54f3741, 0x5b07, 0x11cf, 0xa4, 0xb0, 0x0,
    0xaa, 0x0, 0x4a, 0x55, 0xe8);
    DEFINE_GUID(CLSID_JScript, 0xf414c260, 0x6ac0, 0x11cf, 0xb6, 0xd1, 0x00,
    0xaa, 0x00, 0xbb, 0xbb, 0x58);

    // Ole-initialization class.
    class OleInitClass {
    OleInitClass() {
    ~OleInitClass() {
    // This global class calls OleInitialize() at
    // application startup, and calls OleUninitialize()
    // at application exit...
    OleInitClass g_OleInitClass;

    void HRVERIFY(HRESULT hr, char * msg)
    if(FAILED(hr)) {
    CString str;
    str.Format("Error: 0x%08lx (%s)", hr, msg);
    AfxMessageBox(str, 0x10000);

  12. Compile and run.

After you build the project, run it, add the following VBScript to your application's edit box, then click the button:
   dim x
dim y
dim z
x = 101*199
y = 313*199
z = gcd(x, y)

ShowValue "gcd(" & x & ", " & y & ") = ", z


The basic work flow is as follows:
  1. You start the VBScript engine, vbscript.dll, and obtain IActiveScript and IActiveScriptParse interfaces.
  2. You give the VBScript engine your implementation of IActiveScriptSite, which the engine uses later to obtain and call to your objects.
  3. You add the objects that you implement and want to make available to scripts by calling IActiveScript::AddNamedItem().
  4. You provide the script text to execute through IActiveScriptParse::ParseScriptText(). Note that this doesn't actually run the script yet.
  5. The script engine will now call into your IActiveScriptSite::GetItemInfo() for any objects it doesn't recognize, to get their interface pointers.
  6. You call IActiveScript::SetScriptState() with SCRIPT_STATE_CONNECTED to run the script.
  7. The VBScript engine parses the text in the script for you and when it encounters a method call or property reference, it delegates the implementation to your provided interfaces.


For additional information about Microsoft ActiveX Script Hosting, please see the following articles in the Microsoft Knowledge Base:

183698 SAMPLE: AXSH.EXE Demonstrates Implementing ActiveX Script Hosts

168214 SAMPLE: MFCAxs.exe Implements an Active Script Host Using MFC


ID članka: 221992 - posljednja izmjena: 3. lip 2005. - verzija: 1

Povratne informacije