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.
