Advanced MFC Programming

Chapter 8. DC, Pen, Brush and Palette
Storing Data
When the user finishes drawing a line, the starting and ending points will be stored in the document. At
this time, instead of drawing the new line directly to the window, we need to update the client window and
let the function CView::OnDraw(…) be called. In this function, all the lines added previously will be drawn
again, so the client will always become up-to-date.
We must override function CView::OnDraw(…) to implement client window drawing for an application.
This is because the window update may happen at any time. For example, when the application is restored
from the icon state, the whole portion of the window will be painted again. The system will draw the nonclient
area such as caption bar and borders, and it is the application’s responsibility to implement client area
drawing, which should be carried out in function CView::OnDraw(…) In MFC, if the application does not
implement this, the client window will be simply painted with the default color. As a programmer, it is
important for us to remember that when we output something to the window, it will not be kept there
forever. We must redraw the output whenever the window is being updated.
This forces us to store every line that has been drawn by the user in document, and redraw all of them
when necessary. This is the basic document/view structure of MFC: storing data in CDocument derived
class, and representing it in function CView::OnDraw(…).
In the sample, the lines are stored in an array declared in the document class CGDIDoc. Also, some new
functions are declared to let the data be accessible from the view:
……
……
……
class CGDIDoc : public CDocument
{
public:
void AddLine(CRect rect){m_paLines.Add(new CRect(rect));}
CRect *GetLine(int nID){return (CRect *)m_paLines.GetAt(nID);}
int GetNumOfLines(){return m_paLines.GetSize();}
protected:
CPtrArray m_paLines;
};
A CPtrArray type variable m_paLines is declared for storing lines. Class CPtrArray allows us to add
and delete pointer type objects dynamically. This class encapsulates memory allocation and release, so we
do not have to worry about memory management when adding new elements. Three new public member
functions are also declared, among them CGDIDoc::AddLine(…) can be used to add a new line to
m_paLines, CGDIDoc::GetLine(…) can be used to retrieve a specified line from m_paLines, and CGDIDoc::
GetNumOfLines() can be used to retrieve the total number of lines stored in m_paLines. Here lines are
stored in CRect type variables, usually this class is used to store rectangles. In the sample, the rectangle’s
upper-left and bottom-right points are used to represent a line.
Although class CPtrArray can manage the memory allocation and release for storing pointers, it does
not release the memory for the stored objects. So in class CGDIDoc’s destructor, we need to delete all the
objects stored in the array as follows:
CGDIDoc::~CGDIDoc()
{
while(m_plLines.GetSize())
{
delete m_plLines.GetAt(0);
m_pLines.RemoveAt(0);
}
}
Here we just delete the first object and remove it from the array repeatedly until the size of the array
becomes 0.
In CView derived class, we can call function CView::GetDocument() to obtain a pointer to the
document and use it to access all the public variables and functions declared there.
204