zhu zhu's List: OOS

• Frame Windows
• window

  • the window is a interface to the users
• The "contents" consist of the window's client area, which is fully occupied by a child window — the view.

  • the content----- display in view----which is a child window
    the content-----consist of ----the window's clent area
• The two components — frame and contents — are represented and managed by two different classes in MFC.

  • frame window------is managed by -------a frame-window calss
    
    content --------------is managed by--------a view class
    
    the view window -----is a child of the frame window
• The MFC framework uses frame windows to contain views.
• When an application runs under Microsoft Windows, the user interacts with documents displayed in frame windows.

  • A document frame window type:
    
    (1) single document interface(SDI)
    (2)multiple document interface(MDI) chile window

  • A document frame window has two major components
    (1) the frame
    (2) the contents that it frames.
  • 1 more sticky notes...

  • • when you use the microsoft window to run program, you actually interacts with the documents-------the content of documents can be display in the frame windows.
• Drawing and other user interaction with the document take place in the view's client area, not the frame window's client area.

  • (1)Drawing
    (2)other user interaction
    with the document take place in the view's client area.
• Windows manages

  • Windows manages major basic functions with frame window.
    
    the user manage the content inside the frame.

6 more annotations...

• Windows messages
• Using Views

  • view's responsibilites are
    (1) display the document's data graphically
    (2) interpret user input as operations on the document
• user-interface objects
• class's OnDraw member function,

  • the OnDraw member function ----render(display)----the document data
    
    the handlers ------interprete user input
    
    Connect Window messages (view can do) display messages
• you may need to override other CView member functions in your derived view class.
• renders

  • render =======display
• handlers to interpret user input.
• and OnUpdate to do any special processing needed just before the view redraws itself.

6 more annotations...

• A view may be responsible for handling several different types of input, such as keyboard input,
• The view is responsible for displaying and modifying the document's data but not for storing it.

  • and provide member function in the document class for view to call

  • note: just for display and modify the document's data
    not store data
• The relationship between a view class, a frame window class, and a document class is established by a CDocTemplate object.
• the view
• calls the CDocument::UpdateAllViews function for the document, which notifies all the other views by calling the OnUpdate member function for each
• When a document's data changes,
• tree, list,
• provide member functions in the document class for the view class to call.
• A view can be attached to only one document, but a document can have multiple views attached to it at once

  • (1)A view can be attached to only one document
    (2)A document can have multiple views
• To use CView, derive a class from it and implement the OnDraw member function to perform screen display.

  • when you want to use the CView
    (1)derive a class from the CView
    (2)call the OnDraw() to display the content
• CView Class
• A view is attached to a document and acts as an intermediary between the document and the user:
• use OnDraw
• list controls
• The default implementation of OnUpdate invalidates the view's entire client area. You can override it
• tree controls.

14 more annotations...

• persistent storage
• At the heart of document/view are four key classes:
• CFrameWnd
• CDocTemplate
• The document stores the data and manages printing the data and coordinates updating multiple views of the data.

  • The Documents:
    (1)store data
    (2)manage printing data
    (3)coordinate update views' data
• The CView (
• The CDocument (or COleDocument) class supports objects used to store or control your program's data and provides the basic functionality for programmer-defined document classes.
• views, and the frame windows
• are created by a document template. The document template is responsible for creating and managing all documents of one document type.
• The view displays the data and manages user interaction with it, including selection and editing.

  • The View
    (1) display data
    (2)manage user interaction with it
    include(1)selection(2)editing
• saves
• opens
• • jhjj
• • Document object provide an interface to the data wherever it resides
    
    View
    (1)display data,
    (2) it obtains display data from document
    (3)and communicates back to the document any data changes

12 more annotations...

• he view accesses its document's data either with the GetDocument function, which returns a pointer to the document,

  • In the view class
    (1)In the view's OnDraw function,
    (2)the view uses GetDocument to obtain the document pointer
    (3) the GetDocument() function return Document pointer
    (4) the View use this pointer to access the data in the document
• A Portrait of the Document/View Architecture

• CDC provides two member functions
• CDC Class
• device context, such as a display or printer,
• CClientDC manages a display context associated with a window's client area.
• It also provides member functions for getting and setting drawing attributes
• Defines a class of device-context objects.
• Do all drawing through the member functions of a CDC object.
• he class provides member functions for device-context operations,
• CWindowDC manages a display context associated with an entire window, including its frame and controls
• CDC contains two device contexts,

8 more annotations...

• CWinThread Class  

  <!--Content type: DocStudio. Transform: devdiv2mtps.xslt.-->

  Represents a thread of execution within an application.

• Override this function to initialize the data structure for a new document. You should call the base class version of this function from your override.
• If the user chooses the File New command in an SDI application, the framework uses this function to reinitialize the existing document, rather than creating a new one
• You must place your initialization code in this function instead of in the constructor for the File New command to be effective in SDI applications.

1 more annotation...

• The CWnd class also lets you create a Windows child window for your application.
• Provides the base functionality of all window classes in the Microsoft Foundation Class Library.
• You create a child window in two steps. First, call the constructor CWnd to construct the CWnd object, then call the Create member function to create the child window and attach it to the CWnd object.

  • Create a child window
    (1) call the constructor CWnd ------construct the CWnd object
    (2)call the Create member function -----create the chile window
    ------and attach it to the CWnd object
• message-map mechanism
• A CWnd object is distinct from a Windows window,
• A CWnd object is created or destroyed by the CWnd constructor and destructor. The Windows window, on the other hand, is a data structure internal to Windows that is created by a Create member function and destroyed by the CWnd virtual destructor

  • A CWnd object ---is created by ------CWnd constructor
    ----is deleted by -------CWnd destructor
    The Windows window-----is created by ---a Create member function
    -----is deleted by ----CWnd virtual destructor
    the window is data structure internal to Windows

4 more annotations...