#include <sys/types.h>
#include <sys/stat.h>
#include <fstream>
+#include <sstream>
#include <plib/ul.h>
// nil if it doesn't exist.
static naRef f_getprop(naContext c, naRef me, int argc, naRef* args)
{
+ using namespace simgear;
const SGPropertyNode* p = findnode(c, args, argc);
if(!p) return naNil();
switch(p->getType()) {
- case SGPropertyNode::BOOL: case SGPropertyNode::INT:
- case SGPropertyNode::LONG: case SGPropertyNode::FLOAT:
- case SGPropertyNode::DOUBLE:
+ case props::BOOL: case props::INT:
+ case props::LONG: case props::FLOAT:
+ case props::DOUBLE:
return naNum(p->getDoubleValue());
- case SGPropertyNode::STRING:
- case SGPropertyNode::UNSPECIFIED:
+ case props::STRING:
+ case props::UNSPECIFIED:
{
naRef nastr = naNewString(c);
const char* val = p->getStringValue();
naStr_fromdata(nastr, (char*)val, strlen(val));
return nastr;
}
- case SGPropertyNode::ALIAS: // <--- FIXME, recurse?
+ case props::ALIAS: // <--- FIXME, recurse?
default:
return naNil();
}
SGPropertyNode* props = globals->get_props();
naRef val = args[argc-1];
+ bool result = false;
try {
- bool r;
- if(naIsString(val)) r = props->setStringValue(buf, naStr_data(val));
+ if(naIsString(val)) result = props->setStringValue(buf, naStr_data(val));
else {
naRef n = naNumValue(val);
if(naIsNil(n))
naRuntimeError(c, "setprop() value is not string or number");
- r = props->setDoubleValue(buf, n.num);
+ result = props->setDoubleValue(buf, n.num);
}
- if(!r) naRuntimeError(c, "setprop(): property is not writable");
} catch (const string& err) {
naRuntimeError(c, (char *)err.c_str());
}
- return naNil();
+ return naNum(result);
#undef BUFLEN
}
static naRef f_geodinfo(naContext c, naRef me, int argc, naRef* args)
{
#define HASHSET(s,l,n) naHash_set(matdata, naStr_fromdata(naNewString(c),s,l),n)
- if(argc != 2) naRuntimeError(c, "geodinfo() expects 2 arguments: lat, lon");
+ if(argc < 2 || argc > 3)
+ naRuntimeError(c, "geodinfo() expects 2 or 3 arguments: lat, lon [, maxalt]");
double lat = naNumValue(args[0]).num;
double lon = naNumValue(args[1]).num;
- double elev;
+ double elev = argc == 3 ? naNumValue(args[2]).num : 10000;
const SGMaterial *mat;
- if(!globals->get_scenery()->get_elevation_m(lat, lon, 10000.0, elev, &mat))
+ SGGeod geod = SGGeod::fromDegM(lon, lat, elev);
+ if(!globals->get_scenery()->get_elevation_m(geod, elev, &mat))
return naNil();
naRef vec = naNewVector(c);
naVec_append(vec, naNum(elev));
}
-class airport_filter : public FGAirportSearchFilter {
- virtual bool pass(FGAirport *a) { return a->isAirport(); }
-} airport;
-class seaport_filter : public FGAirportSearchFilter {
- virtual bool pass(FGAirport *a) { return a->isSeaport(); }
-} seaport;
-class heliport_filter : public FGAirportSearchFilter {
- virtual bool pass(FGAirport *a) { return a->isHeliport(); }
-} heliport;
+class AirportInfoFilter : public FGAirport::AirportFilter
+{
+public:
+ AirportInfoFilter() : type(FGPositioned::AIRPORT) {
+ }
+
+ virtual FGPositioned::Type minType() const {
+ return type;
+ }
+
+ virtual FGPositioned::Type maxType() const {
+ return type;
+ }
+
+ FGPositioned::Type type;
+};
// Returns data hash for particular or nearest airport of a <type>, or nil
-// on error. Only one side of each runway is contained.
+// on error.
//
// airportinfo(<id>); e.g. "KSFO"
// airportinfo(<type>); type := ("airport"|"seaport"|"heliport")
{
static SGConstPropertyNode_ptr latn = fgGetNode("/position/latitude-deg", true);
static SGConstPropertyNode_ptr lonn = fgGetNode("/position/longitude-deg", true);
- double lat, lon;
+ SGGeod pos;
+ FGAirport* apt = NULL;
- FGAirportList *aptlst = globals->get_airports();
- FGAirport *apt;
if(argc >= 2 && naIsNum(args[0]) && naIsNum(args[1])) {
- lat = args[0].num;
- lon = args[1].num;
+ pos = SGGeod::fromDeg(args[1].num, args[0].num);
args += 2;
argc -= 2;
} else {
- lat = latn->getDoubleValue();
- lon = lonn->getDoubleValue();
+ pos = SGGeod::fromDeg(lonn->getDoubleValue(), latn->getDoubleValue());
}
+
+ double maxRange = 10000.0; // expose this? or pick a smaller value?
+
+ AirportInfoFilter filter; // defaults to airports only
+
if(argc == 0) {
- apt = aptlst->search(lon, lat, airport);
+ // fall through and use AIRPORT
} else if(argc == 1 && naIsString(args[0])) {
const char *s = naStr_data(args[0]);
- if(!strcmp(s, "airport")) apt = aptlst->search(lon, lat, airport);
- else if(!strcmp(s, "seaport")) apt = aptlst->search(lon, lat, seaport);
- else if(!strcmp(s, "heliport")) apt = aptlst->search(lon, lat, heliport);
- else apt = aptlst->search(s);
+ if(!strcmp(s, "airport")) filter.type = FGPositioned::AIRPORT;
+ else if(!strcmp(s, "seaport")) filter.type = FGPositioned::SEAPORT;
+ else if(!strcmp(s, "heliport")) filter.type = FGPositioned::HELIPORT;
+ else {
+ // user provided an <id>, hopefully
+ apt = FGAirport::findByIdent(s);
+ if (!apt) {
+ // return nil here, but don't raise a runtime error; this is a
+ // legitamate way to validate an ICAO code, for example in a
+ // dialog box or similar.
+ return naNil();
+ }
+ }
} else {
naRuntimeError(c, "airportinfo() with invalid function arguments");
return naNil();
}
- if(!apt) return naNil();
- string id = apt->getId();
- string name = apt->getName();
+ if(!apt) {
+ apt = FGAirport::findClosest(pos, maxRange, &filter);
+ if(!apt) return naNil();
+ }
+
+ string id = apt->ident();
+ string name = apt->name();
// set runway hash
- FGRunwayList *rwylst = globals->get_runways();
- FGRunway rwy;
naRef rwys = naNewHash(c);
- if(rwylst->search(id, &rwy)) {
- do {
- if(rwy._id != id) break;
- if(rwy._type[0] != 'r') continue;
+ for(unsigned int r=0; r<apt->numRunways(); ++r) {
+ FGRunway* rwy(apt->getRunwayByIndex(r));
- naRef rwyid = naStr_fromdata(naNewString(c),
- const_cast<char *>(rwy._rwy_no.c_str()),
- rwy._rwy_no.length());
+ naRef rwyid = naStr_fromdata(naNewString(c),
+ const_cast<char *>(rwy->ident().c_str()),
+ rwy->ident().length());
- naRef rwydata = naNewHash(c);
+ naRef rwydata = naNewHash(c);
#define HASHSET(s,l,n) naHash_set(rwydata, naStr_fromdata(naNewString(c),s,l),n)
- HASHSET("id", 2, rwyid);
- HASHSET("lat", 3, naNum(rwy._lat));
- HASHSET("lon", 3, naNum(rwy._lon));
- HASHSET("heading", 7, naNum(rwy._heading));
- HASHSET("length", 6, naNum(rwy._length * SG_FEET_TO_METER));
- HASHSET("width", 5, naNum(rwy._width * SG_FEET_TO_METER));
- HASHSET("threshold1", 10, naNum(rwy._displ_thresh1 * SG_FEET_TO_METER));
- HASHSET("threshold2", 10, naNum(rwy._displ_thresh2 * SG_FEET_TO_METER));
- HASHSET("stopway1", 8, naNum(rwy._stopway1 * SG_FEET_TO_METER));
- HASHSET("stopway2", 8, naNum(rwy._stopway2 * SG_FEET_TO_METER));
+ HASHSET("id", 2, rwyid);
+ HASHSET("lat", 3, naNum(rwy->latitude()));
+ HASHSET("lon", 3, naNum(rwy->longitude()));
+ HASHSET("heading", 7, naNum(rwy->headingDeg()));
+ HASHSET("length", 6, naNum(rwy->lengthM()));
+ HASHSET("width", 5, naNum(rwy->widthM()));
+ HASHSET("threshold", 9, naNum(rwy->displacedThresholdM()));
+ HASHSET("stopway", 7, naNum(rwy->stopwayM()));
#undef HASHSET
- naHash_set(rwys, rwyid, rwydata);
- } while(rwylst->next(&rwy));
+ naHash_set(rwys, rwyid, rwydata);
}
// set airport hash
const char *s = "nasal-dir-initialized";
SGPropertyNode *signal = fgGetNode("/sim/signals", true);
signal->setBoolValue(s, true);
- signal->removeChildren(s);
+ signal->removeChildren(s, false);
// Pull scripts out of the property tree, too
loadPropertyScripts();
if(n->hasChild("module"))
module = n->getStringValue("module");
- // allow multiple files to be specified within in a single
+ // allow multiple files to be specified within a single
// Nasal module tag
int j = 0;
SGPropertyNode *fn;
bool file_specified = false;
- while ( (fn = n->getChild("file", j)) != NULL ) {
+ while((fn = n->getChild("file", j)) != NULL) {
file_specified = true;
const char* file = fn->getStringValue();
SGPath p(globals->get_fg_root());
j++;
}
- // Old code which only allowed a single file to be specified per module
- /*
- const char* file = n->getStringValue("file");
- if(!n->hasChild("file")) file = 0; // Hrm...
- if(file) {
- SGPath p(globals->get_fg_root());
- p.append(file);
- loadModule(p, module);
- }
- */
-
const char* src = n->getStringValue("script");
if(!n->hasChild("script")) src = 0; // Hrm...
if(src)
// used to pass an associated property node to the module, which can then
// be accessed via cmdarg(). (This is, for example, used by XML dialogs.)
void FGNasalSys::createModule(const char* moduleName, const char* fileName,
- const char* src, int len, const SGPropertyNode* arg)
+ const char* src, int len,
+ const SGPropertyNode* cmdarg,
+ int argc, naRef* args)
{
naRef code = parse(fileName, src, len);
if(naIsNil(code))
if(!naHash_get(_globals, modname, &locals))
locals = naNewHash(_context);
- _cmdArg = (SGPropertyNode*)arg;
+ _cmdArg = (SGPropertyNode*)cmdarg;
- call(code, 0, 0, locals);
+ call(code, argc, args, locals);
hashset(_globals, moduleName, locals);
}
return naNil();
}
- int type = argc > 3 && naIsNum(args[3]) ? (int)args[3].num : 1;
+ int init = argc > 2 && naIsNum(args[2]) ? int(args[2].num) : 0;
+ int type = argc > 3 && naIsNum(args[3]) ? int(args[3].num) : 1;
FGNasalListener *nl = new FGNasalListener(node, code, this,
- gcSave(code), _listenerId, type);
+ gcSave(code), _listenerId, init, type);
- bool initial = argc > 2 && naTrue(args[2]);
- node->addChangeListener(nl, initial);
+ node->addChangeListener(nl, init);
_listener[_listenerId] = nl;
return naNum(_listenerId++);
// FGNasalListener class.
FGNasalListener::FGNasalListener(SGPropertyNode *node, naRef code,
- FGNasalSys* nasal, int key, int id, int type) :
+ FGNasalSys* nasal, int key, int id,
+ int init, int type) :
_node(node),
_code(code),
_gcKey(key),
_id(id),
_nas(nasal),
+ _init(init),
_type(type),
_active(0),
_dead(false),
- _first_call(true),
_last_int(0L),
_last_float(0.0)
{
+ if(_type == 0 && !_init)
+ changed(node);
}
FGNasalListener::~FGNasalListener()
arg[1] = _nas->propNodeGhost(_node);
arg[2] = mode; // value changed, child added/removed
arg[3] = naNum(_node != which); // child event?
- _nas->_cmdArg = _node;
_nas->call(_code, 4, arg, naNil());
_active--;
}
void FGNasalListener::valueChanged(SGPropertyNode* node)
{
if(_type < 2 && node != _node) return; // skip child events
- if(_type > 0 || changed(_node) || _first_call)
+ if(_type > 0 || changed(_node) || _init)
call(node, naNum(0));
- _first_call = false;
+ _init = 0;
}
void FGNasalListener::childAdded(SGPropertyNode*, SGPropertyNode* child)
bool FGNasalListener::changed(SGPropertyNode* node)
{
- SGPropertyNode::Type type = node->getType();
- if(type == SGPropertyNode::NONE) return false;
- if(type == SGPropertyNode::UNSPECIFIED) return true;
+ using namespace simgear;
+ props::Type type = node->getType();
+ if(type == props::NONE) return false;
+ if(type == props::UNSPECIFIED) return true;
bool result;
switch(type) {
- case SGPropertyNode::BOOL:
- case SGPropertyNode::INT:
- case SGPropertyNode::LONG:
+ case props::BOOL:
+ case props::INT:
+ case props::LONG:
{
long l = node->getLongValue();
result = l != _last_int;
_last_int = l;
return result;
}
- case SGPropertyNode::FLOAT:
- case SGPropertyNode::DOUBLE:
+ case props::FLOAT:
+ case props::DOUBLE:
{
double d = node->getDoubleValue();
result = d != _last_float;
// destructor the <unload> script. The latter happens when the model branch
// is removed from the scene graph.
+unsigned int FGNasalModelData::_module_id = 0;
+
void FGNasalModelData::modelLoaded(const string& path, SGPropertyNode *prop,
osg::Node *)
{
if(!prop)
return;
+ SGPropertyNode *nasal = prop->getNode("nasal");
+ if(!nasal)
+ return;
- SGPropertyNode *load = prop->getNode("load");
- _unload = prop->getNode("unload");
+ SGPropertyNode *load = nasal->getNode("load");
+ _unload = nasal->getNode("unload");
if(!load && !_unload)
return;
- _module = path;
- if(_props)
- _module += ':' + _props->getPath();
+ std::stringstream m;
+ m << "__model" << _module_id++;
+ _module = m.str();
+
const char *s = load ? load->getStringValue() : "";
- nasalSys->createModule(_module.c_str(), _module.c_str(), s, strlen(s), _props);
+
+ naRef arg[2];
+ arg[0] = nasalSys->propNodeGhost(_root);
+ arg[1] = nasalSys->propNodeGhost(prop);
+ nasalSys->createModule(_module.c_str(), path.c_str(), s, strlen(s),
+ _root, 2, arg);
}
FGNasalModelData::~FGNasalModelData()
if(_unload) {
const char *s = _unload->getStringValue();
- nasalSys->createModule(_module.c_str(), _module.c_str(), s, strlen(s), _props);
+ nasalSys->createModule(_module.c_str(), _module.c_str(), s, strlen(s), _root);
}
nasalSys->deleteModule(_module.c_str());
}
projects / flightgear.git / blobdiff