Implementing IDocHostUIHandler in a C++ WTL/ATL project

Ryan Ginstrom — Tue, 17 Nov 2009 22:41:13 +0000

I recently implemented IDocHostUIHandler in one of my WTL projects hosting the web browser. You need to implement this interface if you want to do things like control the context menu of the web browser.

I had to go spelunking in various forums and documentation to piece together how to do this, and I never found the complete story online, so I thought I'd save any future searchers some trouble. I only did this in Visual Studio 2008, but I've done similar things in VS 2005, so it should work there also.

You should already have a WTL project with an .idl file that implements a COM server. If not, create a new WTL project with the wizard named "MyProject", and choose the option to make it a COM server.

Add an ATL Simple Object

Next, add a new class to your project, and select the type "ATL Simple Object."

Here's where you might hit your first snag. You might see the following error dialog:

ATL classes can only be added to MFC EXE and MFC Regular DLL projects or projects with full ATL support

"I'm using the ATL, you idiot!" you yell vainly at your computer screen. But alas, the compiler gods did not consider that you might want to use something as esoteric as the WTL for your GUI project, when you have the obviously superior choice of MFC.

To convince Visual Studio that yes, you do deserve to add an ATL Simple Object to your project, you've got to modify the file "VS Root/VC/VCWizards/1033/common.js". Specifically, you've got to have the function IsATLProject return true.

On the Internet, you'll see all sorts of fixes to this function, but I just cut to the chase:

function IsATLProject(oProj)
{
// I promise that I will use this only for good and not evil.
return true ;
try
{
…

Try adding the object again; this time, you should be successful. Name your class something descriptive, like "MyHandler" ( ), and accept all the defaults.

Modify the .idl file

Now go into your .idl file, and make some edits. First, import "atliface.idl", and #include "olectl.h". The top of your file should now look like this:

import "oaidl.idl";
import "ocidl.idl";
import "atliface.idl";

#include "olectl.h"

Now, go to your IMyHandler interface, and change the base class from IDispatch to IDocHostUIHandlerDispatch, like so:

[
object,
uuid(12345678-1234-1234-1234-123456789ABC),
dual,
nonextensible,
helpstring("IMyHandler Interface"),
pointer_default(unique)
]
interface IMyHandler : IDocHostUIHandlerDispatch{
};

Modify your MyHandler.h file

Go into your CMyHandler class file, and #include "Atliface.h". Next, add an entry to your COM map for IDocHostUIHandlerDispatch. The top of your file should now look something like this:

#pragma once
#include "resource.h" // main symbols
#include "Atliface.h"
#include "MyProject.h"

#if defined(_WIN32_WCE) && !defined(_CE_DCOM) && !defined(_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA)
#error "Blah blah blah"
#endif

// CMyHandler

class ATL_NO_VTABLE CMyHandler :
public CComObjectRootEx,
public CComCoClass,
public IDispatchImpl/*wMajor =*/ 1, /*wMinor =*/ 0>
{
public:

CMyHandler()
{
}

DECLARE_REGISTRY_RESOURCEID(IDR_MYHANDLER)

BEGIN_COM_MAP(CMyHandler)
COM_INTERFACE_ENTRY(IMyHandler)
COM_INTERFACE_ENTRY(IDocHostUIHandlerDispatch)
COM_INTERFACE_ENTRY(IDispatch)
END_COM_MAP()

Add skeletons for the IDocHostUIHandler methods

Add skeletons for all the methods implemented by IDocHostUIHandler. You can simply copy and paste the method signatures from IDocHostUIHandlerDispatch in "Atliface.h". Now implement the method bodies so that they all return E_NOTIMPL.

Compile your code

Now compile, and make sure that everything's working.

Here's where you might hit another snag: by failing to show proper respect to the compiler gods above, you could see an obscure MIDL error when you try to compile. Even if you don't, I recommend compiling your .idl file manually just to be sure. Go to All Programs >> Visual Studio 200X >> Visual Studio Tools >> Command Prompt (this loads the command prompt with all your VS symbols defined).

Next, navigate to your source directory, and compile your .idl file:

midl MyProject.idl

Implement methods of interest

Now, you can implement the methods you're interested in. For example, if you want to suppress the context menu, or show your own menu in its place:

HRESULT STDMETHODCALLTYPE ShowContextMenu(DWORD dwID, DWORD x, DWORD y, IUnknown *pcmdtReserved, IDispatch *pdispReserved, HRESULT *dwRetVal )
{
*dwRetVal = S_OK;
// Show your own context menu here if you want.
return S_OK;
}

Set the handler in your web browser

In your OnCreate handler, set your handler in the web browser.

CComObject *pUIH = NULL;
HRESULT hr = CComObject::CreateInstance (&pUIH);
if (SUCCEEDED(hr))
{
// Make our custom DocHostUIHandler the window.external handler
CComQIPtr pIUIH = pUIH;
hr = m_view.SetExternalUIHandler(pIUIH) ;
}
ATLASSERT(SUCCEEDED(hr)) ;

That's it. Compile and run.

Coming from C++/Java to Python should bend your mind

Ryan Ginstrom — Tue, 03 Feb 2009 02:30:38 +0000

Coming from C++ or Java to Python should bend your mind. If it doesn't, then you haven't learned Python yet — you're just writing C++ or Java in Python.

If you only knew a statically typed and compiled language like C++ or Java before, and learning Python hasn't changed the way you think about programming, then check your programs for lots of type-checking code, inheritance, array indexing, and mutable variables. Look at some excellent Python code, and identify where your code diverges from it.

The GITS Blog » c++