Drawing complex ATL/ActiveX controls at designtime

This is the point where you get to problems because you can't put the drawing code into an extra function because it is not yours. So you have to call the default handler of the treecontrol. We can use this with ComCtl32.dll in Version 5.80. Earlier versions are able to do so, but not with all controls.

We draw the Windows to a Bitmap, so normally we only have to blit the Bitmap to the container device (this Bitmap is a member of the control). We only create a new bitmap, if the old one is invalid (properties change, size changes, ...)

Second Solution (a, ComCtl32.dll version >= 5.80)

In this version on ComCtl32.dll, you can call SendMessage(WM_PAINT, WPARAM(hdc), 0) and the window will draw to the given devicecontext. but be careful, it draws to (0 / 0), so you have to move the viewport (via SetViewportOrgEx) and the window won't draw the nonclientarea. This could be done by DrawEdge (for Borders).

If the control doesn't have a window, when the OnDraw is called (this must be designmode, where the OnDraw could be called through IViewObject, elsewhere there would be a window!). Now, we check if the bitmap must be recreated (variables m_bRecreateBitmap and m_sizeBmp). If not, we got the the Blitting part of the OnDraw function. if recreating is neccassary, we check, if the childwindows already exist (childs and "HiddenWindow"). If not, call CreateChildWindows(0) to create them. destroy the old bitmap create the new one (with the new size, located in di.prcBounds) calculate all offsets of the windows,like you create them on the control, so you can draw the windows to the correct position now draw all windows to their positions via ::SetWindowPos(..., rcThisChild, ...) ::SetViewportOrgEx(...) ::SendMessage(hwndChild, WM_PAINT, (WPARAM) hdc, 0) next, draw the nonclientarea of the windows, like borders, Scrollbars, ... ::SetViewportOrgEx(hdc, (0/0) of the control (save at start of OnDraw),...) ::DrawEdge(...) draw scrollbars as dummies (use FillRect and DrawEdge, there will be no arrows, but that doesn't matter!) Now, blit the Bitmap to the container device (di.hdcDraw).

Second Solution (b, ComCtl32.dll version < 5.80)

If you use an earlier version of ComCtl32.dll, it could be possible that this doesn't work. In this case, you need to show the HiddenWindow to Blit the clientrect to the bitmap. Then you can hide the window. This is a bit ugly, because a window jumps to the front and hides itself short time later (about fourth second, or a half).

If the control doesn't have a window, when the OnDraw is called (this must be designmode, where the OnDraw could be called through IViewObject, elsewhere there would be a window!). Now, we check if the bitmap must be recreated (variables m_bRecreateBitmap and m_sizeBmp). If not, we got the the Blitting part of the OnDraw function. if recreating is neccassary, we check, if the childwindows already exist (childs and "HiddenWindow"). If not, call CreateChildWindows(0) to create them. destroy the old bitmap create the new one (with the new size, located in di.prcBounds) show the "HiddenWindow" (via ::SetWindowPos(..., HWND_TOP; ..., ... | SWP_SHOWWINDOW)) call ::SetWindowPos for all clientwindows Call UpdateWindow(m_hHiddenWindow) to force repainting (including clientarea) BitBlt from the HiddenWindow to the local bitmap Hide the HiddenWindow Now, blit the Bitmap to the containerdevice (di.hdcDraw).

That's it, we have finished. Now the sourcecode for this class (I replaced nonsense by ..., the code is for solution 2 a):

To test this sourcecode, you only need to create a new MFC project with a dialog and put the new control on it. Then you see our new painting routines work. If you compile the project and start it, you see the normal painting routines.

DrawingDesignmodeObj.h

class ATL_NO_VTABLE CDesignTimePaintingObj : 
    public ...
{
public:

    /////////////////////////////////////////////////////////////////////////
    // ATL - Makros
    /////////////////////////////////////////////////////////////////////////

...

    /////////////////////////////////////////////////////////////////////////
    // protected functions and Members
    /////////////////////////////////////////////////////////////////////////
protected:
    // the contained control (a tree control)
    CContainedWindow m_wndTree;        // window - object

    // variable for the OnSize Messagehandler
    bool m_bInitialised;            // Indicates, that the Childwindows are created,
                                    // so we can size them

    // variables for designtimepainting
    HWND m_hHiddenWnd;                // handle of the "HiddenWindow"
    HBITMAP m_hBmp;                    // handle of the Bitmap used for faster painting
    bool m_bRecreateBitmap;            // indicates, wether the bitmap must be 
                                       // recreated or not
    SIZE m_sizeBmp;                    // size of the actual bitmap

    /////////////////////////////////////////////////////////////////////////
    // helperfunctions (declared in DesignTimePaintingObj.cpp)
    /////////////////////////////////////////////////////////////////////////
    void SizeViews();
    void FillTree(void);
    BOOL CreateChildWindows(HWND hParent);
    void CreateHiddenWindow();

    /////////////////////////////////////////////////////////////////////////
    // public functions and members
    /////////////////////////////////////////////////////////////////////////
public:
    /////////////////////////////////////////////////////////////////////////
    // standard functions (declared in DesignTimePaintingObj.cpp)
    /////////////////////////////////////////////////////////////////////////
    CDesignTimePaintingObj();
    ~CDesignTimePaintingObj();
    HRESULT OnDraw(ATL_DRAWINFO& di);
    virtual HWND Create(HWND hWndParent, RECT& rcPos, LPCTSTR szWindowName = NULL,
                        DWORD dwStyle = WS_CHILD | WS_VISIBLE, DWORD dwExStyle = 0,
                        UINT nID = 0);

    /////////////////////////////////////////////////////////////////////////
    // messagehandlers (declared in DesignTimePaintingObj.cpp)
    /////////////////////////////////////////////////////////////////////////
    LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
    LRESULT OnSetFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
};

DrawingDesignmodeObj.cpp

...

/////////////////////////////////////////////////////////////////////////
// standard functions
/////////////////////////////////////////////////////////////////////////

CDesignTimePaintingObj::CDesignTimePaintingObj() :    
                        m_wndTree(_T("SysTreeView32"), this, 1)
{
    // This is only initialising, nothig important
    ...
}

CDesignTimePaintingObj::~CDesignTimePaintingObj()
{
    // free all members
    ::DeleteObject(m_hBmp);
    ::DestroyWindow(m_hHiddenWnd);
}

// In the Create - function, we have to create the ContainedWindows via their
// Create - functions
HWND CDesignTimePaintingObj::Create(HWND hWndParent, RECT& rcPos, LPCTSTR szWindowName,
    DWORD dwStyle, DWORD dwExStyle, UINT nID)
{
    m_bInitialised = false;

    HWND hWnd = CWindowImpl<CDesignTimePaintingObj>::Create(hWndParent, rcPos,
        szWindowName, dwStyle, dwExStyle, nID);

    if(hWnd != NULL)
    {
        CreateChildWindows(hWnd);
    }

    m_bInitialised = true;
    SizeViews();

    return hWnd;
}

// This function does nothing, if the control was instantiated and created.
// But some containers instantiate controls
// without creating them, and they draw them through the interface IViewObject::Draw.
// So this is the interisting part of the project
HRESULT CDesignTimePaintingObj::OnDraw(ATL_DRAWINFO& di)
{
    RECT& rc = *(RECT*)di.prcBounds;

    // we are drawn throug IViewObject?
    if(m_hWnd == 0)
    {
        // was there a resize since the last painting?
        SIZE newSize = {abs(rc.right - rc.left), abs(rc.bottom - rc.top)};

        if((newSize.cx != m_sizeBmp.cx) || (newSize.cy != m_sizeBmp.cy))
        {
            m_bRecreateBitmap = true;
        }

        // should we recreate the Bitmap?
        if(m_bRecreateBitmap == true)
        {
            // First, create the Windows, so that they can draw themselves
            CreateChildWindows(0);

            if(m_hBmp != NULL)
            {
                ::DeleteObject(m_hBmp);
                m_hBmp = NULL;
            }

            m_bRecreateBitmap = false;
            m_sizeBmp.cx = newSize.cx;
            m_sizeBmp.cy = newSize.cy;

            // Create the Bitmap
            m_hBmp = ::CreateCompatibleBitmap(di.hdcDraw, m_sizeBmp.cx, m_sizeBmp.cy);
            if(m_hBmp == NULL)
            {
                m_bRecreateBitmap = true;
                return S_OK;
            }

            POINT pt;
            POINT poiOffset;

            // prepare painting the NonClientArea of the TreeView
            poiOffset.x = ::GetSystemMetrics(SM_CXEDGE) + 1;
            poiOffset.y = ::GetSystemMetrics(SM_CYEDGE) + 1;

            // Select the Bitmap as a drawing >Context
            HDC hBmpDC = ::CreateCompatibleDC(di.hdcDraw);
            HBITMAP hOldBmp = (HBITMAP) ::SelectObject(hBmpDC, m_hBmp);

            // Position the Windows in the Hidden one
            m_wndTree.SetWindowPos(HWND_TOP, &rc, SWP_NOZORDER);

            ::SetViewportOrgEx(hBmpDC, poiOffset.x, poiOffset.y, &pt);
            // force The temporary Window to Draw itself and copy it into the Bitmap
            m_wndTree.SendMessage(WM_PAINT, (WPARAM)hBmpDC, 0);

            ::SetViewportOrgEx(hBmpDC, pt.x, pt.y, NULL);
            ::DrawEdge(hBmpDC, &rc, EDGE_BUMP, BF_RECT);

            ::SelectObject(hBmpDC, hOldBmp);
            ::DeleteDC(hBmpDC);
        }

        // Copy the Bitmap to the Container
        HDC hBmpDC = ::CreateCompatibleDC(di.hdcDraw);
        HBITMAP hOldBmp = (HBITMAP) ::SelectObject(hBmpDC, m_hBmp);
        
        ::BitBlt(di.hdcDraw, rc.left, rc.top, m_sizeBmp.cx, m_sizeBmp.cy, hBmpDC, 0,
            0, SRCCOPY);
        ::SelectObject(hBmpDC, hOldBmp);
        ::DeleteDC(hBmpDC);
    }

    return S_OK;
}


/////////////////////////////////////////////////////////////////////////
// messagehandlers
/////////////////////////////////////////////////////////////////////////

// set the focus to the childwindow (the code was created by the wizard)
LRESULT CDesignTimePaintingObj::OnSetFocus(UINT uMsg, WPARAM wParam, LPARAM lParam,
    BOOL& bHandled)
{
    LRESULT lRes = CComControl<CDesignTimePaintingObj>::OnSetFocus(uMsg, wParam, lParam,
       bHandled);
    if (m_bInPlaceActive)
    {
        DoVerbUIActivate(&m_rcPos,  NULL);
        if(!IsChild(::GetFocus()))
            m_wndTree.SetFocus();
    }
    return lRes;
}

// nothing important
LRESULT CDesignTimePaintingObj::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam,
    BOOL& bHandled)
{
    UNUSEDPARAM(uMsg);
    UNUSEDPARAM(wParam);
    UNUSEDPARAM(lParam);
    UNUSEDPARAM(bHandled);

    SizeViews();
    return 0;
}


/////////////////////////////////////////////////////////////////////////
// helperfunctions
/////////////////////////////////////////////////////////////////////////

// Create the childwindow on the given window. If no window is specified by
// hParent (if it's NULL)
// we create our "HiddenWindow" and put the childs on this one.
BOOL CDesignTimePaintingObj::CreateChildWindows(HWND hParent)
{
    // should we create our "HiddenWindow"
    if(hParent == 0)
    {
        CreateHiddenWindow();
        hParent = m_hHiddenWnd;
    }

    // If the Windows already exist, only set a new parent
    if(m_wndTree.m_hWnd != NULL)
    {
        m_wndTree.SetParent(hParent);
    }
    else
    {
        RECT rc = {0,0,0,0};

        // only create the window
        UINT styles = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | TVS_HASLINES |
            TVS_HASBUTTONS | TVS_LINESATROOT | WS_BORDER;
        m_wndTree.Create(hParent, rc, NULL, styles,  WS_EX_CLIENTEDGE);

        // this is only for this example so you can see something
        FillTree();
    }
    return TRUE;
}

// Creates our HiddenWindow which acts as a parentwindow, which will never be seen.
void CDesignTimePaintingObj::CreateHiddenWindow()
{
    // if no HiddenWindow exists, create on
    if(m_hHiddenWnd == NULL)
    {
        long lStyle;

        m_hHiddenWnd = ::CreateWindow(_T("STATIC"), _T(" "), 0, 0, 0, 0, 0, 0, 0,
            0, NULL);
        
        // remove all Borders, captions and other nonsens
        lStyle = ::GetWindowLong(m_hHiddenWnd, GWL_STYLE);
        lStyle &= ~(WS_BORDER | WS_CAPTION);
        ::SetWindowLong(m_hHiddenWnd, GWL_STYLE, lStyle);
    }
}

// only resize the childwindows
void CDesignTimePaintingObj::SizeViews()
{
    if(m_bInitialised == true)
    {
        RECT rc;
        GetClientRect(&rc);

        m_wndTree.SetWindowPos(HWND_TOP, &rc, SWP_NOZORDER | SWP_DRAWFRAME);
    }
}

// I put some items in the tree, so you can see something, not important
void CDesignTimePaintingObj::FillTree()
{
    ...(putting stuff in the tree here)...
}

I think it will be no problem to put more windows on the controls, you only have to draw more windows in the OnDraw.

Have much fun
Gerolf