Visual Programming - Document Models

8/7/2019 Visual Programming - Document Models

1/27

CS1253 VISUAL PROGRAMMING

UNIT III

CHAPTER I

Document View Architecture

Global Application object

|

Execution begins- WinMain by MFC

|

AfxGetApp() Gets ptr to Applocation object

|

InitInstance Executed(Create Window &assigns

|

hInstance,nCmdshow appln object)

|

RUN()- Implements Message Loop

|

Terminate if WM_QUIT Message occurs

|

ExitInstance()


Need: Given set of data can have multiple representation- best to separate display

from data.

Three Objects:

Document - Store the data (responsible for

reading and writing data)

View - To display data

Window - The canvas on which all display take place Menu

, Keyboard Accelerators

1


2/27

The Main Frame Window and Document Classes

Application framework- controls interaction between frame and view

MainFrm.h and MainFrm.cpp -application's main frame window class

ex13aDoc.h and ex13aDoc.cpp-application's document class

ex13aView.h and ex13aView.cpp-applications view class

Windows Menus

A Microsoft Windows menu is a familiar application element that consists of a top-

level horizontal list of items with associated pop-up menus that appear when the user

selects a top-level item.

Menu items - grayed ,have check marks,separator bar.

Multiple levels pop-up menus are possible.

Each Menu item ID which is defined in resource.h

Entire resource definition - .rc file(resource script file)

Command Processing

WM_COMMAND message menu selection, keyboard accelerators,toolbar and

dialog button clicks by windows.

Message Map Entry:

ON_COMMAND( ID, command handler)

Id of menu clicked item corresponding message handler

For example, Menu item is Line (ID is

2


3/27

ID_LINE )

For handle it in the view class,

In view.cpp

BEGIN_MESSAGE_MAP(CMyView, CView) ON_COMMAND(ID_LINE, OnLine)

END_MESSAGE_MAP()

void CMyView::OnLine()

{ // command message processing code

}

In MyView.h Give the definition

afx_msg void OnZoom();

before DECLARE_MESSAGE_MAP() macro

Command update handler function.

Whenever a pop-up menu is first displayed or menu item is

clicked ,MFC calls this function.

The handler function's argument is a CCmdUI object, which containsa pointer to the corresponding menu item.

this pointer to modify the menu item's appearance by its operationssuch as enable , setcheck etc.

In view.cpp

BEGIN_MESSAGE_MAP(CMyView, CView)

ON_UPDATE_COMMAND_UI(ID_LINE, OnUpdateLine) END_MESSAGE_MAP()

void CMyView::OnUpdateLine()

{ // command message processing code

}

In MyView.h Give the definition

afx_msg void OnUpdateLine();

MFC Text Editing features

Edit Control and Rich Edit Control: CEditView and CRichEditView

CEditView Class:

Maximum size is 64 KB, work in View and Edit classes

cant mix font and cut copy paste is possible.

3


4/27

CRichEditView

- Supports mixed format and large quantities of text.

- can include embedded OLE objects

- CRichEditView maintains the text and formatting characteristic of text.

- CRichEditDoc maintains the list of OLE client items which are in the view.

- CRichEditCntrItem provides container-side access to the OLE client item

- Example

1. Add a CStringdata member to the CEx13aDoc class. In ex13aDoc.h

public: CString m_strText;

2. Add a CRichEditCtrldata member to the CEx13aViewclass. In file ex13aView.h

public: CRichEditCtrl m_rich;

In ex13aDoc.cpp

1. void CEx13aDoc::OnEditClearDocument()

{ m_strText.Empty(); }

2. void CEx13aDoc::OnUpdateEditClearDocument

(CCmdUI* pCmdUI)

{

pCmdUI->Enable(!m_strText.IsEmpty());

4


5/27

}

In CEx13View.cpp : Creation RichEdit Control

int CEx13aView::OnCreate(LPCREATESTRUCT lpCreateStruct)

{ CRect rect(0, 0, 0, 0);

if (CView::OnCreate(lpCreateStruct) == -1) return -1;

m_rich.Create(ES_AUTOVSCROLL | ES_MULTILINEES_WANTRETURN

| WS_CHILD | WS_VISIBLE | WS_VSCROLL, rect, this, 1);

return 0;

}

2. void CEx13aView::OnSize(UINT nType, int cx, int cy)

{

CRect rect;

CView::OnSize(nType, cx, cy); GetClientRect(rect);

m_rich.SetWindowPos(&wndTop, 0, 0, rect.right - rect.left, rect.bottom - rect.top,

SWP_SHOWWINDOW);

}

position &structure

3. void CEx13aView::OnTransferGetData()

{

CEx13aDoc* pDoc = GetDocument();

m_rich.SetWindowText(pDoc- >m_strText);

m_rich.SetModify(FALSE);

}

4. void CEx13aView::OnTransferStoreData()

{

CEx13aDoc* pDoc = GetDocument(); m_rich.GetWindowText(pDoc->m_strText);

m_rich.SetModify(FALSE);

}

5. void CEx13aView::OnUpdateTransferStoreData

(CCmdUI* pCmdUI)

{

5


6/27

pCmdUI->Enable(m_rich.GetModify());

}

6. Build and Run the application

Creating Floating Pop-Up Menus

void CMyView::OnContextMenu(CWnd *pWnd,

CPoint point)

{

CMenu menu; menu.LoadMenu(IDR_MYFLOATINGMENU);

menu.GetSubMenu(0) ->TrackPopupMenu

(TPM_LEFTALIGN | TPM_RIGHTBUTTON,

point.x, point.y, this);

}

Extended Command Processing

BEGIN_MESSAGE_MAP(CMyView, CView)

ON_COMMAND_EX_RANGE(IDM_ZOOM_1,

IDM_ZOOM_2, OnZoom)

END_MESSAGE_MAP()

ON_COMMAND_RANGE(id1, id2, Fxn )

ON_COMMAND_EX_RANGE

ON_UPDATE_COMMAND_UI_RANGE

CHAPTER 3

ToolBar & StatusBar

ToolBar

6


7/27

A toolbar consists of a number of horizontally (or vertically) arranged graphical

buttons that might be clustered in groups

Pressing a toolbar button is equivalent to choosing a menu item(WM_COMMANDmessages).

An update command UI message handler is used to update the button's state

MFC toolbar can dock to any side of its parent window or float in its own mini-

frame window.

you can change its size and drag it.

A toolbar can also display tool tips as the user moves the mouse over the toolbars

buttons.

ToolBar Bitmap:

-Each button on a toolbar appears to have its own bitmap,

but actually a single bitmap serves the entire toolbar.

-has tile, 15 pixels high and 16 pixels wide

-The toolbar bitmap is stored in the file Toolbar.bmp

Button State:

0: Normal, unpressed state.

TBSTATE_CHECKED Checked (down) state.TBSTATE_ENABLED Available foruse. Button is grayed and unavailable if this state is not set.

TBSTATE_HIDDEN Not visible.

TBSTATE_INDETERMINATEGrayed.

TBSTATE_PRESSED Currently selected (pressed) with

the mouse.

TBSTATE_WRAP Line break follows the button

7


8/27

Locating the Main FrameWindow

The toolbar and status bar objects you'll be working with are attached to the

application's main frame window, not to the view window

find the main frame window through the application object.

CMainFrame* pFrame = (CMainFrame*)

AfxGetApp()->m_pMainWnd;

CToolBar* pToolBar = &pFrame->m_wndToolBar;

Example

RunAppWizard to create an SDI application

& Use the resource editor to edit the application's main menu as follows

8


9/27

3. Use the resource editor to update the application's toolbar-Edit the

IDR_MAINFRAMEtoolbar resource

4. Give the ID to each Button

5. USE ClassWizard to add command and update command UI messages for

ID_CIRCLE,ID_SQUARE &ID_PATTERN

6. In the file ex14aView.h,

private:

CRect m_rect;

BOOL m_bCircle;

BOOL m_bPattern;

7. void CEx14aView::OnDrawCircle()

{

m_bCircle = TRUE;

m_rect += CPoint(25, 25);

InvalidateRect(m_rect); }

8. void CEx14aView::OnDrawSquare()

{ m_bCircle = FALSE;

m_rect += CPoint(25, 25);

9


10/27

InvalidateRect(m_rect);

}

9. void CEx14aView::OnDrawPattern() //toggles

{ m_bPattern ^= 1; }

10. void CEx14aView::OnUpdateDrawCircle (CCmdUI* pCmdUI)

{ pCmdUI->Enable(!m_bCircle); }

11.voidCEx14aView::OnUpdateDrawSquare(CCmdUI* pCmdUI)

{ pCmdUI->Enable(m_bCircle); }

12. void CEx14aView::OnUpdateDrawPattern(CCmdUI* pCmdUI)

{ pCmdUI->SetCheck(m_bPattern); }

StatusBar

neither accepts user input nor generates command messages

to display text in panes under program control

supports two types of text panes

o message line panes

o status indicator panes

The Status Bar Definition

10


11/27

The static indicators array that AppWizard generates in the MainFrm.cpp file defines

the panes for the application's status bar.

The constant ID_SEPARATOR identifies a message line pane;

the other constants are string resource IDs that identify indicator panes

Get access to the status bar object

CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->

m_pMainWnd;

CStatusBar* pStatus = &pFrame->m_wndStatusBar;

Display String in Massage Line-SetPaneText

pStatus->SetPaneText(0, "message line for first pane");

Pane No.:

0-leftmost pane

1-next pane to the right and so forth.

The Status Indicator

status indicator pane is linked to a single resource-supplied string that is displayed or

hidden by logic in an associated update command UI message handler function.

Contains Indicators .

An indicator is identified by a string resource ID.

same ID is used to route update command UI messages.

For example Caps Lock indication by status bar

In Mainframe.cpp

ON_UPDATE_COMMAND_UI(ID_INDICATOR_CAPS,

OnUpdateKeyCapsLock)

void MainFrame::OnUpdateKeyCapsLock(CCmdUI* pCmdUI)

{ pCmdUI->Enable(::GetKeyState(VK_CAPITAL) & 1); }

For Left Button Status

ON_UPDATE_COMMAND_UI(ID_LEFT, OnLeft)

void MainFrame::OnLeft(CCmdUI* pCmdUI)

{ pCmdUI->Enable(::GetKeyState(VK_LBUTTON) & 1); }

InMainframe.h

11


12/27

void Onleft(CCmdUI* j);

Taking Control of the Status Bar

Avoid Default status bar and have your own status bar

To assign your own ID, you must replace this call

m_wndStatusBar.Create(this); with this call

m_wndStatusBar.Create(this, WS_CHILD | WS_VISIBLE | CBRS_BOTTOM,

ID_MY_STATUS_BAR);

Example

1. Use the string editor to edit the application's string table resource.

ID Caption

ID_INDICATOR_LEFT -LEFT

ID_INDICATOR_RIGHT -RIGHT

2. Choose Resource Symbols from the View menu. Add the new status bar identifier,

ID_MY_STATUS_BAR,

and accept the default value.

3. In MainFrame.cpp

void CMainFrame::OnUpdateLeft(CCmdUI* pCmdUI)

12


13/27

{ pCmdUI->Enable(::GetKeyState(VK_LBUTTON) < 0); }

4. void CMainFrame::OnUpdateRight(CCmdUI* pCmdUI)

{ pmdUI->Enable(::GetKeyState(VK_RBUTTON) < 0); }

5. In MainFrame.cpp MessageMap Entry

ON_UPDATE_COMMAND_UI(ID_INDICATOR_LEFT,

OnUpdateLeft) ON_UPDATE_COMMAND_UI(ID_INDICATOR_RIGHT,

OnUpdateRight)

6. In MainFrm.h.

afx_msg void OnUpdateLeft(CCmdUI* pCmdUI);

afx_msg void OnUpdateRight(CCmdUI*pCmdUI);

7. Edit the MainFrm.cpp file.

Replace the original indicators array with the following boldface code:

static UINT indicators[] =

{ID_SEPARATOR, // first message line pane ID_SEPARATOR, // second message

line pane ID_INDICATOR_LEFT,

ID_INDICATOR_RIGHT };

8. Use ClassWizard to add View menu command handlers in the class CMainFrame.

1. ID_VIEW_STATUS_BAR - COMMAND

-OnViewStatusBar

2. ID_VIEW_STATUS_BAR--

UPDATE_COMMAND_UI

-OnUpdateViewStatusBar

void CMainFrame::OnViewStatusBar()

{ m_wndStatusBar.ShowWindow((m_wndStatusBar.GetStyle() &

WS_VISIBLE) == 0); RecalcLayout();

}

void CMainFrame::OnUpdateViewStatusBar(CCmdUI* pCmdUI)

{ pCmdUI- >SetCheck((m_wndStatusBar.GetStyle() & WS_VISIBLE) != 0); }

9.In OnCreate member function

Replace

13


14/27

if (!m_wndStatusBar.Create(this) || !m_wndStatusBar.SetIndicators(indicators,

sizeof(indicators)/sizeof(UINT)))

{ TRACE0("Failed to create status bar\n");

return -1; // fail to create }

with the statement shown here:

if (!m_wndStatusBar.Create(this, WS_CHILD | WS_VISIBLE | CBRS_BOTTOM,

ID_MY_STATUS_BAR) || !m_wndStatusBar.SetIndicators(indicators,

sizeof(indicators)/sizeof(UINT))) { TRACE0("Failed to create status bar\n"); return

-1; // fail to create }

10. InView.cpp

void CEx14bView::OnDraw(CDC* pDC)

{ pDC->TextOut(0, 0, "Watch the status bar while you move and click themouse."); }

11. void CEx14bView::OnMouseMove(UINT nFlags, Cpoint

point)

{ CString str; CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;

CStatusBar* pStatus = &pFrame->m_wndStatusBar;

if (pStatus)

{ str.Format("x = %d", point.x);

pStatus->SetPaneText(0, str);

str.Format("y = %d", point.y);

pStatus->SetPaneText(1, str); }}

12 #include "MainFrm.h"

A Reusable Frame Window Base Class

CStringclass.

Build your own reusable base class .

Access to the Windows Registry.

PreCreateWindow & ActiveFrame function.

CStringclass

dynamic memory allocation-const char*.

CString strFirstName("Elvis");

14


15/27

CString strLastName("Presley");

CString strTruth = strFirstName + " " +

strLastName;

strTruth += " is alive";

int nError = 23;

CString strMessageText;

strMessageText.Format("Error number %d", nError);

AfxMessageBox(strMessageText);

CString strTest("test");

strncpy(strTest, "T", 1);

CString::GetBuffer- "locks down" the buffer with a specified size and returns a char*.

ReleaseBuffer- to make the string dynamic again.

CString strTest("test"); strncpy(strTest.GetBuffer(5), "T", 1); strTest.ReleaseBuffer();

Build your own reusable base class

CPersistentFrame - derived from the CFrameWnd

- supports a persistent SDI (Single Document Interface) frame window that remembers

the following characteristics.

Window size ,Window position

Maximized status ,Minimized status

Toolbar and Status bar enablement and position

When you terminate an application that's built with the CPersistentFrame class, the

above information is saved on disk in the Windows Registry.

When the application starts again, it reads the Registry and restores the frame to its

state at the previous exit.

The Windows Registry

is a set of system files, managed by Windows, in which Windows and individual

applications can store and access permanent information.

is organized as a kind of hierarchical database in which string and integer data is

accessed by a multipart key.

TEXTPROC

Text formatting

15


16/27

Font = Times Roman

Points = 10

The SetRegistryKey function's string parameter establishes the top of the hierarchy,

SetRegistryKey(" TEXTPROC ");

Following Registry functions(CWinApp) define the bottom two levels: called heading name

and entry name.

GetProfileInt

WriteProfileInt

GetProfileString

WriteProfileString

AfxGetApp()->WriteProfileString("Text formatting", "Font",

"Times Roman");

AfxGetApp()->WriteProfileInt("Text formatting", "Points", 10);

ActivateFrame Member Function CFrameWnd

The key to controlling the frame's size

The application framework calls this virtual function (declared in CFrameWnd)

during the SDI main frame window creation process (and in response to the File Newand File Open commands).

The framework's job is to call the CWnd::ShowWindow function with the parameter

nCmdShow. The nCmdShow parameter determines whether the window is maximized

or minimized or both.

Override ActivateFrame in your derived frame class, to change the value of

nCmdShow before passing to it .

CWnd::SetWindowPlacement function, which sets the size and position of the frame

window, and you can set the visible status of the control bars.

First time call ie CPersistentFrame::ActivateFrame function operates only when the

application starts.

The PreCreateWindowMember Function-CWnd

to change the characteristics of your window before it is displayed

calls this function before it calls ActivateFrame.

a CREATESTRUCTstructure as a parameter, and two of the data members in thisstructure are style and dwExStyle.

16


17/27

CREATESTRUCT member lpszClass is also useful to change the window's

background brush, cursor, or icon.

BOOL MyView::PreCreateWindow(CREATESTRUCT& c)

{ ..

.

c.lpszClass =AfxRegisterWndClass(CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW,

AfxGetApp()-> LoadCursor(IDC_MYCURSOR), ::CreateSolidBrush (RGB(255, 0, 0)));

if (cs.lpszClass != NULL) { return TRUE; }

else { return FALSE; }

}

Style flag -determines whether the window has a border,

scroll bars, a minimize box, and so on.

Extended style double border, left aligned border etc


Menu, Keyboard Accelerators

Status Bar, ToolBar

Reusable Frame Window Class

Global Application object

Execution begins- WinMain by MFC

AfxGetApp() Gets ptr to Applocation object

InitInstance Executed(Create Window &assigns

hInstance,nCmdshow appln object)

RUN()- Implements Message Loop

Terminate if WM_QUIT Message occurs

ExitInstance()

Separating Document from its View

Need: Given set of data can have multiple

representation- best to separate display

from data.

Three Objects:

17


18/27

Document - Store the data (responsible for

reading and writing data)

View - To display data(each view one document)

Window - The canvas on which all display

take place

Document-View Interaction Functions

The CView::GetDocumentFunction-provides the

document pointer that can be used to access document

class member functions or public data embers.

CEx13aDoc* pDoc = GetDocument();

m_rich.SetWindowText(pDoc- >m_strText);

The CDocument::GetNextView -navigates from the

document to the view, but because a document can have

more than one view, it's necessary to call this member

function once for each view, inside a loop

CDocument::UpdateAllViews

-If the document data changes for any reason, all views must be notified so that they

can update their representations of that data.

-GetDocument()->UpdateAllViews(NULL): Update all

associated view .

-GetDocument()->UpdateAllViews(this): - Update all

associated view except current.

Syntax: void UpdateAllViews( CView* pSender, LPARAM lHint= 0L,

CObject* pHint= NULL );

Parameters

pSender-Points to the view that modified the document, or NULL if all views

are to be updated.

lHint - Contains information about the modification.

pHint -Points to an object storing information about the modification.

CView::OnUpdate:

18


19/27

- virtual function is called by the application framework in response to your application's call

to the

CDocument::UpdateAllViews function.

- view class's OnUpdate function accesses the document, gets the document's data, and then

updates the view's data members or controls to reflect the changes.

- OnUpdate can invalidate a portion of the view, causing the view's OnDraw function

to use document data to draw in the window.

- Same parameters as UpdateAllViews.

CView::OnInitialUpdate

-virtual CView function is called when the application starts, when the user chooses

New from the File menu, and when the user chooses Open from the File menu.

-calls OnUpdate.

-use your derived class's OnInitialUpdate function to initialize your view object

-When the application starts, the application framework calls OnInitialUpdate

immediately after OnCreate

CDocument::OnNewDocument

-The framework calls this virtual function after a document object is first constructed

and when the user chooses New from the File menu in an SDI application.

-to set the initial values of your document's data members.

Application starts

CMyDocumentobject constructed

CMyViewobject constructed

View window created

CMyView::OnCreate called (if mapped)

CMyDocument::OnNewDocumentcalled

CMyView::OnInitialUpdate called

View object initialized

View window invalidated

CMyView::OnDrawcalled

User edits data

CMyViewfunctions update CMyDocumentdata members

User exits application

19


20/27

CMyViewobject destroyed

Frame Window - Definition

An application or some parts of an application when framed by Windows are called Frame

Windows

Frame windows act as containers for other windows such as control bars or child controls.

Basic types of Frame Windows

Single Document Interface (SDI) frame windows

Multiple Document Interface (MDI) frame windows.

MDI frame windows can contain MDI child windows

Serialization

Serialization is an important concept in MFC programming because it is the basis for MFC's

ability to open and save documents in document/view applications.

Serialization Process

when someone using a document/view application selects Open or Save from the

application's File menu, MFC opens the file for reading or writing and passes the application

a reference to a CArchive object.

The application, in turn, serializes its persistent data to or from the archive and, by so doing,

saves a complete document to disk or reads it back again. A document whose persistent data

consists entirely of primitive data types or serializable objects can often be serialized withjust a few lines of code.

Serialization - Write

Assume that a CFile object named file represents an open file, that the file was opened withwrite access, and that you want to write a pair of integers named a and b to that file. One way

to accomplish this is to call CFile::Write once for each integer:

file.Write (&a, sizeof (a));

file.Write (&b, sizeof (b));

An alternative method is to create a CArchive object, associate it with the CFile object, and

use the


21/27

CArchive ar (&file, CArchive::load);

ar >> a >> b;

MFC allows a wide variety of primitive data types to be serialized this way, including

BYTEs, WORDs, LONGs, DWORDs, floats, doubles, ints, unsigned ints, shorts, and chars.

SDI and MDI

MFC supports two types of document/view applications. Single document interface (SDI)

applications support just one open document at a time. Multiple document interface (MDI)applications permit two or more documents to be open concurrently and also support multiple

views of a given document. The WordPad applet is an SDI application; Microsoft Word is an

MDI application.

SDI

SDI application frame windows are derived from the class CFrameWnd.The MFC library supports two distinct application types: Single Document Interface (SDI)

and Multiple Document Interface (MDI). An SDI application has, only one window. If the

application depends on disk-file "documents," only one document can be loaded at a time.

The original Windows Notepad is an example of an SDI application.

The standard SDI frame menus

The child windows within an SDI main frame window

SDI Document View Architecture

SDI Application

Startup steps in a Microsoft Windows MFC library application:

Windows loads your program into memory.

The global object theApp is constructed. (All globally declared objects are constructed

immediately when the program is loaded.)

Windows calls the global function WinMain, which is part of the MFC library. (WinMain is

equivalent to the non-Windows main functioneach is a main program entry point.)

Steps

WinMain searches for the one and only instance of a class derived from CWinApp.

WinMain calls the InitInstance member function for theApp, which is overridden in your

derived application class.

Your overridden InitInstance function starts the process of loading a document and

displaying the main frame and view windows.

WinMain calls the Run member function fortheApp, which starts the processes of dispatching

window messages and command messages.

Object Relationship

21


22/27

Steps for processing SDI InitInstance

1. Create an SDI document template from MFC's CSingleDocTemplate class.

2. Adding to list of document templates

3. Initializing command line info values

4. Processing command line parameters

5. Displaying applications frame window

InitInstance function for an SDI application generated by AppWizard

CSingleDocTemplate* pDocTemplate;

pDocTemplate = new CSingleDocTemplate

(IDR_MAINFRAME,

RUNTIME_CLASS (CMyDoc),

RUNTIME_CLASS (CMainFrame),

RUNTIME_CLASS (CMyView)

);

AddDocTemplate (pDocTemplate);

..

..

CCommandLineInfo cmdInfo;

ParseCommandLine (cmdInfo);

if (!ProcessShellCommand (cmdInfo)) return FALSE;

m_pMainWnd->ShowWindow (SW_SHOW);

m_pMainWnd->UpdateWindow ();

1. create an SDI document template from CSingleDocTemplate class

CSingleDocTemplate* pDocTemplate;

pDocTemplate = new CSingleDocTemplate

( IDR_MAINFRAME,

RUNTIME_CLASS (CMyDoc),

RUNTIME_CLASS (CMainFrame),

22


23/27

RUNTIME_CLASS (CMyView)

);

The template's constructor was passed four parameters: an integer value equal to

IDR_MAINFRAME and three RUNTIME_CLASS pointers.

AppWizard uses the resource ID IDR_MAINFRAME in the code that it generates. The

RUNTIME_CLASS macro surrounding the class names returns a pointer to a CRuntimeClass

structure for the specified class, which enables the framework to create objects of that class at

run time.

2. Adding to list of document templates

After the document template is created, the statement

AddDocTemplate (pDocTemplate);

adds it to the list of document templates maintained by the application object. Eachtemplate registered in this way defines one document type the application supports. SDI

applications register just one document type

3. Initialize command line info values

The statements

CCommandLineInfo cmdInfo; Par

seCommandLine (cmdInfo);

use CWinApp::ParseCommandLine to initialize a CCommandLineInfo object with valuesreflecting the parameters entered on the command line, which often include a document file

name.

4. Process command line parameters

The statements

if (!ProcessShellCommand (cmdInfo)) return FALSE;

"process" the command line parameters. Among other things, ProcessShellCommandcalls

CWinApp::OnFileNew to start the application with an empty document if no file name was

entered on the command line, or CWinApp::OpenDocumentFile to load a document if adocument name was specified. It's during this phase of the program's execution that the

framework creates the document, frame window, and view objects using the information

stored in the document template. ProcessShellCommandreturns TRUE if the initialization

succeeds and FALSE if it doesn't.

5. Display applications frame window

If initialization is successful, the statements

m_pMainWnd->ShowWindow (SW_SHOW); m_pMainWnd->UpdateWindow ();

display the application's frame window (and by extension, the view) on the screen.

23


24/27

Routing of command messages sent to an SDI frame window.

Example Program - The SdiSquares Application

The program shown in Figure is an SDI document/view application that displays a grid of

squares four rows deep and four columns wide. Initially, each square is colored white.

However, you can change a square's color by clicking it with the left mouse button. By

default, clicking changes a square's color to red. You can select alternate colors from the

Color menu and thereby create a multicolored grid containing squares of up to six different

colors.

The SdiSquares Application

Use AppWizard to create a new project named SdiSquares. In AppWizard's Step 1 dialogbox, choose Single Document as the application type and check the Document/View

Architecture Support box, as shown in Figure


In the Step 3 dialog box, uncheck the ActiveX Controls box.

In Step 4, uncheck Docking Toolbar, Initial Status Bar, Printing And Print Preview, and 3D

Controls.


Also in the Step 4 dialog box, click the Advanced button and type the letters sqrinto the File

Extension box (as shown in Figure) to define the default file name extension for SdiSquares

documents.


1. In the Step 6 dialog box, manually edit the class names as CSquaresApp. Everywhere

else, accept the AppWizard defaults.


Add the member variables m_clrGridand m_clrCurrentColor to the document class, and addcode to initialize them to OnNewDocument. AppWizard overrides OnNewDocument, so all

you have to do is add the statements that initialize the data members.


Add the member functions GetCurrentColor, GetSquare, and SetSquare to the documentclass. Be sure to make them public member functions, since they must be accessible to the

view.

Modify the Serialize function that AppWizard included in the document class to serialize

m_clrGridand m_clrCurrentColor.

Implement the view's OnDraw function. AppWizard generates a do-nothing OnDrawfunction; you write the code to perform application-specific duties.


24


25/27

Add the WM_LBUTTONDOWN handler (OnLButtonDown) to the view. You can add the

message handler by hand or use ClassWizard to add it. I used ClassWizard.

Open the AppWizard-generated application menu for editing, delete the Edit menu, and add

the Color menu. Then write command and update handlers for the new menu items. As with

message handlers, you can add command and update handlers manually or you can add themwith ClassWizard's help.

SDI vs MDI

MDI

MDI application frame windows are derived from the class CMDIFrameWnd.

An MDI application has multiple child windows, each of which corresponds to an individual

document. Microsoft Word is a good example of an MDI application. When you run

AppWizard to create a new project, MDI is the default application type

The parent-child hierarchy of a Windows MDI application.

MDI application

MDI windows

MDI classes

An MDI application has two frame window classes and many frame objects

Base Class

CMDIFrameWnd

CMDIChildWnd

AppWizard-Generated Class

CMainFrame

CChildFrame

The MDI frame-view window relationship

Splitter Windows

A splitter window is a window that can be divided into two or more panes

horizontally, vertically, or both horizontally and vertically using movable splitter bars.

Each pane contains one view of a document's data. The views are children of the

splitter window, and the splitter window itself is normally a child of a frame window.

Splitter windows

25


26/27

Using splitter windows provided by MFC, a single document interface (SDI)

application can present two or more views of the same document in resizeable

"panes" that subdivide the frame window's client area

In an SDI application, the splitter window is a child of the top-level frame window.

In an MDI application, the splitter window is a child of an MDI document frame.

Types of splitter windows

static splitter window:

The numbers of rows and columns in a static splitter window are set when the splitter is

created and can't be changed by the user. The user is, however, free to resize individual rows

and columns. A static splitter window can contain a maximum of 16 rows and 16 columns.

For an example of an application that uses a static splitter, look no further than the Windows

Explorer. Explorer's main window is divided in half vertically by a static splitter window.

Static splitter window

Dynamic Splitter window

A dynamic splitter window is limited to at most two rows and two columns, but it can

be split and unsplit interactively. The views displayed in a dynamic splitter window's

panes aren't entirely independent of each other: when a dynamic splitter window is

split horizontally, the two rows have independent vertical scroll bars but share a

horizontal scroll bar. Similarly, the two columns of a dynamic splitter window split

vertically contain horizontal scroll bars of their own but share a vertical scroll bar.The maximum number of rows and columns a dynamic splitter window can be

divided into are specified when the splitter is created. Thus, it's a simple matt

Dynamic Splitter window

Procedure for Creating and initializing a dynamic splitter window

1. Add a CSplitterWnddata member to the frame window class.

2. Override the frame window's virtual OnCreateClient function, and call

CSplitterWnd::Create to create a dynamic splitter window in the frame window's

client area.

Creating splitter window

Assuming m_wndSplitter is a CSplitterWnd object that's a member of the frame

window class CMainFrame, the following OnCreateClient override creates adynamic splitter window inside the frame window:

BOOL CMainFrame::OnCreateClient

(LPCREATESTRUCT lpcs,

CCreateContext* pContext)

26


27/27

{

return m_wndSplitter.Create (this, 2, 1, CSize (1, 1), pContext);

}


The first parameter to CSplitterWnd::Create identifies the splitter window's parent,which is the frame window.

The second and third parameters specify the maximum number of rows and columns

that the window can be split into.

Because a dynamic splitter window supports a maximum of two rows and two

columns, these parameter values will always be 1 or 2.

The fourth parameter specifies each pane's minimum width and height in pixels. The

framework uses these values to determine when panes should be created anddestroyed as splitter bars are moved.


CSize values equal to (1,1) specify that panes can be as little as 1 pixel wide and 1pixel tall.

The fifth parameter is a pointer to a CCreateContext structure provided by theframework. The structure's m_pNewViewClass member identifies the view class used

to create views in the splitter's panes.

The framework creates the initial view for you and puts it into the first pane. Other

views of the same class are created automatically as additional panes are created.

27

Visual Programming - Document Models

Documents

Transcript of Visual Programming - Document Models