]> git.mxchange.org Git - flightgear.git/blob - src/GUI/new_gui.hxx
catch non-existent nodes, too
[flightgear.git] / src / GUI / new_gui.hxx
1 // new_gui.hxx - XML-configured GUI subsystem.
2
3 #ifndef __NEW_GUI_HXX
4 #define __NEW_GUI_HXX 1
5
6 #ifndef __cplusplus
7 # error This library requires C++
8 #endif
9
10 #ifdef HAVE_CONFIG_H
11 #  include <config.h>
12 #endif
13
14 #include <plib/pu.h>
15
16 #include <simgear/compiler.h>   // for SG_USING_STD
17 #include <simgear/props/props.hxx>
18 #include <simgear/structure/subsystem_mgr.hxx>
19 #include <simgear/misc/sg_path.hxx>
20
21 #include <vector>
22 #include <map>
23
24 SG_USING_STD(vector);
25 SG_USING_STD(map);
26 SG_USING_STD(string);
27
28 #include <Main/fg_props.hxx>
29
30 class FGMenuBar;
31 class FGDialog;
32 class FGBinding;
33 class FGColor;
34 class FGFontCache;
35
36
37 /**
38  * XML-configured GUI subsystem.
39  *
40  * This subsystem manages the graphical user interface for FlightGear.
41  * It creates a menubar from the XML configuration file in
42  * $FG_ROOT/gui/menubar.xml, then stores the configuration properties
43  * for XML-configured dialog boxes found in $FG_ROOT/gui/dialogs/.  It
44  * can show or hide the menubar, and can display any dialog by name.
45  */
46 class NewGUI : public SGSubsystem
47 {
48 public:
49
50     /**
51      * Constructor.
52      */
53     NewGUI ();
54
55     /**
56      * Destructor.
57      */
58     virtual ~NewGUI ();
59
60     /**
61      * Initialize the GUI subsystem.
62      */
63     virtual void init ();
64
65     /**
66      * Reinitialize the GUI subsystem. Reloads all XML dialogs.
67      */
68     virtual void reinit ();
69
70     /**
71      * Bind properties for the GUI subsystem.
72      *
73      * Currently, this method binds the properties for showing and
74      * hiding the menu.
75      */
76     virtual void bind ();
77
78     /**
79      * Unbind properties for the GUI subsystem.
80      */
81     virtual void unbind ();
82
83     /**
84      * Update the GUI subsystem.
85      *
86      * Currently, this method is a no-op, because nothing the GUI
87      * subsystem does is time-dependent.
88      */
89     virtual void update (double delta_time_sec);
90
91     /**
92      * Redraw the GUI picking up new GUI colors.
93      */
94     virtual void redraw ();
95
96     /**
97      * Creates a new dialog box, using the same property format as the
98      * gui/dialogs configuration files.  Does not display the
99      * resulting dialog.  If a pre-existing dialog of the same name
100      * exists, it will be deleted.  The node argument will be stored
101      * in the GUI subsystem using SGPropertNode_ptr reference counting.
102      * It should not be deleted by user code.
103      *
104      * @param node A property node containing the dialog definition
105      */
106     virtual void newDialog (SGPropertyNode* node);
107
108     /**
109      * Display a dialog box.
110      *
111      * At initialization time, the subsystem reads all of the XML
112      * configuration files from the directory $FG_ROOT/gui/dialogs/.
113      * The configuration for each dialog specifies a name, and this
114      * method invokes the dialog with the name specified (if it
115      * exists).
116      *
117      * @param name The name of the dialog box.
118      * @return true if the dialog exists, false otherwise.
119      */
120     virtual bool showDialog (const string &name);
121
122
123     /**
124      * Close the currenty active dialog.  This function is intended to
125      * be called from code (pui callbacks, for instance) that registers
126      * its dialog object as active via setActiveDialog().  Other
127      * user-level code should use the closeDialog(name) API.
128      *
129      * @return true if a dialog was active, false otherwise
130      */
131     virtual bool closeActiveDialog ();
132
133     /**
134      * Close a named dialog, if it is open.
135      *
136      * @param name The name of the dialog box.
137      * @return true if the dialog was active, false otherwise.
138      */
139     virtual bool closeDialog (const string &name);
140
141     /**
142      * Get dialog property tree's root node.
143      * @param name The name of the dialog box.
144      * @return node pointer if the dialog was found, zero otherwise.
145      */
146     virtual SGPropertyNode_ptr getDialogProperties (const string &name);
147
148     /**
149      * Return a pointer to the current menubar.
150      */
151     virtual FGMenuBar * getMenuBar ();
152
153     /**
154      * Ignore this method.
155      *
156      * This method is for internal use only, but it has to be public
157      * so that a non-class callback can see it.
158      */
159     virtual void setActiveDialog (FGDialog * dialog);
160
161     /**
162      * Get the dialog currently active, if any.
163      *
164      * @return The active dialog, or 0 if none is active.
165      */
166     virtual FGDialog * getActiveDialog ();
167
168
169     /**
170      * Get the named dialog if active.
171      *
172      * @return The named dialog, or 0 if it isn't active.
173      */
174     virtual FGDialog * getDialog (const string &name);
175
176
177     virtual FGColor *getColor (const char * name) const {
178         _citt_t it = _colors.find(name);
179         return (it != _colors.end()) ? it->second : NULL;
180     }
181     virtual FGColor *getColor (const string &name) const {
182         _citt_t it = _colors.find(name.c_str());
183         return (it != _colors.end()) ? it->second : NULL;
184     }
185
186     virtual puFont *getDefaultFont() { return _font; }
187
188
189     /**
190      * menu wide font cache, accessible from other classes as well.
191      */
192     FGFontCache *get_fontcache() { return _fontcache; }
193
194 protected:
195
196     FGFontCache * _fontcache;
197
198     /**
199      * Test if the menubar is visible.
200      *
201      * This method exists only for binding.
202      */
203     virtual bool getMenuBarVisible () const;
204
205     /**
206      * Show or hide the menubar.
207      *
208      * This method exists only for binding.
209      */
210     virtual void setMenuBarVisible (bool visible);
211
212     virtual void setStyle ();
213     virtual void setupFont (SGPropertyNode *);
214
215     /**
216      * Used by reinit() and redraw() to close all dialogs and to apply
217      * current GUI colors. If "reload" is false, reopens all dialogs.
218      * Otherwise reloads all XML dialog files from disk and reopens all
219      * but Nasal * generated dialogs, omitting dynamic widgets. (This
220      * is only useful for GUI development.)
221      */
222     virtual void reset (bool reload);
223
224 private:
225     struct ltstr
226     {
227         bool operator()(const char* s1, const char* s2) const {
228             return strcmp(s1, s2) < 0;
229         }
230     };
231
232     puFont *_font;
233     map<const char*,FGColor*, ltstr> _colors;
234     typedef map<const char*,FGColor*, ltstr>::iterator _itt_t;
235     typedef map<const char*,FGColor*, ltstr>::const_iterator _citt_t;
236
237     void clear_colors();
238
239     // Read all the configuration files in a directory.
240     void readDir (const char * path);
241
242     FGMenuBar * _menubar;
243     FGDialog * _active_dialog;
244     map<string,FGDialog *> _active_dialogs;
245     map<string,SGPropertyNode_ptr> _dialog_props;
246
247 };
248
249
250 class FGColor {
251 public:
252     FGColor() { clear(); }
253     FGColor(float r, float g, float b, float a = 1.0f) { set(r, g, b, a); }
254     FGColor(const SGPropertyNode *prop) { set(prop); }
255     FGColor(FGColor *c) { 
256         if (c) set(c->_red, c->_green, c->_blue, c->_alpha);
257     }
258
259     inline void clear() { _red = _green = _blue = _alpha = -1.0f; }
260     // merges in non-negative components from property with children <red> etc.
261     bool merge(const SGPropertyNode *prop);
262     bool merge(const FGColor *color);
263
264     bool set(const SGPropertyNode *prop) { clear(); return merge(prop); };
265     bool set(const FGColor *color) { clear(); return merge(color); }
266     bool set(float r, float g, float b, float a = 1.0f) {
267         _red = r, _green = g, _blue = b, _alpha = a;
268         return true;
269     }
270     bool isValid() const {
271         return _red >= 0.0 && _green >= 0.0 && _blue >= 0.0;
272     }
273     void print() const {
274         std::cerr << "red=" << _red << ", green=" << _green
275         << ", blue=" << _blue << ", alpha=" << _alpha << std::endl;
276     }
277
278     inline void setRed(float red) { _red = red; }
279     inline void setGreen(float green) { _green = green; }
280     inline void setBlue(float blue) { _blue = blue; }
281     inline void setAlpha(float alpha) { _alpha = alpha; }
282
283     inline float red() const { return clamp(_red); }
284     inline float green() const { return clamp(_green); }
285     inline float blue() const { return clamp(_blue); }
286     inline float alpha() const { return _alpha < 0.0 ? 1.0 : clamp(_alpha); }
287
288 protected:
289     float _red, _green, _blue, _alpha;
290
291 private:
292     float clamp(float f) const { return f < 0.0 ? 0.0 : f > 1.0 ? 1.0 : f; }
293 };
294
295
296
297 /**
298  * A small class to keep all fonts available for future use.
299  * This also assures a font isn't resident more than once.
300  */
301 class FGFontCache {
302 private:
303     struct fnt {
304         fnt(puFont *pu = 0) : pufont(pu), texfont(0) {}
305         ~fnt() { delete pufont; delete texfont; }
306         puFont *pufont;
307         fntTexFont *texfont;
308     };
309     SGPath _path;
310
311     map<const string,fnt *> _fonts;
312     typedef map<const string,fnt *>::const_iterator _itt_t;
313
314 public:
315     FGFontCache();
316     ~FGFontCache();
317
318     puFont *get(const char *name, float size=15.0, float slant=0.0);
319     puFont *get(SGPropertyNode *node);
320 };
321
322
323 #endif // __NEW_GUI_HXX
324