PenPoint provides:
Objects in a running instance of your application
".. A Descendant of clsApp
The PenPoint Application Framework's interactions are sophisticated and complex. Y ou'lliearn more about them in the following sections. Applications need to behave in a standardway to work well in the framework. To simplify life for the application developer, your application class inherits most of this standard behavior from the class clsApp. dsApp handles all the common machinery of application operation, so that many applications do not need to do anything in response to messages like msgAppActivate and msgAppOpen. Applications rely on clsApp to create their main window, display the main window, save state, terminate the application instance, ~nd so on.
You must write a descendant class of dsApp and create it during installation. In the example shown here, the descendant is clsTttApp. At the appropriate time,
3.5.1
The EMPTYAPP sample program in the Tutorial does nothing significant in response to any message, yet because it inherits from clsApp you can create EmptyApp documents, copy them, float them, embed them, and so on.
Lots of stuff is done for you!
CHAPTER 3 I APPLICATION CONCEPTS 27 Application Objects
the PenPoint Application Framework sends this class a message to create an instance of the class (Tic-Tac-Toe application instance in the figure). However, you must decide when to create your application's other objects (windows and filing objects).
".. An Instance of clsWin
The PenPoint Application Framework creates a frame for your application by default. This is a window with many "decorations": a title bar, a shadow if the window is floating, optional resize corners, close box, menu bar, tab bar,
command bar, etc. These decorations surround space for a client window. It is up to you to create the client window. You can also create windows to go into your frame's menu bar, tab bar, and command bar, and you can create floating windows, additional frames, and so on. Most applications create one or more windows to draw in and allow user input.
All window classes inherit from clsWin. This class does not paint anything useful in its window, so you must either create your own window class which draws what you want or use some of the many window descendant classes in PenPoint.
~ Some Window Classes
The Tic-Tac-Toe application, shown in Figure 3-1, for example, creates several kinds of windows based on existing classes in PenPoint:
• A scrolling client window (an instance of clsScrollWin), which lets the user scroll its contents
• An option sheet for its options (clsOption)
• An option card for the option sheet (clsOptionTable)
• Various user interface component windows (clsButton, clsLabel, clslntegerField) for the option card
• Menus
• A Tic-Tac-Toe view (clsTttView) to display the grid and Xs and as.
Like clsTttApp, you have to write the code for clsTttView and create the class at installation. Your application must create the various windows at the appropriate times, such as when it receives msgApplnit or msgAppOpen.
~ Using clsView
Many applications will use clsView, a specialized descendant of clsWin, for their custom windows. clsView associates its window with the data object it is . displaying; the data object sends the view a message when its data changes. In the case ofTic-Tac-Toe, clsTttView inherits from clsView, so the Tic-Tac-Toe window is a view.
In Tic-Tac-Toe, a clsTttView instance observes the data object (an instance of clsTttData). More than one view can be associated with the same data; in theory
3.5.2
Frames support only one client window, but you can insert other windows inside the client window.
3.5.2.1
3.5.2.2
E
IIIU Z
o u Z
[
two views of the Tic-T ac-T oe board could show their state in· different ways.
When the data changes, all the views are notified and can redraw themselves.
'r
An Instance of clsObiectInstead of managing all of the data involved with an application itself, a PenPoint application typically creates separate objects that maintain and file different parts of the data. These objects respond to messages like "Save yourself' and "Restore yourself from a file."
clsObject is actually the ancestor of all classes in PenPoint, including clsWin and clsApp. There is no class specifically for objects that must be. filed. Filing is such a general operation that all objects in the Pen Point operating system are given the opportunity to respond to msgSave and msgRestore messages. PenPoint supplies various descendant classes, which help in storing structured data, such as a list class (clsList), a picture segment (clsPicSeg), a block of styled text (clsText), and so on.
In Figure 3-1, the data for the Tic-Tac-Toe application (the values of the nine squares) are maintained by a separate object, Tic-Tac-Toe square values, an instance of the specialized class clsTttData.
3.5.3
". Understanding the Application Hierarchy
3.6 You may have wondered how PenPoint keeps track of all the sections, documents, and embedded documents in a notebook if application objects are notimmediately up and running when they are created. The answer is that each
\
document and section in a notebook is represented in an application hierarchy in the PenPoint file system. The Notebook table of contents displays a portion of this application hierarchy.
The reason it is called an application hierarchy is that the directory structure is the same as the hierarchy of documents in Pen Point (including embedded documents, accessories, and other floating documents not on a page in the Notebook). Each notebook has a directory in the file system. Within the notebook, each document or section has a directory. Within each section, each document or section has a directory. Within each document, all embedded documents have a directory, and so on.
As an example, when the user creates a document in a section of the Notebook, the PenPoint Application Fr~mework creates a new application directory in that section's directory. When the application is told to save its state by the PenPoint Application Framework, the PenPoint Application Framework gives it a file to save to in that application directory.
All PC operating systems have a file system, and in most you can store application data in a similar hierarchy of directories and subdirector.ies. Some may even provide a folder or section metaphor for their file system. But they do not directly weave applications into this file system. The Notebook's TOe (tap on its
The application hierarchy differs from theclass hierarchy explained in the next chapter, and from the hierarchy of windows on-screen.
CHAPTER 3 I APPLICATION CONCEPTS 29 Understanding the Application Hierarchy
Contents tab to move to it) shows the organization of documents in the Notebook, and this is the organization of part of PenPoint's file system.
In PenPoint, the application hierarchy exists in the \PENPOINT\SYS\BOOKSHELF directory on theSelectedVolume. You can inspect the application hierarchy yourself. Modify your ENVIRON.lNI file so that the DebugSet parameter specifies, IDB800. Run PenPoint and go to the connections notebook. Using the
directory view, browse through the disk volume. In the \PENPOINT directory, you should see directories called NOTEBOOK, SECTION, and so on. Compare this with the Notebook TOe. The browser shows exactly what the file system looks like, while the Notebook TOC interprets this part of the file system as the application hierarchy.
If your selected volume is your hard drive, you can also inspect this hierarchy from DOS. However, to keep path names short, all of the PenPoint directory names below \PENPOINT use two letter names. For example, the SYS directory is SS in DOS, the BookShelf directory is BF, the Notebook is NK, and so on.