Microsoft® Mastering: MFC Development Using Microsoft Visual C++® 6.0

Author Microsoft Corporation Pages 624 Disk 1 Companion CD(s) Level Intermediate Published 02/23/2000 ISBN 9780735609259 ISBN-10 0-7356-0925-X Price(USD) $49.99 To see this book's discounted price, select a reseller below.	More Information About the Book Table of Contents Sample Chapter Index Related Series Related Books About the Author Support: Book & CD Rate this book

Chapter 4: Implementing View Classes

• Introduction to Views
• The CView Class
• Relationship Between a View and a Document
• Coordinating the Views of a Document
• Managing Document/View Interaction
• Establishing Communication
• Displaying Data
• Updating the View
• Adding Multiple Views
• Adding Multiple Views to an SDI Application
• Adding Multiple Views to an MDI Application
• Building an MDI Application
• Starting an Application with the Default View
• Selecting a View for Application Startup
• Suppressing Automatic Creation of a Child Window
• Setting Titles for Child Frame Windows
• Setting Titles for New Documents
• Setting Titles for New Windows
• Adding Scrolling Views
• Introduction to Scrolling Views
• Converting the Application View to a Scrolling View
• Adjusting Scrolling Characteristics
• Converting Coordinates
• Implementing Splitter Windows
• Introduction to Splitter Windows
• Creating Dynamic Splitter Windows
• Creating Static Splitter Windows
• Command Handler Issues
• Coordinating Updates in the Views
• Lab 4.1: Adding a Splitter Bar
• Objectives
• Prerequisites
• Exercises
• Exercise 1: Adding a Splitter Window
• Implementing Form Views
• User-Defined Form Views
• Database View Classes
• Implementing Control Views
• Introduction to Control Views
• Overview of CListView
• Implementing CListView
• Customizing a List Control
• Populating a List Control
• Overview of CTreeView
• Implementing CTreeView
• Customizing Tree View Characteristics
• Associating an Image List with the Tree Control
• Populating the Tree Control
• Overview of CEditView
• Implementing CEditView
• Overview of CRichEditView
• Implementing CRichEditView.tc "Implementing CRichEditView".
• Implementing the Drag-and-Drop Feature
• Creating an Explorer-Style Application
• Coordinating Multiple Interrelated Views
• Coordinating Data Using the UpdateAllViews Function
• Coordinating Data Without Using the UpdateAllViews Function
• Lab 4.2: Adding Open File Dialogs and a Rich Edit View
• Objectives
• Prerequisites
• Exercises
• Exercise 1: Modifying the Base Classes of Views and Documents
• Exercise 2: Handling the Common Open File Dialog Box
• Exercise 3: Using the Rich Edit Views in the Application
• Exercise 4: Managing Drag-and-Drop Editing
• Lab 4.3 (Optional): Building a Text Viewer
• Objectives
• Prerequisites
• Exercises
• Exercise 1: Implementing a Basic Text Viewer
• Exercise 2: Adding Font Support
• Sample Applications
• Self-Check Questions

The CHTMLView class, which provides Internet browsing functionality, is not covered in this chapter. For information about CHTMLView, see "Implementing HTML Views" on page 469 in Chapter 9, "Building Internet Applications."

Objectives

• Describe the purpose of documents, views, templates, and frames within the document/view architecture, and explain how they interact.
• Describe the various types of view classes in MFC.
• Implement applications that use the following view classes:

• CView
• CScrollView
• CListView
• CSplitter
• CTreeView
• CEditView
• CRichEditView
• Create single-document interface (SDI) and multiple-document interface (MDI) applications with multiple views.
• Use two interrelated views in an application.

Introduction to Views

MFC supports a wide variety of views. The following illustration shows the hierarchy of MFC view classes.

Figure 4-1.

By deriving your application’s view from one of these classes, the view inherits support for interaction with the application framework. This section provides information on the CView class and how it fits into document/view architecture. It also introduces the relationship between the view and the document.

The CView class simplifies the implementation of printing and print preview for your documents. For more information about implementing printing features, see Chapter 10, "Printing and Print Preview."

The CView Class

A view is attached to a document and acts as an intermediary between the document and the user. The view renders an image of the document on the screen or printer and interprets user input as operations on the document.

A view is a child of a frame window. More than one view can share a frame window, as in the case of a splitter window. When the user opens a new window or splits an existing one, the framework constructs a new view and attaches it to the document.

Relationship Between a View and a Document

A view displays a document’s data. The document provides the view with the necessary details about its data. You can have the view access the document’s data members directly, or you can provide member functions in the document class for the view class to call.

Coordinating the Views of a Document

• CSingleDocTemplate

You use CSingleDocTemplate with single-document interface (SDI) applications to create and store one document of one type.

• CMultiDocTemplate

You use CMultipleDocTemplate with multiple-document interface (MDI) applications to create and store multiple documents of one type.

When a document’s data changes, the view responsible for the changes typically calls the CDocument::UpdateAllViews function for the document, which notifies all the other views by calling the OnUpdate member function for each view. The default implementation of OnUpdate invalidates the view’s entire client area. You can override this function to invalidate only those parts of the client area that you want to redraw.

Managing Document/View Interaction

1. Establish communication between the document and view.
2. Display data in the view.
3. Update the view when data in the document changes.

Establishing Communication

// Samples\CH04\Mdiapp
// Mdiview.cpp
void CMDIAppView::OnDraw(CDC* pDC)
{
 // Get pointer to current document
 CMDIAppDoc* pDoc = GetDocument();
 ASSERT_VALID(pDoc);
  
 // Use document pointer as required 
 // to access document data and functions
  
 // ... remainder of drawing code goes here
}

Displaying Data

// Overriding the OnDraw function to display data in a view
// Samples\CH04\Mdiapp
// Mdiview.cpp
  
void CMDIAppView::OnDraw(CDC* pDC)
{
 // Get pointer to current document
 CMDIAppDoc* pDoc = GetDocument();
 ASSERT_VALID(pDoc);

 // Calculate position to display text
 CRect r;
 GetClientRect(&r);
 int x = r.right / 2, y = r.bottom / 2;
  
 // Set text characteristics
 pDC->SetTextColor(pDoc->GetColor());
 pDC->SetTextAlign (TA_CENTER | TA_BASELINE);
  
 // Display text to the view
 pDC->TextOut (x, y, pDoc->GetPhrase());
}

Updating the View

• CWnd::Invalidate (or CDocument::UpdateAllViews)

Use in applications that use a single view.

• CDocument::UpdateAllViews

Use in applications that use multiple views.

In applications that use views of different types, calling the UpdateAllViews function may not be the easiest solution for updating data. For information about a method that bypasses the UpdateAllViews function, see "Coordinating Multiple Interrelated Views" on page 183 in this chapter.

For more information about the UpdateAllViews function, search for "UpdateAllViews" in MSDN Library Visual Studio 6.0.

The following sample code shows how an MDI application uses the UpdateAllViews function to ensure that all views associated with the current document are correctly repainted when the user changes the color of the text displayed in the view. To copy this code for use in your own projects, see "Updating the Views in an MDI Application" on the accompanying CD-ROM.

// Repainting all views of a document when the user changes the text 
// color in one of the views
// Samples\CH04\Mdiapp
// Mdiview.cpp
  
 void CMDIAppView::OnColors(UINT nID)
{
 CMDIAppDoc* pDoc = GetDocument();
 pDoc->SetColor(IDtoColorRef(nID));
	  
 // If this were an SDI app then you could call
	// Invalidate();
 // Since it's an MDI app, you have to call
 pDoc->UpdateAllViews(NULL);
}

Adding Multiple Views

This section explains how to create multiple views of the same document for SDI and MDI applications. In the sample applications for this section, multiple views share a single frame window. The views are constructed from different classes, each view providing a different way to display the same document. For example, one view might show the text in a document in a normal mode, while the other view shows the text in italic.

Adding Multiple Views to an SDI Application

To create an SDI application with two views of the same document

1. Build an SDI application the way you normally would. For an application with more than one view class, like the one discussed in these steps, place the command handlers in the CMainFrame class. Placing the command handlers in CMainFrame ensures that they will be available regardless of which view is active. If you place the command handlers in the view class, the handlers will not be available unless that view object is active.

---

TIP:
In an application with only one view class, place command handlers in the view class. In an application with more than one view class, place command handlers in the CMainFrame (SDI) or CChildFrame (MDI) class. The functions CFrameWnd::GetActiveView and CFrameWnd::GetActiveDocument facilitate accessing the view of the document from your main frame or child frame.

---

2. Add a new view class derived from CView.
3. Add debug and nondebug versions of the GetDocument function.

Use the GetDocument functions from your existing view class as a model.

4. Add a public constructor.

ClassWizard provides the new view class with a protected constructor. Make sure the constructor differs from the existing constructor in a way other than scope.

5. Make the destructor provided by Class Wizard public.

The protected destructor is not necessary, and the new constructor you have added is already public.

6. Include the document class header file in the source file of the new view class.
7. Add a handler for the OnDraw event of the new view class.
8. Include the header file of the new view class in Mainfrm.cpp.
9. Add two protected variables in the CMainFrame class.

These variables will be pointers to the two view objects your application uses. Initialize these pointers to NULL (0) in the constructor of CMainFrame, as shown in the following example code:

class CMainFrame : public CFrameWnd
{
	...
protected:
	CItalicsView * m_pItalicsView;
	CDefaultView * m_pDefaultView;
	...
}
CMainFrame::CMainFrame()
{
	// To give this SDI app 2 views, the main frame stores
	// pointers to them both. 
	m_pItalicsView = 0;
	m_pDefaultView = 0;
}

10. Add two menu selections to permit the application to switch between the two views.

The View menu is a good place to insert the menu selections, but you can choose any of the drop-down menus.

11. Add command handlers to CMainFrame for the two new menu items.

The following sample code shows how to add the command handler to switch to the new view. To copy this code for use in your own projects, see "Command Handler to Switch to New View" on the accompanying CD-ROM.

// To switch to the new view and hide the default view
// Samples\CH04\SDI2VIEWS
void CMainFrame::OnViewItalics() 
{
 CDocument* pDoc = GetActiveDocument();
	
 // Only need to do this one time.
 if (0 == m_pItalicsView)
{
	m_pDefaultView = (CDefaultView *)GetActiveView();
	// This object is destroyed in main frame's d'tor.
	m_pItalicsView = new CItalicsView(NULL);

	m_pItalicsView->Create(NULL, NULL, AFX_WS_DEFAULT_VIEW,
			rectDefault, this, AFX_IDW_PANE_FIRST + 1);
 }

 pDoc->AddView(m_pItalicsView);
 
 // Set the child i.d. of the italics view to AFX_IDW_PANE_FIRST,
 // so that CFrameWnd::RecalcLayout will allocate to this 
 // "first pane" that portion of the frame window's client area 
 // not allocated to control bars.  Set the child i.d. of the 
 // default view to AFX_IDW_PANE_FIRST + 1
 m_pItalicsView->SetDlgCtrlID(AFX_IDW_PANE_FIRST);
 m_pDefaultView->SetDlgCtrlID(AFX_IDW_PANE_FIRST+1);
	
 // Show the italics view and hide the default view.
 m_pItalicsView->ShowWindow(SW_SHOW);
 m_pDefaultView->ShowWindow(SW_HIDE);
	
 SetActiveView(m_pItalicsView);

 // See comment in OnViewDefault.
 pDoc->RemoveView(m_pDefaultView);
 RecalcLayout();
}

The following sample code shows how to add the command handler that restores the default view. To copy this code for use in your own projects, see "Command Handler to Restore Default View" on the accompanying CD-ROM.

// To switch to the default view and hide the second view (the italics
// view)
// Samples\CH04\SDI2VIEWS
void CMainFrame::OnViewDefault() 
{
 CDocument* pDoc = GetActiveDocument();
 
 // The UI handler will prevent this function executing before
 // OnViewItalics, but just in case...
 ASSERT (m_pItalicsView != 0);
 ASSERT (m_pDefaultView != 0);
 
 pDoc->AddView(m_pDefaultView);
 
 m_pDefaultView->ShowWindow(SW_SHOW);
 m_pItalicsView->ShowWindow(SW_HIDE);
 
 m_pDefaultView->SetDlgCtrlID(AFX_IDW_PANE_FIRST);
 m_pItalicsView->SetDlgCtrlID(AFX_IDW_PANE_FIRST + 1);
 
 SetActiveView(m_pDefaultView);
 pDoc->RemoveView(m_pItalicsView);
 RecalcLayout();
}

You can choose to leave the inactive view in the application, or you can remove the inactive view from your application. The previous sample code uses CDocument::RemoveView to remove the inactive view. Removing it means that when the document object is changed and CDocument::UpdateAllViews is called, the inactive view object’s OnDraw function will not be called.

Removing the inactive view is not required, but it makes the application more efficient. If the inactive view is not removed from the document object’s list of attached views, nothing detrimental will happen when the inactive view’s OnDraw function executes. In an application with only two views, each with simple OnDraw functions, you will not be able to tell much difference.

12. Enable and disable the two menu items, as shown in the following example code:

void CMainFrame::OnUpdateViewDefault(CCmdUI* pCmdUI) 
{
	// Only enable the default view menu if the current view
	// is the italics view. The isKindOf function checks if the
	// active view is derived from CItalicsView
RUNTIME_CLASS macro
	pCmdUI->Enable(
		GetActiveView()->IsKindOf(RUNTIME_CLASS(CItalicsView)));
}

void CMainFrame::OnUpdateViewItalics(CCmdUI* pCmdUI) 
{
	// Only enable the italics view menu if the current view
	// is the default view.
	pCmdUI->Enable(
		GetActiveView()->IsKindOf(RUNTIME_CLASS(CDefaultView)));
}

The code samples discussed in this topic appear in the sample application SDI2VIEWS, which is located in the folder <install folder>\Samples\Ch04.