From a9b592c7e978510b8b7047e17dbf0307da544789 Mon Sep 17 00:00:00 2001
From: curt <curt>
Date: Wed, 12 May 1999 02:04:38 +0000
Subject: [PATCH] HUD format changed contributed by Norman Vine.

---
 Simulator/Cockpit/Makefile.am  |    1 +
 Simulator/Cockpit/cockpit.cxx  |  594 +++++++++++++++---
 Simulator/Cockpit/cockpit.hxx  |   50 +-
 Simulator/Cockpit/hud.cxx      | 1030 +++++++++++++++++++++-----------
 Simulator/Cockpit/hud.hxx      |  457 ++++++++++----
 Simulator/Cockpit/hud_card.cxx |  438 +++++++++-----
 Simulator/Cockpit/hud_dnst.cxx |    4 +-
 Simulator/Cockpit/hud_guag.cxx |  273 +++++----
 Simulator/Cockpit/hud_inst.cxx |    4 +-
 Simulator/Cockpit/hud_labl.cxx |   84 ++-
 Simulator/Cockpit/hud_ladr.cxx |  549 +++++++++--------
 Simulator/Cockpit/hud_scal.cxx |   14 +-
 Simulator/Cockpit/hud_tbi.cxx  |  203 +++----
 Simulator/Cockpit/panel.cxx    |  548 +++++++++--------
 Simulator/Cockpit/panel.hxx    |  319 +++++-----
 15 files changed, 2866 insertions(+), 1702 deletions(-)

diff --git a/Simulator/Cockpit/Makefile.am b/Simulator/Cockpit/Makefile.am
index 4066624e6..9d30fa66b 100644
--- a/Simulator/Cockpit/Makefile.am
+++ b/Simulator/Cockpit/Makefile.am
@@ -5,6 +5,7 @@ libCockpit_a_SOURCES = \
 	hud.cxx hud.hxx \
 	hud_card.cxx hud_dnst.cxx hud_guag.cxx hud_inst.cxx \
 	hud_labl.cxx hud_ladr.cxx \
+	hud_lat.cxx hud_lon.cxx \
 	hud_scal.cxx hud_tbi.cxx \
 	panel.cxx panel.hxx
 
diff --git a/Simulator/Cockpit/cockpit.cxx b/Simulator/Cockpit/cockpit.cxx
index 1fddd8f0f..bd0c53989 100644
--- a/Simulator/Cockpit/cockpit.cxx
+++ b/Simulator/Cockpit/cockpit.cxx
@@ -47,11 +47,10 @@
 #include <Math/mat3.h>
 #include <Math/polar3d.hxx>
 #include <Scenery/scenery.hxx>
-#include <Time/fg_time.hxx>
 #include <Time/fg_timer.hxx>
+#include <Time/fg_time.hxx>
 
 #include "cockpit.hxx"
-#include "panel.hxx"
 
 
 // This is a structure that contains all data related to
@@ -62,42 +61,69 @@ static pCockpit ac_cockpit;
 // The following routines obtain information concerntin the aircraft's
 // current state and return it to calling instrument display routines.
 // They should eventually be member functions of the aircraft.
+//
 
-double get_latitude( void )
+float get_latitude( void )
 {
-    return (double)((int)(current_aircraft.fdm_state->get_Latitude()*RAD_TO_DEG));
-}
+//  FGState *f;
+    double lat;
+    
+//  current_aircraft.fdm_state
+
+    lat = current_aircraft.fdm_state->get_Latitude() * RAD_TO_DEG;
+
+    float flat = lat;
+    return(flat);
 
-double get_lat_min( void )
+//  if(fabs(lat)<1.0)
+//  {
+//      if(lat<0)
+//          return( -(double)((int)lat) );
+//      else
+//          return( (double)((int)lat) );
+//  }
+//  return( (double)((int)lat) );
+}
+float get_lat_min( void )
 {
-    double a, d;
+//  FGState *f;
+    double      a, d;
 
-    a = current_aircraft.fdm_state->get_Latitude() * RAD_TO_DEG;	
+//  current_aircraft.fdm_state
+    
+    a = current_aircraft.fdm_state->get_Latitude() * RAD_TO_DEG;    
     if (a < 0.0) {
-	a = -a;
+        a = -a;
     }
     d = (double) ( (int) a);
-    return( (a - d) * 60.0);
+    float lat_min = (a - d) * 60.0;
+    return(lat_min );
 }
 
-double get_longitude( void )
-{
-    return( (double)((int) (current_aircraft.fdm_state->get_Longitude()
-			    * RAD_TO_DEG)) );
-}
 
-double get_long_min( void )
+float get_longitude( void )
 {
-    double  a, d;
+    double lon;
+//  FGState *f;
     
-    a = current_aircraft.fdm_state->get_Longitude() * RAD_TO_DEG;	
-    if (a < 0.0) {
-	a = -a;
-    }
-    d = (double) ( (int) a);
-    return( (a - d) * 60.0);
+//  current_aircraft.fdm_state
+
+    lon = current_aircraft.fdm_state->get_Longitude() * RAD_TO_DEG;
+
+    float flon = lon;
+    return(flon);
+    
+//  if(fabs(lon)<1.0)
+//  {
+//      if(lon<0)
+//          return( -(double)((int)lon) );
+//      else
+//          return( (double)((int)lon) );
+//  }
+//  return( (double)((int)lon) );
 }
 
+
 char*
 get_formated_gmt_time( void )
 {
@@ -105,124 +131,454 @@ get_formated_gmt_time( void )
     FGTime *t = FGTime::cur_time_params;
     const struct tm *p = t->getGmt();
     sprintf( buf, "%d/%d/%2d %d:%02d:%02d", 
-	     p->tm_mon+1, p->tm_mday, p->tm_year,
-	     p->tm_hour, p->tm_min, p->tm_sec);
+         p->tm_mon+1, p->tm_mday, p->tm_year,
+         p->tm_hour, p->tm_min, p->tm_sec);
     return buf;
 }
 
 
-double get_throttleval( void )
+float get_long_min( void )
+{
+//  FGState *f;
+    double  a, d;
+
+//  current_aircraft.fdm_state
+    
+    a = current_aircraft.fdm_state->get_Longitude() * RAD_TO_DEG;   
+    if (a < 0.0) {
+        a = -a;
+    }
+    d = (double) ( (int) a);
+    float lon_min = (a - d) * 60.0; 
+    return(lon_min);
+}
+
+float get_throttleval( void )
 {
-    return controls.get_throttle( 0 );     // Hack limiting to one engine
+    float throttle = controls.get_throttle( 0 );
+    return (throttle);     // Hack limiting to one engine
 }
 
-double get_aileronval( void )
+float get_aileronval( void )
 {
-    return controls.get_aileron();
+    float aileronval = controls.get_aileron();
+    return (aileronval);
 }
 
-double get_elevatorval( void )
+float get_elevatorval( void )
 {
-    return controls.get_elevator();
+    float elevator_val = (float)controls.get_elevator();
+    return elevator_val;
 }
 
-double get_elev_trimval( void )
+float get_elev_trimval( void )
 {
-    return controls.get_elevator_trim();
+    float elevatorval = controls.get_elevator_trim();
+    return (elevatorval);
 }
 
-double get_rudderval( void )
+float get_rudderval( void )
 {
-    return controls.get_rudder();
+    float rudderval = controls.get_rudder();
+    return (rudderval);
 }
 
-double get_speed( void )
+float get_speed( void )
 {
-    return( current_aircraft.fdm_state->get_V_equiv_kts() );
+    // Make an explicit function call.
+    float speed = current_aircraft.fdm_state->get_V_equiv_kts();
+    return( speed );
 }
 
-double get_aoa( void )
+float get_aoa( void )
 {
-    return( current_aircraft.fdm_state->get_Alpha() * RAD_TO_DEG );
+    float aoa = current_aircraft.fdm_state->get_Alpha() * RAD_TO_DEG;
+    return( aoa );
 }
 
-double get_roll( void )
+float get_roll( void )
 {
-    return( current_aircraft.fdm_state->get_Phi() );
+    float roll = current_aircraft.fdm_state->get_Phi();
+    return( roll );
 }
 
-double get_pitch( void )
+float get_pitch( void )
 {
-    return( current_aircraft.fdm_state->get_Theta() );
+    float pitch = current_aircraft.fdm_state->get_Theta();
+    return( pitch );
 }
 
-double get_heading( void )
+float get_heading( void )
 {
-    return( current_aircraft.fdm_state->get_Psi() * RAD_TO_DEG );
+    float heading = (current_aircraft.fdm_state->get_Psi() * RAD_TO_DEG);
+    return( heading );
 }
 
-double get_altitude( void )
+float get_altitude( void )
 {
+//  FGState *f;
+    // double rough_elev;
+
+//  current_aircraft.fdm_state
+    // rough_elev = mesh_altitude(f->get_Longitude() * RAD_TO_ARCSEC,
+    //                         f->get_Latitude()  * RAD_TO_ARCSEC);
+    float altitude;
+
     if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
-	return current_aircraft.fdm_state->get_Altitude();
+        altitude = current_aircraft.fdm_state->get_Altitude();
     } else {
-	return current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER;
+        altitude = (current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER);
     }
+    return altitude;
 }
 
-double get_agl( void )
+float get_agl( void )
 {
+//  FGState *f;
+
+//  f = current_aircraft.fdm_state;
+
+    float agl;
+
     if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
-	return current_aircraft.fdm_state->get_Altitude()
-	    - scenery.cur_elev * METER_TO_FEET;
+        agl = (current_aircraft.fdm_state->get_Altitude()
+               - scenery.cur_elev * METER_TO_FEET);
     } else {
-	return current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER
-	    - scenery.cur_elev;
+        agl = (current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER
+               - scenery.cur_elev);
     }
+    return agl;
+}
+
+float get_sideslip( void )
+{
+//  FGState *f;
+        
+//  f = current_aircraft.fdm_state;
+    float sideslip = current_aircraft.fdm_state->get_Beta();
+        
+    return( sideslip );
 }
 
-double get_sideslip( void )
+float get_frame_rate( void )
 {
-    return( current_aircraft.fdm_state->get_Beta() );
+    float frame_rate = general.get_frame_rate();
+    return (frame_rate); 
 }
 
-double get_frame_rate( void )
+float get_fov( void )
 {
-    return (double) general.get_frame_rate();
+    float fov = current_options.get_fov(); 
+    return (fov);
 }
 
-double get_fov( void )
+float get_vfc_ratio( void )
 {
-    return (current_options.get_fov()); 
+    float vfc = current_view.get_vfc_ratio();
+    return (vfc);
 }
 
-double get_vfc_ratio( void )
+float get_vfc_tris_drawn   ( void )
 {
-    return current_view.get_vfc_ratio();
+    float rendered = current_view.get_tris_rendered();
+    return (rendered);
 }
 
-double get_vfc_tris_drawn   ( void )
+float get_vfc_tris_culled   ( void )
 {
-    return current_view.get_tris_rendered();
+    float culled = current_view.get_tris_culled();
+    return (culled);
 }
 
-double get_climb_rate( void )
+float get_climb_rate( void )
 {
+//  FGState *f;
+
+//  current_aircraft.fdm_state
+
+    float climb_rate;
     if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
-	return current_aircraft.fdm_state->get_Climb_Rate() * 60.0;
+        climb_rate = current_aircraft.fdm_state->get_Climb_Rate() * 60.0;
     } else {
-	return current_aircraft.fdm_state->get_Climb_Rate()
-	    * FEET_TO_METER * 60.0;
+        climb_rate = current_aircraft.fdm_state->get_Climb_Rate() * FEET_TO_METER * 60.0;
     }
+    return (climb_rate);
 }
 
 
+float get_view_direction( void )
+{
+//  FGState *f;
+
+
+//    FGView *pview;
+    double view;
+ 
+//    pview = &current_view;
+//  current_aircraft.fdm_state
+
+    view = FG_2PI - current_view.get_view_offset();
+
+    view = ( current_aircraft.fdm_state->get_Psi() + view) * RAD_TO_DEG;
+    if(view > 360.)
+        view -= 360.;
+    else if(view<0.)
+        view += 360.;
+    float fview = view;
+    return( fview );
+}
+
+#ifdef NOT_USED
+/****************************************************************************/
+/* Convert degrees to dd mm'ss.s" (DMS-Format)                              */
+/****************************************************************************/
+char *dmshh_format(double degrees)
+{
+    static char buf[16];    
+    int deg_part;
+    int min_part;
+    double sec_part;
+    
+    if (degrees < 0)
+      degrees = -degrees;
+
+    deg_part = degrees;
+    min_part = 60.0 * (degrees - deg_part);
+    sec_part = 3600.0 * (degrees - deg_part - min_part / 60.0);
+
+    /* Round off hundredths */
+    if (sec_part + 0.005 >= 60.0)
+      sec_part -= 60.0, min_part += 1;
+    if (min_part >= 60)
+      min_part -= 60, deg_part += 1;
+
+    sprintf(buf,"%02d*%02d\'%05.2f\"",deg_part,min_part,sec_part);
+
+    return buf;
+}
+#endif // 0
+
+/****************************************************************************/
+/* Convert degrees to dd mm'ss.s'' (DMS-Format)                              */
+/****************************************************************************/
+static char *toDMS(float a)
+{
+  int        neg = 0;
+  float       d, m, s;
+  static char  dms[16];
+
+  if (a < 0.0f) {
+    a   = -a;
+    neg = 1;
+  }
+  d = (float) ((int) a); 
+  a = (a - d) * 60.0f;
+  m = (float) ((int) a);
+  s = (a - m) * 60.0f;
+  
+  if (s > 59.5f) {
+    s  = 0.0f;
+    m += 1.0f;
+  }
+  if (m > 59.5f) {
+    m  = 0.0f;
+    d += 1.0f;
+  }
+  if (neg)
+    d = -d;
+  
+  sprintf(dms, "%.0f*%02.0f'%04.1f\"", d, m, s);
+  return dms;
+}
+
+
+/****************************************************************************/
+/* Convert degrees to dd mm.mmm' (DMM-Format)                               */
+/****************************************************************************/
+static char *toDM(float a)
+{
+  int        neg = 0;
+  float       d, m;
+  static char  dm[16];
+  
+  if (a < 0.0f) {
+    a = -a;
+    neg = 1;
+  }
+
+  d = (float) ( (int) a);
+  m = (a - d) * 60.0f;
+  
+  if (m > 59.5f) {
+    m  = 0.0f;
+    d += 1.0f;
+  }
+  if (neg) d = -d;
+  
+  sprintf(dm, "%.0f*%06.3f'", d, m);
+  return dm;
+}
+
+static char *(*fgLatLonFormat)(float);
+
+char *coord_format_lat(float latitude)
+{
+    static char buf[16];
+
+    sprintf(buf,"%s%c",
+//      dmshh_format(latitude),
+//      toDMS(latitude),
+//      toDM(latitude),
+        fgLatLonFormat(latitude),           
+        latitude > 0 ? 'N' : 'S');
+    return buf;
+}
+
+char *coord_format_lon(float longitude)
+{
+    static char buf[80];
+
+    sprintf(buf,"%s%c",
+//      dmshh_format(longitude),
+//      toDMS(longitude),
+//      toDM(longitude),
+        fgLatLonFormat(longitude),
+        longitude > 0 ? 'E' : 'W');
+    return buf;
+}
+
+void fgLatLonFormatToggle( puObject *)
+{
+    static int toggle = 0;
+
+    if ( toggle ) 
+        fgLatLonFormat = toDM;
+    else
+        fgLatLonFormat = toDMS;
+    
+    toggle = ~toggle;
+}
+
+#ifdef NOT_USED
+char *coord_format_latlon(double latitude, double longitude)
+{
+    static char buf[1024];
+
+    sprintf(buf,"%s%c %s%c",
+        dmshh_format(latitude),
+        latitude > 0 ? 'N' : 'S',
+        dmshh_format(longitude),
+        longitude > 0 ? 'E' : 'W');
+    return buf;
+}
+#endif
+
+#ifdef FAST_TEXT_TEST
+#undef FAST_TEXT_TEST
+#endif
+
+#ifdef FAST_TEXT_TEST
+
+static unsigned int first=0, last=128;
+unsigned int font_base;
+
+#define FONT "-adobe-courier-medium-r-normal--24-240-75-75-m-150-iso8859-1"
+HFONT hFont;
+
+void Font_Setup(void)
+{
+#ifdef _WIN32
+  int count;
+  HDC    hdc;  
+  HGLRC  hglrc; 
+
+
+  hdc = wglGetCurrentDC();
+  hglrc = wglGetCurrentContext();
+  
+  if (hdc == 0 || hglrc == 0) {
+    printf("Could not get context or DC\n");
+    exit(1);
+  }
+  
+  if (!wglMakeCurrent(hdc, hglrc)) {
+    printf("Could not make context current\n");
+    exit(1);
+  }
+
+#define FONTBASE 0x1000
+    /*
+    hFont = GetStockObject(SYSTEM_FONT);
+    hFont = CreateFont(h, w, esc, orient, weight,
+        ital, under, strike, set, out, clip, qual, pitch/fam, face);
+    */
+    hFont = CreateFont(30, 0, 0, 0, FW_NORMAL,
+        FALSE, FALSE, FALSE, ANSI_CHARSET,
+        OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DRAFT_QUALITY,
+        FIXED_PITCH | FF_MODERN, "Arial");
+    if (!hFont) {
+    MessageBox(WindowFromDC(hdc),
+        "Failed to find acceptable bitmap font.",
+        "OpenGL Application Error",
+        MB_ICONERROR | MB_OK);
+    exit(1);
+    }
+    (void) SelectObject(hdc, hFont);
+    wglUseFontBitmaps(hdc, 0, 255, FONTBASE);
+    glListBase(FONTBASE);
+#if 0
+  SelectObject (hdc, GetStockObject (SYSTEM_FONT));
+
+  count=last-first+1;
+  font_base = glGenLists(count);
+  wglUseFontBitmaps (hdc, first, last, font_base);
+  if (font_base == 0) {
+    printf("Could not generate Text_Setup list\n");
+    exit(1);
+  }
+#endif // 0  
+#else
+  Display *Dpy;
+  XFontStruct *fontInfo;
+  Font id;
+
+  Dpy = XOpenDisplay(NULL);
+  fontInfo = XLoadQueryFont(Dpy, FONT);
+  if (fontInfo == NULL)
+    {
+      printf("Failed to load font %s\n", FONT);
+      exit(1);
+    }
+
+  id = fontInfo->fid;
+  first = fontInfo->min_char_or_byte2;
+  last = fontInfo->max_char_or_byte2;
+  
+  base = glGenLists((GLuint) last+1);
+  if (base == 0) {
+    printf ("out of display lists\n");
+    exit (1);
+  }
+  glXUseXFont(id, first, last-first+1, base+first);
+#endif
+}
+
+static void
+drawString(char *string, GLfloat x, GLfloat y, GLfloat color[4])
+{
+    glColor4fv(color);
+    glRasterPos2f(x, y);
+    glCallLists(strlen(string), GL_BYTE, (GLbyte *) string);
+}
+
+#endif // #ifdef FAST_TEXT_TEST
+
 bool fgCockpitInit( fgAIRCRAFT *cur_aircraft )
 {
     FG_LOG( FG_COCKPIT, FG_INFO, "Initializing cockpit subsystem" );
 
-    //	cockpit->code = 1;	/* It will be aircraft dependent */
-    //	cockpit->status = 0;
+    //  cockpit->code = 1;  /* It will be aircraft dependent */
+    //  cockpit->status = 0;
 
     // If aircraft has HUD specified we will get the specs from its def
     // file. For now we will depend upon hard coding in hud?
@@ -233,6 +589,10 @@ bool fgCockpitInit( fgAIRCRAFT *cur_aircraft )
     // HI_Head is now a null pointer so we can generate a new list from the
     // current aircraft.
 
+#ifdef FAST_TEXT_TEST
+    Font_Setup();
+#endif // #ifdef FAST_TEXT_TEST
+    
     fgHUDInit( cur_aircraft );
     ac_cockpit = new fg_Cockpit();
     
@@ -240,33 +600,101 @@ bool fgCockpitInit( fgAIRCRAFT *cur_aircraft )
         new FGPanel;
     }
 
+    // Have to set the LatLon display type
+    fgLatLonFormat = toDM;
+    
     FG_LOG( FG_COCKPIT, FG_INFO,
-	    "  Code " << ac_cockpit->code() << " Status " 
-	    << ac_cockpit->status() );
+        "  Code " << ac_cockpit->code() << " Status " 
+        << ac_cockpit->status() );
     
     return true;
 }
 
 
 void fgCockpitUpdate( void ) {
+
+#define DISPLAY_COUNTER
+#ifdef DISPLAY_COUNTER
+    static float lightCheck[4] = { 0.7F, 0.7F, 0.7F, 1.0F };
+    char buf[64],*ptr;
+//  int fontSize;
+    int c;
+#endif
+    
     FG_LOG( FG_COCKPIT, FG_DEBUG,
-	    "Cockpit: code " << ac_cockpit->code() << " status " 
-	    << ac_cockpit->status() );
+        "Cockpit: code " << ac_cockpit->code() << " status " 
+        << ac_cockpit->status() );
 
     if ( current_options.get_hud_status() ) {
-	// This will check the global hud linked list pointer.
-	// If these is anything to draw it will.
-	fgUpdateHUD();
+    // This will check the global hud linked list pointer.
+    // If these is anything to draw it will.
+    fgUpdateHUD();
+    }
+#ifdef DISPLAY_COUNTER
+    else
+    {
+        float fps    =       get_frame_rate();
+        float tris   = fps * get_vfc_tris_drawn();
+        float culled = fps * get_vfc_tris_culled();
+        
+        int len = sprintf(buf," %4.1f  %7.0f  %7.0f",
+                          fps, tris, culled);
+//      sprintf(buf,"Tris Per Sec: %7.0f", t);      
+//      fontSize = (current_options.get_xsize() > 1000) ? LARGE : SMALL;
+        glMatrixMode(GL_PROJECTION);
+        glPushMatrix();
+
+        glLoadIdentity();
+        gluOrtho2D(0, 1024, 0, 768);
+        glMatrixMode(GL_MODELVIEW);
+        glPushMatrix();
+        glLoadIdentity();
+
+        glDisable(GL_DEPTH_TEST);
+        glDisable(GL_LIGHTING);
+
+//      glColor3f (.90, 0.27, 0.67);
+        
+
+#ifdef FAST_TEXT_TEST
+        drawString(buf, 250.0F, 10.0F, lightCheck);
+//      glRasterPos2f( 220, 10);
+//      for (int i=0; i < len; i++) {
+//          glCallList(font_base+buf[i]);
+//      }
+#else
+        glColor3f (.8, 0.8, 0.8);
+        glTranslatef( 400, 10, 0);
+        glScalef(.1, .1, 0.0);
+        ptr = buf;
+        while ( ( c = *ptr++) ){
+            glutStrokeCharacter( GLUT_STROKE_MONO_ROMAN, c);
+        }
+#endif // #ifdef FAST_TEXT_TEST
+
+//      glutStrokeCharacter( GLUT_STROKE_MONO_ROMAN, ' ');
+//      glutStrokeCharacter( GLUT_STROKE_MONO_ROMAN, ' ');
+        
+//      ptr = get_formated_gmt_time();
+//      while ( ( c = *ptr++) ){
+//          glutStrokeCharacter( GLUT_STROKE_MONO_ROMAN, c);
+//      }
+        
+        glEnable(GL_DEPTH_TEST);
+        glEnable(GL_LIGHTING);
+        glMatrixMode(GL_PROJECTION);
+        glPopMatrix();
+        glMatrixMode(GL_MODELVIEW);
+        glPopMatrix();
     }
+#endif // DISPLAY_COUNTER
 
     if ( current_options.get_panel_status() && 
-	 (fabs( current_view.get_view_offset() ) < 0.2) )
+     (fabs( current_view.get_view_offset() ) < 0.2) )
     {
-	xglViewport( 0, 0, 
-		     current_view.get_winWidth(), 
-		     current_view.get_winHeight() );
-	FGPanel::OurPanel->Update();
+    xglViewport( 0, 0, 
+             current_view.get_winWidth(), 
+             current_view.get_winHeight() );
+    FGPanel::OurPanel->Update();
     }
 }
-
-
diff --git a/Simulator/Cockpit/cockpit.hxx b/Simulator/Cockpit/cockpit.hxx
index e4ee06979..fce2a0a29 100644
--- a/Simulator/Cockpit/cockpit.hxx
+++ b/Simulator/Cockpit/cockpit.hxx
@@ -1,24 +1,26 @@
-// cockpit.hxx -- cockpit defines and prototypes (initial draft)
-//
-// Written by Michele America, started September 1997.
-//
-// Copyright (C) 1997  Michele F. America  - nomimarketing@mail.telepac.pt
-//
-// 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$
+/**************************************************************************
+ * cockpit.hxx -- cockpit defines and prototypes (initial draft)
+ *
+ * Written by Michele America, started September 1997.
+ *
+ * Copyright (C) 1997  Michele F. America  - nomimarketing@mail.telepac.pt
+ *
+ * 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$
+ **************************************************************************/
  
 
 #ifndef _COCKPIT_HXX
@@ -34,7 +36,7 @@
 #include "panel.hxx"
 
 // Class fg_Cockpit          This class is a holder for the heads up display
-//                           and is initialized with a
+//                          and is initialized with a
 class fg_Cockpit  {
   private:
     int  Code;
@@ -53,6 +55,4 @@ bool fgCockpitInit( fgAIRCRAFT *cur_aircraft );
 void fgCockpitUpdate( void );
 
 
-#endif // _COCKPIT_HXX
-
-
+#endif /* _COCKPIT_HXX */
diff --git a/Simulator/Cockpit/hud.cxx b/Simulator/Cockpit/hud.cxx
index 10acae719..0bc36600a 100644
--- a/Simulator/Cockpit/hud.cxx
+++ b/Simulator/Cockpit/hud.cxx
@@ -38,8 +38,13 @@
 #include <stdlib.h>
 #include <string.h>
 
+#ifdef HAVE_VALUES_H
+#  include <values.h>  // for MAXINT
+#endif
+
 #include <Aircraft/aircraft.hxx>
 #include <Debug/logstream.hxx>
+#include <GUI/gui.h>
 #include <Include/fg_constants.h>
 #include <Main/options.hxx>
 #include <Math/fg_random.h>
@@ -56,15 +61,22 @@ extern "C" {
 
 #include "hud.hxx"
 
-
 static char units[5];
 
-// The following routines obtain information concerntin the aircraft's
+// The following routines obtain information concerning the aircraft's
 // current state and return it to calling instrument display routines.
 // They should eventually be member functions of the aircraft.
 //
 
-HudContainerType HUD_deque;
+deque< instr_item * > HUD_deque;
+vector< fgLineSeg2D > HUD_LineList;
+vector< fgLineSeg2D > HUD_StippleLineList;
+
+#ifdef USE_HUD_TextList
+vector< fgTextString > HUD_TextList;
+#endif
+
+//GLFONT *myFont;
 
 class locRECT {
   public:
@@ -106,31 +118,44 @@ void drawOneLine( RECT &rect)
    /* textString - Bitmap font string */
 
 void textString( int x, int y, char *msg, void *font ){
-	glRasterPos2f(x, y);
-	while (*msg) {
-		glutBitmapCharacter(font, *msg);
-		msg++;
+
+    if(*msg)
+    {
+//      puDrawString (  NULL, msg, x, y );
+        
+        glRasterPos2f(x, y);
+        while (*msg) {
+            glutBitmapCharacter(font, *msg);
+            msg++;
+        }
     }
 }
 
-/* strokeString - Stroke font string */
 
+/* strokeString - Stroke font string */
 void strokeString(int x, int y, char *msg, void *font, float theta)
 {
-int xx;
-int yy;
-
-	glPushMatrix();
-  glRotatef(theta * RAD_TO_DEG, 0.0, 0.0, 1.0);
-  xx = (int)(x * cos(theta) + y * sin( theta ));
-  yy = (int)(y * cos(theta) - x * sin( theta ));
-	glTranslatef( xx, yy, 0);
-	glScalef(.1, .1, 0.0);
-	while (*msg) {
-		glutStrokeCharacter(font, *msg);
-		msg++;
-	}
-	glPopMatrix();
+    int xx;
+    int yy;
+    int c;
+    float sintheta,costheta;
+    
+
+    if(*msg)
+    {
+    glPushMatrix();
+    glRotatef(theta * RAD_TO_DEG, 0.0, 0.0, 1.0);
+    sintheta = sin(theta);
+    costheta = cos(theta);
+    xx = (int)(x * costheta + y * sintheta);
+    yy = (int)(y * costheta - x * sintheta);
+    glTranslatef( xx, yy, 0);
+    glScalef(.1, .1, 0.0);
+    while( (c=*msg++) ) {
+        glutStrokeCharacter(font, c);
+    }
+    glPopMatrix();
+    }
 }
 
 //========================= End of Class Implementations===================
@@ -148,10 +173,31 @@ int yy;
 int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
 {
   instr_item *HIptr;
-  int index;
+//  int index;
+  int font_size;
+
+  int off = 50;
+  int min_x = 25; //off/2;
+  int max_x = 615; //640-(off/2);
+//  int min_y = off;
+  int max_y = 430; //480-off;
+  int cen_x = 320;
+  int cen_y = 240;
+  unsigned int text_h = 10;
+  unsigned int ladr_w2 = 60;
+  int ladr_h2 = 90;
+  int ladr_t = 35;
+//  int compass_w2 = 100;
+  int gap = 10;
+
+  font_size = (current_options.get_xsize() > 1000) ? LARGE : SMALL;
 
   FG_LOG( FG_COCKPIT, FG_INFO, "Initializing current aircraft HUD" );
 
+//  deque < instr_item * > :: iterator first = HUD_deque.begin();
+//  deque < instr_item * > :: iterator last = HUD_deque.end();
+//  HUD_deque.erase( first, last);  // empty the HUD deque  
+
   HUD_deque.erase( HUD_deque.begin(), HUD_deque.end());  // empty the HUD deque
 
 //  hud->code = 1;
@@ -164,132 +210,186 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
 //  fgHUDSetTimeMode( hud, NIGHT );
 //  fgHUDSetBrightness( hud, BRT_LIGHT );
 
-  index = 0;
-
-  do {
-    switch ( index ) {
-      case 0:     // TBI
-        HIptr = (instr_item *) new fgTBI_instr( 270, 100, 60, 10 );
-        break;
-
-      case 1:     // Artificial Horizon
-        HIptr = (instr_item *) new HudLadder( 240, 195, 120, 180 );
-        break;
-
-      case 2:    // KIAS
-        HIptr = (instr_item *) new hud_card( 130,
-                                             170,
-                                              28,
-                                             200,
-                                             get_speed,
-                                             HUDS_LEFT | HUDS_VERT,
-                                             200.0, 0.0,
-                                             1.0,
-                                             10,  5,
-                                             0,
-                                             0,
-                                             50.0,
-                                             true);
-
-        break;
-
-      case 3:    // Radio Altimeter
-        HIptr = (instr_item *) new hud_card( 420,
-                                             195,
-                                              25,
-                                             150,
-                                             get_agl,
-                                             HUDS_LEFT | HUDS_VERT,
-                                             1000, 0,
-                                             1.0,
-                                             25,    5,
-                                             0,
-                                             0,
-                                             200.0,
-                                             true);
-        break;
-
-      case 4:    // GYRO COMPASS
-        HIptr = (instr_item *) new hud_card( 200,
-                                             375,
-                                             200,
-                                              28,
-                                             get_heading,
-                                             HUDS_TOP,
-                                             360, 0,
-                                               1.0,
-                                               5,   1,
-                                             360,
-                                               0,
-                                              25,
-                                             true);
-        break;
-
-      case 5:    // AMSL
-        HIptr = (instr_item *) new hud_card( 460,
-                                             170,
-                                              35,
-                                             200,
-                                             get_altitude,
-                                             HUDS_RIGHT | HUDS_VERT,
-                                             15000, -500,
-                                             1.0,
-                                             100,  25,
-                                             0,
-                                             0,
-                                             250,
-                                             true);
-        break;
-
-      case 6:
-        HIptr = (instr_item *) new  guage_instr( 250,            // x
-                                                 350,            // y
-                                                 100,            // width
-                                                  20,            // height
-                                                 get_aileronval, // data source
-                                                 HUDS_BOTTOM | HUDS_NOTEXT,
-                                                 100.0,
-                                                 +1.0,
-                                                 -1.0);
-        break;
-
-      case 7:
-        HIptr = (instr_item *) new  guage_instr( 170,             // x
-                                                 225,             // y
-                                                  20,             // width
-                                                 100,             // height
-                                                 get_elevatorval, // data source
-                                                 HUDS_RIGHT | HUDS_VERT | HUDS_NOTEXT,
-                                                -100.0,           // Scale data
-                                                  +1.0,           // Data Range
-                                                  -1.0);
-        break;
-
-      case 8:
-        HIptr = (instr_item *) new  guage_instr( 250,             // x
-                                                 200,             // y
-                                                 100,             // width
-                                                  20,             // height
-                                                 get_rudderval,   // data source
-                                                 HUDS_TOP | HUDS_NOTEXT,
-                                                 100.0,
-                                                 +1.0,
-                                                 -1.0);
-        break;
-
-      case 9:
-        HIptr = (instr_item *) new  guage_instr( 100,             // x
-                                                 190,
-                                                  20,
-                                                 160,             // height
-                                                 get_throttleval, // data source
-                                                 HUDS_VERT | HUDS_RIGHT | HUDS_NOTEXT,
-                                                 100.0,
-                                                   1.0,
-                                                   0.0);
-        break;
-
-      case 10:    // Digital KIAS
+//      case 0:     // TBI
+  int x = 290; /*cen_x-30*/
+  int y = 45;  /*off-5*/
+//  HIptr = (instr_item *) new fgTBI_instr( x, y, ladr_w2, text_h );
+  HIptr = (instr_item *) new fgTBI_instr( 290, 45, 60, 10 );  
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+
+//      case 1:     // Artificial Horizon
+  HIptr = (instr_item *) new HudLadder( cen_x-ladr_w2, cen_y-ladr_h2,
+                                        2*ladr_w2, 2*ladr_h2 );
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+
+//      case 4:    // GYRO COMPASS
+  HIptr = (instr_item *) new hud_card( cen_x-100,
+                                       max_y,
+                                       200,
+                                       28,
+                                       get_heading,
+                                       HUDS_TOP,
+                                       360, 0,
+                                       1.0,
+                                       5,   1,
+                                       360,
+                                       0,
+                                       25,
+                                       true);
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+
+//      case 5:    // AMSL
+  HIptr = (instr_item *) new hud_card( max_x - 35 -15, // 15 to balance speed card
+                                       cen_y-100,
+                                       35,
+                                       200,
+                                       get_altitude,
+//                                     HUDS_RIGHT | HUDS_VERT,
+                                       HUDS_LEFT | HUDS_VERT,
+                                       5000, -1000,
+                                       1.0,
+                                       100,  25,
+                                       0,
+                                       0,
+                                       250,
+                                       true);
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+
+//      case 6:
+  HIptr = (instr_item *) new  guage_instr( cen_x-50,            // x
+                                           cen_y + ladr_h2 -20,  // y
+                                           100,            // width
+                                           20,            // height
+                                           get_aileronval, // data source
+                                           HUDS_BOTTOM | HUDS_NOTEXT,
+                                           100.0,
+                                           +1.0,
+                                           -1.0);
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+
+//      case 3:    // Radio Altimeter
+  HIptr = (instr_item *) new hud_card( cen_x + ladr_w2 + gap + 13 + ladr_t,
+                                       cen_y-75,
+                                       25,
+                                       150,
+                                       get_agl,
+                                       HUDS_LEFT | HUDS_VERT,
+                                       1000, 0,
+                                       1.0,
+                                       25,    5,
+                                       0,
+                                       0,
+                                       200.0,
+                                       true);
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+
+//      case 7:
+  HIptr = (instr_item *) new  guage_instr( cen_x -ladr_w2 -gap -13 -20 -ladr_t,
+                                           cen_y-50,             // y
+                                           20,             // width
+                                           100,             // height
+                                           get_elevatorval, // data source
+                                           HUDS_RIGHT | HUDS_VERT | HUDS_NOTEXT,
+                                           -100.0,           // Scale data
+                                           +1.0,           // Data Range
+                                           -1.0);
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+
+//      case 8:
+  HIptr = (instr_item *) new  guage_instr( cen_x-50,             // x
+                                           cen_y -gap -ladr_w2 -20, //-85   // y
+                                           100,             // width
+                                           20,             // height
+                                           get_rudderval,   // data source
+                                           HUDS_TOP | HUDS_NOTEXT,
+                                           100.0,
+                                           +1.0,
+                                           -1.0);
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+
+//      case 2:    // KIAS
+  HIptr = (instr_item *) new hud_card( min_x +10 +5, //min_x +18,
+                                       cen_y-100,
+                                       28,
+                                       200,
+                                       get_speed,
+//                                     HUDS_LEFT | HUDS_VERT,
+                                       HUDS_RIGHT | HUDS_VERT,                                     
+                                       200.0, 0.0,
+                                       1.0,
+                                       10,  5,
+                                       0,
+                                       0,
+                                       50.0,
+                                       true);
+
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+
+//      case 9:
+  HIptr = (instr_item *) new  guage_instr( min_x-10,           // x
+                                           cen_y -75,       // y 
+                                           20,              // width
+                                           150,             // height
+                                           get_throttleval, // data source
+//                                         HUDS_VERT | HUDS_RIGHT | HUDS_NOTEXT,
+                                           HUDS_VERT | HUDS_LEFT | HUDS_NOTEXT,                                        100.0,
+                                           1.0,
+                                           0.0
+                                          );
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+// Remove this when below uncommented       
+//      case 10:
+  HIptr = (instr_item *) new instr_label( 10,
+                                          10,
+                                          60,
+                                          10,
+                                          get_frame_rate,
+                                          "%5.1f",
+                                          "",
+                                          NULL,
+                                          1.0,
+                                          HUDS_TOP,
+                                          RIGHT_JUST,
+                                          font_size,
+                                          0,
+                                          TRUE );
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+  
+    HIptr = (instr_item *) new lat_label( (cen_x -ladr_w2)/2,
+                                          max_y,    
+                                          60,
+                                          text_h,
+                                          get_latitude,
+                                          "%s%", //"%.0f",
+                                          "", //"Lat ",
+                                          "",
+                                          1.0,
+                                          HUDS_TOP,
+                                          CENTER_JUST,
+                                          font_size,
+                                          0,
+                                          TRUE );
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+    
+    HIptr = (instr_item *) new lon_label(
+                                         //(cen_x+ladr_x2) +((max_x-(cen_x+ladr_x2))/2),
+                                         (2*cen_x) - ((cen_x -ladr_w2)/2),
+                                         max_y,
+                                         60, text_h,
+                                         get_longitude,
+                                         "%s%",//"%.0f",
+                                         "", //"Lon ",  
+                                         "",
+                                         1.0,
+                                         HUDS_TOP,
+                                         CENTER_JUST,
+                                         font_size,
+                                         0,
+                                         TRUE );
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+    
+/*
+//      case 10:    // Digital KIAS
         HIptr = (instr_item *) new instr_label ( 110,
                                                  150,
                                                   40,
@@ -301,12 +401,12 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
                                                  1.0,
                                                  HUDS_TOP,
                                                  RIGHT_JUST,
-                                                 SMALL,
+                                                 font_size,
                                                  0,
                                                  TRUE );
-        break;
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
 
-      case 11:    // Digital Rate of Climb
+//      case 11:    // Digital Rate of Climb
         HIptr = (instr_item *) new instr_label ( 110,
                                                  135,
                                                   40,
@@ -318,12 +418,12 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
                                                  1.0,
                                                  HUDS_TOP,
                                                  RIGHT_JUST,
-                                                 SMALL,
+                                                 font_size,
                                                  0,
                                                  TRUE );
-        break;
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
 
-      case 12:    // Roll indication diagnostic
+//      case 12:    // Roll indication diagnostic
         HIptr = (instr_item *) new instr_label ( 110,
                                                  120,
                                                   40,
@@ -335,12 +435,12 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
                                                  1.0,
                                                  HUDS_TOP,
                                                  RIGHT_JUST,
-                                                 SMALL,
+                                                 font_size,
                                                  0,
                                                  TRUE );
-        break;
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
 
-      case 13:    // Angle of attack diagnostic
+//      case 13:    // Angle of attack diagnostic
         HIptr = (instr_item *) new instr_label ( 440,
                                                  150,
                                                   60,
@@ -352,12 +452,12 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
                                                  1.0,
                                                  HUDS_TOP,
                                                  RIGHT_JUST,
-                                                 SMALL,
+                                                 font_size,
                                                  0,
                                                  TRUE );
-        break;
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
 
-      case 14:
+//      case 14:
         HIptr = (instr_item *) new instr_label ( 440,
                                                  135,
                                                   60,
@@ -369,12 +469,12 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
                                                  1.0,
                                                  HUDS_TOP,
                                                  RIGHT_JUST,
-                                                 SMALL,
+                                                 font_size,
                                                  0,
                                                  TRUE );
-        break;
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
 
-      case 15:
+//      case 15:
         HIptr = (instr_item *) new instr_label ( 440,
                                                  120,
                                                   60,
@@ -386,12 +486,12 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
                                                  1.0,
                                                  HUDS_TOP,
                                                  RIGHT_JUST,
-                                                 SMALL,
+                                                 font_size,
                                                  0,
                                                  TRUE );
-        break;
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
 
-      case 16:
+//      case 16:
         HIptr = (instr_item *) new instr_label( 440,
                                                 100,
                                                  60,
@@ -403,12 +503,12 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
                                                  1.0,
                                                 HUDS_TOP,
                                                 RIGHT_JUST,
-                                                SMALL,
+                                                font_size,
                                                 0,
                                                 TRUE );
-        break;
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
 
-      case 17:
+//      case 17:
         HIptr = (instr_item *) new instr_label( 440,
                                                  85,
                                                  60,
@@ -420,12 +520,12 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
                                                  1.0,
                                                 HUDS_TOP,
                                                 RIGHT_JUST,
-                                                SMALL,
+                                                font_size,
                                                 0,
                                                 TRUE );
-        break;
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
 
-      case 18:
+//      case 18:
         HIptr = (instr_item *) new instr_label( 440,
                                                  60,
                                                  60,
@@ -437,67 +537,66 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
                                                  1.0,
                                                 HUDS_TOP,
                                                 RIGHT_JUST,
-                                                SMALL,
+                                                font_size,
                                                 0,
                                                 TRUE );
-        break;
-
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
 
-      case 19:
+//      case 19:
         HIptr = (instr_item *) new instr_label( 10,
                                                 10,
                                                 60,
                                                 10,
                                                  get_frame_rate,
-                                                "%.0f",
+                                                "%.1f",
                                                 "Frame rate = ",
                                                 NULL,
                                                  1.0,
                                                 HUDS_TOP,
                                                 RIGHT_JUST,
-                                                SMALL,
+                                                font_size,
                                                 0,
                                                 TRUE );
-        break;
-
-      case 20:
-	  switch( current_options.get_tris_or_culled() ) {
-	  case 0:
-	      HIptr = (instr_item *) new instr_label( 10,
-						      25,
-						      90,
-						      10,
-						      get_vfc_tris_drawn,
-						      "%.0f",
-						      "Tris Rendered = ",
-						      NULL,
-						      1.0,
-						      HUDS_TOP,
-						      RIGHT_JUST,
-						      SMALL,
-						      0,
-						      TRUE );
-	      break;
-	  case 1:
-	      HIptr = (instr_item *) new instr_label( 10,
-						      25,
-						      90,
-						      10,
-						      get_vfc_ratio,
-						      "%.2f",
-						      "VFC Ratio = ",
-						      NULL,
-						      1.0,
-						      HUDS_TOP,
-						      RIGHT_JUST,
-						      SMALL,
-						      0,
-						      TRUE );
-	      break;
-	  }
-	  break;
-
-      case 21:
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+
+//      case 20:
+      switch( current_options.get_tris_or_culled() ) {
+      case 0:
+          HIptr = (instr_item *) new instr_label( 10,
+                              25,
+                              120,
+                              10,
+                              get_vfc_tris_drawn,
+                              "%.0f",
+                              "Tris Rendered = ",
+                              NULL,
+                              1.0,
+                              HUDS_TOP,
+                              RIGHT_JUST,
+                              font_size,
+                              0,
+                              TRUE );
+          break;
+      case 1:
+          HIptr = (instr_item *) new instr_label( 10,
+                              25,
+                              90,
+                              10,
+                              get_vfc_ratio,
+                              "%.2f",
+                              "VFC Ratio = ",
+                              NULL,
+                              1.0,
+                              HUDS_TOP,
+                              RIGHT_JUST,
+                              font_size,
+                              0,
+                              TRUE );
+          break;
+      }
+      break;
+
+//      case 21:
         HIptr = (instr_item *) new instr_label( 10,
                                                 40,
                                                 90,
@@ -506,33 +605,55 @@ int fgHUDInit( fgAIRCRAFT * /* current_aircraft */ )
                                                 "%.1f",
                                                 "FOV = ",
                                                 NULL,
-						1.0,
+                        1.0,
                                                 HUDS_TOP,
                                                 RIGHT_JUST,
-                                                SMALL,
+                                                font_size,
                                                 0,
                                                 TRUE );
-        break;
-
-      default:
-        HIptr = 0;;
-      }
-    if( HIptr ) {                   // Anything to install?
-      HUD_deque.insert( HUD_deque.begin(), HIptr);
-      }
-    index++;
-    }
-  while( HIptr );
+  HUD_deque.insert( HUD_deque.begin(), HIptr);
+*/
+//      default:
+//        HIptr = 0;;
+//      }
+//    if( HIptr ) {                   // Anything to install?
+//      HUD_deque.insert( HUD_deque.begin(), HIptr);
+//      }
+//    index++;
+//    }
+//  while( HIptr );
 
   return 0;  // For now. Later we may use this for an error code.
+
 }
 
 int fgHUDInit2( fgAIRCRAFT * /* current_aircraft */ )
 {
-    int index;
+//    instr_item *HIptr;
+//    int index;
+    int font_size;
+
+    int off = 50;
+//  int min_x = off;
+//  int max_x = 640-off;
+//  int min_y = off;
+    int max_y = 480-off;
+    int cen_x = 640 / 2;
+//  int cen_y = 480 / 2;
+    int text_h = 10;
+    int ladr_w2 = 60;
+//  int ladr_h2 = 90;
+//  int ladr_t = 35;
+//  int compass_w2 = 100;
+//  int gap = 10;
+
+    font_size = (current_options.get_xsize() > 1000) ? LARGE : SMALL;
 
     FG_LOG( FG_COCKPIT, FG_INFO, "Initializing current aircraft HUD" );
 
+//  deque < instr_item * > :: iterator first = HUD_deque.begin();
+//  deque < instr_item * > :: iterator last = HUD_deque.end();
+//  HUD_deque.erase( first, last);  // empty the HUD deque  
     HUD_deque.erase( HUD_deque.begin(), HUD_deque.end());
 
     //  hud->code = 1;
@@ -546,107 +667,256 @@ int fgHUDInit2( fgAIRCRAFT * /* current_aircraft */ )
     //  fgHUDSetBrightness( hud, BRT_LIGHT );
 
     //  index = 0;
-    index = 19;  
+//    index = 19;  
 
     instr_item* p;
 
+//      case 4:    // GYRO COMPASS
+    p =new hud_card( cen_x-100,
+                     max_y,
+                     200,
+                     28,
+                     get_view_direction,
+                     HUDS_TOP,
+                     360, 0,
+                     1.0,
+                     5,   1,
+                     360,
+                     0,
+                     25,
+                     true);
+    HUD_deque.push_front( p );
+
+    p = new lat_label( (cen_x -ladr_w2)/2,
+                       max_y,
+                       60, text_h,
+                       get_latitude,
+                       "%s%", //"%.0f",
+                       "", //"Lat ",
+                       "",
+                       1.0,
+                       HUDS_TOP,
+                       CENTER_JUST,
+                       font_size,
+                       0,
+                       TRUE );
+    HUD_deque.push_front( p );
+    
+//    p = new instr_label( 140, 450, 60, 10,
+//           get_lat_min,
+//           "%05.2f",
+//           "",
+//           NULL,
+//           1.0,
+//           HUDS_TOP,
+//           CENTER_JUST,
+//           font_size,
+//           0,
+//           TRUE );
+//    HUD_deque.push_front( p );
+    
+    p = new lon_label( (2*cen_x) - ((cen_x -ladr_w2)/2),
+                       max_y,
+                       60, text_h,
+                       get_longitude,
+                       "%s%",//"%.0f",
+                       "", //"Lon ",
+                       "",
+                       1.0,
+                       HUDS_TOP,
+                       CENTER_JUST,
+                       font_size,
+                       0,
+                       TRUE );
+    HUD_deque.push_front( p );
+    
+//    p = new instr_label( 480, 450, 60, 10,
+//           get_long_min,
+//           "%05.2f",
+//           "",
+//           NULL,
+//           1.0,
+//           HUDS_TOP,
+//           CENTER_JUST,
+//           font_size,
+//           0,
+//           TRUE );
+//    HUD_deque.push_front( p );
+    
     p = new instr_label( 10, 10, 60, 10,
-			 get_frame_rate,
-			 "%.0f",
-			 "Frame rate = ",
-			 NULL,
-			 1.0,
-			 HUDS_TOP,
-			 RIGHT_JUST,
-			 SMALL,
-			 0,
-			 TRUE );
+                         get_frame_rate,
+                         "%7.1f",
+                         "Frame rate =",
+                         NULL,
+                         1.0,
+                         HUDS_TOP,
+                         RIGHT_JUST,
+                         font_size,
+                         0, 
+                         TRUE );
     HUD_deque.push_front( p );
 
-    if ( current_options.get_tris_or_culled() == 0 )
-	p = new instr_label( 10, 25, 90, 10,
-			     get_vfc_tris_drawn,
-			     "%.0f",
-			     "Tris Rendered = ",
-			     NULL,
-			     1.0,
-			     HUDS_TOP,
-			     RIGHT_JUST,
-			     SMALL,
-			     0,
-			     TRUE );
-    else
-	p = new instr_label( 10, 25, 90, 10,
-			     get_vfc_ratio,
-			     "%.2f",
-			     "VFC Ratio = ",
-			     NULL,
-			     1.0,
-			     HUDS_TOP,
-			     RIGHT_JUST,
-			     SMALL,
-			     0,
-			     TRUE );
+    p = new instr_label( 10, 25, 120, 10,
+                         get_vfc_tris_culled,
+                         "%7.0f",
+                         "Culled     =",
+                         NULL,
+                         1.0,
+                         HUDS_TOP,
+                         RIGHT_JUST,
+                         font_size,
+                         0,
+                         TRUE );
     HUD_deque.push_front( p );
 
-    p = new instr_label( 10, 40, 90, 10,
-			 get_fov,
-			 "%.1f",
-			 "FOV = ",
-			 NULL,
-			 1.0,
-			 HUDS_TOP,
-			 RIGHT_JUST,
-			 SMALL,
-			 0,
-			 TRUE );
+    p = new instr_label( 10, 40, 120, 10,
+                         get_vfc_tris_drawn,
+                         "%7.0f",
+                         "Rendered   =",
+                         NULL,
+                         1.0,
+                         HUDS_TOP,
+                         RIGHT_JUST,
+                         font_size,
+                         0,
+                         TRUE );
+    HUD_deque.push_front( p );
+    
+    p = new instr_label( 10, 55, 90, 10,
+                         get_fov,
+                         "%7.1f",
+                         "FOV         ",
+                         NULL,
+                         1.0,
+                         HUDS_TOP,
+                         RIGHT_JUST,
+                         font_size,
+                         0,
+                         TRUE );
     HUD_deque.push_front( p );
 
     const int x_pos = 480;
-    p = new instr_label( x_pos, 40, 40, 30,
-			 get_speed,
-			 "%5.0f",
-			 "Airspeed ",
-			 " Kts",
-			 1.0,
-			 HUDS_TOP,
-			 RIGHT_JUST,
-			 SMALL,
-			 0,
-			 TRUE );
+    
+    p = new instr_label ( x_pos,
+                          70,
+                          60,
+                          10,
+                          get_aoa,
+                          "%7.2f",
+                          "AOA    ",
+                          " Deg",
+                          1.0,
+                          HUDS_TOP,
+                          RIGHT_JUST,
+                          font_size,
+                          0,
+                          TRUE );
+    HUD_deque.push_front( p );
+
+    p = new instr_label( x_pos, 55, 40, 30,
+                         get_speed,
+                         "%5.0f",
+                         "Airspeed ",
+                         " Kts",
+                         1.0,
+                         HUDS_TOP,
+                         RIGHT_JUST,
+                         font_size,
+                         0,
+                         TRUE );
     HUD_deque.push_front( p );
 
     if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
-	strcpy(units, " ft");
+    strcpy(units, " ft");
     } else {
-	strcpy(units, " m");
+    strcpy(units, " m");
     }
+    p = new instr_label( x_pos, 40, 40, 10,
+             get_altitude,
+             "%5.0f",
+             "Altitude ",
+             units,
+             1.0,
+             HUDS_TOP,
+             RIGHT_JUST,
+             font_size,
+             0,
+             TRUE );
+    HUD_deque.push_front( p );
+
     p = new instr_label( x_pos, 25, 40, 10,
-			 get_altitude,
-			 "%5.0f",
-			 "Altitude ",
-			 units,
-			 1.0,
-			 HUDS_TOP,
-			 RIGHT_JUST,
-			 SMALL,
-			 0,
-			 TRUE );
+             get_agl,
+             "%5.0f",
+             "Elvation ",
+             units,
+             1.0,
+             HUDS_TOP,
+             RIGHT_JUST,
+             font_size,
+             0,
+             TRUE );
     HUD_deque.push_front( p );
 
     p = new instr_label( x_pos, 10, 60, 10,
-			 get_heading,
-			 "%5.1f",
-			 "Heading  ",
-			 " Deg",
-			 1.0,
-			 HUDS_TOP,
-			 RIGHT_JUST,
-			 SMALL,
-			 0,
-			 TRUE );
+             get_heading,
+             "%5.1f",
+             "Heading  ",
+             " Deg",
+             1.0,
+             HUDS_TOP,
+             RIGHT_JUST,
+             font_size,
+             0,
+             TRUE );
+    HUD_deque.push_front( p );
+
+    p = new fgTBI_instr( 290, 55, 60, 10 ); // 270
+    HUD_deque.push_front( p );
+    
+    p = new  guage_instr( 270, //250,            // x
+                          390, //360, //400, //45, //420,            // y
+                          100,            // width
+                          20,            // height
+                          get_aileronval, // data source
+                          HUDS_BOTTOM | HUDS_NOTEXT,
+                          100.0,
+                          +1.0,
+                          -1.0);
+    HUD_deque.push_front( p );
+
+    p = new  guage_instr( 20,             // x
+                          240-50,             // y
+                          20,             // width
+                          100,             // height
+                          get_elevatorval, // data source
+                          HUDS_RIGHT | HUDS_VERT | HUDS_NOTEXT,
+                          -100.0,           // Scale data
+                          +1.0,           // Data Range
+                          -1.0);
+    HUD_deque.push_front( p );
+
+    p = new  guage_instr( 270, //250,             // x
+                          10+15,             // y
+                          100,             // width
+                          20,             // height
+                          get_rudderval,   // data source
+                          HUDS_TOP | HUDS_NOTEXT,
+                          100.0,
+                          +1.0,
+                          -1.0);
     HUD_deque.push_front( p );
 
+    p = new  guage_instr( 600,             // x
+                          240-80,
+                          20,
+                          160,             // height
+                          get_throttleval, // data source
+                          HUDS_VERT | HUDS_LEFT | HUDS_NOTEXT,
+                          100.0,
+                          1.0,
+                          0.0);
+    HUD_deque.push_front( p );
+    
     return 0;  // For now. Later we may use this for an error code.
 }
 
@@ -661,7 +931,7 @@ int brightness        = pHUDInstr->get_brightness();
     if( incr_bright ) {
       switch (brightness) {
         case BRT_LIGHT:
-   	      current_options.set_hud_status(0);
+          current_options.set_hud_status(0);
           break;
 
         case BRT_MEDIUM:
@@ -696,7 +966,7 @@ int brightness        = pHUDInstr->get_brightness();
 
         case BRT_BLACK:
         default:
-   	      current_options.set_hud_status(0);
+          current_options.set_hud_status(0);
         }
       }
     }
@@ -731,17 +1001,36 @@ int brightness        = pHUDInstr->get_brightness();
 // all C++.
 //
 void fgUpdateHUD( void ) {
-  int i;
+//  int i;
   int brightness;
 //  int day_night_sw = current_aircraft.controls->day_night_switch;
   int day_night_sw = global_day_night_switch;
   int hud_displays = HUD_deque.size();
   instr_item *pHUDInstr;
+  int line_width;
 
   if( !hud_displays ) {  // Trust everyone, but ALWAYS cut the cards!
     return;
     }
 
+//  vector < fgLineSeg2D > :: iterator first_lineSeg = HUD_LineList.begin();
+//  vector < fgLineSeg2D > :: iterator last_lineSeg  = HUD_LineList.end();
+//  HUD_LineList.erase( first_lineSeg, last_lineSeg);
+  HUD_LineList.erase( HUD_LineList.begin(), HUD_LineList.end() );
+//  first = HUD_StippleLineList.begin();
+//  last  = HUD_StippleLineList.end();
+//  HUD_StippleLineList.erase( first, last);
+//  HUD_StippleLineList.erase( HUD_StippleLineList.begin(),
+//                           HUD_StippleLineList.end() );
+#ifdef USE_HUD_TextList
+//  vector < fgTextString > :: iterator first_string = HUD_TextList.begin();
+//  vector < fgTextString > :: iterator last_string  = HUD_TextList.end();
+//  HUD_TextList.erase( first_string, last_string);
+  HUD_TextList.erase( HUD_TextList.begin(), HUD_TextList.end() );
+#endif
+  
+  line_width = (current_options.get_xsize() > 1000) ? 2 : 1;
+  
   pHUDInstr = HUD_deque[0];
   brightness = pHUDInstr->get_brightness();
 //  brightness = HUD_deque.at(0)->get_brightness();
@@ -751,6 +1040,7 @@ void fgUpdateHUD( void ) {
 
   glLoadIdentity();
   gluOrtho2D(0, 640, 0, 480);
+//  gluOrtho2D(0, 1024, 0, 768);  
   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
   glLoadIdentity();
@@ -761,23 +1051,14 @@ void fgUpdateHUD( void ) {
   glDisable(GL_DEPTH_TEST);
   glDisable(GL_LIGHTING);
 
-  glLineWidth(1);
+  glLineWidth(line_width);
 
-  HudIterator current = HUD_deque.begin();
-  HudIterator last = HUD_deque.end();
-
-  for ( ; current != last; ++current ) {
-    pHUDInstr = *current;
-
-    // for( i = hud_displays; i; --i) { // Draw everything
-    // if( HUD_deque.at(i)->enabled()) {
-    // pHUDInstr = HUD_deque[i - 1];
-    if( pHUDInstr->enabled()) {
-                                   // We should to respond to a dial instead
-                                   // or as well to the of time of day. Of
-                                   // course, we have no dial!
-      if( day_night_sw == DAY) {
-        switch (brightness) {
+  // We can do translucency, so why not. :-)
+//  glEnable    ( GL_BLEND ) ;
+//  glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
+  
+  if( day_night_sw == DAY) {
+      switch (brightness) {
           case BRT_LIGHT:
             glColor3f (0.1, 0.9, 0.1);
             break;
@@ -795,11 +1076,11 @@ void fgUpdateHUD( void ) {
             break;
 
           default:;
-            }
-          }
-        else {
-          if( day_night_sw == NIGHT) {
-            switch (brightness) {
+      }
+  }
+  else {
+      if( day_night_sw == NIGHT) {
+          switch (brightness) {
               case BRT_LIGHT:
                 glColor3f (0.9, 0.1, 0.1);
                 break;
@@ -810,20 +1091,76 @@ void fgUpdateHUD( void ) {
 
               case BRT_DARK:
               default:
-                glColor3f (0.5, 0.0, 0.0);
-              }
-            }
+                  glColor3f (0.5, 0.0, 0.0);
+          }
+      }
           else {     // Just in case default
-            glColor3f (0.1, 0.9, 0.1);
-            }
+              glColor3f (0.1, 0.9, 0.1);
           }
-    //  fgPrintf( FG_COCKPIT, FG_DEBUG, "HUD Code %d  Status %d\n",
-    //            hud->code, hud->status );
-      pHUDInstr->draw();
-//      HUD_deque.at(i)->draw(); // Responsible for broken or fixed variants.
+  }
+  deque < instr_item * > :: iterator current = HUD_deque.begin();
+  deque < instr_item * > :: iterator last = HUD_deque.end();
+
+  for ( ; current != last; ++current ) {
+      pHUDInstr = *current;
+
+      // for( i = hud_displays; i; --i) { // Draw everything
+      // if( HUD_deque.at(i)->enabled()) {
+      // pHUDInstr = HUD_deque[i - 1];
+      if( pHUDInstr->enabled()) {
+          //  fgPrintf( FG_COCKPIT, FG_DEBUG, "HUD Code %d  Status %d\n",
+          //            hud->code, hud->status );
+          pHUDInstr->draw();
+//        HUD_deque.at(i)->draw(); // Responsible for broken or fixed variants.
                               // No broken displays honored just now.
       }
-    }
+  }
+
+  vector < fgLineSeg2D > :: iterator curSeg = HUD_LineList.begin();
+  vector < fgLineSeg2D > :: iterator lastSeg = HUD_LineList.end();
+
+  glBegin(GL_LINES);
+  for ( ; curSeg != lastSeg; curSeg++ ) {
+      curSeg->draw();
+  }
+  glEnd();
+  
+//  curSeg = HUD_StippleLineList.begin();
+//  lastSeg = HUD_StippleLineList.end();
+  
+//  glEnable(GL_LINE_STIPPLE);
+//  glLineStipple( 1, 0x00FF );
+//  glBegin(GL_LINES);
+//  for ( ; curSeg != lastSeg; curSeg++ ) {
+//    curSeg->draw();
+//  }
+//  glEnd();
+//  glDisable(GL_LINE_STIPPLE);
+#ifdef USE_HUD_TextList
+#define textString( x , y, text, font )  TextString( font, text, x , y )
+#endif
+  
+#ifdef USE_HUD_TextList
+  GLfloat mat[16];
+  glPushMatrix();
+  glGetFloatv(GL_MODELVIEW_MATRIX, mat);
+  HUD_TextList.push_back( fgTextString( GLUT_BITMAP_8_BY_13,
+                                        get_formated_gmt_time(),
+                                        450, 445)
+                        );
+//  glFontBegin ( myFont );
+  vector < fgTextString > :: iterator curString = HUD_TextList.begin();
+  vector < fgTextString > :: iterator lastString = HUD_TextList.end();
+  
+  for ( ; curString != lastString; curString++ ) {
+      glLoadMatrixf( mat );
+      curString->draw();
+  }
+//  glFontEnd ();
+  glPopMatrix();
+#endif
+  
+//  glDisable   ( GL_BLEND ) ;
 
   glEnable(GL_DEPTH_TEST);
   glEnable(GL_LIGHTING);
@@ -832,4 +1169,3 @@ void fgUpdateHUD( void ) {
   glMatrixMode(GL_MODELVIEW);
   glPopMatrix();
 }
-
diff --git a/Simulator/Cockpit/hud.hxx b/Simulator/Cockpit/hud.hxx
index b40f9e042..0ba59a957 100644
--- a/Simulator/Cockpit/hud.hxx
+++ b/Simulator/Cockpit/hud.hxx
@@ -44,8 +44,8 @@
 #  include <values.h>  // for MAXINT
 #endif
 
-#include <deque>        // STL double ended queue
 #include <vector>       // STL vector
+#include <deque>        // STL double ended queue
 
 #include <fg_typedefs.h>
 #include <fg_constants.h>
@@ -53,6 +53,10 @@
 #include <FDM/flight.hxx>
 #include <Controls/controls.hxx>
 
+//#include "glfont.h"
+
+//extern GLFONT *myFont;
+
 FG_USING_STD(deque);
 FG_USING_STD(vector);
 
@@ -107,10 +111,10 @@ enum fgLabelJust{ LEFT_JUST, CENTER_JUST, RIGHT_JUST } ;
 #define DASHED_NEG_LINES  12
 
 
-#define HORIZON_FIXED	1
-#define HORIZON_MOVING	2
-#define LABEL_COUNTER	1
-#define LABEL_WARNING	2
+#define HORIZON_FIXED   1
+#define HORIZON_MOVING  2
+#define LABEL_COUNTER   1
+#define LABEL_WARNING   2
 
 #define HUDS_AUTOTICKS           0x0001
 #define HUDS_VERT                0x0002
@@ -127,52 +131,60 @@ enum fgLabelJust{ LEFT_JUST, CENTER_JUST, RIGHT_JUST } ;
 
 // Ladder orientaion
 // #define HUD_VERTICAL        1
-// #define HUD_HORIZONTAL		2
-// #define HUD_FREEFLOAT		3
+// #define HUD_HORIZONTAL       2
+// #define HUD_FREEFLOAT        3
 
 // Ladder orientation modes
-// #define HUD_LEFT    		1
-// #define HUD_RIGHT         	2
-// #define HUD_TOP           	1
-// #define HUD_BOTTOM        	2
-// #define HUD_V_LEFT    		1
-// #define HUD_V_RIGHT         	2
-// #define HUD_H_TOP           	1
-// #define HUD_H_BOTTOM        	2
+// #define HUD_LEFT         1
+// #define HUD_RIGHT            2
+// #define HUD_TOP              1
+// #define HUD_BOTTOM           2
+// #define HUD_V_LEFT           1
+// #define HUD_V_RIGHT          2
+// #define HUD_H_TOP            1
+// #define HUD_H_BOTTOM         2
 
 
 // Ladder sub-types
-// #define HUD_LIM				1
-// #define HUD_NOLIM			2
-// #define HUD_CIRC			3
-
-// #define HUD_INSTR_LADDER	1
-// #define HUD_INSTR_CLADDER	2
-// #define HUD_INSTR_HORIZON	3
-// #define HUD_INSTR_LABEL		4
-
-extern double get_throttleval ( void );
-extern double get_aileronval  ( void );
-extern double get_elevatorval ( void );
-extern double get_elev_trimval( void );
-extern double get_rudderval   ( void );
-extern double get_speed       ( void );
-extern double get_aoa         ( void );
-extern double get_roll        ( void );
-extern double get_pitch       ( void );
-extern double get_heading     ( void );
-extern double get_altitude    ( void );
-extern double get_agl         ( void );
-extern double get_sideslip    ( void );
-extern double get_frame_rate  ( void );
-extern double get_latitude    ( void );
-extern double get_lat_min     ( void );
-extern double get_longitude   ( void );
-extern double get_long_min    ( void );
-extern double get_fov         ( void );
-extern double get_vfc_ratio   ( void );
-extern double get_vfc_tris_drawn   ( void );
-extern double get_climb_rate  ( void );
+// #define HUD_LIM              1
+// #define HUD_NOLIM            2
+// #define HUD_CIRC         3
+
+// #define HUD_INSTR_LADDER 1
+// #define HUD_INSTR_CLADDER    2
+// #define HUD_INSTR_HORIZON    3
+// #define HUD_INSTR_LABEL      4
+
+// in cockpit.cxx
+extern float get_throttleval ( void );
+extern float get_aileronval  ( void );
+extern float get_elevatorval ( void );
+extern float get_elev_trimval( void );
+extern float get_rudderval   ( void );
+extern float get_speed       ( void );
+extern float get_aoa         ( void );
+extern float get_roll        ( void );
+extern float get_pitch       ( void );
+extern float get_heading     ( void );
+extern float get_view_direction( void );
+extern float get_altitude    ( void );
+extern float get_agl         ( void );
+extern float get_sideslip    ( void );
+extern float get_frame_rate  ( void );
+extern float get_latitude    ( void );
+extern float get_lat_min     ( void );
+extern float get_longitude   ( void );
+extern float get_long_min    ( void );
+extern float get_fov         ( void );
+extern float get_vfc_ratio   ( void );
+extern float get_vfc_tris_drawn   ( void );
+extern float get_vfc_tris_culled   ( void );
+extern float get_climb_rate  ( void );
+extern char *coord_format_lat(float);
+extern char *coord_format_lon(float);
+//extern char *coord_format_latlon(float latitude, float longitude);  // cockpit.cxx
+
+extern char *get_formated_gmt_time( void );
 
 enum  hudinstype{ HUDno_instr,
               HUDscale,
@@ -191,6 +203,131 @@ typedef struct gltagRGBTRIPLE { // rgbt
     GLfloat Green;
     GLfloat Red;
 } glRGBTRIPLE;
+/*
+struct fgVertex2D {
+    UINT x, y;
+
+    fgVertex2D( UINT a = 0, UINT b =0 )
+        : x(a), y(b) {}
+
+    fgVertex2D( const fgVertex2D & image )
+        : x(image.x), y(image.y) {}
+
+    fgVertex2D& operator= ( const fgVertex2D & image ) {
+        x = image.x; y = image.y; return *this;
+    }
+
+    ~fgVertex2D() {}
+};
+*/
+class fgLineSeg2D {
+private:
+    GLfloat x0, y0, x1, y1;  //UINT
+
+public:
+    fgLineSeg2D( GLfloat a = 0, GLfloat b =0, GLfloat c = 0, GLfloat d =0 )
+        : x0(a), y0(b),  x1(c), y1(d) {}
+
+    fgLineSeg2D( const fgLineSeg2D & image )
+        : x0(image.x0), y0(image.y0), x1(image.x1), y1(image.y1) {}
+
+    fgLineSeg2D& operator= ( const fgLineSeg2D & image ) {
+        x0 = image.x0; y0 = image.y0; x1 = image.x1; y1 = image.y1; return *this;
+    }
+
+    ~fgLineSeg2D() {}
+    
+    void draw()
+    {
+        glVertex2f(x0, y0);
+        glVertex2f(x1, y1);
+    }
+};
+
+#define USE_HUD_TextList
+#ifdef USE_HUD_TextList
+
+//#define FAST_TEXT_TEST
+#ifdef FAST_TEXT_TEST
+extern void Font_Setup(void);
+extern unsigned int font_base;
+#endif
+
+class fgTextString {
+private:
+    void *font;
+    char msg[80];
+    float x, y;
+//  static GLfloat mat[16];
+
+public:
+    fgTextString( void *d = NULL, char *c = NULL, UINT x = 0, UINT y =0 )
+        :  font(d), x(x), y(y) {strcpy(msg,c);}
+
+    fgTextString( const fgTextString & image )
+        : font(image.font), x(image.x), y(image.y) {strcpy(msg,image.msg);}
+
+    fgTextString& operator = ( const fgTextString & image ) {
+        font = image.font; strcpy(msg,image.msg); x = image.x; y = image.y;
+        return *this;
+    }
+
+    ~fgTextString() {msg[0]='\0';}
+
+//  void set_mat(void) {
+//          glScalef(.075, .075, 0.0);
+//          glGetFloatv(GL_MODELVIEW_MATRIX, mat);
+//  }
+    
+
+    void draw()
+    {
+#ifdef FAST_TEXT_TEST
+        glRasterPos2f( x, y);
+        int len = (int) strlen(msg);
+        for (int i=0; i < len; i++) {
+            glCallList(font_base+msg[i]);
+        }
+//      glFontTextOut ( msg, x, y, 0.0f);
+        
+#else
+#define USE_STROKED_CHAR
+#ifdef USE_STROKED_CHAR
+        int c;
+        char *buf;
+        buf = msg;
+        if(*buf)
+        {
+//          glRasterPos2f( x, y);
+            glTranslatef( x, y, 0);
+            glScalef(.075, .075, 0.0);
+            while ((c=*buf++)) {
+                glutStrokeCharacter( GLUT_STROKE_MONO_ROMAN, c);
+            }
+        }
+#else
+        char *c = msg;
+        if(*c)
+        {
+            glRasterPos2f(x, y);
+            while (*c) {
+                glutBitmapCharacter(font, *c);
+                c++;
+            }
+        }
+#endif // #ifdef USE_STROKED_CHAR
+#endif // FAST_TEXT_TEST
+    }
+};
+
+typedef vector< fgTextString > TYPE_HUD_TextList;
+extern TYPE_HUD_TextList HUD_TextList;
+#endif //#ifdef USE_HUD_TextList
+
+
+typedef vector< fgLineSeg2D > TYPE_HUD_LineList;
+extern TYPE_HUD_LineList HUD_LineList;
+extern TYPE_HUD_LineList HUD_StippleLineList;
 
 class instr_item {  // An Abstract Base Class (ABC)
   private:
@@ -201,8 +338,8 @@ class instr_item {  // An Abstract Base Class (ABC)
     UINT               handle;
     RECT               scrn_pos;      // Framing - affects scale dimensions
                                     // and orientation. Vert vs Horz, etc.
-    DBLFNPTR           load_value_fn;
-    double             disp_factor;   // Multiply by to get numbers shown on scale.
+    FLTFNPTR           load_value_fn;
+    float              disp_factor;   // Multiply by to get numbers shown on scale.
     UINT               opts;
     bool               is_enabled;
     bool               broken;
@@ -214,8 +351,8 @@ class instr_item {  // An Abstract Base Class (ABC)
                 int            y,
                 UINT           height,
                 UINT           width,
-                DBLFNPTR       data_source,
-                double         data_scaling,
+                FLTFNPTR       data_source,
+                float         data_scaling,
                 UINT           options,
                 bool           working      = true);
 
@@ -229,28 +366,64 @@ class instr_item {  // An Abstract Base Class (ABC)
     bool         is_broken       ( void ) { return broken;    }
     bool         enabled         ( void ) { return is_enabled;}
     bool         data_available  ( void ) { return !!load_value_fn; }
-    double       get_value       ( void ) { return load_value_fn(); }
-    double       data_scaling    ( void ) { return disp_factor; }
+    float       get_value       ( void ) { return load_value_fn(); }
+    float       data_scaling    ( void ) { return disp_factor; }
     UINT         get_span        ( void ) { return scr_span;  }
     POINT        get_centroid    ( void ) { return mid_span;  }
     UINT         get_options     ( void ) { return opts;      }
 
+    UINT    huds_vert     (UINT options) { return( options  & HUDS_VERT ); }
+    UINT    huds_left     (UINT options) { return( options  & HUDS_LEFT ); }
+    UINT    huds_right    (UINT options) { return( options  & HUDS_RIGHT ); }
+    UINT    huds_both     (UINT options) { return( (options & HUDS_BOTH) == HUDS_BOTH ); }
+    UINT    huds_noticks  (UINT options) { return( options  & HUDS_NOTICKS ); }
+    UINT    huds_notext   (UINT options) { return( options  & HUDS_NOTEXT ); }
+    UINT    huds_top      (UINT options) { return( options  & HUDS_TOP ); }
+    UINT    huds_bottom   (UINT options) { return( options  & HUDS_BOTTOM ); }
+  
     virtual void display_enable( bool working ) { is_enabled = !! working;}
 
-
     virtual void update( void );
     virtual void break_display ( bool bad );
     virtual void SetBrightness( int illumination_level ); // fgHUDSetBright...
     void         SetPosition  ( int x, int y, UINT width, UINT height );
     UINT    get_Handle( void );
     virtual void draw( void ) = 0;   // Required method in derived classes
+    
+    void drawOneLine( UINT x1, UINT y1, UINT x2, UINT y2)
+    {
+        HUD_LineList.push_back(fgLineSeg2D(x1,y1,x2,y2));
+//    glBegin(GL_LINES);
+//    glVertex2i(x1, y1);
+//    glVertex2i(x2, y2);
+//    glEnd();
+    }
+    void drawOneStippleLine( UINT x1, UINT y1, UINT x2, UINT y2)
+    {
+        HUD_StippleLineList.push_back(fgLineSeg2D(x1,y1,x2,y2));
+//      glEnable(GL_LINE_STIPPLE);
+//      glLineStipple( 1, 0x00FF );
+//      glBegin(GL_LINES);
+//      glVertex2i(x1, y1);
+//      glVertex2i(x2, y2);
+//      glEnd();
+//      glDisable(GL_LINE_STIPPLE);
+    }
+#ifdef USE_HUD_TextList
+    void TextString( void *font, char *msg, UINT x, UINT y )
+    {
+        HUD_TextList.push_back(fgTextString(font, msg, x, y));      
+    }
+#endif
 };
 
-typedef deque< instr_item * > HudContainerType;
-typedef HudContainerType::iterator HudIterator;
-
 typedef instr_item *HIptr;
-extern HudContainerType HUD_deque;
+//typedef deque <  instr_item * > hud_deque_type;
+//typedef hud_deque_type::iterator hud_deque_iterator;
+//typedef hud_deque_type::const_iterator hud_deque_const_iterator;
+
+extern deque< instr_item *> HUD_deque;
+//extern hud_deque_type HUD_deque;
 
 // instr_item           This class has no other purpose than to maintain
 //                      a linked list of instrument and derived class
@@ -265,17 +438,18 @@ class instr_label : public instr_item {
     fgLabelJust justify;
     int         fontSize;
     int         blink;
+    char format_buffer[80];
 
   public:
     instr_label( int          x,
                  int          y,
                  UINT         width,
                  UINT         height,
-                 DBLFNPTR     data_source,
+                 FLTFNPTR     data_source,
                  const char  *label_format,
                  const char  *pre_label_string  = 0,
                  const char  *post_label_string = 0,
-                 double       scale_data        = 1.0,
+                 float       scale_data        = 1.0,
                  UINT         options           = HUDS_TOP,
                  fgLabelJust  justification     = CENTER_JUST,
                  int          font_size         = SMALL,
@@ -291,6 +465,77 @@ class instr_label : public instr_item {
 
 typedef instr_label * pInstlabel;
 
+
+class lat_label : public instr_item {
+  private:
+    const char *pformat;
+    const char *pre_str;
+    const char *post_str;
+    fgLabelJust justify;
+    int         fontSize;
+    int         blink;
+    char format_buffer[80];
+
+  public:
+    lat_label( int          x,
+                 int          y,
+                 UINT         width,
+                 UINT         height,
+                 FLTFNPTR     data_source,
+                 const char  *label_format,
+                 const char  *pre_label_string  = 0,
+                 const char  *post_label_string = 0,
+                 float       scale_data        = 1.0,
+                 UINT         options           = HUDS_TOP,
+                 fgLabelJust  justification     = CENTER_JUST,
+                 int          font_size         = SMALL,
+                 int          blinking          = NOBLINK,
+                 bool         working           = true);
+
+    ~lat_label();
+
+    lat_label( const lat_label & image);
+    lat_label & operator = (const lat_label & rhs );
+    virtual void draw( void );       // Required method in base class
+};
+
+typedef lat_label * pLatlabel;
+
+class lon_label : public instr_item {
+  private:
+    const char *pformat;
+    const char *pre_str;
+    const char *post_str;
+    fgLabelJust justify;
+    int         fontSize;
+    int         blink;
+    char format_buffer[80];
+
+  public:
+    lon_label( int          x,
+                 int          y,
+                 UINT         width,
+                 UINT         height,
+                 FLTFNPTR     data_source,
+                 const char  *label_format,
+                 const char  *pre_label_string  = 0,
+                 const char  *post_label_string = 0,
+                 float       scale_data        = 1.0,
+                 UINT         options           = HUDS_TOP,
+                 fgLabelJust  justification     = CENTER_JUST,
+                 int          font_size         = SMALL,
+                 int          blinking          = NOBLINK,
+                 bool         working           = true);
+
+    ~lon_label();
+
+    lon_label( const lon_label & image);
+    lon_label & operator = (const lon_label & rhs );
+    virtual void draw( void );       // Required method in base class
+};
+
+typedef lon_label * pLonlabel;
+
 //
 // instr_scale           This class is an abstract base class for both moving
 //                       scale and moving needle (fixed scale) indicators. It
@@ -299,10 +544,10 @@ typedef instr_label * pInstlabel;
 
 class instr_scale : public instr_item {
   private:
-    double range_shown;   // Width Units.
-    double Maximum_value; //                ceiling.
-    double Minimum_value; // Representation floor.
-    double scale_factor;  // factor => screen units/range values.
+    float range_shown;   // Width Units.
+    float Maximum_value; //                ceiling.
+    float Minimum_value; // Representation floor.
+    float scale_factor;  // factor => screen units/range values.
     UINT   Maj_div;       // major division marker units
     UINT   Min_div;       // minor division marker units
     UINT   Modulo;        // Roll over point
@@ -313,12 +558,12 @@ class instr_scale : public instr_item {
                  int          y,
                  UINT         width,
                  UINT         height,
-                 DBLFNPTR     load_fn,
+                 FLTFNPTR     load_fn,
                  UINT         options,
-                 double       show_range,
-                 double       max_value    = 100.0,
-                 double       min_value    =   0.0,
-                 double       disp_scaling =   1.0,
+                 float       show_range,
+                 float       max_value    = 100.0,
+                 float       min_value    =   0.0,
+                 float       disp_scaling =   1.0,
                  UINT         major_divs   =    10,
                  UINT         minor_divs   =     5,
                  UINT         rollover     =     0,
@@ -332,11 +577,11 @@ class instr_scale : public instr_item {
     virtual void draw   ( void ) {}; // No-op here. Defined in derived classes.
     UINT   div_min      ( void ) { return Min_div;}
     UINT   div_max      ( void ) { return Maj_div;}
-    double min_val      ( void ) { return Minimum_value;}
-    double max_val      ( void ) { return Maximum_value;}
+    float min_val      ( void ) { return Minimum_value;}
+    float max_val      ( void ) { return Maximum_value;}
     UINT   modulo       ( void ) { return Modulo; }
-    double factor       ( void ) { return scale_factor;}
-    double range_to_show( void ) { return range_shown;}
+    float factor       ( void ) { return scale_factor;}
+    float range_to_show( void ) { return range_shown;}
 };
 
 // hud_card_               This class displays the indicated quantity on
@@ -346,24 +591,24 @@ class instr_scale : public instr_item {
 
 class hud_card : public instr_scale {
   private:
-    double val_span;
-    double half_width_units;
-
+    float val_span;
+    float half_width_units;
+    
   public:
     hud_card( int      x,
               int      y,
               UINT     width,
               UINT     height,
-              DBLFNPTR load_fn,
+              FLTFNPTR load_fn,
               UINT     options,
-              double   maxValue      = 100.0,
-              double   minValue      =   0.0,
-              double   disp_scaling  =   1.0,
+              float   maxValue      = 100.0,
+              float   minValue      =   0.0,
+              float   disp_scaling  =   1.0,
               UINT     major_divs    =  10,
               UINT     minor_divs    =   5,
               UINT     modulator     = 100,
               int      dp_showing    =   2,
-              double   value_span    = 100.0,
+              float   value_span    = 100.0,
               bool     working       = true);
 
     ~hud_card();
@@ -376,18 +621,16 @@ class hud_card : public instr_scale {
 typedef hud_card * pCardScale;
 
 class guage_instr : public instr_scale {
-  private:
-
   public:
     guage_instr( int       x,
                  int       y,
                  UINT      width,
                  UINT      height,
-                 DBLFNPTR  load_fn,
+                 FLTFNPTR  load_fn,
                  UINT      options,
-                 double    disp_scaling = 1.0,
-                 double    maxValue     = 100,
-                 double    minValue     =   0,
+                 float    disp_scaling = 1.0,
+                 float    maxValue     = 100,
+                 float    minValue     =   0,
                  UINT      major_divs   =  50,
                  UINT      minor_divs   =   0,
                  int       dp_showing   =   2,
@@ -407,15 +650,15 @@ typedef guage_instr * pGuageInst;
 
 class dual_instr_item : public instr_item {
   private:
-    DBLFNPTR alt_data_source;
+    FLTFNPTR alt_data_source;
 
   public:
     dual_instr_item ( int       x,
                       int       y,
                       UINT      width,
                       UINT      height,
-                      DBLFNPTR  chn1_source,
-                      DBLFNPTR  chn2_source,
+                      FLTFNPTR  chn1_source,
+                      FLTFNPTR  chn2_source,
                       bool      working     = true,
                       UINT      options  = HUDS_TOP);
 
@@ -423,8 +666,8 @@ class dual_instr_item : public instr_item {
     dual_instr_item( const dual_instr_item & image);
     dual_instr_item & operator = (const dual_instr_item & rhs );
 
-    double current_ch1( void ) { return alt_data_source();}
-    double current_ch2( void ) { return get_value();}
+    float current_ch1( void ) { return (float)alt_data_source();}
+    float current_ch2( void ) { return (float)get_value();}
     virtual void draw ( void ) { }
 };
 
@@ -439,11 +682,11 @@ class fgTBI_instr : public dual_instr_item {
                  int       y,
                  UINT      width,
                  UINT      height,
-                 DBLFNPTR  chn1_source  = get_roll,
-                 DBLFNPTR  chn2_source  = get_sideslip,
-                 double    maxBankAngle = 45.0,
-                 double    maxSlipAngle =  5.0,
-                 UINT      gap_width    =  5.0,
+                 FLTFNPTR  chn1_source  = get_roll,
+                 FLTFNPTR  chn2_source  = get_sideslip,
+                 float    maxBankAngle = 45.0,
+                 float    maxSlipAngle =  5.0,
+                 UINT      gap_width    =  5,
                  bool      working      =  true);
 
     fgTBI_instr( const fgTBI_instr & image);
@@ -466,20 +709,20 @@ class HudLadder : public dual_instr_item {
     UINT   minor_div;
     UINT   label_pos;
     UINT   scr_hole;
-    double vmax;
-    double vmin;
-    double factor;
+    float vmax;
+    float vmin;
+    float factor;
 
   public:
     HudLadder( int       x,
                int       y,
                UINT      width,
                UINT      height,
-               DBLFNPTR  ptch_source    = get_roll,
-               DBLFNPTR  roll_source    = get_pitch,
-               double    span_units     = 45.0,
-               double    division_units = 10.0,
-               double    minor_division =  0.0,
+               FLTFNPTR  ptch_source    = get_roll,
+               FLTFNPTR  roll_source    = get_pitch,
+               float    span_units     = 45.0,
+               float    division_units = 10.0,
+               float    minor_division =  0.0,
                UINT      screen_hole    =   70,
                UINT      lbl_pos        =    0,
                bool      working        = true );
@@ -511,6 +754,11 @@ extern void strokeString( int x,
                           char *msg,
                           void *font = GLUT_STROKE_ROMAN,
                           float theta = 0);
+//extern void strokeString(float xx,
+//                       float yy,
+//                       char *msg,
+//                       void *font = GLUT_STROKE_ROMAN)
+
 /*
 bool AddHUDInstrument( instr_item *pBlackBox );
 void DrawHUD ( void );
@@ -524,4 +772,3 @@ void fgHUDSetTimeMode( Hptr hud, int time_of_day );
 */
 
 #endif // _HUD_H
-
diff --git a/Simulator/Cockpit/hud_card.cxx b/Simulator/Cockpit/hud_card.cxx
index a43f343f5..965c34704 100644
--- a/Simulator/Cockpit/hud_card.cxx
+++ b/Simulator/Cockpit/hud_card.cxx
@@ -8,6 +8,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <Aircraft/aircraft.hxx>
+#include <GUI/gui.h>
 #include <Include/fg_constants.h>
 #include <Math/fg_random.h>
 #include <Math/mat3.h>
@@ -15,8 +16,12 @@
 #include <Scenery/scenery.hxx>
 #include <Time/fg_timer.hxx>
 
-
 #include "hud.hxx"
+
+#ifdef USE_HUD_TextList
+#define textString( x , y, text, font )  TextString( font, text, x , y )
+#endif
+
 //========== Top of hud_card class member definitions =============
 
 hud_card ::
@@ -24,16 +29,16 @@ hud_card( int       x,
           int       y,
           UINT      width,
           UINT      height,
-          DBLFNPTR  data_source,
+          FLTFNPTR  data_source,
           UINT      options,
-          double    max_value,
-          double    min_value,
-          double    disp_scaling,
+          float    max_value, // 360
+          float    min_value, // 0
+          float    disp_scaling,
           UINT      major_divs,
           UINT      minor_divs,
-          UINT      modulus,
+          UINT      modulus,  // 360
           int       dp_showing,
-          double    value_span,
+          float    value_span,
           bool      working) :
                 instr_scale( x,y,width,height,
                              data_source, options,
@@ -44,6 +49,14 @@ hud_card( int       x,
                 val_span   ( value_span)
 {
   half_width_units = range_to_show() / 2.0;
+//  UINT options     = get_options();
+//  huds_both = (options & HUDS_BOTH) == HUDS_BOTH;
+//  huds_right = options & HUDS_RIGHT;
+//  huds_left = options & HUDS_LEFT;
+//  huds_vert = options & HUDS_VERT;
+//  huds_notext = options & HUDS_NOTEXT;
+//  huds_top = options & HUDS_TOP;
+//  huds_bottom = options & HUDS_BOTTOM;
 }
 
 hud_card ::
@@ -55,6 +68,14 @@ hud_card( const hud_card & image):
       val_span( image.val_span),
       half_width_units (image.half_width_units)
 {
+//  UINT options     = get_options();
+//  huds_both = (options & HUDS_BOTH) == HUDS_BOTH;
+//  huds_right = options & HUDS_RIGHT;
+//  huds_left = options & HUDS_LEFT;
+//  huds_vert = options & HUDS_VERT;
+//  huds_notext = options & HUDS_NOTEXT;
+//  huds_top = options & HUDS_TOP;
+//  huds_bottom = options & HUDS_BOTTOM;
 }
 
 hud_card & hud_card ::
@@ -71,73 +92,97 @@ operator = (const hud_card & rhs )
 void hud_card ::
 draw( void ) //  (HUD_scale * pscale )
 {
-  double vmin, vmax;
+  float vmin, vmax;
   int marker_xs;
   int marker_xe;
   int marker_ys;
   int marker_ye;
-  /* register */ int i;
+  int lenstr;
+  int height, width;
+  int i, last;
   char TextScale[80];
   bool condition;
   int disp_val = 0;
   POINT mid_scr    = get_centroid();
-  double cur_value = get_value();
+  float cur_value  = get_value();
   RECT   scrn_rect = get_location();
   UINT options     = get_options();
 
+  height = scrn_rect.top  + scrn_rect.bottom;
+  width = scrn_rect.left + scrn_rect.right;
+
   vmin = cur_value - half_width_units; // width units == needle travel
   vmax = cur_value + half_width_units; // or picture unit span.
-    // Draw the basic markings for the scale...
-
-  if( options & HUDS_VERT ) { // Vertical scale
+  
+  // Draw the basic markings for the scale...
+  
+  if( huds_vert(options) ) { // Vertical scale
     drawOneLine( scrn_rect.left,     // Bottom tick bar
                  scrn_rect.top,
-                 scrn_rect.left + scrn_rect.right,
+                 width,
                  scrn_rect.top);
 
     drawOneLine( scrn_rect.left,    // Top tick bar
-                 scrn_rect.top  + scrn_rect.bottom,
-                 scrn_rect.left + scrn_rect.right,
-                 scrn_rect.top  + scrn_rect.bottom );
-
-    marker_xs = scrn_rect.left;
-    marker_xe = scrn_rect.left + scrn_rect.right;
+                 height,
+                 width,
+                 height );
+      
+      marker_xs = scrn_rect.left;  // x start
+      marker_xe = width;  // x extent
+      marker_ye = height;
+
+//    glBegin(GL_LINES);
+      
+      // Bottom tick bar
+//    glVertex2f( marker_xs, scrn_rect.top);
+//    glVertex2f( marker_xe, scrn_rect.top);
+
+      // Top tick bar
+//    glVertex2f( marker_xs, marker_ye);
+//    glVertex2f( marker_xe, marker_ye );
+//    glEnd();
 
     // We do not use else in the following so that combining the two
     // options produces a "caged" display with double carrots. The
     // same is done for horizontal card indicators.
 
-    if( options & HUDS_LEFT ) {    // Calculate x marker offset
-      drawOneLine( scrn_rect.left + scrn_rect.right,
-                   scrn_rect.top,
-                   scrn_rect.left + scrn_rect.right,
-                   scrn_rect.top + scrn_rect.bottom); // Cap right side
+      if( huds_left(options) ) {    // Calculate x marker offset
+          drawOneLine( marker_xe, scrn_rect.top,
+                       marker_xe, marker_ye); // Cap right side
 
-      marker_xs  = marker_xe - scrn_rect.right / 3;   // Adjust tick xs
+        marker_xs  = marker_xe - scrn_rect.right / 3;   // Adjust tick xs
                                                       // Indicator carrot
-      drawOneLine( marker_xs, mid_scr.y,
-                   marker_xe, mid_scr.y + scrn_rect.right / 6);
-      drawOneLine( marker_xs, mid_scr.y,
-                   marker_xe, mid_scr.y - scrn_rect.right / 6);
-
-      }
-    if( options & HUDS_RIGHT ) {  // We'll default this for now.
-      drawOneLine( scrn_rect.left,
-                   scrn_rect.top,
-                   scrn_rect.left,
-                   scrn_rect.top + scrn_rect.bottom);  // Cap left side
+//      drawOneLine( marker_xs, mid_scr.y,
+//                   marker_xe, mid_scr.y + scrn_rect.right / 6);
+//      drawOneLine( marker_xs, mid_scr.y,
+//                   marker_xe, mid_scr.y - scrn_rect.right / 6);
+
+        glBegin(GL_LINE_STRIP);
+        glVertex2f( marker_xe, mid_scr.y + scrn_rect.right / 6);
+        glVertex2f( marker_xs, mid_scr.y);
+        glVertex2f( marker_xe, mid_scr.y - scrn_rect.right / 6);
+        glEnd();
+    }
+    if( huds_right(options) ) {  // We'll default this for now.
+        drawOneLine( scrn_rect.left, scrn_rect.top,
+                     scrn_rect.left, marker_ye );  // Cap left side
 
-      marker_xe = scrn_rect.left + scrn_rect.right / 3;     // Adjust tick xe
+        marker_xe = scrn_rect.left + scrn_rect.right / 3;     // Adjust tick xe
                                                        // Indicator carrot
-      drawOneLine( scrn_rect.left, mid_scr.y +  scrn_rect.right / 6,
-                   marker_xe, mid_scr.y );
-      drawOneLine( scrn_rect.left, mid_scr.y -  scrn_rect.right / 6,
-                   marker_xe, mid_scr.y);
-      }
+//      drawOneLine( scrn_rect.left, mid_scr.y +  scrn_rect.right / 6,
+//                   marker_xe, mid_scr.y );
+//      drawOneLine( scrn_rect.left, mid_scr.y -  scrn_rect.right / 6,
+//                   marker_xe, mid_scr.y);
+        glBegin(GL_LINE_STRIP);
+        glVertex2f( scrn_rect.left, mid_scr.y +  scrn_rect.right / 6);
+        glVertex2f( marker_xe, mid_scr.y );
+        glVertex2f( scrn_rect.left, mid_scr.y -  scrn_rect.right / 6);
+        glEnd();
+    }
 
     // At this point marker x_start and x_end values are transposed.
     // To keep this from confusing things they are now interchanged.
-    if(( options & HUDS_BOTH) == HUDS_BOTH) {
+    if(huds_both(options)) {
       marker_ye = marker_xs;
       marker_xs = marker_xe;
       marker_xe = marker_ye;
@@ -146,7 +191,12 @@ draw( void ) //  (HUD_scale * pscale )
     // Work through from bottom to top of scale. Calculating where to put
     // minor and major ticks.
 
-    for( i = (int)vmin; i <= (int)vmax; i++ )      {
+//  last = FloatToInt(vmax)+1;
+//  i = FloatToInt(vmin);
+    last = (int)vmax + 1;
+    i = (int)vmin;
+    for( ; i <last ; i++ )
+    {
       condition = true;
       if( !modulo()) {
         if( i < min_val()) {
@@ -156,28 +206,35 @@ draw( void ) //  (HUD_scale * pscale )
 
       if( condition ) {  // Show a tick if necessary
                          // Calculate the location of this tick
-        marker_ys = scrn_rect.top + (int)((i - vmin) * factor() + .5);
-
+        marker_ys = scrn_rect.top + FloatToInt(((i - vmin) * factor()/*+.5f*/));
+//        marker_ys = scrn_rect.top + (int)((i - vmin) * factor() + .5);
         // Block calculation artifact from drawing ticks below min coordinate.
         // Calculation here accounts for text height.
 
         if(( marker_ys < (scrn_rect.top + 4)) |
-           ( marker_ys > (scrn_rect.top + scrn_rect.bottom - 4))) {
+           ( marker_ys > (height - 4))) {
             // Magic numbers!!!
           continue;
           }
         if( div_min()) {
-          if( (i%div_min()) == 0) {
+//          if( (i%div_min()) == 0) {
+          if( !(i%(int)div_min())) {            
             if((( marker_ys - 5) > scrn_rect.top ) &&
-               (( marker_ys + 5) < (scrn_rect.top + scrn_rect.bottom))){
-              if( (options & HUDS_BOTH) == HUDS_BOTH ) {
+               (( marker_ys + 5) < (height))){
+              if( huds_both(options) ) {
                 drawOneLine( scrn_rect.left, marker_ys,
                              marker_xs,      marker_ys );
                 drawOneLine( marker_xe,      marker_ys,
-                             scrn_rect.left + scrn_rect.right,  marker_ys );
-                }
+                             width,  marker_ys );
+//                glBegin(GL_LINES);
+//                glVertex2f( scrn_rect.left, marker_ys );
+//                glVertex2f( marker_xs,      marker_ys );
+//                glVertex2f( marker_xe,      marker_ys);
+//                glVertex2f( scrn_rect.left + scrn_rect.right,  marker_ys );
+//                glEnd();
+                  }
               else {
-                if( options & HUDS_LEFT ) {
+                if( huds_left(options) ) {
                   drawOneLine( marker_xs + 4, marker_ys,
                                marker_xe,     marker_ys );
                   }
@@ -189,46 +246,55 @@ draw( void ) //  (HUD_scale * pscale )
               }
             }
           }
-        if( div_max()) {
-          if( !(i%(int)div_max())){
+        if( div_max() ) {
+          if( !(i%(int)div_max()) )         
+          {
             if(modulo()) {
-              if( disp_val < 0) {
-                disp_val += modulo();
-                }
-              else {
-                disp_val = i % modulo();
+                if( disp_val < 0) {
+                    while(disp_val < 0)
+                        disp_val += modulo();
+//              } else {
+//                  disp_val = i % (int)modulo();
                 }
-              }
-            else {
-              disp_val = i;
-              }
-            sprintf( TextScale, "%d", (int)(disp_val  * data_scaling() +.5));
+                disp_val = i % (int) modulo(); // ?????????
+            } else {
+                disp_val = i;
+            }
+
+            lenstr = sprintf( TextScale, "%d",
+                              FloatToInt(disp_val * data_scaling()/*+.5*/));
+//                            (int)(disp_val  * data_scaling() +.5));
             if(( (marker_ys - 8 ) > scrn_rect.top ) &&
-               ( (marker_ys + 8) < (scrn_rect.top + scrn_rect.bottom))){
-              if( (options & HUDS_BOTH) == HUDS_BOTH) {
-                drawOneLine( scrn_rect.left, marker_ys,
-                             marker_xs,      marker_ys);
-                drawOneLine( marker_xs,                  marker_ys,
-                             scrn_rect.left + scrn_rect.right,
-                             marker_ys);
-                if( !(options & HUDS_NOTEXT)) {
-                  textString ( marker_xs + 2,  marker_ys,
-                               TextScale,  GLUT_BITMAP_8_BY_13 );
+               ( (marker_ys + 8) < (height))){
+              if( huds_both(options) ) {
+//                drawOneLine( scrn_rect.left, marker_ys,
+//                             marker_xs,      marker_ys);
+//                drawOneLine( marker_xs, marker_ys,
+//                             scrn_rect.left + scrn_rect.right,
+//                             marker_ys);
+                  glBegin(GL_LINE_STRIP);
+                  glVertex2f( scrn_rect.left, marker_ys );
+                  glVertex2f( marker_xs, marker_ys);
+                  glVertex2f( width, marker_ys);
+                  glEnd();
+                  if( !huds_notext(options)) {
+                      textString ( marker_xs + 2,  marker_ys,
+                                   TextScale,  GLUT_BITMAP_8_BY_13 );
                   }
-                }
+              }
               else {
                 drawOneLine( marker_xs, marker_ys, marker_xe, marker_ys );
-                if( !(options & HUDS_NOTEXT)) {
-                  if( options & HUDS_LEFT )              {
-                    textString( marker_xs -  8 * strlen(TextScale) - 2,
-                                marker_ys - 4,
-                                TextScale, GLUT_BITMAP_8_BY_13 );
+                if( !huds_notext(options) ) {
+                  if( huds_left(options) )              {
+                      textString( marker_xs -  8 * lenstr - 2,
+                                  marker_ys - 4,
+                                  TextScale, GLUT_BITMAP_8_BY_13 );
                     }
                   else  {
-                    textString( marker_xe + 3 * strlen(TextScale),
-                                marker_ys - 4,
-                                TextScale, GLUT_BITMAP_8_BY_13 );
-                    }
+                      textString( marker_xe + 3 * lenstr,
+                                  marker_ys - 4,
+                                  TextScale, GLUT_BITMAP_8_BY_13 );
+                  }
                   }
                 }
               } // Else read oriented right
@@ -238,50 +304,73 @@ draw( void ) //  (HUD_scale * pscale )
       } // End for range of i from vmin to vmax
     }  // End if VERTICAL SCALE TYPE
   else {                                // Horizontal scale by default
-    drawOneLine( scrn_rect.left,     // left tick bar
-                 scrn_rect.top,
-                 scrn_rect.left,
-                 scrn_rect.top + scrn_rect.bottom);
-
-    drawOneLine( scrn_rect.left + scrn_rect.right,    // right tick bar
-                 scrn_rect.top,
-                 scrn_rect.left + scrn_rect.right,
-                 scrn_rect.top  + scrn_rect.bottom );
-
-    marker_ys = scrn_rect.top;                       // Starting point for
-    marker_ye = scrn_rect.top + scrn_rect.bottom;    // tick y location calcs
-
-    if( options & HUDS_TOP ) {
-      drawOneLine( scrn_rect.left,
-                   scrn_rect.top,
-                   scrn_rect.left + scrn_rect.right,
-                   scrn_rect.top);                    // Bottom box line
-
-      marker_ye  = scrn_rect.top + scrn_rect.bottom / 2;   // Tick point adjust
-                                                      // Bottom arrow
-      drawOneLine( mid_scr.x, marker_ye,
-                   mid_scr.x - scrn_rect.bottom / 4, scrn_rect.top);
-      drawOneLine( mid_scr.x, marker_ye,
-                   mid_scr.x + scrn_rect.bottom / 4, scrn_rect.top);
-      }
-    if( options & HUDS_BOTTOM) {
-      drawOneLine( scrn_rect.left,
-                   scrn_rect.top + scrn_rect.bottom,
-                   scrn_rect.left + scrn_rect.right,
-                   scrn_rect.top + scrn_rect.bottom);  // Top box line
-                                                       // Tick point adjust
-      marker_ys = scrn_rect.top +
-                  scrn_rect.bottom - scrn_rect.bottom  / 2;
-                                                       // Top arrow
-      drawOneLine( mid_scr.x + scrn_rect.bottom / 4,
-                          scrn_rect.top + scrn_rect.bottom,
-                   mid_scr.x ,
-                          marker_ys );
-      drawOneLine( mid_scr.x - scrn_rect.bottom / 4,
-                          scrn_rect.top + scrn_rect.bottom,
-                   mid_scr.x ,
-                          marker_ys );
-      }
+      // left tick bar
+      drawOneLine( scrn_rect.left, scrn_rect.top,
+                   scrn_rect.left, height);
+
+      // right tick bar
+      drawOneLine( width, scrn_rect.top,
+                 width,
+                 height );
+      
+      marker_ys = scrn_rect.top;           // Starting point for
+      marker_ye = height;                  // tick y location calcs
+      marker_xe = width;
+
+//    glBegin(GL_LINES);
+      // left tick bar
+//    glVertex2f( scrn_rect.left, scrn_rect.top);
+//    glVertex2f( scrn_rect.left, marker_ye);
+
+      // right tick bar
+//    glVertex2f( marker_xe, scrn_rect.top);
+//    glVertex2f( marker_xe, marker_ye );
+//    glEnd();
+
+    if( huds_top(options) ) {
+        // Bottom box line
+        drawOneLine( scrn_rect.left,
+                     scrn_rect.top,
+                     width,
+                     scrn_rect.top);
+
+        // Tick point adjust
+        marker_ye  = scrn_rect.top + scrn_rect.bottom / 2;
+        
+        // Bottom arrow
+//      drawOneLine( mid_scr.x, marker_ye,
+//                   mid_scr.x - scrn_rect.bottom / 4, scrn_rect.top);
+//      drawOneLine( mid_scr.x, marker_ye,
+//                   mid_scr.x + scrn_rect.bottom / 4, scrn_rect.top);
+
+        glBegin(GL_LINE_STRIP);
+        glVertex2f( mid_scr.x - scrn_rect.bottom / 4, scrn_rect.top);
+        glVertex2f( mid_scr.x, marker_ye);
+        glVertex2f( mid_scr.x + scrn_rect.bottom / 4, scrn_rect.top);
+        glEnd();
+    }
+    if( huds_bottom(options) ) {
+        // Top box line
+        drawOneLine( scrn_rect.left, height,
+                     width, height);
+        // Tick point adjust
+        marker_ys = height - scrn_rect.bottom  / 2;
+        
+        // Top arrow
+//      drawOneLine( mid_scr.x + scrn_rect.bottom / 4,
+//                   scrn_rect.top + scrn_rect.bottom,
+//                   mid_scr.x, marker_ys );
+//      drawOneLine( mid_scr.x - scrn_rect.bottom / 4,
+//                   scrn_rect.top + scrn_rect.bottom,
+//                   mid_scr.x , marker_ys );
+        glBegin(GL_LINE_STRIP);
+        glVertex2f( mid_scr.x + scrn_rect.bottom / 4,
+                    height);
+        glVertex2f( mid_scr.x , marker_ys );
+        glVertex2f( mid_scr.x - scrn_rect.bottom / 4,
+                    height);
+        glEnd();
+    }
 
 //    if(( options & HUDS_BOTTOM) == HUDS_BOTTOM ) {
 //      marker_xe = marker_ys;
@@ -290,7 +379,13 @@ draw( void ) //  (HUD_scale * pscale )
 //      }
 
     // printf("vmin = %d  vmax = %d\n", (int)vmin, (int)vmax);
-    for( i = (int)vmin; i <= (int)vmax; i++ )     {
+
+//  last = FloatToInt(vmax)+1;
+//  i    = FloatToInt(vmin);
+    last = (int)vmax + 1;
+    i = (int)vmin;
+    for(; i <last ; i++ )      {
+//    for( i = (int)vmin; i <= (int)vmax; i++ )     {
       // printf("<*> i = %d\n", i);
       condition = true;
       if( !modulo()) {
@@ -300,21 +395,29 @@ draw( void ) //  (HUD_scale * pscale )
         }
       // printf("<**> i = %d\n", i);
       if( condition )        {
-        marker_xs = scrn_rect.left + (int)((i - vmin) * factor() + .5);
+//        marker_xs = scrn_rect.left + (int)((i - vmin) * factor() + .5);
+        marker_xs = scrn_rect.left + FloatToInt(((i - vmin) * factor()/*+ .5f*/));
         if( div_min()){
-          if( (i%(int)div_min()) == 0 ) {
+//          if( (i%(int)div_min()) == 0 ) {
+          if( !(i%(int)div_min() )) {           
             // draw in ticks only if they aren't too close to the edge.
             if((( marker_xs - 5) > scrn_rect.left ) &&
                (( marker_xs + 5 )< (scrn_rect.left + scrn_rect.right))){
 
-              if( (options & HUDS_BOTH) == HUDS_BOTH ) {
+              if( huds_both(options) ) {
                 drawOneLine( marker_xs, scrn_rect.top,
                              marker_xs, marker_ys - 4);
                 drawOneLine( marker_xs, marker_ye + 4,
-                             marker_xs, scrn_rect.top + scrn_rect.bottom);
-                }
+                             marker_xs, height);
+//                glBegin(GL_LINES);
+//                glVertex2f( marker_xs, scrn_rect.top);
+//                glVertex2f( marker_xs, marker_ys - 4);
+//                glVertex2f( marker_xs, marker_ye + 4);
+//                glVertex2f( marker_xs, scrn_rect.top + scrn_rect.bottom);
+//                glEnd();
+              }
               else {
-                if( options & HUDS_TOP) {
+                if( huds_top(options)) {
                   drawOneLine( marker_xs, marker_ys,
                                marker_xs, marker_ye - 4);
                   }
@@ -326,35 +429,40 @@ draw( void ) //  (HUD_scale * pscale )
               }
             }
           }
-	// printf("<***> i = %d\n", i);
+    // printf("<***> i = %d\n", i);
         if( div_max()) {
-	  // printf("i = %d\n", i);
-          if( (i%(int)div_max())==0 ) {
+      // printf("i = %d\n", i);
+//          if( (i%(int)div_max())==0 ) {
+          if( !(i%(int)div_max()) ) {           
             if(modulo()) {
               if( disp_val < 0) {
-                disp_val += modulo();
-                }
-              else {
-                disp_val = i % modulo();
-                }
+                  while(disp_val<0)
+                      disp_val += modulo();
               }
-            else {
+              disp_val = i % (int) modulo(); // ?????????
+            } else {
               disp_val = i;
-              }
-	    // printf("disp_val = %d\n", disp_val);
-	    // printf("%d\n", (int)(disp_val  * (double)data_scaling() + 0.5));
-            sprintf( TextScale, "%d", (int)(disp_val  * data_scaling() +.5));
+            }
+        // printf("disp_val = %d\n", disp_val);
+        // printf("%d\n", (int)(disp_val  * (double)data_scaling() + 0.5));
+            lenstr = sprintf( TextScale, "%d",
+//                            (int)(disp_val  * data_scaling() +.5));
+                              FloatToInt(disp_val * data_scaling()/*+.5*/));
             // Draw major ticks and text only if far enough from the edge.
             if(( (marker_xs - 10)> scrn_rect.left ) &&
                ( (marker_xs + 10) < (scrn_rect.left + scrn_rect.right))){
-              if( (options & HUDS_BOTH) == HUDS_BOTH) {
-                drawOneLine( marker_xs, scrn_rect.top,
-                             marker_xs, marker_ys);
-                drawOneLine( marker_xs, marker_ye,
-                             marker_xs, scrn_rect.top + scrn_rect.bottom);
-
-                if( !(options & HUDS_NOTEXT)) {
-                  textString ( marker_xs - 4 * strlen(TextScale),
+              if( huds_both(options) ) {
+//                drawOneLine( marker_xs, scrn_rect.top,
+//                             marker_xs, marker_ys);
+//                drawOneLine( marker_xs, marker_ye,
+//                             marker_xs, scrn_rect.top + scrn_rect.bottom);
+                  glBegin(GL_LINE_STRIP);
+                  glVertex2f( marker_xs, scrn_rect.top);
+                  glVertex2f( marker_xs, marker_ye);
+                  glVertex2f( marker_xs, height);
+                  glEnd();
+                if( !huds_notext(options) ) {
+                  textString ( marker_xs - 4 * lenstr,
                                marker_ys + 4,
                                TextScale,  GLUT_BITMAP_8_BY_13 );
                   }
@@ -362,14 +470,14 @@ draw( void ) //  (HUD_scale * pscale )
               else {
                 drawOneLine( marker_xs, marker_ys,
                              marker_xs, marker_ye );
-                if( !(options & HUDS_NOTEXT)) {
-                  if( options & HUDS_TOP )              {
-                    textString ( marker_xs - 4 * strlen(TextScale),
-                                 scrn_rect.top + scrn_rect.bottom - 10,
+                if( !huds_notext(options)) {
+                  if( huds_top(options) )              {
+                    textString ( marker_xs - 4 * lenstr,
+                                 height - 10,
                                  TextScale, GLUT_BITMAP_8_BY_13 );
                     }
                   else  {
-                    textString( marker_xs - 4 * strlen(TextScale),
+                    textString( marker_xs - 4 * lenstr,
                                 scrn_rect.top,
                                 TextScale, GLUT_BITMAP_8_BY_13 );
                     }
@@ -377,8 +485,8 @@ draw( void ) //  (HUD_scale * pscale )
                 }
               }
             }
-	  }
-	// printf("<****> i = %d\n", i);
+      }
+    // printf("<****> i = %d\n", i);
         }
       }
     }
diff --git a/Simulator/Cockpit/hud_dnst.cxx b/Simulator/Cockpit/hud_dnst.cxx
index f66d5706c..49dc1d2cf 100644
--- a/Simulator/Cockpit/hud_dnst.cxx
+++ b/Simulator/Cockpit/hud_dnst.cxx
@@ -25,8 +25,8 @@ dual_instr_item ::
                     int          y,
                     UINT         width,
                     UINT         height,
-                    DBLFNPTR     chn1_source,
-                    DBLFNPTR     chn2_source,
+                    FLTFNPTR     chn1_source,
+                    FLTFNPTR     chn2_source,
                     bool         working,
                     UINT         options ):
                   instr_item( x, y, width, height,
diff --git a/Simulator/Cockpit/hud_guag.cxx b/Simulator/Cockpit/hud_guag.cxx
index d6077e8e3..fec2aa4cd 100644
--- a/Simulator/Cockpit/hud_guag.cxx
+++ b/Simulator/Cockpit/hud_guag.cxx
@@ -8,6 +8,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <Aircraft/aircraft.hxx>
+#include <GUI/gui.h>
 #include <Include/fg_constants.h>
 #include <Math/fg_random.h>
 #include <Math/mat3.h>
@@ -15,8 +16,12 @@
 #include <Scenery/scenery.hxx>
 #include <Time/fg_timer.hxx>
 
-
 #include "hud.hxx"
+
+#ifdef USE_HUD_TextList
+#define textString( x , y, text, font )  TextString( font, text, x , y )
+#endif
+
 //============== Top of guage_instr class member definitions ==============
 
 guage_instr ::
@@ -24,11 +29,11 @@ guage_instr ::
                  int          y,
                  UINT         width,
                  UINT         height,
-                 DBLFNPTR     load_fn,
+                 FLTFNPTR     load_fn,
                  UINT         options,
-                 double       disp_scale,
-                 double       maxValue,
-                 double       minValue,
+                 float       disp_scale,
+                 float       maxValue,
+                 float       minValue,
                  UINT         major_divs,
                  UINT         minor_divs,
                  int          dp_showing,
@@ -43,6 +48,15 @@ guage_instr ::
                         modulus, dp_showing,
                         working)
 {
+//  UINT options = get_options();
+//  huds_vert    = options & HUDS_VERT;
+//  huds_left    = options & HUDS_LEFT;
+//  huds_right   = options & HUDS_RIGHT;
+//  huds_both    = (options & HUDS_BOTH) == HUDS_BOTH;
+//  huds_noticks = options & HUDS_NOTICKS;
+//  huds_notext  = options & HUDS_NOTEXT;
+//  huds_top     = options & HUDS_TOP;
+//  huds_bottom  = options & HUDS_BOTTOM;
 }
 
 guage_instr ::
@@ -54,6 +68,15 @@ guage_instr ::
     guage_instr( const guage_instr & image):
        instr_scale( (instr_scale &) image)
 {
+//  UINT options = get_options();
+//  huds_vert = options & HUDS_VERT;
+//  huds_left = options & HUDS_LEFT;
+//  huds_right = options & HUDS_RIGHT;
+//  huds_both = (options & HUDS_BOTH) == HUDS_BOTH;
+//  huds_noticks = options & HUDS_NOTICKS;
+//  huds_notext = options & HUDS_NOTEXT;
+//  huds_top = options & HUDS_TOP;
+//  huds_bottom =  options & HUDS_BOTTOM;
 }
 
 guage_instr & guage_instr ::
@@ -76,52 +99,60 @@ void guage_instr :: draw (void)
   int marker_xs, marker_xe;
   int marker_ys, marker_ye;
   int text_x, text_y;
+  int width, height, bottom_4;
+  int lenstr;
   int i;
   char TextScale[80];
   bool condition;
-  int disp_val;
-  double vmin         = min_val();
-  double vmax         = max_val();
+  int disp_val = 0;
+  float vmin         = min_val();
+  float vmax         = max_val();
   POINT mid_scr       = get_centroid();
-  double cur_value    = get_value();
+  float cur_value    = get_value();
   RECT   scrn_rect    = get_location();
-  UINT options        = get_options();
+  UINT options     = get_options();
+
+  width = scrn_rect.left + scrn_rect.right;
+  height = scrn_rect.top  + scrn_rect.bottom;
+  bottom_4 = scrn_rect.bottom / 4;
 
     // Draw the basic markings for the scale...
 
-  if( options & HUDS_VERT ) { // Vertical scale
+  if( huds_vert(options) ) { // Vertical scale
     drawOneLine( scrn_rect.left,     // Bottom tick bar
                  scrn_rect.top,
-                 scrn_rect.left + scrn_rect.right,
+                 width,
                  scrn_rect.top);
 
     drawOneLine( scrn_rect.left,    // Top tick bar
-                 scrn_rect.top  + scrn_rect.bottom,
-                 scrn_rect.left + scrn_rect.right,
-                 scrn_rect.top  + scrn_rect.bottom );
+                 height,
+                 width,
+                 height );
 
     marker_xs = scrn_rect.left;
-    marker_xe = scrn_rect.left + scrn_rect.right;
+    marker_xe = width;
 
-    if( options & HUDS_LEFT ) {     // Read left, so line down right side
-      drawOneLine( scrn_rect.left + scrn_rect.right,
+    if( huds_left(options) ) {     // Read left, so line down right side
+      drawOneLine( width,
                    scrn_rect.top,
-                   scrn_rect.left + scrn_rect.right,
-                   scrn_rect.top + scrn_rect.bottom);
-
+                   width,
+                   height);
+      
       marker_xs  = marker_xe - scrn_rect.right / 3;   // Adjust tick xs
-      }
-    if( options & HUDS_RIGHT ) {     // Read  right, so down left sides
+    }
+    
+    if( huds_right(options) ) {     // Read  right, so down left sides
       drawOneLine( scrn_rect.left,
                    scrn_rect.top,
                    scrn_rect.left,
-                   scrn_rect.top + scrn_rect.bottom);
+                   height);
+      
       marker_xe = scrn_rect.left + scrn_rect.right / 3;     // Adjust tick xe
-      }
+    }
 
     // At this point marker x_start and x_end values are transposed.
     // To keep this from confusing things they are now interchanged.
-    if(( options & HUDS_BOTH) == HUDS_BOTH) {
+    if( huds_both(options) ) {
       marker_ye = marker_xs;
       marker_xs = marker_xe;
       marker_xe = marker_ye;
@@ -130,26 +161,29 @@ void guage_instr :: draw (void)
     // Work through from bottom to top of scale. Calculating where to put
     // minor and major ticks.
 
-    if( !(options & HUDS_NOTICKS )) {    // If not no ticks...:)
+    if( !huds_noticks(options)) {    // If not no ticks...:)
                                           // Calculate x marker offsets
-      for( i = (int)vmin; i <= (int)vmax; i++ ) {
+     int last = (int)vmax + 1; //FloatToInt(vmax)+1;
+     i = (int)vmin; //FloatToInt(vmin);
+    for(; i <last ; i++ )      {
+//  for( i = (int)vmin; i <= (int)vmax; i++ ) {
 
         // Calculate the location of this tick
-        marker_ys = scrn_rect.top + (int)((i - vmin) * factor() + .5);
+        marker_ys = scrn_rect.top + FloatToInt((i - vmin) * factor()/* +.5f*/);
 
         // We compute marker_ys even though we don't know if we will use
         // either major or minor divisions. Simpler.
 
         if( div_min()) {                  // Minor tick marks
-          if( (i%div_min()) == 0) {
-            if((options & HUDS_LEFT) && (options && HUDS_RIGHT)) {
+          if( !(i%(int)div_min()) ) {
+            if( huds_left(options) && huds_right(options) ) {
                 drawOneLine( scrn_rect.left, marker_ys,
                              marker_xs - 3, marker_ys );
                 drawOneLine( marker_xe + 3, marker_ys,
-                             scrn_rect.left + scrn_rect.right, marker_ys );
+                             width, marker_ys );
               }
             else {
-              if( options & HUDS_LEFT) {
+              if( huds_left(options) ) {
                 drawOneLine( marker_xs + 3, marker_ys, marker_xe, marker_ys );
                 }
               else {
@@ -164,31 +198,31 @@ void guage_instr :: draw (void)
           // statement.
 
         if( div_max()) {                  // Major tick mark
-          if( (i%div_max()) == 0 )            {
-            if((options & HUDS_LEFT) && (options && HUDS_RIGHT)) {
-
+          if( !(i%(int)div_max()) )            {
+            if( huds_left(options) && huds_right(options) ) {
                 drawOneLine( scrn_rect.left, marker_ys,
                              marker_xs, marker_ys );
                 drawOneLine( marker_xe, marker_ys,
-                             scrn_rect.left + scrn_rect.right, marker_ys );
+                             width, marker_ys );
               }
             else {
               drawOneLine( marker_xs, marker_ys, marker_xe, marker_ys );
-              }
+            }
 
-            if( !(options & HUDS_NOTEXT)) {
+            if( !huds_notext(options) ) {
               disp_val = i;
-              sprintf( TextScale, "%d",disp_val  * (int)(data_scaling() +.5));
+              lenstr = sprintf( TextScale, "%d",
+                                FloatToInt(disp_val * data_scaling()/*+.5*/ ));
 
-              if((options & HUDS_LEFT) && (options && HUDS_RIGHT)) {
-                text_x = mid_scr.x -  2 - ((3 * strlen( TextScale ))>>1);
+              if( huds_left(options) && huds_right(options) ) {
+                text_x = mid_scr.x -  2 - ((3 * lenstr) >> 1);
                 }
               else {
-                if( options & HUDS_LEFT )              {
-                  text_x = marker_xs - 2 - 3 * strlen( TextScale);
+                if( huds_left(options) )              {
+                  text_x = marker_xs - 2 - 3 * lenstr;
                   }
                 else {
-                  text_x = marker_xe + 10 - strlen( TextScale );
+                  text_x = marker_xe + 10 - lenstr;
                   }
                 }
               // Now we know where to put the text.
@@ -203,70 +237,71 @@ void guage_instr :: draw (void)
     // have been drawn, text_x and text_y may be recycled. This is used
     // with the marker start stops to produce a pointer for each side reading
 
-    text_y = scrn_rect.top + (int)((cur_value - vmin) * factor() + .5);
+    text_y = scrn_rect.top + FloatToInt((cur_value - vmin) * factor() /*+.5f*/);
 //    text_x = marker_xs - scrn_rect.left;
 
-    if( options & HUDS_RIGHT ) {
-      drawOneLine(scrn_rect.left, text_y + 5,
-                  marker_xe,      text_y);
-      drawOneLine(scrn_rect.left, text_y - 5,
-                  marker_xe,      text_y);
+    if( huds_right(options) ) {
+      glBegin(GL_LINE_STRIP);
+      glVertex2f( scrn_rect.left, text_y + 5);
+      glVertex2f( marker_xe,      text_y);
+      glVertex2f( scrn_rect.left, text_y - 5);
+      glEnd();
       }
-    if( options & HUDS_LEFT ) {
-      drawOneLine(scrn_rect.left + scrn_rect.right, text_y + 5,
-                  marker_xs,                        text_y);
-      drawOneLine(scrn_rect.left + scrn_rect.right, text_y - 5,
-                  marker_xs,                        text_y);
+    if( huds_left(options) ) {
+      glBegin(GL_LINE_STRIP);
+      glVertex2f( width,      text_y + 5);
+      glVertex2f( marker_xs,  text_y);
+      glVertex2f( width,      text_y - 5);
+      glEnd();
       }
     }  // End if VERTICAL SCALE TYPE
   else {                                // Horizontal scale by default
     drawOneLine( scrn_rect.left,     // left tick bar
                  scrn_rect.top,
                  scrn_rect.left,
-                 scrn_rect.top + scrn_rect.bottom);
+                 height);
 
-    drawOneLine( scrn_rect.left + scrn_rect.right,    // right tick bar
+    drawOneLine( width,    // right tick bar
                  scrn_rect.top,
-                 scrn_rect.left + scrn_rect.right,
-                 scrn_rect.top  + scrn_rect.bottom );
+                 width,
+                 height );
 
     marker_ys = scrn_rect.top;                       // Starting point for
-    marker_ye = scrn_rect.top + scrn_rect.bottom;    // tick y location calcs
-    marker_xs = scrn_rect.left + (int)((cur_value - vmin) * factor() + .5);
+    marker_ye = height;                              // tick y location calcs
+    marker_xs = scrn_rect.left + FloatToInt((cur_value - vmin) * factor() /*+ .5f*/);
 
-    if( options & HUDS_TOP ) {
+    if( huds_top(options) ) {
       drawOneLine( scrn_rect.left,
                    scrn_rect.top,
-                   scrn_rect.left + scrn_rect.right,
+                   width,
                    scrn_rect.top);                    // Bottom box line
-
+      
       marker_ye  = scrn_rect.top + scrn_rect.bottom / 2;   // Tick point adjust
                                                       // Bottom arrow
-      drawOneLine( marker_xs, marker_ye,
-                   marker_xs - scrn_rect.bottom / 4, scrn_rect.top);
-      drawOneLine( marker_xs, marker_ye,
-                   marker_xs + scrn_rect.bottom / 4, scrn_rect.top);
-      }
-    if( options & HUDS_BOTTOM) {
-      drawOneLine( scrn_rect.left,
-                   scrn_rect.top + scrn_rect.bottom,
-                   scrn_rect.left + scrn_rect.right,
-                   scrn_rect.top + scrn_rect.bottom);  // Top box line
-                                                       // Tick point adjust
-      marker_ys = scrn_rect.top +
-                  scrn_rect.bottom - scrn_rect.bottom  / 2;
-                                                       // Top arrow
-      drawOneLine( marker_xs + scrn_rect.bottom / 4,
-                          scrn_rect.top + scrn_rect.bottom,
-                   marker_xs,
-                          marker_ys );
-      drawOneLine( marker_xs - scrn_rect.bottom / 4,
-                          scrn_rect.top + scrn_rect.bottom,
-                   marker_xs ,
-                          marker_ys );
+      glBegin(GL_LINE_STRIP);
+      glVertex2f( marker_xs - bottom_4, scrn_rect.top);
+      glVertex2f( marker_xs, marker_ye);
+      glVertex2f( marker_xs + bottom_4, scrn_rect.top);
+      glEnd();
       }
+    if( huds_bottom(options) ) {
+        // Top box line
+        drawOneLine( scrn_rect.left, height, width, height);
+        // Tick point adjust
+        marker_ys = height - scrn_rect.bottom  / 2;
+
+        // Top arrow
+        glBegin(GL_LINE_STRIP);
+        glVertex2f( marker_xs + bottom_4, height);
+        glVertex2f( marker_xs, marker_ys );
+        glVertex2f( marker_xs - bottom_4, height);
+        glEnd();
+    }
 
-    for( i = (int)vmin; i <= (int)vmax; i++ )   {
+    
+    int last = (int)vmax + 1; //FloatToInt(vmax)+1;
+    i = (int)vmin; //FloatToInt(vmin);
+    for( ; i <last ; i++ )      {
       condition = true;
       if( !modulo()) {
         if( i < min_val()) {
@@ -274,21 +309,22 @@ void guage_instr :: draw (void)
           }
         }
       if( condition )        {
-        marker_xs = scrn_rect.left + (int)((i - vmin) * factor() + .5);
+        marker_xs = scrn_rect.left + FloatToInt((i - vmin) * factor()/* +.5f*/);
+//        marker_xs = scrn_rect.left + (int)((i - vmin) * factor() + .5f);
         if( div_min()){
-          if( (i%(int)div_min()) == 0 ) {
+          if( !(i%(int)div_min()) ) {           
             // draw in ticks only if they aren't too close to the edge.
             if((( marker_xs + 5) > scrn_rect.left ) ||
-               (( marker_xs - 5 )< (scrn_rect.left + scrn_rect.right))){
+               (( marker_xs - 5 )< (width))){
 
-              if( (options & HUDS_BOTH) == HUDS_BOTH ) {
+              if( huds_both(options) ) {
                 drawOneLine( marker_xs, scrn_rect.top,
                              marker_xs, marker_ys - 4);
                 drawOneLine( marker_xs, marker_ye + 4,
-                             marker_xs, scrn_rect.top + scrn_rect.bottom);
-                }
+                             marker_xs, height);
+              }
               else {
-                if( options & HUDS_TOP) {
+                if( huds_top(options) ) {
                   drawOneLine( marker_xs, marker_ys,
                                marker_xs, marker_ye - 4);
                   }
@@ -301,46 +337,45 @@ void guage_instr :: draw (void)
             }
           }
         if( div_max()) {
-          if( (i%(int)div_max())==0 ) {
-            if(modulo()) {
-              if( disp_val < 0) {
-                disp_val += modulo();
-                }
-              else {
-                disp_val = i % modulo();
-                }
-              }
-            else {
-              disp_val = i;
+          if( !(i%(int)div_max()) ) {           
+              if(modulo()) {
+                  if( disp_val < 0) {
+                      while( disp_val < 0 ) {
+                          disp_val += modulo();
+                      } 
+                  }
+                  disp_val = i % (int)modulo();
+              } else {
+                  disp_val = i;
               }
-            sprintf( TextScale, "%d", (int)(disp_val  * data_scaling() +.5));
+            lenstr = 4 * sprintf( TextScale, "%d",
+                                  FloatToInt(disp_val  * data_scaling()/* +.5*/ ));
             // Draw major ticks and text only if far enough from the edge.
             if(( (marker_xs - 10)> scrn_rect.left ) &&
-               ( (marker_xs + 10) < (scrn_rect.left + scrn_rect.right))){
-              if( (options & HUDS_BOTH) == HUDS_BOTH) {
+               ( (marker_xs + 10) < width )){
+              if( huds_both(options) ) {
                 drawOneLine( marker_xs, scrn_rect.top,
                              marker_xs, marker_ys);
                 drawOneLine( marker_xs, marker_ye,
-                             marker_xs, scrn_rect.top + scrn_rect.bottom);
+                             marker_xs, height);
 
-                if( !(options & HUDS_NOTEXT)) {
-                  textString ( marker_xs - 4 * strlen(TextScale),
-                               marker_ys + 4,
+                if( !huds_notext(options) ) {
+                  textString ( marker_xs - lenstr, marker_ys + 4,
                                TextScale,  GLUT_BITMAP_8_BY_13 );
                   }
                 }
               else {
                 drawOneLine( marker_xs, marker_ys,
                              marker_xs, marker_ye );
-                if( !(options & HUDS_NOTEXT)) {
-                  if( options & HUDS_TOP )              {
-                  textString ( marker_xs - 4 * strlen(TextScale),
-                               scrn_rect.top + scrn_rect.bottom - 10,
+                
+                if( !huds_notext(options) ) {
+                  if( huds_top(options) )              {
+                  textString ( marker_xs - lenstr,
+                               height - 10,
                                TextScale, GLUT_BITMAP_8_BY_13 );
                     }
                   else  {
-                    textString( marker_xs - 4 * strlen(TextScale),
-                                scrn_rect.top,
+                    textString( marker_xs - lenstr, scrn_rect.top,
                                 TextScale, GLUT_BITMAP_8_BY_13 );
                     }            
                   }
diff --git a/Simulator/Cockpit/hud_inst.cxx b/Simulator/Cockpit/hud_inst.cxx
index 5de09845d..fb6eece1f 100644
--- a/Simulator/Cockpit/hud_inst.cxx
+++ b/Simulator/Cockpit/hud_inst.cxx
@@ -31,8 +31,8 @@ instr_item  ::
                int              y,
                UINT             width,
                UINT             height,
-               DBLFNPTR         data_source,
-               double           data_scaling,
+               FLTFNPTR         data_source,
+               float           data_scaling,
                UINT             options,
                bool             working) :
                       handle         ( ++instances  ),
diff --git a/Simulator/Cockpit/hud_labl.cxx b/Simulator/Cockpit/hud_labl.cxx
index 7ef189016..340810d32 100644
--- a/Simulator/Cockpit/hud_labl.cxx
+++ b/Simulator/Cockpit/hud_labl.cxx
@@ -8,6 +8,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <Aircraft/aircraft.hxx>
+#include <GUI/gui.h>
 #include <Include/fg_constants.h>
 #include <Math/fg_random.h>
 #include <Math/mat3.h>
@@ -15,20 +16,23 @@
 #include <Scenery/scenery.hxx>
 #include <Time/fg_timer.hxx>
 
-
 #include "hud.hxx"
 
+#ifdef USE_HUD_TextList
+#define textString( x , y, text, font )  TextString( font, text, x , y )
+#endif
+
 //======================= Top of instr_label class =========================
 instr_label ::
          instr_label( int           x,
                       int           y,
                       UINT          width,
                       UINT          height,
-                      DBLFNPTR      data_source,
+                      FLTFNPTR      data_source,
                       const char   *label_format,
                       const char   *pre_label_string,
                       const char   *post_label_string,
-                      double        scale_data,
+                      float        scale_data,
                       UINT          options,
                       fgLabelJust   justification,
                       int           font_size,
@@ -43,6 +47,20 @@ instr_label ::
                            fontSize ( font_size         ),
                            blink    ( blinking          )
 {
+  if( pre_str != NULL) {
+    if( post_str != NULL ) {
+      sprintf( format_buffer, "%s%s%s", pre_str, pformat, post_str );
+      }
+    else {
+      sprintf( format_buffer, "%s%s",   pre_str, pformat );
+      }
+    }
+  else {
+    if( post_str != NULL ) {
+      sprintf( format_buffer, "%s%s",   pformat, post_str );
+      }
+    } // else do nothing if both pre and post strings are nulls. Interesting.
+
 }
 
 // I put this in to make it easy to construct a class member using the current
@@ -61,6 +79,20 @@ instr_label :: instr_label( const instr_label & image) :
                               post_str ( image.post_str ),
                               blink    ( image.blink    )
 {
+  if( pre_str != NULL) {
+    if( post_str != NULL ) {
+      sprintf( format_buffer, "%s%s%s", pre_str, pformat, post_str );
+      }
+    else {
+      sprintf( format_buffer, "%s%s",   pre_str, pformat );
+      }
+    }
+  else {
+    if( post_str != NULL ) {
+      sprintf( format_buffer, "%s%s",   pformat, post_str );
+      }
+    } // else do nothing if both pre and post strings are nulls. Interesting.
+
 }
 
 instr_label & instr_label ::operator = (const instr_label & rhs )
@@ -73,8 +105,9 @@ instr_label & instr_label ::operator = (const instr_label & rhs )
     justify    = rhs.justify;
     pre_str    = rhs.pre_str;
     post_str   = rhs.post_str;
+    strcpy(format_buffer,rhs.format_buffer);    
     }
-	return *this;
+    return *this;
 }
 
 //
@@ -84,40 +117,40 @@ instr_label & instr_label ::operator = (const instr_label & rhs )
 void instr_label ::
 draw( void )       // Required method in base class
 {
-  char format_buffer[80];
+//  char format_buffer[80];
   char label_buffer[80];
   int posincr;
   int lenstr;
   RECT  scrn_rect = get_location();
 
-  if( pre_str != NULL) {
-    if( post_str != NULL ) {
-      sprintf( format_buffer, "%s%s%s", pre_str, pformat, post_str );
-      }
-    else {
-      sprintf( format_buffer, "%s%s",   pre_str, pformat );
-      }
-    }
-  else {
-    if( post_str != NULL ) {
-      sprintf( format_buffer, "%s%s",   pformat, post_str );
-      }
-    } // else do nothing if both pre and post strings are nulls. Interesting.
+//  if( pre_str != NULL) {
+//    if( post_str != NULL ) {
+//      sprintf( format_buffer, "%s%s%s", pre_str, pformat, post_str );
+//      }
+//    else {
+//      sprintf( format_buffer, "%s%s",   pre_str, pformat );
+//      }
+//    }
+//  else {
+//    if( post_str != NULL ) {
+//      sprintf( format_buffer, "%s%s",   pformat, post_str );
+//      }
+//    } // else do nothing if both pre and post strings are nulls. Interesting.
 
   if( data_available() ) {
-    sprintf( label_buffer, format_buffer, get_value() );
+    lenstr = sprintf( label_buffer, format_buffer, get_value() );
     }
   else {
-    sprintf( label_buffer, format_buffer );
+    lenstr = sprintf( label_buffer, format_buffer );
     }
     
 #ifdef DEBUGHUD
-	fgPrintf( FG_COCKPIT, FG_DEBUG,  format_buffer );
-	fgPrintf( FG_COCKPIT, FG_DEBUG,  "\n" );
-	fgPrintf( FG_COCKPIT, FG_DEBUG, label_buffer );
-	fgPrintf( FG_COCKPIT, FG_DEBUG, "\n" );
+    fgPrintf( FG_COCKPIT, FG_DEBUG,  format_buffer );
+    fgPrintf( FG_COCKPIT, FG_DEBUG,  "\n" );
+    fgPrintf( FG_COCKPIT, FG_DEBUG, label_buffer );
+    fgPrintf( FG_COCKPIT, FG_DEBUG, "\n" );
 #endif
-  lenstr = strlen( label_buffer );
+//  lenstr = strlen( label_buffer );
 
   posincr = 0;   //  default to RIGHT_JUST ... center located calc: -lenstr*8;
 
@@ -129,7 +162,6 @@ draw( void )       // Required method in base class
       posincr = - (lenstr << 8);  // 0;
       }
     }
-
   if( fontSize == SMALL ) {
     textString( scrn_rect.left + posincr, scrn_rect.top,
                 label_buffer, GLUT_BITMAP_8_BY_13);
diff --git a/Simulator/Cockpit/hud_ladr.cxx b/Simulator/Cockpit/hud_ladr.cxx
index 51468b80d..a20dd47e1 100644
--- a/Simulator/Cockpit/hud_ladr.cxx
+++ b/Simulator/Cockpit/hud_ladr.cxx
@@ -18,282 +18,317 @@
 
 #include "hud.hxx"
 //====================== Top of HudLadder Class =======================
-HudLadder ::
-  HudLadder(  int       x,
-              int       y,
-              UINT      width,
-              UINT      height,
-              DBLFNPTR  ptch_source,
-              DBLFNPTR  roll_source,
-              double    span_units,
-              double    major_div,
-              double    minor_div,
-              UINT      screen_hole,
-              UINT      lbl_pos,
-              bool      working) :
-               dual_instr_item( x, y, width, height,
-                                ptch_source,
-                                roll_source,
-                                working,
-                                HUDS_RIGHT),
-               width_units    ( span_units   ),
-               div_units      ( major_div < 0? -major_div: major_div ),
-               minor_div      ( minor_div    ),
-               label_pos      ( lbl_pos      ),
-               scr_hole       ( screen_hole  ),
-               vmax           ( span_units/2 ),
-               vmin           ( -vmax        )
-{
-  if( !width_units ) {
-    width_units = 45;
+HudLadder ::   HudLadder(  int       x,
+               int       y,
+               UINT      width,
+               UINT      height,
+               FLTFNPTR  ptch_source,
+               FLTFNPTR  roll_source,
+               float    span_units,
+               float    major_div,
+               float    minor_div,
+               UINT      screen_hole,
+               UINT      lbl_pos,
+               bool      working) :
+   dual_instr_item( x, y, width, height,
+                    ptch_source,
+                    roll_source,
+                    working,
+                    HUDS_RIGHT),
+                    width_units    ( (int)(span_units)   ),
+                    div_units      ( (int)(major_div < 0? -major_div: major_div) ),
+                    minor_div      ( (int)(minor_div)    ),
+                    label_pos      ( lbl_pos      ),
+                    scr_hole       ( screen_hole  ),
+                    vmax           ( span_units/2 ),
+                    vmin           ( -vmax        )
+   {
+       if( !width_units ) {
+           width_units = 45;
+       }
+       factor = (float)get_span() / (float) width_units;
+   }
+   
+HudLadder ::  ~HudLadder()
+    {
     }
-  factor = (double)get_span() / (double) width_units;
-}
-
-HudLadder ::
-  ~HudLadder()
-{
-}
-
-HudLadder ::
-  HudLadder( const HudLadder & image ) :
-        dual_instr_item( (dual_instr_item &) image),
-        width_units    ( image.width_units   ),
-        div_units      ( image.div_units     ),
-        label_pos      ( image.label_pos     ),
-        scr_hole       ( image.scr_hole      ),
-        vmax           ( image.vmax ),
-        vmin           ( image.vmin ),
-        factor         ( image.factor        )
-{
-}
-HudLadder & HudLadder ::
-  operator = ( const HudLadder & rhs )
-{
-  if( !(this == &rhs)) {
-    (dual_instr_item &)(*this) = (dual_instr_item &)rhs;
-    width_units  = rhs.width_units;
-    div_units    = rhs.div_units;
-    label_pos    = rhs.label_pos;
-    scr_hole     = rhs.scr_hole;
-    vmax         = rhs.vmax;
-    vmin         = rhs.vmin;
-    factor       = rhs.factor;
+           
+    HudLadder ::
+            HudLadder( const HudLadder & image ) :
+            dual_instr_item( (dual_instr_item &) image),
+            width_units    ( image.width_units   ),
+            div_units      ( image.div_units     ),
+            label_pos      ( image.label_pos     ),
+            scr_hole       ( image.scr_hole      ),
+            vmax           ( image.vmax ),
+            vmin           ( image.vmin ),
+            factor         ( image.factor        )
+    {
     }
-  return *this;
-}
-
+HudLadder & HudLadder ::  operator = ( const HudLadder & rhs )
+    {
+        if( !(this == &rhs)) {
+            (dual_instr_item &)(*this) = (dual_instr_item &)rhs;
+            width_units  = rhs.width_units;
+            div_units    = rhs.div_units;
+            label_pos    = rhs.label_pos;
+            scr_hole     = rhs.scr_hole;
+            vmax         = rhs.vmax;
+            vmin         = rhs.vmin;
+            factor       = rhs.factor;
+        }
+        return *this;
+    }
+                           
 //
-//	Draws a climb ladder in the center of the HUD
+//  Draws a climb ladder in the center of the HUD
 //
+    
+inline static void _strokeString(float xx, float yy, char *msg, void *font)
+{
+    int c;
+    if(*msg)
+    {
+        glTranslatef( xx, yy, 0);
+        glScalef(.075, .075, 0.0);
+        while ((c=*msg++)) {
+            glutStrokeCharacter( font, c);
+        }
+    }
+}
 
 void HudLadder :: draw( void )
 {
-  double roll_value;
-  double pitch_value;
-  int    marker_y;
-  int    x_ini;
-  int    x_end;
-  int    y_ini;
-  int    y_end;
-  int    new_x_ini;
-  int    new_x_end;
-  int    new_y_ini;
-  int    new_y_end;
-  int    i;
-  POINT  centroid   = get_centroid();
-  RECT   box        = get_location();
-  int    scr_min    = box.top;
-  int    half_span  = box.right >> 1;
-  char   TextLadder[80];
-  int    condition;
-  int    label_length;
-  roll_value        = current_ch2();
-  GLfloat sinRoll   = sin( roll_value );
-  GLfloat cosRoll   = cos( roll_value );
+    float roll_value;
+    float pitch_value;
+    float    marker_y;
+    float    x_ini;
+    float    x_end;
+    float    y_ini;
+    float    y_end;
+
+    int    i;
+    POINT  centroid   = get_centroid();
+    RECT   box        = get_location();
 
-  pitch_value       = current_ch1() * RAD_TO_DEG;
-  vmin              = pitch_value - (double)width_units/2.0;
-  vmax              = pitch_value + (double)width_units/2.0;
+    int    half_span  = box.right >> 1;
+    char   TextLadder[80];
 
-// Box the target.
-  drawOneLine( centroid.x - 5, centroid.y,     centroid.x,     centroid.y + 5);
-  drawOneLine( centroid.x,     centroid.y + 5, centroid.x + 5, centroid.y);
-  drawOneLine( centroid.x + 5, centroid.y,     centroid.x,     centroid.y - 5);
-  drawOneLine( centroid.x,     centroid.y - 5, centroid.x - 5, centroid.y);
+    int    label_length;
+    roll_value        = current_ch2();
+    
+    float hole = (float)((scr_hole)/2);
+    
+    GLfloat mat[16];
+    
+    pitch_value       = current_ch1() * RAD_TO_DEG;
+    vmin              = pitch_value - (float)width_units/2.0;
+    vmax              = pitch_value + (float)width_units/2.0;
 
-  for( i=(int)vmin; i<=(int)vmax; i++ )  {  // Through integer pitch values...
-    condition = 1;
-    if( condition )      {
-      marker_y = centroid.y + (int)(((double)(i - pitch_value) * factor) + .5);
-      if( div_units ) {
-        if( !(i % div_units ))    {        //  At integral multiple of div
-          sprintf( TextLadder, "%d", i );
-          label_length = strlen( TextLadder );
-          if( scr_hole == 0 )           {
-            if( i ) {
-              x_ini = centroid.x - half_span;
-              }
-            else {                         // Make zero point wider on left
-              x_ini = centroid.x - half_span - 10;
-              }
-            y_ini = marker_y;
-            x_end = centroid.x + half_span;
-            y_end = marker_y;
-            new_x_ini = centroid.x + (int)(
-                       (x_ini - centroid.x) * cosRoll -
-                       (y_ini - centroid.y) * sinRoll);
-            new_y_ini = centroid.y + (int)(             \
-                       (x_ini - centroid.x) * sinRoll + \
-                       (y_ini - centroid.y) * cosRoll);
-            new_x_end = centroid.x + (int)(             \
-                       (x_end - centroid.x) * cosRoll - \
-                       (y_end - centroid.y) * sinRoll);
-            new_y_end = centroid.y + (int)(             \
-                       (x_end - centroid.x) * sinRoll + \
-                       (y_end - centroid.y) * cosRoll);
 
-            if( i >= 0 ) { // Above zero draw solid lines
-              drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
-              }
-            else         { // Below zero draw dashed lines.
-              glEnable(GL_LINE_STIPPLE);
-              glLineStipple( 1, 0x00FF );
-              drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
-              glDisable(GL_LINE_STIPPLE);
-              }
-            // Calculate the position of the left text and write it.
-            new_x_ini = centroid.x + (int)(
-                        (x_ini - 8 * label_length- 4 - centroid.x) * cosRoll -
-                        (y_ini - 4 ) * sinRoll);
-            new_y_ini = centroid.y + (int)(
-                        (x_ini - 8 * label_length- 4 - centroid.x) * sinRoll +
-                        (y_ini - 4 - centroid.y) * cosRoll);
-            strokeString( new_x_ini , new_y_ini ,
-                        TextLadder, GLUT_STROKE_ROMAN,
-                        roll_value );
+    // We will do everything with glLoadMatrix :-)
+    // to avoid multiple pushing and popping matrix stack
+    glPushMatrix();
+    //  glTranslatef( centroid.x, centroid.y, 0);
+    //  glRotatef(roll_value * RAD_TO_DEG, 0.0, 0.0, 1.0);
+    //  glGetFloatv(GL_MODELVIEW_MATRIX, mat);
+    // this is the same as above
+    float sinx = sin(roll_value);
+    float cosx = cos(roll_value);
+    mat[0] = cosx;
+    mat[1] = sinx;
+    mat[2] = mat[3] = 0.0;
+    mat[4] = -sinx;
+    mat[5] = cosx;
+    mat[6] = mat[7] = mat[8] = mat[9];
+    mat[10] = 1.0;
+    mat[11] = 0.0;
+    mat[12] = centroid.x;
+    mat[13] = centroid.y;
+    mat[14] = 0;
+    mat[15] = 1.0;
+    glLoadMatrixf( mat );
+    
+    // Draw the target spot.
+#define CENTER_DIAMOND_SIZE 5.0
+    glBegin(GL_LINE_LOOP);
+        glVertex2f( -CENTER_DIAMOND_SIZE, 0.0);
+        glVertex2f(0.0, CENTER_DIAMOND_SIZE);
+        glVertex2f( CENTER_DIAMOND_SIZE, 0.0);
+        glVertex2f(0.0, -CENTER_DIAMOND_SIZE);
+    glEnd();
+#if 0
+    glBegin(GL_LINES);
+        glVertex2f( -CENTER_DIAMOND_SIZE, 0);
+        glVertex2f( -(CENTER_DIAMOND_SIZE*2), 0);
+        glVertex2f(0, CENTER_DIAMOND_SIZE);
+        glVertex2f(0, (CENTER_DIAMOND_SIZE*2));
+        glVertex2f( CENTER_DIAMOND_SIZE, 0);
+        glVertex2f( (CENTER_DIAMOND_SIZE*2), 0);
+        glVertex2f(0, -CENTER_DIAMOND_SIZE);
+        glVertex2f(0, -(CENTER_DIAMOND_SIZE*2));
+    glEnd();
+#endif // 0
+#undef CENTER_DIAMOND_SIZE
 
-            // Calculate the position of the right text and write it.
-            new_x_end = centroid.x + (int)(                  \
-                       (x_end + 24 - 8 * label_length - centroid.x) * cosRoll - \
-                       (y_end -  4 - centroid.y) * sinRoll);
-            new_y_end = centroid.y + (int)(                  \
-                       (x_end + 24 - 8 * label_length - centroid.x) * sinRoll + \
-                       (y_end -  4 - centroid.y) * cosRoll);
-            strokeString( new_x_end,  new_y_end,
-                          TextLadder, GLUT_STROKE_ROMAN,
-                          roll_value );
+    int last =FloatToInt(vmax)+1;
+    i = FloatToInt(vmin);
+    if( div_units ) {
+        if( !scr_hole ) {
+            for( ; i <last ; i++ ) {
+                
+                marker_y =  /*(int)*/(((float)(i - pitch_value) * factor) + .5);
+                if( !(i % div_units ))    {        //  At integral multiple of div
+                
+                    label_length = sprintf( TextLadder, "%d", i );
+                
+                    if( i ) {
+                        x_ini = -half_span;
+                    } else {       // Make zero point wider on left
+                        x_ini = -half_span - 10;
+                    }
+                    x_end = half_span;
+                    
+                    y_ini = marker_y;
+                    y_end = marker_y;
+                    
+//                  printf("(%.1f %.1f) (%.1f %.1f)\n",x_ini,y_ini,x_end,y_end);
+                    
+                    if( i >= 0 ) { // Above zero draw solid lines
+                        glBegin(GL_LINES);
+                            glVertex2f( x_ini, y_ini);
+                            glVertex2f( x_end, y_end );
+                        glEnd();
+                    } else { // Below zero draw dashed lines.
+                        glEnable(GL_LINE_STIPPLE);
+                        glLineStipple( 1, 0x00FF );
+                        glBegin(GL_LINES);
+                            glVertex2f( x_ini, y_ini);
+                            glVertex2f( x_end, y_end );
+                        glEnd();
+                        glDisable(GL_LINE_STIPPLE);
+                    }
+                    
+                    // Calculate the position of the left text and write it.
+                    x_ini -= ( 8*label_length - 4);
+                    y_ini -= 4;
+                    _strokeString(x_ini, y_ini,
+                                  TextLadder, GLUT_STROKE_ROMAN );
+                    
+                    glLoadMatrixf( mat );
+                    // Calculate the position of the right text and write it.
+                    x_end -= (24 - 8 * label_length);
+                    y_end -= 4;
+                    _strokeString(x_end, y_end,
+                                  TextLadder, GLUT_STROKE_ROMAN );
+                    glLoadMatrixf( mat );
+                }
             }
-          else   {  // Draw ladder with space in the middle of the lines
+        }
+        else // if(scr_hole )
+        {    // Draw ladder with space in the middle of the lines
+            last =FloatToInt(vmax)+1;
+            i = FloatToInt(vmin);
+            for( ; i <last ; i++ )      {  
+                marker_y =  /*(int)*/(((float)(i - pitch_value) * factor) + .5);
+                if( !(i % div_units ))    {        //  At integral multiple of div
+                
+                    label_length = sprintf( TextLadder, "%d", i );
+                
                     // Start by calculating the points and drawing the
                     // left side lines.
-            if( i != 0 )  {
-              x_ini = centroid.x - half_span;
-              }
-            else          {
-              x_ini = centroid.x - half_span - 10;
-              }
-            y_ini = marker_y;
-            x_end = centroid.x - half_span + scr_hole/2;
-            y_end = marker_y;
-
-            new_x_end = centroid.x+  (int)(             \
-                        (x_end - centroid.x) * cosRoll -\
-                        (y_end - centroid.y) * sinRoll);
-            new_y_end = centroid.y+ (int)(              \
-                        (x_end - centroid.x) * sinRoll +\
-                        (y_end - centroid.y) * cosRoll);
-            new_x_ini = centroid.x + (int)(              \
-                        (x_ini - centroid.x) * cosRoll -\
-                        (y_ini - centroid.y) * sinRoll);
-            new_y_ini = centroid.y + (int)(             \
-                        (x_ini - centroid.x) * sinRoll +\
-                        (y_ini - centroid.y) * cosRoll);
+                    if( i != 0 )  {
+                        x_ini =  -half_span;
+                    } else {
+                        x_ini = -half_span - 10;
+                    }
+                    x_end =  -half_span + hole;
+                    
+                    y_ini = marker_y;
+                    y_end = marker_y;
+                    
+//                  printf("half_span(%d) scr_hole(%d)\n", half_span, scr_hole);
+//                  printf("x_end(%f) %f\n",x_end,(float)(-half_span + scr_hole/2));
+//                  printf("L: (%.1f %.1f) (%.1f %.1f)\n",x_ini,y_ini,x_end,y_end);
+                    
+                    if( i >= 0 ) { // Above zero draw solid lines
+                        glBegin(GL_LINES);
+                            glVertex2f( x_ini, y_ini);
+                            glVertex2f( x_end, y_end );
+                        glEnd();
+                    } else { // Below zero draw dashed lines.
+                        glEnable(GL_LINE_STIPPLE);
+                        glLineStipple( 1, 0x00FF );
+                        glBegin(GL_LINES);
+                            glVertex2f( x_ini, y_ini);
+                            glVertex2f( x_end, y_end );
+                        glEnd();
+                        glDisable(GL_LINE_STIPPLE);
+                    }
+                    
+                    // Now calculate the location of the left side label using
+                    // the previously calculated start of the left side line.
+                    
+                    x_ini -= (label_length + 32);
+                    if( i < 0) {
+                        x_ini -= 8;
+                    } else {
+                        if( i == 0 ) {
+                            x_ini += 15; //20;
+                        }
+                    }
+                    y_ini -= 4;
 
-            if( i >= 0 )
-              {
-              drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
-              }
-            else  {
-              glEnable(GL_LINE_STIPPLE);
-              glLineStipple( 1, 0x00FF );
-              drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
-              glDisable(GL_LINE_STIPPLE);
-              }
-            // Now calculate the location of the left side label using
-            // the previously calculated start of the left side line.
-
-            x_ini = x_ini - (label_length + 32 + centroid.x);
-            if( i < 0) {
-              x_ini -= 8;
-              }
-            else {
-              if( i == 0 ) {
-                x_ini += 20;
+                    _strokeString(x_ini, y_ini,
+                                  TextLadder, GLUT_STROKE_MONO_ROMAN );
+                    glLoadMatrixf( mat );
+                    
+                    // Now calculate and draw the right side line location
+                    x_ini = half_span - hole;
+                    y_ini = marker_y;
+                    if( i != 0 )  {
+                        x_end = half_span;
+                    } else {
+                        x_end = half_span + 10;
+                    }
+                    y_end = marker_y;
+                    
+//                  printf("R: (%.1f %.1f) (%.1f %.1f)\n",x_ini,y_ini,x_end,y_end);
+                    
+                    if( i >= 0 ) { // Above zero draw solid lines
+                        glBegin(GL_LINES);
+                            glVertex2f( x_ini, y_ini);
+                            glVertex2f( x_end, y_end );
+                        glEnd();
+                    } else { // Below zero draw dashed lines.
+                        glEnable(GL_LINE_STIPPLE);
+                        glLineStipple( 1, 0x00FF );
+                        glBegin(GL_LINES);
+                            glVertex2f( x_ini, y_ini);
+                            glVertex2f( x_end, y_end );
+                        glEnd();
+                        glDisable(GL_LINE_STIPPLE);
+                    }
+                    
+                    // Calculate the location and draw the right side label
+                    // using the end of the line as previously calculated.
+                    x_end -=  (label_length - 24);
+                        
+                    if( i <= 0 ) {
+                        x_end -= 8;
+                    } // else if( i==0)
+//                  {
+//                      x_end -=4;
+//                  }
+                    
+                    y_end  = marker_y - 4;
+                    _strokeString(x_end,  y_end,
+                                  TextLadder, GLUT_STROKE_MONO_ROMAN );
+                    glLoadMatrixf( mat );
                 }
-              }
-            y_ini = y_ini - ( 4 + centroid.y);
-
-            new_x_ini = centroid.x + (int)(x_ini * cosRoll - y_ini * sinRoll);
-            new_y_ini = centroid.y + (int)(x_ini * sinRoll + y_ini * cosRoll);
-            strokeString( new_x_ini , new_y_ini ,
-                          TextLadder, GLUT_STROKE_MONO_ROMAN,
-                          roll_value );
-
-            // Now calculate and draw the right side line location
-            x_ini = centroid.x + half_span - scr_hole/2;
-            y_ini = marker_y;
-            if( i != 0 )  {
-              x_end = centroid.x + half_span;
-              }
-            else          {
-              x_end = centroid.x + half_span + 10;
-              }
-            y_end = marker_y;
-
-            new_x_ini = centroid.x + (int)(         \
-                        (x_ini-centroid.x)*cosRoll -\
-                        (y_ini-centroid.y)*sinRoll);
-            new_y_ini = centroid.y + (int)(         \
-                        (x_ini-centroid.x)*sinRoll +\
-                        (y_ini-centroid.y)*cosRoll);
-            new_x_end = centroid.x + (int)(         \
-                        (x_end-centroid.x)*cosRoll -\
-                        (y_end-centroid.y)*sinRoll);
-            new_y_end = centroid.y +  (int)(        \
-                        (x_end-centroid.x)*sinRoll +\
-                        (y_end-centroid.y)*cosRoll);
-
-            if( i >= 0 )
-              {
-              drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
-              }
-            else
-              {
-              glEnable(GL_LINE_STIPPLE);
-              glLineStipple( 1, 0x00FF );
-              drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
-              glDisable(GL_LINE_STIPPLE);
-              }
-
-            // Calculate the location and draw the right side label
-            // using the end of the line as previously calculated.
-            x_end -= centroid.x + label_length - 24;
-            if( i < 0 ) {
-              x_end -= 8;
-              }
-            y_end  = marker_y - ( 4 + centroid.y);
-            new_x_end = centroid.x + (int)( (GLfloat)x_end * cosRoll -
-                                            (GLfloat)y_end * sinRoll);
-            new_y_end = centroid.y + (int)( (GLfloat)x_end * sinRoll +
-                                            (GLfloat)y_end * cosRoll);
-            strokeString( new_x_end,  new_y_end,
-                          TextLadder, GLUT_STROKE_MONO_ROMAN,
-                          roll_value );
             }
-          }
         }
-      }
     }
+    glPopMatrix();
 }
 
diff --git a/Simulator/Cockpit/hud_scal.cxx b/Simulator/Cockpit/hud_scal.cxx
index 0b582d058..6be8757c1 100644
--- a/Simulator/Cockpit/hud_scal.cxx
+++ b/Simulator/Cockpit/hud_scal.cxx
@@ -34,12 +34,12 @@ instr_scale ( int       x,
               int       y,
               UINT      width,
               UINT      height,
-              DBLFNPTR  load_fn,
+              FLTFNPTR  load_fn,
               UINT      options,
-              double    show_range,
-              double    maxValue,
-              double    minValue,
-              double    disp_scale,
+              float    show_range,
+              float    maxValue,
+              float    minValue,
+              float    disp_scale,
               UINT      major_divs,
               UINT      minor_divs,
               UINT      rollover,
@@ -57,11 +57,11 @@ instr_scale ( int       x,
 {
 int temp;
 
-  scale_factor   = (double)get_span() / range_shown;
+  scale_factor   = (float)get_span() / range_shown;
   if( show_range < 0 ) {
     range_shown = -range_shown;
     }
-  temp = (Maximum_value - Minimum_value) / 100;
+  temp = FloatToInt(Maximum_value - Minimum_value) / 100;
   if( range_shown < temp ) {
     range_shown = temp;
     }
diff --git a/Simulator/Cockpit/hud_tbi.cxx b/Simulator/Cockpit/hud_tbi.cxx
index 299e08dd4..0036e5ca2 100644
--- a/Simulator/Cockpit/hud_tbi.cxx
+++ b/Simulator/Cockpit/hud_tbi.cxx
@@ -24,10 +24,10 @@ fgTBI_instr( int              x,
              int              y,
              UINT             width,
              UINT             height,
-             DBLFNPTR  chn1_source,
-             DBLFNPTR  chn2_source,
-             double    maxBankAngle,
-             double    maxSlipAngle,
+             FLTFNPTR  chn1_source,
+             FLTFNPTR  chn2_source,
+             float    maxBankAngle,
+             float    maxSlipAngle,
              UINT      gap_width,
              bool      working ) :
                dual_instr_item( x, y, width, height,
@@ -35,8 +35,8 @@ fgTBI_instr( int              x,
                                 chn2_source,
                                 working,
                                 HUDS_TOP),
-               BankLimit      (maxBankAngle),
-               SlewLimit      (maxSlipAngle),
+               BankLimit      ((int)(maxBankAngle)),
+               SlewLimit      ((int)(maxSlipAngle)),
                scr_hole       (gap_width   )
 {
 }
@@ -64,127 +64,80 @@ operator = (const fgTBI_instr & rhs )
 }
 
 //
-//	Draws a Turn Bank Indicator on the screen
+//  Draws a Turn Bank Indicator on the screen
 //
 
  void fgTBI_instr :: draw( void )
 {
-  int x_inc1, y_inc1;
-  int x_inc2, y_inc2;
-  int x_t_inc1, y_t_inc1;
-
-  int d_bottom_x, d_bottom_y;
-  int d_right_x, d_right_y;
-  int d_top_x, d_top_y;
-  int d_left_x, d_left_y;
-
-  int inc_b_x, inc_b_y;
-  int inc_r_x, inc_r_y;
-  int inc_t_x, inc_t_y;
-  int inc_l_x, inc_l_y;
-  RECT My_box = get_location();
-  POINT centroid = get_centroid();
-  int tee_height = My_box.bottom;
-
-//	struct fgFLIGHT *f = &current_aircraft.flight;
-  double sin_bank, cos_bank;
-  double bank_angle, sideslip_angle;
-  double ss_const; // sideslip angle pixels per rad
-
-  bank_angle     = current_ch2();  // Roll limit +/- 30 degrees
-  if( bank_angle < -FG_PI_2/3 ) {
-    bank_angle = -FG_PI_2/3;
-    }
-  else
-    if( bank_angle > FG_PI_2/3 ) {
-      bank_angle = FG_PI_2/3;
-      }
-  sideslip_angle = current_ch1(); // Sideslip limit +/- 20 degrees
-  if( sideslip_angle < -FG_PI/9 ) {
-    sideslip_angle = -FG_PI/9;
-    }
-  else
-    if( sideslip_angle > FG_PI/9 ) {
-      sideslip_angle = FG_PI/9;
-      }
-
-	// sin_bank = sin( FG_2PI-FG_Phi );
-	// cos_bank = cos( FG_2PI-FG_Phi );
-  sin_bank = sin(FG_2PI-bank_angle);
-  cos_bank = cos(FG_2PI-bank_angle);
-
-  x_inc1 = (int)(get_span() * cos_bank);
-  y_inc1 = (int)(get_span() * sin_bank);
-  x_inc2 = (int)(scr_hole  * cos_bank);
-  y_inc2 = (int)(scr_hole  * sin_bank);
-
-  x_t_inc1 = (int)(tee_height * sin_bank);
-  y_t_inc1 = (int)(tee_height * cos_bank);
-
-  d_bottom_x = 0;
-  d_bottom_y = (int)(-scr_hole);
-  d_right_x  = (int)(scr_hole);
-  d_right_y  = 0;
-  d_top_x    = 0;
-  d_top_y    = (int)(scr_hole);
-  d_left_x   = (int)(-scr_hole);
-  d_left_y   = 0;
-
-  ss_const = (get_span()*2)/(FG_2PI/9);  // width represents 40 degrees
-
-  d_bottom_x += (int)(sideslip_angle*ss_const);
-  d_right_x  += (int)(sideslip_angle*ss_const);
-  d_left_x   += (int)(sideslip_angle*ss_const);
-  d_top_x    += (int)(sideslip_angle*ss_const);
-
-  inc_b_x = (int)(d_bottom_x*cos_bank-d_bottom_y*sin_bank);
-  inc_b_y = (int)(d_bottom_x*sin_bank+d_bottom_y*cos_bank);
-  inc_r_x = (int)(d_right_x*cos_bank-d_right_y*sin_bank);
-  inc_r_y = (int)(d_right_x*sin_bank+d_right_y*cos_bank);
-  inc_t_x = (int)(d_top_x*cos_bank-d_top_y*sin_bank);
-  inc_t_y = (int)(d_top_x*sin_bank+d_top_y*cos_bank);
-  inc_l_x = (int)(d_left_x*cos_bank-d_left_y*sin_bank);
-  inc_l_y = (int)(d_left_x*sin_bank+d_left_y*cos_bank);
-
-  if( scr_hole == 0 )
-    {
-    drawOneLine( centroid.x - x_inc1, centroid.y - y_inc1, \
-                 centroid.x + x_inc1, centroid.y + y_inc1 );
-    }
-  else
-    {
-    drawOneLine( centroid.x - x_inc1, centroid.y - y_inc1, \
-                 centroid.x - x_inc2, centroid.y - y_inc2 );
-    drawOneLine( centroid.x + x_inc2, centroid.y + y_inc2, \
-                 centroid.x + x_inc1, centroid.y + y_inc1 );
-    }
-
-  // draw teemarks
-  drawOneLine( centroid.x + x_inc2,            \
-                 centroid.y + y_inc2,          \
-               centroid.x + x_inc2 + x_t_inc1, \
-                 centroid.y + y_inc2 - y_t_inc1 );
-  drawOneLine( centroid.x - x_inc2,            \
-                 centroid.y - y_inc2,          \
-               centroid.x - x_inc2 + x_t_inc1, \
-                 centroid.y - y_inc2 - y_t_inc1 );
-
-  // draw sideslip diamond (it is not yet positioned correctly )
-  drawOneLine( centroid.x + inc_b_x, \
-               centroid.y + inc_b_y, \
-               centroid.x + inc_r_x, \
-               centroid.y + inc_r_y );
-  drawOneLine( centroid.x + inc_r_x, \
-               centroid.y + inc_r_y, \
-               centroid.x + inc_t_x, \
-               centroid.y + inc_t_y );
-  drawOneLine( centroid.x + inc_t_x, \
-               centroid.y + inc_t_y, \
-               centroid.x + inc_l_x, \
-               centroid.y + inc_l_y );
-  drawOneLine( centroid.x + inc_l_x, \
-               centroid.y + inc_l_y, \
-               centroid.x + inc_b_x, \
-               centroid.y + inc_b_y );
-
+     float bank_angle, sideslip_angle;
+     float ss_const; // sideslip angle pixels per rad
+     float cen_x, cen_y, bank, fspan, tee, hole;
+
+     int span = get_span();
+     
+     float zero = 0.0;
+  
+     RECT My_box = get_location();
+     POINT centroid = get_centroid();
+     int tee_height = My_box.bottom;
+
+     bank_angle     = current_ch2();  // Roll limit +/- 30 degrees
+     
+     if( bank_angle < -FG_PI_2/3 ) {
+         bank_angle = -FG_PI_2/3;
+     } else if( bank_angle > FG_PI_2/3 ) {
+             bank_angle = FG_PI_2/3;
+     }
+     
+     sideslip_angle = current_ch1(); // Sideslip limit +/- 20 degrees
+     
+     if( sideslip_angle < -FG_PI/9 ) {
+         sideslip_angle = -FG_PI/9;
+     } else if( sideslip_angle > FG_PI/9 ) {
+             sideslip_angle = FG_PI/9;
+     }
+
+     cen_x = centroid.x;
+     cen_y = centroid.y;
+     bank  = bank_angle * RAD_TO_DEG;
+     tee   = -tee_height;
+     fspan = span;
+     hole  = scr_hole;
+     ss_const = 2 * sideslip_angle * fspan/(FG_2PI/9);  // width represents 40 degrees
+     
+//   printf("side_slip: %f   fspan: %f\n", sideslip_angle, fspan);
+//   printf("ss_const: %f   hole: %f\n", ss_const, hole);
+     
+     glPushMatrix();
+     glTranslatef(cen_x, cen_y, zero);
+     glRotatef(-bank, zero, zero, 1.0);
+    
+     glBegin(GL_LINES);
+     
+     if( !scr_hole )  
+     {
+         glVertex2f( -fspan, zero );
+         glVertex2f(  fspan, zero );
+     } else {
+         glVertex2f( -fspan, zero );
+         glVertex2f( -hole,  zero );
+         glVertex2f(  hole,  zero );
+         glVertex2f(  fspan, zero );
+     }
+     // draw teemarks
+     glVertex2f(  hole, zero );
+     glVertex2f(  hole, tee );
+     glVertex2f( -hole, zero );
+     glVertex2f( -hole, tee );
+     
+     glEnd();
+     
+     glBegin(GL_LINE_LOOP);
+         glVertex2f( ss_const,        -hole);
+         glVertex2f( ss_const + hole,  zero);
+         glVertex2f( ss_const,         hole);
+         glVertex2f( ss_const - hole,  zero);
+     glEnd();
+
+     glPopMatrix();
 }
diff --git a/Simulator/Cockpit/panel.cxx b/Simulator/Cockpit/panel.cxx
index e8f6fba43..47eb3a397 100644
--- a/Simulator/Cockpit/panel.cxx
+++ b/Simulator/Cockpit/panel.cxx
@@ -25,10 +25,6 @@
 #  include <config.h>
 #endif
 
-#ifdef FG_MATH_EXCEPTION_CLASH
-#  include <math.h>
-#endif        
-
 #ifdef HAVE_WINDOWS_H          
 #  include <windows.h>
 #endif
@@ -79,10 +75,10 @@ static int n2;
 
 static GLfloat Wings[] = {
     -1.25, -28.125, 1.255, -28.125, 1.255, 28.125, -1.25, 28.125};
-	
+    
 static GLfloat Elevator[] = {
     3.0, -10.9375, 4.5, -10.9375, 4.5, 10.9375, 3.0, 10.9375};
-	
+    
 static GLfloat Rudder[] = {
     2.0, -0.45, 10.625, -0.45, 10.625, 0.55, 2.0, 0.55};
 
@@ -95,35 +91,35 @@ FGPanel::FGPanel(void){
     char line[256];
     GLint test;
     GLubyte *tex = new GLubyte[262144];
-
+    
     if(OurPanel) {
-	FG_LOG( FG_GENERAL, FG_ALERT, "Error: only one Panel allowed" );
-	exit(-1);
+        FG_LOG( FG_GENERAL, FG_ALERT, "Error: only one Panel allowed" );
+        exit(-1);
     }
-
+    
     OurPanel = this;   
-
+    
     Xzoom = (float)((float)(current_view.get_winWidth())/1024);
     Yzoom = (float)((float)(current_view.get_winHeight())/768);
-	
+    
     test_instr[3] = new FGTexInstrument(144.375, 166.875, 4, 32, 3, 30, 15.0,
-					260.0, -20.0, 360, 65, 193, 0);
+                                        260.0, -20.0, 360, 65, 193, 0);
     test_instr[4] = new FGTexInstrument(358, 52, 4, 30, 3, 30, -3.0, 3.0, 100,
-					440, 66.15, 66, 2);
+                                        440, 66.15, 66, 2);
     test_instr[5] = new FGTexInstrument(357.5, 167, 5, 25, 4, 30, 0, 10000, 0,
-					360, 194, 191, 1);
+                                        360, 194, 191, 1);
     test_instr[6] = new FGTexInstrument(357.5, 167, 5, 32, 3, 30, 0, 3000, 0,
-					1080, 194, 191, 1);
+                                        1080, 194, 191, 1);
     test_instr[0] = new FGHorizon(251, 166.75);
     test_instr[1] = new FGTurnCoordinator(143.75, 51.75);
     //test_instr[2] = new FGRpmGauge(462.5, 133);
     test_instr[2] = new FGTexInstrument(462.5, 133, 10, 20, 5.5, 60, 0.0, 1.0,
-					-67, 180, 174, 83, 3); 
-	
+                                        -67, 180, 174, 83, 3); 
+    
     // FontList = glGenLists (256);
     // glListBase(FontList);
     // InitLists();
-
+    
 #ifdef GL_VERSION_1_1
     xglGenTextures(2, panel_tex_id);
     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[1]);
@@ -133,7 +129,7 @@ FGPanel::FGPanel(void){
 #else
 #  error port me
 #endif
-
+    
     xglMatrixMode(GL_PROJECTION);
     xglPushMatrix();
     xglLoadIdentity();
@@ -147,7 +143,7 @@ FGPanel::FGPanel(void){
     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);   
     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
+    
     // load in the texture data 
     
     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 256);
@@ -155,36 +151,36 @@ FGPanel::FGPanel(void){
     tpath.append( "Textures/gauges.rgb" );
     if((img = read_rgb_texture( (char *)tpath.c_str(), &img_width,                      &img_height ))==NULL){
     }
-
+    
     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 256);
     tpath.set( current_options.get_fg_root() );
     tpath.append( "Textures/gauges2.rgb" );
     if((imag = read_rgb_texture( (char *)tpath.c_str(), &imag_width,                     &imag_height ))==NULL){
     }
-
+    
     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
-
+    
     tpath.set( current_options.get_fg_root() );
     tpath.append( "Textures/Fullone.rgb" );
     if ((background = read_rgb_texture( (char *)tpath.c_str(), &width,                         &height ))==NULL ){
     }
-
+    
     //    for(y=0;y<256;y++){
-    //    	for(x=0;x<256;x++){
-    //    	tex[(y+x*256)*3] = imag[(y+x*256)*3];
-    //    	tex[(y+x*256)*3 + 1] = imag[(y+x*256)*3 + 1];
-    //    	tex[(y+x*256)*3 + 2] = imag[(y+x*256)*3 + 2];
-    //    	tex[(y+x*256)*3 + 3] = (imag[(y+x*256)*3 + 1] + imag[(y+x*256)*3 + 2]   //                               + imag[(y+x*256)*3 + 0])/3;
-    //    	
-    //	if((imag[(y+x*256)*3] < 150) && (imag[(y+x*256)*3 +1] < 150) &&         //             (imag[(y+x*256)*3 + 2] < 150) ){
+    //      for(x=0;x<256;x++){
+    //      tex[(y+x*256)*3] = imag[(y+x*256)*3];
+    //      tex[(y+x*256)*3 + 1] = imag[(y+x*256)*3 + 1];
+    //      tex[(y+x*256)*3 + 2] = imag[(y+x*256)*3 + 2];
+    //      tex[(y+x*256)*3 + 3] = (imag[(y+x*256)*3 + 1] + imag[(y+x*256)*3 + 2]   //                               + imag[(y+x*256)*3 + 0])/3;
+    //      
+    //  if((imag[(y+x*256)*3] < 150) && (imag[(y+x*256)*3 +1] < 150) &&         //             (imag[(y+x*256)*3 + 2] < 150) ){
     //              tex[(y+x*256)*3 + 3] = 0x0;
     //               }
     //           else{
     //             tex[(y+x*256)*3 + 3] = 0xff;
     //             }
-    //    	 }
+    //       }
     // }
-
+    
     xglPixelZoom(Xzoom, Yzoom);
     xglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
@@ -193,7 +189,7 @@ FGPanel::FGPanel(void){
     xglPixelZoom(Xzoom, Yzoom);
     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 256);
     xglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB,                                   GL_UNSIGNED_BYTE, imag);
-		  
+    
 #ifdef GL_VERSION_1_1
     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[0]);
 #elif GL_EXT_texture_object
@@ -206,7 +202,7 @@ FGPanel::FGPanel(void){
     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     xglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB,                                  GL_UNSIGNED_BYTE, (GLvoid *)(img)); 
-		  
+    
     xglMatrixMode(GL_MODELVIEW);
     xglPopMatrix();
 }
@@ -247,15 +243,15 @@ void FGPanel::ReInit( int x, int y, int finx, int finy){
     xglRasterPos2i(x, y);
     xglPixelZoom(Xzoom, Yzoom);
     xglDrawPixels(finx - x, finy - y, GL_RGB, GL_UNSIGNED_BYTE,
-		  (GLvoid *)(background));
-	
+                  (GLvoid *)(background));
+    
     // restore original buffer state
     xglDrawBuffer( (GLenum)buffer );
     xglEnable(GL_DEPTH_TEST);
 }
 
 void FGPanel::Update ( void ) {
-
+    
     float alpha;
     double pitch;
     double roll;
@@ -265,13 +261,13 @@ void FGPanel::Update ( void ) {
     
     //    static bool beech_drawn = false;
     //    char *test = "ALM 100";
-                          
+    
     var[0] = get_speed() /* * 1.4 */; // We have to multiply the airspeed by a 
     // factor, to simulate flying a Bonanza 
     var[1] = get_altitude();
     var[2] = get_climb_rate() / 1000.0; 
     var[3] = get_throttleval();
-
+    
     xglMatrixMode(GL_PROJECTION);
     xglPushMatrix();
     xglLoadIdentity();
@@ -283,11 +279,11 @@ void FGPanel::Update ( void ) {
     xglEnable(GL_LIGHTING);
     xglEnable(GL_TEXTURE_2D);
     xglDisable(GL_BLEND);
-
+    
     xglMatrixMode(GL_MODELVIEW);
     xglPopMatrix();
     xglPushMatrix();
-
+    
     xglDisable(GL_LIGHTING);
     test_instr[3]->Render();
     test_instr[4]->Render();
@@ -298,12 +294,12 @@ void FGPanel::Update ( void ) {
     
     test_instr[1]->Render();
     test_instr[2]->Render();
-
+    
     //   DrawBeechcraftLogo(230, 235, 30, 10);
     //   DrawScale(144.375, 166.875, 38, 41.0, 18, 340, 44, 2.0, 1.0, 1.0, 1.0);
     
     xglEnable(GL_LIGHTING);
-            
+    
     test_instr[0]->Render();
     
     
@@ -321,7 +317,7 @@ void FGPanel::Update ( void ) {
 
 // horizon - Let's draw an artificial horizon using both texture mapping and 
 //           primitive drawing
- 
+
 void FGHorizon::Render(void){ 
     double pitch;
     double roll;
@@ -347,10 +343,10 @@ void FGHorizon::Render(void){
     
     pitch = get_pitch() * RAD_TO_DEG;
     if(pitch > 45)
-	pitch = 45;
+        pitch = 45;
     
     if(pitch < -45)
-	pitch = -45;
+        pitch = -45;
     
     roll = get_roll() * RAD_TO_DEG;
     
@@ -366,36 +362,36 @@ void FGHorizon::Render(void){
     xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
     xglMatrixMode(GL_TEXTURE);
     xglPushMatrix();
-        
+    
     // computations for the non-textured parts of the AH
     
     shifted = -((pitch / 10) * 7.0588235);
-        
+    
     if(shifted > (bottom - radius)){
-	theta = (180 - (acos((bottom - shifted) / radius)*RAD_TO_DEG));
-	n = (int)(theta / epsi) - 1;
-	n1 = n;
-	n2 = (180 - n1) + 2;
-	dn = n2 - n1;
-	rot = (int)(roll / epsi);
-	n1 += rot + 45;
-	n2 += rot + 45;
+        theta = (180 - (acos((bottom - shifted) / radius)*RAD_TO_DEG));
+        n = (int)(theta / epsi) - 1;
+        n1 = n;
+        n2 = (180 - n1) + 2;
+        dn = n2 - n1;
+        rot = (int)(roll / epsi);
+        n1 += rot + 45;
+        n2 += rot + 45;
     }
     
     if(shifted < (-top + radius)){
-	theta = ((acos((-top - shifted) / radius)*RAD_TO_DEG));
-	n = (int)(theta / epsi) + 1;
-	n1 = n;
-	n2 = (180 - n1) + 2;
-	dn = n2 - n1;
-	rot = (int)(roll / epsi);
-	n1 += rot - 45;
-	n2 += rot - 45;
-	if(n1 < 0){ n1 += 180; n2 +=180;}
+        theta = ((acos((-top - shifted) / radius)*RAD_TO_DEG));
+        n = (int)(theta / epsi) + 1;
+        n1 = n;
+        n2 = (180 - n1) + 2;
+        dn = n2 - n1;
+        rot = (int)(roll / epsi);
+        n1 += rot - 45;
+        n2 += rot - 45;
+        if(n1 < 0){ n1 += 180; n2 +=180;}
     }
     
     // end of computations  
-       
+    
     light_position[0] = 0.0;
     light_position[1] = 0.0; 
     light_position[2] = 1.5;
@@ -405,7 +401,7 @@ void FGHorizon::Render(void){
     xglLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
     xglLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);
     xglLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, direction);
-
+    
 #ifdef GL_VERSION_1_1
     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[1]);
 #elif GL_EXT_texture_object
@@ -413,13 +409,13 @@ void FGHorizon::Render(void){
 #else
 #  error port me
 #endif
-
+    
     xglLoadIdentity();
     xglTranslatef(0.0, ((pitch / 10) * 0.046875), 0.0);
     xglTranslatef((texXPos/256), (texYPos/256), 0.0);
     xglRotatef(-roll, 0.0, 0.0, 1.0);
     xglScalef(1.7, 1.7, 0.0);
-
+    
     // the following loop draws the textured part of the AH
     
     xglMaterialf(GL_FRONT, GL_SHININESS, 85.0);
@@ -427,93 +423,89 @@ void FGHorizon::Render(void){
     xglMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material4);
     xglMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material5);
     xglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material3);
-   
+    
     xglMatrixMode(GL_MODELVIEW);
     xglBegin(GL_TRIANGLES);
     for(i=45;i<225;i++){
-	xglTexCoord2f(0.0, 0.0);
-	xglNormal3f(0.0, 0.0, 0.6);
-	xglVertex3f(0.0, 0.0, 0.0);
-	xglTexCoord2f(texCoord[i % 180][0], texCoord[i % 180][1]);
-	xglNormal3f(normals[i % 180][0], normals[i % 180][1], 0.6);
-	xglVertex3f(vertices[i % 180][0], vertices[i % 180][1], 0.0);
-	n = (i + 1) % 180;
-	xglTexCoord2f(texCoord[n][0], texCoord[n][1]);
-	xglNormal3f(normals[n][0], normals[n][1], 0.6);
-	xglVertex3f(vertices[n][0], vertices[n][1], 0.0);
+        xglTexCoord2f(0.0, 0.0);
+        xglNormal3f(0.0, 0.0, 0.6);
+        xglVertex3f(0.0, 0.0, 0.0);
+        xglTexCoord2f(texCoord[i % 180][0], texCoord[i % 180][1]);
+        xglNormal3f(normals[i % 180][0], normals[i % 180][1], 0.6);
+        xglVertex3f(vertices[i % 180][0], vertices[i % 180][1], 0.0);
+        n = (i + 1) % 180;
+        xglTexCoord2f(texCoord[n][0], texCoord[n][1]);
+        xglNormal3f(normals[n][0], normals[n][1], 0.6);
+        xglVertex3f(vertices[n][0], vertices[n][1], 0.0);
     }
     xglEnd();
     
-            
-    if((shifted > (bottom - radius)) && (n1 < 1000) && (n1 > 0)){
     
-	a = sin(theta * DEG_TO_RAD) * sin(theta * DEG_TO_RAD);
-	light_ambient2[0] = a;
-	light_ambient2[1] = a;
-	light_ambient2[2] = a;
-    
-	xglLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient2);
-	xglLightfv(GL_LIGHT1, GL_DIFFUSE, light_ambient2); 
-	xglLightfv(GL_LIGHT1, GL_SPECULAR, light_ambient2);
+    if((shifted > (bottom - radius)) && (n1 < 1000) && (n1 > 0)){
         
-	xglBegin(GL_TRIANGLES);
-    
-	tmp1 = n1; tmp2 = n2;
+        a = sin(theta * DEG_TO_RAD) * sin(theta * DEG_TO_RAD);
+        light_ambient2[0] = a;
+        light_ambient2[1] = a;
+        light_ambient2[2] = a;
         
-	for(i = tmp1; i < tmp2 + 1; i++){
-	    n = i % 180;
-	    xglNormal3f(0.0, 0.0, 1.5);
-	    xglTexCoord2f((56 / 256), (140 / 256));
-            xglVertex3f(((vertices[n1 % 180][0] + vertices[n2 % 180][0]) / 2),
-			((vertices[n1 % 180][1] + vertices[n2 % 180][1]) / 2),
-			0.0);
-                                                
-	    xglTexCoord2f((57 / 256), (139 / 256));        
-	    xglNormal3f(normals[n][0], normals[n][1], normals[n][3]);
-	    xglVertex3f(vertices[n][0], vertices[n][1], 0.0);
-		     
-	    n = (i + 1) % 180;
-	    xglTexCoord2f((57 / 256), (139 / 256));	     
-	    xglNormal3f(normals[n][0], normals[n][1], normals[n][3]);
-	    xglVertex3f(vertices[n][0], vertices[n][1], 0.0);	     
-	}
-	xglEnd();
-    }
+        xglLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient2);
+        xglLightfv(GL_LIGHT1, GL_DIFFUSE, light_ambient2); 
+        xglLightfv(GL_LIGHT1, GL_SPECULAR, light_ambient2);
+        
+        xglBegin(GL_TRIANGLES);
+        
+        tmp1 = n1; tmp2 = n2;
+        
+        for(i = tmp1; i < tmp2 + 1; i++){
+            n = i % 180;
+            xglNormal3f(0.0, 0.0, 1.5);
+            xglTexCoord2f((56 / 256), (140 / 256));
+            xglVertex3f(((vertices[n1 % 180][0] + vertices[n2 % 180][0]) / 2),                            ((vertices[n1 % 180][1] + vertices[n2 % 180][1]) / 2),                             0.0);
+            
+            xglTexCoord2f((57 / 256), (139 / 256));        
+            xglNormal3f(normals[n][0], normals[n][1], normals[n][3]);
+            xglVertex3f(vertices[n][0], vertices[n][1], 0.0);
             
+            n = (i + 1) % 180;
+            xglTexCoord2f((57 / 256), (139 / 256));      
+            xglNormal3f(normals[n][0], normals[n][1], normals[n][3]);
+            xglVertex3f(vertices[n][0], vertices[n][1], 0.0);        
+        }
+        xglEnd();
+    }
+    
     if((shifted < (-top + radius)) && (n1 < 1000) && (n1 > 0)){
-	a = sin(theta * DEG_TO_RAD) * sin(theta * DEG_TO_RAD);
-	light_ambient2[0] = a;
-	light_ambient2[1] = a;
-	light_ambient2[2] = a;
-     
-	xglLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient2);
-	xglLightfv(GL_LIGHT1, GL_DIFFUSE, light_ambient2); 
-	xglLightfv(GL_LIGHT1, GL_SPECULAR, light_ambient2);
-	xglMaterialf(GL_FRONT, GL_SHININESS, a * 85);
-	xglBegin(GL_TRIANGLES);
-	tmp1 = n1; tmp2 = n2;
-	for(i = tmp1; i <= tmp2; i++){
-	    n = i % 180;
-	    xglNormal3f(0.0, 0.0, 1.5);
-	    xglTexCoord2f((73 / 256), (237 / 256));
-	    xglVertex3f(((vertices[n1 % 180][0] + vertices[n2 % 180][0]) / 2),
-			((vertices[n1 % 180][1] + vertices[n2 % 180][1]) / 2),
-			0.0); 
-                      
-	    xglTexCoord2f((73 / 256), (236 / 256));
-	    xglNormal3f(normals[n][0], normals[n][1], normals[n][2]);
-	    xglVertex3f(vertices[n][0], vertices[n][1], 0.0);
-		     
-	    n = (i + 1) % 180;
-	    xglTexCoord2f((73 / 256), (236 / 256)); 
-	    xglNormal3f(normals[n][0], normals[n][1], normals[n][2]);
-	    xglVertex3f(vertices[n][0], vertices[n][1], 0.0); 
-	}
-	xglEnd();
+        a = sin(theta * DEG_TO_RAD) * sin(theta * DEG_TO_RAD);
+        light_ambient2[0] = a;
+        light_ambient2[1] = a;
+        light_ambient2[2] = a;
+        
+        xglLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient2);
+        xglLightfv(GL_LIGHT1, GL_DIFFUSE, light_ambient2); 
+        xglLightfv(GL_LIGHT1, GL_SPECULAR, light_ambient2);
+        xglMaterialf(GL_FRONT, GL_SHININESS, a * 85);
+        xglBegin(GL_TRIANGLES);
+        tmp1 = n1; tmp2 = n2;
+        for(i = tmp1; i <= tmp2; i++){
+            n = i % 180;
+            xglNormal3f(0.0, 0.0, 1.5);
+            xglTexCoord2f((73 / 256), (237 / 256));
+            xglVertex3f(((vertices[n1 % 180][0] + vertices[n2 % 180][0]) / 2),                            ((vertices[n1 % 180][1] + vertices[n2 % 180][1]) / 2), 0.0); 
+            
+            xglTexCoord2f((73 / 256), (236 / 256));
+            xglNormal3f(normals[n][0], normals[n][1], normals[n][2]);
+            xglVertex3f(vertices[n][0], vertices[n][1], 0.0);
+            
+            n = (i + 1) % 180;
+            xglTexCoord2f((73 / 256), (236 / 256)); 
+            xglNormal3f(normals[n][0], normals[n][1], normals[n][2]);
+            xglVertex3f(vertices[n][0], vertices[n][1], 0.0); 
+        }
+        xglEnd();
     }
     
     // Now we will have to draw the small triangle indicating the roll value
-
+    
     xglDisable(GL_LIGHTING);
     xglDisable(GL_TEXTURE_2D);
     
@@ -527,7 +519,7 @@ void FGHorizon::Render(void){
     xglEnd();
     
     xglLoadIdentity();
-
+    
     xglBegin(GL_POLYGON);
     xglColor3f(0.2109375, 0.23046875, 0.203125);
     xglVertex2f(275.625, 138.0);
@@ -538,7 +530,7 @@ void FGHorizon::Render(void){
     xglVertex2f(226.875, 138.0);
     xglVertex2f(275.625, 138.0);
     xglEnd();
-
+    
     xglLoadIdentity();
     
     xglMatrixMode(GL_TEXTURE);
@@ -561,17 +553,17 @@ void FGHorizon::Init(void){
     bottom = 36.5;
     top = 36.5;
     int n;
-
+    
     float step = (360*DEG_TO_RAD)/180;
-
+    
     for(n=0;n<180;n++){
-	vertices[n][0] = cos(n * step) * radius;
-	vertices[n][1] = sin(n * step) * radius;
-	texCoord[n][0] = (cos(n * step) * radius)/256;
-	texCoord[n][1] = (sin(n * step) * radius)/256;
-	normals[n][0] = cos(n * step) * radius + sin(n * step);
-	normals[n][1] = sin(n * step) * radius + cos(n * step);
-	normals[n][2] = 0.0;
+        vertices[n][0] = cos(n * step) * radius;
+        vertices[n][1] = sin(n * step) * radius;
+        texCoord[n][0] = (cos(n * step) * radius)/256;
+        texCoord[n][1] = (sin(n * step) * radius)/256;
+        normals[n][0] = cos(n * step) * radius + sin(n * step);
+        normals[n][1] = sin(n * step) * radius + cos(n * step);
+        normals[n][2] = 0.0;
     }
 }
 
@@ -582,14 +574,14 @@ void FGTexInstrument::UpdatePointer(void){
     double speed;    
     glEnableClientState(GL_VERTEX_ARRAY);
     glVertexPointer(2, GL_FLOAT, 0, vertices);
-
+    
     alpha=((((float)((var[variable]) - (value1))) /
-	    (value2 - value1))* (alpha2 - alpha1) + alpha1);
+            (value2 - value1))* (alpha2 - alpha1) + alpha1);
     
     if (alpha < alpha1)
-	alpha = alpha1;
+        alpha = alpha1;
     if (alpha > alpha2)
-	alpha = alpha2;
+        alpha = alpha2;
     xglMatrixMode(GL_MODELVIEW);  
     xglPushMatrix();
     xglLoadIdentity();
@@ -612,7 +604,7 @@ void fgEraseArea(GLfloat *array, int NumVerti, GLfloat texXPos,
     int n;
     float a;
     float ififth;
-
+    
     xglEnable(GL_TEXTURE_2D);
     xglEnable(GL_TEXTURE_GEN_S);
     xglEnable(GL_TEXTURE_GEN_T);
@@ -623,7 +615,7 @@ void fgEraseArea(GLfloat *array, int NumVerti, GLfloat texXPos,
     xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
     xglMatrixMode(GL_TEXTURE);
     xglLoadIdentity();
-        
+    
 #ifdef GL_VERSION_1_1
     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[Texid]);
 #elif GL_EXT_texture_object
@@ -631,19 +623,19 @@ void fgEraseArea(GLfloat *array, int NumVerti, GLfloat texXPos,
 #else
 #  error port me
 #endif
-
+    
     xglMatrixMode(GL_TEXTURE);
     xglLoadIdentity();
     xglTranslatef(-((float)((XPos/0.625)/256)),                                                   -((float)((YPos/0.625)/256)), 0.0);
     xglTranslatef(texXPos/256 , texYPos/256, 0.0);
     xglScalef(0.00625, 0.00625, 1.0);
-			
+    
     xglBegin(GL_POLYGON);
-    for(n=0;n<NumVerti;n += 2){	
-	xglVertex2f(array[n] * ScaleFactor, array[n + 1] * ScaleFactor);
+    for(n=0;n<NumVerti;n += 2){ 
+        xglVertex2f(array[n] * ScaleFactor, array[n + 1] * ScaleFactor);
     } 
     xglEnd();
- 
+    
     xglLoadIdentity();
     xglMatrixMode(GL_MODELVIEW);
     xglPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
@@ -651,7 +643,7 @@ void fgEraseArea(GLfloat *array, int NumVerti, GLfloat texXPos,
     xglDisable(GL_TEXTURE_2D);
     xglDisable(GL_TEXTURE_GEN_S);
     xglDisable(GL_TEXTURE_GEN_T);
-        
+    
 }
 
 // CreatePointer - calculate the vertices of a pointer 
@@ -661,59 +653,59 @@ void FGTexInstrument::CreatePointer(void){
     float alpha;
     float alphastep;
     float r = radius;
-
+    
     vertices[0] = 0;
     vertices[1] = length;
     vertices[2] = -(width/2);
     vertices[3] = length - ((width/2)/(tan(angle*DEG_TO_RAD/2)));
     vertices[4] = -(width/2);
     vertices[5] = cos(asin((width/2)/r))*r;
-
+    
     alphastep = (asin((width/2)/r)+asin((width/2)/r))/5;
     alpha = asin(-(width/2)/r);
-
+    
     for(i=0;i<5;i++){
-	alpha += alphastep;
-	vertices[(i*2)+6] = sin(alpha)*r;
+        alpha += alphastep;
+        vertices[(i*2)+6] = sin(alpha)*r;
     }
-
+    
     alpha = asin(-(width/2)/r);
-
+    
     for(i=0;i<5;i++){
-	alpha +=alphastep;
-	vertices[(i*2)+7]= cos(alpha)*r;
+        alpha +=alphastep;
+        vertices[(i*2)+7]= cos(alpha)*r;
     }
-
+    
     vertices[16] = - vertices[4];
     vertices[17] = vertices[5];
     vertices[18] = - vertices[2];
     vertices[19] = vertices[3];
-
+    
 }
 
 // fgUpdateTurnCoordinator - draws turn coordinator related stuff
 
 void FGTurnCoordinator::Render(void){
     int n;
-
+    
     xglDisable(GL_LIGHTING);
     xglDisable(GL_BLEND);
     xglEnable(GL_TEXTURE_2D);
-
+    
     alpha = (get_sideslip() / 1.5) * 560;
     if(alpha > 56){
-	alpha = 56;
+        alpha = 56;
     }
     if(alpha < -56){
-	alpha = -56;
+        alpha = -56;
     }
- 
+    
     PlaneAlpha = get_roll();
-
+    
     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
-
+    
     xglMatrixMode(GL_MODELVIEW);
     xglLoadIdentity();
     xglTranslatef(BallXPos, BallYPos, 0.0);
@@ -729,33 +721,33 @@ void FGTurnCoordinator::Render(void){
     xglBegin(GL_POLYGON);
     xglColor3f(0.8, 0.8, 0.8);
     for(i=0;i<36;i++){
-	xglVertex2f(vertices[2 * i],                                                                vertices[(2 * i) + 1]);
+        xglVertex2f(vertices[2 * i],                                                                vertices[(2 * i) + 1]);
     }
     xglEnd(); 
-
+    
     xglDisable(GL_TEXTURE_2D);
     xglDisable(GL_BLEND);
-
+    
     xglMatrixMode(GL_MODELVIEW);
     xglLoadIdentity();
     xglTranslatef(XPos, YPos, 0.0);
     xglRotatef(rollhist[0] * RAD_TO_DEG + 90, 0.0, 0.0, 1.0);
-
+    
     fgEraseArea(Wings, 8, PlaneTexXPos, PlaneTexYPos,                                                     XPos, YPos, 1, 1); 
     fgEraseArea(Elevator, 8, PlaneTexXPos, PlaneTexYPos,                                                     XPos, YPos, 1, 1); 
     fgEraseArea(Rudder, 8, PlaneTexXPos, PlaneTexYPos,                                                     XPos, YPos, 1, 1); 
-
+    
     xglLoadIdentity();
     xglTranslatef(XPos, YPos, 0.0);
     xglRotatef(-get_roll() * RAD_TO_DEG + 90, 0.0, 0.0, 1.0);
-
+    
     xglBegin(GL_POLYGON);
     xglColor3f(1.0, 1.0, 1.0);
     for(i=0;i<90;i++){
-	xglVertex2f(cos(i * 4 * DEG_TO_RAD) * 5, sin(i * 4 * DEG_TO_RAD) * 5);
+        xglVertex2f(cos(i * 4 * DEG_TO_RAD) * 5, sin(i * 4 * DEG_TO_RAD) * 5);
     }
     xglEnd();
-
+    
     xglBegin(GL_POLYGON);
     xglVertex2f(Wings[0], Wings[1]);
     xglVertex2f(Wings[2], Wings[3]);
@@ -763,7 +755,7 @@ void FGTurnCoordinator::Render(void){
     xglVertex2f(Wings[6], Wings[7]);
     xglVertex2f(Wings[0], Wings[1]);
     xglEnd();
-
+    
     xglBegin(GL_POLYGON);
     xglVertex2f(Elevator[0], Elevator[1]);
     xglVertex2f(Elevator[2], Elevator[3]);
@@ -771,7 +763,7 @@ void FGTurnCoordinator::Render(void){
     xglVertex2f(Elevator[6], Elevator[7]);
     xglVertex2f(Elevator[0], Elevator[1]);
     xglEnd();
-
+    
     xglBegin(GL_POLYGON);
     xglVertex2f(Rudder[0], Rudder[1]);
     xglVertex2f(Rudder[2], Rudder[3]);
@@ -779,13 +771,13 @@ void FGTurnCoordinator::Render(void){
     xglVertex2f(Rudder[6], Rudder[7]);
     xglVertex2f(Rudder[0], Rudder[1]);
     xglEnd();
-
-
+    
+    
     alphahist[0] = alphahist[1];
     alphahist[1] = alpha;
     rollhist[0] = rollhist[1];
     rollhist[1] = -get_roll();
-
+    
     xglDisable(GL_BLEND);
 }
 
@@ -798,51 +790,52 @@ void FGTurnCoordinator::Init(void){
     BallTexXPos = 49;
     BallTexYPos = 16;
     BallRadius = 3.5;
-
+    
     for(n=0;n<36;n++){
-	vertices[2 * n] = cos(10 * n * DEG_TO_RAD) * BallRadius;
-	vertices[(2 * n) + 1] = sin(10 * n * DEG_TO_RAD) * BallRadius;
-    }	
+        vertices[2 * n] = cos(10 * n * DEG_TO_RAD) * BallRadius;
+        vertices[(2 * n) + 1] = sin(10 * n * DEG_TO_RAD) * BallRadius;
+    }   
 }
 
-void DrawScale(float XPos, float YPos, float InnerRadius, float OuterRadius,
-	       float alpha1, float alpha2, int steps, float LineWidth,
-	       float red, float green, float blue, bool filled){
+void DrawScale(float XPos, float YPos, float InnerRadius, float OuterRadius,                   float alpha1, float alpha2, int steps, float LineWidth,
+               float red, float green, float blue, bool filled){
     int i;
     float diff = (alpha2 - alpha1) / (float)(steps - 1);
-     
+    
 #define ANTIALIASED_INSTRUMENTS
-
+    
 #ifdef ANTIALIASED_INSTRUMENTS
     xglEnable(GL_LINE_SMOOTH);
     xglEnable(GL_BLEND);
     xglHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
 #endif
-     
+    
     xglMatrixMode(GL_MODELVIEW);
     xglLoadIdentity();
-     
+    
     xglTranslatef(XPos, YPos, 0.0);
     xglRotatef(-alpha1, 0.0, 0.0, 1.0);
-     
+    
     xglLineWidth(LineWidth);
     xglColor3f(red, green, blue);
-     
+    
     if(!filled){
-	xglBegin(GL_LINES);
+        xglBegin(GL_LINES);
     }
     else{
-	xglBegin(GL_QUAD_STRIP);
+        xglBegin(GL_QUAD_STRIP);
     }
-     
+    
     for(i=0;i < steps; i++){
-	xglVertex3f(sin(i * diff * DEG_TO_RAD) * OuterRadius,
-		    cos(i * diff * DEG_TO_RAD) * OuterRadius, 0.0);
-	xglVertex3f(sin(i * diff * DEG_TO_RAD) * InnerRadius,
-		    cos(i * diff * DEG_TO_RAD) * InnerRadius, 0.0);
+        xglVertex3f(sin(i * diff * DEG_TO_RAD) * OuterRadius,
+                    cos(i * diff * DEG_TO_RAD) * OuterRadius,
+                    0.0);
+        xglVertex3f(sin(i * diff * DEG_TO_RAD) * InnerRadius,
+                    cos(i * diff * DEG_TO_RAD) * InnerRadius,
+                    0.0);
     }
     xglEnd();
-     
+    
     xglLoadIdentity();
     xglDisable(GL_LINE_SMOOTH);
     xglDisable(GL_BLEND);
@@ -856,7 +849,7 @@ void DrawBeechcraftLogo(float XPos, float YPos, float width, float height){
     xglEnable(GL_TEXTURE_2D);
     //   xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
     //   xglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
+    
 #ifdef GL_VERSION_1_1
     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[1]);
 #elif GL_EXT_texture_object
@@ -864,7 +857,7 @@ void DrawBeechcraftLogo(float XPos, float YPos, float width, float height){
 #else
 #  error port me
 #endif
-
+    
     xglBegin(GL_POLYGON);
     
     xglTexCoord2f(.39844, .01953);
@@ -881,59 +874,59 @@ void DrawBeechcraftLogo(float XPos, float YPos, float width, float height){
     xglDisable(GL_BLEND);
     xglDisable(GL_TEXTURE_2D);
 }
-    
+
 
 // PrintMatrix - routine to print the current modelview matrix.                 
 
 void PrintMatrix( void){
     xglGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix);
-    printf("matrix2 = %f %f %f %f \n", 
-	   mvmatrix[0], mvmatrix[1], mvmatrix[2], mvmatrix[3]);
-    printf("         %f %f %f %f \n", 
-	   mvmatrix[4], mvmatrix[5], mvmatrix[6], mvmatrix[7]);
-    printf("         %f %f %f %f \n", 
-	   mvmatrix[8], mvmatrix[9], mvmatrix[10], mvmatrix[11]);
-    printf("         %f %f %f %f \n", 
-	   mvmatrix[12], mvmatrix[13], mvmatrix[14], mvmatrix[15]);
+    printf("matrix2 = %f %f %f %f \n",
+           mvmatrix[0], mvmatrix[1], mvmatrix[2], mvmatrix[3]);
+    printf("         %f %f %f %f \n",
+           mvmatrix[4], mvmatrix[5], mvmatrix[6], mvmatrix[7]);
+    printf("         %f %f %f %f \n",
+           mvmatrix[8], mvmatrix[9], mvmatrix[10], mvmatrix[11]);
+    printf("         %f %f %f %f \n",
+           mvmatrix[12], mvmatrix[13], mvmatrix[14], mvmatrix[15]);
 }
 
 void FGRpmGauge::Init(void){
     list = xglGenLists (1);
     int n;
-     
+    
     xglNewList(list, GL_COMPILE);
-     
+    
     xglColor3f(.26, .289, .3281);
     xglBegin(GL_POLYGON);
     for(n = 0; n < 180; n++){
-	xglVertex2f(cos(n * 0.0349066) * 24.5, sin(n * 0.0349066) * 24.5);
+        xglVertex2f(cos(n * 0.0349066) * 24.5, sin(n * 0.0349066) * 24.5);
     }
     xglEnd();
-	
+    
     DrawScale(XPos, YPos, 22.5, 25.625, 50, 135, 10, 1.0, 0.0, 0.7, 0.0,FILLED);
     DrawScale(XPos, YPos, 21.0, 25.625, -70, 180, 8, 1.8, 0.88, 0.88, 0.88, false);
     DrawScale(XPos, YPos, 22.5, 25.0, -70, 180, 40, 0.6, 0.5, 0.5, 0.5, false);
-          
+    
     xglEndList();
 }
-     
+
 void FGRpmGauge::Render(void){
     xglMatrixMode(GL_MODELVIEW);
     xglLoadIdentity();
     xglTranslatef(XPos, YPos, 0.0);
-     
+    
     xglCallList(list);
-          
+    
 }
-     
+
 void FGPanel::DrawTestLetter(float X, float Y){
     xglEnable(GL_TEXTURE_2D);
     xglEnable(GL_BLEND);
-     
+    
     xglMatrixMode(GL_TEXTURE);
     xglLoadIdentity();
     xglTranslatef(X, Y, 0.0);
-     
+    
     DrawLetter();
     
     xglMatrixMode(GL_MODELVIEW); 
@@ -941,127 +934,127 @@ void FGPanel::DrawTestLetter(float X, float Y){
     xglDisable(GL_TEXTURE_2D);
     xglDisable(GL_BLEND);
 }
-    
+
 void FGPanel::InitLists(void){
     xglNewList(FontList + 'A', GL_COMPILE);
     DrawTestLetter(0.391625, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'B', GL_COMPILE);
     DrawTestLetter(0.391625 + 1 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'C', GL_COMPILE);
     DrawTestLetter(0.391625 + 2 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'D', GL_COMPILE);
     DrawTestLetter(0.391625 + 3 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'E', GL_COMPILE);
     DrawTestLetter(0.391625 + 4 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'F', GL_COMPILE);
     DrawTestLetter(0.391625 + 5 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'G', GL_COMPILE);
     DrawTestLetter(0.391625 + 6 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'H', GL_COMPILE);
     DrawTestLetter(0.391625 + 7 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'I', GL_COMPILE);
     DrawTestLetter(0.391625 + 8 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'J', GL_COMPILE);
     DrawTestLetter(0.391625 + 9 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'K', GL_COMPILE);
     DrawTestLetter(0.391625 + 9.7 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'L', GL_COMPILE);
     DrawTestLetter(0.399625 + 10.6 * LETTER_OFFSET, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'M', GL_COMPILE);
     DrawTestLetter(0.80459375, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'N', GL_COMPILE);
     DrawTestLetter(0.83975, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'O', GL_COMPILE);
     DrawTestLetter(0.871, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'P', GL_COMPILE);
     DrawTestLetter(0.90715625, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + 'Q', GL_COMPILE);
     DrawTestLetter(0.9413125, 0.29296875);
     xglEndList();
-     
+    
     xglNewList(FontList + '1', GL_COMPILE);
     DrawTestLetter(0.390625, 0.35546875);
     xglEndList();
-     
+    
     xglNewList(FontList + '2', GL_COMPILE);
     DrawTestLetter(0.390625 + 1*LETTER_OFFSET, 0.3515625); 
     xglEndList();
-     
+    
     xglNewList(FontList + '3', GL_COMPILE);
     DrawTestLetter(0.390625 + 2*LETTER_OFFSET, 0.3515625); 
     xglEndList();
-     
+    
     xglNewList(FontList + '4', GL_COMPILE);
     DrawTestLetter(0.390625 + 3*LETTER_OFFSET, 0.3515625); 
     xglEndList();
-     
+    
     xglNewList(FontList + '5', GL_COMPILE);
     DrawTestLetter(0.390625 + 4*LETTER_OFFSET, 0.3515625); 
     xglEndList();
-     
+    
     xglNewList(FontList + '6', GL_COMPILE);
     DrawTestLetter(0.390625 + 5*LETTER_OFFSET, 0.3515625); 
     xglEndList();
-     
+    
     xglNewList(FontList + '7', GL_COMPILE);
     DrawTestLetter(0.390625 + 6*LETTER_OFFSET, 0.3515625); 
     xglEndList();
-     
+    
     xglNewList(FontList + '8', GL_COMPILE);
     DrawTestLetter(0.390625 + 7*LETTER_OFFSET, 0.3515625); 
     xglEndList();
-     
+    
     xglNewList(FontList + '9', GL_COMPILE);
     DrawTestLetter(0.390625 + 8*LETTER_OFFSET, 0.3515625); 
     xglEndList();
-     
+    
     xglNewList(FontList + '0', GL_COMPILE);
     DrawTestLetter(0.383625 + 9*LETTER_OFFSET, 0.3515625); 
     xglEndList();
-     
+    
     xglNewList(FontList + ' ', GL_COMPILE);
     xglTranslatef(8.0, 0.0, 0.0);
     xglEndList();
 }
-    
+
 void FGPanel::TexString(char *s, float XPos, float YPos, float size){
     xglMatrixMode(GL_MODELVIEW);
     xglLoadIdentity();
     xglTranslatef(XPos, YPos, 0.0);
     xglScalef(size, size, 1.0);
-     
+    
 #ifdef GL_VERSION_1_1
     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[1]);
 #elif GL_EXT_texture_object
@@ -1071,25 +1064,24 @@ void FGPanel::TexString(char *s, float XPos, float YPos, float size){
 #endif
     
     while((*s) != '\0'){
-	xglCallList(FontList + (*s));
-	s++;
+        xglCallList(FontList + (*s));
+        s++;
     }
     xglLoadIdentity();
 }
-     
+
 void FGTexInstrument::Init(void){
     CreatePointer();
 }
-     
+
 void FGTexInstrument::Render(void){
     xglEnable(GL_TEXTURE_2D);
     xglLoadIdentity();
     xglTranslatef(XPos, YPos, 0.0);
     xglRotatef(-tape[0], 0.0, 0.0, 1.0);
     fgEraseArea(vertices, 20, (GLfloat)(teXpos),                                               (GLfloat)(texYpos), (GLfloat)(XPos),                                            (GLfloat)(YPos), 0, 1);
-     
+    
     UpdatePointer();
-     
+    
     xglDisable(GL_TEXTURE_2D);
 }
-     
diff --git a/Simulator/Cockpit/panel.hxx b/Simulator/Cockpit/panel.hxx
index 05990e3bd..80c73e606 100644
--- a/Simulator/Cockpit/panel.hxx
+++ b/Simulator/Cockpit/panel.hxx
@@ -17,7 +17,7 @@
 //  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 //
 //  $Id$
- 
+
 #define LETTER_OFFSET 0.03515625 
 
 #ifndef _PANEL_HXX
@@ -43,190 +43,190 @@
 class FGInstrument;
 
 class FGPanel{
-
-private:
-int height, width;
-GLuint FontList;
-
-GLubyte *background;
-
-// FGInstrument **instr_list;
-FGInstrument *test_instr[7];
-
-void GetData(void);
-
-public:
-static FGPanel *OurPanel;
-
-	FGPanel(void);
-
-float   get_height(void){
-	return height;
-	}
-
-void    ReInit( int x, int y, int finx, int finy);
-void    Update(void);
-
-void    DrawLetter(void){
-        glBegin(GL_POLYGON);
-        glTexCoord2f(0.0, 0.0);
-        glVertex2f(0.0, 0.0);
-        glTexCoord2f(LETTER_OFFSET + 0.004, 0.0);
-        glVertex2f(7.0, 0.0);
-        glTexCoord2f(LETTER_OFFSET + 0.004, 0.0390625);
-        glVertex2f(7.0, 9.0);
-        glTexCoord2f(0.0, 0.0390625);
-        glVertex2f(0.0, 9.0);
-        glEnd();
+    
+    private:
+        int height, width;
+        GLuint FontList;
+        
+        GLubyte *background;
+        
+        // FGInstrument **instr_list;
+        FGInstrument *test_instr[7];
+        
+        void GetData(void);
+        
+    public:
+        static FGPanel *OurPanel;
+        
+        FGPanel(void);
+        
+        float   get_height(void){
+            return height;
         }
         
-void DrawTestLetter(float X, float Y);
-void InitLists(void);
-void TexString(char *s, float XPos, float YPos, float size);
-
+        void    ReInit( int x, int y, int finx, int finy);
+        void    Update(void);
+        
+        void    DrawLetter(void){
+            glBegin(GL_POLYGON);
+            glTexCoord2f(0.0, 0.0);
+            glVertex2f(0.0, 0.0);
+            glTexCoord2f(LETTER_OFFSET + 0.004, 0.0);
+            glVertex2f(7.0, 0.0);
+            glTexCoord2f(LETTER_OFFSET + 0.004, 0.0390625);
+            glVertex2f(7.0, 9.0);
+            glTexCoord2f(0.0, 0.0390625);
+            glVertex2f(0.0, 9.0);
+            glEnd();
+        }
+        
+        void DrawTestLetter(float X, float Y);
+        void InitLists(void);
+        void TexString(char *s, float XPos, float YPos, float size);
+        
 };
 
 class FGInstrument{
-friend class FGPanel;
-
-protected:
-float XPos, YPos;
-
-public:
-	FGInstrument(void){
-	}
-	
-	virtual ~FGInstrument(void){}
-	
-virtual void Init(void) = 0;
-virtual void Render(void) = 0;
+    friend class FGPanel;
+    
+    protected:
+        float XPos, YPos;
+        
+    public:
+        FGInstrument(void){
+        }
+        
+        virtual ~FGInstrument(void){}
+        
+        virtual void Init(void) = 0;
+        virtual void Render(void) = 0;
 };
 
 class FGHorizon : public FGInstrument {
-private:
-    float texXPos;
-    float texYPos;
-    float radius;
-    float bottom;   // tell the program the offset between midpoint and bottom 
-    float top;      // guess what ;-)
-    float vertices[180][2];
-    float normals[180][3];
-    float texCoord[180][2];
-    
-public:
-	FGHorizon(void){
-	XPos = 0.0; YPos = 0.0;
-	Init();
-	}
-
+    private:
+        float texXPos;
+        float texYPos;
+        float radius;
+        float bottom;   // tell the program the offset between midpoint and bottom 
+        float top;      // guess what ;-)
+        float vertices[180][2];
+        float normals[180][3];
+        float texCoord[180][2];
+        
+    public:
+        FGHorizon(void){
+            XPos = 0.0; YPos = 0.0;
+            Init();
+        }
+        
         FGHorizon(float inXPos, float inYPos){
-        XPos = inXPos; YPos = inYPos;
-        Init();
+            XPos = inXPos; YPos = inYPos;
+            Init();
         }
         
-virtual void Init(void);
-virtual void Render(void);
-
+        virtual void Init(void);
+        virtual void Render(void);
+        
 };
 
 class FGTurnCoordinator : public FGInstrument {
-private:
-    float PlaneTexXPos;
-    float PlaneTexYPos;
-    float alpha;
-    float PlaneAlpha;
-    float alphahist[2];
-    float rollhist[2];
-    float BallXPos;
-    float BallYPos;
-    float BallTexXPos;
-    float BallTexYPos;
-    float BallRadius;
-  GLfloat vertices[72];
-
-public:
-	FGTurnCoordinator(void){
-	XPos = 0.0; YPos = 0.0;
-	Init();
-	}
-
-	FGTurnCoordinator(float inXPos, float inYPos){
-	XPos = inXPos; YPos = inYPos;
-	Init();
-	}	
-
-virtual void Init (void);
-virtual void Render(void);
-
+    private:
+        float PlaneTexXPos;
+        float PlaneTexYPos;
+        float alpha;
+        float PlaneAlpha;
+        float alphahist[2];
+        float rollhist[2];
+        float BallXPos;
+        float BallYPos;
+        float BallTexXPos;
+        float BallTexYPos;
+        float BallRadius;
+        GLfloat vertices[72];
+        
+    public:
+        FGTurnCoordinator(void){
+            XPos = 0.0; YPos = 0.0;
+            Init();
+        }
+        
+        FGTurnCoordinator(float inXPos, float inYPos){
+            XPos = inXPos; YPos = inYPos;
+            Init();
+        }   
+        
+        virtual void Init (void);
+        virtual void Render(void);
+        
 };
 
 class FGRpmGauge : public FGInstrument {
-private:
-    GLuint list;
-    
-public:
-	FGRpmGauge(void){
-	XPos = 0.0; YPos = 0.0;
-	Init();
-	}
-
-	FGRpmGauge(float inXPos, float inYPos){
-	XPos = inXPos; YPos = inYPos;
-	Init();
-	}	
-
-virtual void Init(void);
-virtual void Render(void);
+    private:
+        GLuint list;
+        
+    public:
+        FGRpmGauge(void){
+            XPos = 0.0; YPos = 0.0;
+            Init();
+        }
+        
+        FGRpmGauge(float inXPos, float inYPos){
+            XPos = inXPos; YPos = inYPos;
+            Init();
+        }   
+        
+        virtual void Init(void);
+        virtual void Render(void);
 };
 
 // temporary class until I get the software-only routines for the 
 // instruments run
 
 class FGTexInstrument : public FGInstrument {
-
-private:
-    float radius;
-    float length;
-    float width;
-    float angle;
-    float tape[2];
-    float value1;
-    float value2;
-    float alpha1;
-    float alpha2;
-    float teXpos;
-    float texYpos;
-    int variable;
-    GLfloat vertices[20];
     
-public:
-	FGTexInstrument(void){
-	XPos = 0.0; YPos = 0.0;
-	Init();
-	}
-
-	FGTexInstrument(float inXPos, float inYPos, float inradius,                                     float inlength, float inwidth, float inangle,                                   float invalue1, float invalue2, float inalpha1,                                 float inalpha2, float intexXPos, float intexYPos,                               int invariable){
-
-	XPos = inXPos; YPos = inYPos;
-	radius = inradius; angle = inangle;
-	length = inlength; width = inwidth;
-	value1 = invalue1; value2 = invalue2;
-	alpha1 = inalpha1; alpha2 = inalpha2;
-	teXpos = intexXPos; texYpos = intexYPos;
-	variable = invariable; 
-	Init();
-	}
-
-   void CreatePointer(void);
-   void UpdatePointer(void);
-
-   void Init(void);
-   void Render(void);
+    private:
+        float radius;
+        float length;
+        float width;
+        float angle;
+        float tape[2];
+        float value1;
+        float value2;
+        float alpha1;
+        float alpha2;
+        float teXpos;
+        float texYpos;
+        int variable;
+        GLfloat vertices[20];
+        
+    public:
+        FGTexInstrument(void){
+            XPos = 0.0; YPos = 0.0;
+            Init();
+        }
+        
+        FGTexInstrument(float inXPos, float inYPos, float inradius,                                     float inlength, float inwidth, float inangle,                                   float invalue1, float invalue2, float inalpha1,                                 float inalpha2, float intexXPos, float intexYPos,                               int invariable){
+            
+            XPos = inXPos; YPos = inYPos;
+            radius = inradius; angle = inangle;
+            length = inlength; width = inwidth;
+            value1 = invalue1; value2 = invalue2;
+            alpha1 = inalpha1; alpha2 = inalpha2;
+            teXpos = intexXPos; texYpos = intexYPos;
+            variable = invariable; 
+            Init();
+        }
+        
+        void CreatePointer(void);
+        void UpdatePointer(void);
+        
+        void Init(void);
+        void Render(void);
 };
 
 typedef struct{
-float XPos;
-float YPos;
+    float XPos;
+    float YPos;
     float radius;
     float length;
     float width;
@@ -249,6 +249,3 @@ void DrawBeechcraftLogo(float XPos, float YPos, float Width, float Height);
 void PrintMatrix( void);
 
 #endif // _PANEL_HXX 
-
-
-
-- 
2.39.5