1998-04-24 00:49:17 +00:00
|
|
|
// options.cxx -- class to handle command line options
|
|
|
|
//
|
|
|
|
// Written by Curtis Olson, started April 1998.
|
|
|
|
//
|
2004-11-19 22:10:41 +00:00
|
|
|
// Copyright (C) 1998 Curtis L. Olson - http://www.flightgear.org/~curt
|
1998-04-24 00:49:17 +00:00
|
|
|
//
|
|
|
|
// 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
|
2006-02-21 01:16:04 +00:00
|
|
|
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
1998-04-24 00:49:17 +00:00
|
|
|
//
|
|
|
|
// $Id$
|
|
|
|
|
|
|
|
|
1998-04-26 05:01:19 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2000-02-15 03:30:01 +00:00
|
|
|
#include <simgear/compiler.h>
|
2003-09-24 17:20:55 +00:00
|
|
|
#include <simgear/structure/exception.hxx>
|
2003-03-22 10:38:15 +00:00
|
|
|
#include <simgear/debug/logstream.hxx>
|
2010-07-01 21:43:28 +00:00
|
|
|
#include <simgear/timing/sg_time.hxx>
|
2010-07-05 07:03:29 +00:00
|
|
|
#include <simgear/misc/sg_dir.hxx>
|
1999-03-02 01:02:31 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
#include <boost/foreach.hpp>
|
|
|
|
|
2015-03-24 16:11:42 +00:00
|
|
|
#include <cmath> // rint()
|
1998-04-24 00:49:17 +00:00
|
|
|
#include <stdio.h>
|
2015-03-24 16:11:42 +00:00
|
|
|
#include <stdlib.h> // atof(), atoi()
|
|
|
|
#include <string.h> // strcmp()
|
2003-02-11 21:17:36 +00:00
|
|
|
#include <algorithm>
|
1999-03-02 01:02:31 +00:00
|
|
|
|
2008-08-14 18:13:39 +00:00
|
|
|
#include <iostream>
|
2008-07-25 18:38:29 +00:00
|
|
|
#include <string>
|
2015-01-04 17:50:10 +00:00
|
|
|
#include <sstream>
|
1998-04-24 00:49:17 +00:00
|
|
|
|
2002-07-26 02:49:14 +00:00
|
|
|
#include <simgear/math/sg_random.h>
|
2008-07-31 12:04:32 +00:00
|
|
|
#include <simgear/props/props_io.hxx>
|
2001-03-25 14:20:12 +00:00
|
|
|
#include <simgear/misc/sgstream.hxx>
|
2002-03-16 00:18:38 +00:00
|
|
|
#include <simgear/misc/sg_path.hxx>
|
2007-05-28 05:21:45 +00:00
|
|
|
#include <simgear/scene/material/mat.hxx>
|
2009-11-30 08:42:29 +00:00
|
|
|
#include <simgear/sound/soundmgr_openal.hxx>
|
2011-02-20 16:14:30 +00:00
|
|
|
#include <simgear/misc/strutils.hxx>
|
2004-01-31 19:47:45 +00:00
|
|
|
#include <Autopilot/route_mgr.hxx>
|
2014-09-17 20:38:40 +00:00
|
|
|
#include <Aircraft/replay.hxx>
|
2013-11-06 23:49:58 +00:00
|
|
|
|
2001-07-19 04:53:13 +00:00
|
|
|
#include <GUI/gui.h>
|
2013-11-06 23:49:58 +00:00
|
|
|
#include <GUI/MessageBox.hxx>
|
2015-03-08 09:40:44 +00:00
|
|
|
#if defined(HAVE_QT)
|
2015-03-06 18:52:06 +00:00
|
|
|
#include <GUI/QtLauncher.hxx>
|
|
|
|
#include <GUI/SetupRootDialog.hxx>
|
2015-03-08 09:40:44 +00:00
|
|
|
#endif
|
2001-07-19 04:53:13 +00:00
|
|
|
|
2013-11-06 23:49:58 +00:00
|
|
|
#include <Main/locale.hxx>
|
2000-07-07 20:28:51 +00:00
|
|
|
#include "globals.hxx"
|
2001-01-13 22:06:39 +00:00
|
|
|
#include "fg_init.hxx"
|
|
|
|
#include "fg_props.hxx"
|
1999-05-06 22:16:12 +00:00
|
|
|
#include "options.hxx"
|
2003-06-11 14:18:24 +00:00
|
|
|
#include "util.hxx"
|
2012-04-21 07:38:41 +00:00
|
|
|
#include "main.hxx"
|
2012-04-25 21:28:00 +00:00
|
|
|
#include "locale.hxx"
|
|
|
|
#include <Viewer/viewer.hxx>
|
|
|
|
#include <Viewer/viewmgr.hxx>
|
2011-01-19 18:36:04 +00:00
|
|
|
#include <Environment/presets.hxx>
|
2014-03-03 20:59:16 +00:00
|
|
|
#include <Network/http/httpd.hxx>
|
2013-11-16 14:22:34 +00:00
|
|
|
#include "AircraftDirVisitorBase.hxx"
|
2010-11-14 22:55:55 +00:00
|
|
|
|
|
|
|
#include <osg/Version>
|
2015-03-06 18:52:06 +00:00
|
|
|
#include <Include/version.h>
|
|
|
|
#include <simgear/version.h>
|
1998-11-16 13:59:58 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
using std::string;
|
|
|
|
using std::sort;
|
|
|
|
using std::cout;
|
|
|
|
using std::cerr;
|
|
|
|
using std::endl;
|
2011-10-17 16:39:47 +00:00
|
|
|
using std::vector;
|
2011-11-13 21:27:55 +00:00
|
|
|
using std::cin;
|
2011-10-16 17:35:40 +00:00
|
|
|
|
2013-10-15 21:16:50 +00:00
|
|
|
using namespace flightgear;
|
2001-01-13 22:06:39 +00:00
|
|
|
|
2013-10-15 21:16:50 +00:00
|
|
|
#define NEW_DEFAULT_MODEL_HZ 120
|
2001-01-13 22:06:39 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
static flightgear::Options* shared_instance = NULL;
|
|
|
|
|
2001-01-13 22:06:39 +00:00
|
|
|
static double
|
1998-08-27 17:01:55 +00:00
|
|
|
atof( const string& str )
|
|
|
|
{
|
|
|
|
return ::atof( str.c_str() );
|
|
|
|
}
|
|
|
|
|
2001-01-13 22:06:39 +00:00
|
|
|
static int
|
1998-08-27 17:01:55 +00:00
|
|
|
atoi( const string& str )
|
|
|
|
{
|
|
|
|
return ::atoi( str.c_str() );
|
|
|
|
}
|
1998-04-24 00:49:17 +00:00
|
|
|
|
2011-02-20 10:42:21 +00:00
|
|
|
static int fgSetupProxy( const char *arg );
|
|
|
|
|
2001-01-13 22:06:39 +00:00
|
|
|
/**
|
|
|
|
* Set a few fail-safe default property values.
|
|
|
|
*
|
|
|
|
* These should all be set in $FG_ROOT/preferences.xml, but just
|
2003-03-19 20:45:09 +00:00
|
|
|
* in case, we provide some initial sane values here. This method
|
2001-01-13 22:06:39 +00:00
|
|
|
* should be invoked *before* reading any init files.
|
|
|
|
*/
|
2013-11-16 12:00:00 +00:00
|
|
|
void fgSetDefaults ()
|
1998-08-27 17:01:55 +00:00
|
|
|
{
|
2010-06-27 07:04:10 +00:00
|
|
|
|
2002-05-01 23:13:36 +00:00
|
|
|
// Position (deliberately out of range)
|
|
|
|
fgSetDouble("/position/longitude-deg", 9999.0);
|
|
|
|
fgSetDouble("/position/latitude-deg", 9999.0);
|
2001-07-02 22:27:24 +00:00
|
|
|
fgSetDouble("/position/altitude-ft", -9999.0);
|
2001-01-12 15:37:40 +00:00
|
|
|
|
|
|
|
// Orientation
|
2007-10-04 17:14:37 +00:00
|
|
|
fgSetDouble("/orientation/heading-deg", 9999.0);
|
2007-10-04 21:52:50 +00:00
|
|
|
fgSetDouble("/orientation/roll-deg", 0.0);
|
|
|
|
fgSetDouble("/orientation/pitch-deg", 0.424);
|
2001-01-12 15:37:40 +00:00
|
|
|
|
|
|
|
// Velocities
|
2001-07-02 22:27:24 +00:00
|
|
|
fgSetDouble("/velocities/uBody-fps", 0.0);
|
|
|
|
fgSetDouble("/velocities/vBody-fps", 0.0);
|
|
|
|
fgSetDouble("/velocities/wBody-fps", 0.0);
|
|
|
|
fgSetDouble("/velocities/speed-north-fps", 0.0);
|
|
|
|
fgSetDouble("/velocities/speed-east-fps", 0.0);
|
|
|
|
fgSetDouble("/velocities/speed-down-fps", 0.0);
|
|
|
|
fgSetDouble("/velocities/airspeed-kt", 0.0);
|
2001-01-13 22:06:39 +00:00
|
|
|
fgSetDouble("/velocities/mach", 0.0);
|
2001-01-12 15:37:40 +00:00
|
|
|
|
2002-11-15 21:13:29 +00:00
|
|
|
// Presets
|
|
|
|
fgSetDouble("/sim/presets/longitude-deg", 9999.0);
|
|
|
|
fgSetDouble("/sim/presets/latitude-deg", 9999.0);
|
|
|
|
fgSetDouble("/sim/presets/altitude-ft", -9999.0);
|
|
|
|
|
2007-10-04 17:14:37 +00:00
|
|
|
fgSetDouble("/sim/presets/heading-deg", 9999.0);
|
2007-10-04 21:52:50 +00:00
|
|
|
fgSetDouble("/sim/presets/roll-deg", 0.0);
|
|
|
|
fgSetDouble("/sim/presets/pitch-deg", 0.424);
|
2002-11-15 21:13:29 +00:00
|
|
|
|
|
|
|
fgSetString("/sim/presets/speed-set", "knots");
|
|
|
|
fgSetDouble("/sim/presets/airspeed-kt", 0.0);
|
|
|
|
fgSetDouble("/sim/presets/mach", 0.0);
|
|
|
|
fgSetDouble("/sim/presets/uBody-fps", 0.0);
|
|
|
|
fgSetDouble("/sim/presets/vBody-fps", 0.0);
|
|
|
|
fgSetDouble("/sim/presets/wBody-fps", 0.0);
|
|
|
|
fgSetDouble("/sim/presets/speed-north-fps", 0.0);
|
|
|
|
fgSetDouble("/sim/presets/speed-east-fps", 0.0);
|
|
|
|
fgSetDouble("/sim/presets/speed-down-fps", 0.0);
|
|
|
|
|
|
|
|
fgSetBool("/sim/presets/onground", true);
|
|
|
|
fgSetBool("/sim/presets/trim", false);
|
|
|
|
|
2001-01-12 15:37:40 +00:00
|
|
|
// Miscellaneous
|
2001-01-13 22:06:39 +00:00
|
|
|
fgSetBool("/sim/startup/splash-screen", true);
|
2001-02-26 13:58:33 +00:00
|
|
|
// we want mouse-pointer to have an undefined value if nothing is
|
|
|
|
// specified so we can do the right thing for voodoo-1/2 cards.
|
|
|
|
// fgSetString("/sim/startup/mouse-pointer", "disabled");
|
2012-03-13 20:00:22 +00:00
|
|
|
fgSetBool("/controls/flight/auto-coordination", false);
|
2003-11-25 17:10:53 +00:00
|
|
|
fgSetString("/sim/logging/priority", "alert");
|
2003-03-22 10:38:15 +00:00
|
|
|
|
2001-01-12 15:37:40 +00:00
|
|
|
// Features
|
2006-06-10 07:23:15 +00:00
|
|
|
fgSetBool("/sim/hud/color/antialiased", false);
|
2011-01-16 15:31:39 +00:00
|
|
|
fgSetBool("/sim/hud/enable3d[1]", true);
|
|
|
|
fgSetBool("/sim/hud/visibility[1]", false);
|
2001-01-13 22:06:39 +00:00
|
|
|
fgSetBool("/sim/panel/visibility", true);
|
2009-10-05 13:47:03 +00:00
|
|
|
fgSetBool("/sim/sound/enabled", true);
|
2009-11-30 12:05:20 +00:00
|
|
|
fgSetBool("/sim/sound/working", true);
|
2013-05-19 14:29:49 +00:00
|
|
|
fgSetBool("/sim/fgcom/enabled", false);
|
2001-01-12 15:37:40 +00:00
|
|
|
|
|
|
|
// Flight Model options
|
2001-07-24 01:02:59 +00:00
|
|
|
fgSetString("/sim/flight-model", "jsb");
|
2001-12-06 23:10:50 +00:00
|
|
|
fgSetString("/sim/aero", "c172");
|
2001-01-13 22:06:39 +00:00
|
|
|
fgSetInt("/sim/model-hz", NEW_DEFAULT_MODEL_HZ);
|
2012-11-17 19:01:19 +00:00
|
|
|
fgSetDouble("/sim/speed-up", 1.0);
|
2001-01-12 15:37:40 +00:00
|
|
|
|
|
|
|
// Rendering options
|
2001-01-13 22:06:39 +00:00
|
|
|
fgSetString("/sim/rendering/fog", "nicest");
|
|
|
|
fgSetBool("/environment/clouds/status", true);
|
|
|
|
fgSetBool("/sim/startup/fullscreen", false);
|
|
|
|
fgSetBool("/sim/rendering/shading", true);
|
2009-11-30 14:24:16 +00:00
|
|
|
fgTie( "/sim/rendering/filtering", SGGetTextureFilter, SGSetTextureFilter, false);
|
2007-05-28 05:21:45 +00:00
|
|
|
fgSetInt("/sim/rendering/filtering", 1);
|
2001-01-13 22:06:39 +00:00
|
|
|
fgSetBool("/sim/rendering/wireframe", false);
|
2003-06-22 09:45:43 +00:00
|
|
|
fgSetBool("/sim/rendering/horizon-effect", false);
|
|
|
|
fgSetBool("/sim/rendering/enhanced-lighting", false);
|
2002-12-30 21:49:56 +00:00
|
|
|
fgSetBool("/sim/rendering/distance-attenuation", false);
|
2003-09-12 21:43:01 +00:00
|
|
|
fgSetBool("/sim/rendering/specular-highlight", true);
|
2011-09-02 18:26:55 +00:00
|
|
|
fgSetString("/sim/rendering/materials-file", "materials.xml");
|
2013-10-27 13:02:54 +00:00
|
|
|
fgSetInt("/sim/startup/xsize", 1024);
|
|
|
|
fgSetInt("/sim/startup/ysize", 768);
|
|
|
|
fgSetInt("/sim/rendering/bits-per-pixel", 32);
|
2001-01-13 22:06:39 +00:00
|
|
|
fgSetString("/sim/view-mode", "pilot");
|
2002-04-18 16:51:47 +00:00
|
|
|
fgSetDouble("/sim/current-view/heading-offset-deg", 0);
|
2001-01-12 15:37:40 +00:00
|
|
|
|
|
|
|
// HUD options
|
2001-01-13 22:06:39 +00:00
|
|
|
fgSetString("/sim/startup/units", "feet");
|
|
|
|
fgSetString("/sim/hud/frame-stat-type", "tris");
|
2010-06-27 07:04:10 +00:00
|
|
|
|
2001-01-12 15:37:40 +00:00
|
|
|
// Time options
|
2001-01-13 22:06:39 +00:00
|
|
|
fgSetInt("/sim/startup/time-offset", 0);
|
|
|
|
fgSetString("/sim/startup/time-offset-type", "system-offset");
|
2002-02-10 04:27:56 +00:00
|
|
|
fgSetLong("/sim/time/cur-time-override", 0);
|
1998-11-25 01:33:58 +00:00
|
|
|
|
2002-01-20 03:52:36 +00:00
|
|
|
// Freeze options
|
|
|
|
fgSetBool("/sim/freeze/master", false);
|
|
|
|
fgSetBool("/sim/freeze/position", false);
|
2002-02-13 02:37:44 +00:00
|
|
|
fgSetBool("/sim/freeze/clock", false);
|
2002-01-22 15:39:51 +00:00
|
|
|
fgSetBool("/sim/freeze/fuel", false);
|
2003-03-19 20:45:09 +00:00
|
|
|
|
|
|
|
fgSetString("/sim/multiplay/callsign", "callsign");
|
2011-08-24 08:44:52 +00:00
|
|
|
fgSetString("/sim/multiplay/rxhost", "");
|
|
|
|
fgSetString("/sim/multiplay/txhost", "");
|
2003-03-19 20:45:09 +00:00
|
|
|
fgSetInt("/sim/multiplay/rxport", 0);
|
|
|
|
fgSetInt("/sim/multiplay/txport", 0);
|
2010-11-13 18:58:55 +00:00
|
|
|
|
2013-10-20 10:58:20 +00:00
|
|
|
SGPropertyNode* v = globals->get_props()->getNode("/sim/version", true);
|
|
|
|
v->setValueReadOnly("flightgear", FLIGHTGEAR_VERSION);
|
|
|
|
v->setValueReadOnly("simgear", SG_STRINGIZE(SIMGEAR_VERSION));
|
|
|
|
v->setValueReadOnly("openscenegraph", osgGetVersion());
|
|
|
|
v->setValueReadOnly("openscenegraph-thread-safe-reference-counting",
|
|
|
|
osg::Referenced::getThreadSafeReferenceCounting());
|
|
|
|
v->setValueReadOnly("revision", REVISION);
|
|
|
|
v->setValueReadOnly("build-number", HUDSON_BUILD_NUMBER);
|
|
|
|
v->setValueReadOnly("build-id", HUDSON_BUILD_ID);
|
|
|
|
v->setValueReadOnly("hla-support", bool(FG_HAVE_HLA));
|
2015-03-17 22:10:49 +00:00
|
|
|
#if defined(FG_NIGHTLY)
|
|
|
|
v->setValueReadOnly("nightly-build", true);
|
|
|
|
#else
|
|
|
|
v->setValueReadOnly("nightly-build", false);
|
|
|
|
#endif
|
|
|
|
|
2013-10-20 10:58:20 +00:00
|
|
|
char* envp = ::getenv( "http_proxy" );
|
2011-10-16 17:35:40 +00:00
|
|
|
if( envp != NULL )
|
2011-02-20 10:42:21 +00:00
|
|
|
fgSetupProxy( envp );
|
1998-05-13 18:29:56 +00:00
|
|
|
}
|
|
|
|
|
2013-11-16 14:22:34 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
// helper object to implement the --show-aircraft command.
|
|
|
|
// resides here so we can share the fgFindAircraftInDir template above,
|
|
|
|
// and hence ensure this command lists exectly the same aircraft as the normal
|
|
|
|
// loading path.
|
|
|
|
class ShowAircraft : public AircraftDirVistorBase
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
ShowAircraft()
|
|
|
|
{
|
|
|
|
_minStatus = getNumMaturity(fgGetString("/sim/aircraft-min-status", "all"));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-09 14:31:09 +00:00
|
|
|
void show(const vector<SGPath> & path_list)
|
2013-11-16 14:22:34 +00:00
|
|
|
{
|
2015-04-09 14:31:09 +00:00
|
|
|
for (vector<SGPath>::const_iterator p = path_list.begin();
|
|
|
|
p != path_list.end(); ++p)
|
|
|
|
visitDir(*p, 0);
|
2013-11-16 14:22:34 +00:00
|
|
|
|
|
|
|
simgear::requestConsole(); // ensure console is shown on Windows
|
|
|
|
|
|
|
|
std::sort(_aircraft.begin(), _aircraft.end(), ciLessLibC());
|
|
|
|
cout << "Available aircraft:" << endl;
|
|
|
|
for ( unsigned int i = 0; i < _aircraft.size(); i++ ) {
|
|
|
|
cout << _aircraft[i] << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
virtual VisitResult visit(const SGPath& path)
|
|
|
|
{
|
|
|
|
SGPropertyNode root;
|
|
|
|
try {
|
|
|
|
readProperties(path.str(), &root);
|
|
|
|
} catch (sg_exception& ) {
|
|
|
|
return VISIT_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
int maturity = 0;
|
|
|
|
string descStr(" ");
|
|
|
|
descStr += path.file();
|
|
|
|
// trim common suffix from file names
|
|
|
|
int nPos = descStr.rfind("-set.xml");
|
|
|
|
if (nPos == (int)(descStr.size() - 8)) {
|
|
|
|
descStr.resize(nPos);
|
|
|
|
}
|
|
|
|
|
|
|
|
SGPropertyNode *node = root.getNode("sim");
|
|
|
|
if (node) {
|
|
|
|
SGPropertyNode* desc = node->getNode("description");
|
|
|
|
// if a status tag is found, read it in
|
|
|
|
if (node->hasValue("status")) {
|
|
|
|
maturity = getNumMaturity(node->getStringValue("status"));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (desc) {
|
|
|
|
if (descStr.size() <= 27+3) {
|
|
|
|
descStr.append(29+3-descStr.size(), ' ');
|
|
|
|
} else {
|
|
|
|
descStr += '\n';
|
|
|
|
descStr.append( 32, ' ');
|
|
|
|
}
|
|
|
|
descStr += desc->getStringValue();
|
|
|
|
}
|
|
|
|
} // of have 'sim' node
|
|
|
|
|
|
|
|
if (maturity >= _minStatus) {
|
|
|
|
_aircraft.push_back(descStr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return VISIT_CONTINUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int getNumMaturity(const char * str)
|
|
|
|
{
|
|
|
|
// changes should also be reflected in $FG_ROOT/data/options.xml &
|
|
|
|
// $FG_ROOT/data/Translations/string-default.xml
|
|
|
|
const char* levels[] = {"alpha","beta","early-production","production"};
|
|
|
|
|
|
|
|
if (!strcmp(str, "all")) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (size_t i=0; i<(sizeof(levels)/sizeof(levels[0]));i++)
|
|
|
|
if (strcmp(str,levels[i])==0)
|
|
|
|
return i;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// recommended in Meyers, Effective STL when internationalization and embedded
|
|
|
|
// NULLs aren't an issue. Much faster than the STL or Boost lex versions.
|
|
|
|
struct ciLessLibC : public std::binary_function<string, string, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const std::string &lhs, const std::string &rhs) const
|
|
|
|
{
|
|
|
|
return strcasecmp(lhs.c_str(), rhs.c_str()) < 0 ? 1 : 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
int _minStatus;
|
|
|
|
string_list _aircraft;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search in the current directory, and in on directory deeper
|
|
|
|
* for <aircraft>-set.xml configuration files and show the aircaft name
|
|
|
|
* and the contents of the<description> tag in a sorted manner.
|
|
|
|
*
|
|
|
|
* @parampath the directory to search for configuration files
|
|
|
|
*/
|
2015-04-09 14:31:09 +00:00
|
|
|
void fgShowAircraft(const vector<SGPath> &path_list)
|
2013-11-16 14:22:34 +00:00
|
|
|
{
|
|
|
|
ShowAircraft s;
|
2015-04-09 14:31:09 +00:00
|
|
|
s.show(path_list);
|
2013-11-16 14:22:34 +00:00
|
|
|
|
|
|
|
#ifdef _MSC_VER
|
|
|
|
cout << "Hit a key to continue..." << endl;
|
|
|
|
std::cin.get();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-06-09 21:28:17 +00:00
|
|
|
static bool
|
|
|
|
parse_wind (const string &wind, double * min_hdg, double * max_hdg,
|
|
|
|
double * speed, double * gust)
|
|
|
|
{
|
2002-07-02 20:45:02 +00:00
|
|
|
string::size_type pos = wind.find('@');
|
2002-06-09 21:28:17 +00:00
|
|
|
if (pos == string::npos)
|
|
|
|
return false;
|
|
|
|
string dir = wind.substr(0, pos);
|
|
|
|
string spd = wind.substr(pos+1);
|
|
|
|
pos = dir.find(':');
|
|
|
|
if (pos == string::npos) {
|
|
|
|
*min_hdg = *max_hdg = atof(dir.c_str());
|
|
|
|
} else {
|
|
|
|
*min_hdg = atof(dir.substr(0,pos).c_str());
|
|
|
|
*max_hdg = atof(dir.substr(pos+1).c_str());
|
|
|
|
}
|
|
|
|
pos = spd.find(':');
|
|
|
|
if (pos == string::npos) {
|
|
|
|
*speed = *gust = atof(spd.c_str());
|
|
|
|
} else {
|
|
|
|
*speed = atof(spd.substr(0,pos).c_str());
|
|
|
|
*gust = atof(spd.substr(pos+1).c_str());
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-10-30 13:48:53 +00:00
|
|
|
static bool
|
|
|
|
parseIntValue(char** ppParserPos, int* pValue,int min, int max, const char* field, const char* argument)
|
|
|
|
{
|
|
|
|
if ( !strlen(*ppParserPos) )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
char num[256];
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
while ( isdigit((*ppParserPos)[0]) && (i<255) )
|
|
|
|
{
|
|
|
|
num[i] = (*ppParserPos)[0];
|
|
|
|
(*ppParserPos)++;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
num[i] = '\0';
|
|
|
|
|
|
|
|
switch ((*ppParserPos)[0])
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case ':':
|
|
|
|
(*ppParserPos)++;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
SG_LOG(SG_GENERAL, SG_ALERT, "Illegal character in time string for " << field << ": '" <<
|
|
|
|
(*ppParserPos)[0] << "'.");
|
|
|
|
// invalid field - skip rest of string to avoid further errors
|
|
|
|
while ((*ppParserPos)[0])
|
|
|
|
(*ppParserPos)++;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i<=0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
int value = atoi(num);
|
|
|
|
if ((value < min)||(value > max))
|
|
|
|
{
|
|
|
|
SG_LOG(SG_GENERAL, SG_ALERT, "Invalid " << field << " in '" << argument <<
|
|
|
|
"'. Valid range is " << min << "-" << max << ".");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*pValue = value;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-03-17 21:06:43 +00:00
|
|
|
// parse a time string ([+/-]%f[:%f[:%f]]) into hours
|
2001-01-13 22:06:39 +00:00
|
|
|
static double
|
|
|
|
parse_time(const string& time_in) {
|
1998-08-27 17:01:55 +00:00
|
|
|
char *time_str, num[256];
|
1998-04-24 00:49:17 +00:00
|
|
|
double hours, minutes, seconds;
|
|
|
|
double result = 0.0;
|
|
|
|
int sign = 1;
|
|
|
|
int i;
|
|
|
|
|
1998-08-27 17:01:55 +00:00
|
|
|
time_str = (char *)time_in.c_str();
|
|
|
|
|
1998-04-24 00:49:17 +00:00
|
|
|
// printf("parse_time(): %s\n", time_str);
|
|
|
|
|
|
|
|
// check for sign
|
|
|
|
if ( strlen(time_str) ) {
|
|
|
|
if ( time_str[0] == '+' ) {
|
|
|
|
sign = 1;
|
|
|
|
time_str++;
|
|
|
|
} else if ( time_str[0] == '-' ) {
|
|
|
|
sign = -1;
|
|
|
|
time_str++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// printf("sign = %d\n", sign);
|
|
|
|
|
|
|
|
// get hours
|
|
|
|
if ( strlen(time_str) ) {
|
|
|
|
i = 0;
|
|
|
|
while ( (time_str[0] != ':') && (time_str[0] != '\0') ) {
|
|
|
|
num[i] = time_str[0];
|
|
|
|
time_str++;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if ( time_str[0] == ':' ) {
|
|
|
|
time_str++;
|
|
|
|
}
|
|
|
|
num[i] = '\0';
|
|
|
|
hours = atof(num);
|
|
|
|
// printf("hours = %.2lf\n", hours);
|
|
|
|
|
1998-07-30 23:48:24 +00:00
|
|
|
result += hours;
|
1998-04-24 00:49:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// get minutes
|
|
|
|
if ( strlen(time_str) ) {
|
|
|
|
i = 0;
|
|
|
|
while ( (time_str[0] != ':') && (time_str[0] != '\0') ) {
|
|
|
|
num[i] = time_str[0];
|
|
|
|
time_str++;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if ( time_str[0] == ':' ) {
|
|
|
|
time_str++;
|
|
|
|
}
|
|
|
|
num[i] = '\0';
|
|
|
|
minutes = atof(num);
|
|
|
|
// printf("minutes = %.2lf\n", minutes);
|
|
|
|
|
1998-07-30 23:48:24 +00:00
|
|
|
result += minutes / 60.0;
|
1998-04-24 00:49:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// get seconds
|
|
|
|
if ( strlen(time_str) ) {
|
|
|
|
i = 0;
|
|
|
|
while ( (time_str[0] != ':') && (time_str[0] != '\0') ) {
|
|
|
|
num[i] = time_str[0];
|
|
|
|
time_str++;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
num[i] = '\0';
|
|
|
|
seconds = atof(num);
|
|
|
|
// printf("seconds = %.2lf\n", seconds);
|
|
|
|
|
1998-07-30 23:48:24 +00:00
|
|
|
result += seconds / 3600.0;
|
1998-04-24 00:49:17 +00:00
|
|
|
}
|
|
|
|
|
2003-03-20 10:43:02 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_INFO, " parse_time() = " << sign * result );
|
2002-11-16 20:17:11 +00:00
|
|
|
|
1998-04-24 00:49:17 +00:00
|
|
|
return(sign * result);
|
|
|
|
}
|
|
|
|
|
2001-03-17 21:06:43 +00:00
|
|
|
// parse a date string (yyyy:mm:dd:hh:mm:ss) into a time_t (seconds)
|
2010-06-27 07:04:10 +00:00
|
|
|
static long int
|
2011-10-30 13:48:53 +00:00
|
|
|
parse_date( const string& date, const char* timeType)
|
1999-04-11 13:19:29 +00:00
|
|
|
{
|
2011-10-30 13:48:53 +00:00
|
|
|
struct tm gmt,*pCurrentTime;
|
|
|
|
int year,month,day,hour,minute,second;
|
|
|
|
char *argument, *date_str;
|
|
|
|
|
2012-09-23 23:03:23 +00:00
|
|
|
SGTime CurrentTime;
|
|
|
|
CurrentTime.update(SGGeod(),0,0);
|
2011-10-30 13:48:53 +00:00
|
|
|
|
|
|
|
// FIXME This should obtain system/aircraft/GMT time depending on timeType
|
|
|
|
pCurrentTime = CurrentTime.getGmt();
|
|
|
|
|
|
|
|
// initialize all fields with current time
|
|
|
|
year = pCurrentTime->tm_year + 1900;
|
|
|
|
month = pCurrentTime->tm_mon + 1;
|
|
|
|
day = pCurrentTime->tm_mday;
|
|
|
|
hour = pCurrentTime->tm_hour;
|
|
|
|
minute = pCurrentTime->tm_min;
|
|
|
|
second = pCurrentTime->tm_sec;
|
|
|
|
|
|
|
|
argument = (char *)date.c_str();
|
|
|
|
date_str = argument;
|
|
|
|
|
|
|
|
// start with parsing year
|
|
|
|
if (!strlen(date_str) ||
|
|
|
|
!parseIntValue(&date_str,&year,0,9999,"year",argument))
|
|
|
|
{
|
|
|
|
return -1;
|
1999-04-11 13:19:29 +00:00
|
|
|
}
|
2011-10-30 13:48:53 +00:00
|
|
|
|
|
|
|
if (year < 1970)
|
|
|
|
{
|
|
|
|
SG_LOG(SG_GENERAL, SG_ALERT, "Invalid year '" << year << "'. Use 1970 or later.");
|
|
|
|
return -1;
|
1999-04-11 13:19:29 +00:00
|
|
|
}
|
2011-10-30 13:48:53 +00:00
|
|
|
|
|
|
|
parseIntValue(&date_str, &month, 1, 12, "month", argument);
|
|
|
|
parseIntValue(&date_str, &day, 1, 31, "day", argument);
|
|
|
|
parseIntValue(&date_str, &hour, 0, 23, "hour", argument);
|
|
|
|
parseIntValue(&date_str, &minute, 0, 59, "minute", argument);
|
|
|
|
parseIntValue(&date_str, &second, 0, 59, "second", argument);
|
|
|
|
|
|
|
|
gmt.tm_sec = second;
|
|
|
|
gmt.tm_min = minute;
|
|
|
|
gmt.tm_hour = hour;
|
|
|
|
gmt.tm_mday = day;
|
|
|
|
gmt.tm_mon = month - 1;
|
|
|
|
gmt.tm_year = year -1900;
|
|
|
|
gmt.tm_isdst = 0; // ignore daylight savings time for the moment
|
|
|
|
|
2000-07-07 23:56:43 +00:00
|
|
|
time_t theTime = sgTimeGetGMT( gmt.tm_year, gmt.tm_mon, gmt.tm_mday,
|
2011-10-30 13:48:53 +00:00
|
|
|
gmt.tm_hour, gmt.tm_min, gmt.tm_sec );
|
|
|
|
|
|
|
|
SG_LOG(SG_GENERAL, SG_INFO, "Configuring startup time to " << ctime(&theTime));
|
|
|
|
|
1999-04-11 13:19:29 +00:00
|
|
|
return (theTime);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-03-17 21:06:43 +00:00
|
|
|
// parse angle in the form of [+/-]ddd:mm:ss into degrees
|
2001-01-13 22:06:39 +00:00
|
|
|
static double
|
|
|
|
parse_degree( const string& degree_str) {
|
1998-08-27 17:01:55 +00:00
|
|
|
double result = parse_time( degree_str );
|
1998-07-30 23:48:24 +00:00
|
|
|
|
|
|
|
// printf("Degree = %.4f\n", result);
|
|
|
|
|
|
|
|
return(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-03-17 21:06:43 +00:00
|
|
|
// parse time offset string into seconds
|
2011-10-30 13:48:53 +00:00
|
|
|
static long int
|
2001-01-13 22:06:39 +00:00
|
|
|
parse_time_offset( const string& time_str) {
|
2011-10-30 13:48:53 +00:00
|
|
|
long int result;
|
1998-04-24 00:49:17 +00:00
|
|
|
|
|
|
|
// printf("time offset = %s\n", time_str);
|
|
|
|
|
1998-04-26 05:01:19 +00:00
|
|
|
#ifdef HAVE_RINT
|
1998-07-30 23:48:24 +00:00
|
|
|
result = (int)rint(parse_time(time_str) * 3600.0);
|
1998-04-26 05:01:19 +00:00
|
|
|
#else
|
1998-07-30 23:48:24 +00:00
|
|
|
result = (int)(parse_time(time_str) * 3600.0);
|
1998-04-26 05:01:19 +00:00
|
|
|
#endif
|
1998-04-24 00:49:17 +00:00
|
|
|
|
1998-07-30 23:48:24 +00:00
|
|
|
// printf("parse_time_offset(): %d\n", result);
|
1998-04-24 00:49:17 +00:00
|
|
|
|
|
|
|
return( result );
|
1998-05-06 03:16:23 +00:00
|
|
|
}
|
|
|
|
|
1998-04-24 00:49:17 +00:00
|
|
|
|
2010-06-27 07:04:10 +00:00
|
|
|
// Parse --fov=x.xx type option
|
2001-01-13 22:06:39 +00:00
|
|
|
static double
|
|
|
|
parse_fov( const string& arg ) {
|
1998-08-27 17:01:55 +00:00
|
|
|
double fov = atof(arg);
|
1998-05-13 18:29:56 +00:00
|
|
|
|
|
|
|
if ( fov < FG_FOV_MIN ) { fov = FG_FOV_MIN; }
|
|
|
|
if ( fov > FG_FOV_MAX ) { fov = FG_FOV_MAX; }
|
|
|
|
|
2007-12-29 21:51:39 +00:00
|
|
|
fgSetDouble("/sim/view[0]/config/default-field-of-view-deg", fov);
|
2000-11-01 23:27:32 +00:00
|
|
|
|
1998-07-30 23:48:24 +00:00
|
|
|
// printf("parse_fov(): result = %.4f\n", fov);
|
1998-05-13 18:29:56 +00:00
|
|
|
|
2000-11-01 23:27:32 +00:00
|
|
|
return fov;
|
1998-05-13 18:29:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-11-19 02:10:24 +00:00
|
|
|
// Parse I/O channel option
|
1998-11-16 13:59:58 +00:00
|
|
|
//
|
1999-11-19 02:10:24 +00:00
|
|
|
// Format is "--protocol=medium,direction,hz,medium_options,..."
|
|
|
|
//
|
2009-01-20 17:30:53 +00:00
|
|
|
// protocol = { native, nmea, garmin, AV400, AV400Sim, fgfs, rul, pve, etc. }
|
1999-11-19 02:10:24 +00:00
|
|
|
// medium = { serial, socket, file, etc. }
|
|
|
|
// direction = { in, out, bi }
|
|
|
|
// hz = number of times to process channel per second (floating
|
|
|
|
// point values are ok.
|
|
|
|
//
|
|
|
|
// Serial example "--nmea=serial,dir,hz,device,baud" where
|
2010-06-27 07:04:10 +00:00
|
|
|
//
|
1999-11-19 02:10:24 +00:00
|
|
|
// device = OS device name of serial line to be open()'ed
|
1998-11-16 13:59:58 +00:00
|
|
|
// baud = {300, 1200, 2400, ..., 230400}
|
1999-11-19 02:10:24 +00:00
|
|
|
//
|
2000-07-14 00:50:56 +00:00
|
|
|
// Socket exacmple "--native=socket,dir,hz,machine,port,style" where
|
2003-03-19 20:45:09 +00:00
|
|
|
//
|
1999-11-20 15:40:15 +00:00
|
|
|
// machine = machine name or ip address if client (leave empty if server)
|
1999-11-19 02:10:24 +00:00
|
|
|
// port = port, leave empty to let system choose
|
2000-07-14 00:50:56 +00:00
|
|
|
// style = tcp or udp
|
1999-11-19 02:10:24 +00:00
|
|
|
//
|
|
|
|
// File example "--garmin=file,dir,hz,filename" where
|
2003-03-19 20:45:09 +00:00
|
|
|
//
|
1999-11-19 02:10:24 +00:00
|
|
|
// filename = file system file name
|
1998-11-25 01:33:58 +00:00
|
|
|
|
2003-03-19 20:45:09 +00:00
|
|
|
static bool
|
2001-08-21 21:13:55 +00:00
|
|
|
add_channel( const string& type, const string& channel_str ) {
|
2010-05-22 20:30:03 +00:00
|
|
|
// This check is neccessary to prevent fgviewer from segfaulting when given
|
|
|
|
// weird options. (It doesn't run the full initailization)
|
|
|
|
if(!globals->get_channel_options_list())
|
|
|
|
{
|
|
|
|
SG_LOG(SG_GENERAL, SG_ALERT, "Option " << type << "=" << channel_str
|
|
|
|
<< " ignored.");
|
|
|
|
return false;
|
|
|
|
}
|
2007-05-05 09:16:59 +00:00
|
|
|
SG_LOG(SG_GENERAL, SG_INFO, "Channel string = " << channel_str );
|
2001-01-26 00:21:36 +00:00
|
|
|
globals->get_channel_options_list()->push_back( type + "," + channel_str );
|
1998-11-16 13:59:58 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2003-02-21 02:46:44 +00:00
|
|
|
static void
|
|
|
|
clearLocation ()
|
|
|
|
{
|
|
|
|
fgSetString("/sim/presets/airport-id", "");
|
|
|
|
fgSetString("/sim/presets/vor-id", "");
|
|
|
|
fgSetString("/sim/presets/ndb-id", "");
|
Mathias Frhlich:
I have introduced the posibility to start directly on the carrier.
With that patch you will have a --carrrier=id argument where id can either be
the pennant number configured in the nimitz scenario or the carriers name
also configured in the carriers scenario.
Additionaly you can use --parkpos=id to select different positions on the
carrier. They are also configured in the scenario file.
That includes the switch of the whole FGInterface class to make use of the
groundcache.
That means that an aircraft no longer uses the current elevation value from
the scenery class. It rather has its own local cache of the aircrafts
environment which is setup in the common_init method of FGInterface and
updated either manually by calling
FGInterface::get_groundlevel_m(lat, lon, alt_m);
or implicitly by calling the above method in the
FGInterface::_updateGeo*Position(lat, lon, alt);
methods.
A call get_groundlevel_m rebuilds the groundcache if the request is outside
the range of the cache.
Note that for the real usage of the groundcache including the correct
information about the movement of objects and the velocity information, you
still need to set up the groundcache in the usual way like YASim and JSBSim
currently does.
If you use the native interface, you will get only static objects correctly.
But for FDM's only using one single ground level for a whole step this is IMO
sufficient.
The AIManager gets a way to return the location of a object which is placed
wrt an AI Object. At the moment it only honours AICarriers for that.
That method is a static one, which loads the scenario file for that reason and
throws it away afterwards. This looked like the aprioriate way, because the
AIManager is initialized much later in flightgears bootstrap, and I did not
find an easy way to reorder that for my needs. Since this additional load is
very small and does only happen if such a relative location is required, I
think that this is ok.
Note that moving on the carrier will only work correctly for JSBSim and YASim,
but you should now be able to start and move on every not itself moving
object with any FDM.
2005-07-03 09:39:14 +00:00
|
|
|
fgSetString("/sim/presets/carrier", "");
|
|
|
|
fgSetString("/sim/presets/parkpos", "");
|
2003-02-21 02:46:44 +00:00
|
|
|
fgSetString("/sim/presets/fix", "");
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptVOR( const char * arg )
|
|
|
|
{
|
|
|
|
clearLocation();
|
|
|
|
fgSetString("/sim/presets/vor-id", arg);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptNDB( const char * arg )
|
|
|
|
{
|
|
|
|
clearLocation();
|
|
|
|
fgSetString("/sim/presets/ndb-id", arg);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
Mathias Frhlich:
I have introduced the posibility to start directly on the carrier.
With that patch you will have a --carrrier=id argument where id can either be
the pennant number configured in the nimitz scenario or the carriers name
also configured in the carriers scenario.
Additionaly you can use --parkpos=id to select different positions on the
carrier. They are also configured in the scenario file.
That includes the switch of the whole FGInterface class to make use of the
groundcache.
That means that an aircraft no longer uses the current elevation value from
the scenery class. It rather has its own local cache of the aircrafts
environment which is setup in the common_init method of FGInterface and
updated either manually by calling
FGInterface::get_groundlevel_m(lat, lon, alt_m);
or implicitly by calling the above method in the
FGInterface::_updateGeo*Position(lat, lon, alt);
methods.
A call get_groundlevel_m rebuilds the groundcache if the request is outside
the range of the cache.
Note that for the real usage of the groundcache including the correct
information about the movement of objects and the velocity information, you
still need to set up the groundcache in the usual way like YASim and JSBSim
currently does.
If you use the native interface, you will get only static objects correctly.
But for FDM's only using one single ground level for a whole step this is IMO
sufficient.
The AIManager gets a way to return the location of a object which is placed
wrt an AI Object. At the moment it only honours AICarriers for that.
That method is a static one, which loads the scenario file for that reason and
throws it away afterwards. This looked like the aprioriate way, because the
AIManager is initialized much later in flightgears bootstrap, and I did not
find an easy way to reorder that for my needs. Since this additional load is
very small and does only happen if such a relative location is required, I
think that this is ok.
Note that moving on the carrier will only work correctly for JSBSim and YASim,
but you should now be able to start and move on every not itself moving
object with any FDM.
2005-07-03 09:39:14 +00:00
|
|
|
static int
|
|
|
|
fgOptCarrier( const char * arg )
|
|
|
|
{
|
|
|
|
clearLocation();
|
|
|
|
fgSetString("/sim/presets/carrier", arg);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptParkpos( const char * arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/presets/parkpos", arg);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2003-02-21 02:46:44 +00:00
|
|
|
static int
|
|
|
|
fgOptFIX( const char * arg )
|
|
|
|
{
|
|
|
|
clearLocation();
|
|
|
|
fgSetString("/sim/presets/fix", arg);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2003-01-19 23:02:51 +00:00
|
|
|
static int
|
|
|
|
fgOptLon( const char *arg )
|
|
|
|
{
|
2003-02-21 02:46:44 +00:00
|
|
|
clearLocation();
|
2003-01-19 23:02:51 +00:00
|
|
|
fgSetDouble("/sim/presets/longitude-deg", parse_degree( arg ));
|
|
|
|
fgSetDouble("/position/longitude-deg", parse_degree( arg ));
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptLat( const char *arg )
|
|
|
|
{
|
2003-02-21 02:46:44 +00:00
|
|
|
clearLocation();
|
2003-01-19 23:02:51 +00:00
|
|
|
fgSetDouble("/sim/presets/latitude-deg", parse_degree( arg ));
|
|
|
|
fgSetDouble("/position/latitude-deg", parse_degree( arg ));
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptAltitude( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetBool("/sim/presets/onground", false);
|
|
|
|
if ( !strcmp(fgGetString("/sim/startup/units"), "feet") )
|
|
|
|
fgSetDouble("/sim/presets/altitude-ft", atof( arg ));
|
|
|
|
else
|
|
|
|
fgSetDouble("/sim/presets/altitude-ft",
|
|
|
|
atof( arg ) * SG_METER_TO_FEET);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptUBody( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/presets/speed-set", "UVW");
|
|
|
|
if ( !strcmp(fgGetString("/sim/startup/units"), "feet") )
|
|
|
|
fgSetDouble("/sim/presets/uBody-fps", atof( arg ));
|
|
|
|
else
|
|
|
|
fgSetDouble("/sim/presets/uBody-fps",
|
|
|
|
atof( arg ) * SG_METER_TO_FEET);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptVBody( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/presets/speed-set", "UVW");
|
|
|
|
if ( !strcmp(fgGetString("/sim/startup/units"), "feet") )
|
|
|
|
fgSetDouble("/sim/presets/vBody-fps", atof( arg ));
|
|
|
|
else
|
|
|
|
fgSetDouble("/sim/presets/vBody-fps",
|
|
|
|
atof( arg ) * SG_METER_TO_FEET);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptWBody( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/presets/speed-set", "UVW");
|
|
|
|
if ( !strcmp(fgGetString("/sim/startup/units"), "feet") )
|
|
|
|
fgSetDouble("/sim/presets/wBody-fps", atof(arg));
|
|
|
|
else
|
|
|
|
fgSetDouble("/sim/presets/wBody-fps",
|
|
|
|
atof(arg) * SG_METER_TO_FEET);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptVNorth( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/presets/speed-set", "NED");
|
|
|
|
if ( !strcmp(fgGetString("/sim/startup/units"), "feet") )
|
|
|
|
fgSetDouble("/sim/presets/speed-north-fps", atof( arg ));
|
|
|
|
else
|
|
|
|
fgSetDouble("/sim/presets/speed-north-fps",
|
|
|
|
atof( arg ) * SG_METER_TO_FEET);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptVEast( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/presets/speed-set", "NED");
|
|
|
|
if ( !strcmp(fgGetString("/sim/startup/units"), "feet") )
|
|
|
|
fgSetDouble("/sim/presets/speed-east-fps", atof(arg));
|
|
|
|
else
|
|
|
|
fgSetDouble("/sim/presets/speed-east-fps",
|
|
|
|
atof(arg) * SG_METER_TO_FEET);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptVDown( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/presets/speed-set", "NED");
|
|
|
|
if ( !strcmp(fgGetString("/sim/startup/units"), "feet") )
|
|
|
|
fgSetDouble("/sim/presets/speed-down-fps", atof(arg));
|
|
|
|
else
|
|
|
|
fgSetDouble("/sim/presets/speed-down-fps",
|
|
|
|
atof(arg) * SG_METER_TO_FEET);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptVc( const char *arg )
|
|
|
|
{
|
|
|
|
// fgSetString("/sim/presets/speed-set", "knots");
|
|
|
|
// fgSetDouble("/velocities/airspeed-kt", atof(arg.substr(5)));
|
|
|
|
fgSetString("/sim/presets/speed-set", "knots");
|
|
|
|
fgSetDouble("/sim/presets/airspeed-kt", atof(arg));
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptMach( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/presets/speed-set", "mach");
|
|
|
|
fgSetDouble("/sim/presets/mach", atof(arg));
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptRoc( const char *arg )
|
|
|
|
{
|
2012-07-08 09:39:50 +00:00
|
|
|
fgSetDouble("/sim/presets/vertical-speed-fps", atof(arg)/60);
|
2003-01-19 23:02:51 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptFgScenery( const char *arg )
|
|
|
|
{
|
2011-10-16 17:35:40 +00:00
|
|
|
globals->append_fg_scenery(arg);
|
2003-01-19 23:02:51 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptFov( const char *arg )
|
|
|
|
{
|
|
|
|
parse_fov( arg );
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptGeometry( const char *arg )
|
|
|
|
{
|
|
|
|
bool geometry_ok = true;
|
|
|
|
int xsize = 0, ysize = 0;
|
|
|
|
string geometry = arg;
|
|
|
|
string::size_type i = geometry.find('x');
|
|
|
|
|
|
|
|
if (i != string::npos) {
|
|
|
|
xsize = atoi(geometry.substr(0, i));
|
|
|
|
ysize = atoi(geometry.substr(i+1));
|
|
|
|
} else {
|
|
|
|
geometry_ok = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( xsize <= 0 || ysize <= 0 ) {
|
|
|
|
xsize = 640;
|
|
|
|
ysize = 480;
|
|
|
|
geometry_ok = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !geometry_ok ) {
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Unknown geometry: " << geometry );
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT,
|
|
|
|
"Setting geometry to " << xsize << 'x' << ysize << '\n');
|
|
|
|
} else {
|
|
|
|
SG_LOG( SG_GENERAL, SG_INFO,
|
|
|
|
"Setting geometry to " << xsize << 'x' << ysize << '\n');
|
|
|
|
fgSetInt("/sim/startup/xsize", xsize);
|
|
|
|
fgSetInt("/sim/startup/ysize", ysize);
|
|
|
|
}
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptBpp( const char *arg )
|
|
|
|
{
|
|
|
|
string bits_per_pix = arg;
|
|
|
|
if ( bits_per_pix == "16" ) {
|
|
|
|
fgSetInt("/sim/rendering/bits-per-pixel", 16);
|
|
|
|
} else if ( bits_per_pix == "24" ) {
|
|
|
|
fgSetInt("/sim/rendering/bits-per-pixel", 24);
|
|
|
|
} else if ( bits_per_pix == "32" ) {
|
|
|
|
fgSetInt("/sim/rendering/bits-per-pixel", 32);
|
|
|
|
} else {
|
|
|
|
SG_LOG(SG_GENERAL, SG_ALERT, "Unsupported bpp " << bits_per_pix);
|
|
|
|
}
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptTimeOffset( const char *arg )
|
|
|
|
{
|
2011-10-30 13:48:53 +00:00
|
|
|
fgSetLong("/sim/startup/time-offset",
|
2003-01-19 23:02:51 +00:00
|
|
|
parse_time_offset( arg ));
|
|
|
|
fgSetString("/sim/startup/time-offset-type", "system-offset");
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptStartDateSys( const char *arg )
|
|
|
|
{
|
2011-10-30 13:48:53 +00:00
|
|
|
long int theTime = parse_date( arg, "system" );
|
|
|
|
if (theTime>=0)
|
|
|
|
{
|
|
|
|
fgSetLong("/sim/startup/time-offset", theTime);
|
|
|
|
fgSetString("/sim/startup/time-offset-type", "system");
|
|
|
|
}
|
2003-01-19 23:02:51 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptStartDateLat( const char *arg )
|
|
|
|
{
|
2011-10-30 13:48:53 +00:00
|
|
|
long int theTime = parse_date( arg, "latitude" );
|
|
|
|
if (theTime>=0)
|
|
|
|
{
|
|
|
|
fgSetLong("/sim/startup/time-offset", theTime);
|
|
|
|
fgSetString("/sim/startup/time-offset-type", "latitude");
|
|
|
|
}
|
2003-01-19 23:02:51 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptStartDateGmt( const char *arg )
|
|
|
|
{
|
2011-10-30 13:48:53 +00:00
|
|
|
long int theTime = parse_date( arg, "gmt" );
|
|
|
|
if (theTime>=0)
|
|
|
|
{
|
|
|
|
fgSetLong("/sim/startup/time-offset", theTime);
|
|
|
|
fgSetString("/sim/startup/time-offset-type", "gmt");
|
|
|
|
}
|
2003-01-19 23:02:51 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2014-10-02 09:33:45 +00:00
|
|
|
static int
|
|
|
|
fgOptJpgHttpd( const char * arg )
|
|
|
|
{
|
|
|
|
SG_LOG(SG_ALL,SG_ALERT,
|
|
|
|
"the option --jpg-httpd is no longer supported! Please use --httpd instead."
|
|
|
|
" URL for the screenshot within the new httpd is http://YourFgServer:xxxx/screenshot");
|
|
|
|
return FG_OPTIONS_EXIT;
|
|
|
|
}
|
|
|
|
|
2014-03-03 20:59:16 +00:00
|
|
|
static int
|
|
|
|
fgOptHttpd( const char * arg )
|
|
|
|
{
|
2014-03-29 21:07:12 +00:00
|
|
|
// port may be any valid address:port notation
|
|
|
|
// like 127.0.0.1:8080
|
|
|
|
// or just the port 8080
|
|
|
|
string port = simgear::strutils::strip(string(arg));
|
|
|
|
if( port.empty() ) return FG_OPTIONS_ERROR;
|
|
|
|
fgSetString( string(flightgear::http::PROPERTY_ROOT).append("/options/listening-port").c_str(), port );
|
2014-03-03 20:59:16 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2004-02-26 12:57:38 +00:00
|
|
|
static int
|
|
|
|
fgSetupProxy( const char *arg )
|
|
|
|
{
|
2011-02-20 16:14:30 +00:00
|
|
|
string options = simgear::strutils::strip( arg );
|
2004-02-26 12:57:38 +00:00
|
|
|
string host, port, auth;
|
2006-12-17 18:32:56 +00:00
|
|
|
string::size_type pos;
|
2004-02-26 12:57:38 +00:00
|
|
|
|
2011-02-20 16:14:30 +00:00
|
|
|
// this is NURLP - NURLP is not an url parser
|
|
|
|
if( simgear::strutils::starts_with( options, "http://" ) )
|
|
|
|
options = options.substr( 7 );
|
|
|
|
if( simgear::strutils::ends_with( options, "/" ) )
|
|
|
|
options = options.substr( 0, options.length() - 1 );
|
|
|
|
|
2004-02-26 12:57:38 +00:00
|
|
|
host = port = auth = "";
|
2010-06-27 07:04:10 +00:00
|
|
|
if ((pos = options.find("@")) != string::npos)
|
2004-02-26 12:57:38 +00:00
|
|
|
auth = options.substr(0, pos++);
|
|
|
|
else
|
|
|
|
pos = 0;
|
|
|
|
|
|
|
|
host = options.substr(pos, options.size());
|
|
|
|
if ((pos = host.find(":")) != string::npos) {
|
|
|
|
port = host.substr(++pos, host.size());
|
|
|
|
host.erase(--pos, host.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
fgSetString("/sim/presets/proxy/host", host.c_str());
|
|
|
|
fgSetString("/sim/presets/proxy/port", port.c_str());
|
|
|
|
fgSetString("/sim/presets/proxy/authentication", auth.c_str());
|
|
|
|
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2003-01-19 23:02:51 +00:00
|
|
|
static int
|
|
|
|
fgOptTraceRead( const char *arg )
|
|
|
|
{
|
|
|
|
string name = arg;
|
|
|
|
SG_LOG(SG_GENERAL, SG_INFO, "Tracing reads for property " << name);
|
|
|
|
fgGetNode(name.c_str(), true)
|
|
|
|
->setAttribute(SGPropertyNode::TRACE_READ, true);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2003-09-22 09:22:05 +00:00
|
|
|
static int
|
|
|
|
fgOptLogLevel( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/logging/priority", arg);
|
2011-12-11 12:55:56 +00:00
|
|
|
setLoggingPriority(arg);
|
2003-09-22 09:31:36 +00:00
|
|
|
|
2003-09-22 09:22:05 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2011-12-11 12:55:56 +00:00
|
|
|
static int
|
|
|
|
fgOptLogClasses( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/logging/classes", arg);
|
|
|
|
setLoggingClasses (arg);
|
|
|
|
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
2003-09-22 09:22:05 +00:00
|
|
|
|
2003-01-19 23:02:51 +00:00
|
|
|
static int
|
|
|
|
fgOptTraceWrite( const char *arg )
|
|
|
|
{
|
|
|
|
string name = arg;
|
|
|
|
SG_LOG(SG_GENERAL, SG_INFO, "Tracing writes for property " << name);
|
|
|
|
fgGetNode(name.c_str(), true)
|
|
|
|
->setAttribute(SGPropertyNode::TRACE_WRITE, true);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptViewOffset( const char *arg )
|
|
|
|
{
|
|
|
|
// $$$ begin - added VS Renganathan, 14 Oct 2K
|
|
|
|
// for multi-window outside window imagery
|
|
|
|
string woffset = arg;
|
|
|
|
double default_view_offset = 0.0;
|
|
|
|
if ( woffset == "LEFT" ) {
|
|
|
|
default_view_offset = SGD_PI * 0.25;
|
|
|
|
} else if ( woffset == "RIGHT" ) {
|
|
|
|
default_view_offset = SGD_PI * 1.75;
|
|
|
|
} else if ( woffset == "CENTER" ) {
|
|
|
|
default_view_offset = 0.00;
|
|
|
|
} else {
|
|
|
|
default_view_offset = atof( woffset.c_str() ) * SGD_DEGREES_TO_RADIANS;
|
|
|
|
}
|
2010-06-27 07:04:10 +00:00
|
|
|
/* apparently not used (CLO, 11 Jun 2002)
|
2003-01-19 23:02:51 +00:00
|
|
|
FGViewer *pilot_view =
|
|
|
|
(FGViewer *)globals->get_viewmgr()->get_view( 0 ); */
|
|
|
|
// this will work without calls to the viewer...
|
|
|
|
fgSetDouble( "/sim/current-view/heading-offset-deg",
|
|
|
|
default_view_offset * SGD_RADIANS_TO_DEGREES );
|
|
|
|
// $$$ end - added VS Renganathan, 14 Oct 2K
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2003-06-11 14:18:24 +00:00
|
|
|
static int
|
|
|
|
fgOptVisibilityMeters( const char *arg )
|
|
|
|
{
|
2011-01-19 18:36:04 +00:00
|
|
|
Environment::Presets::VisibilitySingleton::instance()->preset( atof( arg ) );
|
2003-06-11 14:18:24 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2003-01-19 23:02:51 +00:00
|
|
|
static int
|
|
|
|
fgOptVisibilityMiles( const char *arg )
|
|
|
|
{
|
2011-01-19 18:36:04 +00:00
|
|
|
Environment::Presets::VisibilitySingleton::instance()->preset( atof( arg ) * 5280.0 * SG_FEET_TO_METER );
|
2003-01-19 23:02:51 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptRandomWind( const char *arg )
|
|
|
|
{
|
|
|
|
double min_hdg = sg_random() * 360.0;
|
|
|
|
double max_hdg = min_hdg + (20 - sqrt(sg_random() * 400));
|
2003-09-24 00:04:28 +00:00
|
|
|
double speed = sg_random() * sg_random() * 40;
|
2003-01-19 23:02:51 +00:00
|
|
|
double gust = speed + (10 - sqrt(sg_random() * 100));
|
2011-01-19 18:36:04 +00:00
|
|
|
Environment::Presets::WindSingleton::instance()->preset(min_hdg, max_hdg, speed, gust);
|
2003-01-19 23:02:51 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptWind( const char *arg )
|
|
|
|
{
|
2009-08-24 16:03:49 +00:00
|
|
|
double min_hdg = 0.0, max_hdg = 0.0, speed = 0.0, gust = 0.0;
|
2003-01-19 23:02:51 +00:00
|
|
|
if (!parse_wind( arg, &min_hdg, &max_hdg, &speed, &gust)) {
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "bad wind value " << arg );
|
|
|
|
return FG_OPTIONS_ERROR;
|
|
|
|
}
|
2011-01-19 18:36:04 +00:00
|
|
|
Environment::Presets::WindSingleton::instance()->preset(min_hdg, max_hdg, speed, gust);
|
2003-01-19 23:02:51 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2003-06-11 14:18:24 +00:00
|
|
|
static int
|
2003-09-01 22:58:19 +00:00
|
|
|
fgOptTurbulence( const char *arg )
|
2003-06-11 14:18:24 +00:00
|
|
|
{
|
2011-01-19 18:36:04 +00:00
|
|
|
Environment::Presets::TurbulenceSingleton::instance()->preset( atof(arg) );
|
2003-06-11 14:18:24 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2003-09-01 22:58:19 +00:00
|
|
|
static int
|
|
|
|
fgOptCeiling( const char *arg )
|
|
|
|
{
|
|
|
|
double elevation, thickness;
|
|
|
|
string spec = arg;
|
|
|
|
string::size_type pos = spec.find(':');
|
|
|
|
if (pos == string::npos) {
|
|
|
|
elevation = atof(spec.c_str());
|
|
|
|
thickness = 2000;
|
|
|
|
} else {
|
|
|
|
elevation = atof(spec.substr(0, pos).c_str());
|
|
|
|
thickness = atof(spec.substr(pos + 1).c_str());
|
|
|
|
}
|
2011-01-19 18:36:04 +00:00
|
|
|
Environment::Presets::CeilingSingleton::instance()->preset( elevation, thickness );
|
2003-09-01 22:58:19 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2003-01-19 23:02:51 +00:00
|
|
|
static int
|
|
|
|
fgOptWp( const char *arg )
|
|
|
|
{
|
2011-05-25 07:21:45 +00:00
|
|
|
string_list *waypoints = globals->get_initial_waypoints();
|
|
|
|
if (!waypoints) {
|
|
|
|
waypoints = new string_list;
|
|
|
|
globals->set_initial_waypoints(waypoints);
|
|
|
|
}
|
|
|
|
waypoints->push_back(arg);
|
2003-01-19 23:02:51 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptConfig( const char *arg )
|
|
|
|
{
|
|
|
|
string file = arg;
|
|
|
|
try {
|
2013-10-15 21:16:50 +00:00
|
|
|
readProperties(file, globals->get_props());
|
2003-01-19 23:02:51 +00:00
|
|
|
} catch (const sg_exception &e) {
|
2013-10-15 21:16:50 +00:00
|
|
|
string message = "Error loading config file: ";
|
|
|
|
message += e.getFormattedMessage() + e.getOrigin();
|
|
|
|
SG_LOG(SG_INPUT, SG_ALERT, message);
|
|
|
|
return FG_OPTIONS_ERROR;
|
2003-01-19 23:02:51 +00:00
|
|
|
}
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2003-07-16 23:34:07 +00:00
|
|
|
static bool
|
|
|
|
parse_colon (const string &s, double * val1, double * val2)
|
|
|
|
{
|
|
|
|
string::size_type pos = s.find(':');
|
|
|
|
if (pos == string::npos) {
|
|
|
|
*val2 = atof(s);
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
*val1 = atof(s.substr(0, pos).c_str());
|
|
|
|
*val2 = atof(s.substr(pos+1).c_str());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-09-10 01:29:19 +00:00
|
|
|
static int
|
|
|
|
fgOptFailure( const char * arg )
|
|
|
|
{
|
|
|
|
string a = arg;
|
|
|
|
if (a == "pitot") {
|
|
|
|
fgSetBool("/systems/pitot/serviceable", false);
|
|
|
|
} else if (a == "static") {
|
|
|
|
fgSetBool("/systems/static/serviceable", false);
|
|
|
|
} else if (a == "vacuum") {
|
|
|
|
fgSetBool("/systems/vacuum/serviceable", false);
|
|
|
|
} else if (a == "electrical") {
|
|
|
|
fgSetBool("/systems/electrical/serviceable", false);
|
|
|
|
} else {
|
|
|
|
SG_LOG(SG_INPUT, SG_ALERT, "Unknown failure mode: " << a);
|
|
|
|
return FG_OPTIONS_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-16 23:34:07 +00:00
|
|
|
static int
|
|
|
|
fgOptNAV1( const char * arg )
|
|
|
|
{
|
|
|
|
double radial, freq;
|
|
|
|
if (parse_colon(arg, &radial, &freq))
|
2004-12-04 21:06:57 +00:00
|
|
|
fgSetDouble("/instrumentation/nav[0]/radials/selected-deg", radial);
|
|
|
|
fgSetDouble("/instrumentation/nav[0]/frequencies/selected-mhz", freq);
|
2003-07-16 23:34:07 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptNAV2( const char * arg )
|
|
|
|
{
|
|
|
|
double radial, freq;
|
|
|
|
if (parse_colon(arg, &radial, &freq))
|
2004-12-04 21:06:57 +00:00
|
|
|
fgSetDouble("/instrumentation/nav[1]/radials/selected-deg", radial);
|
|
|
|
fgSetDouble("/instrumentation/nav[1]/frequencies/selected-mhz", freq);
|
2003-07-16 23:34:07 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2011-04-17 15:35:31 +00:00
|
|
|
fgOptADF1( const char * arg )
|
2003-07-16 23:34:07 +00:00
|
|
|
{
|
|
|
|
double rot, freq;
|
|
|
|
if (parse_colon(arg, &rot, &freq))
|
2011-04-17 15:35:31 +00:00
|
|
|
fgSetDouble("/instrumentation/adf[0]/rotation-deg", rot);
|
|
|
|
fgSetDouble("/instrumentation/adf[0]/frequencies/selected-khz", freq);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptADF2( const char * arg )
|
|
|
|
{
|
|
|
|
double rot, freq;
|
|
|
|
if (parse_colon(arg, &rot, &freq))
|
|
|
|
fgSetDouble("/instrumentation/adf[1]/rotation-deg", rot);
|
|
|
|
fgSetDouble("/instrumentation/adf[1]/frequencies/selected-khz", freq);
|
2003-07-16 23:34:07 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptDME( const char *arg )
|
|
|
|
{
|
|
|
|
string opt = arg;
|
|
|
|
if (opt == "nav1") {
|
|
|
|
fgSetInt("/instrumentation/dme/switch-position", 1);
|
|
|
|
fgSetString("/instrumentation/dme/frequencies/source",
|
2004-12-04 21:06:57 +00:00
|
|
|
"/instrumentation/nav[0]/frequencies/selected-mhz");
|
2003-07-16 23:34:07 +00:00
|
|
|
} else if (opt == "nav2") {
|
|
|
|
fgSetInt("/instrumentation/dme/switch-position", 3);
|
|
|
|
fgSetString("/instrumentation/dme/frequencies/source",
|
2004-12-04 21:06:57 +00:00
|
|
|
"/instrumentation/nav[1]/frequencies/selected-mhz");
|
2003-07-16 23:34:07 +00:00
|
|
|
} else {
|
2011-07-10 10:52:45 +00:00
|
|
|
double frequency = atof(arg);
|
|
|
|
if (frequency==0.0)
|
|
|
|
{
|
|
|
|
SG_LOG(SG_INPUT, SG_ALERT, "Invalid DME frequency: '" << arg << "'.");
|
|
|
|
return FG_OPTIONS_ERROR;
|
|
|
|
}
|
2003-07-16 23:34:07 +00:00
|
|
|
fgSetInt("/instrumentation/dme/switch-position", 2);
|
|
|
|
fgSetString("/instrumentation/dme/frequencies/source",
|
|
|
|
"/instrumentation/dme/frequencies/selected-mhz");
|
2011-07-10 10:52:45 +00:00
|
|
|
fgSetDouble("/instrumentation/dme/frequencies/selected-mhz", frequency);
|
2003-07-16 23:34:07 +00:00
|
|
|
}
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2005-10-08 11:55:18 +00:00
|
|
|
static int
|
|
|
|
fgOptLivery( const char *arg )
|
|
|
|
{
|
|
|
|
string opt = arg;
|
|
|
|
string livery_path = "livery/" + opt;
|
|
|
|
fgSetString("/sim/model/texture-path", livery_path.c_str() );
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2006-05-20 12:19:33 +00:00
|
|
|
static int
|
|
|
|
fgOptScenario( const char *arg )
|
|
|
|
{
|
2006-05-20 13:29:31 +00:00
|
|
|
SGPropertyNode_ptr ai_node = fgGetNode( "/sim/ai", true );
|
2006-05-20 12:19:33 +00:00
|
|
|
vector<SGPropertyNode_ptr> scenarii = ai_node->getChildren( "scenario" );
|
|
|
|
int index = -1;
|
|
|
|
for ( size_t i = 0; i < scenarii.size(); ++i ) {
|
|
|
|
int ind = scenarii[i]->getIndex();
|
|
|
|
if ( index < ind ) {
|
|
|
|
index = ind;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SGPropertyNode_ptr scenario = ai_node->getNode( "scenario", index + 1, true );
|
|
|
|
scenario->setStringValue( arg );
|
2011-06-26 14:08:19 +00:00
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2006-05-31 07:20:10 +00:00
|
|
|
static int
|
|
|
|
fgOptRunway( const char *arg )
|
|
|
|
{
|
|
|
|
fgSetString("/sim/presets/runway", arg );
|
|
|
|
fgSetBool("/sim/presets/runway-requested", true );
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2008-02-04 20:03:52 +00:00
|
|
|
static int
|
|
|
|
fgOptParking( const char *arg )
|
|
|
|
{
|
|
|
|
cerr << "Processing argument " << arg << endl;
|
|
|
|
fgSetString("/sim/presets/parking", arg );
|
|
|
|
fgSetBool ("/sim/presets/parking-requested", true );
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2008-03-15 12:10:44 +00:00
|
|
|
static int
|
|
|
|
fgOptVersion( const char *arg )
|
|
|
|
{
|
2010-11-13 18:58:55 +00:00
|
|
|
cerr << "FlightGear version: " << FLIGHTGEAR_VERSION << endl;
|
|
|
|
cerr << "Revision: " << REVISION << endl;
|
|
|
|
cerr << "Build-Id: " << HUDSON_BUILD_ID << endl;
|
2008-03-15 12:10:44 +00:00
|
|
|
cerr << "FG_ROOT=" << globals->get_fg_root() << endl;
|
2012-08-23 20:52:30 +00:00
|
|
|
cerr << "FG_HOME=" << globals->get_fg_home() << endl;
|
2009-12-14 09:18:01 +00:00
|
|
|
cerr << "FG_SCENERY=";
|
|
|
|
|
|
|
|
int didsome = 0;
|
|
|
|
string_list scn = globals->get_fg_scenery();
|
|
|
|
for (string_list::const_iterator it = scn.begin(); it != scn.end(); it++)
|
|
|
|
{
|
|
|
|
if (didsome) cerr << ":";
|
|
|
|
didsome++;
|
|
|
|
cerr << *it;
|
|
|
|
}
|
|
|
|
cerr << endl;
|
2009-12-14 19:51:05 +00:00
|
|
|
cerr << "SimGear version: " << SG_STRINGIZE(SIMGEAR_VERSION) << endl;
|
2009-12-14 09:18:01 +00:00
|
|
|
cerr << "PLIB version: " << PLIB_VERSION << endl;
|
2008-03-15 12:10:44 +00:00
|
|
|
return FG_OPTIONS_EXIT;
|
|
|
|
}
|
2008-02-04 20:03:52 +00:00
|
|
|
|
2010-12-09 15:57:12 +00:00
|
|
|
static int
|
|
|
|
fgOptCallSign(const char * arg)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char callsign[11];
|
|
|
|
strncpy(callsign,arg,10);
|
|
|
|
callsign[10]=0;
|
|
|
|
for (i=0;callsign[i];i++)
|
|
|
|
{
|
2010-12-10 07:28:05 +00:00
|
|
|
char c = callsign[i];
|
|
|
|
if (c >= 'A' && c <= 'Z') continue;
|
|
|
|
if (c >= 'a' && c <= 'z') continue;
|
|
|
|
if (c >= '0' && c <= '9') continue;
|
|
|
|
if (c == '-' || c == '_') continue;
|
|
|
|
// convert any other illegal characters
|
|
|
|
callsign[i]='-';
|
2010-12-09 15:57:12 +00:00
|
|
|
}
|
|
|
|
fgSetString("sim/multiplay/callsign", callsign );
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
2009-08-10 21:43:55 +00:00
|
|
|
|
2013-10-26 17:29:23 +00:00
|
|
|
static int
|
|
|
|
fgOptIgnoreAutosave(const char* arg)
|
|
|
|
{
|
|
|
|
fgSetBool("/sim/startup/ignore-autosave", true);
|
|
|
|
// don't overwrite autosave on exit
|
|
|
|
fgSetBool("/sim/startup/save-on-exit", false);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
2009-08-10 21:43:55 +00:00
|
|
|
|
2015-11-13 22:01:16 +00:00
|
|
|
static int
|
|
|
|
fgOptEnableFreeze(const char* arg)
|
|
|
|
{
|
|
|
|
fgSetBool("/sim/freeze/master", true);
|
|
|
|
fgSetBool("/sim/freeze/clock", true);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fgOptDisableFreeze(const char* arg)
|
|
|
|
{
|
|
|
|
fgSetBool("/sim/freeze/master", false);
|
|
|
|
fgSetBool("/sim/freeze/clock", false);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
// Set a property for the --prop: option. Syntax: --prop:[<type>:]<name>=<value>
|
|
|
|
// <type> can be "double" etc. but also only the first letter "d".
|
|
|
|
// Examples: --prop:alpha=1 --prop:bool:beta=true --prop:d:gamma=0.123
|
|
|
|
static int
|
|
|
|
fgOptSetProperty(const char* raw)
|
|
|
|
{
|
|
|
|
string arg(raw);
|
|
|
|
string::size_type pos = arg.find('=');
|
|
|
|
if (pos == arg.npos || pos == 0 || pos + 1 == arg.size())
|
|
|
|
return FG_OPTIONS_ERROR;
|
|
|
|
|
|
|
|
string name = arg.substr(0, pos);
|
|
|
|
string value = arg.substr(pos + 1);
|
|
|
|
string type;
|
|
|
|
pos = name.find(':');
|
|
|
|
|
|
|
|
if (pos != name.npos && pos != 0 && pos + 1 != name.size()) {
|
|
|
|
type = name.substr(0, pos);
|
|
|
|
name = name.substr(pos + 1);
|
|
|
|
}
|
|
|
|
SGPropertyNode *n = fgGetNode(name.c_str(), true);
|
|
|
|
|
|
|
|
bool writable = n->getAttribute(SGPropertyNode::WRITE);
|
|
|
|
if (!writable)
|
|
|
|
n->setAttribute(SGPropertyNode::WRITE, true);
|
|
|
|
|
|
|
|
bool ret = false;
|
|
|
|
if (type.empty())
|
|
|
|
ret = n->setUnspecifiedValue(value.c_str());
|
|
|
|
else if (type == "s" || type == "string")
|
|
|
|
ret = n->setStringValue(value.c_str());
|
|
|
|
else if (type == "d" || type == "double")
|
|
|
|
ret = n->setDoubleValue(strtod(value.c_str(), 0));
|
|
|
|
else if (type == "f" || type == "float")
|
|
|
|
ret = n->setFloatValue(atof(value.c_str()));
|
|
|
|
else if (type == "l" || type == "long")
|
|
|
|
ret = n->setLongValue(strtol(value.c_str(), 0, 0));
|
|
|
|
else if (type == "i" || type == "int")
|
|
|
|
ret = n->setIntValue(atoi(value.c_str()));
|
|
|
|
else if (type == "b" || type == "bool")
|
|
|
|
ret = n->setBoolValue(value == "true" || atoi(value.c_str()) != 0);
|
|
|
|
|
|
|
|
if (!writable)
|
|
|
|
n->setAttribute(SGPropertyNode::WRITE, false);
|
|
|
|
return ret ? FG_OPTIONS_OK : FG_OPTIONS_ERROR;
|
|
|
|
}
|
|
|
|
|
2014-09-17 20:38:40 +00:00
|
|
|
static int
|
|
|
|
fgOptLoadTape(const char* arg)
|
|
|
|
{
|
|
|
|
// load a flight recorder tape but wait until the fdm is initialized
|
|
|
|
class DelayedTapeLoader : SGPropertyChangeListener {
|
|
|
|
public:
|
|
|
|
DelayedTapeLoader( const char * tape ) :
|
|
|
|
_tape(tape)
|
|
|
|
{
|
|
|
|
SGPropertyNode_ptr n = fgGetNode("/sim/signals/fdm-initialized", true);
|
|
|
|
n->addChangeListener( this );
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~ DelayedTapeLoader() {}
|
|
|
|
|
2015-11-13 22:01:16 +00:00
|
|
|
virtual void valueChanged(SGPropertyNode * node)
|
2014-09-17 20:38:40 +00:00
|
|
|
{
|
|
|
|
node->removeChangeListener( this );
|
|
|
|
|
|
|
|
// tell the replay subsystem to load the tape
|
|
|
|
FGReplay* replay = (FGReplay*) globals->get_subsystem("replay");
|
|
|
|
SGPropertyNode_ptr arg = new SGPropertyNode();
|
|
|
|
arg->setStringValue("tape", _tape );
|
|
|
|
arg->setBoolValue( "same-aircraft", 0 );
|
|
|
|
replay->loadTape(arg);
|
|
|
|
|
|
|
|
delete this; // commence suicide
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
std::string _tape;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
new DelayedTapeLoader(arg);
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
|
2003-01-19 23:02:51 +00:00
|
|
|
|
2003-03-22 14:52:15 +00:00
|
|
|
/*
|
|
|
|
option has_param type property b_param s_param func
|
|
|
|
|
|
|
|
where:
|
|
|
|
option : name of the option
|
|
|
|
has_param : option is --name=value if true or --name if false
|
|
|
|
type : OPTION_BOOL - property is a boolean
|
|
|
|
OPTION_STRING - property is a string
|
|
|
|
OPTION_DOUBLE - property is a double
|
|
|
|
OPTION_INT - property is an integer
|
|
|
|
OPTION_CHANNEL - name of option is the name of a channel
|
|
|
|
OPTION_FUNC - the option trigger a function
|
|
|
|
b_param : if type==OPTION_BOOL,
|
|
|
|
value set to the property (has_param is false for boolean)
|
|
|
|
s_param : if type==OPTION_STRING,
|
|
|
|
value set to the property if has_param is false
|
|
|
|
func : function called if type==OPTION_FUNC. if has_param is true,
|
|
|
|
the value is passed to the function as a string, otherwise,
|
2008-12-18 13:08:44 +00:00
|
|
|
s_param is passed.
|
2003-03-22 14:52:15 +00:00
|
|
|
|
|
|
|
For OPTION_DOUBLE and OPTION_INT, the parameter value is converted into a
|
|
|
|
double or an integer and set to the property.
|
|
|
|
|
|
|
|
For OPTION_CHANNEL, add_channel is called with the parameter value as the
|
|
|
|
argument.
|
|
|
|
*/
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
enum OptionType { OPTION_BOOL = 0, OPTION_STRING, OPTION_DOUBLE, OPTION_INT, OPTION_CHANNEL, OPTION_FUNC, OPTION_IGNORE };
|
|
|
|
const int OPTION_MULTI = 1 << 17;
|
|
|
|
|
2003-01-19 23:02:51 +00:00
|
|
|
struct OptionDesc {
|
2008-08-01 15:57:29 +00:00
|
|
|
const char *option;
|
2003-01-19 23:02:51 +00:00
|
|
|
bool has_param;
|
2011-10-16 17:35:40 +00:00
|
|
|
int type;
|
2008-08-01 15:57:29 +00:00
|
|
|
const char *property;
|
2003-01-19 23:02:51 +00:00
|
|
|
bool b_param;
|
2008-08-01 15:57:29 +00:00
|
|
|
const char *s_param;
|
2003-01-19 23:02:51 +00:00
|
|
|
int (*func)( const char * );
|
|
|
|
} fgOptionArray[] = {
|
2010-06-27 07:04:10 +00:00
|
|
|
|
2012-04-18 11:46:26 +00:00
|
|
|
{"language", true, OPTION_IGNORE, "", false, "", 0 },
|
2013-10-26 20:06:03 +00:00
|
|
|
{"console", false, OPTION_IGNORE, "", false, "", 0 },
|
2014-12-26 12:20:51 +00:00
|
|
|
{"launcher", false, OPTION_IGNORE, "", false, "", 0 },
|
2012-05-08 15:14:55 +00:00
|
|
|
{"disable-rembrandt", false, OPTION_BOOL, "/sim/rendering/rembrandt/enabled", false, "", 0 },
|
|
|
|
{"enable-rembrandt", false, OPTION_BOOL, "/sim/rendering/rembrandt/enabled", true, "", 0 },
|
|
|
|
{"renderer", true, OPTION_STRING, "/sim/rendering/rembrandt/renderer", false, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"disable-splash-screen", false, OPTION_BOOL, "/sim/startup/splash-screen", false, "", 0 },
|
|
|
|
{"enable-splash-screen", false, OPTION_BOOL, "/sim/startup/splash-screen", true, "", 0 },
|
|
|
|
{"disable-mouse-pointer", false, OPTION_STRING, "/sim/startup/mouse-pointer", false, "disabled", 0 },
|
|
|
|
{"enable-mouse-pointer", false, OPTION_STRING, "/sim/startup/mouse-pointer", false, "enabled", 0 },
|
|
|
|
{"disable-random-objects", false, OPTION_BOOL, "/sim/rendering/random-objects", false, "", 0 },
|
|
|
|
{"enable-random-objects", false, OPTION_BOOL, "/sim/rendering/random-objects", true, "", 0 },
|
2012-07-15 08:56:59 +00:00
|
|
|
{"disable-random-vegetation", false, OPTION_BOOL, "/sim/rendering/random-vegetation", false, "", 0 },
|
|
|
|
{"enable-random-vegetation", false, OPTION_BOOL, "/sim/rendering/random-vegetation", true, "", 0 },
|
|
|
|
{"disable-random-buildings", false, OPTION_BOOL, "/sim/rendering/random-buildings", false, "", 0 },
|
|
|
|
{"enable-random-buildings", false, OPTION_BOOL, "/sim/rendering/random-buildings", true, "", 0 },
|
2010-09-11 14:11:35 +00:00
|
|
|
{"disable-real-weather-fetch", false, OPTION_BOOL, "/environment/realwx/enabled", false, "", 0 },
|
|
|
|
{"enable-real-weather-fetch", false, OPTION_BOOL, "/environment/realwx/enabled", true, "", 0 },
|
2009-05-29 10:26:35 +00:00
|
|
|
{"metar", true, OPTION_STRING, "/environment/metar/data", false, "", 0 },
|
2004-05-19 13:55:49 +00:00
|
|
|
{"disable-ai-models", false, OPTION_BOOL, "/sim/ai/enabled", false, "", 0 },
|
|
|
|
{"enable-ai-models", false, OPTION_BOOL, "/sim/ai/enabled", true, "", 0 },
|
2011-01-08 20:38:26 +00:00
|
|
|
{"disable-ai-traffic", false, OPTION_BOOL, "/sim/traffic-manager/enabled", false, "", 0 },
|
|
|
|
{"enable-ai-traffic", false, OPTION_BOOL, "/sim/traffic-manager/enabled", true, "", 0 },
|
2015-11-13 22:01:16 +00:00
|
|
|
{"disable-freeze", false, OPTION_FUNC, "", false, "", fgOptDisableFreeze },
|
|
|
|
{"enable-freeze", false, OPTION_FUNC, "", true, "", fgOptEnableFreeze },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"disable-fuel-freeze", false, OPTION_BOOL, "/sim/freeze/fuel", false, "", 0 },
|
|
|
|
{"enable-fuel-freeze", false, OPTION_BOOL, "/sim/freeze/fuel", true, "", 0 },
|
|
|
|
{"disable-clock-freeze", false, OPTION_BOOL, "/sim/freeze/clock", false, "", 0 },
|
|
|
|
{"enable-clock-freeze", false, OPTION_BOOL, "/sim/freeze/clock", true, "", 0 },
|
2011-01-16 15:31:39 +00:00
|
|
|
{"disable-hud-3d", false, OPTION_BOOL, "/sim/hud/enable3d[1]", false, "", 0 },
|
|
|
|
{"enable-hud-3d", false, OPTION_BOOL, "/sim/hud/enable3d[1]", true, "", 0 },
|
2006-06-10 07:23:15 +00:00
|
|
|
{"disable-anti-alias-hud", false, OPTION_BOOL, "/sim/hud/color/antialiased", false, "", 0 },
|
|
|
|
{"enable-anti-alias-hud", false, OPTION_BOOL, "/sim/hud/color/antialiased", true, "", 0 },
|
2012-03-13 20:00:22 +00:00
|
|
|
{"disable-auto-coordination", false, OPTION_BOOL, "/controls/flight/auto-coordination", false, "", 0 },
|
|
|
|
{"enable-auto-coordination", false, OPTION_BOOL, "/controls/flight/auto-coordination", true, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"browser-app", true, OPTION_STRING, "/sim/startup/browser-app", false, "", 0 },
|
2011-01-16 15:31:39 +00:00
|
|
|
{"disable-hud", false, OPTION_BOOL, "/sim/hud/visibility[1]", false, "", 0 },
|
|
|
|
{"enable-hud", false, OPTION_BOOL, "/sim/hud/visibility[1]", true, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"disable-panel", false, OPTION_BOOL, "/sim/panel/visibility", false, "", 0 },
|
|
|
|
{"enable-panel", false, OPTION_BOOL, "/sim/panel/visibility", true, "", 0 },
|
2009-11-30 12:05:20 +00:00
|
|
|
{"disable-sound", false, OPTION_BOOL, "/sim/sound/working", false, "", 0 },
|
|
|
|
{"enable-sound", false, OPTION_BOOL, "/sim/sound/working", true, "", 0 },
|
2009-11-28 10:42:52 +00:00
|
|
|
{"sound-device", true, OPTION_STRING, "/sim/sound/device-name", false, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"airport", true, OPTION_STRING, "/sim/presets/airport-id", false, "", 0 },
|
2006-05-31 07:20:10 +00:00
|
|
|
{"runway", true, OPTION_FUNC, "", false, "", fgOptRunway },
|
2003-02-21 02:46:44 +00:00
|
|
|
{"vor", true, OPTION_FUNC, "", false, "", fgOptVOR },
|
2011-07-18 09:09:43 +00:00
|
|
|
{"vor-frequency", true, OPTION_DOUBLE, "/sim/presets/vor-freq", false, "", fgOptVOR },
|
2003-02-21 02:46:44 +00:00
|
|
|
{"ndb", true, OPTION_FUNC, "", false, "", fgOptNDB },
|
2011-07-18 09:09:43 +00:00
|
|
|
{"ndb-frequency", true, OPTION_DOUBLE, "/sim/presets/ndb-freq", false, "", fgOptVOR },
|
Mathias Frhlich:
I have introduced the posibility to start directly on the carrier.
With that patch you will have a --carrrier=id argument where id can either be
the pennant number configured in the nimitz scenario or the carriers name
also configured in the carriers scenario.
Additionaly you can use --parkpos=id to select different positions on the
carrier. They are also configured in the scenario file.
That includes the switch of the whole FGInterface class to make use of the
groundcache.
That means that an aircraft no longer uses the current elevation value from
the scenery class. It rather has its own local cache of the aircrafts
environment which is setup in the common_init method of FGInterface and
updated either manually by calling
FGInterface::get_groundlevel_m(lat, lon, alt_m);
or implicitly by calling the above method in the
FGInterface::_updateGeo*Position(lat, lon, alt);
methods.
A call get_groundlevel_m rebuilds the groundcache if the request is outside
the range of the cache.
Note that for the real usage of the groundcache including the correct
information about the movement of objects and the velocity information, you
still need to set up the groundcache in the usual way like YASim and JSBSim
currently does.
If you use the native interface, you will get only static objects correctly.
But for FDM's only using one single ground level for a whole step this is IMO
sufficient.
The AIManager gets a way to return the location of a object which is placed
wrt an AI Object. At the moment it only honours AICarriers for that.
That method is a static one, which loads the scenario file for that reason and
throws it away afterwards. This looked like the aprioriate way, because the
AIManager is initialized much later in flightgears bootstrap, and I did not
find an easy way to reorder that for my needs. Since this additional load is
very small and does only happen if such a relative location is required, I
think that this is ok.
Note that moving on the carrier will only work correctly for JSBSim and YASim,
but you should now be able to start and move on every not itself moving
object with any FDM.
2005-07-03 09:39:14 +00:00
|
|
|
{"carrier", true, OPTION_FUNC, "", false, "", fgOptCarrier },
|
|
|
|
{"parkpos", true, OPTION_FUNC, "", false, "", fgOptParkpos },
|
2003-02-21 02:46:44 +00:00
|
|
|
{"fix", true, OPTION_FUNC, "", false, "", fgOptFIX },
|
2008-05-01 21:14:02 +00:00
|
|
|
{"offset-distance", true, OPTION_DOUBLE, "/sim/presets/offset-distance-nm", false, "", 0 },
|
|
|
|
{"offset-azimuth", true, OPTION_DOUBLE, "/sim/presets/offset-azimuth-deg", false, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"lon", true, OPTION_FUNC, "", false, "", fgOptLon },
|
|
|
|
{"lat", true, OPTION_FUNC, "", false, "", fgOptLat },
|
|
|
|
{"altitude", true, OPTION_FUNC, "", false, "", fgOptAltitude },
|
|
|
|
{"uBody", true, OPTION_FUNC, "", false, "", fgOptUBody },
|
|
|
|
{"vBody", true, OPTION_FUNC, "", false, "", fgOptVBody },
|
|
|
|
{"wBody", true, OPTION_FUNC, "", false, "", fgOptWBody },
|
|
|
|
{"vNorth", true, OPTION_FUNC, "", false, "", fgOptVNorth },
|
|
|
|
{"vEast", true, OPTION_FUNC, "", false, "", fgOptVEast },
|
|
|
|
{"vDown", true, OPTION_FUNC, "", false, "", fgOptVDown },
|
|
|
|
{"vc", true, OPTION_FUNC, "", false, "", fgOptVc },
|
|
|
|
{"mach", true, OPTION_FUNC, "", false, "", fgOptMach },
|
|
|
|
{"heading", true, OPTION_DOUBLE, "/sim/presets/heading-deg", false, "", 0 },
|
|
|
|
{"roll", true, OPTION_DOUBLE, "/sim/presets/roll-deg", false, "", 0 },
|
|
|
|
{"pitch", true, OPTION_DOUBLE, "/sim/presets/pitch-deg", false, "", 0 },
|
|
|
|
{"glideslope", true, OPTION_DOUBLE, "/sim/presets/glideslope-deg", false, "", 0 },
|
|
|
|
{"roc", true, OPTION_FUNC, "", false, "", fgOptRoc },
|
2011-10-16 17:35:40 +00:00
|
|
|
{"fg-root", true, OPTION_IGNORE, "", false, "", 0 },
|
|
|
|
{"fg-scenery", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptFgScenery },
|
|
|
|
{"fg-aircraft", true, OPTION_IGNORE | OPTION_MULTI, "", false, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"fdm", true, OPTION_STRING, "/sim/flight-model", false, "", 0 },
|
|
|
|
{"aero", true, OPTION_STRING, "/sim/aero", false, "", 0 },
|
2011-10-16 20:15:54 +00:00
|
|
|
{"aircraft-dir", true, OPTION_IGNORE, "", false, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"model-hz", true, OPTION_INT, "/sim/model-hz", false, "", 0 },
|
2012-04-01 14:04:12 +00:00
|
|
|
{"max-fps", true, OPTION_DOUBLE, "/sim/frame-rate-throttle-hz", false, "", 0 },
|
2012-11-17 19:01:19 +00:00
|
|
|
{"speed", true, OPTION_DOUBLE, "/sim/speed-up", false, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"trim", false, OPTION_BOOL, "/sim/presets/trim", true, "", 0 },
|
|
|
|
{"notrim", false, OPTION_BOOL, "/sim/presets/trim", false, "", 0 },
|
|
|
|
{"on-ground", false, OPTION_BOOL, "/sim/presets/onground", true, "", 0 },
|
|
|
|
{"in-air", false, OPTION_BOOL, "/sim/presets/onground", false, "", 0 },
|
|
|
|
{"fog-disable", false, OPTION_STRING, "/sim/rendering/fog", false, "disabled", 0 },
|
|
|
|
{"fog-fastest", false, OPTION_STRING, "/sim/rendering/fog", false, "fastest", 0 },
|
2003-06-22 09:45:43 +00:00
|
|
|
{"fog-nicest", false, OPTION_STRING, "/sim/rendering/fog", false, "nicest", 0 },
|
|
|
|
{"disable-horizon-effect", false, OPTION_BOOL, "/sim/rendering/horizon-effect", false, "", 0 },
|
|
|
|
{"enable-horizon-effect", false, OPTION_BOOL, "/sim/rendering/horizon-effect", true, "", 0 },
|
|
|
|
{"disable-enhanced-lighting", false, OPTION_BOOL, "/sim/rendering/enhanced-lighting", false, "", 0 },
|
|
|
|
{"enable-enhanced-lighting", false, OPTION_BOOL, "/sim/rendering/enhanced-lighting", true, "", 0 },
|
|
|
|
{"disable-distance-attenuation", false, OPTION_BOOL, "/sim/rendering/distance-attenuation", false, "", 0 },
|
|
|
|
{"enable-distance-attenuation", false, OPTION_BOOL, "/sim/rendering/distance-attenuation", true, "", 0 },
|
2003-09-12 21:43:01 +00:00
|
|
|
{"disable-specular-highlight", false, OPTION_BOOL, "/sim/rendering/specular-highlight", false, "", 0 },
|
|
|
|
{"enable-specular-highlight", false, OPTION_BOOL, "/sim/rendering/specular-highlight", true, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"disable-clouds", false, OPTION_BOOL, "/environment/clouds/status", false, "", 0 },
|
|
|
|
{"enable-clouds", false, OPTION_BOOL, "/environment/clouds/status", true, "", 0 },
|
2005-06-25 11:21:18 +00:00
|
|
|
{"disable-clouds3d", false, OPTION_BOOL, "/sim/rendering/clouds3d-enable", false, "", 0 },
|
|
|
|
{"enable-clouds3d", false, OPTION_BOOL, "/sim/rendering/clouds3d-enable", true, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"fov", true, OPTION_FUNC, "", false, "", fgOptFov },
|
2005-02-25 21:20:17 +00:00
|
|
|
{"aspect-ratio-multiplier", true, OPTION_DOUBLE, "/sim/current-view/aspect-ratio-multiplier", false, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"disable-fullscreen", false, OPTION_BOOL, "/sim/startup/fullscreen", false, "", 0 },
|
|
|
|
{"enable-fullscreen", false, OPTION_BOOL, "/sim/startup/fullscreen", true, "", 0 },
|
2005-12-22 13:51:11 +00:00
|
|
|
{"disable-save-on-exit", false, OPTION_BOOL, "/sim/startup/save-on-exit", false, "", 0 },
|
|
|
|
{"enable-save-on-exit", false, OPTION_BOOL, "/sim/startup/save-on-exit", true, "", 0 },
|
2013-11-14 16:48:14 +00:00
|
|
|
{"read-only", false, OPTION_BOOL, "/sim/fghome-readonly", true, "", 0 },
|
2013-10-26 17:29:23 +00:00
|
|
|
{"ignore-autosave", false, OPTION_FUNC, "", false, "", fgOptIgnoreAutosave },
|
2012-07-15 08:56:59 +00:00
|
|
|
{"restore-defaults", false, OPTION_BOOL, "/sim/startup/restore-defaults", true, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"shading-flat", false, OPTION_BOOL, "/sim/rendering/shading", false, "", 0 },
|
|
|
|
{"shading-smooth", false, OPTION_BOOL, "/sim/rendering/shading", true, "", 0 },
|
2011-01-08 20:38:26 +00:00
|
|
|
{"texture-filtering", false, OPTION_INT, "/sim/rendering/filtering", 1, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"disable-wireframe", false, OPTION_BOOL, "/sim/rendering/wireframe", false, "", 0 },
|
|
|
|
{"enable-wireframe", false, OPTION_BOOL, "/sim/rendering/wireframe", true, "", 0 },
|
2011-09-02 18:26:55 +00:00
|
|
|
{"materials-file", true, OPTION_STRING, "/sim/rendering/materials-file", false, "", 0 },
|
2011-06-11 22:44:07 +00:00
|
|
|
{"disable-terrasync", false, OPTION_BOOL, "/sim/terrasync/enabled", false, "", 0 },
|
|
|
|
{"enable-terrasync", false, OPTION_BOOL, "/sim/terrasync/enabled", true, "", 0 },
|
2011-06-22 18:01:31 +00:00
|
|
|
{"terrasync-dir", true, OPTION_STRING, "/sim/terrasync/scenery-dir", false, "", 0 },
|
2015-03-17 22:10:49 +00:00
|
|
|
{"download-dir", true, OPTION_STRING, "/sim/paths/download-dir", false, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"geometry", true, OPTION_FUNC, "", false, "", fgOptGeometry },
|
|
|
|
{"bpp", true, OPTION_FUNC, "", false, "", fgOptBpp },
|
|
|
|
{"units-feet", false, OPTION_STRING, "/sim/startup/units", false, "feet", 0 },
|
|
|
|
{"units-meters", false, OPTION_STRING, "/sim/startup/units", false, "meters", 0 },
|
2003-09-15 22:55:39 +00:00
|
|
|
{"timeofday", true, OPTION_STRING, "/sim/startup/time-offset-type", false, "noon", 0 },
|
2005-12-22 13:51:11 +00:00
|
|
|
{"season", true, OPTION_STRING, "/sim/startup/season", false, "summer", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"time-offset", true, OPTION_FUNC, "", false, "", fgOptTimeOffset },
|
|
|
|
{"time-match-real", false, OPTION_STRING, "/sim/startup/time-offset-type", false, "system-offset", 0 },
|
|
|
|
{"time-match-local", false, OPTION_STRING, "/sim/startup/time-offset-type", false, "latitude-offset", 0 },
|
|
|
|
{"start-date-sys", true, OPTION_FUNC, "", false, "", fgOptStartDateSys },
|
|
|
|
{"start-date-lat", true, OPTION_FUNC, "", false, "", fgOptStartDateLat },
|
|
|
|
{"start-date-gmt", true, OPTION_FUNC, "", false, "", fgOptStartDateGmt },
|
|
|
|
{"hud-tris", false, OPTION_STRING, "/sim/hud/frame-stat-type", false, "tris", 0 },
|
|
|
|
{"hud-culled", false, OPTION_STRING, "/sim/hud/frame-stat-type", false, "culled", 0 },
|
2004-11-16 19:47:11 +00:00
|
|
|
{"atcsim", true, OPTION_CHANNEL, "", false, "dummy", 0 },
|
2011-12-11 12:12:18 +00:00
|
|
|
{"atlas", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
2014-03-03 20:59:16 +00:00
|
|
|
{"httpd", true, OPTION_FUNC , "", false, "", fgOptHttpd },
|
2014-10-02 09:33:45 +00:00
|
|
|
{"jpg-httpd", true, OPTION_FUNC, "", false, "", fgOptJpgHttpd },
|
2011-10-29 15:34:06 +00:00
|
|
|
{"native", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"native-ctrls", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"native-fdm", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"native-gui", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"opengc", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"AV400", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"AV400Sim", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"AV400WSimA", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"AV400WSimB", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"garmin", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
2013-10-14 20:13:31 +00:00
|
|
|
{"igc", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
2011-10-29 10:15:45 +00:00
|
|
|
{"nmea", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"generic", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"props", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
|
|
|
{"telnet", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"pve", true, OPTION_CHANNEL, "", false, "", 0 },
|
|
|
|
{"ray", true, OPTION_CHANNEL, "", false, "", 0 },
|
|
|
|
{"rul", true, OPTION_CHANNEL, "", false, "", 0 },
|
|
|
|
{"joyclient", true, OPTION_CHANNEL, "", false, "", 0 },
|
2003-11-12 10:06:18 +00:00
|
|
|
{"jsclient", true, OPTION_CHANNEL, "", false, "", 0 },
|
2004-02-26 12:57:38 +00:00
|
|
|
{"proxy", true, OPTION_FUNC, "", false, "", fgSetupProxy },
|
2010-12-09 15:57:12 +00:00
|
|
|
{"callsign", true, OPTION_FUNC, "", false, "", fgOptCallSign},
|
2011-11-02 11:00:03 +00:00
|
|
|
{"multiplay", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 },
|
2013-10-20 10:58:20 +00:00
|
|
|
#if FG_HAVE_HLA
|
2010-06-27 07:04:10 +00:00
|
|
|
{"hla", true, OPTION_CHANNEL, "", false, "", 0 },
|
2012-11-21 18:41:51 +00:00
|
|
|
{"hla-local", true, OPTION_CHANNEL, "", false, "", 0 },
|
2010-06-27 07:04:10 +00:00
|
|
|
#endif
|
2011-10-29 15:34:06 +00:00
|
|
|
{"trace-read", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptTraceRead },
|
|
|
|
{"trace-write", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptTraceWrite },
|
2003-09-22 09:22:05 +00:00
|
|
|
{"log-level", true, OPTION_FUNC, "", false, "", fgOptLogLevel },
|
2011-12-11 12:55:56 +00:00
|
|
|
{"log-class", true, OPTION_FUNC, "", false, "", fgOptLogClasses },
|
2011-10-16 17:35:40 +00:00
|
|
|
{"view-offset", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptViewOffset },
|
2003-06-11 14:18:24 +00:00
|
|
|
{"visibility", true, OPTION_FUNC, "", false, "", fgOptVisibilityMeters },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"visibility-miles", true, OPTION_FUNC, "", false, "", fgOptVisibilityMiles },
|
|
|
|
{"random-wind", false, OPTION_FUNC, "", false, "", fgOptRandomWind },
|
2011-10-16 17:35:40 +00:00
|
|
|
{"wind", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptWind },
|
2003-06-11 14:18:24 +00:00
|
|
|
{"turbulence", true, OPTION_FUNC, "", false, "", fgOptTurbulence },
|
2003-09-01 22:58:19 +00:00
|
|
|
{"ceiling", true, OPTION_FUNC, "", false, "", fgOptCeiling },
|
2011-10-16 17:35:40 +00:00
|
|
|
{"wp", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptWp },
|
2011-05-25 07:21:45 +00:00
|
|
|
{"flight-plan", true, OPTION_STRING, "/autopilot/route-manager/file-path", false, "", NULL },
|
2011-10-16 17:35:40 +00:00
|
|
|
{"config", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptConfig },
|
2003-01-19 23:02:51 +00:00
|
|
|
{"aircraft", true, OPTION_STRING, "/sim/aircraft", false, "", 0 },
|
2007-11-02 18:39:10 +00:00
|
|
|
{"vehicle", true, OPTION_STRING, "/sim/aircraft", false, "", 0 },
|
2011-10-16 17:35:40 +00:00
|
|
|
{"failure", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptFailure },
|
2013-05-19 14:29:49 +00:00
|
|
|
#ifdef ENABLE_IAX
|
|
|
|
{"enable-fgcom", false, OPTION_BOOL, "/sim/fgcom/enabled", true, "", 0 },
|
|
|
|
{"disable-fgcom", false, OPTION_BOOL, "/sim/fgcom/enabled", false, "", 0 },
|
|
|
|
#endif
|
2004-12-04 21:06:57 +00:00
|
|
|
{"com1", true, OPTION_DOUBLE, "/instrumentation/comm[0]/frequencies/selected-mhz", false, "", 0 },
|
|
|
|
{"com2", true, OPTION_DOUBLE, "/instrumentation/comm[1]/frequencies/selected-mhz", false, "", 0 },
|
2003-07-16 23:34:07 +00:00
|
|
|
{"nav1", true, OPTION_FUNC, "", false, "", fgOptNAV1 },
|
|
|
|
{"nav2", true, OPTION_FUNC, "", false, "", fgOptNAV2 },
|
2011-04-17 15:35:31 +00:00
|
|
|
{"adf", /*legacy*/ true, OPTION_FUNC, "", false, "", fgOptADF1 },
|
|
|
|
{"adf1", true, OPTION_FUNC, "", false, "", fgOptADF1 },
|
|
|
|
{"adf2", true, OPTION_FUNC, "", false, "", fgOptADF2 },
|
2003-07-16 23:34:07 +00:00
|
|
|
{"dme", true, OPTION_FUNC, "", false, "", fgOptDME },
|
2004-10-28 09:37:21 +00:00
|
|
|
{"min-status", true, OPTION_STRING, "/sim/aircraft-min-status", false, "all", 0 },
|
2005-10-08 11:55:18 +00:00
|
|
|
{"livery", true, OPTION_FUNC, "", false, "", fgOptLivery },
|
2011-10-16 17:35:40 +00:00
|
|
|
{"ai-scenario", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptScenario },
|
2008-02-04 20:03:52 +00:00
|
|
|
{"parking-id", true, OPTION_FUNC, "", false, "", fgOptParking },
|
2008-03-15 12:10:44 +00:00
|
|
|
{"version", false, OPTION_FUNC, "", false, "", fgOptVersion },
|
2011-10-16 17:35:40 +00:00
|
|
|
{"enable-fpe", false, OPTION_IGNORE, "", false, "", 0},
|
|
|
|
{"fgviewer", false, OPTION_IGNORE, "", false, "", 0},
|
2012-09-29 18:02:03 +00:00
|
|
|
{"no-default-config", false, OPTION_IGNORE, "", false, "", 0},
|
2011-10-16 17:35:40 +00:00
|
|
|
{"prop", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptSetProperty},
|
2014-09-17 20:38:40 +00:00
|
|
|
{"load-tape", true, OPTION_FUNC, "", false, "", fgOptLoadTape },
|
2003-01-19 23:02:51 +00:00
|
|
|
{0}
|
|
|
|
};
|
2003-03-22 14:52:15 +00:00
|
|
|
|
2000-11-28 23:38:24 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
namespace flightgear
|
allow to specify a node type: --prop:[type:]name=value
where type is one of string (default), double, float, long, int, bool
Using only the first letter works, too.
--prop:foo=123 ... sets property foo to string 123 (old behavior)
--prop:string:foo=123 ... verbose version of above
--prop:s:foo=123 ... slightly less verbose version of above
--prop:bool:foo=1 ... makes property a bool of value 'true'
I hope this isn't considered a silly gimmick. I need this often and maybe
other developers do, too. It's useful in cases where the difference really
matters. if (getprop("/foo")), for instance, is TRUE even when the property
contains string "false", as all strings are TRUE.
2007-06-28 11:26:40 +00:00
|
|
|
{
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
/**
|
|
|
|
* internal storage of a value->option binding
|
|
|
|
*/
|
|
|
|
class OptionValue
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
OptionValue(OptionDesc* d, const string& v) :
|
|
|
|
desc(d), value(v)
|
|
|
|
{;}
|
|
|
|
|
|
|
|
OptionDesc* desc;
|
|
|
|
string value;
|
|
|
|
};
|
2007-07-12 14:45:46 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
typedef std::vector<OptionValue> OptionValueVec;
|
|
|
|
typedef std::map<string, OptionDesc*> OptionDescDict;
|
|
|
|
|
|
|
|
class Options::OptionsPrivate
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
OptionValueVec::const_iterator findValue(const string& key) const
|
|
|
|
{
|
|
|
|
OptionValueVec::const_iterator it = values.begin();
|
|
|
|
for (; it != values.end(); ++it) {
|
2011-11-10 09:15:41 +00:00
|
|
|
if (!it->desc) {
|
|
|
|
continue; // ignore markers
|
|
|
|
}
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
if (it->desc->option == key) {
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
} // of set values iteration
|
|
|
|
|
|
|
|
return it; // not found
|
|
|
|
}
|
|
|
|
|
|
|
|
OptionDesc* findOption(const string& key) const
|
|
|
|
{
|
|
|
|
OptionDescDict::const_iterator it = options.find(key);
|
|
|
|
if (it == options.end()) {
|
|
|
|
return NULL;
|
allow to specify a node type: --prop:[type:]name=value
where type is one of string (default), double, float, long, int, bool
Using only the first letter works, too.
--prop:foo=123 ... sets property foo to string 123 (old behavior)
--prop:string:foo=123 ... verbose version of above
--prop:s:foo=123 ... slightly less verbose version of above
--prop:bool:foo=1 ... makes property a bool of value 'true'
I hope this isn't considered a silly gimmick. I need this often and maybe
other developers do, too. It's useful in cases where the difference really
matters. if (getprop("/foo")), for instance, is TRUE even when the property
contains string "false", as all strings are TRUE.
2007-06-28 11:26:40 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
|
|
|
return it->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
int processOption(OptionDesc* desc, const string& arg_value)
|
|
|
|
{
|
2011-11-10 09:15:41 +00:00
|
|
|
if (!desc) {
|
|
|
|
return FG_OPTIONS_OK; // tolerate marker options
|
|
|
|
}
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
switch ( desc->type & 0xffff ) {
|
|
|
|
case OPTION_BOOL:
|
|
|
|
fgSetBool( desc->property, desc->b_param );
|
|
|
|
break;
|
|
|
|
case OPTION_STRING:
|
|
|
|
if ( desc->has_param && !arg_value.empty() ) {
|
|
|
|
fgSetString( desc->property, arg_value.c_str() );
|
|
|
|
} else if ( !desc->has_param && arg_value.empty() ) {
|
|
|
|
fgSetString( desc->property, desc->s_param );
|
|
|
|
} else if ( desc->has_param ) {
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' needs a parameter" );
|
|
|
|
return FG_OPTIONS_ERROR;
|
|
|
|
} else {
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' does not have a parameter" );
|
|
|
|
return FG_OPTIONS_ERROR;
|
2003-01-19 23:02:51 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
break;
|
|
|
|
case OPTION_DOUBLE:
|
|
|
|
if ( !arg_value.empty() ) {
|
|
|
|
fgSetDouble( desc->property, atof( arg_value ) );
|
|
|
|
} else {
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' needs a parameter" );
|
|
|
|
return FG_OPTIONS_ERROR;
|
2006-03-21 14:43:38 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
break;
|
|
|
|
case OPTION_INT:
|
|
|
|
if ( !arg_value.empty() ) {
|
|
|
|
fgSetInt( desc->property, atoi( arg_value ) );
|
2003-01-19 23:02:51 +00:00
|
|
|
} else {
|
2011-10-16 17:35:40 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' needs a parameter" );
|
|
|
|
return FG_OPTIONS_ERROR;
|
2003-01-19 23:02:51 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
break;
|
|
|
|
case OPTION_CHANNEL:
|
|
|
|
// XXX return value of add_channel should be checked?
|
|
|
|
if ( desc->has_param && !arg_value.empty() ) {
|
|
|
|
add_channel( desc->option, arg_value );
|
|
|
|
} else if ( !desc->has_param && arg_value.empty() ) {
|
|
|
|
add_channel( desc->option, desc->s_param );
|
|
|
|
} else if ( desc->has_param ) {
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' needs a parameter" );
|
|
|
|
return FG_OPTIONS_ERROR;
|
2003-01-19 23:02:51 +00:00
|
|
|
} else {
|
2011-10-16 17:35:40 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' does not have a parameter" );
|
|
|
|
return FG_OPTIONS_ERROR;
|
2003-01-19 23:02:51 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
break;
|
|
|
|
case OPTION_FUNC:
|
|
|
|
if ( desc->has_param && !arg_value.empty() ) {
|
|
|
|
return desc->func( arg_value.c_str() );
|
|
|
|
} else if ( !desc->has_param && arg_value.empty() ) {
|
|
|
|
return desc->func( desc->s_param );
|
|
|
|
} else if ( desc->has_param ) {
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' needs a parameter" );
|
|
|
|
return FG_OPTIONS_ERROR;
|
|
|
|
} else {
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' does not have a parameter" );
|
|
|
|
return FG_OPTIONS_ERROR;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case OPTION_IGNORE:
|
|
|
|
break;
|
2003-01-19 23:02:51 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
1998-11-06 21:17:31 +00:00
|
|
|
return FG_OPTIONS_OK;
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
2011-11-10 09:15:41 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* insert a marker value into the values vector. This is necessary
|
|
|
|
* when processing options, to ensure the correct ordering, where we scan
|
|
|
|
* for marker values in reverse, and then forwards within each group.
|
|
|
|
*/
|
|
|
|
void insertGroupMarker()
|
|
|
|
{
|
|
|
|
values.push_back(OptionValue(NULL, "-"));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-04-06 09:28:10 +00:00
|
|
|
* given a current iterator into the values, find the preceding group marker,
|
2011-11-10 09:15:41 +00:00
|
|
|
* or return the beginning of the value vector.
|
|
|
|
*/
|
|
|
|
OptionValueVec::const_iterator rfindGroup(OptionValueVec::const_iterator pos) const
|
|
|
|
{
|
|
|
|
while (--pos != values.begin()) {
|
|
|
|
if (pos->desc == NULL) {
|
|
|
|
return pos; // found a marker, we're done
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
|
|
|
bool showHelp,
|
|
|
|
verbose,
|
2012-09-29 18:02:03 +00:00
|
|
|
showAircraft,
|
|
|
|
shouldLoadDefaultConfig;
|
2012-04-18 11:46:26 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
OptionDescDict options;
|
|
|
|
OptionValueVec values;
|
|
|
|
simgear::PathList propertyFiles;
|
|
|
|
};
|
|
|
|
|
|
|
|
Options* Options::sharedInstance()
|
|
|
|
{
|
|
|
|
if (shared_instance == NULL) {
|
|
|
|
shared_instance = new Options;
|
|
|
|
}
|
|
|
|
|
|
|
|
return shared_instance;
|
|
|
|
}
|
|
|
|
|
|
|
|
Options::Options() :
|
|
|
|
p(new OptionsPrivate())
|
|
|
|
{
|
|
|
|
p->showHelp = false;
|
|
|
|
p->verbose = false;
|
|
|
|
p->showAircraft = false;
|
2012-09-29 18:02:03 +00:00
|
|
|
p->shouldLoadDefaultConfig = true;
|
2011-10-16 17:35:40 +00:00
|
|
|
|
|
|
|
// build option map
|
|
|
|
OptionDesc *desc = &fgOptionArray[ 0 ];
|
|
|
|
while ( desc->option != 0 ) {
|
2011-10-17 16:39:47 +00:00
|
|
|
p->options[ desc->option ] = desc;
|
|
|
|
++desc;
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
1998-04-24 00:49:17 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
|
|
|
Options::~Options()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2011-10-21 15:49:15 +00:00
|
|
|
void Options::init(int argc, char **argv, const SGPath& appDataPath)
|
2011-10-16 17:35:40 +00:00
|
|
|
{
|
|
|
|
// first, process the command line
|
|
|
|
bool inOptions = true;
|
|
|
|
for (int i=1; i<argc; ++i) {
|
|
|
|
if (inOptions && (argv[i][0] == '-')) {
|
|
|
|
if (strcmp(argv[i], "--") == 0) { // end of options delimiter
|
|
|
|
inOptions = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
int result = parseOption(argv[i]);
|
|
|
|
processArgResult(result);
|
|
|
|
} else {
|
|
|
|
// XML properties file
|
|
|
|
SGPath f(argv[i]);
|
|
|
|
if (!f.exists()) {
|
|
|
|
SG_LOG(SG_GENERAL, SG_ALERT, "config file not found:" << f.str());
|
2014-03-27 08:05:02 +00:00
|
|
|
} else {
|
|
|
|
p->propertyFiles.push_back(f);
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} // of arguments iteration
|
2011-11-10 09:15:41 +00:00
|
|
|
p->insertGroupMarker(); // command line is one group
|
2011-10-16 17:35:40 +00:00
|
|
|
|
2012-05-08 20:47:32 +00:00
|
|
|
// establish log-level before anything else - otherwise it is not possible
|
|
|
|
// to show extra (debug/info/warning) messages for the start-up phase.
|
2012-05-09 21:47:34 +00:00
|
|
|
fgOptLogLevel(valueForOption("log-level", "alert").c_str());
|
2012-05-08 20:47:32 +00:00
|
|
|
|
2012-09-29 18:02:03 +00:00
|
|
|
if (!p->shouldLoadDefaultConfig) {
|
2015-03-06 18:52:06 +00:00
|
|
|
setupRoot(argc, argv);
|
2012-09-29 18:02:03 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
// then config files
|
|
|
|
SGPath config;
|
2013-02-10 13:35:58 +00:00
|
|
|
std::string homedir;
|
|
|
|
if (getenv("HOME")) {
|
|
|
|
homedir = getenv("HOME");
|
|
|
|
}
|
2013-02-08 11:43:51 +00:00
|
|
|
|
2013-02-10 13:35:58 +00:00
|
|
|
if( !homedir.empty() && !hostname.empty() ) {
|
2011-10-16 17:35:40 +00:00
|
|
|
// Check for ~/.fgfsrc.hostname
|
|
|
|
config.set(homedir);
|
|
|
|
config.append(".fgfsrc");
|
|
|
|
config.concat( "." );
|
|
|
|
config.concat( hostname );
|
|
|
|
readConfig(config);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check for ~/.fgfsrc
|
2013-02-10 13:35:58 +00:00
|
|
|
if( !homedir.empty() ) {
|
2011-10-16 17:35:40 +00:00
|
|
|
config.set(homedir);
|
|
|
|
config.append(".fgfsrc");
|
|
|
|
readConfig(config);
|
|
|
|
}
|
|
|
|
|
2011-10-21 15:49:15 +00:00
|
|
|
// check for a config file in app data
|
|
|
|
SGPath appDataConfig(appDataPath);
|
|
|
|
appDataConfig.append("fgfsrc");
|
|
|
|
if (appDataConfig.exists()) {
|
|
|
|
readConfig(appDataConfig);
|
|
|
|
}
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
// setup FG_ROOT
|
2015-03-06 18:52:06 +00:00
|
|
|
setupRoot(argc, argv);
|
2011-10-16 17:35:40 +00:00
|
|
|
|
2015-03-13 18:14:51 +00:00
|
|
|
// system.fgfsrc is disabled, as we no longer allow anything in fgdata to set
|
|
|
|
// fg-root/fg-home/fg-aircraft and hence control what files Nasal can access
|
2015-03-20 18:56:13 +00:00
|
|
|
std::string name_for_error = homedir.empty() ? appDataConfig.str() : config.str();
|
2013-03-22 02:42:22 +00:00
|
|
|
if( ! hostname.empty() ) {
|
2011-10-16 17:35:40 +00:00
|
|
|
config.set(globals->get_fg_root());
|
|
|
|
config.append( "system.fgfsrc" );
|
|
|
|
config.concat( "." );
|
|
|
|
config.concat( hostname );
|
2015-03-13 18:14:51 +00:00
|
|
|
if (config.exists()) {
|
|
|
|
flightgear::fatalMessageBox("Unsupported configuration",
|
2015-03-20 18:56:13 +00:00
|
|
|
"You have a " + config.str() + " file, which is no longer processed for security reasons",
|
|
|
|
"If you created this file intentionally, please move it to " + name_for_error);
|
2015-03-13 18:14:51 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
1998-04-24 00:49:17 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
config.set(globals->get_fg_root());
|
|
|
|
config.append( "system.fgfsrc" );
|
2015-03-13 18:14:51 +00:00
|
|
|
if (config.exists()) {
|
|
|
|
flightgear::fatalMessageBox("Unsupported configuration",
|
2015-03-20 18:56:13 +00:00
|
|
|
"You have a " + config.str() + " file, which is no longer processed for security reasons",
|
|
|
|
"If you created this file intentionally, please move it to " + name_for_error);
|
2015-03-13 18:14:51 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
2014-12-26 12:20:51 +00:00
|
|
|
|
|
|
|
void Options::initPaths()
|
2002-01-04 20:58:48 +00:00
|
|
|
{
|
2014-12-26 12:20:51 +00:00
|
|
|
BOOST_FOREACH(const string& paths, valuesForOption("fg-aircraft")) {
|
|
|
|
globals->append_aircraft_paths(paths);
|
|
|
|
}
|
2008-03-15 12:10:44 +00:00
|
|
|
|
2014-12-26 12:20:51 +00:00
|
|
|
const char* envp = ::getenv("FG_AIRCRAFT");
|
|
|
|
if (envp) {
|
|
|
|
globals->append_aircraft_paths(envp);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Options::initAircraft()
|
|
|
|
{
|
2011-10-16 17:35:40 +00:00
|
|
|
string aircraft;
|
|
|
|
if (isOptionSet("aircraft")) {
|
|
|
|
aircraft = valueForOption("aircraft");
|
|
|
|
} else if (isOptionSet("vehicle")) {
|
|
|
|
aircraft = valueForOption("vehicle");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!aircraft.empty()) {
|
|
|
|
SG_LOG(SG_INPUT, SG_INFO, "aircraft = " << aircraft );
|
|
|
|
fgSetString("/sim/aircraft", aircraft.c_str() );
|
|
|
|
} else {
|
|
|
|
SG_LOG(SG_INPUT, SG_INFO, "No user specified aircraft, using default" );
|
|
|
|
}
|
2013-12-15 20:45:08 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
if (p->showAircraft) {
|
2015-04-09 14:31:09 +00:00
|
|
|
vector<SGPath> path_list;
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
fgOptLogLevel( "alert" );
|
2015-04-09 14:31:09 +00:00
|
|
|
|
|
|
|
// First place to check is the 'Aircraft' sub-directory in $FG_ROOT
|
|
|
|
|
|
|
|
path_list.push_back( SGPath( globals->get_fg_root() ) );
|
|
|
|
path_list.back().append("Aircraft");
|
|
|
|
|
|
|
|
// Additionally, aircraft may also be found in user-defined places
|
|
|
|
// (via $FG_AIRCRAFT or with the '--fg-aircraft' option)
|
|
|
|
|
|
|
|
string_list aircraft_paths = globals->get_aircraft_paths();
|
|
|
|
for (string_list::iterator it = aircraft_paths.begin();
|
|
|
|
it != aircraft_paths.end(); ++it)
|
|
|
|
path_list.push_back( SGPath(*it));
|
|
|
|
|
|
|
|
fgShowAircraft(path_list);
|
2011-10-16 17:35:40 +00:00
|
|
|
exit(0);
|
|
|
|
}
|
2011-10-16 20:15:54 +00:00
|
|
|
|
|
|
|
if (isOptionSet("aircraft-dir")) {
|
Use SGPath::realpath() on the value supplied for --aircraft-dir
* Before setting /sim/aircraft-dir from the --aircraft-dir option,
canonicalize its value with SGPath::realpath() as is already done in
FGGlobals::append_aircraft_path() for the paths given with --fg-aircraft
or via the FG_AIRCRAFT environment variable.
* This fixes a bug when --aircraft-dir is used, due to the fact that
fgValidatePath() canonicalizes its 'path' argument before matching it
against the allowed patterns, and therefore will not validate paths
under the directory specified with --aircraft-dir if this directory has
been given in a non-canonical form by the user (e.g., containing at
least one symlink component).
* This fix does not lower security: the path which is canonicalized has
been explicitely given by the user. This operation is already done for
all paths specified with --fg-aircraft or via the FG_AIRCRAFT
environment variable, via Options::initPaths() which calls
FGGlobals::append_aircraft_paths().
* To reproduce the bug, create a symlink (e.g., /tmp/aircrafts) to a
directory suitable for --fg-aircraft, then run:
fgfs ... --fg-aircraft=/tmp/aircrafts \
--aircraft-dir=/tmp/aircrafts/SenecaII --aircraft=SenecaII
This will trigger many failures such as:
loadxml: reading '/tmp/aircrafts/SenecaII/Dialogs/registration.xml'
denied (unauthorized directory - authorization no longer follows
symlinks; to authorize reading additional directories, add them to
--fg-aircraft)
(from do_load_xml_to_proptree() in flightgear/src/Main/fg_commands.cxx)
I have also tested this with the ec130b4 and the 777-200ER. Same
problem, same fix.
2015-10-06 10:20:54 +00:00
|
|
|
SGPath aircraftDirPath(valueForOption("aircraft-dir"));
|
|
|
|
|
|
|
|
// Set this now, so it's available in FindAndCacheAircraft. Use realpath()
|
|
|
|
// as in FGGlobals::append_aircraft_path(), otherwise fgValidatePath()
|
|
|
|
// will deny access to resources under this path if one of its components
|
|
|
|
// is a symlink (which is not a problem, since it was given as is by the
|
|
|
|
// user---this is very different from a symlink *under* the aircraft dir
|
|
|
|
// or a scenery dir).
|
|
|
|
fgSetString("/sim/aircraft-dir", aircraftDirPath.realpath().c_str());
|
2011-10-16 20:15:54 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Options::processArgResult(int result)
|
|
|
|
{
|
|
|
|
if ((result == FG_OPTIONS_HELP) || (result == FG_OPTIONS_ERROR))
|
|
|
|
p->showHelp = true;
|
|
|
|
else if (result == FG_OPTIONS_VERBOSE_HELP)
|
|
|
|
p->verbose = true;
|
|
|
|
else if (result == FG_OPTIONS_SHOW_AIRCRAFT) {
|
2012-09-29 18:02:03 +00:00
|
|
|
p->showAircraft = true;
|
|
|
|
} else if (result == FG_OPTIONS_NO_DEFAULT_CONFIG) {
|
|
|
|
p->shouldLoadDefaultConfig = false;
|
2011-10-16 17:35:40 +00:00
|
|
|
} else if (result == FG_OPTIONS_SHOW_SOUND_DEVICES) {
|
|
|
|
SGSoundMgr smgr;
|
|
|
|
|
|
|
|
smgr.init();
|
|
|
|
string vendor = smgr.get_vendor();
|
|
|
|
string renderer = smgr.get_renderer();
|
|
|
|
cout << renderer << " provided by " << vendor << endl;
|
|
|
|
cout << endl << "No. Device" << endl;
|
|
|
|
|
|
|
|
vector <const char*>devices = smgr.get_available_devices();
|
|
|
|
for (vector <const char*>::size_type i=0; i<devices.size(); i++) {
|
|
|
|
cout << i << ". \"" << devices[i] << "\"" << endl;
|
1998-04-24 00:49:17 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
devices.clear();
|
2012-09-21 11:26:33 +00:00
|
|
|
smgr.stop();
|
2011-10-16 17:35:40 +00:00
|
|
|
exit(0);
|
|
|
|
} else if (result == FG_OPTIONS_EXIT) {
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Options::readConfig(const SGPath& path)
|
|
|
|
{
|
|
|
|
sg_gzifstream in( path.str() );
|
|
|
|
if ( !in.is_open() ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
SG_LOG( SG_GENERAL, SG_INFO, "Processing config file: " << path.str() );
|
|
|
|
|
|
|
|
in >> skipcomment;
|
|
|
|
while ( ! in.eof() ) {
|
|
|
|
string line;
|
|
|
|
getline( in, line, '\n' );
|
|
|
|
|
|
|
|
// catch extraneous (DOS) line ending character
|
|
|
|
int i;
|
|
|
|
for (i = line.length(); i > 0; i--)
|
|
|
|
if (line[i - 1] > 32)
|
|
|
|
break;
|
|
|
|
line = line.substr( 0, i );
|
|
|
|
|
|
|
|
if ( parseOption( line ) == FG_OPTIONS_ERROR ) {
|
|
|
|
cerr << endl << "Config file parse error: " << path.str() << " '"
|
|
|
|
<< line << "'" << endl;
|
|
|
|
p->showHelp = true;
|
2002-08-25 22:38:20 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
in >> skipcomment;
|
|
|
|
}
|
2002-08-25 22:38:20 +00:00
|
|
|
|
2011-11-10 09:15:41 +00:00
|
|
|
p->insertGroupMarker(); // each config file is a group
|
1998-04-24 00:49:17 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
|
|
|
int Options::parseOption(const string& s)
|
|
|
|
{
|
|
|
|
if ((s == "--help") || (s=="-h")) {
|
|
|
|
return FG_OPTIONS_HELP;
|
|
|
|
} else if ( (s == "--verbose") || (s == "-v") ) {
|
|
|
|
// verbose help/usage request
|
|
|
|
return FG_OPTIONS_VERBOSE_HELP;
|
2013-10-26 20:06:03 +00:00
|
|
|
} else if ((s == "--console") || (s == "-c")) {
|
|
|
|
simgear::requestConsole();
|
|
|
|
return FG_OPTIONS_OK;
|
2011-10-16 17:35:40 +00:00
|
|
|
} else if (s.find("-psn") == 0) {
|
|
|
|
// on Mac, when launched from the GUI, we are passed the ProcessSerialNumber
|
|
|
|
// as an argument (and no others). Silently ignore the argument here.
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
} else if ( s.find( "--show-aircraft") == 0) {
|
|
|
|
return(FG_OPTIONS_SHOW_AIRCRAFT);
|
|
|
|
} else if ( s.find( "--show-sound-devices") == 0) {
|
|
|
|
return(FG_OPTIONS_SHOW_SOUND_DEVICES);
|
2012-09-29 18:02:03 +00:00
|
|
|
} else if ( s.find( "--no-default-config") == 0) {
|
|
|
|
return FG_OPTIONS_NO_DEFAULT_CONFIG;
|
2011-10-16 17:35:40 +00:00
|
|
|
} else if ( s.find( "--prop:") == 0) {
|
|
|
|
// property setting has a slightly different syntax, so fudge things
|
|
|
|
OptionDesc* desc = p->findOption("prop");
|
|
|
|
if (s.find("=", 7) == string::npos) { // no equals token
|
|
|
|
SG_LOG(SG_GENERAL, SG_ALERT, "malformed property option:" << s);
|
|
|
|
return FG_OPTIONS_ERROR;
|
2001-05-18 16:09:39 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
|
|
|
p->values.push_back(OptionValue(desc, s.substr(7)));
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
} else if ( s.find( "--" ) == 0 ) {
|
|
|
|
size_t eqPos = s.find( '=' );
|
|
|
|
string key, value;
|
|
|
|
if (eqPos == string::npos) {
|
|
|
|
key = s.substr(2);
|
|
|
|
} else {
|
|
|
|
key = s.substr( 2, eqPos - 2 );
|
|
|
|
value = s.substr( eqPos + 1);
|
1998-05-13 18:29:56 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
|
|
|
return addOption(key, value);
|
|
|
|
} else {
|
2014-01-25 10:36:00 +00:00
|
|
|
flightgear::modalMessageBox("Unknown option", "Unknown command-line option: " + s);
|
2011-10-16 17:35:40 +00:00
|
|
|
return FG_OPTIONS_ERROR;
|
|
|
|
}
|
1998-05-13 18:29:56 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
|
|
|
int Options::addOption(const string &key, const string &value)
|
2001-01-13 22:06:39 +00:00
|
|
|
{
|
2011-10-16 17:35:40 +00:00
|
|
|
OptionDesc* desc = p->findOption(key);
|
|
|
|
if (!desc) {
|
2014-01-25 10:36:00 +00:00
|
|
|
flightgear::modalMessageBox("Unknown option", "Unknown command-line option: " + key);
|
2011-10-16 17:35:40 +00:00
|
|
|
return FG_OPTIONS_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(desc->type & OPTION_MULTI)) {
|
|
|
|
OptionValueVec::const_iterator it = p->findValue(key);
|
|
|
|
if (it != p->values.end()) {
|
2014-01-25 10:36:00 +00:00
|
|
|
SG_LOG(SG_GENERAL, SG_WARN, "multiple values forbidden for option:" << key << ", ignoring:" << value);
|
2011-10-16 17:35:40 +00:00
|
|
|
return FG_OPTIONS_OK;
|
2002-06-10 23:30:23 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
p->values.push_back(OptionValue(desc, value));
|
|
|
|
return FG_OPTIONS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Options::isOptionSet(const string &key) const
|
|
|
|
{
|
|
|
|
OptionValueVec::const_iterator it = p->findValue(key);
|
|
|
|
return (it != p->values.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
string Options::valueForOption(const string& key, const string& defValue) const
|
|
|
|
{
|
|
|
|
OptionValueVec::const_iterator it = p->findValue(key);
|
|
|
|
if (it == p->values.end()) {
|
|
|
|
return defValue;
|
|
|
|
}
|
|
|
|
|
|
|
|
return it->value;
|
|
|
|
}
|
2002-06-10 23:30:23 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
string_list Options::valuesForOption(const std::string& key) const
|
|
|
|
{
|
|
|
|
string_list result;
|
|
|
|
OptionValueVec::const_iterator it = p->values.begin();
|
|
|
|
for (; it != p->values.end(); ++it) {
|
2011-11-10 09:15:41 +00:00
|
|
|
if (!it->desc) {
|
|
|
|
continue; // ignore marker values
|
|
|
|
}
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
if (it->desc->option == key) {
|
|
|
|
result.push_back(it->value);
|
2002-06-10 23:30:23 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2012-04-21 07:38:41 +00:00
|
|
|
|
2015-03-17 22:10:49 +00:00
|
|
|
string defaultDownloadDir()
|
2014-01-26 16:05:45 +00:00
|
|
|
{
|
|
|
|
#if defined(SG_WINDOWS)
|
2015-03-17 22:10:49 +00:00
|
|
|
SGPath p(SGPath::documents());
|
|
|
|
p.append("FlightGear");
|
2014-01-26 16:05:45 +00:00
|
|
|
#else
|
|
|
|
SGPath p(globals->get_fg_home());
|
|
|
|
#endif
|
2015-03-17 22:10:49 +00:00
|
|
|
return p.str();
|
2014-01-26 16:05:45 +00:00
|
|
|
}
|
|
|
|
|
2013-10-15 21:16:50 +00:00
|
|
|
OptionResult Options::processOptions()
|
2011-10-16 17:35:40 +00:00
|
|
|
{
|
2012-04-21 18:17:42 +00:00
|
|
|
// establish locale before showing help (this selects the default locale,
|
|
|
|
// when no explicit option was set)
|
|
|
|
globals->get_locale()->selectLanguage(valueForOption("language").c_str());
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
// now FG_ROOT is setup, process various command line options that bail us
|
|
|
|
// out quickly, but rely on aircraft / root settings
|
|
|
|
if (p->showHelp) {
|
|
|
|
showUsage();
|
2013-10-15 21:16:50 +00:00
|
|
|
return FG_OPTIONS_EXIT;
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
|
|
|
|
2011-11-10 09:15:41 +00:00
|
|
|
// processing order is complicated. We must process groups LIFO, but the
|
|
|
|
// values *within* each group in FIFO order, to retain consistency with
|
|
|
|
// older versions of FG, and existing user configs.
|
|
|
|
// in practice this means system.fgfsrc must be *processed* before
|
|
|
|
// .fgfsrc, which must be processed before the command line args, and so on.
|
|
|
|
OptionValueVec::const_iterator groupEnd = p->values.end();
|
2012-04-01 14:04:12 +00:00
|
|
|
|
2011-11-10 09:15:41 +00:00
|
|
|
while (groupEnd != p->values.begin()) {
|
|
|
|
OptionValueVec::const_iterator groupBegin = p->rfindGroup(groupEnd);
|
|
|
|
// run over the group in FIFO order
|
|
|
|
OptionValueVec::const_iterator it;
|
|
|
|
for (it = groupBegin; it != groupEnd; ++it) {
|
|
|
|
int result = p->processOption(it->desc, it->value);
|
2012-03-17 11:01:51 +00:00
|
|
|
switch(result)
|
|
|
|
{
|
|
|
|
case FG_OPTIONS_ERROR:
|
|
|
|
showUsage();
|
2013-10-15 21:16:50 +00:00
|
|
|
return FG_OPTIONS_ERROR;
|
|
|
|
|
2012-03-17 11:01:51 +00:00
|
|
|
case FG_OPTIONS_EXIT:
|
2013-10-15 21:16:50 +00:00
|
|
|
return FG_OPTIONS_EXIT;
|
|
|
|
|
2012-03-17 11:01:51 +00:00
|
|
|
default:
|
|
|
|
break;
|
2011-11-10 09:15:41 +00:00
|
|
|
}
|
2002-06-10 23:30:23 +00:00
|
|
|
}
|
2011-11-10 09:15:41 +00:00
|
|
|
|
|
|
|
groupEnd = groupBegin;
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
2012-04-01 14:04:12 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
BOOST_FOREACH(const SGPath& file, p->propertyFiles) {
|
|
|
|
SG_LOG(SG_GENERAL, SG_INFO,
|
|
|
|
"Reading command-line property file " << file.str());
|
|
|
|
readProperties(file.str(), globals->get_props());
|
|
|
|
}
|
2002-06-10 23:30:23 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
// now options are process, do supplemental fixup
|
|
|
|
const char *envp = ::getenv( "FG_SCENERY" );
|
|
|
|
if (envp) {
|
|
|
|
globals->append_fg_scenery(envp);
|
|
|
|
}
|
2015-03-17 22:10:49 +00:00
|
|
|
|
|
|
|
// download dir fix-up
|
|
|
|
string downloadDir = simgear::strutils::strip(fgGetString("/sim/paths/download-dir"));
|
|
|
|
if (downloadDir.empty()) {
|
|
|
|
downloadDir = defaultDownloadDir();
|
|
|
|
SG_LOG(SG_GENERAL, SG_INFO, "Using default download dir: " << downloadDir);
|
|
|
|
} else {
|
|
|
|
simgear::Dir d(downloadDir);
|
|
|
|
if (!d.exists()) {
|
|
|
|
SG_LOG(SG_GENERAL, SG_INFO, "Creating requested download dir: " << downloadDir);
|
|
|
|
d.create(0755);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-16 20:46:27 +00:00
|
|
|
// terrasync directory fixup
|
2015-01-04 17:50:10 +00:00
|
|
|
string terrasyncDir = simgear::strutils::strip(fgGetString("/sim/terrasync/scenery-dir"));
|
2013-12-17 18:09:12 +00:00
|
|
|
if (terrasyncDir.empty()) {
|
2015-03-17 22:10:49 +00:00
|
|
|
SGPath p(downloadDir);
|
|
|
|
p.append("TerraSync");
|
|
|
|
terrasyncDir = p.str();
|
2014-01-26 16:05:45 +00:00
|
|
|
|
2015-03-17 22:10:49 +00:00
|
|
|
simgear::Dir d(terrasyncDir);
|
|
|
|
if (!d.exists()) {
|
|
|
|
d.create(0755);
|
|
|
|
}
|
2014-01-26 16:05:45 +00:00
|
|
|
|
2015-03-17 22:10:49 +00:00
|
|
|
SG_LOG(SG_GENERAL, SG_INFO, "Using default TerraSync: " << terrasyncDir);
|
|
|
|
fgSetString("/sim/terrasync/scenery-dir", p.str());
|
|
|
|
} else {
|
|
|
|
SG_LOG(SG_GENERAL, SG_INFO, "Using explicit TerraSync dir: " << terrasyncDir);
|
2013-12-17 18:09:12 +00:00
|
|
|
}
|
2015-01-04 17:50:10 +00:00
|
|
|
|
2015-03-17 22:10:49 +00:00
|
|
|
// check if we setup a scenery path so far
|
|
|
|
bool addFGDataScenery = globals->get_fg_scenery().empty();
|
2015-01-04 17:50:10 +00:00
|
|
|
|
2015-03-17 22:10:49 +00:00
|
|
|
// always add the terrasync location, regardless of whether terrasync
|
|
|
|
// is enabled or not. This allows us to toggle terrasync on/off at
|
|
|
|
// runtime and have things work as expected
|
2011-10-16 20:46:27 +00:00
|
|
|
const string_list& scenery_paths(globals->get_fg_scenery());
|
|
|
|
if (std::find(scenery_paths.begin(), scenery_paths.end(), terrasyncDir) == scenery_paths.end()) {
|
2015-03-17 22:10:49 +00:00
|
|
|
// terrasync dir is not in the scenery paths, add it
|
|
|
|
globals->append_fg_scenery(terrasyncDir);
|
2011-10-16 20:46:27 +00:00
|
|
|
}
|
2015-03-17 22:10:49 +00:00
|
|
|
|
|
|
|
if (addFGDataScenery) {
|
|
|
|
// no scenery paths set at all, use the data in FG_ROOT
|
|
|
|
// ensure this path is added last
|
|
|
|
SGPath root(globals->get_fg_root());
|
|
|
|
root.append("Scenery");
|
|
|
|
globals->append_fg_scenery(root.str());
|
|
|
|
}
|
|
|
|
|
2013-12-17 18:09:12 +00:00
|
|
|
return FG_OPTIONS_OK;
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Options::showUsage() const
|
|
|
|
{
|
|
|
|
fgOptLogLevel( "alert" );
|
|
|
|
|
2012-04-21 18:17:42 +00:00
|
|
|
FGLocale *locale = globals->get_locale();
|
2011-10-16 17:35:40 +00:00
|
|
|
SGPropertyNode options_root;
|
|
|
|
|
2013-10-26 20:06:03 +00:00
|
|
|
simgear::requestConsole(); // ensure console is shown on Windows
|
2011-10-16 17:35:40 +00:00
|
|
|
cout << endl;
|
2012-04-21 18:17:42 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
try {
|
|
|
|
fgLoadProps("options.xml", &options_root);
|
|
|
|
} catch (const sg_exception &) {
|
|
|
|
cout << "Unable to read the help file." << endl;
|
|
|
|
cout << "Make sure the file options.xml is located in the FlightGear base directory," << endl;
|
|
|
|
cout << "and the location of the base directory is specified by setting $FG_ROOT or" << endl;
|
|
|
|
cout << "by adding --fg-root=path as a program argument." << endl;
|
|
|
|
|
|
|
|
exit(-1);
|
|
|
|
}
|
2012-04-21 18:17:42 +00:00
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
SGPropertyNode *options = options_root.getNode("options");
|
|
|
|
if (!options) {
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT,
|
|
|
|
"Error reading options.xml: <options> directive not found." );
|
|
|
|
exit(-1);
|
|
|
|
}
|
2012-04-21 18:17:42 +00:00
|
|
|
|
|
|
|
if (!locale->loadResource("options"))
|
|
|
|
{
|
|
|
|
cout << "Unable to read the language resource." << endl;
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* usage = locale->getLocalizedString(options->getStringValue("usage"), "options");
|
2011-10-16 17:35:40 +00:00
|
|
|
if (usage) {
|
2012-04-21 18:17:42 +00:00
|
|
|
cout << usage << endl;
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
vector<SGPropertyNode_ptr>section = options->getChildren("section");
|
|
|
|
for (unsigned int j = 0; j < section.size(); j++) {
|
|
|
|
string msg = "";
|
|
|
|
|
|
|
|
vector<SGPropertyNode_ptr>option = section[j]->getChildren("option");
|
|
|
|
for (unsigned int k = 0; k < option.size(); k++) {
|
|
|
|
|
|
|
|
SGPropertyNode *name = option[k]->getNode("name");
|
|
|
|
SGPropertyNode *short_name = option[k]->getNode("short");
|
|
|
|
SGPropertyNode *key = option[k]->getNode("key");
|
|
|
|
SGPropertyNode *arg = option[k]->getNode("arg");
|
|
|
|
bool brief = option[k]->getNode("brief") != 0;
|
|
|
|
|
|
|
|
if ((brief || p->verbose) && name) {
|
|
|
|
string tmp = name->getStringValue();
|
|
|
|
|
|
|
|
if (key){
|
|
|
|
tmp.append(":");
|
|
|
|
tmp.append(key->getStringValue());
|
2002-06-10 23:30:23 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
if (arg) {
|
|
|
|
tmp.append("=");
|
|
|
|
tmp.append(arg->getStringValue());
|
|
|
|
}
|
|
|
|
if (short_name) {
|
|
|
|
tmp.append(", -");
|
|
|
|
tmp.append(short_name->getStringValue());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tmp.size() <= 25) {
|
|
|
|
msg+= " --";
|
|
|
|
msg += tmp;
|
|
|
|
msg.append( 27-tmp.size(), ' ');
|
|
|
|
} else {
|
|
|
|
msg += "\n --";
|
|
|
|
msg += tmp + '\n';
|
|
|
|
msg.append(32, ' ');
|
|
|
|
}
|
2012-04-21 18:17:42 +00:00
|
|
|
// There may be more than one <description> tag associated
|
2011-10-16 17:35:40 +00:00
|
|
|
// with one option
|
|
|
|
|
|
|
|
vector<SGPropertyNode_ptr> desc;
|
|
|
|
desc = option[k]->getChildren("description");
|
2013-03-22 02:42:22 +00:00
|
|
|
if (! desc.empty()) {
|
2011-10-16 17:35:40 +00:00
|
|
|
for ( unsigned int l = 0; l < desc.size(); l++) {
|
|
|
|
string t = desc[l]->getStringValue();
|
2012-04-21 18:17:42 +00:00
|
|
|
|
|
|
|
// There may be more than one translation line.
|
|
|
|
vector<SGPropertyNode_ptr>trans_desc = locale->getLocalizedStrings(t.c_str(),"options");
|
2011-10-16 17:35:40 +00:00
|
|
|
for ( unsigned int m = 0; m < trans_desc.size(); m++ ) {
|
|
|
|
string t_str = trans_desc[m]->getStringValue();
|
|
|
|
|
|
|
|
if ((m > 0) || ((l > 0) && m == 0)) {
|
|
|
|
msg.append( 32, ' ');
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the string is too large to fit on the screen,
|
|
|
|
// then split it up in several pieces.
|
|
|
|
|
|
|
|
while ( t_str.size() > 47 ) {
|
|
|
|
|
|
|
|
string::size_type m = t_str.rfind(' ', 47);
|
|
|
|
msg += t_str.substr(0, m) + '\n';
|
|
|
|
msg.append( 32, ' ');
|
|
|
|
|
|
|
|
t_str.erase(t_str.begin(), t_str.begin() + m + 1);
|
|
|
|
}
|
|
|
|
msg += t_str + '\n';
|
|
|
|
}
|
|
|
|
}
|
2002-08-25 22:38:20 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
2002-08-25 22:38:20 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
2012-04-21 18:17:42 +00:00
|
|
|
const char* name = locale->getLocalizedString(section[j]->getStringValue("name"),"options");
|
2011-10-16 17:35:40 +00:00
|
|
|
if (!msg.empty() && name) {
|
2012-04-21 18:17:42 +00:00
|
|
|
cout << endl << name << ":" << endl;
|
2011-10-16 17:35:40 +00:00
|
|
|
cout << msg;
|
|
|
|
msg.erase();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !p->verbose ) {
|
2012-04-21 18:17:42 +00:00
|
|
|
const char* verbose_help = locale->getLocalizedString(options->getStringValue("verbose-help"),"options");
|
|
|
|
if (verbose_help)
|
|
|
|
cout << endl << verbose_help << endl;
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
2011-11-13 21:27:55 +00:00
|
|
|
std::cout << "Hit a key to continue..." << std::endl;
|
|
|
|
std::cin.get();
|
2011-10-16 17:35:40 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(__CYGWIN__)
|
|
|
|
string Options::platformDefaultRoot() const
|
|
|
|
{
|
|
|
|
return "../data";
|
|
|
|
}
|
2002-08-25 22:38:20 +00:00
|
|
|
|
2013-11-19 22:01:11 +00:00
|
|
|
#elif defined(SG_WINDOWS)
|
2011-10-16 17:35:40 +00:00
|
|
|
string Options::platformDefaultRoot() const
|
|
|
|
{
|
|
|
|
return "..\\data";
|
|
|
|
}
|
2013-11-19 22:01:11 +00:00
|
|
|
#elif defined(SG_MAC)
|
2013-11-18 15:52:30 +00:00
|
|
|
// platformDefaultRoot defined in CocoaHelpers.mm
|
2011-10-16 17:35:40 +00:00
|
|
|
#else
|
|
|
|
string Options::platformDefaultRoot() const
|
|
|
|
{
|
|
|
|
return PKGLIBDIR;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-03-06 18:52:06 +00:00
|
|
|
void Options::setupRoot(int argc, char **argv)
|
2011-10-16 17:35:40 +00:00
|
|
|
{
|
|
|
|
string root;
|
2015-03-06 18:52:06 +00:00
|
|
|
bool usingDefaultRoot = false;
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
if (isOptionSet("fg-root")) {
|
|
|
|
root = valueForOption("fg-root"); // easy!
|
|
|
|
} else {
|
|
|
|
// Next check if fg-root is set as an env variable
|
|
|
|
char *envp = ::getenv( "FG_ROOT" );
|
|
|
|
if ( envp != NULL ) {
|
|
|
|
root = envp;
|
|
|
|
} else {
|
2015-03-06 18:52:06 +00:00
|
|
|
usingDefaultRoot = true;
|
2011-10-16 17:35:40 +00:00
|
|
|
root = platformDefaultRoot();
|
2002-06-10 23:30:23 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
}
|
|
|
|
|
2015-03-06 18:52:06 +00:00
|
|
|
SG_LOG(SG_GENERAL, SG_INFO, "fg_root = " << root );
|
2011-10-16 17:35:40 +00:00
|
|
|
globals->set_fg_root(root);
|
2015-03-06 18:52:06 +00:00
|
|
|
static char required_version[] = FLIGHTGEAR_VERSION;
|
|
|
|
string base_version = fgBasePackageVersion(root);
|
|
|
|
|
|
|
|
#if defined(HAVE_QT)
|
|
|
|
if (base_version != required_version) {
|
|
|
|
QtLauncher::initApp(argc, argv);
|
|
|
|
if (SetupRootDialog::restoreUserSelectedRoot()) {
|
|
|
|
SG_LOG(SG_GENERAL, SG_INFO, "restored user selected fg_root = " << globals->get_fg_root() );
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
SetupRootDialog dlg(usingDefaultRoot);
|
|
|
|
dlg.exec();
|
|
|
|
if (dlg.result() != QDialog::Accepted) {
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
// validate it
|
2013-11-06 23:49:58 +00:00
|
|
|
if (base_version.empty()) {
|
|
|
|
flightgear::fatalMessageBox("Base package not found",
|
|
|
|
"Required data files not found, check your installation.",
|
|
|
|
"Looking for base-package files at: '" + root + "'");
|
|
|
|
|
|
|
|
exit(-1);
|
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
2015-03-06 18:52:06 +00:00
|
|
|
if (base_version != required_version) {
|
2013-11-06 23:49:58 +00:00
|
|
|
flightgear::fatalMessageBox("Base package version mismatch",
|
|
|
|
"Version check failed: please check your installation.",
|
|
|
|
"Found data files for version '" + base_version +
|
|
|
|
"' at '" + globals->get_fg_root() + "', version '"
|
|
|
|
+ required_version + "' is required.");
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
exit(-1);
|
|
|
|
}
|
2015-03-06 18:52:06 +00:00
|
|
|
#endif
|
1998-04-24 00:49:17 +00:00
|
|
|
}
|
2011-10-16 17:35:40 +00:00
|
|
|
|
2012-09-29 18:02:03 +00:00
|
|
|
bool Options::shouldLoadDefaultConfig() const
|
|
|
|
{
|
|
|
|
return p->shouldLoadDefaultConfig;
|
|
|
|
}
|
2014-02-19 21:53:52 +00:00
|
|
|
|
|
|
|
bool Options::checkForArg(int argc, char* argv[], const char* checkArg)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < argc; ++i) {
|
|
|
|
char* arg = argv[i];
|
|
|
|
if (!strncmp("--", arg, 2) && !strcmp(arg + 2, checkArg)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((arg[0] == '-') && !strcmp(arg + 1, checkArg)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-10-16 17:35:40 +00:00
|
|
|
} // of namespace flightgear
|
|
|
|
|