1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
//========================================================================
// tutapp.cpp: Source file for tutorial V application
//
// Copyright 1995,1996 Bruce E. Wampler. All rights reserved.
//========================================================================
//
// This file is used to define the main application object. There
// will be exactly one instance of the application object. You will
// usually derive you own app class from the vApp class. This file
// defines a sample myApp class. The usual purpose of myApp is to
// start the initial window, and act as a central controller for
// your application. Rather than reading this file sequentially,
// you should skip to the end and read the comments surrounding the
// AppMain function.
// Files required for tutorial minimal application:
// tutapp.h: Header for the min app
// tutapp.cpp: Source code for min app
// tcmdwin.h: Header code for sample command window
// tcmdwin.cpp: Source code for sample command window
// tdialog.h: Header for sample modeless dialog
// tdialog.cpp: Source for sample modeless dialog
// tmodal.h: Header for sample modal dialog
// tmodal.cpp: Source for sample modal dialog
//
// First #include header files we need to use.
#include "tutapp.h" // our header file
//=========================>>> tutApp::NewAppWin <<<======================
vWindow* tutApp::NewAppWin(vWindow* win, char* name, int w, int h,
vAppWinInfo* winInfo)
{
// This version of NewAppWin is provided with the information
// required to name and size a window. You can derive
//
// Typically, this method would get a file name or other information
// needed to setup the AppWinInfo class specifically for the
// application. Thus, each open window usually represents a view of
// a file or data object.
vWindow* thisWin = win; // local copy to use
vAppWinInfo* awinfo = winInfo;
char *myname = name; // local copy
if (!name || !*name)
myname = "Example"; // make up a name
// The UserDebug macros are useful for tracking what is going on.
// This shows we're building a window.
UserDebug1(Build,"tutApp::NewAppWin(%s)\n",myname);
// You may instantiate an instance of the window outside of
// NewAppWin, or allow NewAppWin to create the instance.
if (!thisWin) // Didn't provide a window, so create one.
thisWin = new tCmdWindow(myname, w, h);
// The vAppWinInfo class is meant to serve as a database used by the
// tutApp controller. If you use this feature, you will probably
// derive your own myAppWinInfo class from vAppWinInfo. The instance
// of vAppWinInfo created here will be automatically deleted when
// this window instance is closed through CloseAppWin.
if (!awinfo) // Did caller provide an appinfo?
awinfo = new vAppWinInfo(myname);
// After you have created an instance of the window and an instance
// of the AppWinInfo, you MUST call the base vApp::NewAppWin method.
// You won't need to explicitly keep track of the pointer to
// each new window -- unless it has to interact with other windows.
// If that is the case, then you can use your derived vAppWinInfo
// to coordinate the interaction.
return vApp::NewAppWin(thisWin,name,w,h,awinfo);
}
//===========================>>> tutApp::Exit <<<=========================
void tutApp::Exit(void)
{
// This can be called to close all windows. If the app needs to do
// something special, it can. Otherwise, it can call the general
// vApp::Exit method, which will perform appropriate calls the the
// specialized tutApp::CloseAppWin.
UserDebug(Build,"tutApp::Exit()\n");
vApp::Exit(); // easy default behavior
}
//======================>>> tutApp::CloseAppWin <<<=======================
void tutApp::CloseAppWin(vWindow* win)
{
// This will be called BEFORE a window has been unregistered or
// closed. The app can do whatever it needs to to close down the
// data associated with this window. (It is invoked explicitly by
// you in response to a Close menu pick, for example, or when the
// user clicks the close button. It can also be called by vApp::Exit().
// After this method cleans up, it can then call the superclass
// vApp::CloseAppWin to unregister and close this window. Note that
// the win gives a handle that can be used with vApp::getAppWinInfo
// to retrieve the AppWinInfo class.
UserDebug(Build,"tutApp::CloseAppWin()\n");
// Code to handle close of window (such as saving/closing
// a file) would go here...
vApp::CloseAppWin(win); // Unregister and close the window.
}
//=====================>>> tutApp::AppCommand <<<=========================
void tutApp::AppCommand(vWindow* win, ItemVal id, ItemVal val,
CmdType cType)
{
// Any commands not processed by the window WindowCommand
// method will be passed to here for default treatment.
UserDebug1(Build,"tutApp::AppCmd(ID: %d)\n",id);
vApp::AppCommand(win, id, val, cType);
}
//=======================>>> tutApp::KeyIn <<<============================
void tutApp::KeyIn(vWindow* win, vKey key, unsigned int shift)
{
// Any key strokes not processed by the window will be passed
// along to here for default treatment.
vApp::KeyIn(win, key, shift);
}
//========================================================================
// Remember that any static references to an object are constructed by
// the C++ startup code before main or any other functions are called.
// Thus, the constructor for tutApp (and thus vApp) is invoked before
// anything else happens. This enables V to perform whatever
// initializations are required by the host GUI system - and frees you
// from having to worry about the typical gory details. All this means
// that EVERY V application needs a static instance of the tutApp to
// get things rolling. Note that the global variable theApp is set to
// point to this instance, and is the easiest way to access the vApp
// and tutApp methods (e.g., theApp->Exit()).
//========================================================================
static tutApp tut_App("TutorApp"); // The single instance of the app
//===========================>>> AppMain <<<==============================
int AppMain(int argc, char** argv)
{
// The V framework defines the instance of main. After some
// processing of command line arguments, AppMain is called with
// cleaned up command line arguments. Note that at this time, no
// windows have been defined. Normally, AppMain is the place to
// start up the first window. You can perform any initialization you
// need to do here.
(void) theApp->NewAppWin(0, "Tutorial V Example", 350, 100, 0);
// At this point, the window is up, and all events are being
// routed through its methods.
// We MUST return 0 if the status is ok at this point.
return 0;
}
|
