#include <boost/foreach.hpp>
#include <algorithm>
+#include <osgViewer/Viewer>
+#include <osgDB/Registry>
+
#include <simgear/structure/commands.hxx>
#include <simgear/misc/sg_path.hxx>
#include <simgear/misc/sg_dir.hxx>
#include <simgear/props/propertyObject.hxx>
#include <simgear/props/props_io.hxx>
#include <simgear/scene/model/modellib.hxx>
+#include <simgear/package/Root.hxx>
#include <Aircraft/controls.hxx>
#include <Airports/runways.hxx>
-#include <ATCDCL/ATISmgr.hxx>
#include <Autopilot/route_mgr.hxx>
#include <GUI/FGFontCache.hxx>
#include <GUI/gui.h>
#include <Navaids/navlist.hxx>
#include <Viewer/renderer.hxx>
#include <Viewer/viewmgr.hxx>
+#include <Sound/sample_queue.hxx>
#include "globals.hxx"
#include "locale.hxx"
// Constructor
FGGlobals::FGGlobals() :
- initial_state( NULL ),
renderer( new FGRenderer ),
subsystem_mgr( new SGSubsystemMgr ),
event_mgr( new SGEventMgr ),
fg_home( "" ),
time_params( NULL ),
ephem( NULL ),
- matlib( NULL ),
route_mgr( NULL ),
- ATIS_mgr( NULL ),
controls( NULL ),
viewmgr( NULL ),
commands( SGCommandMgr::instance() ),
initial_waypoints( NULL ),
fontcache ( new FGFontCache ),
channellist( NULL ),
- haveUserSettings(false)
+ haveUserSettings(false),
+ _chatter_queue(NULL)
{
SGPropertyNode* root = new SGPropertyNode;
props = SGPropertyNode_ptr(root);
subsystem_mgr->remove("model-manager");
_tile_mgr.clear();
+ osg::ref_ptr<osgViewer::Viewer> vw(renderer->getViewer());
+ if (vw) {
+ // https://code.google.com/p/flightgear-bugs/issues/detail?id=1291
+ // explicitly stop trheading before we delete the renderer or
+ // viewMgr (which ultimately holds refs to the CameraGroup, and
+ // GraphicsContext)
+ vw->stopThreading();
+ }
+
+ // don't cancel the pager until after shutdown, since AIModels (and
+ // potentially others) can queue delete requests on the pager.
+ if (vw && vw->getDatabasePager()) {
+ vw->getDatabasePager()->cancel();
+ vw->getDatabasePager()->clear();
+ }
+
+ osgDB::Registry::instance()->clearObjectCache();
+
// renderer touches subsystems during its destruction
set_renderer(NULL);
_scenery.clear();
-
+ _chatter_queue.clear();
+
delete subsystem_mgr;
- subsystem_mgr = NULL; // important so ::get_subsystem returns NULL
+ subsystem_mgr = NULL; // important so ::get_subsystem returns NULL
+ vw = 0; // don't delete the viewer until now
delete time_params;
set_matlib(NULL);
delete route_mgr;
- delete ATIS_mgr;
delete channel_options_list;
delete initial_waypoints;
delete fontcache;
delete locale;
locale = NULL;
+ cleanupListeners();
+
props.clear();
+
+ delete commands;
}
// set the fg_root path
<< fg_root << "'\n***\n***");
}
- // remove /sim/fg-root before writing to prevent hijacking
+ // deliberately not a tied property, for fgValidatePath security
+ // write-protect to avoid accidents
SGPropertyNode *n = fgGetNode("/sim", true);
- n->removeChild("fg-root", 0, false);
+ n->removeChild("fg-root", 0);
n = n->getChild("fg-root", 0, true);
n->setStringValue(fg_root.c_str());
n->setAttribute(SGPropertyNode::WRITE, false);
void FGGlobals::append_fg_scenery (const std::string &paths)
{
-// fg_scenery.clear();
SGPropertyNode* sim = fgGetNode("/sim", true);
// find first unused fg-scenery property in /sim
SGPropertyNode* n = sim->getChild("fg-scenery", propIndex++, true);
n->setStringValue(abspath.str());
n->setAttribute(SGPropertyNode::WRITE, false);
+
+ // temporary fix so these values survive reset
+ n->setAttribute(SGPropertyNode::PRESERVE, true);
} // of path list iteration
}
+void FGGlobals::clear_fg_scenery()
+{
+ fg_scenery.clear();
+}
+
+void FGGlobals::set_catalog_aircraft_path(const SGPath& path)
+{
+ catalog_aircraft_dir = path;
+}
+
+string_list FGGlobals::get_aircraft_paths() const
+{
+ string_list r;
+ if (!catalog_aircraft_dir.isNull()) {
+ r.push_back(catalog_aircraft_dir.str());
+ }
+
+ r.insert(r.end(), fg_aircraft_dirs.begin(), fg_aircraft_dirs.end());
+ return r;
+}
+
void FGGlobals::append_aircraft_path(const std::string& path)
{
SGPath dirPath(path);
if (!dirPath.exists()) {
- SG_LOG(SG_GENERAL, SG_WARN, "aircraft path not found:" << path);
+ SG_LOG(SG_GENERAL, SG_ALERT, "aircraft path not found:" << path);
return;
}
+
+ SGPath acSubdir(dirPath);
+ acSubdir.append("Aircraft");
+ if (acSubdir.exists()) {
+ SG_LOG(
+ SG_GENERAL,
+ SG_WARN,
+ "Specified an aircraft-dir with an 'Aircraft' subdirectory:" << dirPath
+ << ", will instead use child directory:" << acSubdir
+ );
+ dirPath = acSubdir;
+ }
+
std::string abspath = dirPath.realpath();
-
- unsigned int index = fg_aircraft_dirs.size();
fg_aircraft_dirs.push_back(abspath);
-
-// make aircraft dirs available to Nasal
- SGPropertyNode* sim = fgGetNode("/sim", true);
- sim->removeChild("fg-aircraft", index, false);
- SGPropertyNode* n = sim->getChild("fg-aircraft", index, true);
- n->setStringValue(abspath);
- n->setAttribute(SGPropertyNode::WRITE, false);
}
void FGGlobals::append_aircraft_paths(const std::string& path)
}
}
+static void treeClearAliases(SGPropertyNode* nd)
+{
+ if (nd->isAlias()) {
+ nd->unalias();
+ }
+
+ for (int i=0; i<nd->nChildren(); ++i) {
+ SGPropertyNode* cp = nd->getChild(i);
+ treeClearAliases(cp);
+ }
+}
+
void
FGGlobals::resetPropertyRoot()
{
delete locale;
+ cleanupListeners();
+
+ // we don't strictly need to clear these (they will be reset when we
+ // initProperties again), but trying to reduce false-positives when dumping
+ // ref-counts.
+ positionLon.clear();
+ positionLat.clear();
+ positionAlt.clear();
+ viewLon.clear();
+ viewLat.clear();
+ viewAlt.clear();
+ orientPitch.clear();
+ orientHeading.clear();
+ orientRoll.clear();
+
+ // clear aliases so ref-counts are accurate when dumped
+ treeClearAliases(props);
+
SG_LOG(SG_GENERAL, SG_INFO, "root props refcount:" << props.getNumRefs());
treeDumpRefCounts(0, props);
+ //BaseStackSnapshot::dumpAll(std::cout);
+
props = new SGPropertyNode;
initProperties();
locale = new FGLocale(props);
// remove /sim/fg-root before writing to prevent hijacking
SGPropertyNode *n = props->getNode("/sim", true);
- n->removeChild("fg-root", 0, false);
+ n->removeChild("fg-root", 0);
n = n->getChild("fg-root", 0, true);
n->setStringValue(fg_root.c_str());
n->setAttribute(SGPropertyNode::WRITE, false);
}
-// Save the current state as the initial state.
-void
-FGGlobals::saveInitialState ()
-{
- initial_state = new SGPropertyNode();
-
- // copy properties which are READ/WRITEable - but not USERARCHIVEd or PRESERVEd
- int checked = SGPropertyNode::READ+SGPropertyNode::WRITE+
- SGPropertyNode::USERARCHIVE+SGPropertyNode::PRESERVE;
- int expected = SGPropertyNode::READ+SGPropertyNode::WRITE;
- if (!copyProperties(props, initial_state, expected, checked))
- SG_LOG(SG_GENERAL, SG_ALERT, "Error saving initial state");
-
- // delete various properties from the initial state, since we want to
- // preserve their values even if doing a restore
- // => Properties should now use the PRESERVE flag to protect their values
- // on sim-reset. Remove some specific properties for backward compatibility.
- SGPropertyNode* sim = initial_state->getChild("sim");
- SGPropertyNode* cameraGroupNode = sim->getNode("rendering/camera-group");
- if (cameraGroupNode) {
- cameraGroupNode->removeChild("camera");
- cameraGroupNode->removeChild("gui");
- }
-}
-
static std::string autosaveName()
{
std::ostringstream os;
return os.str();
}
-// Restore the saved initial state, if any
-void
-FGGlobals::restoreInitialState ()
-{
- if ( initial_state == 0 ) {
- SG_LOG(SG_GENERAL, SG_ALERT,
- "No initial state available to restore!!!");
- return;
- }
- // copy properties which are READ/WRITEable - but not USERARCHIVEd or PRESERVEd
- int checked = SGPropertyNode::READ+SGPropertyNode::WRITE+
- SGPropertyNode::USERARCHIVE+SGPropertyNode::PRESERVE;
- int expected = SGPropertyNode::READ+SGPropertyNode::WRITE;
- if ( copyProperties(initial_state, props, expected, checked)) {
- SG_LOG( SG_GENERAL, SG_INFO, "Initial state restored successfully" );
- } else {
- SG_LOG( SG_GENERAL, SG_INFO,
- "Some errors restoring initial state (read-only props?)" );
- }
-
-}
-
// Load user settings from autosave.xml
void
FGGlobals::loadUserSettings(const SGPath& dataPath)
void FGGlobals::set_matlib( SGMaterialLib *m )
{
- if (matlib)
- delete matlib;
matlib = m;
}
+FGSampleQueue* FGGlobals::get_chatter_queue() const
+{
+ return _chatter_queue;
+}
+
+void FGGlobals::set_chatter_queue(FGSampleQueue* queue)
+{
+ _chatter_queue = queue;
+}
+
+void FGGlobals::addListenerToCleanup(SGPropertyChangeListener* l)
+{
+ _listeners_to_cleanup.push_back(l);
+}
+
+void FGGlobals::cleanupListeners()
+{
+ SGPropertyChangeListenerVec::iterator i = _listeners_to_cleanup.begin();
+ for (; i != _listeners_to_cleanup.end(); ++i) {
+ delete *i;
+ }
+ _listeners_to_cleanup.clear();
+}
+
+simgear::pkg::Root* FGGlobals::packageRoot()
+{
+ return _packageRoot.get();
+}
+
+void FGGlobals::setPackageRoot(const SGSharedPtr<simgear::pkg::Root>& p)
+{
+ _packageRoot = p;
+}
+
// end of globals.cxx