IE Desk Band with own GUI Thread - problem with Accelerator Messages

I have created a Desk Band (IE Explorer Bar) as an instance of
XTExplorerBar. The main window is XTMainFrame which is derived from
CFrameWindowImp<XTMainFrame>. As long as my Desk Band, which
implements IObjectWithSiteImpl, IInputObject and IDeskBand, is derived
from XTMainWindow everything works fine, especialy receiving
accelerator messages makes no problem. When XTMainframe receives the
focus, I call m_pSite->OnFocusChangeIS((IInputObject*)this, TRUE) and
TranslateAcceleratorIO(...) is called.
But now I have the following problem. In the above scenario
XTMainFrame runs in the message loop of the hosting site, in my case
this is Internet Explorer. Due to the fact that I have a very time
consuming GUI within XTMainFrame which is updated 25 times per second,
every time when IE is downloading content, my GUI is blocked. So I
decided to create an own GUI thread in which XTMainFrame is running.
Everything works fine (until now) exept accelerators. When XTMainFrame
receives the focus I also call m_pExplorerBar->m_pSite-


the exception: iexplore.exe: 0xC0000005: Access violation reading
location ... I have debugged and found out that the
call ::CallWindowProc(m_pfnSuperWindowProc within DefWindowProc(...)
causes the problem. It is clear to me that OnFocusChangeIS expects the
object which receives the focus. That is not the desk band
(m_pExplorerBar) but XTMainFrame. I have implemented IUnknown within
XTMainFrame and tried to to call OnFocusChangeIS with an instance of
XTMainFrame, but the exception stays the same. I'm sure that the
problem has to do with the threading model of COM, but I have realy no
idea how to solve it. Attached is the code of XTExplorerBar and
XTMainFrame.

#pragma once

#include "resource.h"
#include "XoohmCOM_i.h"

#include <shlguid.h>
#include <shlobj.h>
#include <comdef.h>
#include <comutil.h>

class XTMainFrame;

#if defined(_WIN32_WCE) && !defined(_CE_DCOM) && !
defined(_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA)
#error "Single-threaded COM objects are not properly supported on
Windows CE platform, such as the Windows Mobile platforms that do not
include full DCOM support. Define
_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA to force ATL to support
creating single-thread COM object's and allow use of it's single-
threaded COM object implementations. The threading model in your rgs
file was set to 'Free' as that is the only threading model supported
in non DCOM Windows CE platforms."
#endif

class ATL_NO_VTABLE XTExplorerBar :
    public CComObjectRootEx<CComSingleThreadModel>,
    public CComCoClass<XTExplorerBar, &CLSID_XTExplorerBar>,
    public IObjectWithSiteImpl<XTExplorerBar>,
    public IPersistStreamInitImpl<XTExplorerBar>,
    public IInputObject,
    public IDeskBand,
    public IDispatchImpl<IXTExplorerBar, &IID_IXTExplorerBar,
&LIBID_XoohmCOMLib, /*wMajor =*/ 1, /*wMinor =*/ 0>
{
public:
    XTExplorerBar();
    ~XTExplorerBar();

    DECLARE_REGISTRY_RESOURCEID(IDR_XTEXPLORERBAR)

    DECLARE_NOT_AGGREGATABLE(XTExplorerBar)

    BEGIN_COM_MAP(XTExplorerBar)
        COM_INTERFACE_ENTRY(IXTExplorerBar)
        COM_INTERFACE_ENTRY(IDispatch)
        COM_INTERFACE_ENTRY(IObjectWithSite)
        COM_INTERFACE_ENTRY(IOleWindow)
        COM_INTERFACE_ENTRY(IInputObject)
        COM_INTERFACE_ENTRY_IID(IID_IDockingWindow, IDeskBand)
        COM_INTERFACE_ENTRY_IID(IID_IDeskBand, IDeskBand)
    END_COM_MAP()

    BEGIN_CATEGORY_MAP(XTExplorerBar)
    END_CATEGORY_MAP()

    BEGIN_PROP_MAP(XTExplorerBar)
    END_PROP_MAP()

    BEGIN_MSG_MAP(XTExplorerBar)
    END_MSG_MAP()

    DECLARE_PROTECT_FINAL_CONSTRUCT()

    HRESULT FinalConstruct()
    {
        return S_OK;
    }

    void FinalRelease()
    {
    }

public:
    STDMETHOD(GetSite)(REFIID riid, void **ppvSite);
    STDMETHOD(SetSite)(IUnknown *pUnkSite);

    STDMETHOD(GetWindow)(HWND* phwnd);
    STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode);

    STDMETHOD(ShowDW)(BOOL bShow);
    STDMETHOD(CloseDW)(DWORD dwReserved);
    STDMETHOD(ResizeBorderDW)(LPCRECT prcBorder, IUnknown
*punkToolbarSite, BOOL fReserved);

    STDMETHOD(GetBandInfo)(DWORD dwBandID, DWORD dwViewMode,
DESKBANDINFO* pdbi);

    STDMETHOD(UIActivateIO)(BOOL fActivate, MSG* pMsg);
    STDMETHOD(HasFocusIO)();
    STDMETHOD(TranslateAcceleratorIO)(LPMSG lpMsg);

    void FocusChange(BOOL bFocus);

protected:
    void CreateFrame();

private:
    static DWORD WINAPI RunThread(LPVOID pParam);
    void CreateMainFrame();

public:
    BOOL m_bRequiresSave;

private:
    ULONG_PTR m_gdiplusToken;

    IInputObjectSite* m_pSite;
    HWND m_hWndParent;
    HWND m_hWndMainFrame;
    BOOL m_bFocus;
    HACCEL m_hAccel;
    DESKBANDINFO m_dbi;

    HANDLE m_hMainFrameThread;
    HANDLE m_hMainFrameCreatedEvent;

    XTMainFrame* m_pMainFrame;
};

OBJECT_ENTRY_AUTO(__uuidof(XTExplorerBar), XTExplorerBar)

#include "stdafx.h"
#include "XTExplorerBar.h"

#include "XTMainFrame.h"

#define MIN_SIZE_X 100
#define MIN_SIZE_Y 100

XTExplorerBar::XTExplorerBar()
{
    GdiplusStartupInput gdiplusStartupInput;
    ::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL);

    m_pSite = NULL;
    m_hWndParent = NULL;
    m_hWndMainFrame = NULL;
    m_bFocus = FALSE;
    m_hAccel = ::LoadAccelerators(_AtlBaseModule.GetResourceInstance(),
MAKEINTRESOURCE(IDR_MAINFRAME));

    ::memset(&m_dbi, 0, sizeof DESKBANDINFO);

    m_dbi.ptMinSize.x = MIN_SIZE_X;
    m_dbi.ptMinSize.y = MIN_SIZE_Y;
    m_dbi.ptMaxSize.x = -1;
    m_dbi.ptMaxSize.y = -1;
    m_dbi.ptIntegral.x = 1;
    m_dbi.ptIntegral.y = 1;
    m_dbi.dwModeFlags = DBIMF_NORMAL | DBIMF_VARIABLEHEIGHT;

    ::lstrcpyW(m_dbi.wszTitle, _T("Xoohm ATL"));

    m_hMainFrameThread = NULL;
    m_hMainFrameCreatedEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
}

XTExplorerBar::~XTExplorerBar()
{
    ::CloseHandle(m_hMainFrameCreatedEvent);

    ::GdiplusShutdown(m_gdiplusToken);
}

STDMETHODIMP XTExplorerBar::GetSite(REFIID riid, void **ppvSite)
{
    *ppvSite = NULL;

    if (m_pSite)
        return m_pSite->QueryInterface(riid, ppvSite);

    return E_FAIL;
}

STDMETHODIMP XTExplorerBar::SetSite(IUnknown *pUnkSite)
{
    if (m_pSite)
    {
        m_pSite->Release();
        m_pSite = NULL;
    }

    if (pUnkSite)
    {
        IOleWindow *pOleWindow = NULL;

        m_hWndParent = NULL;

        if(SUCCEEDED(pUnkSite->QueryInterface(IID_IOleWindow,
(LPVOID*)&pOleWindow)))
        {
            pOleWindow->GetWindow(&m_hWndParent);
            pOleWindow->Release();
        }

        if (!m_hWndParent)
            return E_FAIL;

        CreateMainFrame();

        if (SUCCEEDED(pUnkSite->QueryInterface(IID_IInputObjectSite,
(LPVOID*)&m_pSite)))
            return S_OK;

        return E_FAIL;
    }
    else
    {
        while (::MsgWaitForMultipleObjects(1, &m_hMainFrameThread, FALSE,
INFINITE, QS_ALLINPUT) == WAIT_OBJECT_0 + 1)
        {
            MSG msg;

            if (::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
            {
                ::TranslateMessage(&msg);
                ::DispatchMessage(&msg);
            }
        }
    }

    return S_OK;
}

STDMETHODIMP XTExplorerBar::GetWindow(HWND* phwnd)
{
    *phwnd = m_hWndMainFrame;
    return S_OK;
}

STDMETHODIMP XTExplorerBar::ContextSensitiveHelp(BOOL fEnterMode)
{
    return E_NOTIMPL;
}

STDMETHODIMP XTExplorerBar::ShowDW(BOOL bShow)
{
    ::ShowWindow(m_hWndMainFrame, bShow ? SW_SHOW : SW_HIDE);

    return S_OK;
}

STDMETHODIMP XTExplorerBar::CloseDW(DWORD dwReserved)
{
    ShowDW(FALSE);

    if (::IsWindow(m_hWndMainFrame))
        ::DestroyWindow(m_hWndMainFrame);

    return S_OK;
}

STDMETHODIMP XTExplorerBar::ResizeBorderDW(LPCRECT prcBorder, IUnknown
*punkToolbarSite, BOOL fReserved)
{
    return E_NOTIMPL;
}

STDMETHODIMP XTExplorerBar::GetBandInfo(DWORD dwBandID, DWORD
dwViewMode, DESKBANDINFO* pdbi)
{
    if (pdbi)
    {
        if (pdbi->dwMask & DBIM_MINSIZE)
        {
            pdbi->ptMinSize.x = m_dbi.ptMinSize.x;
            pdbi->ptMinSize.y = m_dbi.ptMinSize.y;
        }

        if (pdbi->dwMask & DBIM_MAXSIZE)
        {
            pdbi->ptMaxSize.x = m_dbi.ptMaxSize.x;
            pdbi->ptMaxSize.y = m_dbi.ptMaxSize.y;
        }

        if (pdbi->dwMask & DBIM_INTEGRAL)
        {
            pdbi->ptIntegral.x = m_dbi.ptIntegral.x;
            pdbi->ptIntegral.y = m_dbi.ptIntegral.y;
        }

        if (pdbi->dwMask & DBIM_ACTUAL)
        {
            pdbi->ptActual.x = m_dbi.ptActual.x;
            pdbi->ptActual.y = m_dbi.ptActual.y;
        }

        if (pdbi->dwMask & DBIM_TITLE)
        {
            ::lstrcpyW(pdbi->wszTitle, m_dbi.wszTitle);
        }

        if (pdbi->dwMask & DBIM_MODEFLAGS)
        {
            pdbi->dwModeFlags = m_dbi.dwModeFlags;
        }

        if (pdbi->dwMask & DBIM_BKCOLOR)
        {
            pdbi->crBkgnd = m_dbi.crBkgnd;
        }

        return S_OK;
    }

    return E_INVALIDARG;
}

STDMETHODIMP XTExplorerBar::UIActivateIO(BOOL fActivate, MSG* pMsg)
{
    if (fActivate)
        ::SetFocus(m_hWndMainFrame);

    return S_OK;
}

STDMETHODIMP XTExplorerBar::HasFocusIO()
{
    if (m_bFocus)
        return S_OK;

    return S_FALSE;
}

void XTExplorerBar::FocusChange(BOOL bFocus)
{
    m_bFocus = bFocus;

    if (m_pSite)
        m_pSite->OnFocusChangeIS((IDockingWindow*)this, bFocus);
}

STDMETHODIMP XTExplorerBar::TranslateAcceleratorIO(LPMSG lpMsg)
{
    if (lpMsg->message >= WM_KEYFIRST && lpMsg->message <= WM_KEYLAST)
    {
        if (m_hAccel)
        {
            if (m_hWndMainFrame && ::TranslateAccelerator(m_hWndMainFrame,
m_hAccel, lpMsg))
                return S_OK;
        }
    }

    return S_FALSE;
}

DWORD WINAPI XTExplorerBar::RunThread(LPVOID pParam)
{
    XTExplorerBar* pThis = reinterpret_cast<XTExplorerBar*>(pParam);

    CMessageLoop theLoop;
    pThis->m_pMainFrame = new XTMainFrame(pThis);

    RECT rect;
    ::GetClientRect(pThis->m_hWndParent, &rect);

    if (pThis->m_pMainFrame->CreateEx(pThis->m_hWndParent, rect, WS_CHILD
| WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS) == NULL)
    {
        ::SetEvent(pThis->m_hMainFrameCreatedEvent);
        return 0;
    }

    pThis->m_hWndMainFrame = pThis->m_pMainFrame->m_hWnd;
    ::SetEvent(pThis->m_hMainFrameCreatedEvent);

    int nRet = theLoop.Run();

    SAFE_DELETE(pThis->m_pMainFrame);

    return nRet;
}

void XTExplorerBar::CreateMainFrame()
{
    DWORD dwThreadId;
    m_hMainFrameThread = ::CreateThread(NULL, 0, RunThread, this, 0,
&dwThreadId);

    while (::MsgWaitForMultipleObjects(1, &m_hMainFrameCreatedEvent,
FALSE, INFINITE, QS_ALLINPUT) == WAIT_OBJECT_0 + 1)
    {
        MSG msg;

        if (::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            ::TranslateMessage(&msg);
            ::DispatchMessage(&msg);
        }
    }
}

#pragma once

class XTExplorerBar;

#include "XTCommandBarCtrl.h"
#include "XTToolBarAdapter.h"

#include "XTGraphWnd.h"
#include "XTGraphHandler.h"

class XTMainFrame :
    public CFrameWindowImpl<XTMainFrame>,
    public CUpdateUI<XTMainFrame>,
    public XTToolBarAdapter<XTMainFrame>,
    public IUnknown
{
public:
    DECLARE_FRAME_WND_CLASS(_T("Ernst"), IDR_MAINFRAME)

public:
    XTMainFrame(XTExplorerBar* pExplorerBar);
    ~XTMainFrame();

public:
    BEGIN_UPDATE_UI_MAP(XTMainFrame)
        UPDATE_ELEMENT(ID_VIEW_TOOLBAR, UPDUI_MENUPOPUP)
    END_UPDATE_UI_MAP()

    BEGIN_MSG_MAP(XTMainFrame)
        MESSAGE_HANDLER(WM_CREATE, OnCreate)
        MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBkgnd)
        MESSAGE_HANDLER(WM_KILLFOCUS, OnKillFocus)
        MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
        MESSAGE_HANDLER(WM_MOUSEACTIVATE, OnMouseActivate)
        MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
        COMMAND_ID_HANDLER(ID_FILE_NEW, OnFileNew)
        COMMAND_ID_HANDLER(ID_NEW_FILE, OnNewThing)
        COMMAND_ID_HANDLER(ID_NEW_DOCUMENT, OnNewThing)
        COMMAND_ID_HANDLER(ID_EDIT_CUT, OnEditCut)
        CHAIN_MSG_MAP(CUpdateUI<XTMainFrame>)
        CHAIN_MSG_MAP(CFrameWindowImpl<XTMainFrame>)
        CHAIN_MSG_MAP(XTToolBarAdapter<XTMainFrame>)
    END_MSG_MAP()

public:
    XTExplorerBar* m_pExplorerBar;

    CCommandBarCtrl m_cmdBar;
    CComboBox m_wndCombo;

    XTGraphWnd m_graphWnd;
    XTGraphHandler* m_pGraphHandler;

public:
    void OnToolBarCombo(HWND hWndCombo, UINT nID, int nSel, LPCTSTR
lpszText, DWORD dwItemData);
    virtual void PrepareToolBarMenu(UINT nMenuID, HMENU hMenu);

private:
    LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&
bHandled);
    LRESULT OnEraseBkgnd(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&
bHandled);
    LRESULT OnKillFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&
bHandled);
    LRESULT OnSetFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&
bHandled);
    LRESULT OnMouseActivate(UINT uMsg, WPARAM wParam, LPARAM lParam,
BOOL& bHandled);
    LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&
bHandled);
    LRESULT OnFileNew(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL&
bHandled);
    LRESULT OnNewThing(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL&
bHandled);
    LRESULT OnEditCut(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL&
bHandled);

public:
    STDMETHOD(QueryInterface)(REFIID refiid, void FAR* FAR* ppvObject)
    {
        *ppvObject = ( refiid == IID_IUnknown) ? this : NULL;

        if ( *ppvObject != NULL )
            ( (LPUNKNOWN)*ppvObject )->AddRef();

        return *ppvObject == NULL ? E_NOINTERFACE : S_OK;
    }

    STDMETHOD_(ULONG, AddRef)( void )
    {
        return ++m_nRefCount;
    }

    STDMETHOD_(ULONG, Release)( void )
    {
        int nRefCount = --m_nRefCount;

        if (nRefCount == 0 )
            delete this;

        return nRefCount;
    }

    LONG m_nRefCount;
};

#include "stdafx.h"
#include "resource.h"

#include "XoohmCOM_i.h"
#include "dllmain.h"

#include "XTMainFrame.h"

#include "XTExplorerBar.h"

XTMainFrame::XTMainFrame(XTExplorerBar* pExplorerBar)
{
    m_pExplorerBar = pExplorerBar;

    m_pGraphHandler = NULL;
}

XTMainFrame::~XTMainFrame()
{
    SAFE_DELETE(m_pGraphHandler);
}

LRESULT XTMainFrame::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam,
BOOL& bHandled)
{
    HWND hWndCmdBar = m_cmdBar.Create(m_hWnd, rcDefault, NULL,
ATL_SIMPLE_CMDBAR_PANE_STYLE);

    m_cmdBar.m_wndParent.UnsubclassWindow();
    m_cmdBar.m_wndParent.SubclassWindow(m_hWnd);

    m_cmdBar.AttachMenu(GetMenu());
    m_cmdBar.LoadImages(IDR_MAINFRAME);
    m_cmdBar.LoadImages(IDR_MENU_IMAGES);
    SetMenu(NULL);

    HWND hWndToolBar = CreateSimpleToolBarCtrl(m_hWnd, IDR_MAINFRAME,
FALSE, ATL_SIMPLE_TOOLBAR_PANE_STYLE_EX);

    AddToolBarDropDownMenu(hWndToolBar, ID_FILE_NEW, IDR_NEW);

    AddToolbarButtonText(hWndToolBar, ID_FILE_SAVE);

    AddToolbarButtonText(hWndToolBar, ID_EDIT_PASTE, _T("Paste"));
    AddToolBarDropDownMenu(hWndToolBar, ID_EDIT_PASTE, IDR_COLOR,
BTNS_WHOLEDROPDOWN);

    AddToolbarButtonText(hWndToolBar, ID_VIEW_COLOR, _T("Color"));
    AddToolBarDropDownMenu(hWndToolBar, ID_VIEW_COLOR, IDR_COLOR);

    AddToolbarButtonText(hWndToolBar, ID_APP_ABOUT, _T("About"));

    CreateSimpleReBar(ATL_SIMPLE_REBAR_NOBORDER_STYLE);
    AddSimpleReBarBand(hWndCmdBar);
    AddSimpleReBarBand(hWndToolBar, NULL, TRUE);

    m_hWndClient = m_graphWnd.Create(m_hWnd, rcDefault, NULL, WS_CHILD |
WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);

    UIAddToolBar(hWndToolBar);
    UISetCheck(ID_VIEW_TOOLBAR, 1);

    m_pGraphHandler = new XTGraphHandler(&m_graphWnd);

    return 0;
}

LRESULT XTMainFrame::OnEraseBkgnd(UINT uMsg, WPARAM wParam, LPARAM
lParam, BOOL& bHandled)
{
    bHandled = TRUE;
    return 0;
}

LRESULT XTMainFrame::OnKillFocus(UINT uMsg, WPARAM wParam, LPARAM
lParam, BOOL& bHandled)
{
    m_pExplorerBar->FocusChange(FALSE);

    return 1;
}

LRESULT XTMainFrame::OnSetFocus(UINT uMsg, WPARAM wParam, LPARAM
lParam, BOOL& bHandled)
{
    m_pExplorerBar->FocusChange(TRUE);

    return 0;
}

LRESULT XTMainFrame::OnMouseActivate(UINT uMsg, WPARAM wParam, LPARAM
lParam, BOOL& bHandled)
{
    SetFocus();

    return 1;
}

LRESULT XTMainFrame::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM
lParam, BOOL& bHandled)
{
    m_pGraphHandler->Shutdown();

    bHandled = FALSE;
    return 1;
}

LRESULT XTMainFrame::OnFileNew(WORD wNotifyCode, WORD wID, HWND
hWndCtl, BOOL& bHandled)
{
    AtlMessageBox(*this, _T("New File from Menu & Toolbar"),
IDR_MAINFRAME);
    return 0;
}

LRESULT XTMainFrame::OnEditCut(WORD wNotifyCode, WORD wID, HWND
hWndCtl, BOOL& bHandled)
{
    AtlMessageBox(*this, _T("Edit Cut"), IDR_MAINFRAME);
    return 0;
}

void XTMainFrame::OnToolBarCombo(HWND hWndCombo, UINT nID, int nSel,
LPCTSTR lpszText, DWORD dwItemData)
{
    if (nID == ID_COMBO_PLACEHOLDER)
    {
    }

    AtlMessageBox(*this, lpszText, IDR_MAINFRAME);
}

void XTMainFrame::PrepareToolBarMenu(UINT nMenuID, HMENU hMenu)
{
    if (nMenuID == IDR_NEW)
    {
        CMenuHandle menu(hMenu);
        menu.AppendMenu(MF_SEPARATOR);
        menu.AppendMenu(MF_STRING, ID_NEW_DOCUMENT, _T("Document..."));
        menu.AppendMenu(MF_STRING, ID_NEW_TEMPLATE, _T("Template..."));
    }
}

LRESULT XTMainFrame::OnNewThing(WORD wNotifyCode, WORD wID, HWND
hWndCtl, BOOL& bHandled)
{
    switch (wID)
    {
    case ID_NEW_FILE:
        AtlMessageBox(*this, _T("New File"), IDR_MAINFRAME);
        break;
    case ID_NEW_DOCUMENT:
        AtlMessageBox(*this, _T("New Document"), IDR_MAINFRAME);
        break;
    case ID_NEW_TEMPLATE:
        AtlMessageBox(*this, _T("New Template"), IDR_MAINFRAME);
        break;
    }

    return 0;
}

Thanks for any help

Ernst