Flat Toolbar (requires IE3+)

NOTE: You must also have new the COMCTL32.DLL (version 4.7 or later). This is installed with Internet Explorer 3 and will come standard with the new Windows 98. So if you are using VC++ 5 then you probably already have this DLL.

Here is a toolbar enhancement that gives you DevStudio-like toolbars.

These have a flat look with a "gripper" on the left hand side and separator lines between groups. As the mouse moves over the toolbar, the tools get a button created around them.

There are a number of issues that needed to be addressed here.

MFC uses the style bits that control the flat look for its own purposes. So you cannot set this style when creating the toolbar, but must modify the style afterwards. To do this, I have added a SetFlatLookStyle() function.

Flat look toolbars are painted transparently. Unfortunately, MFC has not been written with transparent toolbars in mind, so one needs to repaint the background. This is done on size and move messages, for example when draggin a docked toolbar. They are also done when the tool button's style changes. For example, when a button changes from pushed to released, the background needs to be repainted.

The toolbar control does not draw the separators between groups of toolbar buttons, but instead leaves a gap. The class intecepts the WM_PAINT method and adds separators at the correct position.

The toolbar control also does not support the gripper at the left or top end of the toolbar. The class adjusts the client area and draws the gripper approriately.

To use this class, simply change your use of CToolBar to CFlatToolBar and call the SetFlatLookStyle() function after creating the toolbar itself (ie. after toolbar bitmaps are loaded).

//***************************************************************
// FlatToolBar.h
// (c) 1997, Roger Onslow

#if !defined(__FLATTOOLBAR_H__)
#define __FLATTOOLBAR_H__

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

class CFlatToolBar : public CToolBar 
{
	DECLARE_DYNAMIC(CFlatToolBar);
public:
	void SetFlatLookStyle();
	void RepaintBackground();
	void DrawSeparators();
	void DrawSeparators(CClientDC* pDC);
	void EraseNonClient();
	void DrawGripper(CWindowDC *pDC, CRect& rectWindow);
protected:
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CFlatToolBar)
	virtual void OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler);
	//}}AFX_VIRTUAL
	// Message Handlers
protected:
	//{{AFX_MSG(CFlatToolBar)
	afx_msg void OnWindowPosChanging(LPWINDOWPOS lpWndPos);
	afx_msg void OnPaint();
	afx_msg void OnNcPaint();
	afx_msg void OnNcCalcSize( BOOL bCalcValidRects, NCCALCSIZE_PARAMS*	lpncsp );
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP();
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.

#endif // !defined(__FLATTOOLBAR_H__)

//***************************************************************
// FlatToolBar.cpp
// (c) 1997, Roger Onslow

#include "stdafx.h"
#include "FlatToolBar.h"

#ifdef _DEBUG
#undef THIS_FILE
#define new DEBUG_NEW

static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

BEGIN_MESSAGE_MAP(CFlatToolBar, CToolBar)
	//{{AFX_MSG_MAP(CFlatToolBar)
	ON_WM_WINDOWPOSCHANGING()
	ON_WM_PAINT()
	ON_WM_NCPAINT()
	ON_WM_NCCALCSIZE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

IMPLEMENT_DYNAMIC(CFlatToolBar,CToolBar)

// Must set after creation, as MFC wipes out extra style bits
void CFlatToolBar::SetFlatLookStyle()
{
	// Set flat style (transparent)
	ModifyStyle(0,TBSTYLE_FLAT);
	// others are...
	// #define TBSTYLE_TOOLTIPS        0x0100
	// #define TBSTYLE_WRAPABLE        0x0200
	// #define TBSTYLE_ALTDRAG         0x0400
	// #define TBSTYLE_FLAT            0x0800
	// #define TBSTYLE_LIST            0x1000
}

// Because buttons are transparent, we need to repaint the background
void CFlatToolBar::RepaintBackground()
{
	// get parent window (there should be one)
	CWnd* pParent = GetParent();
	if (pParent) {
		// get rect for this toolbar
		CRect rw; GetWindowRect(&rw;);
		// convert rect to parent coords
		CRect rc = rw; pParent->ScreenToClient(&rc;);
		// invalidate this part of parent
		pParent->InvalidateRect(&rc;);
		// now do all the other toolbars (etc) that belong to the parent
		for (
			CWnd* pSibling = pParent->GetWindow(GW_CHILD);
		pSibling;
		pSibling = pSibling->GetNextWindow(GW_HWNDNEXT)
			) {
			// but do not draw ourselves
			if (pSibling == this) continue;
			// convert rect to siblings coords
			CRect rc = rw; pSibling->ScreenToClient(&rc;);
			// invalidate this part of sibling
			pSibling->InvalidateRect(&rc;);
		}
	}
}

// Draw the separators in the client area
void CFlatToolBar::DrawSeparators()
{
	// get a dc for the client area
	CClientDC dc(this);
	// draw the separators on it
	DrawSeparators(&dc;);
}

// Draw the separators
void CFlatToolBar::DrawSeparators(CClientDC* pDC)
{
	// horizontal vs vertical
	bool ishorz = (m_dwStyle & CBRS_ORIENT_HORZ) != 0;
	// get number of buttons
	int nIndexMax = (int)DefWindowProc(TB_BUTTONCOUNT, 0, 0);
	int nIndex;
	
	// try each button
	for (nIndex = 0; nIndex < nIndexMax; nIndex++)
	{
		UINT dwStyle=GetButtonStyle(nIndex);
		UINT wStyle=LOWORD(dwStyle);
		
		// if it is a separator
		if (wStyle == TBBS_SEPARATOR)
		{
			// get it's rectangle and width
			CRect rect;
			GetItemRect(nIndex,rect);
			
			// if small enough to be a true separator
			int w=rect.Width();
			if (w <= 8)
			{
				if (ishorz)
				{
					// draw the separator bar in the middle
					CRect rectbar=rect;
					int x=(rectbar.left+rectbar.right)/2;
					rectbar.left=x-1;
					rectbar.right=x+1;
					pDC->Draw3dRect(rectbar,::GetSysColor(COLOR_3DSHADOW),::GetSysColor(COLOR_3DHILIGHT));
				}
				else
				{
					// draw the separator bar in the middle
					CRect rectbar = rect;
					rectbar.left = rectbar.left - m_sizeButton.cx;
					rectbar.right = rectbar.left + m_sizeButton.cx;
					rectbar.top = rectbar.bottom+1;
					rectbar.bottom = rectbar.top+3;
					int y = (rectbar.top+rectbar.bottom)/2;
					rectbar.top = y-1;
					rectbar.bottom = y+1;
					pDC->Draw3dRect(rectbar,::GetSysColor(COLOR_3DSHADOW),::GetSysColor(COLOR_3DHILIGHT));
					
				}
			}
		}
	}
}

// Draw the gripper at left or top
void CFlatToolBar::DrawGripper(CWindowDC *pDC, CRect& rectWindow)
{
	// get the gripper rect (1 pixel smaller than toolbar)
	CRect gripper = rectWindow;
	gripper.DeflateRect(1,1);
	if (m_dwStyle & CBRS_FLOATING) {
		// no grippers
	} else if (m_dwStyle & CBRS_ORIENT_HORZ) {
		// gripper at left
		gripper.right = gripper.left+3;
		pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
		gripper.OffsetRect(+4,0);
		pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
		rectWindow.left += 8;
	} else {
		// gripper at top
		gripper.bottom = gripper.top+3;
		pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
		gripper.OffsetRect(0,+4);
		pDC->Draw3dRect(gripper,::GetSysColor(COLOR_3DHIGHLIGHT),::GetSysColor(COLOR_3DSHADOW));
		rectWindow.top += 8;
	}
}

// Erase the non-client area (borders) - copied from MFC implementation
void CFlatToolBar::EraseNonClient()
{
	// get window DC that is clipped to the non-client area
	CWindowDC dc(this);
	CRect rectClient;
	GetClientRect(rectClient);
	CRect rectWindow;
	GetWindowRect(rectWindow);
	ScreenToClient(rectWindow);
	rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
	dc.ExcludeClipRect(rectClient);
	
	// draw borders in non-client area
	rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
	DrawBorders(&dc;, rectWindow);
	
	// erase parts not drawn
	dc.IntersectClipRect(rectWindow);
	SendMessage(WM_ERASEBKGND, (WPARAM)dc.m_hDC);
	
	DrawGripper(&dc;, rectWindow); // 
} 

// Because buttons are transparaent, we need to repaint background if style changes 
void CFlatToolBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
{
    static CUIntArray styles; // get the number of buttons
    int nIndexMax=(int)DefWindowProc(TB_BUTTONCOUNT, 0, 0); 
	
    int nIndex; // save styles 
    for (nIndex=0; nIndex < nIndexMax; nIndex++)
    {
        UINT dwStyle=GetButtonStyle(nIndex);
        styles.SetAtGrow(nIndex,dwStyle); 
    } 
    
    // do base class processing 
    CToolBar::OnUpdateCmdUI(pTarget,bDisableIfNoHndler); 
	
    // make checked button appear pushed in 
    for (nIndex=0; nIndex < nIndexMax; nIndex++) 
    { 
        UINT dwStyle=GetButtonStyle(nIndex);
        if (dwStyle & TBBS_DISABLED) 
        { 
            // don't touch if disabled (avoids flicker) 
        } 
        else if (dwStyle & TBBS_CHECKBOX) 
        {
            UINT dwStyleWas=dwStyle; // if checked, make it pressed, else not pressed 
            if (dwStyle & TBBS_CHECKED) 
            { 
                dwStyle |=TBBS_PRESSED;
            }
            else if (!(styles[nIndex]&TBBS;_CHECKED) && (styles[nIndex]&TBBS;_PRESSED)) 
            {
                dwStyle |=TBBS_PRESSED; 
            } 
            else
            {
                dwStyle &=~TBBS_PRESSED;
            }
            // set new style if changed 
            if (dwStyleWas !=dwStyle) SetButtonStyle(nIndex,dwStyle); 
        } 
    }
    // check for changes to style (buttons presssed/released)
    for (nIndex=0; nIndex < nIndexMax; nIndex++) 
    { 
        UINT dwStyle=GetButtonStyle(nIndex);
        if (styles[nIndex] !=dwStyle) {
            // repaint whole toolbar (not just this button) 
            Invalidate(); 
            // no need to check any more 
            break; 
        }
    }
} 

// Because buttons are transparent, we need to repaint background on size or move 
void CFlatToolBar::OnWindowPosChanging(LPWINDOWPOS lpwp) 
{ 
    // default processing 
    CToolBar::OnWindowPosChanging(lpwp); 
    RepaintBackground(); 
}

// Paint the toolbar 
void CFlatToolBar::OnPaint() 
{
    // standard tolbar 
    CToolBar::OnPaint(); 
    
    // erase the background 
    EraseNonClient(); 
	
    // plus separators 
    DrawSeparators(); 
}

// Paint the non-client area copied from MFC implementatios 
void CFlatToolBar::OnNcPaint() 
{ 
    // EraseNonClient(); don't do it here 
}

// Calculate the non-client area adjusting for grippers 
void CFlatToolBar::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS* lpncsp) 
{
    CToolBar::OnNcCalcSize(bCalcValidRects,lpncsp); 
    
    // adjust non-client area for gripper at left or top 
    if (m_dwStyle & CBRS_FLOATING) 
    {
        // no grippers 
    } 
    else if (m_dwStyle & CBRS_ORIENT_HORZ) 
    {
        // move 2 pixels right to make room 
        lpncsp->rgrc[0].left += 2;
        lpncsp->rgrc[0].right += 2;
    }
    else 
    {
        // move 4 pixels downto make room
        lpncsp->rgrc[0].top += 4;
        lpncsp->rgrc[0].bottom += 4;
    }
}