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 protected:
 190
 191     /**
 192      * Test if the menubar is visible.
 193      *
 194      * This method exists only for binding.
 195      */
 196     virtual bool getMenuBarVisible () const;
 197
 198     /**
 199      * Show or hide the menubar.
 200      *
 201      * This method exists only for binding.
 202      */
 203     virtual void setMenuBarVisible (bool visible);
 204
 205     virtual void setStyle ();
 206     virtual void setupFont (SGPropertyNode *);
 207
 208     /**
 209      * Used by reinit() and redraw() to close all dialogs and to apply
 210      * current GUI colors. If "reload" is false, reopens all dialogs.
 211      * Otherwise reloads all XML dialog files from disk and reopens all
 212      * but Nasal * generated dialogs, omitting dynamic widgets. (This
 213      * is only useful for GUI development.)
 214      */
 215     virtual void reset (bool reload);
 216
 217 private:
 218     struct ltstr
 219     {
 220         bool operator()(const char* s1, const char* s2) const {
 221             return strcmp(s1, s2) < 0;
 222         }
 223     };
 224
 225     puFont *_font;
 226     map<const char*,FGColor*, ltstr> _colors;
 227     typedef map<const char*,FGColor*, ltstr>::iterator _itt_t;
 228     typedef map<const char*,FGColor*, ltstr>::const_iterator _citt_t;
 229
 230     void clear_colors();
 231
 232     // Read all the configuration files in a directory.
 233     void readDir (const char * path);
 234
 235     FGMenuBar * _menubar;
 236     FGDialog * _active_dialog;
 237     map<string,FGDialog *> _active_dialogs;
 238     map<string,SGPropertyNode_ptr> _dialog_props;
 239
 240 };
 241
 242
 243 class FGColor {
 244 public:
 245     FGColor() { clear(); }
 246     FGColor(float r, float g, float b, float a = 1.0f) { set(r, g, b, a); }
 247     FGColor(const SGPropertyNode *prop) { set(prop); }
 248     FGColor(FGColor *c) {
 249         if (c) set(c->_red, c->_green, c->_blue, c->_alpha);
 250     }
 251
 252     inline void clear() { _red = _green = _blue = _alpha = -1.0f; }
 253     // merges in non-negative components from property with children <red> etc.
 254     bool merge(const SGPropertyNode *prop);
 255     bool merge(const FGColor *color);
 256
 257     bool set(const SGPropertyNode *prop) { clear(); return merge(prop); };
 258     bool set(const FGColor *color) { clear(); return merge(color); }
 259     bool set(float r, float g, float b, float a = 1.0f) {
 260         _red = r, _green = g, _blue = b, _alpha = a;
 261         return true;
 262     }
 263     bool isValid() const {
 264         return _red >= 0.0 && _green >= 0.0 && _blue >= 0.0;
 265     }
 266     void print() const {
 267         std::cerr << "red=" << _red << ", green=" << _green
 268         << ", blue=" << _blue << ", alpha=" << _alpha << std::endl;
 269     }
 270
 271     inline void setRed(float red) { _red = red; }
 272     inline void setGreen(float green) { _green = green; }
 273     inline void setBlue(float blue) { _blue = blue; }
 274     inline void setAlpha(float alpha) { _alpha = alpha; }
 275
 276     inline float red() const { return clamp(_red); }
 277     inline float green() const { return clamp(_green); }
 278     inline float blue() const { return clamp(_blue); }
 279     inline float alpha() const { return _alpha < 0.0 ? 1.0 : clamp(_alpha); }
 280
 281 protected:
 282     float _red, _green, _blue, _alpha;
 283
 284 private:
 285     float clamp(float f) const { return f < 0.0 ? 0.0 : f > 1.0 ? 1.0 : f; }
 286 };
 287
 288
 289
 290 /**
 291  * A small class to keep all fonts available for future use.
 292  * This also assures a font isn't resident more than once.
 293  */
 294 class FGFontCache {
 295 private:
 296     struct fnt {
 297         fnt(puFont *pu = 0) : pufont(pu), texfont(0) {}
 298         ~fnt() { delete pufont; delete texfont; }
 299         puFont *pufont;
 300         fntTexFont *texfont;
 301     };
 302     SGPath _path;
 303
 304     map<const string,fnt *> _fonts;
 305     typedef map<const string,fnt *>::const_iterator _itt_t;
 306     bool _initialized;
 307
 308 public:
 309     FGFontCache();
 310     ~FGFontCache();
 311
 312     puFont *get(const char *name, float size=15.0, float slant=0.0);
 313     puFont *get(SGPropertyNode *node);
 314 };
 315
 316
 317 #endif // __NEW_GUI_HXX
 318