delete cur;
}
}
+
+// delete legs
+ BOOST_FOREACH(Leg* l, _legs) {
+ delete l;
+ }
}
FlightPlan* FlightPlan::clone(const string& newIdent) const
}
if ((index < 0) || (index >= numLegs())) {
- SG_LOG(SG_AUTOPILOT, SG_WARN, "removeAtIndex with invalid index:" << aIndex);
+ SG_LOG(SG_NAVAID, SG_WARN, "removeAtIndex with invalid index:" << aIndex);
return;
}
}
_legs.clear();
+ if (_delegate) {
+ _delegate->runCleared();
+ }
unlockDelegate();
}
++count;
}
}
+
+ // test if the current leg will be removed
+ bool currentIsBeingCleared = false;
+ Leg* curLeg = currentLeg();
+ if (curLeg) {
+ currentIsBeingCleared = curLeg->waypoint()->flag(flag);
+ }
_currentIndex -= count;
+
+ // if we're clearing the current waypoint, what shall we do with the
+ // index? there's various options, but safest is to select no waypoint
+ // and let the use re-activate.
+ // http://code.google.com/p/flightgear-bugs/issues/detail?id=1134
+ if (currentIsBeingCleared) {
+ SG_LOG(SG_GENERAL, SG_INFO, "currentIsBeingCleared:" << currentIsBeingCleared);
+ _currentIndex = -1;
+ }
// now delete and remove
RemoveWithFlag rf(flag);
lockDelegate();
_waypointsChanged = true;
- if (count > 0) {
+ if ((count > 0) || currentIsBeingCleared) {
_currentWaypointChanged = true;
}
_legs.erase(it, _legs.end());
+
+ if (_legs.empty()) { // maybe all legs were deleted
+ if (_delegate) {
+ _delegate->runCleared();
+ }
+ }
+
unlockDelegate();
return rf.numDeleted();
}
_currentWaypointChanged = true;
unlockDelegate();
}
+
+void FlightPlan::finish()
+{
+ if (_currentIndex == -1) {
+ return;
+ }
+
+ lockDelegate();
+ _currentIndex = -1;
+ _currentWaypointChanged = true;
+
+ if (_delegate) {
+ _delegate->runFinished();
+ }
+
+ unlockDelegate();
+}
int FlightPlan::findWayptIndex(const SGGeod& aPos) const
{
bool FlightPlan::save(const SGPath& path)
{
- SG_LOG(SG_IO, SG_INFO, "Saving route to " << path.str());
+ SG_LOG(SG_NAVAID, SG_INFO, "Saving route to " << path.str());
try {
SGPropertyNode_ptr d(new SGPropertyNode);
d->setIntValue("version", 2);
writeProperties(path.str(), d, true /* write-all */);
return true;
} catch (sg_exception& e) {
- SG_LOG(SG_IO, SG_ALERT, "Failed to save flight-plan '" << path.str() << "'. " << e.getMessage());
+ SG_LOG(SG_NAVAID, SG_ALERT, "Failed to save flight-plan '" << path.str() << "'. " << e.getMessage());
return false;
}
}
{
if (!path.exists())
{
- SG_LOG(SG_IO, SG_ALERT, "Failed to load flight-plan '" << path.str()
+ SG_LOG(SG_NAVAID, SG_ALERT, "Failed to load flight-plan '" << path.str()
<< "'. The file does not exist.");
return false;
}
SGPropertyNode_ptr routeData(new SGPropertyNode);
- SG_LOG(SG_IO, SG_INFO, "going to read flight-plan from:" << path.str());
+ SG_LOG(SG_NAVAID, SG_INFO, "going to read flight-plan from:" << path.str());
bool Status = false;
lockDelegate();
}
Status = true;
} catch (sg_exception& e) {
- SG_LOG(SG_IO, SG_ALERT, "Failed to load flight-plan '" << e.getOrigin()
+ SG_LOG(SG_NAVAID, SG_ALERT, "Failed to load flight-plan '" << e.getOrigin()
<< "'. " << e.getMessage());
Status = false;
}
string depIdent = dep->getStringValue("airport");
setDeparture((FGAirport*) fgFindAirportID(depIdent));
if (_departure) {
- if (dep->hasChild("runway")) {
- setDeparture(_departure->getRunwayByIdent(dep->getStringValue("runway")));
+ string rwy(dep->getStringValue("runway"));
+ if (_departure->hasRunwayWithIdent(rwy)) {
+ setDeparture(_departure->getRunwayByIdent(rwy));
}
if (dep->hasChild("sid")) {
if (dst) {
setDestination((FGAirport*) fgFindAirportID(dst->getStringValue("airport")));
if (_destination) {
- if (dst->hasChild("runway")) {
- setDestination(_destination->getRunwayByIdent(dst->getStringValue("runway")));
+ string rwy(dst->getStringValue("runway"));
+ if (_destination->hasRunwayWithIdent(rwy)) {
+ setDestination(_destination->getRunwayByIdent(rwy));
}
if (dst->hasChild("star")) {
} else {
string nid = aWP->getStringValue("navid", ident.c_str());
FGPositionedRef p = FGPositioned::findClosestWithIdent(nid, lastPos);
- if (!p) {
- throw sg_io_exception("bad route file, unknown navid:" + nid);
+ SGGeod pos;
+
+ if (p) {
+ pos = p->geod();
+ } else {
+ SG_LOG(SG_GENERAL, SG_WARN, "unknown navaid in flightplan:" << nid);
+ pos = SGGeod::fromDeg(aWP->getDoubleValue("longitude-deg"),
+ aWP->getDoubleValue("latitude-deg"));
}
- SGGeod pos(p->geod());
if (aWP->hasChild("offset-nm") && aWP->hasChild("offset-radial")) {
double radialDeg = aWP->getDoubleValue("offset-radial");
// convert magnetic radial to a true radial!
radialDeg += magvarDegAt(pos);
double offsetNm = aWP->getDoubleValue("offset-nm");
double az2;
- SGGeodesy::direct(p->geod(), radialDeg, offsetNm * SG_NM_TO_METER, pos, az2);
+ SGGeodesy::direct(pos, radialDeg, offsetNm * SG_NM_TO_METER, pos, az2);
}
w = new BasicWaypt(pos, ident, NULL);
_legs.push_back(new Leg(this, w));
} // of line iteration
} catch (sg_exception& e) {
- SG_LOG(SG_IO, SG_ALERT, "Failed to load route from: '" << path.str() << "'. " << e.getMessage());
+ SG_LOG(SG_NAVAID, SG_ALERT, "Failed to load route from: '" << path.str() << "'. " << e.getMessage());
_legs.clear();
return false;
}
string_list pieces(simgear::strutils::split(target, "/"));
FGPositionedRef p = FGPositioned::findClosestWithIdent(pieces.front(), basePosition);
if (!p) {
- SG_LOG( SG_AUTOPILOT, SG_INFO, "Unable to find FGPositioned with ident:" << pieces.front());
+ SG_LOG( SG_NAVAID, SG_INFO, "Unable to find FGPositioned with ident:" << pieces.front());
return NULL;
}
} else if (pieces.size() == 2) {
FGAirport* apt = dynamic_cast<FGAirport*>(p.ptr());
if (!apt) {
- SG_LOG(SG_AUTOPILOT, SG_INFO, "Waypoint is not an airport:" << pieces.front());
+ SG_LOG(SG_NAVAID, SG_INFO, "Waypoint is not an airport:" << pieces.front());
return NULL;
}
if (!apt->hasRunwayWithIdent(pieces[1])) {
- SG_LOG(SG_AUTOPILOT, SG_INFO, "No runway: " << pieces[1] << " at " << pieces[0]);
+ SG_LOG(SG_NAVAID, SG_INFO, "No runway: " << pieces[1] << " at " << pieces[0]);
return NULL;
}
// navid/radial/navid/radial notation
FGPositionedRef p2 = FGPositioned::findClosestWithIdent(pieces[2], basePosition);
if (!p2) {
- SG_LOG( SG_AUTOPILOT, SG_INFO, "Unable to find FGPositioned with ident:" << pieces[2]);
+ SG_LOG( SG_NAVAID, SG_INFO, "Unable to find FGPositioned with ident:" << pieces[2]);
return NULL;
}
SGGeod intersection;
bool ok = SGGeodesy::radialIntersection(p->geod(), r1, p2->geod(), r2, intersection);
if (!ok) {
- SG_LOG(SG_AUTOPILOT, SG_INFO, "no valid intersection for:" << target);
+ SG_LOG(SG_NAVAID, SG_INFO, "no valid intersection for:" << target);
return NULL;
}
}
if (!wpt) {
- SG_LOG(SG_AUTOPILOT, SG_INFO, "Unable to parse waypoint:" << target);
+ SG_LOG(SG_NAVAID, SG_INFO, "Unable to parse waypoint:" << target);
return NULL;
}
}
}
+SGGeod FlightPlan::pointAlongRoute(int aIndex, double aOffsetNm) const
+{
+ if (aIndex >= (int) _legs.size()) {
+ throw sg_range_exception();
+ }
+
+ const int lastLeg = static_cast<int>(_legs.size()) - 1;
+// convert the relative offset and leg index into an absolute, positive
+// distance in nm from the route origin. This means we can simply walk
+// forwards to find the actual leg.
+ Leg* leg = _legs[(aIndex >= 0) ? aIndex : lastLeg];
+ double absolutePathDistance = leg->_distanceAlongPath + aOffsetNm;
+ if (absolutePathDistance < 0.0) {
+ return _legs[0]->waypoint()->position(); // begining of route
+ }
+
+ if (absolutePathDistance > _totalDistance) {
+ return _legs[lastLeg]->waypoint()->position(); // end of route
+ }
+
+// find the leg containing the absolute distance
+ for (int l=0; l<lastLeg; ++l) {
+ leg = _legs[l];
+ if (absolutePathDistance < leg->_pathDistance) {
+ break; // found our matching leg
+ }
+ absolutePathDistance -= leg->_pathDistance;
+ } // of forwards walk along route to find leg
+
+ return SGGeodesy::direct(leg->waypoint()->position(),
+ leg->_courseDeg, absolutePathDistance * SG_NM_TO_METER);
+}
+
void FlightPlan::lockDelegate()
{
if (_delegateLock == 0) {
_deleteWithPlan(false),
_inner(NULL)
{
-
}
FlightPlan::Delegate::~Delegate()
-{
-
+{
}
void FlightPlan::Delegate::removeInner(Delegate* d)
{
if (!_inner) {
- return;
+ throw sg_exception("FlightPlan delegate not found");
}
if (_inner == d) {
if (_inner) _inner->runCurrentWaypointChanged();
currentWaypointChanged();
}
-
+
+void FlightPlan::Delegate::runCleared()
+{
+ if (_inner) _inner->runCleared();
+ cleared();
+}
+
+void FlightPlan::Delegate::runFinished()
+{
+ if (_inner) _inner->runFinished();
+ endOfFlightPlan();
+}
+
} // of namespace flightgear
projects / flightgear.git / blobdiff