Advanced MFC Programming

Chapter 1. Tool Bar and Dialog Bar
Class CControlBar has two member functions dealing with control bar layout: CControlBar::
CalcFixedLayout(…) and CControlBar::CalcDynamicLayout(…). The first function returns the fixed size
of a control bar, which is determined from the resource of a control bar. The second function is designed
for implementing dynamic layout, however in class CControlBar, this function does noting but calling
CControlBar::CalcFixedLayout(…). So actually CControlBar does not have dynamic layout feature.
Class CToolBar overrides function CControlBar::CalcDynamicLayout(…), which adjusts the size of
control bar according to its current docking state and the size of buttons. Whenever its docking state is
changed, this function will be called to obtain the information of a tool bar before its layout is changed
accordingly. With this implementation, a tool bar can always have a balanced appearance.
Unlike CToolBar, CDialogBar does not override this function, so when the docking state of a dialog
bar is changed, the default CControlBar::CalcDynamicLayout(…) is called, which of course, will not
perform any dynamic layout for the dialog bar. If we want to add any dynamic layout feature, we must
override this member function.
Sample 1.9\Bar demonstrates how to build a dialog bar that can be resized dynamically. The
application is a standard SDI application generated from Application Wizard, with four classes named
CBarApp, CMainFrame, CBarDoc, and CBarView. In the sample, a dialog bar with an edit control is added to
the application. This dialog bar will support dynamic layout feature: when we float or dock it to different
borders of the mainframe window, the size of the dialog bar will change accordingly.
Deriving New Class from CDialogBar
To implement dialog bar, first we need to add a dialog-template resource. In the sample, the ID of the
new resource is IDD_DIALOGBAR, which contains an edit box. The ID of this edit box is IDC_EDIT, it
supports multiple-line editing. To enable this style, first we can open “Edit Properties” property sheet of the
edit control (To invoke this property sheet, when editing the dialog template, we can double click on the
edit control or right click on it and move to “Properties” menu item), then we need to click “Styles” tab and
check “Multiline” check box.
To override the default function, first we need to derive a new class from CDialogBar. The following
code fragment shows the derived class MCDialogBar, which resides in file “MDlgBar.h”:
class MCDialogBar : public CDialogBar
{
public:
MCDialogBar();
//{{AFX_DATA(MCDialogBar)
//}}AFX_DATA
virtual CSize CalcDynamicLayout(int, DWORD);
//{{AFX_VIRTUAL(MCDialogBar)
//}}AFX_VIRTUAL
protected:
//{{AFX_MSG(MCDialogBar)
afx_msg void OnSize(UINT nType, int cx, int cy);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
Besides constructor, the only things included in this class are two functions. As we already know,
MCDialogBar::CalcDynamicLayout(…) will be used to support dynamic layout. Another afx_msg type
function MCDialogBar::OnSize(…) is a message handler, which will be used to resize the edit control
contained in the dialog bar. By doing this, we can see that whenever the size of the dialog bar is adjusted,
the size of the edit box will also change accordingly. This will let the edit box fit well within the dialog bar.
The new class can be added by opening new files (“.h” and “.cpp” files) and typing in the new class
and function implementations. Then we can execute Project | Add To Project | Files… command to add
the newly created files to the project. However, if we do so, we can not use Class Wizard to add member
variables and functions to the class. In this case, we need to implement message mapping manually. If this
is our choice, we must make sure that DECLARE_MESSAGE_MAP() macro is included in the class, and
BEGIN_MESSAGE_MAP, END_MESSAGE_MAP macros are included in the implementation file (“.cpp” file) so that
the class will support message mapping.
25