Introduction
I was recently looking for a sample of how to mimic the IE menu bar. First, I read an article in MSDN Library named "Creating an Internet Explorer-style Menu Bar" which gives a brief idea of how to get started. Then, I ran across an article by Paul DiLascia (with a working sample!). Unfortunately, Paul's article addresses SDI applications rather than MDI, although it gives many useful ideas and tricks which I used later on. Finally, I visited Internet sites devoted to MFC programming and found there some good articles concerning the problem in question. But most of those articles seem to pretend to be too universal and as a result are too heavy. This is possibly because the authors were trying to mimic MS Office/DevStudio (which is more complicated indeed) rather than the IE menu bar. Thus I came to the decision to create my own MenuBar which will meet all my unpretentious needs.
As my MenuBar was getting along I realized that it also would be nice to incorporate the standard ReBar control into another sizable "re-bar" just like IE does, so that the user could resize the ReBar by dragging a divider between the frame's client area and the ReBar itself. So this gave rise to another control, which I call SizableReBar here. It was not hard to implement corresponding C++ class, since there are a lot of samples of custom ControlBars on the Net. My favourite is CSizingControlBar
by Cristi Posea (thanks Cristi for your excellent work!). I used some of his basic ideas in my CSizableReBar
class.
After all, one thing left to be implemented to fully mimic the IE-style GUI was a toolbar control that could display itself on a chevron menu when some of its buttons get clipped. Frankly speaking, I was not excited about this idea in the beginning and the initial version of the class library did not contain any toolbar classes. Fortunately, I had some spare time a while ago and did write that anticipated CToolBarEx
class.
Although bitmapped menus are not a distinction of the IE-style GUI, it is considered to be a good form for modern apps to have them nowadays. There are plenty of good articles on the Net that show how to implement owner-draw bitmapped menus. But I have failed to find one that utilizes new functions and structures introduced in Windows 98, namely the hbmpItem
member of the MENUITEMINFO
structure and the GetMenuInfo()
/ SetMenuInfo()
functions along with the MENUINFO
structure. In my opinion it is quite reasonable to use these functions/structures, bearing in mind the growing number of the users that have already moved from W95/NT4 to W98/W2K/XP platforms. Also it is much more easy and a more standard way than to use fully owner-draw menus. That is why I have built in support of bitmapped menus using these new functions/structures.
Highlights of the classes
Moving on to what has been implemented so far (all these classes are located in \GuiLib directory of the demo project and compiled into MFC extension DLL called GuiLib.dll):
CMenuBar
class encapsulates the core functionality of the menu bar. It also knows how to display itself on chevron menu when some of menu bar items (and/or caption buttons, in case of MDI app) get clipped:
The latest version of CMenuBar
seems to work correctly when an embedded item is activated in-place.
CToolBarEx
class is meant to be used instead of standard CToolBar
class. Unlike CToolBar
, CToolBarEx
knows how to display itself on chevron menu when some of its buttons get clipped:
CToolBarEx
provides 3 different options for text labels ("Show text lables", "Selective text on right" and "No text labels") and 2 options for icons ("Small icons" that is 16x16 and "Large icons" that is 24x24").
Besides, CToolBarEx
is persistent, i.e. its state (including Text and Icon options) can be saved in the registry and restored later on. Corresponding methods are: SaveState(LPCTSTR lpszProfileName)
and LoadState(LPCTSTR lpszProfileName)
.
CCustomizeDialog
class allows the user to change toolbar options, as well as do other toolbar customizations. In fact, it is standard "Customize Toolbar" dialog which has been slightly extended (see new combo-boxes at the bottom of the dialog):
CSizableReBar
class encapsulates the functionality of the sizable re-bar control.
The control is persistent, i.e. its state can be saved in the registry and restored later on now. Corresponding methods are: SaveState(LPCTSTR lpszProfileName)
and LoadState(LPCTSTR lpszProfileName)
.
CSizableReBar
has context menu which usually has two parts: the first part is a list of bands that can be hidden/shown, and the second part (which is optional) is specific to the band that was clicked. For example, when the user right-clicks band with a toolbar the context menu may look as follows:
CFrameWndEx
(to be used in SDI applications), CMDIFrameWndEx
and CMDIChildWndEx
(to be used in MDI applications) classes were introduced to make the programmer's life as easy as possible. C(MDI)FrameWndEx
will automatically create a SizableReBar and MenuBar, as well as handle some key windows messages in order to get the MenuBar working correctly.
CPreviewToolBar
, CPreviewViewEx
and template<class TBase> class CPreviewableView
classes were introduced to provide Print Preview mode with nice-looking CToolBarEx
-derived toolbar instead of that ugly standard preview bar provided by MFC by default:
To have such a preview toolbar your view should be derived from CPreviewableView
. For example:
class CMyView : public CPreviewableView< CEditView >
Also ID_FILE_PRINT_PREVIEW
command handler implemented in CPreviewableView
should be added to the message map of the derived class:
BEGIN_MESSAGE_MAP( CMyView, CEditView )
...
ON_COMMAND( ID_FILE_PRINT_PREVIEW, OnFilePrintPreview )
END_MESSAGE_MAP()
- Every window that is assumed to be used as bitmapped popup menu owner should be derived from
template<class TBase> class CBmpMenuOwnerWnd
. For example:class CMyFrame : public CBmpMenuOwnerWnd< CMiniFrameWnd >
Also message handlers implemented in CBmpMenuOwnerWnd
should be added to the message map of the derived class:
BEGIN_MESSAGE_MAP( CMyFrame, CMiniFrameWnd )
...
ON_WM_INITMENUPOPUP()
ON_WM_DRAWITEM()
ON_WM_MEASUREITEM()
END_MESSAGE_MAP()
Note: CFrameWndEx
, CMDIFrameWndEx
and CMDIChildWndEx
are already derived from CBmpMenuOwnerWnd
.
CWindowListDialog
class allows the user to manage MDI child windows:
Obviously, this dialog makes sense for MDI apps only. Menu item that invokes this dialog is automatically added to the end of the Window popup menu, if any.
CWinAppEx
class is used to cache various system-wide settings. It also holds image list with menu icons.
General note for the latest release of CMenuBar
and CToolBarEx
classes: all that new W98/W2K/XP visual effects (like XP themes, flat menu appearance, menu animation, menu underlines, menu fade, etc.) are supported by menu bar/toolbar chevron menu now and brought into accord with corresponding system-wide settings.
Using the classes
Here are basic steps:
- Add GuiLib directory to the list of additional include directories for your project.
- Add the following line of code to your stdafx.h:
#include "GuiLib.h"
- Add inclusion of GuiLib\Resource.h in your RC file:
#include "afxres.h"
#include "GuiLib\Resource.h"
...
2 TEXTINCLUDE MOVEABLE PURE
BEGIN
"#include ""afxres.h""\r\n"
"#include ""GuiLib\\Resource.h""\r\n"
...
"\0"
END
Note: Resource IDs from 101 to 999 and from 33001 to 33999 are reserved by GuiLib.dll and should not be used by your application.
- Derive your Windows application object from
CWinAppEx
rather than CWinApp
and modify InitInstance()
as follows:BOOL YourApp::InitInstance()
{
InitGuiLibDLL();
...
}
- Derive your main frame object from
C(MDI)FrameWndEx
rather than C(MDI)FrameWnd
. In case of MDI application all child frames should be derived from CMDIChildWndEx
.
- Derive all your toolbars from
CToolBarEx
(don't forget to override CToolBarEx::Init()
function!). As soon as toolbar created it should be added to the sizable re-bar control. This can be done in CMainFrame::OnCreate()
. For example:int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if ( CMDIFrameWndEx::OnCreate( lpCreateStruct ) == -1 )
return -1;
VERIFY( m_wndToolBar.Create( this,
WS_CHILD | WS_VISIBLE | CBRS_ALIGN_TOP | CBRS_FLYBY ) );
VERIFY( m_wndReBar.AddBar( &m_wndToolBar,
0, 0, RBBS_FIXEDBMP | RBBS_BREAK, _T("&Toolbar"), false ) );
m_wndToolBar.Init();
...
}
Having no time to illustrate bit by bit usage of each of the classes, I can say that it should not be a problem for an intermediate MFC developer to get all omitted here details and aspects from the source code of the demo project.
Minimal system requirements
As you probably know, there is always a fly in the ointment: all this stuff requires Comctl32.dll version 5.81 or higher now. I personally don't see any difference between v5.80 and v5.81 though. From my experience all these v5.81 specific flags (like BTNS_SHOWTEXT
) work with v5.80 just fine. What a mystery! Should someone know the actual difference, please let me know.
Final words
Unfortunately, I had no time to test the classes thoroughly. Therefore, any bug reports, bug fixes and comments are more than welcome! Anyway, I hope you will enjoy using this set of classes.