GEOS SDK TechDocs
|
| 
2.1 Features of Hello World
| 
2.3 Naming Conventions
The code for Hello World, as you will see, is quite simple. It consists mainly of User Interface gadgetry and uses just a few message handlers.
The main component of the application is the Process object, an instance of
HelloProcessClass
(a subclass of
GenProcessClass
). This object makes all drawing and color changes by handling messages sent from the window manager and the triggers in the dialog box. The Process object basically manages the application, keeping track of the relevant data and interacting with the UI gadgetry.
The Process object is event-driven, meaning it has no
main()
routine run when the program is launched. Instead, the program does nothing until an event occurs (such as the view window sending
MSG_META_EXPOSED
when first opened). When the event (message) is received, the Process object responds to it and then waits until the next event occurs. Note, however, that the vast majority of events a Process object will receive and handle are not generated by your code but by the kernel and the UI.
Both the menu and the dialog box, once defined in the source code as objects, are implemented automatically by the system software. The application does not have to draw or otherwise manage these objects; they will interact directly with the UI to do the proper thing.
The triggers within the dialog, however, request actions that must be carried out by the application (changing the color to blue and gold, respectively). Although the application does not have to instantiate, draw, or otherwise modify the trigger objects, it must handle messages sent out by them when they are pressed by the user. This is discussed below, under "Changing the Text Color."
Almost everything is handled automatically by the User Interface for the Hello World application. This includes implementation of the system menus for the primary window and the scrolling functionality of the scrollable View window.
The view object (of
GenViewClass
) is powerful and provides a lot of what most applications need. It automatically handles all window resizes and scrolls, and it will cause proper redrawing when another object (such as a pinned menu) is moved across it. The only thing it does not do is actually draw the application's images.
When the view senses that some portion of its window has become invalid (through scrolling or when the view window is first opened, for example), it will send a
MSG_META_EXPOSED
message to the Hello World application's Process object. The Process object will respond by drawing the text appropriately--it does not, however, have to worry about what portion of the text is visible or what portion of the screen the view window occupies. The view will automatically clip the text properly and display it within the window's bounds.
In all, the Process object can handle six events specific to this application:
MSG_META_CONTENT_VIEW_WIN_OPENED
(sent by the view when it first creates its window),
MSG_META_CONTENT_VIEW_WIN_CLOSED
(sent by the view when its window is being destroyed),
MSG_META_EXPOSED
(described above),
MSG_HELLO_CHANGE_TO_BLUE
(sent by the Blue trigger),
MSG_HELLO_CHANGE_TO_GOLD
(sent by the Gold trigger), and
MSG_HELLO_REDRAW_DOCUMENT
(sent by the Process object to itself).
The Process object maintains two global variables:
helloTextColor
contains the current color of the text, and
winHan
contains the window handle of the view's window. When it draws the text, the Process object checks
helloTextColor
before drawing. Therefore, the handlers for the change-color messages change the value of
helloTextColor
.
However, changing the text's color is not quite that easy. Because the view window does not have any way of knowing that the Process object has changed the text, the application must inform the UI of the change. Otherwise, the change will be made in the document but will not appear on the screen until the view window is moved or resized by the user.
Therefore, we must force a window invalidation when we change the color. This will cause the View window to generate a new
MSG_META_EXPOSED
that will force the redrawing of the text in the new color. The window handle is cached in
winHan
for just this purpose; when the text color changes, we must invalidate the window so the UI will redraw its contents. We invalidate the window by calling the special graphics routine
GrInvalRect()
, passing the window's handle. We get the window handle when the view first creates the window--it will send out a
MSG_META_CONTENT_VIEW_WIN_OPENED
. When the window closes, the view will send
MSG_META_CONTENT_VIEW_WIN_CLOSED
in which Hello World destroys the cached window handle.
GEOS SDK TechDocs
|
| 2.1 Features of Hello World
| 2.3 Naming Conventions