• Introduction
• Loading the DLL
• Creating a Browser Window
• Getting and Setting Properties
• Invoking Methods
• Handling Events

The C++ include file WebsterDllWrap.h defines a wrapper class named CWebsterProWrapper that is used to create the browser window, set and get properties, and call methods. The file also contains function templates for event handlers that you can optionally implement in your application, and it defines all of the constants and enumerations used by the Webster Pro. Include this file in your project.

#include "WebsterDllWrap.h"

CWebsterProWrapper m_WebsterPro1;

m_WebsterPro1.Create(WS_CHILD | WS_VISIBLE, 
                     left, top, right, bottom, 
                     GetSafeHwnd(), 
                     (DWORD) ((LPCTSTR) "0000000000"));

To destroy the browser object you can either call the Destroy() member function of CWebsterProWrapper or, if the CWebsterProWrapper was created with new then you can just delete it.

The browser object is built around a regular Windows window and you can get the HWND of that window with the GetHwnd() member function. Use this HWND in standard Windows API calls to set generic window characteristics, as in this WM_SIZE handler:

void CDillView::OnSize(UINT nType, int cx, int cy) 
{
   // Make sure that the Webster Pro window has been created:
   if (m_WebsterPro1.isCreated())
   {
      // Size the control to fill the view
      ::MoveWindow(m_WebsterPro1.GetHwnd(), 0, 0, cx, cy, TRUE);
   }

   // Chain to the base class:
   CView::OnSize(nType, cx, cy);
}

The argument to string property Set functions is a pointer to a string (char*) which can be temporary. For example, to set the PageURL property:

WebsterPro1.SetPageURL("http://www.someplace.com")

char* lpszPageUrl = WebsterPro1.GetPageURL();
//
// Do something with lpszPageUrl...
// ...
// Done with the string object, free it:
WebsterPro1.FreeObject(lpszPageUrl);

long GetProxyExclusionsHTTPCount();
char* GetProxyExclusionsHTTPItem(long index);
void SetProxyExclusionsHTTPItem(long index, LPCTSTR lpszItem);
void AddProxyExclusionsHTTPItem(LPCTSTR lpszItem);
long FindProxyExclusionsHTTPItem(LPCTSTR lpszItem);
void RemoveProxyExclusionsHTTPItem(long index);
void RemoveAllProxyExclusionsHTTPItems();

for (int index = 0; 
         index < WebsterPro1.GetProxyExclusionsHTTPCount(); 
         index++)
{
   // Get the next proxy server name in the collection:
   char* lpszProxy = GetProxyExclusionsHTTPItem(long index);

   // Do something with lpszProxy...
   //...

   // Done with the string object, free it:
   WebsterPro1.FreeObject(lpszProxy);
}

WebsterPro1.SetFontName(dispidFontNormal, "Arial");
WebsterPro1.SetFontSize(dispidFontNormal, 10);

To handle an event, you implement an event handler function in your application and then specify the address of that function to the Webster Pro DLL at runtime. It is perfectly safe to completely ignore any event that you don't need to handle.

Steps for handling an event are:

1. Write an event handling function based on the event prototype in WebsterDllWrap.h. When a Webster Pro fires the corresponding event, it calls this function.

   The event handler prototypes specify extern "C" functions, so event handlers cannot be class member functions. You can use the hControl argument to identify the specific Webster Pro instance in the handler. This can be useful if you create multiple browser windows simultaneously, as in the following BeforeNavigate handler from an MDI application:

   DWORD  gfEventBeforeNavigate(HANDLE  hControl,
                                LPSTR*  plpszHyperlinkUrl,
                                DWORD   dwNavFlags,
                                DWORD   dwContextHandle,
                                LPSTR*  plpszTargetName,
                                LPSTR*  plpszTextToPost,
                                LPSTR*  plpszExtraHeaders,
                                DWORD*  pdwContainerCancel)
   {
      // A BeforeNavigate event was fired by the Webster Pro.
      // The specific window that fired the event is identified by
      // the hControl argument.
   
      // In this particular implementation, we assume that the 
      // Webster Pro is embedded in a CDillView object (derived from 
      // CView) and so is a child window of  the CDillView window.  
      // We call a BeforeNavigate handler in the parent CDillView 
      // of the object that fired the event.
      //
      CWnd* pDillView = CWnd::FromHandle(::GetParent((HWND) hControl));
   
      ASSERT(pDillView && pDillView->IsKindOf(RUNTIME_CLASS(CDillView)));
   
      // If we have obtained the parent DillView...
      if (pDillView && pDillView->IsKindOf(RUNTIME_CLASS(CDillView)))
      {
        // Convey the event to a handler in the specific DillView 
        // that hosts this Webster Pro window:
        ((CDillView*) pDillView)->eventBeforeNavigate(hControl,
                                                      plpszHyperlinkUrl,
                                                      dwNavFlags,
                                                      dwContextHandle,
                                                      plpszTargetName,
                                                      plpszTextToPost,
                                                      plpszExtraHeaders,
                                                      pdwContainerCancel);
      }
      return 0;
   }

2. Specify the address of your event handling function:

   m_WebsterPro1.SetEventHandlerAddress(eventidBeforeNavigate, 
                                        ::gfEventBeforeNavigate);

   To stop handling an event specify an address of NULL:

   m_WebsterPro1.SetEventHandlerAddress(eventidBeforeNavigate, NULL);

m_WebsterPro1.ReplaceObject(plpszHyperlinkUrl, 
                            stringNewUrl, stringNewUrl.GetLength());