From c2226f6e3480c99306fe197b8aef63c9613e825b Mon Sep 17 00:00:00 2001
From: curt <curt>
Date: Sat, 26 Feb 2000 18:01:13 +0000
Subject: [PATCH] Added bfi.[ch]xx (Big Flat Interface) to give a consistant
 access point to shared state inside Flight Gear.

---
 src/Cockpit/panel.cxx | 334 ++++++-----------
 src/Cockpit/panel.hxx |  19 +-
 src/Main/Makefile.am  |   1 +
 src/Main/bfi.cxx      | 850 ++++++++++++++++++++++++++++++++++++++++++
 src/Main/bfi.hxx      | 152 ++++++++
 src/Main/save.cxx     | 280 ++++++--------
 6 files changed, 1247 insertions(+), 389 deletions(-)
 create mode 100644 src/Main/bfi.cxx
 create mode 100644 src/Main/bfi.hxx

diff --git a/src/Cockpit/panel.cxx b/src/Cockpit/panel.cxx
index 520e6ed51..d6b3d0065 100644
--- a/src/Cockpit/panel.cxx
+++ b/src/Cockpit/panel.cxx
@@ -35,6 +35,7 @@
 #include <simgear/debug/logstream.hxx>
 #include <simgear/misc/fgpath.hxx>
 #include <Main/options.hxx>
+#include <Main/bfi.hxx>
 #include <Objects/texload.h>
 #include <Autopilot/autopilot.hxx>
 #include <Time/fg_time.hxx>
@@ -60,120 +61,6 @@ extern fgAPDataPtr APDataGlobal;
 // or BFI (Big Friendly Interface).
 ////////////////////////////////////////////////////////////////////////
 
-/**
- * Return the indicated airspeed in knots.
- */
-static double
-panelGetSpeed ()
-{
-  return get_speed();
-}
-
-/**
- * Return the roll in degrees.
- */
-static double
-panelGetRoll ()
-{
-  return get_roll() * RAD_TO_DEG;
-}
-
-/**
- * Return the pitch in degrees.
- */
-static double
-panelGetPitch ()
-{
-  return get_pitch() * RAD_TO_DEG;
-}
-
-/**
- * Return the altitude in feet.
- */
-static double
-panelGetAltitude ()
-{
-  return get_altitude();
-}
-
-/**
- * Return the sideslip (units unknown).
- */
-static double
-panelGetSideSlip ()
-{
-  return get_sideslip();
-}
-
-/**
- * Return the heading in degrees.
- */
-static double
-panelGetHeading ()
-{
-  return get_heading();
-}
-
-/**
- * Return the current autopilot heading in degrees.
- */
-static double
-panelGetAPHeading ()
-{
-  return fgAPget_TargetHeading();
-}
-
-/**
- * Return the climb rate in feet/minute.
- */
-static double
-panelGetVerticalVelocity ()
-{
-  return get_climb_rate();
-}
-
-/**
- * Return the throttle setting (0.0 - 1.0).
- */
-static double
-panelGetThrottle ()
-{
-  return get_throttleval();
-}
-
-/**
- * Return the flaps setting (0.0 - 1.0).
- */
-static double
-panelGetFlaps ()
-{
-  return controls.get_flaps();
-}
-
-static double
-panelGetAileron ()
-{
-  return controls.get_aileron();
-}
-
-static double
-panelGetRudder ()
-{
-  return controls.get_rudder();
-}
-
-static double
-panelGetElevator ()
-{
-  return controls.get_elevator();
-}
-
-static double
-panelGetElevatorTrim ()
-{
-  return controls.get_elevator_trim();
-}
-
 static char * panelGetTime (char * buf)
 {
   struct tm * t = FGTime::cur_time_params->getGmt();
@@ -192,23 +79,29 @@ static char * panelGetTime (char * buf)
 // they're hard-coded.
 ////////////////////////////////////////////////////////////////////////
 
+static ssgTexture *
+createTexture (const char * relativePath)
+{
+  return FGPanel::OurPanel->createTexture(relativePath);
+}
+
 
 /**
  * Construct an airspeed indicator for a single-engine prop.
  */
 static FGPanelInstrument *
-makeAirspeedIndicator (int x, int y)
+createAirspeedIndicator (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 
 				// Layer 0: gauge background.
-  inst->addLayer(0, "Textures/Panel/airspeed.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/airspeed.rgb"));
 
 				// Layer 1: needle.
 				// Rotates with airspeed.
-  inst->addLayer(1, "Textures/Panel/long-needle.rgb");
+  inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
-			  panelGetSpeed,
+			  FGBFI::getAirspeed,
 			  30.0, 220.0, 36.0 / 20.0, -54.0);
   return inst;
 }
@@ -218,37 +111,37 @@ makeAirspeedIndicator (int x, int y)
  * Construct an artificial horizon.
  */
 static FGPanelInstrument *
-makeHorizon (int x, int y)
+createHorizon (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 
 				// Layer 0: coloured background
 				// moves with roll only
-  inst->addLayer(0, "Textures/Panel/horizon-bg.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/horizon-bg.rgb"));
   inst->addTransformation(0, FGInstrumentLayer::ROTATION,
-			  panelGetRoll,
+			  FGBFI::getRoll,
 			  -360.0, 360.0, -1.0, 0.0);
 
 				// Layer 1: floating horizon
 				// moves with roll and pitch
-  inst->addLayer(1, "Textures/Panel/horizon-float.rgb");
+  inst->addLayer(1, createTexture("Textures/Panel/horizon-float.rgb"));
   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
-			  panelGetRoll,
+			  FGBFI::getRoll,
 			  -360.0, 360.0, -1.0, 0.0);
   inst->addTransformation(1, FGInstrumentLayer::YSHIFT,
-			  panelGetPitch,
+			  FGBFI::getPitch,
 			  -20.0, 20.0, -(1.5 / 160.0) * SIX_W, 0.0);
 
 				// Layer 2: rim
 				// moves with roll only
-  inst->addLayer(2, "Textures/Panel/horizon-rim.rgb");
+  inst->addLayer(2, createTexture("Textures/Panel/horizon-rim.rgb"));
   inst->addTransformation(2, FGInstrumentLayer::ROTATION,
-			  panelGetRoll,
+			  FGBFI::getRoll,
 			  -360.0, 360.0, -1.0, 0.0);
 
 				// Layer 3: glass front of gauge
 				// fixed, with markings
-  inst->addLayer(3, "Textures/Panel/horizon-fg.rgb");
+  inst->addLayer(3, createTexture("Textures/Panel/horizon-fg.rgb"));
 
   return inst;
 }
@@ -258,32 +151,32 @@ makeHorizon (int x, int y)
  * Construct an altimeter.
  */
 static FGPanelInstrument *
-makeAltimeter (int x, int y)
+createAltimeter (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 
 				// Layer 0: gauge background
-  inst->addLayer(0, "Textures/Panel/altimeter.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/altimeter.rgb"));
 
 				// Layer 1: hundreds needle (long)
 				// moves with altitude
-  inst->addLayer(1, "Textures/Panel/long-needle.rgb");
+  inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
-			  panelGetAltitude,
+			  FGBFI::getAltitude,
 			  0.0, 100000.0, 360.0 / 1000.0, 0.0);
 
 				// Layer 2: thousands needle (short)
 				// moves with altitude
-  inst->addLayer(2, "Textures/Panel/short-needle.rgb");
+  inst->addLayer(2, createTexture("Textures/Panel/short-needle.rgb"));
   inst->addTransformation(2, FGInstrumentLayer::ROTATION,
-			  panelGetAltitude,
+			  FGBFI::getAltitude,
 			  0.0, 100000.0, 360.0 / 10000.0, 0.0);
 
 				// Layer 3: ten thousands bug (outside)
 				// moves with altitude
-  inst->addLayer(3, "Textures/Panel/bug.rgb");
+  inst->addLayer(3, createTexture("Textures/Panel/bug.rgb"));
   inst->addTransformation(3, FGInstrumentLayer::ROTATION,
-			  panelGetAltitude,
+			  FGBFI::getAltitude,
 			  0.0, 100000.0, 360.0 / 100000.0, 0.0);
 
   return inst;
@@ -294,25 +187,25 @@ makeAltimeter (int x, int y)
  * Construct a turn coordinator.
  */
 static FGPanelInstrument *
-makeTurnCoordinator (int x, int y)
+createTurnCoordinator (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 
 				// Layer 0: background
-  inst->addLayer(0, "Textures/Panel/turn-bg.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/turn-bg.rgb"));
 
 				// Layer 1: little plane
 				// moves with roll
-  inst->addLayer(1, "Textures/Panel/turn.rgb");
+  inst->addLayer(1, createTexture("Textures/Panel/turn.rgb"));
   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
-			  panelGetRoll,
+			  FGBFI::getRoll,
 			  -30.0, 30.0, 1.0, 0.0);
 
 				// Layer 2: little ball
 				// moves with slip/skid
-  inst->addLayer(2, "Textures/Panel/ball.rgb");
+  inst->addLayer(2, createTexture("Textures/Panel/ball.rgb"));
   inst->addTransformation(2, FGInstrumentLayer::ROTATION,
-			  panelGetSideSlip,
+			  FGBFI::getSideSlip,
 			  -0.1, 0.1, 450.0, 0.0);
 
   return inst;
@@ -323,29 +216,29 @@ makeTurnCoordinator (int x, int y)
  * Construct a gyro compass.
  */
 static FGPanelInstrument *
-makeGyroCompass (int x, int y)
+createGyroCompass (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 
 				// Layer 0: compass background
 				// rotates with heading
-  inst->addLayer(0, "Textures/Panel/gyro-bg.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
   inst->addTransformation(0, FGInstrumentLayer::ROTATION,
-			  panelGetHeading,
+			  FGBFI::getHeading,
 			  -360.0, 360.0, -1.0, 0.0);
 
 				// Layer 1: heading bug
 				// rotates with heading and AP heading
-  inst->addLayer(1, "Textures/Panel/bug.rgb");
+  inst->addLayer(1, createTexture("Textures/Panel/bug.rgb"));
   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
-			  panelGetHeading,
+			  FGBFI::getHeading,
 			  -360.0, 360.0, -1.0, 0.0);
   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
-			  panelGetAPHeading,
+			  FGBFI::getAPHeading,
 			  -360.0, 360.0, 1.0, 0.0);
 
 				// Layer 2: fixed center
-  inst->addLayer(2, "Textures/Panel/gyro-fg.rgb");
+  inst->addLayer(2, createTexture("Textures/Panel/gyro-fg.rgb"));
 
   return inst;
 }
@@ -355,18 +248,18 @@ makeGyroCompass (int x, int y)
  * Construct a vertical velocity indicator.
  */
 static FGPanelInstrument *
-makeVerticalVelocity (int x, int y)
+createVerticalVelocity (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 
 				// Layer 0: gauge background
-  inst->addLayer(0, "Textures/Panel/vertical.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/vertical.rgb"));
 
 				// Layer 1: needle
 				// moves with vertical velocity
-  inst->addLayer(1, "Textures/Panel/long-needle.rgb");
+  inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
-			  panelGetVerticalVelocity,
+			  FGBFI::getVerticalSpeed,
 			  -2000.0, 2000.0, 42.0/500.0, 270.0);
 
   return inst;
@@ -377,18 +270,18 @@ makeVerticalVelocity (int x, int y)
  * Construct an RPM gauge.
  */
 static FGPanelInstrument *
-makeRPMGauge (int x, int y)
+createRPMGauge (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
 
 				// Layer 0: gauge background
-  inst->addLayer(0, "Textures/Panel/rpm.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/rpm.rgb"));
 
 				// Layer 1: long needle
 				// FIXME: moves with throttle (for now)
-  inst->addLayer(1, "Textures/Panel/long-needle.rgb");
+  inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
-			  panelGetThrottle,
+			  FGBFI::getThrottle,
 			  0.0, 100.0, 300.0, -150.0);
 
   return inst;
@@ -399,32 +292,32 @@ makeRPMGauge (int x, int y)
  * Construct a flap position indicator.
  */
 static FGPanelInstrument *
-makeFlapIndicator (int x, int y)
+createFlapIndicator (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
 
 				// Layer 0: gauge background
-  inst->addLayer(0, "Textures/Panel/flaps.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/flaps.rgb"));
 
 				// Layer 1: long needle
 				// shifted over, rotates with flap position
-  inst->addLayer(1, "Textures/Panel/long-needle.rgb");
+  inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
   inst->addTransformation(1, FGInstrumentLayer::XSHIFT,
 			  -(SMALL_W / 4) + (SMALL_W / 16));
   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
-			  panelGetFlaps,
+			  FGBFI::getFlaps,
 			  0.0, 1.0, 120.0, 30.0);
 
   return inst;
 }
 
 static FGPanelInstrument *
-makeChronometer (int x, int y)
+createChronometer (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
 
 				// Layer 0: gauge background
-  inst->addLayer(0, "Textures/Panel/clock.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/clock.rgb"));
 
 				// Layer 1: text
 				// displays current GMT
@@ -445,42 +338,42 @@ makeChronometer (int x, int y)
  * Construct control-position indicators.
  */
 static FGPanelInstrument *
-makeControls (int x, int y)
+createControls (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
 
 				// Layer 0: gauge background
-  inst->addLayer(0, "Textures/Panel/controls.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/controls.rgb"));
 
 				// Layer 1: bug
 				// moves left-right with aileron
-  inst->addLayer(1, "Textures/Panel/bug.rgb");
-  inst->addTransformation(1, FGInstrumentLayer::XSHIFT, panelGetAileron,
+  inst->addLayer(1, createTexture("Textures/Panel/bug.rgb"));
+  inst->addTransformation(1, FGInstrumentLayer::XSHIFT, FGBFI::getAileron,
 			  -1.0, 1.0, SMALL_W * .75 / 2.0, 0.0);
 
 				// Layer 2: bug
 				// moves left-right with rudder
-  inst->addLayer(2, "Textures/Panel/bug.rgb");
+  inst->addLayer(2, createTexture("Textures/Panel/bug.rgb"));
   inst->addTransformation(2, FGInstrumentLayer::ROTATION, 180.0);
-  inst->addTransformation(2, FGInstrumentLayer::XSHIFT, panelGetRudder,
+  inst->addTransformation(2, FGInstrumentLayer::XSHIFT, FGBFI::getRudder,
 			  -1.0, 1.0, -SMALL_W * .75 / 2.0, 0.0);
 
 				// Layer 3: bug
 				// moves up-down with elevator trim
-  inst->addLayer(3, "Textures/Panel/bug.rgb");
+  inst->addLayer(3, createTexture("Textures/Panel/bug.rgb"));
   inst->addTransformation(3, FGInstrumentLayer::ROTATION, 270.0);
   inst->addTransformation(3, FGInstrumentLayer::YSHIFT,
 			  -SMALL_W * (3.0 / 8.0));
-  inst->addTransformation(3, FGInstrumentLayer::XSHIFT, panelGetElevatorTrim,
+  inst->addTransformation(3, FGInstrumentLayer::XSHIFT, FGBFI::getElevatorTrim,
 			  -1.0, 1.0, SMALL_W * .75 / 2.0, 0.0);
 
 				// Layer 4: bug
 				// moves up-down with elevator
-  inst->addLayer(4, "Textures/Panel/bug.rgb");
+  inst->addLayer(4, createTexture("Textures/Panel/bug.rgb"));
   inst->addTransformation(4, FGInstrumentLayer::ROTATION, 90.0);
   inst->addTransformation(4, FGInstrumentLayer::YSHIFT,
 			  -SMALL_W * (3.0 / 8.0));
-  inst->addTransformation(4, FGInstrumentLayer::XSHIFT, panelGetElevator,
+  inst->addTransformation(4, FGInstrumentLayer::XSHIFT, FGBFI::getElevator,
 			  -1.0, 1.0, -SMALL_W * .75 / 2.0, 0.0);
 
   return inst;
@@ -491,12 +384,12 @@ makeControls (int x, int y)
  * Construct a NAV1 gauge (dummy for now).
  */
 static FGPanelInstrument *
-makeNAV1 (int x, int y)
+createNAV1 (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 
 				// Layer 0: background
-  inst->addLayer(0, "Textures/Panel/gyro-bg.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
 
   return inst;
 }
@@ -506,12 +399,12 @@ makeNAV1 (int x, int y)
  * Construct a NAV2 gauge (dummy for now).
  */
 static FGPanelInstrument *
-makeNAV2 (int x, int y)
+createNAV2 (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 
 				// Layer 0: background
-  inst->addLayer(0, "Textures/Panel/gyro-bg.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
 
   return inst;
 }
@@ -521,12 +414,12 @@ makeNAV2 (int x, int y)
  * Construct an ADF gauge (dummy for now).
  */
 static FGPanelInstrument *
-makeADF (int x, int y)
+createADF (int x, int y)
 {
   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 
 				// Layer 0: background
-  inst->addLayer(0, "Textures/Panel/gyro-bg.rgb");
+  inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
 
   return inst;
 }
@@ -551,46 +444,44 @@ FGPanel::FGPanel ()
   int x = SIX_X;
   int y = SIX_Y;
 
-  FGPath tpath(current_options.get_fg_root());
-  tpath.append("Textures/Panel/panel-bg.rgb");
-  _bg = new ssgTexture((char *)tpath.c_str(), false, false);
+  _bg = createTexture("Textures/Panel/panel-bg.rgb");
 
 				// Chronometer alone at side
   x = SIX_X - SIX_SPACING - 8;
-  _instruments.push_back(makeChronometer(x, y));
+  _instruments.push_back(createChronometer(x, y));
 
 				// Top row
   x = SIX_X;
-  _instruments.push_back(makeAirspeedIndicator(x, y));
+  _instruments.push_back(createAirspeedIndicator(x, y));
   x += SIX_SPACING;
-  _instruments.push_back(makeHorizon(x, y));
+  _instruments.push_back(createHorizon(x, y));
   x += SIX_SPACING;
-  _instruments.push_back(makeAltimeter(x, y));
+  _instruments.push_back(createAltimeter(x, y));
   x += SIX_SPACING + 20;
-  _instruments.push_back(makeNAV1(x, y));
+  _instruments.push_back(createNAV1(x, y));
 
 				// Middle row
   x = SIX_X;
   y -= SIX_SPACING;
-  _instruments.push_back(makeTurnCoordinator(x, y));
+  _instruments.push_back(createTurnCoordinator(x, y));
   x += SIX_SPACING;
-  _instruments.push_back(makeGyroCompass(x, y));
+  _instruments.push_back(createGyroCompass(x, y));
   x += SIX_SPACING;
-  _instruments.push_back(makeVerticalVelocity(x, y));
+  _instruments.push_back(createVerticalVelocity(x, y));
   x += SIX_SPACING + 20;
-  _instruments.push_back(makeNAV2(x, y));
+  _instruments.push_back(createNAV2(x, y));
 
 				// Bottom row
   x = SIX_X;
   y -= SIX_SPACING + 10;
-  _instruments.push_back(makeControls(x, y));
+  _instruments.push_back(createControls(x, y));
   x += SIX_SPACING;
-  _instruments.push_back(makeFlapIndicator(x, y));
+  _instruments.push_back(createFlapIndicator(x, y));
   x += SIX_SPACING;
-  _instruments.push_back(makeRPMGauge(x, y));
+  _instruments.push_back(createRPMGauge(x, y));
   x += SIX_SPACING + 20;
   y += 10;
-  _instruments.push_back(makeADF(x, y));
+  _instruments.push_back(createADF(x, y));
 }
 
 FGPanel::~FGPanel ()
@@ -668,6 +559,24 @@ FGPanel::Update () const
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 }
 
+ssgTexture *
+FGPanel::createTexture (const char * relativePath)
+{
+  ssgTexture *texture;
+
+  texture = _textureMap[relativePath];
+  if (texture == 0) {
+    FGPath tpath(current_options.get_fg_root());
+    tpath.append(relativePath);
+    texture = new ssgTexture((char *)tpath.c_str(), false, false);
+    _textureMap[relativePath] = texture;
+    cerr << "Created texture " << relativePath
+	 << " handle=" << texture->getHandle() << endl;
+  }
+
+  return texture;
+}
+
 
 
 ////////////////////////////////////////////////////////////////////////
@@ -751,9 +660,9 @@ FGLayeredInstrument::addLayer (FGInstrumentLayer *layer)
 }
 
 void
-FGLayeredInstrument::addLayer (int layer, const char *textureName)
+FGLayeredInstrument::addLayer (int layer, ssgTexture * texture)
 {
-  addLayer(new FGTexturedInstrumentLayer(textureName, _w, _h, layer));
+  addLayer(new FGTexturedInstrumentLayer(texture, _w, _h, layer));
 }
 
 void
@@ -781,8 +690,8 @@ FGInstrumentLayer::FGInstrumentLayer (int w, int h, int z)
 
 FGInstrumentLayer::~FGInstrumentLayer ()
 {
-  transformation_list::iterator it;
-  transformation_list::iterator end;
+  transformation_list::iterator it = _transformations.begin();
+  transformation_list::iterator end = _transformations.end();
   while (it != end) {
     delete *it;
     it++;
@@ -843,12 +752,12 @@ FGInstrumentLayer::addTransformation (transform_type type,
 // Implementation of FGTexturedInstrumentLayer.
 ////////////////////////////////////////////////////////////////////////
 
-FGTexturedInstrumentLayer::FGTexturedInstrumentLayer (const char *tname,
-						      int w, int h, int z)
-  : FGInstrumentLayer(w, h, z)
-{
-  setTexture(tname);
-}
+// FGTexturedInstrumentLayer::FGTexturedInstrumentLayer (const char *tname,
+// 						      int w, int h, int z)
+//   : FGInstrumentLayer(w, h, z)
+// {
+//   setTexture(tname);
+// }
 
 FGTexturedInstrumentLayer::FGTexturedInstrumentLayer (ssgTexture * texture,
 						      int w, int h, int z)
@@ -881,15 +790,14 @@ FGTexturedInstrumentLayer::draw () const
   glPopMatrix();
 }
 
-void
-FGTexturedInstrumentLayer::setTexture (const char *textureName)
-{
-  FGPath tpath(current_options.get_fg_root());
-  tpath.append(textureName);
-  ssgTexture * texture = new ssgTexture((char *)tpath.c_str(), false, false);
-  cerr << "Loaded texture " << textureName << endl;
-  setTexture(texture);
-}
+// void
+// FGTexturedInstrumentLayer::setTexture (const char *textureName)
+// {
+//   FGPath tpath(current_options.get_fg_root());
+//   tpath.append(textureName);
+//   ssgTexture * texture = new ssgTexture((char *)tpath.c_str(), false, false);
+//   setTexture(texture);
+// }
 
 
 
diff --git a/src/Cockpit/panel.hxx b/src/Cockpit/panel.hxx
index 13e4f4aad..0f2910872 100644
--- a/src/Cockpit/panel.hxx
+++ b/src/Cockpit/panel.hxx
@@ -38,13 +38,14 @@
 #include <plib/ssg.h>
 
 #include <vector>
+#include <hash_map>
 #include <plib/fnt.h>
 
 FG_USING_STD(vector);
+FG_USING_STD(hash_map);
 
 class FGPanelInstrument;
 
-
 
 ////////////////////////////////////////////////////////////////////////
 // Instrument panel class.
@@ -54,11 +55,11 @@ class FGPanel
 {
 public:
 
-  typedef vector<FGPanelInstrument *> instrument_list_type;
-
   FGPanel ();
   virtual ~FGPanel ();
 
+  virtual ssgTexture * createTexture (const char * relativePath);
+
 				// Legacy interface from old panel.
   static FGPanel * OurPanel;
   virtual float get_height () const;
@@ -66,11 +67,18 @@ public:
   virtual void Update () const;
 
 private:
+
+  typedef vector<FGPanelInstrument *> instrument_list_type;
+
   int _x, _y, _w, _h;
   int _panel_h;
 
   ssgTexture * _bg;
 
+				// Internalization table.
+  hash_map<const char *,ssgTexture *> _textureMap;
+
+				// List of instruments in panel.
   instrument_list_type _instruments;
 };
 
@@ -173,7 +181,7 @@ public:
   virtual void draw () const;
 
   virtual void addLayer (FGInstrumentLayer *layer);
-  virtual void addLayer (int i, const char *textureName);
+  virtual void addLayer (int i, ssgTexture * texture);
   virtual void addTransformation (int layer,
 				  FGInstrumentLayer::transform_type type,
 				  FGInstrumentLayer::transform_func func,
@@ -205,15 +213,12 @@ protected:
 class FGTexturedInstrumentLayer : public FGInstrumentLayer
 {
 public:
-  FGTexturedInstrumentLayer (const char * textureName,
-			     int w, int h, int z);
   FGTexturedInstrumentLayer (ssgTexture * texture,
 			     int w, int h, int z);
   virtual ~FGTexturedInstrumentLayer ();
 
   virtual void draw () const;
 
-  virtual void setTexture (const char *textureName);
   virtual void setTexture (ssgTexture * texture) { _texture = texture; }
 
 private:
diff --git a/src/Main/Makefile.am b/src/Main/Makefile.am
index 338e18831..2e10ed8b3 100644
--- a/src/Main/Makefile.am
+++ b/src/Main/Makefile.am
@@ -32,6 +32,7 @@ bin_PROGRAMS = fgfs
 bin_SCRIPTS = runfgfs runfgfs.bat
 
 fgfs_SOURCES = \
+	bfi.cxx bfi.hxx \
 	fg_init.cxx fg_init.hxx \
 	fg_io.cxx fg_io.hxx \
 	keyboard.cxx keyboard.hxx \
diff --git a/src/Main/bfi.cxx b/src/Main/bfi.cxx
new file mode 100644
index 000000000..10978d791
--- /dev/null
+++ b/src/Main/bfi.cxx
@@ -0,0 +1,850 @@
+// bfi.cxx - Big Friendly Interface implementation
+//
+// Written by David Megginson, started February, 2000.
+//
+// Copyright (C) 2000  David Megginson - david@megginson.com
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#if defined( FG_HAVE_NATIVE_SGI_COMPILERS )
+#  include <iostream.h>
+#else
+#  include <iostream>
+#endif
+
+#include <simgear/constants.h>
+#include <simgear/math/fg_types.hxx>
+
+#include <Aircraft/aircraft.hxx>
+#include <Controls/controls.hxx>
+#include <Autopilot/autopilot.hxx>
+#include <Time/fg_time.hxx>
+#include <Astro/solarsystem.hxx>
+#ifndef FG_OLD_WEATHER
+#  include <WeatherCM/FGLocalWeatherDatabase.h>
+#else
+#  include <Weather/weather.hxx>
+#endif
+
+#include "options.hxx"
+#include "save.hxx"
+#include "fg_init.hxx"
+
+FG_USING_NAMESPACE(std);
+
+				// FIXME: these are not part of the
+				// published interface!!!
+extern fgAPDataPtr APDataGlobal;
+extern void fgAPAltitudeSet (double new_altitude);
+extern void fgAPHeadingSet (double new_heading);
+
+
+#include "bfi.hxx"
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Static variables.
+////////////////////////////////////////////////////////////////////////
+
+bool FGBFI::_needReinit = false;
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Local functions
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Reinitialize FGFS if required.
+ *
+ * Some changes (especially those in aircraft position) require that
+ * FGFS be reinitialized afterwards.  Rather than reinitialize after
+ * every change, the setter methods simply set a flag so that there
+ * can be a single reinit at the end of the frame.
+ */
+void
+FGBFI::update ()
+{
+  if (_needReinit) {
+    reinit();
+  }
+}
+
+
+/**
+ * Reinitialize FGFS to use the new BFI settings.
+ */
+void
+FGBFI::reinit ()
+{
+				// Save the state of everything
+				// that's going to get clobbered
+				// when we reinit the subsystems.
+
+				// TODO: add more AP stuff
+  double elevator = getElevator();
+  double aileron = getAileron();
+  double rudder = getRudder();
+  double throttle = getThrottle();
+  double elevator_trim = getElevatorTrim();
+  double flaps = getFlaps();
+  double brake = getBrake();
+  bool apHeadingLock = getAPHeadingLock();
+  double apHeading = getAPHeading();
+  bool apAltitudeLock = getAPAltitudeLock();
+  double apAltitude = getAPAltitude();
+  const string &targetAirport = getTargetAirport();
+  bool gpsLock = getGPSLock();
+  double gpsLatitude = getGPSTargetLatitude();
+  double gpsLongitude = getGPSTargetLongitude();
+
+  fgReInitSubsystems();
+  solarSystemRebuild();
+  cur_light_params.Update();
+
+				// Restore all of the old states.
+  setElevator(elevator);
+  setAileron(aileron);
+  setRudder(rudder);
+  setThrottle(throttle);
+  setElevatorTrim(elevator_trim);
+  setFlaps(flaps);
+  setBrake(brake);
+  setAPHeadingLock(apHeadingLock);
+  setAPHeading(apHeading);
+  setAPAltitudeLock(apAltitudeLock);
+  setAPAltitude(apAltitude);
+  setTargetAirport(targetAirport);
+  setGPSLock(gpsLock);
+  setGPSTargetLatitude(gpsLatitude);
+  setGPSTargetLongitude(gpsLongitude);
+
+  _needReinit = false;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Simulation.
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Return the flight model as an integer.
+ *
+ * TODO: use a string instead.
+ */
+int
+FGBFI::getFlightModel ()
+{
+  return current_options.get_flight_model();
+}
+
+
+/**
+ * Set the flight model as an integer.
+ *
+ * TODO: use a string instead.
+ */
+void
+FGBFI::setFlightModel (int model)
+{
+  current_options.set_flight_model(model);
+  needReinit();
+}
+
+
+/**
+ * Return the current Zulu time.
+ */
+time_t
+FGBFI::getTimeGMT ()
+{
+				// FIXME: inefficient
+  return mktime(FGTime::cur_time_params->getGmt());
+}
+
+
+/**
+ * Set the current Zulu time.
+ */
+void
+FGBFI::setTimeGMT (time_t time)
+{
+				// FIXME: need to update lighting
+				// and solar system
+  current_options.set_time_offset(time);
+  current_options.set_time_offset_type(fgOPTIONS::FG_TIME_GMT_ABSOLUTE);
+  FGTime::cur_time_params->init(*cur_fdm_state);
+  FGTime::cur_time_params->update(*cur_fdm_state);
+  needReinit();
+}
+
+
+/**
+ * Return true if the HUD is visible.
+ */
+bool
+FGBFI::getHUDVisible ()
+{
+  return current_options.get_hud_status();
+}
+
+
+/**
+ * Ensure that the HUD is visible or hidden.
+ */
+void
+FGBFI::setHUDVisible (bool visible)
+{
+  current_options.set_hud_status(visible);
+}
+
+
+/**
+ * Return true if the 2D panel is visible.
+ */
+bool
+FGBFI::getPanelVisible ()
+{
+  return current_options.get_panel_status();
+}
+
+
+/**
+ * Ensure that the 2D panel is visible or hidden.
+ */
+void
+FGBFI::setPanelVisible (bool visible)
+{
+  if (current_options.get_panel_status() != visible) {
+    current_options.toggle_panel();
+  }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Position
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Return the current latitude in degrees (negative for south).
+ */
+double
+FGBFI::getLatitude ()
+{
+  return current_aircraft.fdm_state->get_Latitude() * RAD_TO_DEG;
+}
+
+
+/**
+ * Set the current latitude in degrees (negative for south).
+ */
+void
+FGBFI::setLatitude (double latitude)
+{
+  current_options.set_lat(latitude);
+  needReinit();
+}
+
+
+/**
+ * Return the current longitude in degrees (negative for west).
+ */
+double
+FGBFI::getLongitude ()
+{
+  return current_aircraft.fdm_state->get_Longitude() * RAD_TO_DEG;
+}
+
+
+/**
+ * Set the current longitude in degrees (negative for west).
+ */
+void
+FGBFI::setLongitude (double longitude)
+{
+  current_options.set_lon(longitude);
+  needReinit();
+}
+
+
+/**
+ * Return the current altitude in feet.
+ */
+double
+FGBFI::getAltitude ()
+{
+  return current_aircraft.fdm_state->get_Altitude();
+}
+
+
+/**
+ * Set the current altitude in feet.
+ */
+void
+FGBFI::setAltitude (double altitude)
+{
+  current_options.set_altitude(altitude * FEET_TO_METER);
+  needReinit();
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Attitude
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Return the current heading in degrees.
+ */
+double
+FGBFI::getHeading ()
+{
+  return current_aircraft.fdm_state->get_Psi() * RAD_TO_DEG;
+}
+
+
+/**
+ * Set the current heading in degrees.
+ */
+void
+FGBFI::setHeading (double heading)
+{
+  current_options.set_heading(heading);
+  needReinit();
+}
+
+
+/**
+ * Return the current pitch in degrees.
+ */
+double
+FGBFI::getPitch ()
+{
+  return current_aircraft.fdm_state->get_Theta() * RAD_TO_DEG;
+}
+
+
+/**
+ * Set the current pitch in degrees.
+ */
+void
+FGBFI::setPitch (double pitch)
+{
+
+  current_options.set_pitch(pitch);
+  needReinit();
+}
+
+
+/**
+ * Return the current roll in degrees.
+ */
+double
+FGBFI::getRoll ()
+{
+  return current_aircraft.fdm_state->get_Phi() * RAD_TO_DEG;
+}
+
+
+/**
+ * Set the current roll in degrees.
+ */
+void
+FGBFI::setRoll (double roll)
+{
+  current_options.set_roll(roll);
+  needReinit();
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Velocities
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Return the current airspeed in knots.
+ */
+double
+FGBFI::getAirspeed ()
+{
+				// FIXME: should we add speed-up?
+  return current_aircraft.fdm_state->get_V_calibrated_kts();
+}
+
+
+/**
+ * Return the current sideslip (FIXME: units unknown).
+ */
+double
+FGBFI::getSideSlip ()
+{
+  return current_aircraft.fdm_state->get_Beta();
+}
+
+
+/**
+ * Return the current climb rate in feet/second (FIXME: verify).
+ */
+double
+FGBFI::getVerticalSpeed ()
+{
+				// What about meters?
+  return current_aircraft.fdm_state->get_Climb_Rate() * 60.0;
+}
+
+
+/**
+ * Get the current north velocity (units??).
+ */
+double
+FGBFI::getSpeedNorth ()
+{
+  return current_aircraft.fdm_state->get_V_north();
+}
+
+
+/**
+ * Set the current north velocity (units??).
+ */
+void
+FGBFI::setSpeedNorth (double speed)
+{
+  current_options.set_uBody(speed);
+  needReinit();
+}
+
+
+/**
+ * Get the current east velocity (units??).
+ */
+double
+FGBFI::getSpeedEast ()
+{
+  return current_aircraft.fdm_state->get_V_east();
+}
+
+
+/**
+ * Set the current east velocity (units??).
+ */
+void
+FGBFI::setSpeedEast (double speed)
+{
+  current_options.set_vBody(speed);
+  needReinit();
+}
+
+
+/**
+ * Get the current down velocity (units??).
+ */
+double
+FGBFI::getSpeedDown ()
+{
+  return current_aircraft.fdm_state->get_V_down();
+}
+
+
+/**
+ * Set the current down velocity (units??).
+ */
+void
+FGBFI::setSpeedDown (double speed)
+{
+  current_options.set_wBody(speed);
+  needReinit();
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Controls
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Get the throttle setting, from 0.0 (none) to 1.0 (full).
+ */
+double
+FGBFI::getThrottle ()
+{
+				// FIXME: add throttle selector
+  return controls.get_throttle(0);
+}
+
+
+/**
+ * Set the throttle, from 0.0 (none) to 1.0 (full).
+ */
+void
+FGBFI::setThrottle (double throttle)
+{
+				// FIXME: allow throttle selection
+				// FIXME: clamp?
+  controls.set_throttle(0, throttle);
+}
+
+
+/**
+ * Get the flaps setting, from 0.0 (none) to 1.0 (full).
+ */
+double
+FGBFI::getFlaps ()
+{
+  return controls.get_flaps();
+}
+
+
+/**
+ * Set the flaps, from 0.0 (none) to 1.0 (full).
+ */
+void
+FGBFI::setFlaps (double flaps)
+{
+				// FIXME: clamp?
+  controls.set_flaps(flaps);
+}
+
+
+/**
+ * Get the aileron, from -1.0 (left) to 1.0 (right).
+ */
+double
+FGBFI::getAileron ()
+{
+  return controls.get_aileron();
+}
+
+
+/**
+ * Set the aileron, from -1.0 (left) to 1.0 (right).
+ */
+void
+FGBFI::setAileron (double aileron)
+{
+				// FIXME: clamp?
+  controls.set_aileron(aileron);
+}
+
+
+/**
+ * Get the rudder setting, from -1.0 (left) to 1.0 (right).
+ */
+double
+FGBFI::getRudder ()
+{
+  return controls.get_rudder();
+}
+
+
+/**
+ * Set the rudder, from -1.0 (left) to 1.0 (right).
+ */
+void
+FGBFI::setRudder (double rudder)
+{
+				// FIXME: clamp?
+  controls.set_rudder(rudder);
+}
+
+
+/**
+ * Get the elevator setting, from -1.0 (down) to 1.0 (up).
+ */
+double
+FGBFI::getElevator ()
+{
+  return controls.get_elevator();
+}
+
+
+/**
+ * Set the elevator, from -1.0 (down) to 1.0 (up).
+ */
+void
+FGBFI::setElevator (double elevator)
+{
+				// FIXME: clamp?
+  controls.set_elevator(elevator);
+}
+
+
+/**
+ * Get the elevator trim, from -1.0 (down) to 1.0 (up).
+ */
+double
+FGBFI::getElevatorTrim ()
+{
+  return controls.get_elevator_trim();
+}
+
+
+/**
+ * Set the elevator trim, from -1.0 (down) to 1.0 (up).
+ */
+void
+FGBFI::setElevatorTrim (double trim)
+{
+				// FIXME: clamp?
+  controls.set_elevator_trim(trim);
+}
+
+
+/**
+ * Get the brake setting, from 0.0 (none) to 1.0 (full).
+ */
+double
+FGBFI::getBrake ()
+{
+				// FIXME: add brake selector
+  return controls.get_brake(0);
+}
+
+
+/**
+ * Set the brake, from 0.0 (none) to 1.0 (full).
+ */
+void
+FGBFI::setBrake (double brake)
+{
+				// FIXME: clamp?
+				// FIXME: allow brake selection
+  controls.set_brake(0, brake);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Autopilot
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Get the autopilot altitude lock (true=on).
+ */
+bool
+FGBFI::getAPAltitudeLock ()
+{
+  return fgAPAltitudeEnabled();
+}
+
+
+/**
+ * Set the autopilot altitude lock (true=on).
+ */
+void
+FGBFI::setAPAltitudeLock (bool lock)
+{
+  APDataGlobal->altitude_hold = lock;
+}
+
+
+/**
+ * Get the autopilot target altitude in feet.
+ */
+double
+FGBFI::getAPAltitude ()
+{
+  return fgAPget_TargetAltitude() * METER_TO_FEET;
+}
+
+
+/**
+ * Set the autopilot target altitude in feet.
+ */
+void
+FGBFI::setAPAltitude (double altitude)
+{
+  fgAPAltitudeSet(altitude);
+}
+
+
+/**
+ * Get the autopilot heading lock (true=on).
+ */
+bool
+FGBFI::getAPHeadingLock ()
+{
+  return fgAPHeadingEnabled();
+}
+
+
+/**
+ * Set the autopilot heading lock (true=on).
+ */
+void
+FGBFI::setAPHeadingLock (bool lock)
+{
+  APDataGlobal->heading_hold = lock;
+}
+
+
+/**
+ * Get the autopilot target heading in degrees.
+ */
+double
+FGBFI::getAPHeading ()
+{
+  return fgAPget_TargetHeading();
+}
+
+
+/**
+ * Set the autopilot target heading in degrees.
+ */
+void
+FGBFI::setAPHeading (double heading)
+{
+  fgAPHeadingSet(heading);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// GPS
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Get the autopilot GPS lock (true=on).
+ */
+bool
+FGBFI::getGPSLock ()
+{
+  return fgAPWayPointEnabled();
+}
+
+
+/**
+ * Set the autopilot GPS lock (true=on).
+ */
+void
+FGBFI::setGPSLock (bool lock)
+{
+  APDataGlobal->waypoint_hold = lock;
+}
+
+
+/**
+ * Get the GPS target airport code.
+ */
+const string
+FGBFI::getTargetAirport ()
+{
+  return current_options.get_airport_id();
+}
+
+
+/**
+ * Set the GPS target airport code.
+ */
+void
+FGBFI::setTargetAirport (const string &airportId)
+{
+  current_options.set_airport_id(airportId);
+}
+
+
+/**
+ * Get the GPS target latitude in degrees (negative for south).
+ */
+double
+FGBFI::getGPSTargetLatitude ()
+{
+  return fgAPget_TargetLatitude();
+}
+
+
+/**
+ * Set the GPS target latitude in degrees (negative for south).
+ */
+void
+FGBFI::setGPSTargetLatitude (double latitude)
+{
+  APDataGlobal->TargetLatitude = latitude;
+}
+
+
+/**
+ * Get the GPS target longitude in degrees (negative for west).
+ */
+double
+FGBFI::getGPSTargetLongitude ()
+{
+  return fgAPget_TargetLongitude();
+}
+
+
+/**
+ * Set the GPS target longitude in degrees (negative for west).
+ */
+void
+FGBFI::setGPSTargetLongitude (double longitude)
+{
+  APDataGlobal->TargetLongitude = longitude;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Weather
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Get the current visible (units??).
+ */
+double
+FGBFI::getVisibility ()
+{
+#ifndef FG_OLD_WEATHER
+  return WeatherDatabase->getWeatherVisibility();
+#else
+  return current_weather.get_visibility();
+#endif
+}
+
+
+/**
+ * Set the current visibility (units??).
+ */
+void
+FGBFI::setVisibility (double visibility)
+{
+#ifndef FG_OLD_WEATHER
+  WeatherDatabase->setWeatherVisibility(visibility);
+#else
+  current_weather.set_visibility(visibility);
+#endif
+}
+
+
+// end of bfi.cxx
diff --git a/src/Main/bfi.hxx b/src/Main/bfi.hxx
new file mode 100644
index 000000000..8828f7c85
--- /dev/null
+++ b/src/Main/bfi.hxx
@@ -0,0 +1,152 @@
+// bfi.hxx - Big Flat Interface
+//
+// Written by David Megginson, started February, 2000.
+//
+// Copyright (C) 2000  David Megginson - david@megginson.com
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// $Id$
+
+#include <time.h>
+#include <string>
+
+FG_USING_NAMESPACE(std);
+
+
+/**
+ * Big Flat Interface
+ *
+ * This class implements the Facade design pattern (GOF p.185) to provide
+ * a single, (deceptively) simple flat interface for the FlightGear
+ * subsystems.  
+ *
+ * To help cut down on interdependence, subsystems should
+ * use the BFI whenever possible for inter-system communication.
+ *
+ * TODO:
+ * - add selectors to switch the current plane, throttle, brake, etc.
+ * - add more autopilot settings
+ */
+class FGBFI
+{
+public:
+
+				// Reinit if necessary.
+  static void update ();
+
+				// Simulation
+  static int getFlightModel ();
+  static time_t getTimeGMT ();
+  static bool getHUDVisible ();
+  static bool getPanelVisible ();
+
+  static void setFlightModel (int flightModel);
+  static void setTimeGMT (time_t time);
+  static void setHUDVisible (bool hudVisible);
+  static void setPanelVisible (bool panelVisible);
+
+
+				// Position
+  static double getLatitude ();
+  static double getLongitude ();
+  static double getAltitude ();
+
+  static void setLatitude (double latitude);
+  static void setLongitude (double longitude);
+  static void setAltitude (double altitude);
+
+
+				// Attitude
+  static double getHeading ();
+  static double getPitch ();
+  static double getRoll ();
+
+  static void setHeading (double heading);
+  static void setPitch (double pitch);
+  static void setRoll (double roll);
+
+
+				// Velocities
+  static double getAirspeed ();
+  static double getSideSlip ();
+  static double getVerticalSpeed ();
+  static double getSpeedNorth ();
+  static double getSpeedEast ();
+  static double getSpeedDown ();
+
+  static void setSpeedNorth (double speed);
+  static void setSpeedEast (double speed);
+  static void setSpeedDown (double speed);
+
+
+				// Controls
+  static double getThrottle ();
+  static double getFlaps ();
+  static double getAileron ();
+  static double getRudder ();
+  static double getElevator ();
+  static double getElevatorTrim ();
+  static double getBrake ();
+
+  static void setThrottle (double throttle);
+  static void setFlaps (double flaps);
+  static void setAileron (double aileron);
+  static void setRudder (double rudder);
+  static void setElevator (double elevator);
+  static void setElevatorTrim (double trim);
+  static void setBrake (double brake);
+
+
+				// Autopilot
+  static bool getAPAltitudeLock ();
+  static double getAPAltitude ();
+  static bool getAPHeadingLock ();
+  static double getAPHeading ();
+
+  static void setAPAltitudeLock (bool lock);
+  static void setAPAltitude (double altitude);
+  static void setAPHeadingLock (bool lock);
+  static void setAPHeading (double heading);
+
+
+				// GPS
+  static const string getTargetAirport ();
+  static bool getGPSLock ();
+  static double getGPSTargetLatitude ();
+  static double getGPSTargetLongitude ();
+
+  static void setTargetAirport (const string &targetAirport);
+  static void setGPSLock (bool lock);
+  static void setGPSTargetLatitude (double latitude);
+  static void setGPSTargetLongitude (double longitude);
+
+
+				// Weather
+  static double getVisibility ();
+
+  static void setVisibility (double visiblity);
+
+
+private:
+				// Will cause a linking error if invoked.
+  FGBFI ();
+
+  static void reinit ();
+  static void needReinit () { _needReinit = true; }
+  static bool _needReinit;
+};
+
+// end of bfi.hxx
diff --git a/src/Main/save.cxx b/src/Main/save.cxx
index a6f1d4184..11cf679ad 100644
--- a/src/Main/save.cxx
+++ b/src/Main/save.cxx
@@ -22,10 +22,6 @@
 
 
 /*
-CHANGES:
-- time is now working
-- autopilot is working (even with GPS)
-
 TODO:
 - use a separate options object so that we can roll back on error
 - use proper FGFS logging
@@ -41,28 +37,10 @@ TODO:
 #include <simgear/constants.h>
 #include <simgear/math/fg_types.hxx>
 
-#include <Aircraft/aircraft.hxx>
-#include <Controls/controls.hxx>
-#include <Autopilot/autopilot.hxx>
-#include <Time/fg_time.hxx>
-#ifndef FG_OLD_WEATHER
-#  include <WeatherCM/FGLocalWeatherDatabase.h>
-#else
-#  include <Weather/weather.hxx>
-#endif
-
-#include "options.hxx"
-#include "save.hxx"
-#include "fg_init.hxx"
+#include "bfi.hxx"
 
 FG_USING_NAMESPACE(std);
 
-				// FIXME: these are not part of the
-				// published interface!!!
-extern fgAPDataPtr APDataGlobal;
-extern void fgAPAltitudeSet (double new_altitude);
-extern void fgAPHeadingSet (double new_heading);
-
 #define SAVE(name, value) { output << name << ": " << value << endl; }
 
 /**
@@ -71,80 +49,72 @@ extern void fgAPHeadingSet (double new_heading);
 bool
 fgSaveFlight (ostream &output)
 {
-  char tb[100];
-  const FGInterface * f = current_aircraft.fdm_state;
-  struct tm *t = FGTime::cur_time_params->getGmt();
-
   output << "#!fgfs" << endl;
 
   //
   // Simulation
   //
-  SAVE("flight-model", current_options.get_flight_model());
-  SAVE("time", mktime(t));
-  SAVE("hud", current_options.get_hud_status());
-  SAVE("panel", current_options.get_panel_status());
+  SAVE("flight-model", FGBFI::getFlightModel());
+  SAVE("time", FGBFI::getTimeGMT());
+  SAVE("hud", FGBFI::getHUDVisible());
+  SAVE("panel", FGBFI::getPanelVisible());
 
   // 
   // Location
   //
-  SAVE("latitude", (f->get_Latitude() * RAD_TO_DEG));
-  SAVE("longitude", (f->get_Longitude() * RAD_TO_DEG));
-  SAVE("altitude", f->get_Altitude());
+  SAVE("latitude", FGBFI::getLatitude());
+  SAVE("longitude", FGBFI::getLongitude());
+  SAVE("altitude", FGBFI::getAltitude());
 
   //
   // Orientation
   //
-  SAVE("heading", (f->get_Psi() * RAD_TO_DEG));
-  SAVE("pitch", (f->get_Theta() * RAD_TO_DEG));
-  SAVE("roll", (f->get_Phi() * RAD_TO_DEG));
+  SAVE("heading", FGBFI::getHeading());
+  SAVE("pitch", FGBFI::getPitch());
+  SAVE("roll", FGBFI::getRoll());
 
   //
   // Velocities
   //
-  SAVE("speed-north", f->get_V_north());
-  SAVE("speed-east", f->get_V_east());
-  SAVE("speed-down", f->get_V_down());
+  SAVE("speed-north", FGBFI::getSpeedNorth());
+  SAVE("speed-east", FGBFI::getSpeedEast());
+  SAVE("speed-down", FGBFI::getSpeedDown());
 
   //
   // Primary controls
   //
-  SAVE("elevator", controls.get_elevator());
-  SAVE("aileron", controls.get_aileron());
-  SAVE("rudder", controls.get_rudder());
+  SAVE("elevator", FGBFI::getElevator());
+  SAVE("aileron", FGBFI::getAileron());
+  SAVE("rudder", FGBFI::getRudder());
 				// FIXME: save each throttle separately
-  SAVE("throttle", controls.get_throttle(0));
+  SAVE("throttle", FGBFI::getThrottle());
 
   //
   // Secondary controls
   //
-  SAVE("elevator-trim", controls.get_elevator_trim());
-  SAVE("flaps", controls.get_flaps());
+  SAVE("elevator-trim", FGBFI::getElevatorTrim());
+  SAVE("flaps", FGBFI::getFlaps());
 				// FIXME: save each brake separately
-  SAVE("brake", controls.get_brake(0));
+  SAVE("brake", FGBFI::getBrake());
 
   //
   // Navigation.
   //
-  if (current_options.get_airport_id().length() > 0) {
-    SAVE("target-airport", current_options.get_airport_id());
+  if (FGBFI::getTargetAirport().length() > 0) {
+    SAVE("target-airport", FGBFI::getTargetAirport());
   }
-  SAVE("autopilot-altitude-lock", fgAPAltitudeEnabled());
-  SAVE("autopilot-altitude", fgAPget_TargetAltitude() * METER_TO_FEET);
-  SAVE("autopilot-heading-lock", fgAPHeadingEnabled());
-  SAVE("autopilot-heading", fgAPget_TargetHeading());
-  SAVE("autopilot-gps-lock", fgAPWayPointEnabled());
-  SAVE("autopilot-gps-lat", fgAPget_TargetLatitude());
-  SAVE("autopilot-gps-lon", fgAPget_TargetLongitude());
+  SAVE("autopilot-altitude-lock", FGBFI::getAPAltitudeLock());
+  SAVE("autopilot-altitude", FGBFI::getAPAltitude());
+  SAVE("autopilot-heading-lock", FGBFI::getAPHeadingLock());
+  SAVE("autopilot-heading", FGBFI::getAPHeading());
+  SAVE("autopilot-gps-lock", FGBFI::getGPSLock());
+  SAVE("autopilot-gps-lat", FGBFI::getGPSTargetLatitude());
+  SAVE("autopilot-gps-lon", FGBFI::getGPSTargetLongitude());
 
   //
   // Environment.
   //
-#ifndef FG_OLD_WEATHER
-  SAVE("visibility", WeatherDatabase->getWeatherVisibility());
-#else
-  SAVE("visibility", current_weather.get_visibility());
-#endif
+  SAVE("visibility", FGBFI::getVisibility());
 
   return true;
 }
@@ -156,32 +126,11 @@ fgSaveFlight (ostream &output)
 bool
 fgLoadFlight (istream &input)
 {
-  FGInterface * f = current_aircraft.fdm_state;
+//   FGInterface * f = current_aircraft.fdm_state;
   string text;
   double n;
   long int i;
 
-  double elevator = controls.get_elevator();
-  double aileron = controls.get_aileron();
-  double rudder = controls.get_rudder();
-  double throttle = controls.get_throttle(0);
-  double elevator_trim = controls.get_elevator_trim();
-  double flaps = controls.get_flaps();
-  double brake =  controls.get_brake(FGControls::ALL_WHEELS);
-
-  bool ap_heading_lock = false;
-  double ap_heading = 0;
-  bool ap_altitude_lock = false;
-  double ap_altitude = 0;
-  bool ap_gps_lock = false;
-  double ap_gps_lat = 0;
-  double ap_gps_lon = 0;
-
-  string airport_id = current_options.get_airport_id();
-  current_options.set_airport_id("");
-  current_options.set_time_offset(0);
-  current_options.set_time_offset_type(fgOPTIONS::FG_TIME_GMT_OFFSET);
-
   if (!input.good() || input.eof()) {
     cout << "Stream is no good!\n";
     return false;
@@ -189,7 +138,7 @@ fgLoadFlight (istream &input)
 
   input >> text;
   if (text != "#!fgfs") {
-    printf("Bad save file format!\n");
+    cerr << "Bad save file format!\n";
     return false;
   }
 
@@ -204,30 +153,25 @@ fgLoadFlight (istream &input)
     if (text == "flight-model:") {
       input >> i;
       cout << "flight model is " << i << endl;
-      current_options.set_flight_model(i);
+      FGBFI::setFlightModel(i);
     }
 
     else if (text == "time:") {
       input >> i;
       cout << "saved time is " << i << endl;
-      current_options.set_time_offset(i);
-      current_options.set_time_offset_type(fgOPTIONS::FG_TIME_GMT_ABSOLUTE);
-      FGTime::cur_time_params->init(*cur_fdm_state);
-      FGTime::cur_time_params->update(*cur_fdm_state);
+      FGBFI::setTimeGMT(i);
     }
 
     else if (text == "hud:") {
       input >> i;
       cout << "hud status is " << i << endl;
-      current_options.set_hud_status(i);
+      FGBFI::setHUDVisible(i);
     }
 
     else if (text == "panel:") {
       input >> i;
       cout << "panel status is " << i << endl;
-      if (current_options.get_panel_status() != i) {
-	current_options.toggle_panel();
-      }
+      FGBFI::setPanelVisible(i);
     }
 
     //
@@ -237,15 +181,19 @@ fgLoadFlight (istream &input)
     else if (text == "latitude:") {
       input >> n;
       cout << "latitude is " << n << endl;
-      current_options.set_lat(n);
-    } else if (text == "longitude:") {
+      FGBFI::setLatitude(n);
+    } 
+
+    else if (text == "longitude:") {
       input >> n;
       cout << "longitude is " << n << endl;
-      current_options.set_lon(n);
-    } else if (text == "altitude:") {
+      FGBFI::setLongitude(n);
+    } 
+
+    else if (text == "altitude:") {
       input >> n;
       cout << "altitude is " << n << endl;
-      current_options.set_altitude(n * FEET_TO_METER);
+      FGBFI::setAltitude(n);
     } 
 
     //
@@ -255,15 +203,19 @@ fgLoadFlight (istream &input)
     else if (text == "heading:") {
       input >> n;
       cout << "heading is " << n << endl;
-      current_options.set_heading(n);
-    } else if (text == "pitch:") {
+      FGBFI::setHeading(n);
+    } 
+
+    else if (text == "pitch:") {
       input >> n;
       cout << "pitch is " << n << endl;
-      current_options.set_pitch(n);
-    } else if (text == "roll:") {
+      FGBFI::setPitch(n);
+    } 
+
+    else if (text == "roll:") {
       input >> n;
       cout << "roll is " << n << endl;
-      current_options.set_roll(n);
+      FGBFI::setRoll(n);
     } 
 
     //
@@ -273,15 +225,19 @@ fgLoadFlight (istream &input)
     else if (text == "speed-north:") {
       input >> n;
       cout << "speed north is " << n << endl;
-      current_options.set_uBody(n);
-    } else if (text == "speed-east:") {
+      FGBFI::setSpeedNorth(n);
+    } 
+
+    else if (text == "speed-east:") {
       input >> n;
       cout << "speed east is " << n << endl;
-      current_options.set_vBody(n);
-    } else if (text == "speed-down:") {
+      FGBFI::setSpeedEast(n);
+    } 
+
+    else if (text == "speed-down:") {
       input >> n;
       cout << "speed down is " << n << endl;
-      current_options.set_wBody(n);
+      FGBFI::setSpeedDown(n);
     } 
 
     //
@@ -289,42 +245,49 @@ fgLoadFlight (istream &input)
     //
 
     else if (text == "elevator:") {
-      input >> elevator;
-      cout << "elevator is " << elevator << endl;
+      input >> n;
+      cout << "elevator is " << n << endl;
+      FGBFI::setElevator(n);
     }
 
     else if (text == "aileron:") {
-      input >> aileron;
-      cout << "aileron is " << aileron << endl;
+      input >> n;
+      cout << "aileron is " << n << endl;
+      FGBFI::setAileron(n);
     }
 
     else if (text == "rudder:") {
-      input >> rudder;
-      cout << "rudder is " << rudder << endl;
+      input >> n;
+      cout << "rudder is " << n << endl;
+      FGBFI::setRudder(n);
     }
 
 				// FIXME: assumes single engine
     else if (text == "throttle:") {
-      input >> throttle;
-      cout << "throttle is " << throttle << endl;
+      input >> n;
+      cout << "throttle is " << n << endl;
+      FGBFI::setThrottle(n);
     }
 
     //
     // Secondary controls
 
     else if (text == "elevator-trim:") {
-      input >> elevator_trim;
-      cout << "elevator trim is " << elevator_trim << endl;
+      input >> n;
+      cout << "elevator trim is " << n << endl;
+      FGBFI::setElevatorTrim(n);
     }
 
     else if (text == "flaps:") {
-      input >> flaps;
-      cout << "flaps are " << flaps << endl;
+      input >> n;
+      cout << "flaps are " << n << endl;
+      FGBFI::setFlaps(n);
     }
 
     else if (text == "brake:") {
-      input >> brake;
-      cout << "brake is " << brake << endl;
+      input >> n;
+      cout << "brake is " << n << endl;
+      FGBFI::setBrake(n);
     }
 
     //
@@ -332,41 +295,51 @@ fgLoadFlight (istream &input)
     //
 
     else if (text == "target-airport:") {
-      input >> airport_id;
-      cout << "target airport is " << airport_id << endl;
+      input >> text;
+      cout << "target airport is " << text << endl;
+      FGBFI::setTargetAirport(text);
     }
 
     else if (text == "autopilot-altitude-lock:") {
-      input >> ap_altitude_lock;
-      cout << "autopilot altitude lock is " << ap_altitude_lock << endl;
+      input >> i;
+      cout << "autopilot altitude lock is " << i << endl;
+      FGBFI::setAPAltitudeLock(i);
     }
 
     else if (text == "autopilot-altitude:") {
-      input >> ap_altitude;
-      cout << "autopilot altitude is " << ap_altitude << endl;
+      input >> n;
+      cout << "autopilot altitude is " << n << endl;
+      FGBFI::setAPAltitude(n);
     }
 
     else if (text == "autopilot-heading-lock:") {
-      input >> ap_heading_lock;
-      cout << "autopilot heading lock is " << ap_heading_lock << endl;
+      input >> i;
+      cout << "autopilot heading lock is " << i << endl;
+      FGBFI::setAPHeadingLock(i);
     }
 
     else if (text == "autopilot-heading:") {
-      input >> ap_heading;
-      cout << "autopilot heading is " << ap_heading << endl;
+      input >> n;
+      cout << "autopilot heading is " << n << endl;
+      FGBFI::setAPHeading(n);
     }
 
     else if (text == "autopilot-gps-lock:") {
-      input >> ap_gps_lock;
-      cout << "autopilot GPS lock is " << ap_gps_lock << endl;
+      input >> i;
+      cout << "autopilot GPS lock is " << i << endl;
+      FGBFI::setGPSLock(i);
     }
 
     else if (text == "autopilot-gps-lat:") {
-      input >> ap_gps_lat;
+      input >> n;
+      cout << "GPS target latitude is " << n << endl;
+      FGBFI::setGPSTargetLatitude(n);
     }
 
     else if (text == "autopilot-gps-lon:") {
-      input >> ap_gps_lon;
+      input >> n;
+      cout << "GPS target longitude is " << n << endl;
+      FGBFI::setGPSTargetLongitude(n);
     }
 
     //
@@ -376,12 +349,7 @@ fgLoadFlight (istream &input)
     else if (text == "visibility:") {
       input >> n;
       cout << "visibility is " << n << endl;
-      
-#ifndef FG_OLD_WEATHER
-      WeatherDatabase->setWeatherVisibility(n);
-#else
-      current_weather.set_visibility(n);
-#endif
+      FGBFI::setVisibility(n);
     }
 
     //
@@ -394,33 +362,7 @@ fgLoadFlight (istream &input)
     }
   }
 
-  fgReInitSubsystems();
-
-				// Set airport and controls after the
-				// re-init.
-  current_options.set_airport_id(airport_id);
-
-				// The controls have to be set after
-				// the reinit
-  controls.set_elevator(elevator);
-  controls.set_aileron(aileron);
-  controls.set_rudder(rudder);
-  controls.set_throttle(FGControls::ALL_ENGINES, throttle);
-  controls.set_elevator_trim(elevator_trim);
-  controls.set_flaps(flaps);
-  controls.set_brake(FGControls::ALL_WHEELS, brake);
-
-				// Ditto for the autopilot.
-				// FIXME: shouldn't have to use
-				// APDataGlobal.
-  APDataGlobal->heading_hold = ap_heading_lock;
-  APDataGlobal->altitude_hold = ap_altitude_lock;
-  fgAPHeadingSet(ap_heading);
-  fgAPAltitudeSet(ap_altitude);
-				// GPS overrides heading
-  APDataGlobal->waypoint_hold = ap_gps_lock;
-  APDataGlobal->TargetLatitude = ap_gps_lat;
-  APDataGlobal->TargetLongitude = ap_gps_lon;
+  FGBFI::update();
 
   return true;
 }
-- 
2.39.5