Advanced MFC Programming

Chapter 2. Menu
We can implement bitmap drawing by obtaining a target DC and calling member functions of CDC. The
target DC is usually obtained from a window.
A DC can select a lot of GDI objects, such pen, brush, font and bitmap. Pen can be different type of
pens, and brush can be different types of brushes. A DC can select any pen or brush as its current tool, but
at any time, a DC can select only one pen and one brush. If we want to draw a pixel or a line, we can select
the appropriate pen into the target DC and use it to implement drawing. A DC can also select bitmap for
drawing. However, to paint a bitmap, we can not select it into the target DC and draw it directly. The
normal way of painting a bitmap is to prepare a compatible memory DC (which is a block of memory with
the same attributes of the target DC), select the bitmap into the memory DC, and copy the bitmap from the
memory DC to the target DC.
We will learn more about DC and bitmap drawing in later chapters. For the time being, we can neglect
the drawing details.
Deriving a New Class from CMenu
Sample 2.6\Menu demonstrates owner-draw menu implementation. It is base on sample 2.5\Menu. In
this sample menu items ID__POPUPITEM1 and ID__POPUPITEM2 of the dynamic menu are implemented as
owner-draw menu, their menu items are painted using different bitmaps.
Like sample 2.5\Menu, some new images are prepared as bitmap resources. In the sample, the newly
added bitmaps are IDB_BITMAP_QUESTIONSEL, IDB_BITMAP_SMILE and IDB_BITMAP_SMILESEL. We will use
IDB_BITMAP_SMILE and IDB_BITMAP_SMILESEL to implement owner-draw menu item ID__POPITEM1, and
use IDB_BITMAP_QUESTION to implement ID__POPITEM2.
First, we need to override class CMenu. In the sample, a new class MCMenu is derived from CMenu, in this
class, we declare four CBitmap type variables that will be used to load bitmaps for menu drawing. Also,
functions CMenu::MeasureItem(…) and CMenu::DrawItem(…) are overridden:
class MCMenu : public CMenu
{
protected:
CBitmap m_bmpQuestion;
CBitmap m_bmpQuestionSel;
CBitmap m_bmpSmile;
CBitmap m_bmpSmileSel;
public:
MCMenu();
virtual ~MCMenu();
virtual void MeasureItem(LPMEASUREITEMSTRUCT);
virtual void DrawItem(LPDRAWITEMSTRUCT);
};
In the constructor of class MCMenu, four bitmaps are loaded:
MCMenu::MCMenu() : CMenu()
{
m_bmpQuestion.LoadBitmap(IDB_BITMAP_QUESTION);
m_bmpQuestionSel.LoadBitmap(IDB_BITMAP_QUESTIONSEL);
m_bmpSmile.LoadBitmap(IDB_BITMAP_SMILE);
m_bmpSmileSel.LoadBitmap(IDB_BITMAP_SMILESEL);
}
Overriding Function CMenu::MeasureItem(…)
Next we need to override function CMenu::MeasureItem(…). It has only one parameter, which is a
pointer to MEASUREITEMSTRUCT type object. Structure MEASUREITEMSTRUCT is used to inform system the
dimension of the owner-draw menu and other controls. There are three important members that will be
used: itemWidth and itemHeight, which represent width and height of the menu item; itemData, from
which we know the type of the menu item that is being inquired.
The program can assign special data to an owner-draw menu item when it is being created. When the
mainframe window calls the overridden functions to inquire the item’s attributes or paint the menu, the data
51