From 4b2506d709fb03d7021ac9be1e259e0fa46625d9 Mon Sep 17 00:00:00 2001
From: ThorstenB <brehmt@gmail.com>
Date: Sat, 19 Nov 2011 15:37:49 +0100
Subject: [PATCH 01/18] Add new performance monitoring subsystem. Rename some
 subsystems for naming consistency.

---
 src/AIModel/AIManager.cxx        |  2 +-
 src/AIModel/submodel.cxx         |  2 +-
 src/Main/fg_init.cxx             | 19 ++++++++++++++-----
 src/Main/globals.cxx             |  2 +-
 src/Main/main.cxx                | 30 ------------------------------
 src/MultiPlayer/multiplaymgr.cxx |  2 +-
 src/Network/HLA/hla.cxx          |  2 +-
 src/Time/TimeManager.cxx         |  3 +++
 src/Time/TimeManager.hxx         |  1 +
 src/Traffic/Schedule.cxx         |  6 +++---
 10 files changed, 26 insertions(+), 43 deletions(-)

diff --git a/src/AIModel/AIManager.cxx b/src/AIModel/AIManager.cxx
index 2ad548371..731983f25 100644
--- a/src/AIModel/AIManager.cxx
+++ b/src/AIModel/AIManager.cxx
@@ -146,7 +146,7 @@ FGAIManager::update(double dt) {
     if (!enabled)
         return;
 
-    FGTrafficManager *tmgr = (FGTrafficManager*) globals->get_subsystem("Traffic Manager");
+    FGTrafficManager *tmgr = (FGTrafficManager*) globals->get_subsystem("traffic-manager");
     _dt = dt;
 
     ai_list_iterator ai_list_itr = ai_list.begin();
diff --git a/src/AIModel/submodel.cxx b/src/AIModel/submodel.cxx
index a25212198..83bb681b0 100644
--- a/src/AIModel/submodel.cxx
+++ b/src/AIModel/submodel.cxx
@@ -45,7 +45,7 @@ FGSubmodelMgr::~FGSubmodelMgr()
 
 FGAIManager* FGSubmodelMgr::aiManager()
 {
-   return (FGAIManager*)globals->get_subsystem("ai_model");
+   return (FGAIManager*)globals->get_subsystem("ai-model");
 }
 
 void FGSubmodelMgr::init()
diff --git a/src/Main/fg_init.cxx b/src/Main/fg_init.cxx
index 4a1881da9..7e842f9ba 100644
--- a/src/Main/fg_init.cxx
+++ b/src/Main/fg_init.cxx
@@ -56,6 +56,7 @@
 #include <simgear/debug/logstream.hxx>
 #include <simgear/structure/exception.hxx>
 #include <simgear/structure/event_mgr.hxx>
+#include <simgear/structure/SGPerfMon.hxx>
 #include <simgear/misc/sg_path.hxx>
 #include <simgear/misc/sg_dir.hxx>
 #include <simgear/misc/sgstream.hxx>
@@ -1199,6 +1200,14 @@ bool fgInitSubsystems() {
     ////////////////////////////////////////////////////////////////////
     globals->add_subsystem("properties", new FGProperties);
 
+
+    ////////////////////////////////////////////////////////////////////
+    // Add the performance monitoring system.
+    ////////////////////////////////////////////////////////////////////
+    globals->add_subsystem("performance-mon",
+            new SGPerformanceMonitor(globals->get_subsystem_mgr(),
+                                     fgGetNode("/sim/performance", true)));
+
     ////////////////////////////////////////////////////////////////////
     // Initialize the material property subsystem.
     ////////////////////////////////////////////////////////////////////
@@ -1282,7 +1291,7 @@ bool fgInitSubsystems() {
     // sub system infrastructure.
     ////////////////////////////////////////////////////////////////////
 
-    globals->add_subsystem("Old ATC", new FGATCMgr, SGSubsystemMgr::INIT);
+    globals->add_subsystem("ATC-old", new FGATCMgr, SGSubsystemMgr::INIT);
 
     ////////////////////////////////////////////////////////////////////
    // Initialize the ATC subsystem
@@ -1304,14 +1313,14 @@ bool fgInitSubsystems() {
     // Initialise the AI Model Manager
     ////////////////////////////////////////////////////////////////////
     SG_LOG(SG_GENERAL, SG_INFO, "  AI Model Manager");
-    globals->add_subsystem("ai_model", new FGAIManager, SGSubsystemMgr::POST_FDM);
-    globals->add_subsystem("submodel_mgr", new FGSubmodelMgr, SGSubsystemMgr::POST_FDM);
+    globals->add_subsystem("ai-model", new FGAIManager, SGSubsystemMgr::POST_FDM);
+    globals->add_subsystem("submodel-mgr", new FGSubmodelMgr, SGSubsystemMgr::POST_FDM);
 
 
     // It's probably a good idea to initialize the top level traffic manager
     // After the AI and ATC systems have been initialized properly.
     // AI Traffic manager
-    globals->add_subsystem("Traffic Manager", new FGTrafficManager, SGSubsystemMgr::POST_FDM);
+    globals->add_subsystem("traffic-manager", new FGTrafficManager, SGSubsystemMgr::POST_FDM);
 
     ////////////////////////////////////////////////////////////////////
     // Add a new 2D panel.
@@ -1446,7 +1455,7 @@ void fgReInitSubsystems()
     
     // Force reupdating the positions of the ai 3d models. They are used for
     // initializing ground level for the FDM.
-    globals->get_subsystem("ai_model")->reinit();
+    globals->get_subsystem("ai-model")->reinit();
 
     // Initialize the FDM
     globals->get_subsystem("flight")->reinit();
diff --git a/src/Main/globals.cxx b/src/Main/globals.cxx
index 5f5fa60a3..dc48bd846 100644
--- a/src/Main/globals.cxx
+++ b/src/Main/globals.cxx
@@ -167,7 +167,7 @@ FGGlobals::~FGGlobals()
     // deallocation of AIModel objects. To ensure we can safely
     // shut down all subsystems, make sure we take down the 
     // AIModels system first.
-    SGSubsystem* ai = subsystem_mgr->remove("ai_model");
+    SGSubsystem* ai = subsystem_mgr->remove("ai-model");
     if (ai) {
         ai->unbind();
         delete ai;
diff --git a/src/Main/main.cxx b/src/Main/main.cxx
index 3532bcb5e..3afaeceae 100644
--- a/src/Main/main.cxx
+++ b/src/Main/main.cxx
@@ -108,15 +108,6 @@ static void fgMainLoop( void )
     static SGPropertyNode_ptr frame_signal
         = fgGetNode("/sim/signals/frame", true);
 
-    static SGPropertyNode_ptr _statisticsFlag
-        = fgGetNode("/sim/timing-statistics/enabled", true);
-    static SGPropertyNode_ptr _statisticsInterval
-        = fgGetNode("/sim/timing-statistics/interval-s", true);
-    static SGPropertyNode_ptr _statiticsMinJitter
-        = fgGetNode("/sim/timing-statistics/min-jitter-ms", true);
-    static SGPropertyNode_ptr _statiticsMinTime
-        = fgGetNode("/sim/timing-statistics/min-time-ms", true);
-
     frame_signal->fireValueChanged();
     
     SG_LOG( SG_GENERAL, SG_DEBUG, "Running Main Loop");
@@ -197,27 +188,6 @@ static void fgMainLoop( void )
         }
     }
 
-    // print timing statistics
-    static bool _lastStatisticsFlag = false;
-    if (_lastStatisticsFlag != _statisticsFlag->getBoolValue())
-    {
-        // flag has changed, update subsystem manager
-        _lastStatisticsFlag = _statisticsFlag->getBoolValue();
-        globals->get_subsystem_mgr()->collectDebugTiming(_lastStatisticsFlag);
-    }
-    if (_lastStatisticsFlag)
-    {
-        static double elapsed = 0;
-        elapsed += real_dt;
-        if (elapsed >= _statisticsInterval->getDoubleValue())
-        {
-            // print and reset timing statistics
-            globals->get_subsystem_mgr()->printTimingStatistics(_statiticsMinTime->getDoubleValue(),
-                                                                _statiticsMinJitter->getDoubleValue());
-            elapsed = 0;
-        }
-    }
-
     simgear::AtomicChangeListener::fireChangeListeners();
 
     SG_LOG( SG_GENERAL, SG_DEBUG, "" );
diff --git a/src/MultiPlayer/multiplaymgr.cxx b/src/MultiPlayer/multiplaymgr.cxx
index 22703a28c..123317c63 100644
--- a/src/MultiPlayer/multiplaymgr.cxx
+++ b/src/MultiPlayer/multiplaymgr.cxx
@@ -1309,7 +1309,7 @@ FGMultiplayMgr::addMultiplayer(const std::string& callsign,
   mp->setCallSign(callsign);
   mMultiPlayerMap[callsign] = mp;
 
-  FGAIManager *aiMgr = (FGAIManager*)globals->get_subsystem("ai_model");
+  FGAIManager *aiMgr = (FGAIManager*)globals->get_subsystem("ai-model");
   if (aiMgr) {
     aiMgr->attach(mp);
 
diff --git a/src/Network/HLA/hla.cxx b/src/Network/HLA/hla.cxx
index 22450de10..5f8d15731 100644
--- a/src/Network/HLA/hla.cxx
+++ b/src/Network/HLA/hla.cxx
@@ -701,7 +701,7 @@ public:
             if (modelPath.empty())
                 return;
             FGAIManager *aiMgr;
-            aiMgr = static_cast<FGAIManager*>(globals->get_subsystem("ai_model"));
+            aiMgr = static_cast<FGAIManager*>(globals->get_subsystem("ai-model"));
             if (!aiMgr)
                 return;
 
diff --git a/src/Time/TimeManager.cxx b/src/Time/TimeManager.cxx
index eb3bb25a1..00f6f31b9 100644
--- a/src/Time/TimeManager.cxx
+++ b/src/Time/TimeManager.cxx
@@ -102,6 +102,7 @@ void TimeManager::init()
   // frame-rate / worst-case latency / update-rate counters
   _frameRate = fgGetNode("/sim/frame-rate", true);
   _frameLatency = fgGetNode("/sim/frame-latency-max-ms", true);
+  _frameRateWorst = fgGetNode("/sim/frame-rate-worst", true);
   _lastFrameTime = 0;
   _frameLatencyMax = 0.0;
   _frameCount = 0;
@@ -267,6 +268,8 @@ void TimeManager::computeFrameRate()
   if ((_impl->get_cur_time() != _lastFrameTime)) {
     _frameRate->setIntValue(_frameCount);
     _frameLatency->setDoubleValue(_frameLatencyMax*1000);
+    if (_frameLatencyMax>0)
+        _frameRateWorst->setIntValue(1/_frameLatencyMax);
     _frameCount = 0;
     _frameLatencyMax = 0.0;
   }
diff --git a/src/Time/TimeManager.hxx b/src/Time/TimeManager.hxx
index 6f0d35acb..10226eaf6 100644
--- a/src/Time/TimeManager.hxx
+++ b/src/Time/TimeManager.hxx
@@ -82,6 +82,7 @@ private:
   
   // frame-rate / worst-case latency / update-rate counters
   SGPropertyNode_ptr _frameRate;
+  SGPropertyNode_ptr _frameRateWorst;
   SGPropertyNode_ptr _frameLatency;
   time_t _lastFrameTime;
   double _frameLatencyMax;
diff --git a/src/Traffic/Schedule.cxx b/src/Traffic/Schedule.cxx
index 4314d0237..85343db29 100644
--- a/src/Traffic/Schedule.cxx
+++ b/src/Traffic/Schedule.cxx
@@ -228,7 +228,7 @@ bool FGAISchedule::update(time_t now, const SGVec3d& userCart)
     
   if (AIManagerRef) {
     // Check if this aircraft has been released. 
-    FGTrafficManager *tmgr = (FGTrafficManager *) globals->get_subsystem("Traffic Manager");
+    FGTrafficManager *tmgr = (FGTrafficManager *) globals->get_subsystem("traffic-manager");
     if (tmgr->isReleased(AIManagerRef)) {
       AIManagerRef = 0;
     } else {
@@ -347,7 +347,7 @@ bool FGAISchedule::createAIAircraft(FGScheduledFlight* flight, double speedKnots
                                             airline);
   if (fp->isValidPlan()) {
         aircraft->SetFlightPlan(fp);
-        FGAIManager* aimgr = (FGAIManager *) globals-> get_subsystem("ai_model");
+        FGAIManager* aimgr = (FGAIManager *) globals-> get_subsystem("ai-model");
         aimgr->attach(aircraft);
         AIManagerRef = aircraft->getID();
         return true;
@@ -465,7 +465,7 @@ FGScheduledFlight* FGAISchedule::findAvailableFlight (const string &currentDesti
 {
     time_t now = time(NULL) + fgGetLong("/sim/time/warp");
 
-    FGTrafficManager *tmgr = (FGTrafficManager *) globals->get_subsystem("Traffic Manager");
+    FGTrafficManager *tmgr = (FGTrafficManager *) globals->get_subsystem("traffic-manager");
     FGScheduledFlightVecIterator fltBegin, fltEnd;
     fltBegin = tmgr->getFirstFlight(req);
     fltEnd   = tmgr->getLastFlight(req);

From a05ea36acb143e1d50c70f5af444e3ffe50b5222 Mon Sep 17 00:00:00 2001
From: James Turner <zakalawe@mac.com>
Date: Sat, 19 Nov 2011 20:25:51 +0000
Subject: [PATCH 02/18] Restructure GUI code, isolate PLIB in source files, to
 ease future refactoring and alternative GUI layers.

---
 src/ATC/atcdialog.cxx           |   1 +
 src/ATCDCL/ATCDialogOld.cxx     |   1 +
 src/Cockpit/panel.cxx           |   2 +-
 src/GUI/CMakeLists.txt          |   4 +
 src/GUI/FGColor.cxx             |  54 +++++++
 src/GUI/FGColor.hxx             |  49 +++++++
 src/GUI/FGFontCache.cxx         | 223 ++++++++++++++++++++++++++++
 src/GUI/FGFontCache.hxx         |  96 +++++++++++++
 src/GUI/dialog.cxx              |   4 +
 src/GUI/gui.cxx                 |   1 +
 src/GUI/new_gui.cxx             | 248 +-------------------------------
 src/GUI/new_gui.hxx             | 118 +--------------
 src/Instrumentation/HUD/HUD.cxx |   3 +
 src/Main/globals.cxx            |   4 +-
 src/Main/main.cxx               |   2 +-
 src/Main/splash.cxx             |   5 +-
 utils/fgpanel/FGFontCache.cxx   |  15 +-
 utils/fgpanel/FGFontCache.hxx   |  10 +-
 18 files changed, 469 insertions(+), 371 deletions(-)
 create mode 100644 src/GUI/FGColor.cxx
 create mode 100644 src/GUI/FGColor.hxx
 create mode 100644 src/GUI/FGFontCache.cxx
 create mode 100644 src/GUI/FGFontCache.hxx

diff --git a/src/ATC/atcdialog.cxx b/src/ATC/atcdialog.cxx
index 912f35446..5185ee0c0 100644
--- a/src/ATC/atcdialog.cxx
+++ b/src/ATC/atcdialog.cxx
@@ -24,6 +24,7 @@
 
 #include <Main/fg_commands.hxx>
 #include <Main/globals.hxx>
+#include <Main/fg_props.hxx>
 
 #include <simgear/constants.h>
 #include <simgear/structure/commands.hxx>
diff --git a/src/ATCDCL/ATCDialogOld.cxx b/src/ATCDCL/ATCDialogOld.cxx
index 20e2f1f83..b1824180c 100644
--- a/src/ATCDCL/ATCDialogOld.cxx
+++ b/src/ATCDCL/ATCDialogOld.cxx
@@ -30,6 +30,7 @@
 #include <Main/globals.hxx>
 #include <GUI/gui.h>		// mkDialog
 #include <GUI/new_gui.hxx>
+#include <Main/fg_props.hxx>
 
 #include "ATCDialogOld.hxx"
 #include "ATC.hxx"
diff --git a/src/Cockpit/panel.cxx b/src/Cockpit/panel.cxx
index 916771726..6cdce3d70 100644
--- a/src/Cockpit/panel.cxx
+++ b/src/Cockpit/panel.cxx
@@ -57,7 +57,7 @@
 #include <Main/fg_props.hxx>
 #include <Main/viewmgr.hxx>
 #include <Time/light.hxx>
-#include <GUI/new_gui.hxx>	// FGFontCache
+#include <GUI/FGFontCache.hxx>	
 #include <Main/viewer.hxx>
 #include <Instrumentation/dclgps.hxx>
 
diff --git a/src/GUI/CMakeLists.txt b/src/GUI/CMakeLists.txt
index 428cdcb9e..eee0fcd41 100644
--- a/src/GUI/CMakeLists.txt
+++ b/src/GUI/CMakeLists.txt
@@ -14,6 +14,8 @@ set(SOURCES
 	menubar.cxx
 	new_gui.cxx
 	property_list.cxx
+	FGFontCache.cxx
+	FGColor.cxx
 	)
 
 set(HEADERS
@@ -27,6 +29,8 @@ set(HEADERS
 	menubar.hxx
 	new_gui.hxx
 	property_list.hxx
+	FGFontCache.hxx
+	FGColor.hxx
 	)
     		
 flightgear_component(GUI "${SOURCES}" "${HEADERS}")
diff --git a/src/GUI/FGColor.cxx b/src/GUI/FGColor.cxx
new file mode 100644
index 000000000..e808af662
--- /dev/null
+++ b/src/GUI/FGColor.cxx
@@ -0,0 +1,54 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "FGColor.hxx"
+
+#include <iostream>
+
+#include <simgear/props/props.hxx>
+
+////////////////////////////////////////////////////////////////////////
+// FGColor class.
+////////////////////////////////////////////////////////////////////////
+
+void
+FGColor::print() const {
+    std::cerr << "red=" << _red << ", green=" << _green
+              << ", blue=" << _blue << ", alpha=" << _alpha << std::endl;
+}
+
+bool
+FGColor::merge(const SGPropertyNode *node)
+{
+    if (!node)
+        return false;
+
+    bool dirty = false;
+    const SGPropertyNode * n;
+    if ((n = node->getNode("red")))
+        _red = n->getFloatValue(), dirty = true;
+    if ((n = node->getNode("green")))
+        _green = n->getFloatValue(), dirty = true;
+    if ((n = node->getNode("blue")))
+        _blue = n->getFloatValue(), dirty = true;
+    if ((n = node->getNode("alpha")))
+        _alpha = n->getFloatValue(), dirty = true;
+    return dirty;
+}
+
+bool
+FGColor::merge(const FGColor *color)
+{
+    bool dirty = false;
+    if (color && color->_red >= 0.0)
+        _red = color->_red, dirty = true;
+    if (color && color->_green >= 0.0)
+        _green = color->_green, dirty = true;
+    if (color && color->_blue >= 0.0)
+        _blue = color->_blue, dirty = true;
+    if (color && color->_alpha >= 0.0)
+        _alpha = color->_alpha, dirty = true;
+    return dirty;
+}
+
diff --git a/src/GUI/FGColor.hxx b/src/GUI/FGColor.hxx
new file mode 100644
index 000000000..3a8e4d6a9
--- /dev/null
+++ b/src/GUI/FGColor.hxx
@@ -0,0 +1,49 @@
+#ifndef FG_GUI_COLOR_HXX
+#define FG_GUI_COLOR_HXX
+
+// forward decls
+class SGPropertyNode;
+
+class FGColor {
+public:
+    FGColor() { clear(); }
+    FGColor(float r, float g, float b, float a = 1.0f) { set(r, g, b, a); }
+    FGColor(const SGPropertyNode *prop) { set(prop); }
+    FGColor(FGColor *c) { 
+        if (c) set(c->_red, c->_green, c->_blue, c->_alpha);
+    }
+
+    inline void clear() { _red = _green = _blue = _alpha = -1.0f; }
+    // merges in non-negative components from property with children <red> etc.
+    bool merge(const SGPropertyNode *prop);
+    bool merge(const FGColor *color);
+
+    bool set(const SGPropertyNode *prop) { clear(); return merge(prop); };
+    bool set(const FGColor *color) { clear(); return merge(color); }
+    bool set(float r, float g, float b, float a = 1.0f) {
+        _red = r, _green = g, _blue = b, _alpha = a;
+        return true;
+    }
+    bool isValid() const {
+        return _red >= 0.0 && _green >= 0.0 && _blue >= 0.0;
+    }
+    void print() const;
+
+    inline void setRed(float red) { _red = red; }
+    inline void setGreen(float green) { _green = green; }
+    inline void setBlue(float blue) { _blue = blue; }
+    inline void setAlpha(float alpha) { _alpha = alpha; }
+
+    inline float red() const { return clamp(_red); }
+    inline float green() const { return clamp(_green); }
+    inline float blue() const { return clamp(_blue); }
+    inline float alpha() const { return _alpha < 0.0 ? 1.0 : clamp(_alpha); }
+
+protected:
+    float _red, _green, _blue, _alpha;
+
+private:
+    float clamp(float f) const { return f < 0.0 ? 0.0 : f > 1.0 ? 1.0 : f; }
+};
+
+#endif
\ No newline at end of file
diff --git a/src/GUI/FGFontCache.cxx b/src/GUI/FGFontCache.cxx
new file mode 100644
index 000000000..1f01c045b
--- /dev/null
+++ b/src/GUI/FGFontCache.cxx
@@ -0,0 +1,223 @@
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License as
+//  published by the Free Software Foundation; either version 2 of the
+//  License, or (at your option) any later version.
+// 
+//  This program is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#endif
+
+#include "FGFontCache.hxx"
+
+#include <plib/fnt.h>
+#include <plib/pu.h>
+
+#include <simgear/props/props.hxx>
+
+#include <Main/globals.hxx>
+
+////////////////////////////////////////////////////////////////////////
+// FGFontCache class.
+////////////////////////////////////////////////////////////////////////
+
+extern puFont FONT_HELVETICA_14;
+extern puFont FONT_SANS_12B;
+
+namespace
+{
+struct GuiFont
+{
+    const char *name;
+    puFont *font;
+    struct Predicate
+        : public std::unary_function<const GuiFont, bool>
+    {
+        Predicate(const char* name_) : name(name_) {}
+        bool operator() (const GuiFont& f1) const
+        {
+            return ::strcmp(f1.name, name) == 0;
+        }
+        const char* name;
+    };
+};
+
+const GuiFont guifonts[] = {
+    { "default",      &PUFONT_HELVETICA_12 },
+    { "FIXED_8x13",   &PUFONT_8_BY_13 },
+    { "FIXED_9x15",   &PUFONT_9_BY_15 },
+    { "TIMES_10",     &PUFONT_TIMES_ROMAN_10 },
+    { "TIMES_24",     &PUFONT_TIMES_ROMAN_24 },
+    { "HELVETICA_10", &PUFONT_HELVETICA_10 },
+    { "HELVETICA_12", &PUFONT_HELVETICA_12 },
+    { "HELVETICA_14", &FONT_HELVETICA_14 },
+    { "HELVETICA_18", &PUFONT_HELVETICA_18 },
+    { "SANS_12B",     &FONT_SANS_12B }
+};
+
+const GuiFont* guifontsEnd = &guifonts[sizeof(guifonts)/ sizeof(guifonts[0])];
+}
+
+FGFontCache::FGFontCache() :
+    _initialized(false)
+{
+}
+
+FGFontCache::~FGFontCache()
+{
+   PuFontMap::iterator it, end = _puFonts.end();
+   for (it = _puFonts.begin(); it != end; ++it)
+       delete it->second;
+}
+
+inline bool FGFontCache::FntParamsLess::operator()(const FntParams& f1,
+                                                   const FntParams& f2) const
+{
+    int comp = f1.name.compare(f2.name);
+    if (comp < 0)
+        return true;
+    else if (comp > 0)
+        return false;
+    if (f1.size < f2.size)
+        return true;
+    else if (f1.size > f2.size)
+        return false;
+    return f1.slant < f2.slant;
+}
+
+struct FGFontCache::fnt *
+FGFontCache::getfnt(const char *name, float size, float slant)
+{
+    std::string fontName(name);
+    FntParams fntParams(fontName, size, slant);
+    PuFontMap::iterator i = _puFonts.find(fntParams);
+    if (i != _puFonts.end())
+        return i->second;
+    // fntTexFont s are all preloaded into the _texFonts map
+    TexFontMap::iterator texi = _texFonts.find(fontName);
+    fntTexFont* texfont = 0;
+    puFont* pufont = 0;
+    if (texi != _texFonts.end()) {
+        texfont = texi->second;
+    } else {
+        const GuiFont* guifont = std::find_if(&guifonts[0], guifontsEnd,
+                                              GuiFont::Predicate(name));
+        if (guifont != guifontsEnd) {
+            pufont = guifont->font;
+        }
+    }
+    fnt* f = new fnt;
+    if (pufont) {
+        f->pufont = pufont;
+    } else if (texfont) {
+        f->texfont = texfont;
+        f->pufont = new puFont;
+        f->pufont->initialize(static_cast<fntFont *>(f->texfont), size, slant);
+    } else {
+        f->pufont = guifonts[0].font;
+    }
+    _puFonts[fntParams] = f;
+    return f;
+}
+
+puFont *
+FGFontCache::get(const char *name, float size, float slant)
+{
+    return getfnt(name, size, slant)->pufont;
+}
+
+fntTexFont *
+FGFontCache::getTexFont(const char *name, float size, float slant)
+{
+    init();
+    return getfnt(name, size, slant)->texfont;
+}
+
+puFont *
+FGFontCache::get(SGPropertyNode *node)
+{
+    if (!node)
+        return get("Helvetica.txf", 15.0, 0.0);
+
+    const char *name = node->getStringValue("name", "Helvetica.txf");
+    float size = node->getFloatValue("size", 15.0);
+    float slant = node->getFloatValue("slant", 0.0);
+
+    return get(name, size, slant);
+}
+
+void FGFontCache::init()
+{
+    if (!_initialized) {
+        char *envp = ::getenv("FG_FONTS");
+        if (envp != NULL) {
+            _path.set(envp);
+        } else {
+            _path.set(globals->get_fg_root());
+            _path.append("Fonts");
+        }
+        _initialized = true;
+    }
+}
+
+SGPath
+FGFontCache::getfntpath(const char *name)
+{
+    init();
+    SGPath path(_path);
+    if (name && std::string(name) != "") {
+        path.append(name);
+        if (path.exists())
+            return path;
+    }
+
+    path = SGPath(_path);
+    path.append("Helvetica.txf");
+    
+    return path;
+}
+
+bool FGFontCache::initializeFonts()
+{
+    static std::string fontext("txf");
+    init();
+    ulDir* fontdir = ulOpenDir(_path.c_str());
+    if (!fontdir)
+        return false;
+    const ulDirEnt *dirEntry;
+    while ((dirEntry = ulReadDir(fontdir)) != 0) {
+        SGPath path(_path);
+        path.append(dirEntry->d_name);
+        if (path.extension() == fontext) {
+            fntTexFont* f = new fntTexFont;
+            if (f->load((char *)path.c_str()))
+                _texFonts[std::string(dirEntry->d_name)] = f;
+            else
+                delete f;
+        }
+    }
+    ulCloseDir(fontdir);
+    return true;
+}
+
+FGFontCache::fnt::~fnt()
+{
+    if (texfont) { 
+        delete pufont; 
+        delete texfont;
+    }
+}
+
diff --git a/src/GUI/FGFontCache.hxx b/src/GUI/FGFontCache.hxx
new file mode 100644
index 000000000..c9d12c7a3
--- /dev/null
+++ b/src/GUI/FGFontCache.hxx
@@ -0,0 +1,96 @@
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License as
+//  published by the Free Software Foundation; either version 2 of the
+//  License, or (at your option) any later version.
+// 
+//  This program is distributed in the hope that it will be useful, but
+//  WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+#ifndef __FGFONTCACHE_HXX
+#define __FGFONTCACHE_HXX
+
+#include <simgear/math/SGMath.hxx>
+#include <simgear/misc/sg_path.hxx>
+
+#include <map>
+#include <algorithm>
+
+// forward decls
+class SGPropertyNode;
+class puFont;
+class fntTexFont;
+
+/**
+ * A class to keep all fonts available for future use.
+ * This also assures a font isn't resident more than once.
+ */
+class FGFontCache {
+private:
+    // The parameters of a request to the cache.
+    struct FntParams
+    {
+        const std::string name;
+        const float size;
+        const float slant;
+        FntParams() : size(0.0f), slant(0.0f) {}
+        FntParams(const FntParams& rhs)
+            : name(rhs.name), size(rhs.size), slant(rhs.slant)
+        {
+        }
+        FntParams(const std::string& name_, float size_, float slant_)
+            : name(name_), size(size_), slant(slant_)
+        {
+        }
+    };
+    struct FntParamsLess
+        : public std::binary_function<const FntParams, const FntParams, bool>
+    {
+        bool operator() (const FntParams& f1, const FntParams& f2) const;
+    };
+    struct fnt {
+        fnt(puFont *pu = 0) : pufont(pu), texfont(0) {}
+        ~fnt();
+        
+        // Font used by plib GUI code
+        puFont *pufont;
+        // TXF font
+        fntTexFont *texfont;
+    };
+    // Path to the font directory
+    SGPath _path;
+
+    typedef std::map<const std::string, fntTexFont*> TexFontMap;
+    typedef std::map<const FntParams, fnt*, FntParamsLess> PuFontMap;
+    TexFontMap _texFonts;
+    PuFontMap _puFonts;
+
+    bool _initialized;
+    struct fnt *getfnt(const char *name, float size, float slant);
+    void init();
+
+public:
+    FGFontCache();
+    ~FGFontCache();
+
+    puFont *get(const char *name, float size=15.0, float slant=0.0);
+    puFont *get(SGPropertyNode *node);
+
+    fntTexFont *getTexFont(const char *name, float size=15.0, float slant=0.0);
+
+    SGPath getfntpath(const char *name);
+    /**
+     * Preload all the fonts in the FlightGear font directory. It is
+     * important to load the font textures early, with the proper
+     * graphics context current, so that no plib (or our own) code
+     * tries to load a font from disk when there's no current graphics
+     * context.
+     */
+    bool initializeFonts();
+};
+#endif
diff --git a/src/GUI/dialog.cxx b/src/GUI/dialog.cxx
index 4af5b8a68..539002992 100644
--- a/src/GUI/dialog.cxx
+++ b/src/GUI/dialog.cxx
@@ -9,6 +9,8 @@
 
 #include <Scripting/NasalSys.hxx>
 #include <Main/fg_os.hxx>
+#include <Main/globals.hxx>
+#include <Main/fg_props.hxx>
 
 #include "dialog.hxx"
 #include "new_gui.hxx"
@@ -17,6 +19,8 @@
 #include "layout.hxx"
 #include "WaypointList.hxx"
 #include "MapWidget.hxx"
+#include "FGFontCache.hxx"
+#include "FGColor.hxx"
 
 enum format_type { f_INVALID, f_INT, f_LONG, f_FLOAT, f_DOUBLE, f_STRING };
 static const int FORMAT_BUFSIZE = 255;
diff --git a/src/GUI/gui.cxx b/src/GUI/gui.cxx
index 1ae94dbb0..f659d325a 100644
--- a/src/GUI/gui.cxx
+++ b/src/GUI/gui.cxx
@@ -44,6 +44,7 @@
 #include <Main/fg_props.hxx>
 #include <Main/WindowSystemAdapter.hxx>
 #include <GUI/new_gui.hxx>
+#include <GUI/FGFontCache.hxx>
 
 #include "gui.h"
 #include "layout.hxx"
diff --git a/src/GUI/new_gui.cxx b/src/GUI/new_gui.cxx
index 220d4c3fc..5f05a8f0e 100644
--- a/src/GUI/new_gui.cxx
+++ b/src/GUI/new_gui.cxx
@@ -28,9 +28,8 @@
 
 #include "menubar.hxx"
 #include "dialog.hxx"
-
-extern puFont FONT_HELVETICA_14;
-extern puFont FONT_SANS_12B;
+#include "FGFontCache.hxx"
+#include "FGColor.hxx"
 
 using std::map;
 using std::string;
@@ -326,247 +325,4 @@ NewGUI::setupFont (SGPropertyNode *node)
     return;
 }
 
-
-
-
-////////////////////////////////////////////////////////////////////////
-// FGColor class.
-////////////////////////////////////////////////////////////////////////
-
-void
-FGColor::print() const {
-    std::cerr << "red=" << _red << ", green=" << _green
-              << ", blue=" << _blue << ", alpha=" << _alpha << std::endl;
-}
-
-bool
-FGColor::merge(const SGPropertyNode *node)
-{
-    if (!node)
-        return false;
-
-    bool dirty = false;
-    const SGPropertyNode * n;
-    if ((n = node->getNode("red")))
-        _red = n->getFloatValue(), dirty = true;
-    if ((n = node->getNode("green")))
-        _green = n->getFloatValue(), dirty = true;
-    if ((n = node->getNode("blue")))
-        _blue = n->getFloatValue(), dirty = true;
-    if ((n = node->getNode("alpha")))
-        _alpha = n->getFloatValue(), dirty = true;
-    return dirty;
-}
-
-bool
-FGColor::merge(const FGColor *color)
-{
-    bool dirty = false;
-    if (color && color->_red >= 0.0)
-        _red = color->_red, dirty = true;
-    if (color && color->_green >= 0.0)
-        _green = color->_green, dirty = true;
-    if (color && color->_blue >= 0.0)
-        _blue = color->_blue, dirty = true;
-    if (color && color->_alpha >= 0.0)
-        _alpha = color->_alpha, dirty = true;
-    return dirty;
-}
-
-
-
-
-////////////////////////////////////////////////////////////////////////
-// FGFontCache class.
-////////////////////////////////////////////////////////////////////////
-
-namespace
-{
-struct GuiFont
-{
-    const char *name;
-    puFont *font;
-    struct Predicate
-        : public std::unary_function<const GuiFont, bool>
-    {
-        Predicate(const char* name_) : name(name_) {}
-        bool operator() (const GuiFont& f1) const
-        {
-            return std::strcmp(f1.name, name) == 0;
-        }
-        const char* name;
-    };
-};
-
-const GuiFont guifonts[] = {
-    { "default",      &FONT_HELVETICA_14 },
-    { "FIXED_8x13",   &PUFONT_8_BY_13 },
-    { "FIXED_9x15",   &PUFONT_9_BY_15 },
-    { "TIMES_10",     &PUFONT_TIMES_ROMAN_10 },
-    { "TIMES_24",     &PUFONT_TIMES_ROMAN_24 },
-    { "HELVETICA_10", &PUFONT_HELVETICA_10 },
-    { "HELVETICA_12", &PUFONT_HELVETICA_12 },
-    { "HELVETICA_14", &FONT_HELVETICA_14 },
-    { "HELVETICA_18", &PUFONT_HELVETICA_18 },
-    { "SANS_12B",     &FONT_SANS_12B }
-};
-
-const GuiFont* guifontsEnd = &guifonts[sizeof(guifonts)/ sizeof(guifonts[0])];
-}
-
-FGFontCache::FGFontCache() :
-    _initialized(false)
-{
-}
-
-FGFontCache::~FGFontCache()
-{
-#if defined(SG_UNIX) && !defined(SG_MAC) 
-   // Ugly workaround for a crash on exit with multiple screens configured
-   if (!glXGetCurrentContext())
-      return;
-#endif
-   PuFontMap::iterator it, end = _puFonts.end();
-   for (it = _puFonts.begin(); it != end; ++it)
-       delete it->second;
-}
-
-inline bool FGFontCache::FntParamsLess::operator()(const FntParams& f1,
-                                                   const FntParams& f2) const
-{
-    int comp = f1.name.compare(f2.name);
-    if (comp < 0)
-        return true;
-    else if (comp > 0)
-        return false;
-    if (f1.size < f2.size)
-        return true;
-    else if (f1.size > f2.size)
-        return false;
-    return f1.slant < f2.slant;
-}
-
-struct FGFontCache::fnt *
-FGFontCache::getfnt(const char *name, float size, float slant)
-{
-    string fontName = boost::to_lower_copy(string(name));
-    FntParams fntParams(fontName, size, slant);
-    PuFontMap::iterator i = _puFonts.find(fntParams);
-    if (i != _puFonts.end()) {
-        // found in the puFonts map, all done
-        return i->second;
-    }
-    
-    // fntTexFont s are all preloaded into the _texFonts map
-    TexFontMap::iterator texi = _texFonts.find(fontName);
-    fntTexFont* texfont = NULL;
-    puFont* pufont = NULL;
-    if (texi != _texFonts.end()) {
-        texfont = texi->second;
-    } else {
-        // check the built-in PUI fonts (in guifonts array)
-        const GuiFont* guifont = std::find_if(&guifonts[0], guifontsEnd,
-                                              GuiFont::Predicate(name));
-        if (guifont != guifontsEnd) {
-            pufont = guifont->font;
-        }
-    }
-    
-    fnt* f = new fnt;
-    if (pufont) {
-        f->pufont = pufont;
-    } else if (texfont) {
-        f->texfont = texfont;
-        f->pufont = new puFont;
-        f->pufont->initialize(static_cast<fntFont *>(f->texfont), size, slant);
-    } else {
-        f->pufont = guifonts[0].font;
-    }
-    _puFonts[fntParams] = f;
-    return f;
-}
-
-puFont *
-FGFontCache::get(const char *name, float size, float slant)
-{
-    return getfnt(name, size, slant)->pufont;
-}
-
-fntTexFont *
-FGFontCache::getTexFont(const char *name, float size, float slant)
-{
-    return getfnt(name, size, slant)->texfont;
-}
-
-puFont *
-FGFontCache::get(SGPropertyNode *node)
-{
-    if (!node)
-        return get("Helvetica.txf", 15.0, 0.0);
-
-    const char *name = node->getStringValue("name", "Helvetica.txf");
-    float size = node->getFloatValue("size", 15.0);
-    float slant = node->getFloatValue("slant", 0.0);
-
-    return get(name, size, slant);
-}
-
-void FGFontCache::init()
-{
-    if (_initialized) {
-        return;
-    }
-    
-    char *envp = ::getenv("FG_FONTS");
-    if (envp != NULL) {
-        _path.set(envp);
-    } else {
-        _path.set(globals->get_fg_root());
-        _path.append("Fonts");
-    }
-    _initialized = true;
-}
-
-SGPath
-FGFontCache::getfntpath(const char *name)
-{
-    init();
-    SGPath path(_path);
-    if (name && std::string(name) != "") {
-        path.append(name);
-        if (path.exists())
-            return path;
-    }
-
-    path = SGPath(_path);
-    path.append("Helvetica.txf");
-    SG_LOG(SG_GENERAL, SG_WARN, "Unknown font name '" << name << "', defaulting to Helvetica");
-    return path;
-}
-
-bool FGFontCache::initializeFonts()
-{
-    static string fontext("txf");
-    init();
-    ulDir* fontdir = ulOpenDir(_path.c_str());
-    if (!fontdir)
-        return false;
-    const ulDirEnt *dirEntry;
-    while ((dirEntry = ulReadDir(fontdir)) != 0) {
-        SGPath path(_path);
-        path.append(dirEntry->d_name);
-        if (path.extension() == fontext) {
-            fntTexFont* f = new fntTexFont;
-            if (f->load((char *)path.c_str())) {
-                // convert font names in the map to lowercase for matching
-                string fontName = boost::to_lower_copy(string(dirEntry->d_name));
-                _texFonts[fontName] = f;
-            } else
-                delete f;
-        }
-    }
-    ulCloseDir(fontdir);
-    return true;
-}
-
 // end of new_gui.cxx
diff --git a/src/GUI/new_gui.hxx b/src/GUI/new_gui.hxx
index 53590173e..422503a1a 100644
--- a/src/GUI/new_gui.hxx
+++ b/src/GUI/new_gui.hxx
@@ -3,8 +3,6 @@
 #ifndef __NEW_GUI_HXX
 #define __NEW_GUI_HXX 1
 
-#include <plib/pu.h>
-
 #include <simgear/props/props.hxx>
 #include <simgear/structure/subsystem_mgr.hxx>
 #include <simgear/misc/sg_path.hxx>
@@ -13,15 +11,13 @@
 #include <vector>
 #include <map>
 
-#include <Main/fg_props.hxx>
-
 class SGBinding;
 
 class FGMenuBar;
 class FGDialog;
 class FGColor;
 class FGFontCache;
-
+class puFont;
 
 /**
  * XML-configured GUI subsystem.
@@ -230,117 +226,5 @@ private:
 };
 
 
-class FGColor {
-public:
-    FGColor() { clear(); }
-    FGColor(float r, float g, float b, float a = 1.0f) { set(r, g, b, a); }
-    FGColor(const SGPropertyNode *prop) { set(prop); }
-    FGColor(FGColor *c) { 
-        if (c) set(c->_red, c->_green, c->_blue, c->_alpha);
-    }
-
-    inline void clear() { _red = _green = _blue = _alpha = -1.0f; }
-    // merges in non-negative components from property with children <red> etc.
-    bool merge(const SGPropertyNode *prop);
-    bool merge(const FGColor *color);
-
-    bool set(const SGPropertyNode *prop) { clear(); return merge(prop); };
-    bool set(const FGColor *color) { clear(); return merge(color); }
-    bool set(float r, float g, float b, float a = 1.0f) {
-        _red = r, _green = g, _blue = b, _alpha = a;
-        return true;
-    }
-    bool isValid() const {
-        return _red >= 0.0 && _green >= 0.0 && _blue >= 0.0;
-    }
-    void print() const;
-
-    inline void setRed(float red) { _red = red; }
-    inline void setGreen(float green) { _green = green; }
-    inline void setBlue(float blue) { _blue = blue; }
-    inline void setAlpha(float alpha) { _alpha = alpha; }
-
-    inline float red() const { return clamp(_red); }
-    inline float green() const { return clamp(_green); }
-    inline float blue() const { return clamp(_blue); }
-    inline float alpha() const { return _alpha < 0.0 ? 1.0 : clamp(_alpha); }
-
-protected:
-    float _red, _green, _blue, _alpha;
-
-private:
-    float clamp(float f) const { return f < 0.0 ? 0.0 : f > 1.0 ? 1.0 : f; }
-};
-
-
-
-/**
- * A class to keep all fonts available for future use.
- * This also assures a font isn't resident more than once.
- */
-class FGFontCache {
-private:
-    // The parameters of a request to the cache.
-    struct FntParams
-    {
-        const std::string name;
-        const float size;
-        const float slant;
-        FntParams() : size(0.0f), slant(0.0f) {}
-        FntParams(const FntParams& rhs)
-            : name(rhs.name), size(rhs.size), slant(rhs.slant)
-        {
-        }
-        FntParams(const std::string& name_, float size_, float slant_)
-            : name(name_), size(size_), slant(slant_)
-        {
-        }
-    };
-    struct FntParamsLess
-        : public std::binary_function<const FntParams, const FntParams, bool>
-    {
-        bool operator() (const FntParams& f1, const FntParams& f2) const;
-    };
-    struct fnt {
-        fnt(puFont *pu = 0) : pufont(pu), texfont(0) {}
-        ~fnt() { if (texfont) { delete pufont; delete texfont; } }
-        // Font used by plib GUI code
-        puFont *pufont;
-        // TXF font
-        fntTexFont *texfont;
-    };
-    // Path to the font directory
-    SGPath _path;
-
-    typedef std::map<const std::string, fntTexFont*> TexFontMap;
-    typedef std::map<const FntParams, fnt*, FntParamsLess> PuFontMap;
-    TexFontMap _texFonts;
-    PuFontMap _puFonts;
-
-    bool _initialized;
-    struct fnt *getfnt(const char *name, float size, float slant);
-    void init();
-
-public:
-    FGFontCache();
-    ~FGFontCache();
-
-    puFont *get(const char *name, float size=15.0, float slant=0.0);
-    puFont *get(SGPropertyNode *node);
-
-    fntTexFont *getTexFont(const char *name, float size=15.0, float slant=0.0);
-
-    SGPath getfntpath(const char *name);
-    /**
-     * Preload all the fonts in the FlightGear font directory. It is
-     * important to load the font textures early, with the proper
-     * graphics context current, so that no plib (or our own) code
-     * tries to load a font from disk when there's no current graphics
-     * context.
-     */
-    bool initializeFonts();
-};
-
-
 #endif // __NEW_GUI_HXX
 
diff --git a/src/Instrumentation/HUD/HUD.cxx b/src/Instrumentation/HUD/HUD.cxx
index 2f130ae96..8cbb2e513 100644
--- a/src/Instrumentation/HUD/HUD.cxx
+++ b/src/Instrumentation/HUD/HUD.cxx
@@ -34,9 +34,12 @@
 #include <simgear/props/props_io.hxx>
 #include <osg/GLU>
 
+#include <plib/fnt.h>
+
 #include <Main/globals.hxx>
 #include <Main/viewmgr.hxx>
 #include <Main/viewer.hxx>
+#include <GUI/FGFontCache.hxx>
 
 #include "HUD.hxx"
 
diff --git a/src/Main/globals.cxx b/src/Main/globals.cxx
index dc48bd846..e2ea2954b 100644
--- a/src/Main/globals.cxx
+++ b/src/Main/globals.cxx
@@ -47,7 +47,7 @@
 #include <ATCDCL/ATCmgr.hxx>
 #include <Autopilot/route_mgr.hxx>
 #include <Cockpit/panel.hxx>
-#include <GUI/new_gui.hxx>
+#include <GUI/FGFontCache.hxx>
 #include <Model/acmodel.hxx>
 #include <Model/modelmgr.hxx>
 #include <MultiPlayer/multiplaymgr.hxx>
@@ -220,7 +220,7 @@ void FGGlobals::set_fg_root (const string &root) {
     SGPath tmp( fg_root );
     tmp.append( "data" );
     tmp.append( "version" );
-    if ( ulFileExists( tmp.c_str() ) ) {
+    if ( tmp.exists() ) {
         fgGetNode("BAD_FG_ROOT", true)->setStringValue(fg_root);
         fg_root += "/data";
         fgGetNode("GOOD_FG_ROOT", true)->setStringValue(fg_root);
diff --git a/src/Main/main.cxx b/src/Main/main.cxx
index 3afaeceae..1cfdd7dbf 100644
--- a/src/Main/main.cxx
+++ b/src/Main/main.cxx
@@ -82,7 +82,7 @@
 #include "fg_os.hxx"
 #include "WindowSystemAdapter.hxx"
 #include <Main/viewer.hxx>
-
+#include <Main/fg_props.hxx>
 
 using namespace flightgear;
 
diff --git a/src/Main/splash.cxx b/src/Main/splash.cxx
index 5708c72e1..c3a0a7d9b 100644
--- a/src/Main/splash.cxx
+++ b/src/Main/splash.cxx
@@ -46,7 +46,10 @@
 #include <simgear/math/sg_random.h>
 #include <simgear/misc/sg_path.hxx>
 
-#include <GUI/new_gui.hxx>
+#include <plib/fnt.h>
+
+#include "GUI/FGFontCache.hxx"
+#include "GUI/FGColor.hxx"
 
 #include "globals.hxx"
 #include "fg_props.hxx"
diff --git a/utils/fgpanel/FGFontCache.cxx b/utils/fgpanel/FGFontCache.cxx
index 19a1b3746..b3bbdd6b9 100644
--- a/utils/fgpanel/FGFontCache.cxx
+++ b/utils/fgpanel/FGFontCache.cxx
@@ -22,11 +22,16 @@
 #include <windows.h>
 #endif
 
-
 #include <map>
 #include <algorithm>
+
+#include <plib/fnt.h>
+#include <plib/pu.h>
+
 #include "ApplicationProperties.hxx"
 #include "FGFontCache.hxx"
+
+
 ////////////////////////////////////////////////////////////////////////
 // FGFontCache class.
 ////////////////////////////////////////////////////////////////////////
@@ -68,6 +73,14 @@ const GuiFont guifonts[] = {
 const GuiFont* guifontsEnd = &guifonts[sizeof(guifonts)/ sizeof(guifonts[0])];
 }
 
+FGFontCache::fnt::~fnt()
+{
+    if (texfont) { 
+        delete pufont; 
+        delete texfont;
+    }
+}
+
 FGFontCache::FGFontCache() :
     _initialized(false)
 {
diff --git a/utils/fgpanel/FGFontCache.hxx b/utils/fgpanel/FGFontCache.hxx
index 2fd03d8ed..c2ff03d15 100644
--- a/utils/fgpanel/FGFontCache.hxx
+++ b/utils/fgpanel/FGFontCache.hxx
@@ -14,10 +14,16 @@
 //
 #ifndef __FGFONTCACHE_HXX
 #define __FGFONTCACHE_HXX
+
 #include <simgear/math/SGMath.hxx>
 #include <simgear/misc/sg_path.hxx>
 #include <simgear/props/props.hxx>
-#include <plib/pu.h>
+
+
+// forward declare only!
+class puFont;
+class fntTexFont;
+
 /**
  * A class to keep all fonts available for future use.
  * This also assures a font isn't resident more than once.
@@ -47,7 +53,7 @@ private:
     };
     struct fnt {
         fnt(puFont *pu = 0) : pufont(pu), texfont(0) {}
-        ~fnt() { if (texfont) { delete pufont; delete texfont; } }
+        ~fnt();
         // Font used by plib GUI code
         puFont *pufont;
         // TXF font

From 03c966de13c990787b162e37a2c046ac9c605eb8 Mon Sep 17 00:00:00 2001
From: James Turner <zakalawe@mac.com>
Date: Sat, 19 Nov 2011 20:46:17 +0000
Subject: [PATCH 03/18] Make FGDialog an interface, moving existing code to
 FGPUIDialog implementation. (no functionality change, yet)

---
 src/GUI/AirportList.hxx   |    2 +-
 src/GUI/CMakeLists.txt    |    2 +
 src/GUI/FGPUIDialog.cxx   | 1418 +++++++++++++++++++++++++++++++++++++
 src/GUI/FGPUIDialog.hxx   |  277 ++++++++
 src/GUI/WaypointList.hxx  |    2 +-
 src/GUI/dialog.cxx        | 1408 +-----------------------------------
 src/GUI/dialog.hxx        |  234 +-----
 src/GUI/new_gui.cxx       |    6 +-
 src/GUI/property_list.hxx |    2 +-
 9 files changed, 1723 insertions(+), 1628 deletions(-)
 create mode 100644 src/GUI/FGPUIDialog.cxx
 create mode 100644 src/GUI/FGPUIDialog.hxx

diff --git a/src/GUI/AirportList.hxx b/src/GUI/AirportList.hxx
index bc745930c..99d131f56 100644
--- a/src/GUI/AirportList.hxx
+++ b/src/GUI/AirportList.hxx
@@ -5,7 +5,7 @@
 
 #include <simgear/compiler.h>
 #include <plib/puAux.h>
-#include "dialog.hxx"
+#include "FGPUIDialog.hxx"
 
 class FGAirportList;
 
diff --git a/src/GUI/CMakeLists.txt b/src/GUI/CMakeLists.txt
index eee0fcd41..6fd3f4704 100644
--- a/src/GUI/CMakeLists.txt
+++ b/src/GUI/CMakeLists.txt
@@ -6,6 +6,7 @@ set(SOURCES
 	SafeTexFont.cxx
 	WaypointList.cxx
 	dialog.cxx
+	FGPUIDialog.cxx
 	fonts.cxx
 	gui.cxx
 	gui_funcs.cxx
@@ -24,6 +25,7 @@ set(HEADERS
 	SafeTexFont.hxx
 	WaypointList.hxx
 	dialog.hxx
+	FGPUIDialog.hxx
 	gui.h
 	layout.hxx
 	menubar.hxx
diff --git a/src/GUI/FGPUIDialog.cxx b/src/GUI/FGPUIDialog.cxx
new file mode 100644
index 000000000..61bba82b6
--- /dev/null
+++ b/src/GUI/FGPUIDialog.cxx
@@ -0,0 +1,1418 @@
+// dialog.cxx: implementation of an XML-configurable dialog box.
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include <simgear/structure/SGBinding.hxx>
+#include <simgear/props/props_io.hxx>
+
+#include <Scripting/NasalSys.hxx>
+#include <Main/fg_os.hxx>
+#include <Main/globals.hxx>
+#include <Main/fg_props.hxx>
+
+#include "FGPUIDialog.hxx"
+#include "new_gui.hxx"
+#include "AirportList.hxx"
+#include "property_list.hxx"
+#include "layout.hxx"
+#include "WaypointList.hxx"
+#include "MapWidget.hxx"
+#include "FGFontCache.hxx"
+#include "FGColor.hxx"
+
+enum format_type { f_INVALID, f_INT, f_LONG, f_FLOAT, f_DOUBLE, f_STRING };
+static const int FORMAT_BUFSIZE = 255;
+static const int RESIZE_MARGIN = 7;
+
+
+/**
+ * Makes sure the format matches '%[ -+#]?\d*(\.\d*)?(l?[df]|s)', with
+ * only one number or string placeholder and otherwise arbitrary prefix
+ * and postfix containing only quoted percent signs (%%).
+ */
+static format_type
+validate_format(const char *f)
+{
+    bool l = false;
+    format_type type;
+    for (; *f; f++) {
+        if (*f == '%') {
+            if (f[1] == '%')
+                f++;
+            else
+                break;
+        }
+    }
+    if (*f++ != '%')
+        return f_INVALID;
+    while (*f == ' ' || *f == '+' || *f == '-' || *f == '#' || *f == '0')
+        f++;
+    while (*f && isdigit(*f))
+        f++;
+    if (*f == '.') {
+        f++;
+        while (*f && isdigit(*f))
+            f++;
+    }
+
+    if (*f == 'l')
+        l = true, f++;
+
+    if (*f == 'd') {
+        type = l ? f_LONG : f_INT;
+    } else if (*f == 'f')
+        type = l ? f_DOUBLE : f_FLOAT;
+    else if (*f == 's') {
+        if (l)
+            return f_INVALID;
+        type = f_STRING;
+    } else
+        return f_INVALID;
+
+    for (++f; *f; f++) {
+        if (*f == '%') {
+            if (f[1] == '%')
+                f++;
+            else
+                return f_INVALID;
+        }
+    }
+    return type;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of GUIInfo.
+////////////////////////////////////////////////////////////////////////
+
+/**
+ * User data for a GUI object.
+ */
+struct GUIInfo
+{
+    GUIInfo(FGPUIDialog *d);
+    virtual ~GUIInfo();
+    void apply_format(SGPropertyNode *);
+
+    FGPUIDialog *dialog;
+    SGPropertyNode_ptr node;
+    vector <SGBinding *> bindings;
+    int key;
+    string label, legend, text, format;
+    format_type fmt_type;
+};
+
+GUIInfo::GUIInfo (FGPUIDialog *d) :
+    dialog(d),
+    key(-1),
+    fmt_type(f_INVALID)
+{
+}
+
+GUIInfo::~GUIInfo ()
+{
+    for (unsigned int i = 0; i < bindings.size(); i++) {
+        delete bindings[i];
+        bindings[i] = 0;
+    }
+}
+
+void GUIInfo::apply_format(SGPropertyNode *n)
+{
+    char buf[FORMAT_BUFSIZE + 1];
+    if (fmt_type == f_INT)
+        snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getIntValue());
+    else if (fmt_type == f_LONG)
+        snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getLongValue());
+    else if (fmt_type == f_FLOAT)
+        snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getFloatValue());
+    else if (fmt_type == f_DOUBLE)
+        snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getDoubleValue());
+    else
+        snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getStringValue());
+
+    buf[FORMAT_BUFSIZE] = '\0';
+    text = buf;
+}
+
+
+
+/**
+ * Key handler.
+ */
+int fgPopup::checkKey(int key, int updown)
+{
+    if (updown == PU_UP || !isVisible() || !isActive() || window != puGetWindow())
+        return false;
+
+    puObject *input = getActiveInputField(this);
+    if (input)
+        return input->checkKey(key, updown);
+
+    puObject *object = getKeyObject(this, key);
+    if (!object)
+        return puPopup::checkKey(key, updown);
+
+    // invokeCallback() isn't enough; we need to simulate a mouse button press
+    object->checkHit(PU_LEFT_BUTTON, PU_DOWN,
+            (object->getABox()->min[0] + object->getABox()->max[0]) / 2,
+            (object->getABox()->min[1] + object->getABox()->max[1]) / 2);
+    object->checkHit(PU_LEFT_BUTTON, PU_UP,
+            (object->getABox()->min[0] + object->getABox()->max[0]) / 2,
+            (object->getABox()->min[1] + object->getABox()->max[1]) / 2);
+    return true;
+}
+
+puObject *fgPopup::getKeyObject(puObject *object, int key)
+{
+    puObject *ret;
+    if (object->getType() & PUCLASS_GROUP)
+        for (puObject *obj = ((puGroup *)object)->getFirstChild();
+                obj; obj = obj->getNextObject())
+            if ((ret = getKeyObject(obj, key)))
+                return ret;
+
+    GUIInfo *info = (GUIInfo *)object->getUserData();
+    if (info && info->key == key)
+        return object;
+
+    return 0;
+}
+
+puObject *fgPopup::getActiveInputField(puObject *object)
+{
+    puObject *ret;
+    if (object->getType() & PUCLASS_GROUP)
+        for (puObject *obj = ((puGroup *)object)->getFirstChild();
+                obj; obj = obj->getNextObject())
+            if ((ret = getActiveInputField(obj)))
+                return ret;
+
+    if (object->getType() & (PUCLASS_INPUT|PUCLASS_LARGEINPUT)
+            && ((puInput *)object)->isAcceptingInput())
+        return object;
+
+    return 0;
+}
+
+/**
+ * Mouse handler.
+ */
+int fgPopup::checkHit(int button, int updown, int x, int y)
+{
+    int result = 0;
+    if (updown != PU_DRAG && !_dragging)
+        result = puPopup::checkHit(button, updown, x, y);
+
+    if (!_draggable)
+       return result;
+
+    // This is annoying.  We would really want a true result from the
+    // superclass to indicate "handled by child object", but all it
+    // tells us is that the pointer is inside the dialog.  So do the
+    // intersection test (again) to make sure we don't start a drag
+    // when inside controls.
+
+    if (updown == PU_DOWN && !_dragging) {
+        if (!result)
+            return 0;
+        int global_drag = fgGetKeyModifiers() & KEYMOD_SHIFT;
+        int global_resize = fgGetKeyModifiers() & KEYMOD_CTRL;
+
+        int hit = getHitObjects(this, x, y);
+        if (hit & PUCLASS_LIST)  // ctrl-click in property browser (toggle bool)
+            return result;
+        if (!global_resize && hit & (PUCLASS_BUTTON|PUCLASS_ONESHOT|PUCLASS_INPUT
+                |PUCLASS_LARGEINPUT|PUCLASS_SCROLLBAR))
+            return result;
+
+        getPosition(&_dlgX, &_dlgY);
+        getSize(&_dlgW, &_dlgH);
+        _start_cursor = fgGetMouseCursor();
+        _dragging = true;
+        _startX = x;
+        _startY = y;
+
+        // check and prepare for resizing
+        static const int cursor[] = {
+            MOUSE_CURSOR_POINTER, MOUSE_CURSOR_LEFTSIDE, MOUSE_CURSOR_RIGHTSIDE, 0,
+            MOUSE_CURSOR_TOPSIDE, MOUSE_CURSOR_TOPLEFT, MOUSE_CURSOR_TOPRIGHT, 0,
+            MOUSE_CURSOR_BOTTOMSIDE, MOUSE_CURSOR_BOTTOMLEFT, MOUSE_CURSOR_BOTTOMRIGHT, 0,
+        };
+
+        _resizing = 0;
+        if (!global_drag && _resizable) {
+            int hmargin = global_resize ? _dlgW / 3 : RESIZE_MARGIN;
+            int vmargin = global_resize ? _dlgH / 3 : RESIZE_MARGIN;
+
+            if (y - _dlgY < vmargin)
+                _resizing |= BOTTOM;
+            else if (_dlgY + _dlgH - y < vmargin)
+                _resizing |= TOP;
+
+            if (x - _dlgX < hmargin)
+                _resizing |= LEFT;
+            else if (_dlgX + _dlgW - x < hmargin)
+                _resizing |= RIGHT;
+
+            if (!_resizing && global_resize)
+                _resizing = BOTTOM|RIGHT;
+
+            _cursor = cursor[_resizing];
+           if (_resizing && _resizable)
+                fgSetMouseCursor(_cursor);
+       }
+
+    } else if (updown == PU_DRAG && _dragging) {
+        if (_resizing) {
+            GUIInfo *info = (GUIInfo *)getUserData();
+            if (_resizable && info && info->node) {
+                int w = _dlgW;
+                int h = _dlgH;
+                if (_resizing & LEFT)
+                    w += _startX - x;
+                if (_resizing & RIGHT)
+                    w += x - _startX;
+                if (_resizing & TOP)
+                    h += y - _startY;
+                if (_resizing & BOTTOM)
+                    h += _startY - y;
+
+                int prefw, prefh;
+                LayoutWidget wid(info->node);
+                wid.calcPrefSize(&prefw, &prefh);
+                if (w < prefw)
+                    w = prefw;
+                if (h < prefh)
+                    h = prefh;
+
+                int x = _dlgX;
+                int y = _dlgY;
+                if (_resizing & LEFT)
+                    x += _dlgW - w;
+                if (_resizing & BOTTOM)
+                    y += _dlgH - h;
+
+                wid.layout(x, y, w, h);
+                setSize(w, h);
+                setPosition(x, y);
+                applySize(static_cast<puObject *>(this));
+                getFirstChild()->setSize(w, h); // dialog background puFrame
+            }
+        } else {
+            int posX = x + _dlgX - _startX,
+              posY = y + _dlgY - _startY;
+            setPosition(posX, posY);
+            
+            GUIInfo *info = (GUIInfo *)getUserData();
+            if (info && info->node) {
+                info->node->setIntValue("x", posX);
+                info->node->setIntValue("y", posY);
+            }
+        } // re-positioning
+
+    } else if (_dragging) {
+        fgSetMouseCursor(_start_cursor);
+        _dragging = false;
+    }
+    return result;
+}
+
+int fgPopup::getHitObjects(puObject *object, int x, int y)
+{
+    if (!object->isVisible())
+        return 0;
+
+    int type = 0;
+    if (object->getType() & PUCLASS_GROUP)
+        for (puObject *obj = ((puGroup *)object)->getFirstChild();
+                obj; obj = obj->getNextObject())
+            type |= getHitObjects(obj, x, y);
+
+    int cx, cy, cw, ch;
+    object->getAbsolutePosition(&cx, &cy);
+    object->getSize(&cw, &ch);
+    if (x >= cx && x < cx + cw && y >= cy && y < cy + ch)
+        type |= object->getType();
+    return type;
+}
+
+void fgPopup::applySize(puObject *object)
+{
+    // compound plib widgets use setUserData() for internal purposes, so refuse
+    // to descend into anything that has other bits set than the following
+    const int validUserData = PUCLASS_VALUE|PUCLASS_OBJECT|PUCLASS_GROUP|PUCLASS_INTERFACE
+            |PUCLASS_FRAME|PUCLASS_TEXT|PUCLASS_BUTTON|PUCLASS_ONESHOT|PUCLASS_INPUT
+            |PUCLASS_ARROW|PUCLASS_DIAL|PUCLASS_POPUP;
+
+    int type = object->getType();
+    if (type & PUCLASS_GROUP && !(type & ~validUserData))
+        for (puObject *obj = ((puGroup *)object)->getFirstChild();
+                obj; obj = obj->getNextObject())
+            applySize(obj);
+
+    GUIInfo *info = (GUIInfo *)object->getUserData();
+    if (!info)
+        return;
+
+    SGPropertyNode *n = info->node;
+    if (!n) {
+        SG_LOG(SG_GENERAL, SG_ALERT, "fgPopup::applySize: no props");
+        return;
+    }
+    int x = n->getIntValue("x");
+    int y = n->getIntValue("y");
+    int w = n->getIntValue("width", 4);
+    int h = n->getIntValue("height", 4);
+    object->setPosition(x, y);
+    object->setSize(w, h);
+}
+
+////////////////////////////////////////////////////////////////////////
+
+void FGPUIDialog::ConditionalObject::update(FGPUIDialog* aDlg)
+{
+  if (_name == "visible") {
+    bool wasVis = _pu->isVisible() != 0;
+    bool newVis = test();
+    
+    if (newVis == wasVis) {
+      return;
+    }
+    
+    if (newVis) { // puObject needs a setVisible. Oh well.
+    _pu->reveal();
+    } else {
+      _pu->hide();
+    }
+  } else if (_name == "enable") {
+    bool wasEnabled = _pu->isActive() != 0;
+    bool newEnable = test();
+    
+    if (wasEnabled == newEnable) {
+      return;
+    }
+    
+    if (newEnable) {
+      _pu->activate();
+    } else {
+      _pu->greyOut();
+    }
+  }
+  
+  aDlg->setNeedsLayout();
+}
+////////////////////////////////////////////////////////////////////////
+// Callbacks.
+////////////////////////////////////////////////////////////////////////
+
+/**
+ * Action callback.
+ */
+static void
+action_callback (puObject *object)
+{
+    GUIInfo *info = (GUIInfo *)object->getUserData();
+    NewGUI *gui = (NewGUI *)globals->get_subsystem("gui");
+    gui->setActiveDialog(info->dialog);
+    int nBindings = info->bindings.size();
+    for (int i = 0; i < nBindings; i++) {
+        info->bindings[i]->fire();
+        if (gui->getActiveDialog() == 0)
+            break;
+    }
+    gui->setActiveDialog(0);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Static helper functions.
+////////////////////////////////////////////////////////////////////////
+
+/**
+ * Copy a property value to a PUI object.
+ */
+static void
+copy_to_pui (SGPropertyNode *node, puObject *object)
+{
+    using namespace simgear;
+    GUIInfo *info = (GUIInfo *)object->getUserData();
+    if (!info) {
+        SG_LOG(SG_GENERAL, SG_ALERT, "dialog: widget without GUIInfo!");
+        return;   // this can't really happen
+    }
+
+    // Treat puText objects specially, so their "values" can be set
+    // from properties.
+    if (object->getType() & PUCLASS_TEXT) {
+        if (info->fmt_type != f_INVALID)
+            info->apply_format(node);
+        else
+            info->text = node->getStringValue();
+
+        object->setLabel(info->text.c_str());
+        return;
+    }
+
+    switch (node->getType()) {
+    case props::BOOL:
+    case props::INT:
+    case props::LONG:
+        object->setValue(node->getIntValue());
+        break;
+    case props::FLOAT:
+    case props::DOUBLE:
+        object->setValue(node->getFloatValue());
+        break;
+    default:
+        info->text = node->getStringValue();
+        object->setValue(info->text.c_str());
+        break;
+    }
+}
+
+
+static void
+copy_from_pui (puObject *object, SGPropertyNode *node)
+{
+    using namespace simgear;
+    // puText objects are immutable, so should not be copied out
+    if (object->getType() & PUCLASS_TEXT)
+        return;
+
+    switch (node->getType()) {
+    case props::BOOL:
+    case props::INT:
+    case props::LONG:
+        node->setIntValue(object->getIntegerValue());
+        break;
+    case props::FLOAT:
+    case props::DOUBLE:
+        node->setFloatValue(object->getFloatValue());
+        break;
+    default:
+        const char *s = object->getStringValue();
+        if (s)
+            node->setStringValue(s);
+        break;
+    }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGDialog.
+////////////////////////////////////////////////////////////////////////
+
+FGPUIDialog::FGPUIDialog (SGPropertyNode *props) :
+    FGDialog(props),
+    _object(0),
+    _gui((NewGUI *)globals->get_subsystem("gui")),
+    _props(props),
+    _needsRelayout(false)
+{
+    _module = string("__dlg:") + props->getStringValue("name", "[unnamed]");
+        
+    SGPropertyNode *nasal = props->getNode("nasal");
+    if (nasal) {
+        _nasal_close = nasal->getNode("close");
+        SGPropertyNode *open = nasal->getNode("open");
+        if (open) {
+            const char *s = open->getStringValue();
+            FGNasalSys *nas = (FGNasalSys *)globals->get_subsystem("nasal");
+            if (nas)
+                nas->createModule(_module.c_str(), _module.c_str(), s, strlen(s), props);
+        }
+    }
+    display(props);
+}
+
+FGPUIDialog::~FGPUIDialog ()
+{
+    int x, y;
+    _object->getAbsolutePosition(&x, &y);
+    _props->setIntValue("lastx", x);
+    _props->setIntValue("lasty", y);
+
+    FGNasalSys *nas = (FGNasalSys *)globals->get_subsystem("nasal");
+    if (nas) {
+        if (_nasal_close) {
+            const char *s = _nasal_close->getStringValue();
+            nas->createModule(_module.c_str(), _module.c_str(), s, strlen(s), _props);
+        }
+        nas->deleteModule(_module.c_str());
+    }
+
+    puDeleteObject(_object);
+
+    unsigned int i;
+                                // Delete all the info objects we
+                                // were forced to keep around because
+                                // PUI cannot delete its own user data.
+    for (i = 0; i < _info.size(); i++) {
+        delete (GUIInfo *)_info[i];
+        _info[i] = 0;
+    }
+                                // Finally, delete the property links.
+    for (i = 0; i < _propertyObjects.size(); i++) {
+        delete _propertyObjects[i];
+        _propertyObjects[i] = 0;
+    }
+}
+
+void
+FGPUIDialog::updateValues (const char *objectName)
+{
+    if (objectName && !objectName[0])
+        objectName = 0;
+
+  for (unsigned int i = 0; i < _propertyObjects.size(); i++) {
+    const string &name = _propertyObjects[i]->name;
+    if (objectName && name != objectName) {
+      continue;
+    }
+    
+    puObject *widget = _propertyObjects[i]->object;
+    int widgetType = widget->getType();
+    if (widgetType & PUCLASS_LIST) {
+      GUI_ID* gui_id = dynamic_cast<GUI_ID *>(widget);
+      if (gui_id && (gui_id->id & FGCLASS_LIST)) {
+        fgList *pl = static_cast<fgList*>(widget);
+        pl->update();
+      } else {
+        copy_to_pui(_propertyObjects[i]->node, widget);
+      }
+    } else if (widgetType & PUCLASS_COMBOBOX) {
+      fgComboBox* combo = static_cast<fgComboBox*>(widget);
+      combo->update();
+    } else {
+      copy_to_pui(_propertyObjects[i]->node, widget);
+    }
+  } // of property objects iteration
+}
+
+void
+FGPUIDialog::applyValues (const char *objectName)
+{
+    if (objectName && !objectName[0])
+        objectName = 0;
+
+    for (unsigned int i = 0; i < _propertyObjects.size(); i++) {
+        const string &name = _propertyObjects[i]->name;
+        if (objectName && name != objectName)
+            continue;
+
+        copy_from_pui(_propertyObjects[i]->object,
+                      _propertyObjects[i]->node);
+    }
+}
+
+void
+FGPUIDialog::update ()
+{
+    for (unsigned int i = 0; i < _liveObjects.size(); i++) {
+        puObject *obj = _liveObjects[i]->object;
+        if (obj->getType() & PUCLASS_INPUT && ((puInput *)obj)->isAcceptingInput())
+            continue;
+
+        copy_to_pui(_liveObjects[i]->node, obj);
+    }
+    
+  for (unsigned int j=0; j < _conditionalObjects.size(); ++j) {
+    _conditionalObjects[j]->update(this);
+  }
+  
+  if (_needsRelayout) {
+    relayout();
+  }
+}
+
+void
+FGPUIDialog::display (SGPropertyNode *props)
+{
+    if (_object != 0) {
+        SG_LOG(SG_GENERAL, SG_ALERT, "This widget is already active");
+        return;
+    }
+
+    int screenw = globals->get_props()->getIntValue("/sim/startup/xsize");
+    int screenh = globals->get_props()->getIntValue("/sim/startup/ysize");
+
+    bool userx = props->hasValue("x");
+    bool usery = props->hasValue("y");
+    bool userw = props->hasValue("width");
+    bool userh = props->hasValue("height");
+
+    // Let the layout widget work in the same property subtree.
+    LayoutWidget wid(props);
+
+    SGPropertyNode *fontnode = props->getNode("font");
+    if (fontnode) {
+        FGFontCache *fc = globals->get_fontcache();
+        _font = fc->get(fontnode);
+    } else {
+        _font = _gui->getDefaultFont();
+    }
+    wid.setDefaultFont(_font, int(_font->getPointSize()));
+
+    int pw = 0, ph = 0;
+    int px, py, savex, savey;
+    if (!userw || !userh)
+        wid.calcPrefSize(&pw, &ph);
+    pw = props->getIntValue("width", pw);
+    ph = props->getIntValue("height", ph);
+    px = savex = props->getIntValue("x", (screenw - pw) / 2);
+    py = savey = props->getIntValue("y", (screenh - ph) / 2);
+
+    // Negative x/y coordinates are interpreted as distance from the top/right
+    // corner rather than bottom/left.
+    if (userx && px < 0)
+        px = screenw - pw + px;
+    if (usery && py < 0)
+        py = screenh - ph + py;
+
+    // Define "x", "y", "width" and/or "height" in the property tree if they
+    // are not specified in the configuration file.
+    wid.layout(px, py, pw, ph);
+
+    // Use the dimension and location properties as specified in the
+    // configuration file or from the layout widget.
+    _object = makeObject(props, screenw, screenh);
+
+    // Remove automatically generated properties, so the layout looks
+    // the same next time around, or restore x and y to preserve negative coords.
+    if (userx)
+        props->setIntValue("x", savex);
+    else
+        props->removeChild("x");
+
+    if (usery)
+        props->setIntValue("y", savey);
+    else
+        props->removeChild("y");
+
+    if (!userw) props->removeChild("width");
+    if (!userh) props->removeChild("height");
+
+    if (_object != 0) {
+        _object->reveal();
+    } else {
+        SG_LOG(SG_GENERAL, SG_ALERT, "Widget "
+               << props->getStringValue("name", "[unnamed]")
+               << " does not contain a proper GUI definition");
+    }
+}
+
+puObject *
+FGPUIDialog::makeObject (SGPropertyNode *props, int parentWidth, int parentHeight)
+{
+    if (!props->getBoolValue("enabled", true))
+        return 0;
+
+    bool presetSize = props->hasValue("width") && props->hasValue("height");
+    int width = props->getIntValue("width", parentWidth);
+    int height = props->getIntValue("height", parentHeight);
+    int x = props->getIntValue("x", (parentWidth - width) / 2);
+    int y = props->getIntValue("y", (parentHeight - height) / 2);
+    string type = props->getName();
+
+    if (type.empty())
+        type = "dialog";
+
+    if (type == "dialog") {
+        puPopup *obj;
+        bool draggable = props->getBoolValue("draggable", true);
+        bool resizable = props->getBoolValue("resizable", false);
+        if (props->getBoolValue("modal", false))
+            obj = new puDialogBox(x, y);
+        else
+            obj = new fgPopup(x, y, resizable, draggable);
+        setupGroup(obj, props, width, height, true);
+        setColor(obj, props);
+        return obj;
+
+    } else if (type == "group") {
+        puGroup *obj = new puGroup(x, y);
+        setupGroup(obj, props, width, height, false);
+        setColor(obj, props);
+        return obj;
+
+    } else if (type == "frame") {
+        puGroup *obj = new puGroup(x, y);
+        setupGroup(obj, props, width, height, true);
+        setColor(obj, props);
+        return obj;
+
+    } else if (type == "hrule" || type == "vrule") {
+        puFrame *obj = new puFrame(x, y, x + width, y + height);
+        obj->setBorderThickness(0);
+        setupObject(obj, props);
+        setColor(obj, props, BACKGROUND|FOREGROUND|HIGHLIGHT);
+        return obj;
+
+    } else if (type == "list") {
+        int slider_width = props->getIntValue("slider", 20);
+        fgList *obj = new fgList(x, y, x + width, y + height, props, slider_width);
+        if (presetSize)
+            obj->setSize(width, height);
+        setupObject(obj, props);
+        setColor(obj, props);
+        return obj;
+
+    } else if (type == "airport-list") {
+        AirportList *obj = new AirportList(x, y, x + width, y + height);
+        if (presetSize)
+            obj->setSize(width, height);
+        setupObject(obj, props);
+        setColor(obj, props);
+        return obj;
+
+    } else if (type == "property-list") {
+        PropertyList *obj = new PropertyList(x, y, x + width, y + height, globals->get_props());
+        if (presetSize)
+            obj->setSize(width, height);
+        setupObject(obj, props);
+        setColor(obj, props);
+        return obj;
+
+    } else if (type == "input") {
+        puInput *obj = new puInput(x, y, x + width, y + height);
+        setupObject(obj, props);
+        setColor(obj, props, FOREGROUND|LABEL);
+        return obj;
+
+    } else if (type == "text") {
+        puText *obj = new puText(x, y);
+        setupObject(obj, props);
+
+        // Layed-out objects need their size set, and non-layout ones
+        // get a different placement.
+        if (presetSize)
+            obj->setSize(width, height);
+        else
+            obj->setLabelPlace(PUPLACE_LABEL_DEFAULT);
+        setColor(obj, props, LABEL);
+        return obj;
+
+    } else if (type == "checkbox") {
+        puButton *obj;
+        obj = new puButton(x, y, x + width, y + height, PUBUTTON_XCHECK);
+        setupObject(obj, props);
+        setColor(obj, props, FOREGROUND|LABEL);
+        return obj;
+
+    } else if (type == "radio") {
+        puButton *obj;
+        obj = new puButton(x, y, x + width, y + height, PUBUTTON_CIRCLE);
+        setupObject(obj, props);
+        setColor(obj, props, FOREGROUND|LABEL);
+        return obj;
+
+    } else if (type == "button") {
+        puButton *obj;
+        const char *legend = props->getStringValue("legend", "[none]");
+        if (props->getBoolValue("one-shot", true))
+            obj = new puOneShot(x, y, legend);
+        else
+            obj = new puButton(x, y, legend);
+        if (presetSize)
+            obj->setSize(width, height);
+        setupObject(obj, props);
+        setColor(obj, props);
+        return obj;
+    } else if (type == "map") {
+        MapWidget* mapWidget = new MapWidget(x, y, x + width, y + height);
+        setupObject(mapWidget, props);
+        return mapWidget;
+    } else if (type == "combo") {
+        fgComboBox *obj = new fgComboBox(x, y, x + width, y + height, props,
+                props->getBoolValue("editable", false));
+        setupObject(obj, props);
+        setColor(obj, props, EDITFIELD);
+        return obj;
+
+    } else if (type == "slider") {
+        bool vertical = props->getBoolValue("vertical", false);
+        puSlider *obj = new puSlider(x, y, (vertical ? height : width), vertical);
+        obj->setMinValue(props->getFloatValue("min", 0.0));
+        obj->setMaxValue(props->getFloatValue("max", 1.0));
+        obj->setStepSize(props->getFloatValue("step"));
+        obj->setSliderFraction(props->getFloatValue("fraction"));
+#if PLIB_VERSION > 185
+        obj->setPageStepSize(props->getFloatValue("pagestep"));
+#endif
+        setupObject(obj, props);
+        if (presetSize)
+            obj->setSize(width, height);
+        setColor(obj, props, FOREGROUND|LABEL);
+        return obj;
+
+    } else if (type == "dial") {
+        puDial *obj = new puDial(x, y, width);
+        obj->setMinValue(props->getFloatValue("min", 0.0));
+        obj->setMaxValue(props->getFloatValue("max", 1.0));
+        obj->setWrap(props->getBoolValue("wrap", true));
+        setupObject(obj, props);
+        setColor(obj, props, FOREGROUND|LABEL);
+        return obj;
+
+    } else if (type == "textbox") {
+        int slider_width = props->getIntValue("slider", 20);
+        int wrap = props->getBoolValue("wrap", true);
+#if PLIB_VERSION > 185
+        puaLargeInput *obj = new puaLargeInput(x, y,
+                x + width, x + height, 11, slider_width, wrap);
+#else
+        puaLargeInput *obj = new puaLargeInput(x, y,
+                x + width, x + height, 2, slider_width, wrap);
+#endif
+
+        if (props->getBoolValue("editable"))
+            obj->enableInput();
+        else
+            obj->disableInput();
+
+        if (presetSize)
+            obj->setSize(width, height);
+        setupObject(obj, props);
+        setColor(obj, props, FOREGROUND|LABEL);
+
+        int top = props->getIntValue("top-line", 0);
+        obj->setTopLineInWindow(top < 0 ? unsigned(-1) >> 1 : top);
+        return obj;
+
+    } else if (type == "select") {
+        fgSelectBox *obj = new fgSelectBox(x, y, x + width, y + height, props);
+        setupObject(obj, props);
+        setColor(obj, props, EDITFIELD);
+        return obj;
+    } else if (type == "waypointlist") {
+        ScrolledWaypointList* obj = new ScrolledWaypointList(x, y, width, height);
+        setupObject(obj, props);
+        return obj;
+    } else {
+        return 0;
+    }
+}
+
+void
+FGPUIDialog::setupObject (puObject *object, SGPropertyNode *props)
+{
+    GUIInfo *info = new GUIInfo(this);
+    object->setUserData(info);
+    _info.push_back(info);
+    object->setLabelPlace(PUPLACE_CENTERED_RIGHT);
+    object->makeReturnDefault(props->getBoolValue("default"));
+    info->node = props;
+
+    if (props->hasValue("legend")) {
+        info->legend = props->getStringValue("legend");
+        object->setLegend(info->legend.c_str());
+    }
+
+    if (props->hasValue("label")) {
+        info->label = props->getStringValue("label");
+        object->setLabel(info->label.c_str());
+    }
+
+    if (props->hasValue("border"))
+        object->setBorderThickness( props->getIntValue("border", 2) );
+
+    if (SGPropertyNode *nft = props->getNode("font", false)) {
+       FGFontCache *fc = globals->get_fontcache();
+       puFont *lfnt = fc->get(nft);
+       object->setLabelFont(*lfnt);
+       object->setLegendFont(*lfnt);
+    } else {
+       object->setLabelFont(*_font);
+    }
+
+    if (props->hasChild("visible")) {
+      ConditionalObject* cnd = new ConditionalObject("visible", object);
+      cnd->setCondition(sgReadCondition(globals->get_props(), props->getChild("visible")));
+      _conditionalObjects.push_back(cnd);
+    }
+
+    if (props->hasChild("enable")) {
+      ConditionalObject* cnd = new ConditionalObject("enable", object);
+      cnd->setCondition(sgReadCondition(globals->get_props(), props->getChild("enable")));
+      _conditionalObjects.push_back(cnd);
+    }
+
+    string type = props->getName();
+    if (type == "input" && props->getBoolValue("live"))
+        object->setDownCallback(action_callback);
+
+    if (type == "text") {
+        const char *format = props->getStringValue("format", 0);
+        if (format) {
+            info->fmt_type = validate_format(format);
+            if (info->fmt_type != f_INVALID)
+                info->format = format;
+            else
+                SG_LOG(SG_GENERAL, SG_ALERT, "DIALOG: invalid <format> '"
+                        << format << '\'');
+        }
+    }
+
+    if (props->hasValue("property")) {
+        const char *name = props->getStringValue("name");
+        if (name == 0)
+            name = "";
+        const char *propname = props->getStringValue("property");
+        SGPropertyNode_ptr node = fgGetNode(propname, true);
+        if (type == "map") {
+          // mapWidget binds to a sub-tree of properties, and
+          // ignores the puValue mechanism, so special case things here
+          MapWidget* mw = static_cast<MapWidget*>(object);
+          mw->setProperty(node);
+        } else {
+            // normal widget, creating PropertyObject
+            copy_to_pui(node, object);
+            PropertyObject *po = new PropertyObject(name, object, node);
+            _propertyObjects.push_back(po);
+            if (props->getBoolValue("live"))
+                _liveObjects.push_back(po);
+        }
+        
+
+    }
+
+    SGPropertyNode *dest = fgGetNode("/sim/bindings/gui", true);
+    vector<SGPropertyNode_ptr> bindings = props->getChildren("binding");
+    if (bindings.size() > 0) {
+        info->key = props->getIntValue("keynum", -1);
+        if (props->hasValue("key"))
+            info->key = getKeyCode(props->getStringValue("key", ""));
+
+        for (unsigned int i = 0; i < bindings.size(); i++) {
+            unsigned int j = 0;
+            SGPropertyNode_ptr binding;
+            while (dest->getChild("binding", j))
+                j++;
+
+            const char *cmd = bindings[i]->getStringValue("command");
+            if (!strcmp(cmd, "nasal"))
+                bindings[i]->setStringValue("module", _module.c_str());
+
+            binding = dest->getChild("binding", j, true);
+            copyProperties(bindings[i], binding);
+            info->bindings.push_back(new SGBinding(binding, globals->get_props()));
+        }
+        object->setCallback(action_callback);
+    }
+}
+
+void
+FGPUIDialog::setupGroup(puGroup *group, SGPropertyNode *props,
+       int width, int height, bool makeFrame)
+{
+    setupObject(group, props);
+
+    if (makeFrame) {
+        puFrame* f = new puFrame(0, 0, width, height);
+        setColor(f, props);
+    }
+
+    int nChildren = props->nChildren();
+    for (int i = 0; i < nChildren; i++)
+        makeObject(props->getChild(i), width, height);
+    group->close();
+}
+
+void
+FGPUIDialog::setColor(puObject *object, SGPropertyNode *props, int which)
+{
+    string type = props->getName();
+    if (type.empty())
+        type = "dialog";
+    if (type == "textbox" && props->getBoolValue("editable"))
+        type += "-editable";
+
+    FGColor c(_gui->getColor("background"));
+    c.merge(_gui->getColor(type));
+    c.merge(props->getNode("color"));
+    if (c.isValid())
+        object->setColourScheme(c.red(), c.green(), c.blue(), c.alpha());
+
+    const struct {
+        int mask;
+        int id;
+        const char *name;
+        const char *cname;
+    } pucol[] = {
+        { BACKGROUND, PUCOL_BACKGROUND, "background", "color-background" },
+        { FOREGROUND, PUCOL_FOREGROUND, "foreground", "color-foreground" },
+        { HIGHLIGHT,  PUCOL_HIGHLIGHT,  "highlight",  "color-highlight" },
+        { LABEL,      PUCOL_LABEL,      "label",      "color-label" },
+        { LEGEND,     PUCOL_LEGEND,     "legend",     "color-legend" },
+        { MISC,       PUCOL_MISC,       "misc",       "color-misc" },
+        { EDITFIELD,  PUCOL_EDITFIELD,  "editfield",  "color-editfield" },
+    };
+
+    const int numcol = sizeof(pucol) / sizeof(pucol[0]);
+
+    for (int i = 0; i < numcol; i++) {
+        bool dirty = false;
+        c.clear();
+        c.setAlpha(1.0);
+
+        dirty |= c.merge(_gui->getColor(type + '-' + pucol[i].name));
+        if (which & pucol[i].mask)
+            dirty |= c.merge(props->getNode("color"));
+
+        if ((pucol[i].mask == LABEL) && !c.isValid())
+            dirty |= c.merge(_gui->getColor("label"));
+
+        dirty |= c.merge(props->getNode(pucol[i].cname));
+
+        if (c.isValid() && dirty)
+            object->setColor(pucol[i].id, c.red(), c.green(), c.blue(), c.alpha());
+    }
+}
+
+
+static struct {
+    const char *name;
+    int key;
+} keymap[] = {
+    {"backspace", 8},
+    {"tab", 9},
+    {"return", 13},
+    {"enter", 13},
+    {"esc", 27},
+    {"escape", 27},
+    {"space", ' '},
+    {"&amp;", '&'},
+    {"and", '&'},
+    {"&lt;", '<'},
+    {"&gt;", '>'},
+    {"f1", PU_KEY_F1},
+    {"f2", PU_KEY_F2},
+    {"f3", PU_KEY_F3},
+    {"f4", PU_KEY_F4},
+    {"f5", PU_KEY_F5},
+    {"f6", PU_KEY_F6},
+    {"f7", PU_KEY_F7},
+    {"f8", PU_KEY_F8},
+    {"f9", PU_KEY_F9},
+    {"f10", PU_KEY_F10},
+    {"f11", PU_KEY_F11},
+    {"f12", PU_KEY_F12},
+    {"left", PU_KEY_LEFT},
+    {"up", PU_KEY_UP},
+    {"right", PU_KEY_RIGHT},
+    {"down", PU_KEY_DOWN},
+    {"pageup", PU_KEY_PAGE_UP},
+    {"pagedn", PU_KEY_PAGE_DOWN},
+    {"home", PU_KEY_HOME},
+    {"end", PU_KEY_END},
+    {"insert", PU_KEY_INSERT},
+    {0, -1},
+};
+
+int
+FGPUIDialog::getKeyCode(const char *str)
+{
+    enum {
+        CTRL = 0x1,
+        SHIFT = 0x2,
+        ALT = 0x4,
+    };
+
+    while (*str == ' ')
+        str++;
+
+    char *buf = new char[strlen(str) + 1];
+    strcpy(buf, str);
+    char *s = buf + strlen(buf);
+    while (s > str && s[-1] == ' ')
+        s--;
+    *s = 0;
+    s = buf;
+
+    int mod = 0;
+    while (1) {
+        if (!strncmp(s, "Ctrl-", 5) || !strncmp(s, "CTRL-", 5))
+            s += 5, mod |= CTRL;
+        else if (!strncmp(s, "Shift-", 6) || !strncmp(s, "SHIFT-", 6))
+            s += 6, mod |= SHIFT;
+        else if (!strncmp(s, "Alt-", 4) || !strncmp(s, "ALT-", 4))
+            s += 4, mod |= ALT;
+        else
+            break;
+    }
+
+    int key = -1;
+    if (strlen(s) == 1 && isascii(*s)) {
+        key = *s;
+        if (mod & SHIFT)
+            key = toupper(key);
+        if (mod & CTRL)
+            key = toupper(key) - '@';
+        /* if (mod & ALT)
+            ;   // Alt not propagated to the gui
+        */
+    } else {
+        for (char *t = s; *t; t++)
+            *t = tolower(*t);
+        for (int i = 0; keymap[i].name; i++) {
+            if (!strcmp(s, keymap[i].name)) {
+                key = keymap[i].key;
+                break;
+            }
+        }
+    }
+    delete[] buf;
+    return key;
+}
+
+voidFGPUIDialog::relayout()
+{
+  _needsRelayout = false;
+  
+  int screenw = globals->get_props()->getIntValue("/sim/startup/xsize");
+  int screenh = globals->get_props()->getIntValue("/sim/startup/ysize");
+
+  bool userx = _props->hasValue("x");
+  bool usery = _props->hasValue("y");
+  bool userw = _props->hasValue("width");
+  bool userh = _props->hasValue("height");
+
+  // Let the layout widget work in the same property subtree.
+  LayoutWidget wid(_props);
+  wid.setDefaultFont(_font, int(_font->getPointSize()));
+
+  int pw = 0, ph = 0;
+  int px, py, savex, savey;
+  if (!userw || !userh) {
+    wid.calcPrefSize(&pw, &ph);
+  }
+  
+  pw = _props->getIntValue("width", pw);
+  ph = _props->getIntValue("height", ph);
+  px = savex = _props->getIntValue("x", (screenw - pw) / 2);
+  py = savey = _props->getIntValue("y", (screenh - ph) / 2);
+
+  // Negative x/y coordinates are interpreted as distance from the top/right
+  // corner rather than bottom/left.
+  if (userx && px < 0)
+    px = screenw - pw + px;
+  if (usery && py < 0)
+    py = screenh - ph + py;
+
+  // Define "x", "y", "width" and/or "height" in the property tree if they
+  // are not specified in the configuration file.
+  wid.layout(px, py, pw, ph);
+
+  applySize(_object);
+  
+  // Remove automatically generated properties, so the layout looks
+  // the same next time around, or restore x and y to preserve negative coords.
+  if (userx)
+      _props->setIntValue("x", savex);
+  else
+      _props->removeChild("x");
+
+  if (usery)
+      _props->setIntValue("y", savey);
+  else
+      _props->removeChild("y");
+
+  if (!userw) _props->removeChild("width");
+  if (!userh) _props->removeChild("height");
+}
+
+void
+FGPUIDialog::applySize(puObject *object)
+{
+  // compound plib widgets use setUserData() for internal purposes, so refuse
+  // to descend into anything that has other bits set than the following
+  const int validUserData = PUCLASS_VALUE|PUCLASS_OBJECT|PUCLASS_GROUP|PUCLASS_INTERFACE
+          |PUCLASS_FRAME|PUCLASS_TEXT|PUCLASS_BUTTON|PUCLASS_ONESHOT|PUCLASS_INPUT
+          |PUCLASS_ARROW|PUCLASS_DIAL|PUCLASS_POPUP;
+
+  int type = object->getType();
+  if ((type & PUCLASS_GROUP) && !(type & ~validUserData)) {
+    puObject* c = ((puGroup *)object)->getFirstChild();
+    for (; c != NULL; c = c->getNextObject()) {
+      applySize(c);
+    } // of child iteration
+  } // of group object case
+  
+  GUIInfo *info = (GUIInfo *)object->getUserData();
+  if (!info)
+    return;
+
+  SGPropertyNode *n = info->node;
+  if (!n) {
+    SG_LOG(SG_GENERAL, SG_ALERT, "FGDialog::applySize: no props");
+    return;
+  }
+  
+  int x = n->getIntValue("x");
+  int y = n->getIntValue("y");
+  int w = n->getIntValue("width", 4);
+  int h = n->getIntValue("height", 4);
+  object->setPosition(x, y);
+  object->setSize(w, h);
+}
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGDialog::PropertyObject.
+////////////////////////////////////////////////////////////////////////
+
+FGPUIDialog::PropertyObject::PropertyObject(const char *n,
+        puObject *o, SGPropertyNode_ptr p) :
+    name(n),
+    object(o),
+    node(p)
+{
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of fgValueList and derived pui widgets
+////////////////////////////////////////////////////////////////////////
+
+
+fgValueList::fgValueList(SGPropertyNode *p) :
+    _props(p)
+{
+    make_list();
+}
+
+void
+fgValueList::update()
+{
+    destroy_list();
+    make_list();
+}
+
+fgValueList::~fgValueList()
+{
+    destroy_list();
+}
+
+void
+fgValueList::make_list()
+{
+  SGPropertyNode_ptr values = _props;
+  const char* vname = "value";
+  
+  if (_props->hasChild("properties")) {
+    // dynamic values, read from a property's children
+    const char* path = _props->getStringValue("properties");
+    values = fgGetNode(path, true);
+  }
+  
+  if (_props->hasChild("property-name")) {
+    vname = _props->getStringValue("property-name");
+  }
+  
+  vector<SGPropertyNode_ptr> value_nodes = values->getChildren(vname);
+  _list = new char *[value_nodes.size() + 1];
+  unsigned int i;
+  for (i = 0; i < value_nodes.size(); i++) {
+    _list[i] = strdup((char *)value_nodes[i]->getStringValue());
+  }
+  _list[i] = 0;
+}
+
+void
+fgValueList::destroy_list()
+{
+    for (int i = 0; _list[i] != 0; i++)
+        if (_list[i])
+            free(_list[i]);
+    delete[] _list;
+}
+
+
+
+void
+fgList::update()
+{
+    fgValueList::update();
+    int top = getTopItem();
+    newList(_list);
+    setTopItem(top);
+}
+
+void fgComboBox::update()
+{
+  if (_inHit) {
+    return;
+  }
+  
+  std::string curValue(getStringValue());
+  fgValueList::update();
+  newList(_list);
+  int currentItem = puaComboBox::getCurrentItem();
+
+  
+// look for the previous value, in the new list
+  for (int i = 0; _list[i] != 0; i++) {
+    if (_list[i] == curValue) {
+    // don't set the current item again; this is important to avoid
+    // recursion here if the combo callback ultimately causes another dialog-update
+      if (i != currentItem) {
+        puaComboBox::setCurrentItem(i);
+      }
+      
+      return;
+    }
+  } // of list values iteration
+  
+// cound't find current item, default to first
+  if (currentItem != 0) {
+    puaComboBox::setCurrentItem(0);
+  }
+}
+
+int fgComboBox::checkHit(int b, int up, int x, int y)
+{
+  _inHit = true;
+  int r = puaComboBox::checkHit(b, up, x, y);
+  _inHit = false;
+  return r;
+}
+
+void fgComboBox::setSize(int w, int h)
+{
+  puaComboBox::setSize(w, h);
+  recalc_bbox();
+}
+
+void fgComboBox::recalc_bbox()
+{
+// bug-fix for issue #192
+// http://code.google.com/p/flightgear-bugs/issues/detail?id=192
+// puaComboBox is including the height of its popupMenu in the height
+// computation, which breaks layout computations.
+// this implementation skips popup-menus
+  
+  puBox contents;
+  contents.empty();
+  
+  for (puObject *bo = dlist; bo != NULL; bo = bo -> getNextObject()) {
+    if (bo->getType() & PUCLASS_POPUPMENU) {
+      continue;
+    }
+    
+    contents.extend (bo -> getBBox()) ;
+  }
+  
+  abox.max[0] = abox.min[0] + contents.max[0] ;
+  abox.max[1] = abox.min[1] + contents.max[1] ;
+
+  puObject::recalc_bbox () ;
+
+}
+
+// end of FGPUIDialog.cxx
diff --git a/src/GUI/FGPUIDialog.hxx b/src/GUI/FGPUIDialog.hxx
new file mode 100644
index 000000000..e3a158e8b
--- /dev/null
+++ b/src/GUI/FGPUIDialog.hxx
@@ -0,0 +1,277 @@
+// FGPUIDialog.hxx - XML-configured dialog box.
+
+#ifndef FG_PUI_DIALOG_HXX
+#define FG_PUI_DIALOG_HXX 1
+
+#include "dialog.hxx"
+
+#include <plib/puAux.h>
+
+#include <simgear/props/props.hxx>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/props/condition.hxx>
+
+#include <vector>
+
+
+// ugly temporary workaround for plib's lack of user defined class ids  FIXME
+#define FGCLASS_LIST          0x00000001
+#define FGCLASS_AIRPORTLIST   0x00000002
+#define FGCLASS_PROPERTYLIST  0x00000004
+#define FGCLASS_WAYPOINTLIST  0x00000008
+
+class GUI_ID { public: GUI_ID(int id) : id(id) {} virtual ~GUI_ID() {} int id; };
+
+
+
+class NewGUI;
+class FGColor;
+class puObject;
+class puFont;
+
+/**
+ * An XML-configured dialog box.
+ *
+ * The GUI manager stores only the property tree for the dialog
+ * boxes.  This class creates a PUI dialog box on demand from
+ * the properties in that tree.  The manager recreates the dialog
+ * every time it needs to show it.
+ */
+class FGPUIDialog : public FGDialog
+{
+public:
+
+    /**
+     * Construct a new GUI widget configured by a property tree.
+     *
+     * The configuration properties are not part of the main
+     * FlightGear property tree; the GUI manager reads them
+     * from individual configuration files.
+     *
+     * @param props A property tree describing the dialog.
+     */
+    FGPUIDialog (SGPropertyNode * props);
+
+
+    /**
+     * Destructor.
+     */
+    virtual ~FGPUIDialog ();
+
+
+    /**
+     * Update the values of all GUI objects with a specific name,
+     * or all if name is 0 (default).
+     *
+     * This method copies values from the FlightGear property tree to
+     * the GUI object(s).
+     *
+     * @param objectName The name of the GUI object(s) to update.
+     *        Use the empty name for all unnamed objects.
+     */
+    virtual void updateValues (const char * objectName = 0);
+
+
+    /**
+     * Apply the values of all GUI objects with a specific name,
+     * or all if name is 0 (default)
+     *
+     * This method copies values from the GUI object(s) to the
+     * FlightGear property tree.
+     *
+     * @param objectName The name of the GUI object(s) to update.
+     *        Use the empty name for all unnamed objects.
+     */
+    virtual void applyValues (const char * objectName = 0);
+
+
+    /**
+     * Update state.  Called on active dialogs before rendering.
+     */
+    virtual void update ();
+
+    /**
+     * Recompute the dialog's layout
+     */
+    void relayout();
+    
+    
+    void setNeedsLayout() {
+      _needsRelayout = true;
+    }
+private:
+
+    enum {
+        BACKGROUND = 0x01,
+        FOREGROUND = 0x02,
+        HIGHLIGHT = 0x04,
+        LABEL = 0x08,
+        LEGEND = 0x10,
+        MISC = 0x20,
+        EDITFIELD = 0x40
+    };
+
+    // Show the dialog.
+    void display (SGPropertyNode * props);
+
+    // Build the dialog or a subobject of it.
+    puObject * makeObject (SGPropertyNode * props,
+                           int parentWidth, int parentHeight);
+
+    // Common configuration for all GUI objects.
+    void setupObject (puObject * object, SGPropertyNode * props);
+
+    // Common configuration for all GUI group objects.
+    void setupGroup (puGroup * group, SGPropertyNode * props,
+                     int width, int height, bool makeFrame = false);
+
+    // Set object colors: the "which" argument defines which color qualities
+    // (PUCOL_LABEL, etc.) should pick up the <color> property.
+    void setColor(puObject * object, SGPropertyNode * props, int which = 0);
+
+    // return key code number for keystring
+    int getKeyCode(const char *keystring);
+
+    /**
+     * Apply layout sizes to a tree of puObjects
+     */
+    void applySize(puObject *object);
+
+    // The top-level PUI object.
+    puObject * _object;
+
+    // The GUI subsystem.
+    NewGUI * _gui;
+
+    // The dialog font. Defaults to the global gui font, but can get
+    // overridden by a top level font definition.
+    puFont * _font;
+
+    // The source xml tree, so that we can pass data back, such as the
+    // last position.
+    SGPropertyNode_ptr _props;
+
+    bool _needsRelayout;
+
+    // Nasal module.
+    std::string _module;
+    SGPropertyNode_ptr _nasal_close;
+
+    // PUI provides no way for userdata to be deleted automatically
+    // with a GUI object, so we have to keep track of all the special
+    // data we allocated and then free it manually when the dialog
+    // closes.
+    std::vector<void *> _info;
+    struct PropertyObject {
+        PropertyObject (const char * name,
+                        puObject * object,
+                        SGPropertyNode_ptr node);
+        std::string name;
+        puObject * object;
+        SGPropertyNode_ptr node;
+    };
+    std::vector<PropertyObject *> _propertyObjects;
+    std::vector<PropertyObject *> _liveObjects;
+    
+    class ConditionalObject : public SGConditional
+    {
+    public:
+      ConditionalObject(const std::string& aName, puObject* aPu) :
+        _name(aName),
+        _pu(aPu)
+      { ; }
+    
+      void update(FGPUIDialog* aDlg);
+    
+    private:
+      const std::string _name;
+      puObject* _pu;      
+    };
+    
+    typedef SGSharedPtr<ConditionalObject> ConditionalObjectRef;
+    std::vector<ConditionalObjectRef> _conditionalObjects;
+};
+
+//
+// Custom subclass of puPopup to implement "draggable" windows in the
+// interface.  Note that this is a subclass of puPopup, not
+// puDialogBox.  Sadly, PUI (mis)uses subclassing to implement a
+// boolean property: modality.  That means that we can't implement
+// dragging of both puPopup windows and puDialogBoxes with the same
+// code.  Rather than duplicate code, I've chosen to implement only
+// "non-modal dragability" here.  Modal dialog boxes (like the exit
+// confirmation) are not draggable.
+//
+class fgPopup : public puPopup {
+public:
+    fgPopup(int x, int y, bool r = true, bool d = true) :
+            puPopup(x, y), _draggable(d), _resizable(r), _dragging(false)
+    {}
+    int checkHit(int b, int up, int x, int y);
+    int checkKey(int key, int updown);
+    int getHitObjects(puObject *, int x, int y);
+    puObject *getKeyObject(puObject *, int key);
+    puObject *getActiveInputField(puObject *);
+    void applySize(puObject *);
+private:
+    enum { LEFT = 1, RIGHT = 2, TOP = 4, BOTTOM = 8 };
+    bool _draggable;
+    bool _resizable;
+    bool _dragging;
+    int _resizing;
+    int _start_cursor;
+    int _cursor;
+    int _dlgX, _dlgY, _dlgW, _dlgH;
+    int _startX, _startY;
+};
+
+
+class fgValueList {
+public:
+    fgValueList(SGPropertyNode *p);
+    virtual ~fgValueList();
+    virtual void update();
+
+protected:
+    char **_list;
+
+private:
+    void make_list();
+    void destroy_list();
+    SGPropertyNode_ptr _props;
+};
+
+
+class fgList : public fgValueList, public puaList, public GUI_ID {
+public:
+    fgList(int x1, int y1, int x2, int y2, SGPropertyNode *p, int sw) :
+            fgValueList(p), puaList(x1, y1, x2, y2, _list, sw), GUI_ID(FGCLASS_LIST) {}
+    void update();
+};
+
+class fgComboBox : public fgValueList, public puaComboBox {
+public:
+    fgComboBox(int x1, int y1, int x2, int y2, SGPropertyNode *p, bool editable) :
+        fgValueList(p), 
+        puaComboBox(x1, y1, x2, y2, _list, editable),
+        _inHit(false)
+      {}
+        
+    void update();
+    
+    virtual void setSize(int w, int h);
+    
+    virtual int checkHit(int b, int up, int x, int y);
+    
+    virtual void recalc_bbox();
+private:
+    bool _inHit;
+};
+
+class fgSelectBox : public fgValueList, public puaSelectBox {
+public:
+    fgSelectBox(int x1, int y1, int x2, int y2, SGPropertyNode *p) :
+        fgValueList(p), puaSelectBox(x1, y1, x2, y2, _list) {}
+};
+
+#endif // __DIALOG_HXX
diff --git a/src/GUI/WaypointList.hxx b/src/GUI/WaypointList.hxx
index 46a386b59..4176d751f 100644
--- a/src/GUI/WaypointList.hxx
+++ b/src/GUI/WaypointList.hxx
@@ -10,7 +10,7 @@
 
 #include <plib/pu.h>
 
-#include "dialog.hxx" // for GUI_ID
+#include "FGPUIDialog.hxx" // for GUI_ID
 
 // forward decls
 class puaScrollBar;
diff --git a/src/GUI/dialog.cxx b/src/GUI/dialog.cxx
index 539002992..43827164c 100644
--- a/src/GUI/dialog.cxx
+++ b/src/GUI/dialog.cxx
@@ -4,1414 +4,16 @@
 #  include "config.h"
 #endif
 
-#include <simgear/structure/SGBinding.hxx>
-#include <simgear/props/props_io.hxx>
-
-#include <Scripting/NasalSys.hxx>
-#include <Main/fg_os.hxx>
-#include <Main/globals.hxx>
-#include <Main/fg_props.hxx>
-
 #include "dialog.hxx"
-#include "new_gui.hxx"
-#include "AirportList.hxx"
-#include "property_list.hxx"
-#include "layout.hxx"
-#include "WaypointList.hxx"
-#include "MapWidget.hxx"
-#include "FGFontCache.hxx"
-#include "FGColor.hxx"
 
-enum format_type { f_INVALID, f_INT, f_LONG, f_FLOAT, f_DOUBLE, f_STRING };
-static const int FORMAT_BUFSIZE = 255;
-static const int RESIZE_MARGIN = 7;
-
-
-/**
- * Makes sure the format matches '%[ -+#]?\d*(\.\d*)?(l?[df]|s)', with
- * only one number or string placeholder and otherwise arbitrary prefix
- * and postfix containing only quoted percent signs (%%).
- */
-static format_type
-validate_format(const char *f)
+FGDialog::FGDialog (SGPropertyNode *)
 {
-    bool l = false;
-    format_type type;
-    for (; *f; f++) {
-        if (*f == '%') {
-            if (f[1] == '%')
-                f++;
-            else
-                break;
-        }
-    }
-    if (*f++ != '%')
-        return f_INVALID;
-    while (*f == ' ' || *f == '+' || *f == '-' || *f == '#' || *f == '0')
-        f++;
-    while (*f && isdigit(*f))
-        f++;
-    if (*f == '.') {
-        f++;
-        while (*f && isdigit(*f))
-            f++;
-    }
-
-    if (*f == 'l')
-        l = true, f++;
-
-    if (*f == 'd') {
-        type = l ? f_LONG : f_INT;
-    } else if (*f == 'f')
-        type = l ? f_DOUBLE : f_FLOAT;
-    else if (*f == 's') {
-        if (l)
-            return f_INVALID;
-        type = f_STRING;
-    } else
-        return f_INVALID;
-
-    for (++f; *f; f++) {
-        if (*f == '%') {
-            if (f[1] == '%')
-                f++;
-            else
-                return f_INVALID;
-        }
-    }
-    return type;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-// Implementation of GUIInfo.
-////////////////////////////////////////////////////////////////////////
-
-/**
- * User data for a GUI object.
- */
-struct GUIInfo
-{
-    GUIInfo(FGDialog *d);
-    virtual ~GUIInfo();
-    void apply_format(SGPropertyNode *);
-
-    FGDialog *dialog;
-    SGPropertyNode_ptr node;
-    vector <SGBinding *> bindings;
-    int key;
-    string label, legend, text, format;
-    format_type fmt_type;
-};
-
-GUIInfo::GUIInfo (FGDialog *d) :
-    dialog(d),
-    key(-1),
-    fmt_type(f_INVALID)
-{
-}
-
-GUIInfo::~GUIInfo ()
-{
-    for (unsigned int i = 0; i < bindings.size(); i++) {
-        delete bindings[i];
-        bindings[i] = 0;
-    }
-}
-
-void GUIInfo::apply_format(SGPropertyNode *n)
-{
-    char buf[FORMAT_BUFSIZE + 1];
-    if (fmt_type == f_INT)
-        snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getIntValue());
-    else if (fmt_type == f_LONG)
-        snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getLongValue());
-    else if (fmt_type == f_FLOAT)
-        snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getFloatValue());
-    else if (fmt_type == f_DOUBLE)
-        snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getDoubleValue());
-    else
-        snprintf(buf, FORMAT_BUFSIZE, format.c_str(), n->getStringValue());
-
-    buf[FORMAT_BUFSIZE] = '\0';
-    text = buf;
-}
-
-
-
-/**
- * Key handler.
- */
-int fgPopup::checkKey(int key, int updown)
-{
-    if (updown == PU_UP || !isVisible() || !isActive() || window != puGetWindow())
-        return false;
-
-    puObject *input = getActiveInputField(this);
-    if (input)
-        return input->checkKey(key, updown);
-
-    puObject *object = getKeyObject(this, key);
-    if (!object)
-        return puPopup::checkKey(key, updown);
-
-    // invokeCallback() isn't enough; we need to simulate a mouse button press
-    object->checkHit(PU_LEFT_BUTTON, PU_DOWN,
-            (object->getABox()->min[0] + object->getABox()->max[0]) / 2,
-            (object->getABox()->min[1] + object->getABox()->max[1]) / 2);
-    object->checkHit(PU_LEFT_BUTTON, PU_UP,
-            (object->getABox()->min[0] + object->getABox()->max[0]) / 2,
-            (object->getABox()->min[1] + object->getABox()->max[1]) / 2);
-    return true;
-}
-
-puObject *fgPopup::getKeyObject(puObject *object, int key)
-{
-    puObject *ret;
-    if (object->getType() & PUCLASS_GROUP)
-        for (puObject *obj = ((puGroup *)object)->getFirstChild();
-                obj; obj = obj->getNextObject())
-            if ((ret = getKeyObject(obj, key)))
-                return ret;
-
-    GUIInfo *info = (GUIInfo *)object->getUserData();
-    if (info && info->key == key)
-        return object;
-
-    return 0;
-}
-
-puObject *fgPopup::getActiveInputField(puObject *object)
-{
-    puObject *ret;
-    if (object->getType() & PUCLASS_GROUP)
-        for (puObject *obj = ((puGroup *)object)->getFirstChild();
-                obj; obj = obj->getNextObject())
-            if ((ret = getActiveInputField(obj)))
-                return ret;
-
-    if (object->getType() & (PUCLASS_INPUT|PUCLASS_LARGEINPUT)
-            && ((puInput *)object)->isAcceptingInput())
-        return object;
-
-    return 0;
-}
-
-/**
- * Mouse handler.
- */
-int fgPopup::checkHit(int button, int updown, int x, int y)
-{
-    int result = 0;
-    if (updown != PU_DRAG && !_dragging)
-        result = puPopup::checkHit(button, updown, x, y);
-
-    if (!_draggable)
-       return result;
-
-    // This is annoying.  We would really want a true result from the
-    // superclass to indicate "handled by child object", but all it
-    // tells us is that the pointer is inside the dialog.  So do the
-    // intersection test (again) to make sure we don't start a drag
-    // when inside controls.
-
-    if (updown == PU_DOWN && !_dragging) {
-        if (!result)
-            return 0;
-        int global_drag = fgGetKeyModifiers() & KEYMOD_SHIFT;
-        int global_resize = fgGetKeyModifiers() & KEYMOD_CTRL;
-
-        int hit = getHitObjects(this, x, y);
-        if (hit & PUCLASS_LIST)  // ctrl-click in property browser (toggle bool)
-            return result;
-        if (!global_resize && hit & (PUCLASS_BUTTON|PUCLASS_ONESHOT|PUCLASS_INPUT
-                |PUCLASS_LARGEINPUT|PUCLASS_SCROLLBAR))
-            return result;
-
-        getPosition(&_dlgX, &_dlgY);
-        getSize(&_dlgW, &_dlgH);
-        _start_cursor = fgGetMouseCursor();
-        _dragging = true;
-        _startX = x;
-        _startY = y;
-
-        // check and prepare for resizing
-        static const int cursor[] = {
-            MOUSE_CURSOR_POINTER, MOUSE_CURSOR_LEFTSIDE, MOUSE_CURSOR_RIGHTSIDE, 0,
-            MOUSE_CURSOR_TOPSIDE, MOUSE_CURSOR_TOPLEFT, MOUSE_CURSOR_TOPRIGHT, 0,
-            MOUSE_CURSOR_BOTTOMSIDE, MOUSE_CURSOR_BOTTOMLEFT, MOUSE_CURSOR_BOTTOMRIGHT, 0,
-        };
-
-        _resizing = 0;
-        if (!global_drag && _resizable) {
-            int hmargin = global_resize ? _dlgW / 3 : RESIZE_MARGIN;
-            int vmargin = global_resize ? _dlgH / 3 : RESIZE_MARGIN;
-
-            if (y - _dlgY < vmargin)
-                _resizing |= BOTTOM;
-            else if (_dlgY + _dlgH - y < vmargin)
-                _resizing |= TOP;
-
-            if (x - _dlgX < hmargin)
-                _resizing |= LEFT;
-            else if (_dlgX + _dlgW - x < hmargin)
-                _resizing |= RIGHT;
-
-            if (!_resizing && global_resize)
-                _resizing = BOTTOM|RIGHT;
-
-            _cursor = cursor[_resizing];
-           if (_resizing && _resizable)
-                fgSetMouseCursor(_cursor);
-       }
-
-    } else if (updown == PU_DRAG && _dragging) {
-        if (_resizing) {
-            GUIInfo *info = (GUIInfo *)getUserData();
-            if (_resizable && info && info->node) {
-                int w = _dlgW;
-                int h = _dlgH;
-                if (_resizing & LEFT)
-                    w += _startX - x;
-                if (_resizing & RIGHT)
-                    w += x - _startX;
-                if (_resizing & TOP)
-                    h += y - _startY;
-                if (_resizing & BOTTOM)
-                    h += _startY - y;
-
-                int prefw, prefh;
-                LayoutWidget wid(info->node);
-                wid.calcPrefSize(&prefw, &prefh);
-                if (w < prefw)
-                    w = prefw;
-                if (h < prefh)
-                    h = prefh;
-
-                int x = _dlgX;
-                int y = _dlgY;
-                if (_resizing & LEFT)
-                    x += _dlgW - w;
-                if (_resizing & BOTTOM)
-                    y += _dlgH - h;
-
-                wid.layout(x, y, w, h);
-                setSize(w, h);
-                setPosition(x, y);
-                applySize(static_cast<puObject *>(this));
-                getFirstChild()->setSize(w, h); // dialog background puFrame
-            }
-        } else {
-            int posX = x + _dlgX - _startX,
-              posY = y + _dlgY - _startY;
-            setPosition(posX, posY);
-            
-            GUIInfo *info = (GUIInfo *)getUserData();
-            if (info && info->node) {
-                info->node->setIntValue("x", posX);
-                info->node->setIntValue("y", posY);
-            }
-        } // re-positioning
-
-    } else if (_dragging) {
-        fgSetMouseCursor(_start_cursor);
-        _dragging = false;
-    }
-    return result;
-}
-
-int fgPopup::getHitObjects(puObject *object, int x, int y)
-{
-    if (!object->isVisible())
-        return 0;
-
-    int type = 0;
-    if (object->getType() & PUCLASS_GROUP)
-        for (puObject *obj = ((puGroup *)object)->getFirstChild();
-                obj; obj = obj->getNextObject())
-            type |= getHitObjects(obj, x, y);
-
-    int cx, cy, cw, ch;
-    object->getAbsolutePosition(&cx, &cy);
-    object->getSize(&cw, &ch);
-    if (x >= cx && x < cx + cw && y >= cy && y < cy + ch)
-        type |= object->getType();
-    return type;
-}
-
-void fgPopup::applySize(puObject *object)
-{
-    // compound plib widgets use setUserData() for internal purposes, so refuse
-    // to descend into anything that has other bits set than the following
-    const int validUserData = PUCLASS_VALUE|PUCLASS_OBJECT|PUCLASS_GROUP|PUCLASS_INTERFACE
-            |PUCLASS_FRAME|PUCLASS_TEXT|PUCLASS_BUTTON|PUCLASS_ONESHOT|PUCLASS_INPUT
-            |PUCLASS_ARROW|PUCLASS_DIAL|PUCLASS_POPUP;
-
-    int type = object->getType();
-    if (type & PUCLASS_GROUP && !(type & ~validUserData))
-        for (puObject *obj = ((puGroup *)object)->getFirstChild();
-                obj; obj = obj->getNextObject())
-            applySize(obj);
-
-    GUIInfo *info = (GUIInfo *)object->getUserData();
-    if (!info)
-        return;
-
-    SGPropertyNode *n = info->node;
-    if (!n) {
-        SG_LOG(SG_GENERAL, SG_ALERT, "fgPopup::applySize: no props");
-        return;
-    }
-    int x = n->getIntValue("x");
-    int y = n->getIntValue("y");
-    int w = n->getIntValue("width", 4);
-    int h = n->getIntValue("height", 4);
-    object->setPosition(x, y);
-    object->setSize(w, h);
-}
-
-////////////////////////////////////////////////////////////////////////
-
-void FGDialog::ConditionalObject::update(FGDialog* aDlg)
-{
-  if (_name == "visible") {
-    bool wasVis = _pu->isVisible() != 0;
-    bool newVis = test();
     
-    if (newVis == wasVis) {
-      return;
-    }
+}
+
+FGDialog::~FGDialog()
+{
     
-    if (newVis) { // puObject needs a setVisible. Oh well.
-    _pu->reveal();
-    } else {
-      _pu->hide();
-    }
-  } else if (_name == "enable") {
-    bool wasEnabled = _pu->isActive() != 0;
-    bool newEnable = test();
-    
-    if (wasEnabled == newEnable) {
-      return;
-    }
-    
-    if (newEnable) {
-      _pu->activate();
-    } else {
-      _pu->greyOut();
-    }
-  }
-  
-  aDlg->setNeedsLayout();
-}
-////////////////////////////////////////////////////////////////////////
-// Callbacks.
-////////////////////////////////////////////////////////////////////////
-
-/**
- * Action callback.
- */
-static void
-action_callback (puObject *object)
-{
-    GUIInfo *info = (GUIInfo *)object->getUserData();
-    NewGUI *gui = (NewGUI *)globals->get_subsystem("gui");
-    gui->setActiveDialog(info->dialog);
-    int nBindings = info->bindings.size();
-    for (int i = 0; i < nBindings; i++) {
-        info->bindings[i]->fire();
-        if (gui->getActiveDialog() == 0)
-            break;
-    }
-    gui->setActiveDialog(0);
-}
-
-
-
-////////////////////////////////////////////////////////////////////////
-// Static helper functions.
-////////////////////////////////////////////////////////////////////////
-
-/**
- * Copy a property value to a PUI object.
- */
-static void
-copy_to_pui (SGPropertyNode *node, puObject *object)
-{
-    using namespace simgear;
-    GUIInfo *info = (GUIInfo *)object->getUserData();
-    if (!info) {
-        SG_LOG(SG_GENERAL, SG_ALERT, "dialog: widget without GUIInfo!");
-        return;   // this can't really happen
-    }
-
-    // Treat puText objects specially, so their "values" can be set
-    // from properties.
-    if (object->getType() & PUCLASS_TEXT) {
-        if (info->fmt_type != f_INVALID)
-            info->apply_format(node);
-        else
-            info->text = node->getStringValue();
-
-        object->setLabel(info->text.c_str());
-        return;
-    }
-
-    switch (node->getType()) {
-    case props::BOOL:
-    case props::INT:
-    case props::LONG:
-        object->setValue(node->getIntValue());
-        break;
-    case props::FLOAT:
-    case props::DOUBLE:
-        object->setValue(node->getFloatValue());
-        break;
-    default:
-        info->text = node->getStringValue();
-        object->setValue(info->text.c_str());
-        break;
-    }
-}
-
-
-static void
-copy_from_pui (puObject *object, SGPropertyNode *node)
-{
-    using namespace simgear;
-    // puText objects are immutable, so should not be copied out
-    if (object->getType() & PUCLASS_TEXT)
-        return;
-
-    switch (node->getType()) {
-    case props::BOOL:
-    case props::INT:
-    case props::LONG:
-        node->setIntValue(object->getIntegerValue());
-        break;
-    case props::FLOAT:
-    case props::DOUBLE:
-        node->setFloatValue(object->getFloatValue());
-        break;
-    default:
-        const char *s = object->getStringValue();
-        if (s)
-            node->setStringValue(s);
-        break;
-    }
-}
-
-
-
-////////////////////////////////////////////////////////////////////////
-// Implementation of FGDialog.
-////////////////////////////////////////////////////////////////////////
-
-FGDialog::FGDialog (SGPropertyNode *props) :
-    _object(0),
-    _gui((NewGUI *)globals->get_subsystem("gui")),
-    _props(props),
-    _needsRelayout(false)
-{
-    _module = string("__dlg:") + props->getStringValue("name", "[unnamed]");
-        
-    SGPropertyNode *nasal = props->getNode("nasal");
-    if (nasal) {
-        _nasal_close = nasal->getNode("close");
-        SGPropertyNode *open = nasal->getNode("open");
-        if (open) {
-            const char *s = open->getStringValue();
-            FGNasalSys *nas = (FGNasalSys *)globals->get_subsystem("nasal");
-            if (nas)
-                nas->createModule(_module.c_str(), _module.c_str(), s, strlen(s), props);
-        }
-    }
-    display(props);
-}
-
-FGDialog::~FGDialog ()
-{
-    int x, y;
-    _object->getAbsolutePosition(&x, &y);
-    _props->setIntValue("lastx", x);
-    _props->setIntValue("lasty", y);
-
-    FGNasalSys *nas = (FGNasalSys *)globals->get_subsystem("nasal");
-    if (nas) {
-        if (_nasal_close) {
-            const char *s = _nasal_close->getStringValue();
-            nas->createModule(_module.c_str(), _module.c_str(), s, strlen(s), _props);
-        }
-        nas->deleteModule(_module.c_str());
-    }
-
-    puDeleteObject(_object);
-
-    unsigned int i;
-                                // Delete all the info objects we
-                                // were forced to keep around because
-                                // PUI cannot delete its own user data.
-    for (i = 0; i < _info.size(); i++) {
-        delete (GUIInfo *)_info[i];
-        _info[i] = 0;
-    }
-                                // Finally, delete the property links.
-    for (i = 0; i < _propertyObjects.size(); i++) {
-        delete _propertyObjects[i];
-        _propertyObjects[i] = 0;
-    }
-}
-
-void
-FGDialog::updateValues (const char *objectName)
-{
-    if (objectName && !objectName[0])
-        objectName = 0;
-
-  for (unsigned int i = 0; i < _propertyObjects.size(); i++) {
-    const string &name = _propertyObjects[i]->name;
-    if (objectName && name != objectName) {
-      continue;
-    }
-    
-    puObject *widget = _propertyObjects[i]->object;
-    int widgetType = widget->getType();
-    if (widgetType & PUCLASS_LIST) {
-      GUI_ID* gui_id = dynamic_cast<GUI_ID *>(widget);
-      if (gui_id && (gui_id->id & FGCLASS_LIST)) {
-        fgList *pl = static_cast<fgList*>(widget);
-        pl->update();
-      } else {
-        copy_to_pui(_propertyObjects[i]->node, widget);
-      }
-    } else if (widgetType & PUCLASS_COMBOBOX) {
-      fgComboBox* combo = static_cast<fgComboBox*>(widget);
-      combo->update();
-    } else {
-      copy_to_pui(_propertyObjects[i]->node, widget);
-    }
-  } // of property objects iteration
-}
-
-void
-FGDialog::applyValues (const char *objectName)
-{
-    if (objectName && !objectName[0])
-        objectName = 0;
-
-    for (unsigned int i = 0; i < _propertyObjects.size(); i++) {
-        const string &name = _propertyObjects[i]->name;
-        if (objectName && name != objectName)
-            continue;
-
-        copy_from_pui(_propertyObjects[i]->object,
-                      _propertyObjects[i]->node);
-    }
-}
-
-void
-FGDialog::update ()
-{
-    for (unsigned int i = 0; i < _liveObjects.size(); i++) {
-        puObject *obj = _liveObjects[i]->object;
-        if (obj->getType() & PUCLASS_INPUT && ((puInput *)obj)->isAcceptingInput())
-            continue;
-
-        copy_to_pui(_liveObjects[i]->node, obj);
-    }
-    
-  for (unsigned int j=0; j < _conditionalObjects.size(); ++j) {
-    _conditionalObjects[j]->update(this);
-  }
-  
-  if (_needsRelayout) {
-    relayout();
-  }
-}
-
-void
-FGDialog::display (SGPropertyNode *props)
-{
-    if (_object != 0) {
-        SG_LOG(SG_GENERAL, SG_ALERT, "This widget is already active");
-        return;
-    }
-
-    int screenw = globals->get_props()->getIntValue("/sim/startup/xsize");
-    int screenh = globals->get_props()->getIntValue("/sim/startup/ysize");
-
-    bool userx = props->hasValue("x");
-    bool usery = props->hasValue("y");
-    bool userw = props->hasValue("width");
-    bool userh = props->hasValue("height");
-
-    // Let the layout widget work in the same property subtree.
-    LayoutWidget wid(props);
-
-    SGPropertyNode *fontnode = props->getNode("font");
-    if (fontnode) {
-        FGFontCache *fc = globals->get_fontcache();
-        _font = fc->get(fontnode);
-    } else {
-        _font = _gui->getDefaultFont();
-    }
-    wid.setDefaultFont(_font, int(_font->getPointSize()));
-
-    int pw = 0, ph = 0;
-    int px, py, savex, savey;
-    if (!userw || !userh)
-        wid.calcPrefSize(&pw, &ph);
-    pw = props->getIntValue("width", pw);
-    ph = props->getIntValue("height", ph);
-    px = savex = props->getIntValue("x", (screenw - pw) / 2);
-    py = savey = props->getIntValue("y", (screenh - ph) / 2);
-
-    // Negative x/y coordinates are interpreted as distance from the top/right
-    // corner rather than bottom/left.
-    if (userx && px < 0)
-        px = screenw - pw + px;
-    if (usery && py < 0)
-        py = screenh - ph + py;
-
-    // Define "x", "y", "width" and/or "height" in the property tree if they
-    // are not specified in the configuration file.
-    wid.layout(px, py, pw, ph);
-
-    // Use the dimension and location properties as specified in the
-    // configuration file or from the layout widget.
-    _object = makeObject(props, screenw, screenh);
-
-    // Remove automatically generated properties, so the layout looks
-    // the same next time around, or restore x and y to preserve negative coords.
-    if (userx)
-        props->setIntValue("x", savex);
-    else
-        props->removeChild("x");
-
-    if (usery)
-        props->setIntValue("y", savey);
-    else
-        props->removeChild("y");
-
-    if (!userw) props->removeChild("width");
-    if (!userh) props->removeChild("height");
-
-    if (_object != 0) {
-        _object->reveal();
-    } else {
-        SG_LOG(SG_GENERAL, SG_ALERT, "Widget "
-               << props->getStringValue("name", "[unnamed]")
-               << " does not contain a proper GUI definition");
-    }
-}
-
-puObject *
-FGDialog::makeObject (SGPropertyNode *props, int parentWidth, int parentHeight)
-{
-    if (!props->getBoolValue("enabled", true))
-        return 0;
-
-    bool presetSize = props->hasValue("width") && props->hasValue("height");
-    int width = props->getIntValue("width", parentWidth);
-    int height = props->getIntValue("height", parentHeight);
-    int x = props->getIntValue("x", (parentWidth - width) / 2);
-    int y = props->getIntValue("y", (parentHeight - height) / 2);
-    string type = props->getName();
-
-    if (type.empty())
-        type = "dialog";
-
-    if (type == "dialog") {
-        puPopup *obj;
-        bool draggable = props->getBoolValue("draggable", true);
-        bool resizable = props->getBoolValue("resizable", false);
-        if (props->getBoolValue("modal", false))
-            obj = new puDialogBox(x, y);
-        else
-            obj = new fgPopup(x, y, resizable, draggable);
-        setupGroup(obj, props, width, height, true);
-        setColor(obj, props);
-        return obj;
-
-    } else if (type == "group") {
-        puGroup *obj = new puGroup(x, y);
-        setupGroup(obj, props, width, height, false);
-        setColor(obj, props);
-        return obj;
-
-    } else if (type == "frame") {
-        puGroup *obj = new puGroup(x, y);
-        setupGroup(obj, props, width, height, true);
-        setColor(obj, props);
-        return obj;
-
-    } else if (type == "hrule" || type == "vrule") {
-        puFrame *obj = new puFrame(x, y, x + width, y + height);
-        obj->setBorderThickness(0);
-        setupObject(obj, props);
-        setColor(obj, props, BACKGROUND|FOREGROUND|HIGHLIGHT);
-        return obj;
-
-    } else if (type == "list") {
-        int slider_width = props->getIntValue("slider", 20);
-        fgList *obj = new fgList(x, y, x + width, y + height, props, slider_width);
-        if (presetSize)
-            obj->setSize(width, height);
-        setupObject(obj, props);
-        setColor(obj, props);
-        return obj;
-
-    } else if (type == "airport-list") {
-        AirportList *obj = new AirportList(x, y, x + width, y + height);
-        if (presetSize)
-            obj->setSize(width, height);
-        setupObject(obj, props);
-        setColor(obj, props);
-        return obj;
-
-    } else if (type == "property-list") {
-        PropertyList *obj = new PropertyList(x, y, x + width, y + height, globals->get_props());
-        if (presetSize)
-            obj->setSize(width, height);
-        setupObject(obj, props);
-        setColor(obj, props);
-        return obj;
-
-    } else if (type == "input") {
-        puInput *obj = new puInput(x, y, x + width, y + height);
-        setupObject(obj, props);
-        setColor(obj, props, FOREGROUND|LABEL);
-        return obj;
-
-    } else if (type == "text") {
-        puText *obj = new puText(x, y);
-        setupObject(obj, props);
-
-        // Layed-out objects need their size set, and non-layout ones
-        // get a different placement.
-        if (presetSize)
-            obj->setSize(width, height);
-        else
-            obj->setLabelPlace(PUPLACE_LABEL_DEFAULT);
-        setColor(obj, props, LABEL);
-        return obj;
-
-    } else if (type == "checkbox") {
-        puButton *obj;
-        obj = new puButton(x, y, x + width, y + height, PUBUTTON_XCHECK);
-        setupObject(obj, props);
-        setColor(obj, props, FOREGROUND|LABEL);
-        return obj;
-
-    } else if (type == "radio") {
-        puButton *obj;
-        obj = new puButton(x, y, x + width, y + height, PUBUTTON_CIRCLE);
-        setupObject(obj, props);
-        setColor(obj, props, FOREGROUND|LABEL);
-        return obj;
-
-    } else if (type == "button") {
-        puButton *obj;
-        const char *legend = props->getStringValue("legend", "[none]");
-        if (props->getBoolValue("one-shot", true))
-            obj = new puOneShot(x, y, legend);
-        else
-            obj = new puButton(x, y, legend);
-        if (presetSize)
-            obj->setSize(width, height);
-        setupObject(obj, props);
-        setColor(obj, props);
-        return obj;
-    } else if (type == "map") {
-        MapWidget* mapWidget = new MapWidget(x, y, x + width, y + height);
-        setupObject(mapWidget, props);
-        return mapWidget;
-    } else if (type == "combo") {
-        fgComboBox *obj = new fgComboBox(x, y, x + width, y + height, props,
-                props->getBoolValue("editable", false));
-        setupObject(obj, props);
-        setColor(obj, props, EDITFIELD);
-        return obj;
-
-    } else if (type == "slider") {
-        bool vertical = props->getBoolValue("vertical", false);
-        puSlider *obj = new puSlider(x, y, (vertical ? height : width), vertical);
-        obj->setMinValue(props->getFloatValue("min", 0.0));
-        obj->setMaxValue(props->getFloatValue("max", 1.0));
-        obj->setStepSize(props->getFloatValue("step"));
-        obj->setSliderFraction(props->getFloatValue("fraction"));
-#if PLIB_VERSION > 185
-        obj->setPageStepSize(props->getFloatValue("pagestep"));
-#endif
-        setupObject(obj, props);
-        if (presetSize)
-            obj->setSize(width, height);
-        setColor(obj, props, FOREGROUND|LABEL);
-        return obj;
-
-    } else if (type == "dial") {
-        puDial *obj = new puDial(x, y, width);
-        obj->setMinValue(props->getFloatValue("min", 0.0));
-        obj->setMaxValue(props->getFloatValue("max", 1.0));
-        obj->setWrap(props->getBoolValue("wrap", true));
-        setupObject(obj, props);
-        setColor(obj, props, FOREGROUND|LABEL);
-        return obj;
-
-    } else if (type == "textbox") {
-        int slider_width = props->getIntValue("slider", 20);
-        int wrap = props->getBoolValue("wrap", true);
-#if PLIB_VERSION > 185
-        puaLargeInput *obj = new puaLargeInput(x, y,
-                x + width, x + height, 11, slider_width, wrap);
-#else
-        puaLargeInput *obj = new puaLargeInput(x, y,
-                x + width, x + height, 2, slider_width, wrap);
-#endif
-
-        if (props->getBoolValue("editable"))
-            obj->enableInput();
-        else
-            obj->disableInput();
-
-        if (presetSize)
-            obj->setSize(width, height);
-        setupObject(obj, props);
-        setColor(obj, props, FOREGROUND|LABEL);
-
-        int top = props->getIntValue("top-line", 0);
-        obj->setTopLineInWindow(top < 0 ? unsigned(-1) >> 1 : top);
-        return obj;
-
-    } else if (type == "select") {
-        fgSelectBox *obj = new fgSelectBox(x, y, x + width, y + height, props);
-        setupObject(obj, props);
-        setColor(obj, props, EDITFIELD);
-        return obj;
-    } else if (type == "waypointlist") {
-        ScrolledWaypointList* obj = new ScrolledWaypointList(x, y, width, height);
-        setupObject(obj, props);
-        return obj;
-    } else {
-        return 0;
-    }
-}
-
-void
-FGDialog::setupObject (puObject *object, SGPropertyNode *props)
-{
-    GUIInfo *info = new GUIInfo(this);
-    object->setUserData(info);
-    _info.push_back(info);
-    object->setLabelPlace(PUPLACE_CENTERED_RIGHT);
-    object->makeReturnDefault(props->getBoolValue("default"));
-    info->node = props;
-
-    if (props->hasValue("legend")) {
-        info->legend = props->getStringValue("legend");
-        object->setLegend(info->legend.c_str());
-    }
-
-    if (props->hasValue("label")) {
-        info->label = props->getStringValue("label");
-        object->setLabel(info->label.c_str());
-    }
-
-    if (props->hasValue("border"))
-        object->setBorderThickness( props->getIntValue("border", 2) );
-
-    if (SGPropertyNode *nft = props->getNode("font", false)) {
-       FGFontCache *fc = globals->get_fontcache();
-       puFont *lfnt = fc->get(nft);
-       object->setLabelFont(*lfnt);
-       object->setLegendFont(*lfnt);
-    } else {
-       object->setLabelFont(*_font);
-    }
-
-    if (props->hasChild("visible")) {
-      ConditionalObject* cnd = new ConditionalObject("visible", object);
-      cnd->setCondition(sgReadCondition(globals->get_props(), props->getChild("visible")));
-      _conditionalObjects.push_back(cnd);
-    }
-
-    if (props->hasChild("enable")) {
-      ConditionalObject* cnd = new ConditionalObject("enable", object);
-      cnd->setCondition(sgReadCondition(globals->get_props(), props->getChild("enable")));
-      _conditionalObjects.push_back(cnd);
-    }
-
-    string type = props->getName();
-    if (type == "input" && props->getBoolValue("live"))
-        object->setDownCallback(action_callback);
-
-    if (type == "text") {
-        const char *format = props->getStringValue("format", 0);
-        if (format) {
-            info->fmt_type = validate_format(format);
-            if (info->fmt_type != f_INVALID)
-                info->format = format;
-            else
-                SG_LOG(SG_GENERAL, SG_ALERT, "DIALOG: invalid <format> '"
-                        << format << '\'');
-        }
-    }
-
-    if (props->hasValue("property")) {
-        const char *name = props->getStringValue("name");
-        if (name == 0)
-            name = "";
-        const char *propname = props->getStringValue("property");
-        SGPropertyNode_ptr node = fgGetNode(propname, true);
-        if (type == "map") {
-          // mapWidget binds to a sub-tree of properties, and
-          // ignores the puValue mechanism, so special case things here
-          MapWidget* mw = static_cast<MapWidget*>(object);
-          mw->setProperty(node);
-        } else {
-            // normal widget, creating PropertyObject
-            copy_to_pui(node, object);
-            PropertyObject *po = new PropertyObject(name, object, node);
-            _propertyObjects.push_back(po);
-            if (props->getBoolValue("live"))
-                _liveObjects.push_back(po);
-        }
-        
-
-    }
-
-    SGPropertyNode *dest = fgGetNode("/sim/bindings/gui", true);
-    vector<SGPropertyNode_ptr> bindings = props->getChildren("binding");
-    if (bindings.size() > 0) {
-        info->key = props->getIntValue("keynum", -1);
-        if (props->hasValue("key"))
-            info->key = getKeyCode(props->getStringValue("key", ""));
-
-        for (unsigned int i = 0; i < bindings.size(); i++) {
-            unsigned int j = 0;
-            SGPropertyNode_ptr binding;
-            while (dest->getChild("binding", j))
-                j++;
-
-            const char *cmd = bindings[i]->getStringValue("command");
-            if (!strcmp(cmd, "nasal"))
-                bindings[i]->setStringValue("module", _module.c_str());
-
-            binding = dest->getChild("binding", j, true);
-            copyProperties(bindings[i], binding);
-            info->bindings.push_back(new SGBinding(binding, globals->get_props()));
-        }
-        object->setCallback(action_callback);
-    }
-}
-
-void
-FGDialog::setupGroup(puGroup *group, SGPropertyNode *props,
-       int width, int height, bool makeFrame)
-{
-    setupObject(group, props);
-
-    if (makeFrame) {
-        puFrame* f = new puFrame(0, 0, width, height);
-        setColor(f, props);
-    }
-
-    int nChildren = props->nChildren();
-    for (int i = 0; i < nChildren; i++)
-        makeObject(props->getChild(i), width, height);
-    group->close();
-}
-
-void
-FGDialog::setColor(puObject *object, SGPropertyNode *props, int which)
-{
-    string type = props->getName();
-    if (type.empty())
-        type = "dialog";
-    if (type == "textbox" && props->getBoolValue("editable"))
-        type += "-editable";
-
-    FGColor c(_gui->getColor("background"));
-    c.merge(_gui->getColor(type));
-    c.merge(props->getNode("color"));
-    if (c.isValid())
-        object->setColourScheme(c.red(), c.green(), c.blue(), c.alpha());
-
-    const struct {
-        int mask;
-        int id;
-        const char *name;
-        const char *cname;
-    } pucol[] = {
-        { BACKGROUND, PUCOL_BACKGROUND, "background", "color-background" },
-        { FOREGROUND, PUCOL_FOREGROUND, "foreground", "color-foreground" },
-        { HIGHLIGHT,  PUCOL_HIGHLIGHT,  "highlight",  "color-highlight" },
-        { LABEL,      PUCOL_LABEL,      "label",      "color-label" },
-        { LEGEND,     PUCOL_LEGEND,     "legend",     "color-legend" },
-        { MISC,       PUCOL_MISC,       "misc",       "color-misc" },
-        { EDITFIELD,  PUCOL_EDITFIELD,  "editfield",  "color-editfield" },
-    };
-
-    const int numcol = sizeof(pucol) / sizeof(pucol[0]);
-
-    for (int i = 0; i < numcol; i++) {
-        bool dirty = false;
-        c.clear();
-        c.setAlpha(1.0);
-
-        dirty |= c.merge(_gui->getColor(type + '-' + pucol[i].name));
-        if (which & pucol[i].mask)
-            dirty |= c.merge(props->getNode("color"));
-
-        if ((pucol[i].mask == LABEL) && !c.isValid())
-            dirty |= c.merge(_gui->getColor("label"));
-
-        dirty |= c.merge(props->getNode(pucol[i].cname));
-
-        if (c.isValid() && dirty)
-            object->setColor(pucol[i].id, c.red(), c.green(), c.blue(), c.alpha());
-    }
-}
-
-
-static struct {
-    const char *name;
-    int key;
-} keymap[] = {
-    {"backspace", 8},
-    {"tab", 9},
-    {"return", 13},
-    {"enter", 13},
-    {"esc", 27},
-    {"escape", 27},
-    {"space", ' '},
-    {"&amp;", '&'},
-    {"and", '&'},
-    {"&lt;", '<'},
-    {"&gt;", '>'},
-    {"f1", PU_KEY_F1},
-    {"f2", PU_KEY_F2},
-    {"f3", PU_KEY_F3},
-    {"f4", PU_KEY_F4},
-    {"f5", PU_KEY_F5},
-    {"f6", PU_KEY_F6},
-    {"f7", PU_KEY_F7},
-    {"f8", PU_KEY_F8},
-    {"f9", PU_KEY_F9},
-    {"f10", PU_KEY_F10},
-    {"f11", PU_KEY_F11},
-    {"f12", PU_KEY_F12},
-    {"left", PU_KEY_LEFT},
-    {"up", PU_KEY_UP},
-    {"right", PU_KEY_RIGHT},
-    {"down", PU_KEY_DOWN},
-    {"pageup", PU_KEY_PAGE_UP},
-    {"pagedn", PU_KEY_PAGE_DOWN},
-    {"home", PU_KEY_HOME},
-    {"end", PU_KEY_END},
-    {"insert", PU_KEY_INSERT},
-    {0, -1},
-};
-
-int
-FGDialog::getKeyCode(const char *str)
-{
-    enum {
-        CTRL = 0x1,
-        SHIFT = 0x2,
-        ALT = 0x4,
-    };
-
-    while (*str == ' ')
-        str++;
-
-    char *buf = new char[strlen(str) + 1];
-    strcpy(buf, str);
-    char *s = buf + strlen(buf);
-    while (s > str && s[-1] == ' ')
-        s--;
-    *s = 0;
-    s = buf;
-
-    int mod = 0;
-    while (1) {
-        if (!strncmp(s, "Ctrl-", 5) || !strncmp(s, "CTRL-", 5))
-            s += 5, mod |= CTRL;
-        else if (!strncmp(s, "Shift-", 6) || !strncmp(s, "SHIFT-", 6))
-            s += 6, mod |= SHIFT;
-        else if (!strncmp(s, "Alt-", 4) || !strncmp(s, "ALT-", 4))
-            s += 4, mod |= ALT;
-        else
-            break;
-    }
-
-    int key = -1;
-    if (strlen(s) == 1 && isascii(*s)) {
-        key = *s;
-        if (mod & SHIFT)
-            key = toupper(key);
-        if (mod & CTRL)
-            key = toupper(key) - '@';
-        /* if (mod & ALT)
-            ;   // Alt not propagated to the gui
-        */
-    } else {
-        for (char *t = s; *t; t++)
-            *t = tolower(*t);
-        for (int i = 0; keymap[i].name; i++) {
-            if (!strcmp(s, keymap[i].name)) {
-                key = keymap[i].key;
-                break;
-            }
-        }
-    }
-    delete[] buf;
-    return key;
-}
-
-voidFGDialog::relayout()
-{
-  _needsRelayout = false;
-  
-  int screenw = globals->get_props()->getIntValue("/sim/startup/xsize");
-  int screenh = globals->get_props()->getIntValue("/sim/startup/ysize");
-
-  bool userx = _props->hasValue("x");
-  bool usery = _props->hasValue("y");
-  bool userw = _props->hasValue("width");
-  bool userh = _props->hasValue("height");
-
-  // Let the layout widget work in the same property subtree.
-  LayoutWidget wid(_props);
-  wid.setDefaultFont(_font, int(_font->getPointSize()));
-
-  int pw = 0, ph = 0;
-  int px, py, savex, savey;
-  if (!userw || !userh) {
-    wid.calcPrefSize(&pw, &ph);
-  }
-  
-  pw = _props->getIntValue("width", pw);
-  ph = _props->getIntValue("height", ph);
-  px = savex = _props->getIntValue("x", (screenw - pw) / 2);
-  py = savey = _props->getIntValue("y", (screenh - ph) / 2);
-
-  // Negative x/y coordinates are interpreted as distance from the top/right
-  // corner rather than bottom/left.
-  if (userx && px < 0)
-    px = screenw - pw + px;
-  if (usery && py < 0)
-    py = screenh - ph + py;
-
-  // Define "x", "y", "width" and/or "height" in the property tree if they
-  // are not specified in the configuration file.
-  wid.layout(px, py, pw, ph);
-
-  applySize(_object);
-  
-  // Remove automatically generated properties, so the layout looks
-  // the same next time around, or restore x and y to preserve negative coords.
-  if (userx)
-      _props->setIntValue("x", savex);
-  else
-      _props->removeChild("x");
-
-  if (usery)
-      _props->setIntValue("y", savey);
-  else
-      _props->removeChild("y");
-
-  if (!userw) _props->removeChild("width");
-  if (!userh) _props->removeChild("height");
-}
-
-void
-FGDialog::applySize(puObject *object)
-{
-  // compound plib widgets use setUserData() for internal purposes, so refuse
-  // to descend into anything that has other bits set than the following
-  const int validUserData = PUCLASS_VALUE|PUCLASS_OBJECT|PUCLASS_GROUP|PUCLASS_INTERFACE
-          |PUCLASS_FRAME|PUCLASS_TEXT|PUCLASS_BUTTON|PUCLASS_ONESHOT|PUCLASS_INPUT
-          |PUCLASS_ARROW|PUCLASS_DIAL|PUCLASS_POPUP;
-
-  int type = object->getType();
-  if ((type & PUCLASS_GROUP) && !(type & ~validUserData)) {
-    puObject* c = ((puGroup *)object)->getFirstChild();
-    for (; c != NULL; c = c->getNextObject()) {
-      applySize(c);
-    } // of child iteration
-  } // of group object case
-  
-  GUIInfo *info = (GUIInfo *)object->getUserData();
-  if (!info)
-    return;
-
-  SGPropertyNode *n = info->node;
-  if (!n) {
-    SG_LOG(SG_GENERAL, SG_ALERT, "FGDialog::applySize: no props");
-    return;
-  }
-  
-  int x = n->getIntValue("x");
-  int y = n->getIntValue("y");
-  int w = n->getIntValue("width", 4);
-  int h = n->getIntValue("height", 4);
-  object->setPosition(x, y);
-  object->setSize(w, h);
-}
-
-////////////////////////////////////////////////////////////////////////
-// Implementation of FGDialog::PropertyObject.
-////////////////////////////////////////////////////////////////////////
-
-FGDialog::PropertyObject::PropertyObject(const char *n,
-        puObject *o, SGPropertyNode_ptr p) :
-    name(n),
-    object(o),
-    node(p)
-{
-}
-
-
-
-
-////////////////////////////////////////////////////////////////////////
-// Implementation of fgValueList and derived pui widgets
-////////////////////////////////////////////////////////////////////////
-
-
-fgValueList::fgValueList(SGPropertyNode *p) :
-    _props(p)
-{
-    make_list();
-}
-
-void
-fgValueList::update()
-{
-    destroy_list();
-    make_list();
-}
-
-fgValueList::~fgValueList()
-{
-    destroy_list();
-}
-
-void
-fgValueList::make_list()
-{
-  SGPropertyNode_ptr values = _props;
-  const char* vname = "value";
-  
-  if (_props->hasChild("properties")) {
-    // dynamic values, read from a property's children
-    const char* path = _props->getStringValue("properties");
-    values = fgGetNode(path, true);
-  }
-  
-  if (_props->hasChild("property-name")) {
-    vname = _props->getStringValue("property-name");
-  }
-  
-  vector<SGPropertyNode_ptr> value_nodes = values->getChildren(vname);
-  _list = new char *[value_nodes.size() + 1];
-  unsigned int i;
-  for (i = 0; i < value_nodes.size(); i++) {
-    _list[i] = strdup((char *)value_nodes[i]->getStringValue());
-  }
-  _list[i] = 0;
-}
-
-void
-fgValueList::destroy_list()
-{
-    for (int i = 0; _list[i] != 0; i++)
-        if (_list[i])
-            free(_list[i]);
-    delete[] _list;
-}
-
-
-
-void
-fgList::update()
-{
-    fgValueList::update();
-    int top = getTopItem();
-    newList(_list);
-    setTopItem(top);
-}
-
-void fgComboBox::update()
-{
-  if (_inHit) {
-    return;
-  }
-  
-  std::string curValue(getStringValue());
-  fgValueList::update();
-  newList(_list);
-  int currentItem = puaComboBox::getCurrentItem();
-
-  
-// look for the previous value, in the new list
-  for (int i = 0; _list[i] != 0; i++) {
-    if (_list[i] == curValue) {
-    // don't set the current item again; this is important to avoid
-    // recursion here if the combo callback ultimately causes another dialog-update
-      if (i != currentItem) {
-        puaComboBox::setCurrentItem(i);
-      }
-      
-      return;
-    }
-  } // of list values iteration
-  
-// cound't find current item, default to first
-  if (currentItem != 0) {
-    puaComboBox::setCurrentItem(0);
-  }
-}
-
-int fgComboBox::checkHit(int b, int up, int x, int y)
-{
-  _inHit = true;
-  int r = puaComboBox::checkHit(b, up, x, y);
-  _inHit = false;
-  return r;
-}
-
-void fgComboBox::setSize(int w, int h)
-{
-  puaComboBox::setSize(w, h);
-  recalc_bbox();
-}
-
-void fgComboBox::recalc_bbox()
-{
-// bug-fix for issue #192
-// http://code.google.com/p/flightgear-bugs/issues/detail?id=192
-// puaComboBox is including the height of its popupMenu in the height
-// computation, which breaks layout computations.
-// this implementation skips popup-menus
-  
-  puBox contents;
-  contents.empty();
-  
-  for (puObject *bo = dlist; bo != NULL; bo = bo -> getNextObject()) {
-    if (bo->getType() & PUCLASS_POPUPMENU) {
-      continue;
-    }
-    
-    contents.extend (bo -> getBBox()) ;
-  }
-  
-  abox.max[0] = abox.min[0] + contents.max[0] ;
-  abox.max[1] = abox.min[1] + contents.max[1] ;
-
-  puObject::recalc_bbox () ;
-
 }
 
 // end of dialog.cxx
diff --git a/src/GUI/dialog.hxx b/src/GUI/dialog.hxx
index 497e07104..7aa4adc80 100644
--- a/src/GUI/dialog.hxx
+++ b/src/GUI/dialog.hxx
@@ -7,31 +7,8 @@
 # error This library requires C++
 #endif
 
-#include <plib/puAux.h>
-
-#include <simgear/compiler.h>	// for SG_USING_STD
-#include <simgear/props/props.hxx>
-#include <simgear/misc/sg_path.hxx>
-#include <simgear/props/condition.hxx>
-
-#include <vector>
-using std::vector;
-
-
-// ugly temporary workaround for plib's lack of user defined class ids  FIXME
-#define FGCLASS_LIST          0x00000001
-#define FGCLASS_AIRPORTLIST   0x00000002
-#define FGCLASS_PROPERTYLIST  0x00000004
-#define FGCLASS_WAYPOINTLIST  0x00000008
-
-class GUI_ID { public: GUI_ID(int id) : id(id) {} virtual ~GUI_ID() {} int id; };
-
-
-
-class FGDialog;
-class NewGUI;
-class FGColor;
-
+// forward decls
+class SGPropertyNode;
 
 /**
  * An XML-configured dialog box.
@@ -45,16 +22,6 @@ class FGDialog
 {
 public:
 
-    /**
-     * Construct a new GUI widget configured by a property tree.
-     *
-     * The configuration properties are not part of the main
-     * FlightGear property tree; the GUI manager reads them
-     * from individual configuration files.
-     *
-     * @param props A property tree describing the dialog.
-     */
-    FGDialog (SGPropertyNode * props);
 
 
     /**
@@ -73,7 +40,7 @@ public:
      * @param objectName The name of the GUI object(s) to update.
      *        Use the empty name for all unnamed objects.
      */
-    virtual void updateValues (const char * objectName = 0);
+    virtual void updateValues (const char * objectName = 0) = 0;
 
 
     /**
@@ -86,199 +53,28 @@ public:
      * @param objectName The name of the GUI object(s) to update.
      *        Use the empty name for all unnamed objects.
      */
-    virtual void applyValues (const char * objectName = 0);
+    virtual void applyValues (const char * objectName = 0) = 0;
 
 
     /**
      * Update state.  Called on active dialogs before rendering.
      */
-    virtual void update ();
-
-    /**
-     * Recompute the dialog's layout
-     */
-    void relayout();
-    
-    
-    void setNeedsLayout() {
-      _needsRelayout = true;
-    }
-private:
-
-    enum {
-        BACKGROUND = 0x01,
-        FOREGROUND = 0x02,
-        HIGHLIGHT = 0x04,
-        LABEL = 0x08,
-        LEGEND = 0x10,
-        MISC = 0x20,
-        EDITFIELD = 0x40
-    };
-
-    // Private copy constructor to avoid unpleasant surprises.
-    FGDialog (const FGDialog &);
-
-    // Show the dialog.
-    void display (SGPropertyNode * props);
-
-    // Build the dialog or a subobject of it.
-    puObject * makeObject (SGPropertyNode * props,
-                           int parentWidth, int parentHeight);
-
-    // Common configuration for all GUI objects.
-    void setupObject (puObject * object, SGPropertyNode * props);
-
-    // Common configuration for all GUI group objects.
-    void setupGroup (puGroup * group, SGPropertyNode * props,
-                     int width, int height, bool makeFrame = false);
-
-    // Set object colors: the "which" argument defines which color qualities
-    // (PUCOL_LABEL, etc.) should pick up the <color> property.
-    void setColor(puObject * object, SGPropertyNode * props, int which = 0);
-
-    // return key code number for keystring
-    int getKeyCode(const char *keystring);
-
-    /**
-     * Apply layout sizes to a tree of puObjects
-     */
-    void applySize(puObject *object);
-
-    // The top-level PUI object.
-    puObject * _object;
-
-    // The GUI subsystem.
-    NewGUI * _gui;
-
-    // The dialog font. Defaults to the global gui font, but can get
-    // overridden by a top level font definition.
-    puFont * _font;
-
-    // The source xml tree, so that we can pass data back, such as the
-    // last position.
-    SGPropertyNode_ptr _props;
-
-    bool _needsRelayout;
-
-    // Nasal module.
-    std::string _module;
-    SGPropertyNode_ptr _nasal_close;
-
-    // PUI provides no way for userdata to be deleted automatically
-    // with a GUI object, so we have to keep track of all the special
-    // data we allocated and then free it manually when the dialog
-    // closes.
-    vector<void *> _info;
-    struct PropertyObject {
-        PropertyObject (const char * name,
-                        puObject * object,
-                        SGPropertyNode_ptr node);
-        std::string name;
-        puObject * object;
-        SGPropertyNode_ptr node;
-    };
-    vector<PropertyObject *> _propertyObjects;
-    vector<PropertyObject *> _liveObjects;
-    
-    class ConditionalObject : public SGConditional
-    {
-    public:
-      ConditionalObject(const std::string& aName, puObject* aPu) :
-        _name(aName),
-        _pu(aPu)
-      { ; }
-    
-      void update(FGDialog* aDlg);
-    
-    private:
-      const std::string _name;
-      puObject* _pu;      
-    };
-    
-    typedef SGSharedPtr<ConditionalObject> ConditionalObjectRef;
-    vector<ConditionalObjectRef> _conditionalObjects;
-};
-
-//
-// Custom subclass of puPopup to implement "draggable" windows in the
-// interface.  Note that this is a subclass of puPopup, not
-// puDialogBox.  Sadly, PUI (mis)uses subclassing to implement a
-// boolean property: modality.  That means that we can't implement
-// dragging of both puPopup windows and puDialogBoxes with the same
-// code.  Rather than duplicate code, I've chosen to implement only
-// "non-modal dragability" here.  Modal dialog boxes (like the exit
-// confirmation) are not draggable.
-//
-class fgPopup : public puPopup {
-public:
-    fgPopup(int x, int y, bool r = true, bool d = true) :
-            puPopup(x, y), _draggable(d), _resizable(r), _dragging(false)
-    {}
-    int checkHit(int b, int up, int x, int y);
-    int checkKey(int key, int updown);
-    int getHitObjects(puObject *, int x, int y);
-    puObject *getKeyObject(puObject *, int key);
-    puObject *getActiveInputField(puObject *);
-    void applySize(puObject *);
-private:
-    enum { LEFT = 1, RIGHT = 2, TOP = 4, BOTTOM = 8 };
-    bool _draggable;
-    bool _resizable;
-    bool _dragging;
-    int _resizing;
-    int _start_cursor;
-    int _cursor;
-    int _dlgX, _dlgY, _dlgW, _dlgH;
-    int _startX, _startY;
-};
-
-
-class fgValueList {
-public:
-    fgValueList(SGPropertyNode *p);
-    virtual ~fgValueList();
-    virtual void update();
+    virtual void update () = 0;
 
 protected:
-    char **_list;
+    /**
+     * Construct a new GUI widget configured by a property tree.
+     *
+     * The configuration properties are not part of the main
+     * FlightGear property tree; the GUI manager reads them
+     * from individual configuration files.
+     *
+     * @param props A property tree describing the dialog.
+     */
+    FGDialog (SGPropertyNode * props);
 
 private:
-    void make_list();
-    void destroy_list();
-    SGPropertyNode_ptr _props;
-};
 
-
-class fgList : public fgValueList, public puaList, public GUI_ID {
-public:
-    fgList(int x1, int y1, int x2, int y2, SGPropertyNode *p, int sw) :
-            fgValueList(p), puaList(x1, y1, x2, y2, _list, sw), GUI_ID(FGCLASS_LIST) {}
-    void update();
-};
-
-class fgComboBox : public fgValueList, public puaComboBox {
-public:
-    fgComboBox(int x1, int y1, int x2, int y2, SGPropertyNode *p, bool editable) :
-        fgValueList(p), 
-        puaComboBox(x1, y1, x2, y2, _list, editable),
-        _inHit(false)
-      {}
-        
-    void update();
-    
-    virtual void setSize(int w, int h);
-    
-    virtual int checkHit(int b, int up, int x, int y);
-    
-    virtual void recalc_bbox();
-private:
-    bool _inHit;
-};
-
-class fgSelectBox : public fgValueList, public puaSelectBox {
-public:
-    fgSelectBox(int x1, int y1, int x2, int y2, SGPropertyNode *p) :
-        fgValueList(p), puaSelectBox(x1, y1, x2, y2, _list) {}
 };
 
 #endif // __DIALOG_HXX
diff --git a/src/GUI/new_gui.cxx b/src/GUI/new_gui.cxx
index 5f05a8f0e..a374b2912 100644
--- a/src/GUI/new_gui.cxx
+++ b/src/GUI/new_gui.cxx
@@ -27,7 +27,7 @@
 #endif
 
 #include "menubar.hxx"
-#include "dialog.hxx"
+#include "FGPUIDialog.hxx"
 #include "FGFontCache.hxx"
 #include "FGColor.hxx"
 
@@ -80,7 +80,7 @@ void
 NewGUI::reset (bool reload)
 {
     map<string,FGDialog *>::iterator iter;
-    vector<string> dlg;
+    std::vector<string> dlg;
     // close all open dialogs and remember them ...
     for (iter = _active_dialogs.begin(); iter != _active_dialogs.end(); ++iter)
         dlg.push_back(iter->first);
@@ -138,7 +138,7 @@ NewGUI::showDialog (const string &name)
         return false;
     } else {
         if(!_active_dialogs[name])
-            _active_dialogs[name] = new FGDialog(_dialog_props[name]);
+            _active_dialogs[name] = new FGPUIDialog(_dialog_props[name]);
         return true;
     }
 }
diff --git a/src/GUI/property_list.hxx b/src/GUI/property_list.hxx
index 046c09435..e11d5bfe8 100644
--- a/src/GUI/property_list.hxx
+++ b/src/GUI/property_list.hxx
@@ -27,7 +27,7 @@
 
 #include <plib/puAux.h>
 #include <simgear/props/props.hxx>
-#include "dialog.hxx"
+#include "FGPUIDialog.hxx"
 
 
 class PropertyList : public puaList, public SGPropertyChangeListener, public GUI_ID {

From 339c57e0b2904a3c3546cd23d8b727066b69112b Mon Sep 17 00:00:00 2001
From: ThorstenB <brehmt@gmail.com>
Date: Sat, 19 Nov 2011 22:37:13 +0100
Subject: [PATCH 04/18] Adapt path of performance-monitor properties.

---
 src/Main/fg_init.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Main/fg_init.cxx b/src/Main/fg_init.cxx
index 7e842f9ba..8d01e88e6 100644
--- a/src/Main/fg_init.cxx
+++ b/src/Main/fg_init.cxx
@@ -1206,7 +1206,7 @@ bool fgInitSubsystems() {
     ////////////////////////////////////////////////////////////////////
     globals->add_subsystem("performance-mon",
             new SGPerformanceMonitor(globals->get_subsystem_mgr(),
-                                     fgGetNode("/sim/performance", true)));
+                                     fgGetNode("/sim/performance-monitor", true)));
 
     ////////////////////////////////////////////////////////////////////
     // Initialize the material property subsystem.

From 76baf75a47c454ba8b157626b951f44ccf4a0997 Mon Sep 17 00:00:00 2001
From: ThorstenB <brehmt@gmail.com>
Date: Sat, 19 Nov 2011 22:48:26 +0100
Subject: [PATCH 05/18] Fix include dependencies for non-Mac platforms. ;-)

---
 src/GUI/new_gui.hxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/GUI/new_gui.hxx b/src/GUI/new_gui.hxx
index 422503a1a..3f69cab95 100644
--- a/src/GUI/new_gui.hxx
+++ b/src/GUI/new_gui.hxx
@@ -7,6 +7,7 @@
 #include <simgear/structure/subsystem_mgr.hxx>
 #include <simgear/misc/sg_path.hxx>
 
+#include <string.h>
 #include <functional>
 #include <vector>
 #include <map>

From daa973f1bc7efdcc96adf58fdba7248969af3ad1 Mon Sep 17 00:00:00 2001
From: James Turner <zakalawe@mac.com>
Date: Sat, 19 Nov 2011 22:04:35 +0000
Subject: [PATCH 06/18] And make FGMenuBar abstract too, sinking the current
 implementation into FGPUIMenubar

---
 src/GUI/CMakeLists.txt   |   2 +
 src/GUI/FGPUIMenuBar.cxx | 376 +++++++++++++++++++++++++++++++++++++++
 src/GUI/FGPUIMenuBar.hxx | 138 ++++++++++++++
 src/GUI/menubar.cxx      | 362 -------------------------------------
 src/GUI/menubar.hxx      |  99 +----------
 src/GUI/new_gui.cxx      |  10 +-
 src/GUI/new_gui.hxx      |   2 +-
 7 files changed, 527 insertions(+), 462 deletions(-)
 create mode 100644 src/GUI/FGPUIMenuBar.cxx
 create mode 100644 src/GUI/FGPUIMenuBar.hxx

diff --git a/src/GUI/CMakeLists.txt b/src/GUI/CMakeLists.txt
index 6fd3f4704..030416ef0 100644
--- a/src/GUI/CMakeLists.txt
+++ b/src/GUI/CMakeLists.txt
@@ -13,6 +13,7 @@ set(SOURCES
 	layout-props.cxx
 	layout.cxx
 	menubar.cxx
+	FGPUIMenuBar.cxx
 	new_gui.cxx
 	property_list.cxx
 	FGFontCache.cxx
@@ -29,6 +30,7 @@ set(HEADERS
 	gui.h
 	layout.hxx
 	menubar.hxx
+	FGPUIMenuBar.hxx
 	new_gui.hxx
 	property_list.hxx
 	FGFontCache.hxx
diff --git a/src/GUI/FGPUIMenuBar.cxx b/src/GUI/FGPUIMenuBar.cxx
new file mode 100644
index 000000000..a7d8ba0eb
--- /dev/null
+++ b/src/GUI/FGPUIMenuBar.cxx
@@ -0,0 +1,376 @@
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <string.h>
+#include <iostream>
+#include <plib/pu.h>
+#include <simgear/debug/logstream.hxx>
+#include <simgear/structure/SGBinding.hxx>
+#include <simgear/props/props_io.hxx>
+
+#include <Main/globals.hxx>
+#include <Main/fg_props.hxx>
+
+#include "new_gui.hxx"
+#include "FGPUIMenuBar.hxx"
+
+using std::vector;
+using std::string;
+using std::map;
+////////////////////////////////////////////////////////////////////////
+// FIXME!!
+//
+// Deprecated wrappers for old menu commands.
+//
+// DO NOT ADD TO THESE.  THEY WILL BE DELETED SOON!
+//
+// These are defined in gui_funcs.cxx.  They should be replaced with
+// user-configured dialogs and new commands where necessary.
+////////////////////////////////////////////////////////////////////////
+
+#if defined(TR_HIRES_SNAP)
+extern void dumpHiResSnapShot ();
+static bool
+do_hires_snapshot_dialog (const SGPropertyNode * arg)
+{
+    dumpHiResSnapShot();
+    return true;
+}
+#endif // TR_HIRES_SNAP
+
+static struct {
+    const char * name;
+    SGCommandMgr::command_t command;
+} deprecated_dialogs [] = {
+#if defined(TR_HIRES_SNAP)
+    { "old-hires-snapshot-dialog", do_hires_snapshot_dialog },
+#endif
+    { 0, 0 }
+};
+
+static void
+add_deprecated_dialogs ()
+{
+  SG_LOG(SG_GENERAL, SG_INFO, "Initializing old dialog commands:");
+  for (int i = 0; deprecated_dialogs[i].name != 0; i++) {
+    SG_LOG(SG_GENERAL, SG_INFO, "  " << deprecated_dialogs[i].name);
+    globals->get_commands()->addCommand(deprecated_dialogs[i].name,
+					deprecated_dialogs[i].command);
+  }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Static functions.
+////////////////////////////////////////////////////////////////////////
+
+
+static void
+menu_callback (puObject * object)
+{
+    NewGUI * gui = (NewGUI *)globals->get_subsystem("gui");
+    FGPUIMenuBar* mb = static_cast<FGPUIMenuBar*>(gui->getMenuBar());
+    mb->fireItem(object);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGPUIMenuBar.
+////////////////////////////////////////////////////////////////////////
+
+
+FGPUIMenuBar::FGPUIMenuBar ()
+    : _visible(false),
+      _menuBar(0)
+{
+}
+
+FGPUIMenuBar::~FGPUIMenuBar ()
+{
+    destroy_menubar();
+}
+
+void
+FGPUIMenuBar::init ()
+{
+    delete _menuBar;            // FIXME: check if PUI owns the pointer
+    make_menubar();
+                                // FIXME: temporary commands to get at
+                                // old, hard-coded dialogs.
+    add_deprecated_dialogs();
+}
+
+void
+FGPUIMenuBar::show ()
+{
+    if (_menuBar != 0)
+        _menuBar->reveal();
+    _visible = true;
+}
+
+void
+FGPUIMenuBar::hide ()
+{
+    if (_menuBar != 0)
+        _menuBar->hide();
+    _visible = false;
+}
+
+bool
+FGPUIMenuBar::isVisible () const
+{
+    return _visible;
+}
+
+void
+FGPUIMenuBar::fireItem (puObject * item)
+{
+    const char * name = item->getLegend();
+    vector<SGBinding *> &bindings = _bindings[name];
+    int nBindings = bindings.size();
+
+    for (int i = 0; i < nBindings; i++)
+        bindings[i]->fire();
+}
+
+void
+FGPUIMenuBar::make_menu (SGPropertyNode * node)
+{
+    const char * name = strdup(node->getStringValue("label"));
+    vector<SGPropertyNode_ptr> item_nodes = node->getChildren("item");
+
+    int array_size = item_nodes.size();
+
+    char ** items = make_char_array(array_size);
+    puCallback * callbacks = make_callback_array(array_size);
+
+    for (unsigned int i = 0, j = item_nodes.size() - 1;
+         i < item_nodes.size();
+         i++, j--) {
+
+                                // Set up the PUI entries for this item
+        items[j] = strdup((char *)item_nodes[i]->getStringValue("label"));
+        callbacks[j] = menu_callback;
+
+                                // Load all the bindings for this item
+        vector<SGPropertyNode_ptr> bindings = item_nodes[i]->getChildren("binding");
+        SGPropertyNode * dest = fgGetNode("/sim/bindings/menu", true);
+
+        for (unsigned int k = 0; k < bindings.size(); k++) {
+            unsigned int m = 0;
+            SGPropertyNode_ptr binding;
+            while (dest->getChild("binding", m))
+                m++;
+
+            binding = dest->getChild("binding", m, true);
+            copyProperties(bindings[k], binding);
+            _bindings[items[j]].push_back(new SGBinding(binding, globals->get_props()));
+        }
+    }
+
+    _menuBar->add_submenu(name, items, callbacks);
+}
+
+void
+FGPUIMenuBar::make_menubar ()
+{
+    SGPropertyNode *targetpath;
+   
+    targetpath = fgGetNode("/sim/menubar/default",true);
+    // fgLoadProps("gui/menubar.xml", targetpath);
+    
+    /* NOTE: there is no check to see whether there's any usable data at all
+     *
+     * This would also have the advantage of being able to create some kind of
+     * 'fallback' menu - just in case that either menubar.xml is empty OR that
+     * its XML data is not valid, that way we would avoid displaying an
+     * unusable menubar without any functionality - if we decided to add another
+     * char * element to the commands structure in
+     *  $FG_SRC/src/Main/fgcommands.cxx 
+     * we could additionally save each function's (short) description and use
+     * this as label for the fallback PUI menubar item labels - as a workaround
+     * one might simply use the internal fgcommands and put them into the 
+     * fallback menu, so that the user is at least able to re-init the menu
+     * loading - just in case there was some malformed XML in it
+     * (it happend to me ...)
+     */
+    
+    make_menubar(targetpath);
+}
+
+/* WARNING: We aren't yet doing any validation of what's found - but since
+ * this isn't done with menubar.xml either, it should not really matter
+ * right now. Although one should later on consider to validate the
+ * contents, whether they are representing a 'legal' menubar structure.
+ */
+void
+FGPUIMenuBar::make_menubar(SGPropertyNode * props) 
+{    
+    // Just in case.
+    destroy_menubar();
+    _menuBar = new puMenuBar;
+
+    vector<SGPropertyNode_ptr> menu_nodes = props->getChildren("menu");
+    for (unsigned int i = 0; i < menu_nodes.size(); i++)
+        make_menu(menu_nodes[i]);
+
+    _menuBar->close();
+    make_object_map(props);
+
+    if (_visible)
+        _menuBar->reveal();
+    else
+        _menuBar->hide();
+}
+
+void
+FGPUIMenuBar::destroy_menubar ()
+{
+    if ( _menuBar == 0 )
+        return;
+
+    hide();
+    puDeleteObject(_menuBar);
+
+    unsigned int i;
+
+                                // Delete all the character arrays
+                                // we were forced to keep around for
+                                // plib.
+    SG_LOG(SG_GENERAL, SG_BULK, "Deleting char arrays");
+    for (i = 0; i < _char_arrays.size(); i++) {
+        for (int j = 0; _char_arrays[i][j] != 0; j++)
+            free(_char_arrays[i][j]); // added with strdup
+        delete[] _char_arrays[i];
+    }
+
+                                // Delete all the callback arrays
+                                // we were forced to keep around for
+                                // plib.
+    SG_LOG(SG_GENERAL, SG_BULK, "Deleting callback arrays");
+    for (i = 0; i < _callback_arrays.size(); i++)
+        delete[] _callback_arrays[i];
+
+                                // Delete all those bindings
+    SG_LOG(SG_GENERAL, SG_BULK, "Deleting bindings");
+    map<string,vector<SGBinding *> >::iterator it;
+    for (it = _bindings.begin(); it != _bindings.end(); it++) {
+        SG_LOG(SG_GENERAL, SG_BULK, "Deleting bindings for " << it->first);
+        for ( i = 0; i < it->second.size(); i++ )
+            delete it->second[i];
+    }
+
+    SG_LOG(SG_GENERAL, SG_BULK, "Done.");
+}
+
+void
+FGPUIMenuBar::make_object_map(SGPropertyNode * node)
+{
+    unsigned int menu_index = 0;
+    vector<SGPropertyNode_ptr> menus = node->getChildren("menu");
+    for (puObject *obj = ((puGroup *)_menuBar)->getFirstChild();
+            obj; obj = obj->getNextObject()) {
+
+        // skip puPopupMenus. They are also children of _menuBar,
+        // but we access them via getUserData()  (see below)
+        if (!(obj->getType() & PUCLASS_ONESHOT))
+            continue;
+
+        if (menu_index >= menus.size()) {
+            SG_LOG(SG_GENERAL, SG_WARN, "'menu' object without node: "
+                    << node->getPath() << "/menu[" << menu_index << ']');
+            return;
+        }
+
+        SGPropertyNode *menu = menus.at(menu_index);
+        _objects[menu->getPath()] = obj;
+        add_enabled_listener(menu);
+
+        puGroup *popup = (puGroup *)obj->getUserData();
+        if (!popup)
+            continue;
+
+        // the entries are for some reason reversed (last first), and we
+        // don't know yet how many there will be; so we collect first
+        vector<puObject *> e;
+        for (puObject *me = popup->getFirstChild(); me; me = me->getNextObject())
+            e.push_back(me);
+
+        vector<SGPropertyNode_ptr> items = menu->getChildren("item");
+        for (unsigned int i = 0; i < e.size(); i++) {
+            if (i >= items.size()) {
+                SG_LOG(SG_GENERAL, SG_WARN, "'item' object without node: "
+                        << menu->getPath() << "/item[" << i << ']');
+                break;
+            }
+            SGPropertyNode *item = items.at(e.size() - i - 1);
+            _objects[item->getPath()] = e[i];
+            add_enabled_listener(item);
+        }
+        menu_index++;
+    }
+}
+
+struct EnabledListener : SGPropertyChangeListener {
+    void valueChanged(SGPropertyNode *node) {
+        NewGUI * gui = (NewGUI *)globals->get_subsystem("gui");
+        if (!gui)
+            return;
+        FGPUIMenuBar* menubar = static_cast<FGPUIMenuBar*>(gui->getMenuBar());
+        if (menubar)
+            menubar->enable_item(node->getParent(), node->getBoolValue());
+    }
+};
+
+void
+FGPUIMenuBar::add_enabled_listener(SGPropertyNode * node)
+{
+    if (!node->hasValue("enabled"))
+        node->setBoolValue("enabled", true);
+
+    enable_item(node, node->getBoolValue("enabled"));
+    node->getNode("enabled")->addChangeListener(new EnabledListener());
+}
+
+bool
+FGPUIMenuBar::enable_item(const SGPropertyNode * node, bool state)
+{
+    string path = node->getPath();
+    if (_objects.find(path) == _objects.end()) {
+        SG_LOG(SG_GENERAL, SG_ALERT, "Trying to enable/disable "
+            "non-existent menu item for node `" << path << '\'');
+        return false;
+    }
+    puObject *object = _objects[path];
+    if (state)
+        object->activate();
+    else
+        object->greyOut();
+
+    return true;
+}
+
+char **
+FGPUIMenuBar::make_char_array (int size)
+{
+    char ** list = new char*[size+1];
+    for (int i = 0; i <= size; i++)
+        list[i] = 0;
+    _char_arrays.push_back(list);
+    return list;
+}
+
+puCallback *
+FGPUIMenuBar::make_callback_array (int size)
+{
+    puCallback * list = new puCallback[size+1];
+    for (int i = 0; i <= size; i++)
+        list[i] = 0;
+    _callback_arrays.push_back(list);
+    return list;
+}
+
+// end of menubar.cxx
diff --git a/src/GUI/FGPUIMenuBar.hxx b/src/GUI/FGPUIMenuBar.hxx
new file mode 100644
index 000000000..fa21c05b3
--- /dev/null
+++ b/src/GUI/FGPUIMenuBar.hxx
@@ -0,0 +1,138 @@
+// menubar.hxx - XML-configured menu bar.
+
+#ifndef FG_PUI_MENUBAR_HXX
+#define FG_PUI_MENUBAR_HXX 1
+
+#ifndef __cplusplus
+# error This library requires C++
+#endif
+
+#include <GUI/menubar.hxx>
+
+#include <map>
+#include <vector>
+
+// forward decls, avoid pulling in PLIB headers here
+class puMenuBar;
+class puObject;
+class SGPropertyNode;
+class SGBinding;
+
+typedef void (*puCallback)(class puObject *) ;
+
+/**
+ * XML-configured PUI menu bar.
+ *
+ * This class creates a menu bar from a tree of XML properties.  These
+ * properties are not part of the main FlightGear property tree, but
+ * are read from a separate file ($FG_ROOT/gui/menubar.xml).
+ *
+ * WARNING: because PUI provides no easy way to attach user data to a
+ * menu item, all menu item strings must be unique; otherwise, this
+ * class will always use the first binding with any given name.
+ */
+class FGPUIMenuBar : public FGMenuBar
+{
+public:
+
+    /**
+     * Constructor.
+     */
+    FGPUIMenuBar ();
+
+
+    /**
+     * Destructor.
+     */
+    virtual ~FGPUIMenuBar ();
+
+
+    /**
+     * Initialize the menu bar from $FG_ROOT/gui/menubar.xml
+     */
+    virtual void init ();
+    
+    /**
+     * Make the menu bar visible.
+     */
+    virtual void show ();
+
+
+    /**
+     * Make the menu bar invisible.
+     */
+    virtual void hide ();
+
+
+    /**
+     * Test whether the menu bar is visible.
+     */
+    virtual bool isVisible () const;
+
+
+    /**
+     * IGNORE THIS METHOD!!!
+     *
+     * This is necessary only because plib does not provide any easy
+     * way to attach user data to a menu item.  FlightGear should not
+     * have to know about PUI internals, but this method allows the
+     * callback to pass the menu item one-shot on to the current menu.
+     */
+    virtual void fireItem (puObject * item);
+
+
+    /**
+     * create a menubar based on a PropertyList within the PropertyTree
+     */
+    void make_menubar (SGPropertyNode * props);
+
+
+    /**
+     * destroy a menubar based on a PropertyList within the PropertyTree
+     */
+    void destroy_menubar ();
+
+
+    /**
+     * Disable/enable menu titles and entries
+     */
+    bool enable_item (const SGPropertyNode * item, bool state);
+
+
+private:
+
+    // Make a single menu.
+    void make_menu (SGPropertyNode * node);
+
+    // Make the top-level menubar.
+    void make_menubar ();
+
+    // Create a property-path -> puObject map for menu node
+    void make_object_map(SGPropertyNode * node);
+
+    // Add <enabled> listener that enables/disables menu entries.
+    void add_enabled_listener(SGPropertyNode * node);
+
+    // Is the menu visible?
+    bool _visible;
+
+    // The top-level menubar itself.
+    puMenuBar * _menuBar;
+
+    // A map of bindings for the menubar.
+    std::map<std::string,std::vector<SGBinding *> > _bindings;
+
+    // These are hoops that we have to jump through because PUI doesn't
+    // do memory management for lists.  We have to allocate the arrays,
+    // hang onto pointers, and then delete them when the menubar is
+    // freed.
+    char ** make_char_array (int size);
+    puCallback * make_callback_array (int size);
+    std::vector<char **> _char_arrays;
+    std::vector<puCallback *> _callback_arrays;
+
+    // A map for {menu node path}->puObject translation.
+    std::map<std::string, puObject *> _objects;
+};
+
+#endif // __MENUBAR_HXX
diff --git a/src/GUI/menubar.cxx b/src/GUI/menubar.cxx
index b21b9ce64..4295f808b 100644
--- a/src/GUI/menubar.cxx
+++ b/src/GUI/menubar.cxx
@@ -2,373 +2,11 @@
 #  include <config.h>
 #endif
 
-#include <string.h>
-#include <iostream>
-#include <plib/pu.h>
-#include <simgear/debug/logstream.hxx>
-#include <simgear/structure/SGBinding.hxx>
-#include <simgear/props/props_io.hxx>
 
-#include <Main/globals.hxx>
-
-#include "new_gui.hxx"
 #include "menubar.hxx"
 
-using std::vector;
-using std::string;
-using std::map;
-////////////////////////////////////////////////////////////////////////
-// FIXME!!
-//
-// Deprecated wrappers for old menu commands.
-//
-// DO NOT ADD TO THESE.  THEY WILL BE DELETED SOON!
-//
-// These are defined in gui_funcs.cxx.  They should be replaced with
-// user-configured dialogs and new commands where necessary.
-////////////////////////////////////////////////////////////////////////
-
-#if defined(TR_HIRES_SNAP)
-extern void dumpHiResSnapShot ();
-static bool
-do_hires_snapshot_dialog (const SGPropertyNode * arg)
-{
-    dumpHiResSnapShot();
-    return true;
-}
-#endif // TR_HIRES_SNAP
-
-static struct {
-    const char * name;
-    SGCommandMgr::command_t command;
-} deprecated_dialogs [] = {
-#if defined(TR_HIRES_SNAP)
-    { "old-hires-snapshot-dialog", do_hires_snapshot_dialog },
-#endif
-    { 0, 0 }
-};
-
-static void
-add_deprecated_dialogs ()
-{
-  SG_LOG(SG_GENERAL, SG_INFO, "Initializing old dialog commands:");
-  for (int i = 0; deprecated_dialogs[i].name != 0; i++) {
-    SG_LOG(SG_GENERAL, SG_INFO, "  " << deprecated_dialogs[i].name);
-    globals->get_commands()->addCommand(deprecated_dialogs[i].name,
-					deprecated_dialogs[i].command);
-  }
-}
-
-
-
-////////////////////////////////////////////////////////////////////////
-// Static functions.
-////////////////////////////////////////////////////////////////////////
-
-
-static void
-menu_callback (puObject * object)
-{
-    NewGUI * gui = (NewGUI *)globals->get_subsystem("gui");
-    gui->getMenuBar()->fireItem(object);
-}
-
-
-
-////////////////////////////////////////////////////////////////////////
-// Implementation of FGMenuBar.
-////////////////////////////////////////////////////////////////////////
-
-
-FGMenuBar::FGMenuBar ()
-    : _visible(false),
-      _menuBar(0)
-{
-}
-
 FGMenuBar::~FGMenuBar ()
 {
-    destroy_menubar();
-}
-
-void
-FGMenuBar::init ()
-{
-    delete _menuBar;            // FIXME: check if PUI owns the pointer
-    make_menubar();
-                                // FIXME: temporary commands to get at
-                                // old, hard-coded dialogs.
-    add_deprecated_dialogs();
-}
-
-void
-FGMenuBar::show ()
-{
-    if (_menuBar != 0)
-        _menuBar->reveal();
-    _visible = true;
-}
-
-void
-FGMenuBar::hide ()
-{
-    if (_menuBar != 0)
-        _menuBar->hide();
-    _visible = false;
-}
-
-bool
-FGMenuBar::isVisible () const
-{
-    return _visible;
-}
-
-void
-FGMenuBar::fireItem (puObject * item)
-{
-    const char * name = item->getLegend();
-    vector<SGBinding *> &bindings = _bindings[name];
-    int nBindings = bindings.size();
-
-    for (int i = 0; i < nBindings; i++)
-        bindings[i]->fire();
-}
-
-void
-FGMenuBar::make_menu (SGPropertyNode * node)
-{
-    const char * name = strdup(node->getStringValue("label"));
-    vector<SGPropertyNode_ptr> item_nodes = node->getChildren("item");
-
-    int array_size = item_nodes.size();
-
-    char ** items = make_char_array(array_size);
-    puCallback * callbacks = make_callback_array(array_size);
-
-    for (unsigned int i = 0, j = item_nodes.size() - 1;
-         i < item_nodes.size();
-         i++, j--) {
-
-                                // Set up the PUI entries for this item
-        items[j] = strdup((char *)item_nodes[i]->getStringValue("label"));
-        callbacks[j] = menu_callback;
-
-                                // Load all the bindings for this item
-        vector<SGPropertyNode_ptr> bindings = item_nodes[i]->getChildren("binding");
-        SGPropertyNode * dest = fgGetNode("/sim/bindings/menu", true);
-
-        for (unsigned int k = 0; k < bindings.size(); k++) {
-            unsigned int m = 0;
-            SGPropertyNode_ptr binding;
-            while (dest->getChild("binding", m))
-                m++;
-
-            binding = dest->getChild("binding", m, true);
-            copyProperties(bindings[k], binding);
-            _bindings[items[j]].push_back(new SGBinding(binding, globals->get_props()));
-        }
-    }
-
-    _menuBar->add_submenu(name, items, callbacks);
-}
-
-void
-FGMenuBar::make_menubar ()
-{
-    SGPropertyNode *targetpath;
-   
-    targetpath = fgGetNode("/sim/menubar/default",true);
-    // fgLoadProps("gui/menubar.xml", targetpath);
-    
-    /* NOTE: there is no check to see whether there's any usable data at all
-     *
-     * This would also have the advantage of being able to create some kind of
-     * 'fallback' menu - just in case that either menubar.xml is empty OR that
-     * its XML data is not valid, that way we would avoid displaying an
-     * unusable menubar without any functionality - if we decided to add another
-     * char * element to the commands structure in
-     *  $FG_SRC/src/Main/fgcommands.cxx 
-     * we could additionally save each function's (short) description and use
-     * this as label for the fallback PUI menubar item labels - as a workaround
-     * one might simply use the internal fgcommands and put them into the 
-     * fallback menu, so that the user is at least able to re-init the menu
-     * loading - just in case there was some malformed XML in it
-     * (it happend to me ...)
-     */
-    
-    make_menubar(targetpath);
-}
-
-/* WARNING: We aren't yet doing any validation of what's found - but since
- * this isn't done with menubar.xml either, it should not really matter
- * right now. Although one should later on consider to validate the
- * contents, whether they are representing a 'legal' menubar structure.
- */
-void
-FGMenuBar::make_menubar(SGPropertyNode * props) 
-{    
-    // Just in case.
-    destroy_menubar();
-    _menuBar = new puMenuBar;
-
-    vector<SGPropertyNode_ptr> menu_nodes = props->getChildren("menu");
-    for (unsigned int i = 0; i < menu_nodes.size(); i++)
-        make_menu(menu_nodes[i]);
-
-    _menuBar->close();
-    make_object_map(props);
-
-    if (_visible)
-        _menuBar->reveal();
-    else
-        _menuBar->hide();
-}
-
-void
-FGMenuBar::destroy_menubar ()
-{
-    if ( _menuBar == 0 )
-        return;
-
-    hide();
-    puDeleteObject(_menuBar);
-
-    unsigned int i;
-
-                                // Delete all the character arrays
-                                // we were forced to keep around for
-                                // plib.
-    SG_LOG(SG_GENERAL, SG_BULK, "Deleting char arrays");
-    for (i = 0; i < _char_arrays.size(); i++) {
-        for (int j = 0; _char_arrays[i][j] != 0; j++)
-            free(_char_arrays[i][j]); // added with strdup
-        delete[] _char_arrays[i];
-    }
-
-                                // Delete all the callback arrays
-                                // we were forced to keep around for
-                                // plib.
-    SG_LOG(SG_GENERAL, SG_BULK, "Deleting callback arrays");
-    for (i = 0; i < _callback_arrays.size(); i++)
-        delete[] _callback_arrays[i];
-
-                                // Delete all those bindings
-    SG_LOG(SG_GENERAL, SG_BULK, "Deleting bindings");
-    map<string,vector<SGBinding *> >::iterator it;
-    for (it = _bindings.begin(); it != _bindings.end(); it++) {
-        SG_LOG(SG_GENERAL, SG_BULK, "Deleting bindings for " << it->first);
-        for ( i = 0; i < it->second.size(); i++ )
-            delete it->second[i];
-    }
-
-    SG_LOG(SG_GENERAL, SG_BULK, "Done.");
-}
-
-void
-FGMenuBar::make_object_map(SGPropertyNode * node)
-{
-    unsigned int menu_index = 0;
-    vector<SGPropertyNode_ptr> menus = node->getChildren("menu");
-    for (puObject *obj = ((puGroup *)_menuBar)->getFirstChild();
-            obj; obj = obj->getNextObject()) {
-
-        // skip puPopupMenus. They are also children of _menuBar,
-        // but we access them via getUserData()  (see below)
-        if (!(obj->getType() & PUCLASS_ONESHOT))
-            continue;
-
-        if (menu_index >= menus.size()) {
-            SG_LOG(SG_GENERAL, SG_WARN, "'menu' object without node: "
-                    << node->getPath() << "/menu[" << menu_index << ']');
-            return;
-        }
-
-        SGPropertyNode *menu = menus.at(menu_index);
-        _objects[menu->getPath()] = obj;
-        add_enabled_listener(menu);
-
-        puGroup *popup = (puGroup *)obj->getUserData();
-        if (!popup)
-            continue;
-
-        // the entries are for some reason reversed (last first), and we
-        // don't know yet how many there will be; so we collect first
-        vector<puObject *> e;
-        for (puObject *me = popup->getFirstChild(); me; me = me->getNextObject())
-            e.push_back(me);
-
-        vector<SGPropertyNode_ptr> items = menu->getChildren("item");
-        for (unsigned int i = 0; i < e.size(); i++) {
-            if (i >= items.size()) {
-                SG_LOG(SG_GENERAL, SG_WARN, "'item' object without node: "
-                        << menu->getPath() << "/item[" << i << ']');
-                break;
-            }
-            SGPropertyNode *item = items.at(e.size() - i - 1);
-            _objects[item->getPath()] = e[i];
-            add_enabled_listener(item);
-        }
-        menu_index++;
-    }
-}
-
-struct EnabledListener : SGPropertyChangeListener {
-    void valueChanged(SGPropertyNode *node) {
-        NewGUI * gui = (NewGUI *)globals->get_subsystem("gui");
-        if (!gui)
-            return;
-        FGMenuBar *menubar = gui->getMenuBar();
-        if (menubar)
-            menubar->enable_item(node->getParent(), node->getBoolValue());
-    }
-};
-
-void
-FGMenuBar::add_enabled_listener(SGPropertyNode * node)
-{
-    if (!node->hasValue("enabled"))
-        node->setBoolValue("enabled", true);
-
-    enable_item(node, node->getBoolValue("enabled"));
-    node->getNode("enabled")->addChangeListener(new EnabledListener());
-}
-
-bool
-FGMenuBar::enable_item(const SGPropertyNode * node, bool state)
-{
-    string path = node->getPath();
-    if (_objects.find(path) == _objects.end()) {
-        SG_LOG(SG_GENERAL, SG_ALERT, "Trying to enable/disable "
-            "non-existent menu item for node `" << path << '\'');
-        return false;
-    }
-    puObject *object = _objects[path];
-    if (state)
-        object->activate();
-    else
-        object->greyOut();
-
-    return true;
-}
-
-char **
-FGMenuBar::make_char_array (int size)
-{
-    char ** list = new char*[size+1];
-    for (int i = 0; i <= size; i++)
-        list[i] = 0;
-    _char_arrays.push_back(list);
-    return list;
-}
-
-puCallback *
-FGMenuBar::make_callback_array (int size)
-{
-    puCallback * list = new puCallback[size+1];
-    for (int i = 0; i <= size; i++)
-        list[i] = 0;
-    _callback_arrays.push_back(list);
-    return list;
 }
 
 // end of menubar.cxx
diff --git a/src/GUI/menubar.hxx b/src/GUI/menubar.hxx
index 79e0af814..fa3f43ca5 100644
--- a/src/GUI/menubar.hxx
+++ b/src/GUI/menubar.hxx
@@ -3,42 +3,19 @@
 #ifndef __MENUBAR_HXX
 #define __MENUBAR_HXX 1
 
-#ifndef __cplusplus
-# error This library requires C++
-#endif
-
-#include <Main/fg_props.hxx>
-
-#include <plib/pu.h>
-
-#include <map>
-#include <vector>
-
-class puMenuBar;
-class puObject;
-class SGBinding;
-
 
 /**
- * XML-configured PUI menu bar.
+ * XML-configured menu bar interface
  *
  * This class creates a menu bar from a tree of XML properties.  These
  * properties are not part of the main FlightGear property tree, but
  * are read from a separate file ($FG_ROOT/gui/menubar.xml).
- *
- * WARNING: because PUI provides no easy way to attach user data to a
- * menu item, all menu item strings must be unique; otherwise, this
- * class will always use the first binding with any given name.
+
  */
 class FGMenuBar
 {
 public:
 
-    /**
-     * Constructor.
-     */
-    FGMenuBar ();
-
 
     /**
      * Destructor.
@@ -49,89 +26,25 @@ public:
     /**
      * Initialize the menu bar from $FG_ROOT/gui/menubar.xml
      */
-    virtual void init ();
+    virtual void init () = 0;
     
     /**
      * Make the menu bar visible.
      */
-    virtual void show ();
+    virtual void show () = 0;
 
 
     /**
      * Make the menu bar invisible.
      */
-    virtual void hide ();
+    virtual void hide () = 0;
 
 
     /**
      * Test whether the menu bar is visible.
      */
-    virtual bool isVisible () const;
+    virtual bool isVisible () const = 0;
 
-
-    /**
-     * IGNORE THIS METHOD!!!
-     *
-     * This is necessary only because plib does not provide any easy
-     * way to attach user data to a menu item.  FlightGear should not
-     * have to know about PUI internals, but this method allows the
-     * callback to pass the menu item one-shot on to the current menu.
-     */
-    virtual void fireItem (puObject * item);
-
-
-    /**
-     * create a menubar based on a PropertyList within the PropertyTree
-     */
-    void make_menubar (SGPropertyNode * props);
-
-
-    /**
-     * destroy a menubar based on a PropertyList within the PropertyTree
-     */
-    void destroy_menubar ();
-
-
-    /**
-     * Disable/enable menu titles and entries
-     */
-    bool enable_item (const SGPropertyNode * item, bool state);
-
-
-private:
-
-    // Make a single menu.
-    void make_menu (SGPropertyNode * node);
-
-    // Make the top-level menubar.
-    void make_menubar ();
-
-    // Create a property-path -> puObject map for menu node
-    void make_object_map(SGPropertyNode * node);
-
-    // Add <enabled> listener that enables/disables menu entries.
-    void add_enabled_listener(SGPropertyNode * node);
-
-    // Is the menu visible?
-    bool _visible;
-
-    // The top-level menubar itself.
-    puMenuBar * _menuBar;
-
-    // A map of bindings for the menubar.
-    std::map<std::string,std::vector<SGBinding *> > _bindings;
-
-    // These are hoops that we have to jump through because PUI doesn't
-    // do memory management for lists.  We have to allocate the arrays,
-    // hang onto pointers, and then delete them when the menubar is
-    // freed.
-    char ** make_char_array (int size);
-    puCallback * make_callback_array (int size);
-    std::vector<char **> _char_arrays;
-    std::vector<puCallback *> _callback_arrays;
-
-    // A map for {menu node path}->puObject translation.
-    std::map<std::string, puObject *> _objects;
 };
 
 #endif // __MENUBAR_HXX
diff --git a/src/GUI/new_gui.cxx b/src/GUI/new_gui.cxx
index a374b2912..f9d7941c2 100644
--- a/src/GUI/new_gui.cxx
+++ b/src/GUI/new_gui.cxx
@@ -26,7 +26,7 @@
 #include "GL/glx.h"
 #endif
 
-#include "menubar.hxx"
+#include "FGPUIMenuBar.hxx"
 #include "FGPUIDialog.hxx"
 #include "FGFontCache.hxx"
 #include "FGColor.hxx"
@@ -41,14 +41,13 @@ using std::string;
 
 
 NewGUI::NewGUI ()
-    : _menubar(new FGMenuBar),
+    : _menubar(new FGPUIMenuBar),
       _active_dialog(0)
 {
 }
 
 NewGUI::~NewGUI ()
 {
-    delete _menubar;
     _dialog_props.clear();
     for (_itt_t it = _colors.begin(); it != _colors.end(); ++it)
         delete it->second;
@@ -92,8 +91,7 @@ NewGUI::reset (bool reload)
     setStyle();
 
     unbind();
-    delete _menubar;
-    _menubar = new FGMenuBar;
+    _menubar.reset(new FGPUIMenuBar);
 
     if (reload) {
         _dialog_props.clear();
@@ -214,7 +212,7 @@ NewGUI::getActiveDialog ()
 FGMenuBar *
 NewGUI::getMenuBar ()
 {
-    return _menubar;
+    return _menubar.get();
 }
 
 bool
diff --git a/src/GUI/new_gui.hxx b/src/GUI/new_gui.hxx
index 3f69cab95..08a01b27f 100644
--- a/src/GUI/new_gui.hxx
+++ b/src/GUI/new_gui.hxx
@@ -219,7 +219,7 @@ private:
     // Read all the configuration files in a directory.
     void readDir (const SGPath& path);
 
-    FGMenuBar * _menubar;
+    std::auto_ptr<FGMenuBar> _menubar;
     FGDialog * _active_dialog;
     std::map<std::string,FGDialog *> _active_dialogs;
     std::map<std::string,SGPropertyNode_ptr> _dialog_props;

From 394cc3ee9fecd2eb10c168478a3cf96f991622ab Mon Sep 17 00:00:00 2001
From: Frederic Bouvier <fredfgfs01@free.fr>
Date: Sat, 19 Nov 2011 23:37:42 +0100
Subject: [PATCH 07/18] Fix MSVC build

---
 projects/VC90/FlightGear/FlightGear.vcproj | 64 ++++++++++++++++------
 src/GUI/FGColor.cxx                        |  1 +
 2 files changed, 49 insertions(+), 16 deletions(-)

diff --git a/projects/VC90/FlightGear/FlightGear.vcproj b/projects/VC90/FlightGear/FlightGear.vcproj
index 58633d244..364454c1b 100644
--- a/projects/VC90/FlightGear/FlightGear.vcproj
+++ b/projects/VC90/FlightGear/FlightGear.vcproj
@@ -385,14 +385,6 @@
 				RelativePath="..\..\..\src\Aircraft\controls.hxx"
 				>
 			</File>
-			<File
-				RelativePath="..\..\..\src\Aircraft\replay.cxx"
-				>
-			</File>
-			<File
-				RelativePath="..\..\..\src\Aircraft\replay.hxx"
-				>
-			</File>
 			<File
 				RelativePath="..\..\..\src\Aircraft\flightrecorder.cxx"
 				>
@@ -401,6 +393,14 @@
 				RelativePath="..\..\..\src\Aircraft\flightrecorder.hxx"
 				>
 			</File>
+			<File
+				RelativePath="..\..\..\src\Aircraft\replay.cxx"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\Aircraft\replay.hxx"
+				>
+			</File>
 		</Filter>
 		<Filter
 			Name="Lib_Airports"
@@ -2525,6 +2525,38 @@
 				RelativePath="..\..\..\src\GUI\dialog.hxx"
 				>
 			</File>
+			<File
+				RelativePath="..\..\..\src\GUI\FGColor.cxx"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\GUI\FGColor.hxx"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\GUI\FGFontCache.cxx"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\GUI\FGFontCache.hxx"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\GUI\FGPUIDialog.cxx"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\GUI\FGPUIDialog.hxx"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\GUI\FGPUIMenuBar.cxx"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\GUI\FGPUIMenuBar.hxx"
+				>
+			</File>
 			<File
 				RelativePath="..\..\..\src\Gui\fonts.cxx"
 				>
@@ -3753,6 +3785,14 @@
 				RelativePath="..\..\..\src\Instrumentation\mrg.hxx"
 				>
 			</File>
+			<File
+				RelativePath="..\..\..\src\Instrumentation\NavDisplay.cxx"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\src\Instrumentation\NavDisplay.hxx"
+				>
+			</File>
 			<File
 				RelativePath="..\..\..\src\Instrumentation\navradio.cxx"
 				>
@@ -3777,14 +3817,6 @@
 				RelativePath="..\..\..\src\Instrumentation\od_gauge.hxx"
 				>
 			</File>
-			<File
-				RelativePath="..\..\..\src\Instrumentation\NavDisplay.cxx"
-				>
-			</File>
-			<File
-				RelativePath="..\..\..\src\Instrumentation\NavDisplay.hxx"
-				>
-			</File>
 			<File
 				RelativePath="..\..\..\src\Instrumentation\rad_alt.cxx"
 				>
diff --git a/src/GUI/FGColor.cxx b/src/GUI/FGColor.cxx
index e808af662..f96bb1331 100644
--- a/src/GUI/FGColor.cxx
+++ b/src/GUI/FGColor.cxx
@@ -7,6 +7,7 @@
 #include <iostream>
 
 #include <simgear/props/props.hxx>
+#include <simgear/math/SGMath.hxx>
 
 ////////////////////////////////////////////////////////////////////////
 // FGColor class.

From 8b340ff043eb2cc7320e4ac1d175d3264fda0c23 Mon Sep 17 00:00:00 2001
From: James Turner <zakalawe@mac.com>
Date: Sat, 19 Nov 2011 22:42:15 +0000
Subject: [PATCH 08/18] Hopefully fix non-Mac ;)

---
 src/GUI/new_gui.hxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/GUI/new_gui.hxx b/src/GUI/new_gui.hxx
index 08a01b27f..dfc1ad812 100644
--- a/src/GUI/new_gui.hxx
+++ b/src/GUI/new_gui.hxx
@@ -11,6 +11,7 @@
 #include <functional>
 #include <vector>
 #include <map>
+#include <memory> // for auto_ptr on some systems
 
 class SGBinding;
 

From 5381aafe6d53574cb90fdba0cd217509b9f57a25 Mon Sep 17 00:00:00 2001
From: Erik Hofman <erik@ehofman.com>
Date: Sun, 20 Nov 2011 10:28:20 +0100
Subject: [PATCH 09/18] Read CPACK ignore files from .gitignore

---
 CMakeLists.txt | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d620f565c..db0f8e7b3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,6 +20,7 @@ string(STRIP ${versionFile} FLIGHTGEAR_VERSION)
 #packaging
 
 # split version string into components, note CMAKE_MATCH_0 is the entire regexp match
+file(READ .gitignore CPACK_SOURCE_IGNORE_FILES)
 string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CPACK_PACKAGE_VERSION ${FLIGHTGEAR_VERSION} )
 set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1}) 
 set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
@@ -29,8 +30,8 @@ SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
 
 set(CPACK_SOURCE_GENERATOR TBZ2 ZIP)
 set(CPACK_SOURCE_PACKAGE_FILE_NAME "flightgear-${FLIGHTGEAR_VERSION}" CACHE INTERNAL "tarball basename")
-set(CPACK_SOURCE_IGNORE_FILES
-  "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
+#set(CPACK_SOURCE_IGNORE_FILES
+#  "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
 
 include (CPack)
 

From 64102d0da9287575d85ccbcdb7ea3f33b74e7693 Mon Sep 17 00:00:00 2001
From: Erik Hofman <erik@ehofman.com>
Date: Sun, 20 Nov 2011 15:03:48 +0100
Subject: [PATCH 10/18] Allow for a different property root location besides
 '/'

---
 src/Sound/fg_fx.cxx | 24 ++++++++++++++----------
 src/Sound/fg_fx.hxx |  5 +++--
 2 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/src/Sound/fg_fx.cxx b/src/Sound/fg_fx.cxx
index 376498c7f..eac5179ba 100644
--- a/src/Sound/fg_fx.cxx
+++ b/src/Sound/fg_fx.cxx
@@ -39,14 +39,18 @@
 #include <simgear/sound/soundmgr_openal.hxx>
 #include <simgear/sound/xmlsound.hxx>
 
-FGFX::FGFX ( SGSoundMgr *smgr, const string &refname ) :
+FGFX::FGFX ( SGSoundMgr *smgr, const string &refname, SGPropertyNode *props ) :
+    _props( props ),
     _enabled( fgGetNode("/sim/sound/effects/enabled", true) ),
-    _volume( fgGetNode("/sim/sound/effects/volume", true) ),
-    _avionics_enabled( fgGetNode("/sim/sound/avionics/enabled", true) ),
-    _avionics_volume( fgGetNode("/sim/sound/avionics/volume", true) ),
-    _avionics_external( fgGetNode("/sim/sound/avionics/external-view", true) ),
-    _internal( fgGetNode("/sim/current-view/internal", true) )
+    _volume( fgGetNode("/sim/sound/effects/volume", true) )
 {
+    if (!props) _props = globals->get_props();
+
+    _avionics_enabled = _props->getNode("sim/sound/avionics/enabled", true);
+    _avionics_volume = _props->getNode("sim/sound/avionics/volume", true);
+    _avionics_ext = _props->getNode("sim/sound/avionics/external-view", true);
+    _internal = _props->getNode("sim/current-view/internal", true);
+
     SGSampleGroup::_smgr = smgr;
     SGSampleGroup::_refname = refname;
     SGSampleGroup::_smgr->add(this, refname);
@@ -67,7 +71,7 @@ FGFX::~FGFX ()
 void
 FGFX::init()
 {
-    SGPropertyNode *node = fgGetNode("/sim/sound", true);
+    SGPropertyNode *node = _props->getNode("sim/sound", true);
 
     string path_str = node->getStringValue("path");
     if (path_str.empty()) {
@@ -121,12 +125,12 @@ FGFX::reinit()
 void
 FGFX::update (double dt)
 {
-    bool active = _avionics_external->getBoolValue() ||
+    bool active = _avionics_ext->getBoolValue() ||
                   _internal->getBoolValue();
 
-    if ( active && _avionics_enabled->getBoolValue() )
+    if ( active && _avionics_enabled->getBoolValue() ) {
         _avionics->resume(); // no-op if already in resumed state
-    else
+    } else
         _avionics->suspend();
     _avionics->set_volume( _avionics_volume->getFloatValue() );
 
diff --git a/src/Sound/fg_fx.hxx b/src/Sound/fg_fx.hxx
index 8051ce4aa..a46d8583c 100644
--- a/src/Sound/fg_fx.hxx
+++ b/src/Sound/fg_fx.hxx
@@ -49,7 +49,7 @@ class FGFX : public SGSampleGroup
 
 public:
 
-    FGFX ( SGSoundMgr *smgr, const string &refname );
+    FGFX ( SGSoundMgr *smgr, const string &refname, SGPropertyNode *props = 0 );
     virtual ~FGFX ();
 
     virtual void init ();
@@ -61,11 +61,12 @@ private:
     SGSharedPtr<SGSampleGroup> _avionics;
     std::vector<SGXmlSound *> _sound;
 
+    SGPropertyNode_ptr _props;
     SGPropertyNode_ptr _enabled;
     SGPropertyNode_ptr _volume;
     SGPropertyNode_ptr _avionics_enabled;
     SGPropertyNode_ptr _avionics_volume;
-    SGPropertyNode_ptr _avionics_external;
+    SGPropertyNode_ptr _avionics_ext;
     SGPropertyNode_ptr _internal;
 };
 

From 9e1121fc4ccaa179baa8fe292d604bc2eaf7a62e Mon Sep 17 00:00:00 2001
From: Erik Hofman <erik@ehofman.com>
Date: Sun, 20 Nov 2011 15:05:37 +0100
Subject: [PATCH 11/18] First implementation of sound effects for AI models.

---
 src/AIModel/.AIBase.cxx.swp | Bin 0 -> 16384 bytes
 src/AIModel/AIBase.cxx      |  41 ++++++++++++++++++++++++++++++++++--
 src/AIModel/AIBase.hxx      |   2 ++
 3 files changed, 41 insertions(+), 2 deletions(-)
 create mode 100644 src/AIModel/.AIBase.cxx.swp

diff --git a/src/AIModel/.AIBase.cxx.swp b/src/AIModel/.AIBase.cxx.swp
new file mode 100644
index 0000000000000000000000000000000000000000..29e590c57d7804a3e8feaa8ddfe70a780c654402
GIT binary patch
literal 16384
zcmeI2TZ|-C8OIA2mW!Y$D*FKV(QB}W?dj^v&d%)2u+Y16>#)-^neN$TK~t&jI@Nuk
zx=vAbdS-gLNMeE-P0$x1JQ`y}h%dw!O}r!~$b%AN)ToI@6C;Tx1|LYo3;xfks+sPY
zU6%)aG1bYhyXsuN`p*A+b?Tf`-7cN0uhMj}V&HR&VZ3wrwZ=178^-H*8U_pbqbm7I
zpA9>ZBD_*5!+1&=G^4O%x?MLiU5|HrvdipHr`77K!eO3StDm+bR_yHTT-jn)B2yq!
z;N2^5vr(;-OGk5e(XAiYeD~F|l9>XT0+|At0+|At0+|At0+|At0{<5Z$l!Y89kc{X
ze&ciCs)Tp&c^b!`PtN~^^8m*;p@1s$Pn=)C?-R-SKXCpK&VQDi{~hNSac;t}D*ral
zU&il?$@$-Kp2PX(p*SCh*(XyVQy^0yQy^0yQy^0yQy^0yQy^0yQy^0yQ{aE3fbHnl
z{>Hl60KofywFmI}`wZg+ume60E`Zy>2f<I@YZzYy4}c@!L*U0Z8^#yF1K=azcJPav
z4C8sQ2o}H@Py|Q7`@t>XukSI8H^FbgZ@{bI74STG4oI*LJ__Et5q^P}!Asy-5P$}#
zf(p1D90FH^*KRP3FN1Sn6U>7-a2ULKy<z+w`~-XlJOR339o!EJ;0QPb{&JmR{1W^C
zd;>fSJ_%g#Fn9<&2<`wsKWrFZ15blTKoi^tOmGCeeJyN(Z-Z}vuY(uCm%yh$00ejt
zoCcGi0Imav!5^-{HNf}5SHNdL00cM>?gOVl9^4A923LVMu*dR8@N4iZ@FVa&@Cx`U
zcpf|l9Iy^<0ylyiz?+DR?}C@XOW*~-fCE&_tbx%FB_HlmKCnaP%L&6s6PwHHp$J$g
zhYkGI;~t6&(7hBOIhs7xWpZ8D$xqDbO4^Fbo1n*IGa>7XEvEk|k`^*e+Vn%#<&k6|
z$(}7q_>Ax)dyJwE^I15gzU|vx78*;-@gGcPXP-(B^V<58yKdS%D8iMds<|B6K`%cs
zc`9O3IlXE}kLI6hE?bSYg~ioc^8u^1xUo^IH>}h3)`-`4G2d=`Y(=2`s`+q|?F1h0
zaOn-n;gQOvm9-YRBBXp@L~?>^b?U4Cz(jFdSM5#@;*?@7Y#dgPCno_;%4{mmY2l<Y
zljMXwq4MTp6Rs+V9PLBI!Y$rm`pWl`YkLt(a(dEoxa-DcmAhN$Bult1TD_Op6CuAi
zma5IV(n6nF4(nPTMBjCIG+p>3e#k-STcPdnL1eij6{3JK$6|H_Z(uB9ojqf5o-ab#
zJD6#ElFNa^4qDqY5QqpT&E;h#oY`476#WI(&6f&PLa*s|44}`IOIbsEdrSi*mlX=n
zJD3`9+3AfX>kC=qB5DJ}v0^%DXDlhM84cR?g%K$&1Qid5R>%TK!yIHK{i;oL;1-X#
zfZUfZ!25ySk(bFuBr?gYJ{z~{aaX0BEF}@=3*CGq$#8&(Qdj2w7Oty8e9R%P`rYsD
zOWm=e9@l{|+&v0~v?Uxz{ZcWxP#b?0<9-)OaBM5hP7Q{R(6N-3mR+<9?MLzCN2Ta4
zL6SN~PbNoODmL_2n!kHdRj|hptop(|M_pc}jmMly(IJXlUG?!erYv_SUy4Tni~C%1
z+v69Rlh>UzQP5ghLJk9#$4HT!hs>=n<jL~ccJik<oK8@ho%ET$9E>NG(w;<%4<zbF
z9Y{r64x}kz4<vfRKbU6A-847IQ)Bb&**y>aNZOvaubs&VJYH6hcZfeVsylgdyUX!7
zo6ngxH{;PT{+Ub)<qA5^cJ<KDj&Y+_{9wuFa;ZAL-De}GeH$^SMw@)Kq!dh_1hcd0
zQC_qkVYo9?*N~6}Y761f-k?sihB1g#P$<(8?jk&DcwhaS5yMGGKml^ZK-~eU$=O-2
z9a&OXkvHh7fJ2~E%cYsp$*EF#x-y5`#xzkAW3RepaU*xs-zqO-OWi}2;&geYGE<(Z
z&Lzb<Jv*d(9Ol{sPg+_&l*_H^r;3TOug_#SG`k*mSXi_>IXHWi`yCIXC*=@r@l&$c
z+u6yDW$6E8>eRjD`KB274*txEC|5O3jb?R19!Th8Htfjun#1T|3H@L;lLz$v>{Xll
z@Kdz$n2Pg8tS3sFy6@xf{q@r#4r>p(rYE|Q44K`(Trus1Igs2lo6G5g{(#S^(YUmh
zHx5pZw=ZY8&!dhRbrF-YciA$?!*y48i;T2YMBRnc<`VbVCcKMAMMjpXeBGah0mKSq
zcxt3?=h1xh#&}X3uZX#R0P|t7r?Q!kseo}*jp1=v%p(F_-c`9rxr^AMmD;&Q>&#kX
zslIHjVD^W}&5{ZQJtP;X?stj>nkv&0#^y&o?o$)mGu%W=80LGl<OvZL=rra$!Y|Nj
zji^*9mrIl7YN=eH&1S8rOxhTCy0pzvL-u&2CW+n9?#~fsg}%Baw?i%&NulR?OSl3x
zg)6r)gH+Wohyg`CG4LGf*;|Z4)?plj4B6BX!H|Tj>n%4nX<0?0?a?~!SKgtsm?Zg;
zGNSBUI#W;E`XXfHFlnP-w9BiD8)sH(jaKb+{cOE;fiSgOs<#@8%_c3aZBUKYYa6Zl
zna#7c4O-vaSYK-{7KxhhTuoKsin`$WdTV8EvqiPW1v+2D<g(GaFsF4814(R)`MNX)
ze2=3!XfI@zszIuDYeXu7YM5%G=i37{IY3XS>+~=O#{uSQT*59Mk!?np{kQ`U<J>?d
z4Nqh!s8-}rcqj%T3Eb4epCH>G5@vgta3{l+ZhxQzjC#0Kd#Eop)+-}HGDi&kx>uVj
zNq?v&;J)JSP&tQ~(o=f4%ffzi<vt@jx|9g63XUiVjycs5>exO)Vox1)IUA!HM%=jH
z&#S<*9S09>jOMCA>h|Pzgs>K@hd}Ak-E@v`aadYq_Qi`fRZ6AfG>Px&#K<H$_7-<K
z123rDkNd2H$!*bRN@7}2Idpd5x*vm0EK3%BOk;=C@$4uLr}GGKiSEX=<HBcPr$BhP
z>bYJ+Y^f_&(P{X{yn|JbGMhebXp-zU`W{aaogdrPaf@|E{CJBDwf^s6eSHnq<7)k%
z!_N<~&ffwI<iYQ-#{VW5f(V450an2s;4Q58-vF<I&w>?jC%6L`;LouAC-7PDY48ki
z!5V0Q`@n7B!{9n_El~a(0@){1AX6YyAX6YyAX6YyAX6YyAXDJKtU&zgBV=l0p170j
zhwFV@=h(5i8?dUtN(CEMYC(ymH<sp}*k(>q?_a8yG<O|4#+~F%50)nqt7z_HeW`2B
z8R|G)m(0%Y-`K=nY3u>6(@|?&nxCg!Q}55Y(!|T391`N~)%p1x)spT0yo+}xDl6TK
z)%CDU!^$kDj`b0Kv8CZ9jY{6BXk(@wZ&s_z+8)+uSkK0F{6W8scSX8+>b*<!SSTq^
z<>GO=hsx9C6Zpxu=olTJI$4~aNZ$Lv&W0)+unu>jKo@I8y?ck{Id&_0YQ@MN8(>2#
zw&BW2uWhQ`KyyQ13I^2n@~#2wJ4*`Hu1Z=R`VS&lz&j*uN$q~XtF*TERq3Wy%8}ZV
zp@)@%pGXUAW6jNG)3cGLb<v`YeXUB1?TMpbsEyl)hpGIrUhxa4fK19mshNE?lWy31
z*`{7lO_hr$r%^Bv+j+{52n!?CnUlqnGZR#x$#S_^ota6*CVX0`i`Dj2u{4Fg$YVdX
zR6e1)DD@~Q`y^f%M2sF+b*}V5AJ8Dc3oR_OA-#wKC7F>{Q|=z0t`^Iwy9}O{i_=vs
zx3vS<0Z?t;^?>&KJDt4ENSso44^>Z;rz$iO$amkpYXQkKmFn>+!dpt^1sqg2-+%BA
Zdub{_FQw*Gd8T+mi8)oQOr3yh{|3Y4)z1I`

literal 0
HcmV?d00001

diff --git a/src/AIModel/AIBase.cxx b/src/AIModel/AIBase.cxx
index 69442229c..d8c87f90f 100644
--- a/src/AIModel/AIBase.cxx
+++ b/src/AIModel/AIBase.cxx
@@ -42,6 +42,7 @@
 #include <Main/globals.hxx>
 #include <Scenery/scenery.hxx>
 #include <Scripting/NasalSys.hxx>
+#include <Sound/fg_fx.hxx>
 
 #include "AIBase.hxx"
 #include "AIManager.hxx"
@@ -70,7 +71,8 @@ FGAIBase::FGAIBase(object_type ot, bool enableHot) :
     _impact_speed(0),
     _refID( _newAIModelID() ),
     _otype(ot),
-    _initialized(false)
+    _initialized(false),
+    _fx(0)
 
 {
     tgt_heading = hdg = tgt_altitude_ft = tgt_speed = 0.0;
@@ -137,6 +139,9 @@ FGAIBase::~FGAIBase() {
         if (parent)
             model_removed->setStringValue(props->getPath());
     }
+    delete _fx;
+    _fx = 0;
+
     delete fp;
     fp = 0;
 }
@@ -198,6 +203,19 @@ void FGAIBase::update(double dt) {
 
     ft_per_deg_lat = 366468.96 - 3717.12 * cos(pos.getLatitudeRad());
     ft_per_deg_lon = 365228.16 * cos(pos.getLatitudeRad());
+
+    if ( _fx )
+    {
+        // update model's audio sample values
+        _fx->set_position_geod( pos );
+
+        SGQuatd orient = SGQuatd::fromYawPitchRollDeg(hdg, pitch, roll);
+        _fx->set_orientation( orient );
+
+        SGVec3d velocity;
+        velocity = SGVec3d( speed_north_deg_sec, speed_east_deg_sec, pitch*speed );
+        _fx->set_velocity( velocity );
+    }
 }
 
 /** update LOD properties of the model */
@@ -293,6 +311,20 @@ bool FGAIBase::init(bool search_in_AI_path) {
         aip.setVisible(true);
         invisible = false;
         globals->get_scenery()->get_scene_graph()->addChild(aip.getSceneGraph());
+
+        // Get the sound-path tag from the configuration file and store it
+        // in the property tree.
+        string fxpath = props->getStringValue("/sim/sound/path");
+        if ( !fxpath.empty() )
+        {
+            props->setStringValue("sim/sound/path", fxpath.c_str());
+
+            // initialize the sound configuration
+            SGSoundMgr *smgr = globals->get_soundmgr();
+            _fx = new FGFX(smgr, "aifx:"+f, props);
+            _fx->init();
+        }
+
         _initialized = true;
 
     } else if (!model_path.empty()) {
@@ -400,7 +432,12 @@ void FGAIBase::bind() {
     props->setDoubleValue("controls/flight/target-alt", altitude_ft);
     props->setDoubleValue("controls/flight/target-pitch", pitch);
 
-   props->setDoubleValue("controls/flight/target-spd", speed);
+    props->setDoubleValue("controls/flight/target-spd", speed);
+
+    props->setBoolValue("sim/sound/avionics/enabled", false);
+    props->setDoubleValue("sim/sound/avionics/volume", 0.0);
+    props->setBoolValue("sim/sound/avionics/external-view", false);
+    props->setBoolValue("sim/current-view/internal", false);
 
 }
 
diff --git a/src/AIModel/AIBase.hxx b/src/AIModel/AIBase.hxx
index fb845bd41..726ce303b 100644
--- a/src/AIModel/AIBase.hxx
+++ b/src/AIModel/AIBase.hxx
@@ -43,6 +43,7 @@ using std::list;
 class SGMaterial;
 class FGAIManager;
 class FGAIFlightPlan;
+class FGFX;
 
 class FGAIBase : public SGReferenced {
 
@@ -225,6 +226,7 @@ private:
     object_type _otype;
     bool _initialized;
     osg::ref_ptr<osg::LOD> _model; //The 3D model LOD object
+    SGSharedPtr<FGFX>  _fx;
 
 public:
     object_type getType();

From 544bad86c7ad3bd21f58f07c39c49ec05830d9c6 Mon Sep 17 00:00:00 2001
From: Erik Hofman <erik@ehofman.com>
Date: Sun, 20 Nov 2011 15:06:10 +0100
Subject: [PATCH 12/18] remove a .swp file

---
 src/AIModel/.AIBase.cxx.swp | Bin 16384 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 src/AIModel/.AIBase.cxx.swp

diff --git a/src/AIModel/.AIBase.cxx.swp b/src/AIModel/.AIBase.cxx.swp
deleted file mode 100644
index 29e590c57d7804a3e8feaa8ddfe70a780c654402..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 16384
zcmeI2TZ|-C8OIA2mW!Y$D*FKV(QB}W?dj^v&d%)2u+Y16>#)-^neN$TK~t&jI@Nuk
zx=vAbdS-gLNMeE-P0$x1JQ`y}h%dw!O}r!~$b%AN)ToI@6C;Tx1|LYo3;xfks+sPY
zU6%)aG1bYhyXsuN`p*A+b?Tf`-7cN0uhMj}V&HR&VZ3wrwZ=178^-H*8U_pbqbm7I
zpA9>ZBD_*5!+1&=G^4O%x?MLiU5|HrvdipHr`77K!eO3StDm+bR_yHTT-jn)B2yq!
z;N2^5vr(;-OGk5e(XAiYeD~F|l9>XT0+|At0+|At0+|At0+|At0{<5Z$l!Y89kc{X
ze&ciCs)Tp&c^b!`PtN~^^8m*;p@1s$Pn=)C?-R-SKXCpK&VQDi{~hNSac;t}D*ral
zU&il?$@$-Kp2PX(p*SCh*(XyVQy^0yQy^0yQy^0yQy^0yQy^0yQy^0yQ{aE3fbHnl
z{>Hl60KofywFmI}`wZg+ume60E`Zy>2f<I@YZzYy4}c@!L*U0Z8^#yF1K=azcJPav
z4C8sQ2o}H@Py|Q7`@t>XukSI8H^FbgZ@{bI74STG4oI*LJ__Et5q^P}!Asy-5P$}#
zf(p1D90FH^*KRP3FN1Sn6U>7-a2ULKy<z+w`~-XlJOR339o!EJ;0QPb{&JmR{1W^C
zd;>fSJ_%g#Fn9<&2<`wsKWrFZ15blTKoi^tOmGCeeJyN(Z-Z}vuY(uCm%yh$00ejt
zoCcGi0Imav!5^-{HNf}5SHNdL00cM>?gOVl9^4A923LVMu*dR8@N4iZ@FVa&@Cx`U
zcpf|l9Iy^<0ylyiz?+DR?}C@XOW*~-fCE&_tbx%FB_HlmKCnaP%L&6s6PwHHp$J$g
zhYkGI;~t6&(7hBOIhs7xWpZ8D$xqDbO4^Fbo1n*IGa>7XEvEk|k`^*e+Vn%#<&k6|
z$(}7q_>Ax)dyJwE^I15gzU|vx78*;-@gGcPXP-(B^V<58yKdS%D8iMds<|B6K`%cs
zc`9O3IlXE}kLI6hE?bSYg~ioc^8u^1xUo^IH>}h3)`-`4G2d=`Y(=2`s`+q|?F1h0
zaOn-n;gQOvm9-YRBBXp@L~?>^b?U4Cz(jFdSM5#@;*?@7Y#dgPCno_;%4{mmY2l<Y
zljMXwq4MTp6Rs+V9PLBI!Y$rm`pWl`YkLt(a(dEoxa-DcmAhN$Bult1TD_Op6CuAi
zma5IV(n6nF4(nPTMBjCIG+p>3e#k-STcPdnL1eij6{3JK$6|H_Z(uB9ojqf5o-ab#
zJD6#ElFNa^4qDqY5QqpT&E;h#oY`476#WI(&6f&PLa*s|44}`IOIbsEdrSi*mlX=n
zJD3`9+3AfX>kC=qB5DJ}v0^%DXDlhM84cR?g%K$&1Qid5R>%TK!yIHK{i;oL;1-X#
zfZUfZ!25ySk(bFuBr?gYJ{z~{aaX0BEF}@=3*CGq$#8&(Qdj2w7Oty8e9R%P`rYsD
zOWm=e9@l{|+&v0~v?Uxz{ZcWxP#b?0<9-)OaBM5hP7Q{R(6N-3mR+<9?MLzCN2Ta4
zL6SN~PbNoODmL_2n!kHdRj|hptop(|M_pc}jmMly(IJXlUG?!erYv_SUy4Tni~C%1
z+v69Rlh>UzQP5ghLJk9#$4HT!hs>=n<jL~ccJik<oK8@ho%ET$9E>NG(w;<%4<zbF
z9Y{r64x}kz4<vfRKbU6A-847IQ)Bb&**y>aNZOvaubs&VJYH6hcZfeVsylgdyUX!7
zo6ngxH{;PT{+Ub)<qA5^cJ<KDj&Y+_{9wuFa;ZAL-De}GeH$^SMw@)Kq!dh_1hcd0
zQC_qkVYo9?*N~6}Y761f-k?sihB1g#P$<(8?jk&DcwhaS5yMGGKml^ZK-~eU$=O-2
z9a&OXkvHh7fJ2~E%cYsp$*EF#x-y5`#xzkAW3RepaU*xs-zqO-OWi}2;&geYGE<(Z
z&Lzb<Jv*d(9Ol{sPg+_&l*_H^r;3TOug_#SG`k*mSXi_>IXHWi`yCIXC*=@r@l&$c
z+u6yDW$6E8>eRjD`KB274*txEC|5O3jb?R19!Th8Htfjun#1T|3H@L;lLz$v>{Xll
z@Kdz$n2Pg8tS3sFy6@xf{q@r#4r>p(rYE|Q44K`(Trus1Igs2lo6G5g{(#S^(YUmh
zHx5pZw=ZY8&!dhRbrF-YciA$?!*y48i;T2YMBRnc<`VbVCcKMAMMjpXeBGah0mKSq
zcxt3?=h1xh#&}X3uZX#R0P|t7r?Q!kseo}*jp1=v%p(F_-c`9rxr^AMmD;&Q>&#kX
zslIHjVD^W}&5{ZQJtP;X?stj>nkv&0#^y&o?o$)mGu%W=80LGl<OvZL=rra$!Y|Nj
zji^*9mrIl7YN=eH&1S8rOxhTCy0pzvL-u&2CW+n9?#~fsg}%Baw?i%&NulR?OSl3x
zg)6r)gH+Wohyg`CG4LGf*;|Z4)?plj4B6BX!H|Tj>n%4nX<0?0?a?~!SKgtsm?Zg;
zGNSBUI#W;E`XXfHFlnP-w9BiD8)sH(jaKb+{cOE;fiSgOs<#@8%_c3aZBUKYYa6Zl
zna#7c4O-vaSYK-{7KxhhTuoKsin`$WdTV8EvqiPW1v+2D<g(GaFsF4814(R)`MNX)
ze2=3!XfI@zszIuDYeXu7YM5%G=i37{IY3XS>+~=O#{uSQT*59Mk!?np{kQ`U<J>?d
z4Nqh!s8-}rcqj%T3Eb4epCH>G5@vgta3{l+ZhxQzjC#0Kd#Eop)+-}HGDi&kx>uVj
zNq?v&;J)JSP&tQ~(o=f4%ffzi<vt@jx|9g63XUiVjycs5>exO)Vox1)IUA!HM%=jH
z&#S<*9S09>jOMCA>h|Pzgs>K@hd}Ak-E@v`aadYq_Qi`fRZ6AfG>Px&#K<H$_7-<K
z123rDkNd2H$!*bRN@7}2Idpd5x*vm0EK3%BOk;=C@$4uLr}GGKiSEX=<HBcPr$BhP
z>bYJ+Y^f_&(P{X{yn|JbGMhebXp-zU`W{aaogdrPaf@|E{CJBDwf^s6eSHnq<7)k%
z!_N<~&ffwI<iYQ-#{VW5f(V450an2s;4Q58-vF<I&w>?jC%6L`;LouAC-7PDY48ki
z!5V0Q`@n7B!{9n_El~a(0@){1AX6YyAX6YyAX6YyAX6YyAXDJKtU&zgBV=l0p170j
zhwFV@=h(5i8?dUtN(CEMYC(ymH<sp}*k(>q?_a8yG<O|4#+~F%50)nqt7z_HeW`2B
z8R|G)m(0%Y-`K=nY3u>6(@|?&nxCg!Q}55Y(!|T391`N~)%p1x)spT0yo+}xDl6TK
z)%CDU!^$kDj`b0Kv8CZ9jY{6BXk(@wZ&s_z+8)+uSkK0F{6W8scSX8+>b*<!SSTq^
z<>GO=hsx9C6Zpxu=olTJI$4~aNZ$Lv&W0)+unu>jKo@I8y?ck{Id&_0YQ@MN8(>2#
zw&BW2uWhQ`KyyQ13I^2n@~#2wJ4*`Hu1Z=R`VS&lz&j*uN$q~XtF*TERq3Wy%8}ZV
zp@)@%pGXUAW6jNG)3cGLb<v`YeXUB1?TMpbsEyl)hpGIrUhxa4fK19mshNE?lWy31
z*`{7lO_hr$r%^Bv+j+{52n!?CnUlqnGZR#x$#S_^ota6*CVX0`i`Dj2u{4Fg$YVdX
zR6e1)DD@~Q`y^f%M2sF+b*}V5AJ8Dc3oR_OA-#wKC7F>{Q|=z0t`^Iwy9}O{i_=vs
zx3vS<0Z?t;^?>&KJDt4ENSso44^>Z;rz$iO$amkpYXQkKmFn>+!dpt^1sqg2-+%BA
Zdub{_FQw*Gd8T+mi8)oQOr3yh{|3Y4)z1I`


From 04395fa9a5e2e1fe82652666252f597f51de3ebd Mon Sep 17 00:00:00 2001
From: Erik Hofman <erik@ehofman.com>
Date: Sun, 20 Nov 2011 15:31:58 +0100
Subject: [PATCH 13/18] Postpone initialization of the avionics soundgroup
 until avionics are enabled. This prevents AI classes from creating new and
 unnecessary avionics sample groups.

---
 src/AIModel/AIBase.cxx |  2 +-
 src/Sound/fg_fx.cxx    | 25 ++++++++++++++++++-------
 2 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/src/AIModel/AIBase.cxx b/src/AIModel/AIBase.cxx
index d8c87f90f..2d7edd550 100644
--- a/src/AIModel/AIBase.cxx
+++ b/src/AIModel/AIBase.cxx
@@ -314,7 +314,7 @@ bool FGAIBase::init(bool search_in_AI_path) {
 
         // Get the sound-path tag from the configuration file and store it
         // in the property tree.
-        string fxpath = props->getStringValue("/sim/sound/path");
+        string fxpath = props->getStringValue("sim/sound/path");
         if ( !fxpath.empty() )
         {
             props->setStringValue("sim/sound/path", fxpath.c_str());
diff --git a/src/Sound/fg_fx.cxx b/src/Sound/fg_fx.cxx
index eac5179ba..7aad56b0b 100644
--- a/src/Sound/fg_fx.cxx
+++ b/src/Sound/fg_fx.cxx
@@ -54,8 +54,12 @@ FGFX::FGFX ( SGSoundMgr *smgr, const string &refname, SGPropertyNode *props ) :
     SGSampleGroup::_smgr = smgr;
     SGSampleGroup::_refname = refname;
     SGSampleGroup::_smgr->add(this, refname);
-    _avionics = _smgr->find("avionics", true);
-    _avionics->tie_to_listener();
+
+    if (_avionics_enabled->getBoolValue())
+    {
+        _avionics = _smgr->find("avionics", true);
+        _avionics->tie_to_listener();
+    }
 }
 
 
@@ -128,11 +132,18 @@ FGFX::update (double dt)
     bool active = _avionics_ext->getBoolValue() ||
                   _internal->getBoolValue();
 
-    if ( active && _avionics_enabled->getBoolValue() ) {
-        _avionics->resume(); // no-op if already in resumed state
-    } else
-        _avionics->suspend();
-    _avionics->set_volume( _avionics_volume->getFloatValue() );
+    if (_avionics_enabled->getBoolValue()) {
+        if (!_avionics) {
+            _avionics = _smgr->find("avionics", true);
+            _avionics->tie_to_listener();
+        }
+
+        if ( active )
+            _avionics->resume(); // no-op if already in resumed state
+        else
+            _avionics->suspend();
+        _avionics->set_volume( _avionics_volume->getFloatValue() );
+    }
 
     if ( _enabled->getBoolValue() ) {
         set_volume( _volume->getDoubleValue() );

From e1c1a28288183236d2244b15cd494276e94fe59c Mon Sep 17 00:00:00 2001
From: ThorstenB <brehmt@gmail.com>
Date: Sun, 20 Nov 2011 16:20:05 +0100
Subject: [PATCH 14/18] Introduce some structure in fgMainLoop. - Move some
 code to sub functions. - Make sound manager a subsystem-manager member (and
 make sure it's still processed last).

---
 src/Main/fg_init.cxx |   9 ++
 src/Main/globals.cxx |  11 ++-
 src/Main/globals.hxx |   1 -
 src/Main/main.cxx    | 209 +++++++++++++++++++++++--------------------
 4 files changed, 124 insertions(+), 106 deletions(-)

diff --git a/src/Main/fg_init.cxx b/src/Main/fg_init.cxx
index 8d01e88e6..807606916 100644
--- a/src/Main/fg_init.cxx
+++ b/src/Main/fg_init.cxx
@@ -1181,6 +1181,15 @@ bool fgInitSubsystems() {
     SG_LOG( SG_GENERAL, SG_INFO, "Initialize Subsystems");
     SG_LOG( SG_GENERAL, SG_INFO, "========== ==========");
 
+    ////////////////////////////////////////////////////////////////////
+    // Initialize the sound subsystem.
+    ////////////////////////////////////////////////////////////////////
+    // Sound manager uses an own subsystem group "SOUND" which is the last
+    // to be updated in every loop.
+    // Sound manager is updated last so it can use the CPU while the GPU
+    // is processing the scenery (doubled the frame-rate for me) -EMH-
+    globals->add_subsystem("sound", new SGSoundMgr, SGSubsystemMgr::SOUND);
+
     ////////////////////////////////////////////////////////////////////
     // Initialize the event manager subsystem.
     ////////////////////////////////////////////////////////////////////
diff --git a/src/Main/globals.cxx b/src/Main/globals.cxx
index e2ea2954b..00dd943dc 100644
--- a/src/Main/globals.cxx
+++ b/src/Main/globals.cxx
@@ -125,7 +125,6 @@ FGGlobals::FGGlobals() :
     renderer( new FGRenderer ),
     subsystem_mgr( new SGSubsystemMgr ),
     event_mgr( new SGEventMgr ),
-    soundmgr( new SGSoundMgr ),
     sim_time_sec( 0.0 ),
     fg_root( "" ),
     time_params( NULL ),
@@ -151,7 +150,7 @@ FGGlobals::FGGlobals() :
     dmelist( NULL ),
     tacanlist( NULL ),
     carrierlist( NULL ),
-    channellist( NULL )    
+    channellist( NULL )
 {
   simgear::ResourceManager::instance()->addProvider(new AircraftResourceProvider());
   simgear::PropertyObjectBase::setDefaultRoot(props);
@@ -206,9 +205,6 @@ FGGlobals::~FGGlobals()
     delete tacanlist;
     delete carrierlist;
     delete channellist;
-
-    soundmgr->unbind();
-    delete soundmgr;
 }
 
 
@@ -360,7 +356,10 @@ FGGlobals::add_subsystem (const char * name,
 SGSoundMgr *
 FGGlobals::get_soundmgr () const
 {
-    return soundmgr;
+    if (subsystem_mgr)
+        return (SGSoundMgr*) subsystem_mgr->get_subsystem("sound");
+
+    return NULL;
 }
 
 SGEventMgr *
diff --git a/src/Main/globals.hxx b/src/Main/globals.hxx
index 52df7f514..11dc124dc 100644
--- a/src/Main/globals.hxx
+++ b/src/Main/globals.hxx
@@ -91,7 +91,6 @@ private:
     FGRenderer *renderer;
     SGSubsystemMgr *subsystem_mgr;
     SGEventMgr *event_mgr;
-    SGSoundMgr *soundmgr;
 
     // Number of milliseconds elapsed since the start of the program.
     double sim_time_sec;
diff --git a/src/Main/main.cxx b/src/Main/main.cxx
index 1cfdd7dbf..d6036771a 100644
--- a/src/Main/main.cxx
+++ b/src/Main/main.cxx
@@ -93,105 +93,10 @@ using std::cerr;
 // splash screen up and running right away.
 int idle_state = 0;
 
-
-void fgInitSoundManager();
-void fgSetNewSoundDevice(const char *);
-
 // The atexit() function handler should know when the graphical subsystem
 // is initialized.
 extern int _bootstrap_OSInit;
 
-// What should we do when we have nothing else to do?  Let's get ready
-// for the next move and update the display?
-static void fgMainLoop( void )
-{
-    static SGPropertyNode_ptr frame_signal
-        = fgGetNode("/sim/signals/frame", true);
-
-    frame_signal->fireValueChanged();
-    
-    SG_LOG( SG_GENERAL, SG_DEBUG, "Running Main Loop");
-    SG_LOG( SG_GENERAL, SG_DEBUG, "======= ==== ====");
-    
-    
-  // update "time"
-    double sim_dt, real_dt;
-    TimeManager* timeMgr = (TimeManager*) globals->get_subsystem("time");
-    // compute simulated time (allowing for pause, warp, etc) and
-    // real elapsed time
-    timeMgr->computeTimeDeltas(sim_dt, real_dt);
-
-    // update magvar model
-    globals->get_mag()->update( globals->get_aircraft_position(),
-                                globals->get_time_params()->getJD() );
-
-    globals->get_subsystem_mgr()->update(sim_dt);
-
-    // Update the sound manager last so it can use the CPU while the GPU
-    // is processing the scenery (doubled the frame-rate for me) -EMH-
-#ifdef ENABLE_AUDIO_SUPPORT
-    static bool smgr_init = true;
-    static SGPropertyNode *sound_working = fgGetNode("/sim/sound/working");
-    if (smgr_init == true) {
-        if (sound_working->getBoolValue() == true) {
-            fgInitSoundManager();
-            smgr_init = false;
-        }
-    } else {
-        static SGPropertyNode *sound_enabled = fgGetNode("/sim/sound/enabled");
-        static SGSoundMgr *smgr = globals->get_soundmgr();
-        static bool smgr_enabled = true;
-
-        if (sound_working->getBoolValue() == false) {	// request to reinit
-           smgr->reinit();
-           smgr->resume();
-           sound_working->setBoolValue(true);
-        }
-
-        if (smgr_enabled != sound_enabled->getBoolValue()) {
-            if (smgr_enabled == true) { // request to suspend
-                smgr->suspend();
-                smgr_enabled = false;
-            } else {
-                smgr->resume();
-                smgr_enabled = true;
-            }
-        }
-
-        if (smgr_enabled == true) {
-            static SGPropertyNode *volume = fgGetNode("/sim/sound/volume");
-            smgr->set_volume(volume->getFloatValue());
-            smgr->update(sim_dt);
-        }
-    }
-#endif
-
-    // END Tile Manager updates
-    bool scenery_loaded = fgGetBool("sim/sceneryloaded");
-    if (!scenery_loaded)
-    {
-        if (globals->get_tile_mgr()->isSceneryLoaded()
-             && fgGetBool("sim/fdm-initialized")) {
-            fgSetBool("sim/sceneryloaded",true);
-            fgSplashProgress("");
-            if (fgGetBool("/sim/sound/working")) {
-                globals->get_soundmgr()->activate();
-            }
-            globals->get_props()->tie("/sim/sound/devices/name",
-                  SGRawValueFunctions<const char *>(0, fgSetNewSoundDevice), false);
-        }
-        else
-        {
-            fgSplashProgress("loading scenery");
-            // be nice to loader threads while waiting for initial scenery, reduce to 2fps
-            SGTimeStamp::sleepForMSec(500);
-        }
-    }
-
-    simgear::AtomicChangeListener::fireChangeListeners();
-
-    SG_LOG( SG_GENERAL, SG_DEBUG, "" );
-}
 
 void fgInitSoundManager()
 {
@@ -210,10 +115,116 @@ void fgInitSoundManager()
 
 void fgSetNewSoundDevice(const char *device)
 {
-    globals->get_soundmgr()->suspend();
-    globals->get_soundmgr()->stop();
-    globals->get_soundmgr()->init(device);
-    globals->get_soundmgr()->resume();
+    SGSoundMgr *smgr = globals->get_soundmgr();
+    smgr->suspend();
+    smgr->stop();
+    smgr->init(device);
+    smgr->resume();
+}
+
+// Update sound manager state (init/suspend/resume) and propagate property values,
+// since the sound manager doesn't read any properties itself.
+// Actual sound update is triggered by the subsystem manager.
+static void fgUpdateSound(double dt)
+{
+#ifdef ENABLE_AUDIO_SUPPORT
+    static bool smgr_init = true;
+    static SGPropertyNode *sound_working = fgGetNode("/sim/sound/working");
+    if (smgr_init == true) {
+        if (sound_working->getBoolValue() == true) {
+            fgInitSoundManager();
+            smgr_init = false;
+        }
+    } else {
+        static SGPropertyNode *sound_enabled = fgGetNode("/sim/sound/enabled");
+        static SGSoundMgr *smgr = globals->get_soundmgr();
+        static bool smgr_enabled = true;
+
+        if (sound_working->getBoolValue() == false) {   // request to reinit
+           smgr->reinit();
+           smgr->resume();
+           sound_working->setBoolValue(true);
+        }
+
+        if (smgr_enabled != sound_enabled->getBoolValue()) {
+            if (smgr_enabled == true) { // request to suspend
+                smgr->suspend();
+                smgr_enabled = false;
+            } else {
+                smgr->resume();
+                smgr_enabled = true;
+            }
+        }
+
+        if (smgr_enabled == true) {
+            static SGPropertyNode *volume = fgGetNode("/sim/sound/volume");
+            smgr->set_volume(volume->getFloatValue());
+        }
+    }
+#endif
+}
+
+static void fgLoadInitialScenery()
+{
+    static SGPropertyNode_ptr scenery_loaded
+        = fgGetNode("sim/sceneryloaded", true);
+
+    if (!scenery_loaded->getBoolValue())
+    {
+        if (globals->get_tile_mgr()->isSceneryLoaded()
+             && fgGetBool("sim/fdm-initialized")) {
+            fgSetBool("sim/sceneryloaded",true);
+            fgSplashProgress("");
+            if (fgGetBool("/sim/sound/working")) {
+                globals->get_soundmgr()->activate();
+            }
+            globals->get_props()->tie("/sim/sound/devices/name",
+                  SGRawValueFunctions<const char *>(0, fgSetNewSoundDevice), false);
+        }
+        else
+        {
+            fgSplashProgress("loading scenery");
+            // be nice to loader threads while waiting for initial scenery, reduce to 2fps
+            SGTimeStamp::sleepForMSec(500);
+        }
+    }
+}
+
+// What should we do when we have nothing else to do?  Let's get ready
+// for the next move and update the display?
+static void fgMainLoop( void )
+{
+    static SGPropertyNode_ptr frame_signal
+        = fgGetNode("/sim/signals/frame", true);
+
+    frame_signal->fireValueChanged();
+
+    SG_LOG( SG_GENERAL, SG_DEBUG, "Running Main Loop");
+    SG_LOG( SG_GENERAL, SG_DEBUG, "======= ==== ====");
+
+    // compute simulated time (allowing for pause, warp, etc) and
+    // real elapsed time
+    double sim_dt, real_dt;
+    TimeManager* timeMgr = (TimeManager*) globals->get_subsystem("time");
+    timeMgr->computeTimeDeltas(sim_dt, real_dt);
+
+    // update magvar model
+    globals->get_mag()->update( globals->get_aircraft_position(),
+                                globals->get_time_params()->getJD() );
+
+    // Propagate sound manager properties (note: actual update is triggered
+    // by the subsystem manager).
+    fgUpdateSound(sim_dt);
+
+    // update all subsystems
+    globals->get_subsystem_mgr()->update(sim_dt);
+
+    // END Tile Manager updates
+    fgLoadInitialScenery();
+
+    simgear::AtomicChangeListener::fireChangeListeners();
+
+    SG_LOG( SG_GENERAL, SG_DEBUG, "" );
 }
 
 // Operation for querying OpenGL parameters. This must be done in a

From ebfdebeb43ca11e385fc5248fcdd6746899b1c9f Mon Sep 17 00:00:00 2001
From: James Turner <zakalawe@mac.com>
Date: Sun, 20 Nov 2011 13:23:52 +0000
Subject: [PATCH 15/18] Cocoa menu-bar implementation.

---
 CMakeLists.txt             |   3 +-
 src/GUI/CMakeLists.txt     |   5 +
 src/GUI/FGCocoaMenuBar.hxx |  65 +++++++++++
 src/GUI/FGCocoaMenuBar.mm  | 231 +++++++++++++++++++++++++++++++++++++
 src/GUI/new_gui.cxx        |  21 +++-
 5 files changed, 321 insertions(+), 4 deletions(-)
 create mode 100644 src/GUI/FGCocoaMenuBar.hxx
 create mode 100644 src/GUI/FGCocoaMenuBar.mm

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1fde17c9d..e1b568b0b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -65,7 +65,8 @@ IF(APPLE)
     set(EVENT_INPUT_DEFAULT 1)
     
     find_library(CORESERVICES_LIBRARY CoreServices)
-    list(APPEND PLATFORM_LIBS ${CORESERVICES_LIBRARY})
+    find_library(COCOA_LIBRARY Cocoa)
+    list(APPEND PLATFORM_LIBS ${COCOA_LIBRARY} ${CORESERVICES_LIBRARY})
 
 elseif(CMAKE_SYSTEM_NAME MATCHES "Linux")
     # disabled while DBus / HAL / udev issues are decided
diff --git a/src/GUI/CMakeLists.txt b/src/GUI/CMakeLists.txt
index 030416ef0..b44a90f09 100644
--- a/src/GUI/CMakeLists.txt
+++ b/src/GUI/CMakeLists.txt
@@ -37,4 +37,9 @@ set(HEADERS
 	FGColor.hxx
 	)
     		
+if (APPLE)
+    list(APPEND HEADERS FGCocoaMenuBar.hxx)
+    list(APPEND SOURCES FGCocoaMenuBar.mm)
+endif()
+    		
 flightgear_component(GUI "${SOURCES}" "${HEADERS}")
diff --git a/src/GUI/FGCocoaMenuBar.hxx b/src/GUI/FGCocoaMenuBar.hxx
new file mode 100644
index 000000000..694561aae
--- /dev/null
+++ b/src/GUI/FGCocoaMenuBar.hxx
@@ -0,0 +1,65 @@
+// menubar.hxx - XML-configured menu bar.
+
+#ifndef FG_COCOA_MENUBAR_HXX
+#define FG_COCOA_MENUBAR_HXX 1
+
+#include <GUI/menubar.hxx>
+
+#include <memory>
+
+/**
+ * XML-configured Cocoa menu bar.
+ *
+ * This class creates a menu bar from a tree of XML properties.  These
+ * properties are not part of the main FlightGear property tree, but
+ * are read from a separate file ($FG_ROOT/gui/menubar.xml).
+ *
+ * WARNING: because PUI provides no easy way to attach user data to a
+ * menu item, all menu item strings must be unique; otherwise, this
+ * class will always use the first binding with any given name.
+ */
+class FGCocoaMenuBar : public FGMenuBar
+{
+public:
+  
+  /**
+   * Constructor.
+   */
+  FGCocoaMenuBar ();
+  
+  
+  /**
+   * Destructor.
+   */
+  virtual ~FGCocoaMenuBar ();
+  
+  
+  /**
+   * Initialize the menu bar from $FG_ROOT/gui/menubar.xml
+   */
+  virtual void init ();
+  
+  /**
+   * Make the menu bar visible.
+   */
+  virtual void show ();
+  
+  
+  /**
+   * Make the menu bar invisible.
+   */
+  virtual void hide ();
+  
+  
+  /**
+   * Test whether the menu bar is visible.
+   */
+  virtual bool isVisible () const;
+  
+  class CocoaMenuBarPrivate;
+private:
+  std::auto_ptr<CocoaMenuBarPrivate> p;
+  
+};
+
+#endif // __MENUBAR_HXX
diff --git a/src/GUI/FGCocoaMenuBar.mm b/src/GUI/FGCocoaMenuBar.mm
new file mode 100644
index 000000000..7b44c7820
--- /dev/null
+++ b/src/GUI/FGCocoaMenuBar.mm
@@ -0,0 +1,231 @@
+#include "FGCocoaMenuBar.hxx"
+
+#include <Cocoa/Cocoa.h>
+
+#include <boost/foreach.hpp>
+
+#include <simgear/props/props.hxx>
+#include <simgear/props/props_io.hxx>
+#include <simgear/debug/logstream.hxx>
+#include <simgear/structure/SGBinding.hxx>
+
+#include <Main/fg_props.hxx>
+
+#include <iostream>
+
+using std::string;
+using std::map;
+using std::cout;
+
+typedef std::map<NSMenuItem*, SGBindingList> MenuItemBindings;
+
+@class CocoaMenuDelegate;
+
+class FGCocoaMenuBar::CocoaMenuBarPrivate
+{
+public:
+  CocoaMenuBarPrivate();
+  ~CocoaMenuBarPrivate();
+  
+  bool labelIsSeparator(const std::string& s) const;  
+  void menuFromProps(NSMenu* menu, SGPropertyNode* menuNode);
+  
+  void fireBindingsForItem(NSMenuItem* item);
+  
+public:
+  CocoaMenuDelegate* delegate;
+  
+  MenuItemBindings itemBindings;
+};
+
+
+@interface CocoaMenuDelegate : NSObject <NSMenuDelegate> {
+@private
+  FGCocoaMenuBar::CocoaMenuBarPrivate* peer;
+}
+
+@property (nonatomic, assign) FGCocoaMenuBar::CocoaMenuBarPrivate* peer;
+@end
+
+@implementation CocoaMenuDelegate
+
+@synthesize peer;
+
+- (void) itemAction:(id) sender
+{
+  peer->fireBindingsForItem((NSMenuItem*) sender);
+}
+
+@end
+
+static NSString* stdStringToCocoa(const string& s)
+{
+  return [NSString stringWithUTF8String:s.c_str()];
+}
+
+class EnabledListener : public SGPropertyChangeListener
+{
+public:
+  EnabledListener(NSMenuItem* i) :
+    item(i)
+  {}
+  
+  
+  virtual void valueChanged(SGPropertyNode *node) 
+  {
+    BOOL b = node->getBoolValue();
+    [item setEnabled:b];
+  }
+  
+private:
+  NSMenuItem* item;
+};
+
+
+
+FGCocoaMenuBar::CocoaMenuBarPrivate::CocoaMenuBarPrivate()
+{
+  delegate = [[CocoaMenuDelegate alloc] init];
+  delegate.peer = this;
+}
+  
+FGCocoaMenuBar::CocoaMenuBarPrivate::~CocoaMenuBarPrivate()
+{
+  [delegate release];
+}
+  
+bool FGCocoaMenuBar::CocoaMenuBarPrivate::labelIsSeparator(const std::string& s) const
+{
+  for (unsigned int i=0; i<s.size(); ++i) {
+    if (s[i] != '-') {
+      return false;
+    }
+  }
+  
+  return true;
+}
+  
+void FGCocoaMenuBar::CocoaMenuBarPrivate::menuFromProps(NSMenu* menu, SGPropertyNode* menuNode)
+{
+  int index = 0;
+  BOOST_FOREACH(SGPropertyNode_ptr n, menuNode->getChildren("item")) {
+    if (!n->hasValue("enabled")) {
+      n->setBoolValue("enabled", true);
+    }
+    
+    string l = n->getStringValue("label");
+    string::size_type pos = l.find("(");
+    if (pos != string::npos) {
+      l = l.substr(0, pos);
+    }
+    
+    NSString* label = stdStringToCocoa(l);
+    NSString* shortcut = @"";
+    NSMenuItem* item;
+    if (index >= [menu numberOfItems]) {
+      if (labelIsSeparator(l)) {
+        item = [NSMenuItem separatorItem];
+        [menu addItem:item];
+      } else {        
+        item = [menu addItemWithTitle:label action:nil keyEquivalent:shortcut];
+        n->getNode("enabled")->addChangeListener(new EnabledListener(item));
+        [item setTarget:delegate];
+        [item setAction:@selector(itemAction:)];
+      }
+    } else {
+      item = [menu itemAtIndex:index];
+      [item setTitle:label]; 
+    }
+    
+    BOOL enabled = n->getBoolValue("enabled");
+    [item setEnabled:enabled];
+    
+    SGBindingList bl;
+    BOOST_FOREACH(SGPropertyNode_ptr binding, n->getChildren("binding")) {
+    // have to clone the bindings, since SGBinding takes ownership of the
+    // passed in node. Seems like something is wrong here, but following the
+    // PUI code for the moment.
+      SGPropertyNode* cloned(new SGPropertyNode);
+      copyProperties(binding, cloned);
+      bl.push_back(new SGBinding(cloned, globals->get_props()));
+    }
+    
+    itemBindings[item] = bl;    
+    ++index;
+  } // of item iteration
+}
+
+void FGCocoaMenuBar::CocoaMenuBarPrivate::fireBindingsForItem(NSMenuItem *item)
+{
+  MenuItemBindings::iterator it = itemBindings.find(item);
+  if (it == itemBindings.end()) {
+    return;
+  }
+
+  BOOST_FOREACH(SGSharedPtr<SGBinding> b, it->second) {
+    b->fire();
+  }
+}
+
+FGCocoaMenuBar::FGCocoaMenuBar() :
+  p(new CocoaMenuBarPrivate)
+{
+  
+}
+
+FGCocoaMenuBar::~FGCocoaMenuBar()
+{
+  
+}
+
+void FGCocoaMenuBar::init()
+{
+  NSMenu* mainBar = [[NSApplication sharedApplication] mainMenu];
+  SGPropertyNode_ptr props = fgGetNode("/sim/menubar/default",true);
+  
+  int index = 0;
+  NSMenuItem* previousMenu = [mainBar itemAtIndex:0];
+  if (![[previousMenu title] isEqualToString:@"FlightGear"]) {
+    [previousMenu setTitle:@"FlightGear"];
+  }
+  
+  BOOST_FOREACH(SGPropertyNode_ptr n, props->getChildren("menu")) {
+    NSString* label = stdStringToCocoa(n->getStringValue("label"));
+    NSMenuItem* item = [mainBar itemWithTitle:label];
+    NSMenu* menu;
+    
+    if (!item) {
+      NSInteger insertIndex = [mainBar indexOfItem:previousMenu] + 1; 
+      item = [mainBar insertItemWithTitle:label action:nil keyEquivalent:@"" atIndex:insertIndex];
+      item.tag = index + 400;
+      
+      menu = [[NSMenu alloc] init];
+      menu.title = label;
+      [menu setAutoenablesItems:NO];
+      [mainBar setSubmenu:menu forItem:item];
+      [menu autorelease];
+    } else {
+      menu = item.submenu;
+    }
+    
+  // synchronise menu with properties
+    p->menuFromProps(menu, n);
+    ++index;
+    previousMenu = item;
+  }
+}
+
+bool FGCocoaMenuBar::isVisible() const
+{
+  return true;
+}
+
+void FGCocoaMenuBar::show()
+{
+  // no-op
+}
+
+void FGCocoaMenuBar::hide()
+{
+  // no-op
+}
diff --git a/src/GUI/new_gui.cxx b/src/GUI/new_gui.cxx
index f9d7941c2..ef50d7731 100644
--- a/src/GUI/new_gui.cxx
+++ b/src/GUI/new_gui.cxx
@@ -27,6 +27,11 @@
 #endif
 
 #include "FGPUIMenuBar.hxx"
+
+#if defined(SG_MAC)
+#include "FGCocoaMenuBar.hxx"
+#endif
+
 #include "FGPUIDialog.hxx"
 #include "FGFontCache.hxx"
 #include "FGColor.hxx"
@@ -40,10 +45,14 @@ using std::string;
 
 
 
-NewGUI::NewGUI ()
-    : _menubar(new FGPUIMenuBar),
-      _active_dialog(0)
+NewGUI::NewGUI () :
+  _active_dialog(0)
 {
+#if defined(SG_MAC)
+  _menubar.reset(new FGCocoaMenuBar);
+#else
+  _menubar.reset(new FGPUIMenuBar);
+#endif
 }
 
 NewGUI::~NewGUI ()
@@ -91,7 +100,13 @@ NewGUI::reset (bool reload)
     setStyle();
 
     unbind();
+#if defined(SG_MAC)
+    if (reload) {
+        _menubar.reset(new FGCocoaMenuBar);
+    }
+#else
     _menubar.reset(new FGPUIMenuBar);
+#endif
 
     if (reload) {
         _dialog_props.clear();

From 9e344ee64594e4932e11227a95e6efcafad1cd86 Mon Sep 17 00:00:00 2001
From: James Turner <zakalawe@mac.com>
Date: Sun, 20 Nov 2011 16:33:22 +0000
Subject: [PATCH 16/18] Avoid crash when reloading GUI from debug menu.

---
 src/GUI/new_gui.cxx | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/GUI/new_gui.cxx b/src/GUI/new_gui.cxx
index ef50d7731..c13456068 100644
--- a/src/GUI/new_gui.cxx
+++ b/src/GUI/new_gui.cxx
@@ -100,11 +100,7 @@ NewGUI::reset (bool reload)
     setStyle();
 
     unbind();
-#if defined(SG_MAC)
-    if (reload) {
-        _menubar.reset(new FGCocoaMenuBar);
-    }
-#else
+#if !defined(SG_MAC)
     _menubar.reset(new FGPUIMenuBar);
 #endif
 

From 029226f8d41a13c9f1886c7ca1f7515ce106b8ce Mon Sep 17 00:00:00 2001
From: James Turner <zakalawe@mac.com>
Date: Sun, 20 Nov 2011 18:30:31 +0000
Subject: [PATCH 17/18] Use property objects to avoid property look-ups during
 TimeManager updates.

---
 src/Time/TimeManager.cxx | 27 ++++++++++++++-------------
 src/Time/TimeManager.hxx |  6 ++++++
 2 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/src/Time/TimeManager.cxx b/src/Time/TimeManager.cxx
index 00f6f31b9..96282bfe3 100644
--- a/src/Time/TimeManager.cxx
+++ b/src/Time/TimeManager.cxx
@@ -53,7 +53,12 @@ static bool do_timeofday (const SGPropertyNode * arg)
 
 TimeManager::TimeManager() :
   _inited(false),
-  _impl(NULL)
+  _impl(NULL),
+  _sceneryLoaded("sim/sceneryloaded"),
+  _sceneryLoadOverride("sim/sceneryloaded-override"),
+  _modelHz("sim/model-hz"),
+  _timeDelta("sim/time/delta-realtime-sec"),
+  _simTimeDelta("sim/time/delta-sec")
 {
   SGCommandMgr::instance()->addCommand("timeofday", do_timeofday);
 }
@@ -158,9 +163,7 @@ void TimeManager::computeTimeDeltas(double& simDt, double& realDt)
     _lastClockFreeze = _clockFreeze->getBoolValue();
   }
 
-  bool scenery_loaded = fgGetBool("sim/sceneryloaded");
-  bool wait_for_scenery = !(scenery_loaded || fgGetBool("sim/sceneryloaded-override"));
-  
+  bool wait_for_scenery = !(_sceneryLoaded || _sceneryLoadOverride);
   if (!wait_for_scenery) {
     throttleUpdateRate();
   }
@@ -190,20 +193,18 @@ void TimeManager::computeTimeDeltas(double& simDt, double& realDt)
   if (0 < dtMax && dtMax < dt) {
     dt = dtMax;
   }
-  
-  int model_hz = fgGetInt("/sim/model-hz");
-  
+    
   SGSubsystemGroup* fdmGroup = 
     globals->get_subsystem_mgr()->get_group(SGSubsystemMgr::FDM);
-  fdmGroup->set_fixed_update_time(1.0 / model_hz);
+  fdmGroup->set_fixed_update_time(1.0 / _modelHz);
   
 // round the real time down to a multiple of 1/model-hz.
 // this way all systems are updated the _same_ amount of dt.
   dt += _dtRemainder;
-  int multiLoop = long(floor(dt * model_hz));
+  int multiLoop = long(floor(dt * _modelHz));
   multiLoop = SGMisc<long>::max(0, multiLoop);
-  _dtRemainder = dt - double(multiLoop)/double(model_hz);
-  dt = double(multiLoop)/double(model_hz);
+  _dtRemainder = dt - double(multiLoop)/double(_modelHz);
+  dt = double(multiLoop)/double(_modelHz);
 
   realDt = dt;
   if (_clockFreeze->getBoolValue() || wait_for_scenery) {
@@ -216,8 +217,8 @@ void TimeManager::computeTimeDeltas(double& simDt, double& realDt)
   globals->inc_sim_time_sec(simDt);
 
 // These are useful, especially for Nasal scripts.
-  fgSetDouble("/sim/time/delta-realtime-sec", realDt);
-  fgSetDouble("/sim/time/delta-sec", simDt);
+  _timeDelta = realDt;
+  _simTimeDelta = simDt;
 }
 
 void TimeManager::update(double dt)
diff --git a/src/Time/TimeManager.hxx b/src/Time/TimeManager.hxx
index 10226eaf6..ef86c907f 100644
--- a/src/Time/TimeManager.hxx
+++ b/src/Time/TimeManager.hxx
@@ -23,6 +23,7 @@
 
 #include <simgear/structure/subsystem_mgr.hxx>
 #include <simgear/props/props.hxx>
+#include <simgear/props/propertyObject.hxx>
 
 // forward decls
 class SGTime;
@@ -87,6 +88,11 @@ private:
   time_t _lastFrameTime;
   double _frameLatencyMax;
   int _frameCount;
+  
+  SGPropObjBool _sceneryLoaded, 
+    _sceneryLoadOverride;
+  SGPropObjInt _modelHz;
+  SGPropObjDouble _timeDelta, _simTimeDelta;
 };
 
 #endif // of FG_TIME_TIMEMANAGER_HXX

From 50f82808f98052188457ca8b2bbcf736fa12b795 Mon Sep 17 00:00:00 2001
From: Anders Gidenstam <anders@gidenstam.org>
Date: Tue, 22 Nov 2011 21:15:42 +0100
Subject: [PATCH 18/18] src/FDM/JSBSim/models/FGGasCell.cpp: Restore the
 ballonet model to a working state.

---
 src/FDM/JSBSim/models/FGGasCell.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/FDM/JSBSim/models/FGGasCell.cpp b/src/FDM/JSBSim/models/FGGasCell.cpp
index de92cc1fa..f2f6688c3 100644
--- a/src/FDM/JSBSim/models/FGGasCell.cpp
+++ b/src/FDM/JSBSim/models/FGGasCell.cpp
@@ -261,8 +261,8 @@ FGGasCell::~FGGasCell()
 void FGGasCell::Calculate(double dt)
 {
   const double AirTemperature = in.Temperature;  // [Rankine]
-  const double AirPressure    = in.Pressure;     // [lbs/ft²]
-  const double AirDensity     = in.Density;      // [slug/ft³]
+  const double AirPressure    = in.Pressure;     // [lbs/ft^2]
+  const double AirDensity     = in.Density;      // [slug/ft^3]
   const double g = in.gravity;                   // [lbs/slug]
 
   const double OldTemperature = Temperature;
@@ -689,8 +689,8 @@ FGBallonet::~FGBallonet()
 
 void FGBallonet::Calculate(double dt)
 {
-  const double ParentPressure = Parent->GetPressure(); // [lbs/ft²]
-  const double AirPressure    = Pressure;              // [lbs/ft²]
+  const double ParentPressure = Parent->GetPressure(); // [lbs/ft^2]
+  const double AirPressure    = in.Pressure;           // [lbs/ft^2]
 
   const double OldTemperature = Temperature;
   const double OldPressure    = Pressure;