a) HUD - Here is the updated hud code with moving pointers, dials, turn/slip gauge, choice of circular ticks, two sizes for fonts, box for text labels etc. based partly on MIL-STD-1787b and our pilots requirements. Our pilots are not very enthusiastic about all symbols discussed in MIL-STD-1787b (I suppose it is very subjective) and so I did not have motivation to try all of them. Even now I plan to do simple symbols as seen on Russian aircraft since our Air Force pilots are familiar with them. That should be part of my next update. I have included a html document which is basically the old text file plus some snapshots with all possible hud symbols linked to corresponding xml templates. You have to just cut & paste the template, change names and positions to create additional symbols (if you have the real estate on the hud).

src/Cockpit/Makefile.am

@@ -3,7 +3,7 @@ noinst_LIBRARIES = libCockpit.a
 libCockpit_a_SOURCES = \
 	cockpit.cxx cockpit.hxx \
 	hud.cxx hud.hxx hud_opts.hxx \
-	hud_card.cxx hud_dnst.cxx hud_guag.cxx hud_inst.cxx \
+	hud_card.cxx hud_dnst.cxx hud_gaug.cxx hud_inst.cxx \
 	hud_labl.cxx hud_ladr.cxx \
 	hud_lat.cxx hud_lon.cxx \
 	hud_scal.cxx hud_tbi.cxx \

src/Cockpit/cockpit.cxx

@@ -64,13 +64,7 @@ static pCockpit ac_cockpit;
 
 float get_latitude( void )
 {
-    double lat;
+    return current_aircraft.fdm_state->get_Latitude() * SGD_RADIANS_TO_DEGREES;
-
-    lat = current_aircraft.fdm_state->get_Latitude() * SGD_RADIANS_TO_DEGREES;
-
-    float flat = lat;
-    return(flat);
-
 }
 
 float get_lat_min( void )
@@ -83,18 +77,14 @@ float get_lat_min( void )
     }
     d = (double) ( (int) a);
     float lat_min = (a - d) * 60.0;
-    return(lat_min );
+
+    return lat_min;
 }
 
 
 float get_longitude( void )
 {
-    double lon;
+    return current_aircraft.fdm_state->get_Longitude() * SGD_RADIANS_TO_DEGREES;
-
-    lon = current_aircraft.fdm_state->get_Longitude() * SGD_RADIANS_TO_DEGREES;
-
-    float flon = lon;
-    return(flon);
 }
 
 
@@ -106,6 +96,7 @@ get_formated_gmt_time( void )
     sprintf( buf, "%d/%d/%4d %d:%02d:%02d", 
          p->tm_mon+1, p->tm_mday, 1900 + p->tm_year,
          p->tm_hour, p->tm_min, p->tm_sec);
+
     return buf;
 }
 
@@ -119,37 +110,34 @@ float get_long_min( void )
     }
     d = (double) ( (int) a);
     float lon_min = (a - d) * 60.0; 
-    return(lon_min);
+
+    return lon_min;
 }
 
 float get_throttleval( void )
 {
-    float throttle = globals->get_controls()->get_throttle( 0 );
+    // Hack limiting to one engine
-    return (throttle);     // Hack limiting to one engine
+    return globals->get_controls()->get_throttle( 0 );
 }
 
 float get_aileronval( void )
 {
-    float aileronval = globals->get_controls()->get_aileron();
+    return globals->get_controls()->get_aileron();
-    return (aileronval);
 }
 
 float get_elevatorval( void )
 {
-    float elevator_val = (float)globals->get_controls()->get_elevator();
+    return globals->get_controls()->get_elevator();
-    return elevator_val;
 }
 
 float get_elev_trimval( void )
 {
-    float elevatorval = globals->get_controls()->get_elevator_trim();
+    return globals->get_controls()->get_elevator_trim();
-    return (elevatorval);
 }
 
 float get_rudderval( void )
 {
-    float rudderval = globals->get_controls()->get_rudder();
+    return globals->get_controls()->get_rudder();
-    return (rudderval);
 }
 
 float get_speed( void )
@@ -164,32 +152,27 @@ float get_speed( void )
 
 float get_mach(void)
 {
-	float mach=current_aircraft.fdm_state->get_Mach_number();
+    return current_aircraft.fdm_state->get_Mach_number();
-	return mach;
 }	
 
 float get_aoa( void )
 {
-    float aoa = current_aircraft.fdm_state->get_Alpha() * SGD_RADIANS_TO_DEGREES;
+    return current_aircraft.fdm_state->get_Alpha() * SGD_RADIANS_TO_DEGREES;
-    return( aoa );
 }
 
 float get_roll( void )
 {
-    float roll = current_aircraft.fdm_state->get_Phi();
+    return current_aircraft.fdm_state->get_Phi();
-    return( roll );
 }
 
 float get_pitch( void )
 {
-    float pitch = current_aircraft.fdm_state->get_Theta();
+    return current_aircraft.fdm_state->get_Theta();
-    return( pitch );
 }
 
 float get_heading( void )
 {
-    float heading = (current_aircraft.fdm_state->get_Psi() * SGD_RADIANS_TO_DEGREES);
+    return current_aircraft.fdm_state->get_Psi() * SGD_RADIANS_TO_DEGREES;
-    return( heading );
 }
 
 float get_altitude( void )
@@ -220,25 +203,23 @@ float get_agl( void )
         agl = (current_aircraft.fdm_state->get_Altitude() * SG_FEET_TO_METER
                - scenery.cur_elev);
     }
+
     return agl;
 }
 
 float get_sideslip( void )
 {
-    float sideslip = current_aircraft.fdm_state->get_Beta();
+    return current_aircraft.fdm_state->get_Beta();
-    return( sideslip );
 }
 
 float get_frame_rate( void )
 {
-    float frame_rate = general.get_frame_rate();
+    return general.get_frame_rate();
-    return (frame_rate); 
 }
 
 float get_fov( void )
 {
-    float fov = globals->get_current_view()->get_fov(); 
+    return globals->get_current_view()->get_fov(); 
-    return (fov);
 }
 
 float get_vfc_ratio( void )
@@ -270,7 +251,8 @@ float get_climb_rate( void )
     } else {
         climb_rate = current_aircraft.fdm_state->get_Climb_Rate() * SG_FEET_TO_METER * 60.0;
     }
-    return (climb_rate);
+
+    return climb_rate;
 }
 
 
@@ -292,230 +274,230 @@ float get_view_direction( void )
 // #ifdef FIGHTER_HUD
 float get_Vx   ( void )
 {
-    // CLO - 5 Jan 2000 - something needs to get addressed here
+    // Curt dont comment this and return zero. - Ranga
-    // float Vxx = current_aircraft.fdm_state->get_V_north_rel_ground();
+    // Please remove comments from get_V_..() function in flight.hxx
-    float Vxx = 0;
+    float Vxx = current_aircraft.fdm_state->get_V_north_rel_ground();
-    return (Vxx);
+    return Vxx;
 }
 
 float get_Vy   ( void )
 {
-    // CLO - 5 Jan 2000 - something needs to get addressed here
+    // Curt dont comment this and return zero. - Ranga
-    // float Vyy = current_aircraft.fdm_state->get_V_east_rel_ground();
+    // Please remove comments from get_V_..() function in flight.hxx
-    float Vyy = 0;
+    float Vyy = current_aircraft.fdm_state->get_V_east_rel_ground();
-    return (Vyy);
+    return Vyy;
 }
 
 float get_Vz   ( void )
 {
-    // CLO - 5 Jan 2000 - something needs to get addressed here
+    // Curt dont comment this and return zero. - Ranga
-    // float Vzz = current_aircraft.fdm_state->get_V_down_rel_ground();
+    // Please remove comments from get_V_..() function in flight.hxx
-    float Vzz = 0;
+    float Vzz = current_aircraft.fdm_state->get_V_down_rel_ground();
-    return (Vzz);
+    return Vzz;
 }
 
 float get_Ax   ( void )
 {
     float Ax = current_aircraft.fdm_state->get_V_dot_north();
-    return (Ax);
+    return Ax;
 }
 
 float get_Ay   ( void )
 {
     float Ay = current_aircraft.fdm_state->get_V_dot_east();
-    return (Ay);
+    return Ay;
 }
 
 float get_Az   ( void )
 {
     float Az = current_aircraft.fdm_state->get_V_dot_down();
-    return (Az);
+    return Az;
 }
 
 float get_anzg   ( void )
 {
     float anzg = current_aircraft.fdm_state->get_N_Z_cg();
-    return (anzg);
+    return anzg;
 }
 
 int get_iaux1 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux1();
+    return fdm->get_iaux(1);
 }
 
 int get_iaux2 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux2();
+    return fdm->get_iaux(2);
 }
 
 int get_iaux3 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux3();
+    return fdm->get_iaux(3);
 }
 
 int get_iaux4 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux4();
+    return fdm->get_iaux(4);
 }
 
 int get_iaux5 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux5();
+    return fdm->get_iaux(5);
 }
 
 int get_iaux6 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux6();
+    return fdm->get_iaux(6);
 }
 
 int get_iaux7 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux7();
+    return fdm->get_iaux(7);
 }
 
 int get_iaux8 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux8();
+    return fdm->get_iaux(8);
 }
 
 int get_iaux9 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux9();
+    return fdm->get_iaux(9);
 }
 
 int get_iaux10 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux10();
+    return fdm->get_iaux(10);
 }
 
 int get_iaux11 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_iaux11();
+    return fdm->get_iaux(11);
 }
 
 int get_iaux12 (void)
 {
      FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-     return fdm->get_iaux12();
+     return fdm->get_iaux(12);
 }
 
 float get_aux1 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux1();
+    return fdm->get_daux(1);
 }
 
 float get_aux2 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux2();
+    return fdm->get_daux(2);
 }
 
 float get_aux3 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux3();
+    return fdm->get_daux(3);
 }
 
 float get_aux4 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux4();
+    return fdm->get_daux(4);
 }
 
 float get_aux5 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux5();
+    return fdm->get_daux(5);
 }
 
 float get_aux6 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux6();
+    return fdm->get_daux(6);
 }
 
 float get_aux7 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux7();
+    return fdm->get_daux(7);
 }
 
 float get_aux8 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux8();
+    return fdm->get_daux(8);
 }
 
 float get_aux9 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux9();
+    return fdm->get_faux(1);
 }
 
 float get_aux10 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux10();
+    return fdm->get_faux(2);
 }
 
 float get_aux11 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux11();
+    return fdm->get_faux(3);
 }
 
 float get_aux12 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux12();
+    return fdm->get_faux(4);
 }
 
 float get_aux13 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux13();
+    return fdm->get_faux(5);
 }
 
 float get_aux14 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux14();
+    return fdm->get_faux(6);
 }
 
 float get_aux15 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux15();
+    return fdm->get_faux(7);
 }
 
 float get_aux16 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux16();
+    return fdm->get_faux(8);
 }
 
 float get_aux17 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux17();
+    return fdm->get_faux(9);
 }
 
 float get_aux18 (void)
 {
     FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
-    return fdm->get_aux18();
+    return fdm->get_faux(10);
 }
 // #endif
 // $$$ end - added, VS Renganathan 13 Oct 2K

src/Cockpit/hud.cxx

@@ -52,7 +52,6 @@
 #include <GUI/gui.h>
 #include <Main/globals.hxx>
 #include <Main/fg_props.hxx>
-#include <Main/viewmgr.hxx>
 #ifdef FG_NETWORK_OLK
 #include <NetworkOLK/network.h>
 #endif
@@ -144,6 +143,19 @@ static bool	glide;
 static float	glide_slope_val;
 static bool	worm_energy;
 static bool	waypoint;
+static string type_tick;//hud
+static string length_tick;//hud
+static bool label_box;//hud
+static int digits; //suma
+static float radius; //suma
+static int divisions; //suma
+static int zoom; //suma
+static int zenith; //suma
+static int nadir ; //suma
+static int hat; //suma
+static bool tsi; //suma
+static float rad; //suma
+
 
 static FLTFNPTR load_fn;    
 static fgLabelJust justification;
@@ -200,7 +212,8 @@ void drawOneLine( RECT &rect)
 //
    /* textString - Bitmap font string */
 
-void textString( int x, int y, char *msg, void *font ){
+void textString( int x, int y, char *msg, void *font,int digit) //suma
+{
 
     if(*msg)
     {
@@ -293,6 +306,10 @@ readLadder(const SGPropertyNode * node)
 				worm_energy		= node->getBoolValue("enable_energy_marker",false);
 				waypoint		= node->getBoolValue("enable_waypoint_marker",false);
 				working			= node->getBoolValue("working");
+				zenith			= node->getIntValue("zenith");  //suma
+				nadir			= node->getIntValue("nadir");  //suma
+				hat				= node->getIntValue("hat");
+
 
 				SG_LOG(SG_INPUT, SG_INFO, "Done reading instrument " << name);
 	
@@ -304,7 +321,7 @@ readLadder(const SGPropertyNode * node)
 										screen_hole, lbl_pos, frl_spot, target, vel_vector, 
 										drift, alpha, energy, climb_dive, 
 										glide, glide_slope_val, worm_energy, 
-										waypoint, working);
+										waypoint, working, zenith, nadir, hat);
 				
 				return p;
 		
@@ -342,13 +359,17 @@ readCard(const SGPropertyNode * node)
 				marker_off		= node->getFloatValue("marker_offset",0.0);
 				enable_pointer	= node->getBoolValue("enable_pointer",true);
 				type_pointer	= node->getStringValue("pointer_type");
+				type_tick		= node->getStringValue("tick_type");//hud Can be 'circle' or 'line'
+				length_tick		= node->getStringValue("tick_length");//hud For variable length
 				working			= node->getBoolValue("working");
-
+                radius			= node->getFloatValue("radius"); //suma
+				divisions		= node->getIntValue("divisions"); //suma
+				zoom			= node->getIntValue("zoom"); //suma
 
 				SG_LOG(SG_INPUT, SG_INFO, "Done reading instrument " << name);
 
 
-				if(type=="guage")
+				if(type=="gauge")
 					span_units = maxValue - minValue;
 
 				if(loadfn=="anzg")
@@ -412,7 +433,13 @@ readCard(const SGPropertyNode * node)
 														marker_off,
 														enable_pointer,
 														type_pointer,
-														working);
+														type_tick,//hud
+														length_tick,//hud
+														working,
+														radius, //suma
+														divisions, //suma
+														zoom  //suma
+														);
 					return p;
 }// end readCard
 
@@ -438,7 +465,9 @@ readLabel(const SGPropertyNode * node)
         blinking            = node->getIntValue("blinking");
         latitude			= node->getBoolValue("latitude",false);
         longitude			= node->getBoolValue("longitude",false);
+		label_box			= node->getBoolValue("label_box",false);//hud
         working             = node->getBoolValue("working");
+		digits				= node->getIntValue("digits"); //suma
 
 
         SG_LOG(SG_INPUT, SG_INFO, "Done reading instrument " << name);
@@ -480,26 +509,42 @@ readLabel(const SGPropertyNode * node)
             }
         }
 
-        if ( loadfn == "aux16" ) {
+		if ( loadfn== "aux1" ) {
-            load_fn = get_aux16;
+			 load_fn = get_aux1;
-        } else if ( loadfn == "aux17" ) {
+        } else if ( loadfn == "aux2" ) {
-            load_fn = get_aux17;
+            load_fn = get_aux2;
+        } else if ( loadfn == "aux3" ) {
+            load_fn = get_aux3;
+        } else if ( loadfn == "aux4" ) {
+            load_fn = get_aux4;
+        } else if ( loadfn == "aux5" ) {
+            load_fn = get_aux5;
+        } else if ( loadfn == "aux6" ) {
+            load_fn = get_aux6;
+        } else if ( loadfn == "aux7" ) {
+            load_fn = get_aux7;
+        } else if ( loadfn == "aux8" ) {
+            load_fn = get_aux8;
         } else if ( loadfn == "aux9" ) {
             load_fn = get_aux9;
+        } else if ( loadfn == "aux10" ) {
+            load_fn = get_aux10;
         } else if ( loadfn == "aux11" ) {
             load_fn = get_aux11;
         } else if ( loadfn == "aux12" ) {
             load_fn = get_aux12;
-        } else if ( loadfn == "aux10" ) {
-            load_fn = get_aux10;
         } else if ( loadfn == "aux13" ) {
             load_fn = get_aux13;
         } else if ( loadfn == "aux14" ) {
             load_fn = get_aux14;
         } else if ( loadfn == "aux15" ) {
             load_fn = get_aux15;
-        } else if ( loadfn == "aux8" ) {
+		} else if ( loadfn == "aux16" ) {
-            load_fn = get_aux8;
+            load_fn = get_aux16;
+        } else if ( loadfn == "aux17" ) {
+            load_fn = get_aux17;
+        } else if ( loadfn == "aux18" ) {
+            load_fn = get_aux18;
         } else if ( loadfn == "ax" ) {
             load_fn = get_Ax;
         } else if ( loadfn == "speed" ) {
@@ -524,8 +569,12 @@ readLabel(const SGPropertyNode * node)
             load_fn = get_aoa;
         } else if ( loadfn == "latitude" ) {
             load_fn  = get_latitude;
+		} else if ( loadfn == "anzg" ) {
+			load_fn = get_anzg;
         } else if ( loadfn == "longitude" ) {
             load_fn   = get_longitude;
+        } else if (loadfn=="throttleval") {
+			load_fn = get_throttleval;
 		}
 
         p = (instr_item *) new instr_label ( x,
@@ -543,7 +592,9 @@ readLabel(const SGPropertyNode * node)
                                              blinking,
                                              latitude,
                                              longitude,
-                                             working);
+											 label_box, //hud
+                                             working,
+											 digits); //suma
 
         return p;
 } // end readLabel
@@ -563,6 +614,8 @@ readTBI(const SGPropertyNode * node)
         maxSlipAngle   = node->getFloatValue("maxSlipAngle");
         gap_width      = node->getIntValue("gap_width");
         working        = node->getBoolValue("working");
+		tsi			   = node->getBoolValue("tsi"); //suma
+		rad			   = node->getFloatValue("rad"); //suma
 
         SG_LOG(SG_INPUT, SG_INFO, "Done reading instrument " << name);
 
@@ -576,7 +629,9 @@ readTBI(const SGPropertyNode * node)
                                                 maxBankAngle, 
                                                 maxSlipAngle,
                                                 gap_width,
-                                                working);
+                                                working,
+												tsi, //suma
+												rad); //suma
 
         return p;
 } //end readTBI
@@ -1033,7 +1088,6 @@ void fgUpdateHUD( GLfloat x_start, GLfloat y_start,
 //	  glEnable(GL_BLEND);
 	  glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 	  glHint(GL_LINE_SMOOTH_HINT,GL_DONT_CARE);
-//	  glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);
 	  glLineWidth(1.5);
   } else {
 	  glLineWidth(1.0);
@@ -1104,7 +1158,7 @@ void fgUpdateHUD( GLfloat x_start, GLfloat y_start,
   }
 
   char *gmt_str = get_formated_gmt_time();
-  HUD_TextList.add( fgText(40, 10, gmt_str) );
+  HUD_TextList.add( fgText(40, 10, gmt_str, 0) );
 
 #ifdef FG_NETWORK_OLK
   if ( net_hud_display ) {

src/Cockpit/hud.hxx

@@ -48,6 +48,7 @@
 
 #include <vector>       // STL vector
 #include <deque>        // STL double ended queue
+#include STL_FSTREAM
 
 #include <simgear/constants.h>
 
@@ -56,6 +57,8 @@
 #include <FDM/flight.hxx>
 #include <Controls/controls.hxx>
 #include <GUI/gui.h>
+#include <Main/globals.hxx>
+#include <Main/viewmgr.hxx>
 
 #include "hud_opts.hxx"
 
@@ -218,6 +221,7 @@ extern float get_aux3(void);
 extern float get_aux4(void);
 extern float get_aux5 (void);
 extern float get_aux6 (void);
+extern float get_aux7 (void);
 extern float get_aux8(void);
 extern float get_aux9(void);
 extern float get_aux10(void);
@@ -240,7 +244,7 @@ enum  hudinstype{ HUDno_instr,
               HUDladder,
               HUDcirc_ladder,
               HUDhorizon,
-              HUDguage,
+              HUDgauge,
               HUDdual_inst,
               HUDmoving_scale,
               HUDtbi
@@ -286,14 +290,18 @@ private:
     float x, y;
     char msg[64];
 public:
-    fgText( float x = 0, float y = 0, char *c = NULL )
+    int digit; //suma
-        : x(x), y(y) {strncpy(msg,c,64-1);}
+    fgText(float x = 0, float y = 0, char *c = NULL,int digits=0): x(x), y(y) //suma
+    { 
+        strcpy(msg,c);
+        digit=digits; //suma
+    }
 		   
     fgText( const fgText & image )
-        : x(image.x), y(image.y) {strcpy(msg,image.msg);}
+        : x(image.x), y(image.y),digit(image.digit) {strcpy(msg,image.msg);} //suma
 
     fgText& operator = ( const fgText & image ) {
-        strcpy(msg,image.msg); x = image.x; y = image.y;
+        strcpy(msg,image.msg); x = image.x; y = image.y;digit=image.digit; //suma
         return *this;   
     }
 
@@ -321,11 +329,56 @@ public:
         return 0 ;
     }
    
-    void Draw(fntRenderer *fnt)
+    // this code is changed to display Numbers with big/small digits
+    // according to MIL Standards for example Altitude above 10000 ft
+    // is shown as 10ooo.  begin suma
+
+    void Draw(fntRenderer *fnt,int digits) {
+        if(digits==1) {
+            int c=0,i=0;
+            char *t=msg;
+            int p=4;
+
+            if(t[0]=='-') //if negative value then increase the c and p values for '-' sign.
             {
+                c++;
+                p++;
+            }
+            char *tmp=msg;
+            while(tmp[i]!='\0') {
+                if((tmp[i]>='0') && (tmp[i]<='9'))  
+                    c++;
+                i++;
+            }
+            if(c>p) {
+                fnt->setPointSize(8);
+                int p1=c-3;
+                char *tmp1=msg+p1;
+                int p2=p1*8;
+ 			  
+                fnt->start2f(x+p2,y);
+                fnt->puts(tmp1);
+
+                fnt->setPointSize(12);
+                char tmp2[p1+1];
+                strncpy(tmp2,msg,p1);
+                tmp2[p1]='\0';
+			 
+                fnt->start2f(x,y);
+                fnt->puts(tmp2);
+            } else {
+                fnt->setPointSize(12);					
+                fnt->start2f( x, y );
+                fnt->puts(tmp);
+            }
+        } else {
+            //if digits not equal to 1
+            fnt->setPointSize(8);         
             fnt->start2f( x, y );
             fnt->puts( msg ) ;
         }
+    }
+    //end suma
 
     void Draw()
     {
@@ -389,7 +442,7 @@ public:
 
         Font->begin();
         for( ; curString != lastString; curString++ ) {
-            curString->Draw(Font);
+            curString->Draw(Font,curString->digit); //suma
         }
         Font->end();
 
@@ -437,6 +490,7 @@ class instr_item {  // An Abstract Base Class (ABC)
     bool               broken;
     UINT               scr_span;      // Working values for draw;
     POINT              mid_span;      //
+    int		       digits;        //suma
   
   public:
     instr_item( int            x,
@@ -446,7 +500,9 @@ class instr_item {  // An Abstract Base Class (ABC)
                 FLTFNPTR       data_source,
                 float          data_scaling,
                 UINT           options,
-                bool           working  = true);
+                bool           working  = true,
+                int	       digit = 0); //suma
+
 
     instr_item( const instr_item & image );
 
@@ -463,6 +519,7 @@ class instr_item {  // An Abstract Base Class (ABC)
     UINT    get_span        ( void ) { return scr_span;  }
     POINT   get_centroid    ( void ) { return mid_span;  }
     UINT    get_options     ( void ) { return opts;      }
+    int     get_digits	    ( void ) { return digits;	 } //suma
 
     UINT    huds_vert     (UINT options) { return( options  & HUDS_VERT ); }
     UINT    huds_left     (UINT options) { return( options  & HUDS_LEFT ); }
@@ -490,9 +547,9 @@ class instr_item {  // An Abstract Base Class (ABC)
     {
         HUD_StippleLineList.add(fgLineSeg2D(x1,y1,x2,y2));
     }
-    void TextString( char *msg, float x, float y )
+    void TextString( char *msg, float x, float y,int digit ) //suma
     {
-        HUD_TextList.add(fgText(x, y, msg));        
+        HUD_TextList.add(fgText(x, y, msg,digit)); //suma  
     }
     int getStringWidth ( char *str )
     {
@@ -505,6 +562,18 @@ class instr_item {  // An Abstract Base Class (ABC)
         return 0 ;
     }
 
+    //code to draw ticks as small circles
+    void drawOneCircle(float x1, float y1, float r)
+    {
+        glBegin(GL_LINE_LOOP);  // Use polygon to approximate a circle 
+        for(int count=0; count<25; count++) {             
+            float cosine = r * cos(count * 2 * M_PI/10.0); 
+            float sine =   r * sin(count * 2 * M_PI/10.0); 
+            glVertex2f(cosine+x1, sine+y1);
+        }     
+        glEnd(); 
+    }
+    
 };
 
 typedef instr_item *HIptr;
@@ -532,6 +601,7 @@ class instr_label : public instr_item {
     char format_buffer[80];
     bool		lat;
     bool		lon;
+    bool		lbox;
 
   public:
     instr_label( int          x,
@@ -549,7 +619,9 @@ class instr_label : public instr_item {
                  int          blinking,
                  bool		  latitude,
                  bool		  longitude,
-                 bool         working);
+                 bool		  label_box,
+                 bool         working,
+                 int          digit ); //suma);
 
     ~instr_label();
 
@@ -585,7 +657,8 @@ class lat_label : public instr_item {
                fgLabelJust  justification,
                int          font_size,
                int          blinking,
-                 bool         working);
+               bool         working,
+               int	    digits =0 );//suma
 
     ~lat_label();
 
@@ -620,7 +693,9 @@ class lon_label : public instr_item {
                fgLabelJust  justification,
                int          font_size,
                int          blinking,
-                 bool         working);
+               bool         working,
+               int	    digit=0); //suma
+
 
     ~lon_label();
 
@@ -700,6 +775,15 @@ class hud_card : public instr_scale {
     float marker_offset;
     bool  pointer;
     string  pointer_type;
+    string  tick_type;
+    string  tick_length;
+    float   radius; //suma
+    float   maxValue; //suma
+    float   minValue; //suma
+    int		divisions; //suma
+    int     zoom; //suma
+    UINT	Maj_div; //suma
+    UINT	Min_div; //suma
 	
     
   public:
@@ -729,20 +813,29 @@ class hud_card : public instr_scale {
 	      float    marker_offset,
 	      bool     pointer,
 	      string   pointer_type,
-              bool     working);
+              string  tick_type,
+              string  tick_length,
+              bool     working,
+              float    radius, //suma
+              int      divisions, //suma
+              int	   zoom); //suma
+
 
     ~hud_card();
     hud_card( const hud_card & image);
     hud_card & operator = (const hud_card & rhs );
 //    virtual void display_enable( bool setting );
     virtual void draw( void );       // Required method in base class
+    void circles(float,float,float); // suma
+    void fixed(float,float,float,float,float,float); //suma
+    void zoomed_scale(int,int); //suma
 };
 
 typedef hud_card * pCardScale;
 
-class guage_instr : public instr_scale {
+class gauge_instr : public instr_scale {
   public:
-    guage_instr( int       x,
+    gauge_instr( int       x,
                  int       y,
                  UINT      width,
                  UINT      height,
@@ -757,13 +850,13 @@ class guage_instr : public instr_scale {
                  UINT      modulus,
                  bool      working);
 
-    ~guage_instr();
+    ~gauge_instr();
-    guage_instr( const guage_instr & image);
+    gauge_instr( const gauge_instr & image);
-    guage_instr & operator = (const guage_instr & rhs );
+    gauge_instr & operator = (const gauge_instr & rhs );
     virtual void draw( void );       // Required method in base class
 };
 
-typedef guage_instr * pGuageInst;
+typedef gauge_instr * pGaugeInst;
 //
 // dual_instr_item         This class was created to form the base class
 //                         for both panel and HUD Turn Bank Indicators.
@@ -791,11 +884,14 @@ class dual_instr_item : public instr_item {
     virtual void draw ( void ) { }
 };
 
-class fgTBI_instr : public dual_instr_item {
+class fgTBI_instr : public dual_instr_item 
+{
   private:
     UINT BankLimit;
     UINT SlewLimit;
     UINT scr_hole;
+    bool tsi;  //suma
+    float rad; //suma
 
   public:
     fgTBI_instr( int       x,
@@ -807,7 +903,9 @@ class fgTBI_instr : public dual_instr_item {
                  float    maxBankAngle,
                  float    maxSlipAngle,
                  UINT      gap_width,
-                 bool      working);
+                 bool      working,
+                 bool	   tsi, //suma
+                 float     rad); //suma
 
     fgTBI_instr( const fgTBI_instr & image);
     fgTBI_instr & operator = (const fgTBI_instr & rhs );
@@ -844,6 +942,10 @@ class HudLadder : public dual_instr_item {
     float	glide_slope;
     bool	energy_worm;
     bool	waypoint_marker;
+    int     zenith; //suma
+    int     nadir; //suma
+    int		hat; //suma
+    
 
     fgTextList         TextList;
     fgLineList         LineList;
@@ -874,13 +976,19 @@ class HudLadder : public dual_instr_item {
 	       float	 glide_slope,
 	       bool	 energy_worm,
 	       bool	 waypoint_marker,
-               bool      working);
+               bool  working,
+               int   zenith, //suma
+               int   nadir, //suma
+               int   hat); //suma
+
 
     ~HudLadder();
 
     HudLadder( const HudLadder & image );
     HudLadder & operator = ( const HudLadder & rhs );
     virtual void draw( void );
+    void drawZenith(float,float,float); //suma
+    void drawNadir(float, float, float); //suma
 
     void Text( float x, float y, char *s)
     {
@@ -915,7 +1023,7 @@ extern void drawOneLine ( RECT &rect);
 extern void textString  ( int x,
                           int y,
                           char *msg,
-                          void *font = GLUT_BITMAP_8_BY_13);
+                          void *font = GLUT_BITMAP_9_BY_15,int digit=0); //suma
 extern void strokeString( int x,
                           int y,
                           char *msg,

src/Cockpit/hud_gaug.cxx

@@ -0,0 +1,380 @@
+
+#include "hud.hxx"
+
+
+#ifdef USE_HUD_TextList
+#define textString( x , y, text, font,digit )  TextString( text, x , y,digit )  //suma
+#else
+#define textString( x , y, text, font,digit )  puDrawString ( guiFnt, text, x, y ); //suma
+#endif
+
+//============== Top of gauge_instr class member definitions ==============
+
+gauge_instr ::
+gauge_instr( int          x,
+	     int          y,
+	     UINT         width,
+	     UINT         height,
+	     FLTFNPTR     load_fn,
+	     UINT         options,
+	     float       disp_scale,
+	     float       maxValue,
+	     float       minValue,
+	     UINT         major_divs,
+	     UINT         minor_divs,
+	     int          dp_showing,
+	     UINT         modulus,
+	     bool         working) :
+    instr_scale( x, y, width, height,
+		 load_fn, options,
+		 (maxValue - minValue), // Always shows span?
+		 maxValue, minValue,
+		 disp_scale,
+		 major_divs, minor_divs,
+		 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;
+}
+
+gauge_instr ::
+~gauge_instr()
+{
+}
+
+gauge_instr ::
+gauge_instr( const gauge_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;
+}
+
+gauge_instr & gauge_instr ::
+operator = (const gauge_instr & rhs )
+{
+    if( !(this == &rhs)) {
+	instr_scale::operator = (rhs);
+    }
+    return *this;
+}
+
+// As implemented, draw only correctly draws a horizontal or vertical
+// scale. It should contain a variation that permits clock type displays.
+// Now is supports "tickless" displays such as control surface indicators.
+// This routine should be worked over before using. Current value would be
+// fetched and not used if not commented out. Clearly that is intollerable.
+
+void gauge_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 = 0;
+    float vmin       = min_val();
+    float vmax       = max_val();
+    POINT mid_scr    = get_centroid();
+    float cur_value  = get_value();
+    RECT  scrn_rect  = get_location();
+    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( huds_vert(options) ) { // Vertical scale
+	drawOneLine( scrn_rect.left,     // Bottom tick bar
+		     scrn_rect.top,
+		     width,
+		     scrn_rect.top);
+
+	drawOneLine( scrn_rect.left,    // Top tick bar
+		     height,
+		     width,
+		     height );
+
+	marker_xs = scrn_rect.left;
+	marker_xe = width;
+
+	if( huds_left(options) ) {     // Read left, so line down right side
+	    drawOneLine( width,
+			 scrn_rect.top,
+			 width,
+			 height);
+	  
+	    marker_xs  = marker_xe - scrn_rect.right / 3;   // Adjust tick xs
+	}
+	
+	if( huds_right(options) ) {     // Read  right, so down left sides
+	    drawOneLine( scrn_rect.left,
+			 scrn_rect.top,
+			 scrn_rect.left,
+			 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( huds_both(options) ) {
+	    marker_ye = marker_xs;
+	    marker_xs = marker_xe;
+	    marker_xe = marker_ye;
+	}
+
+	// Work through from bottom to top of scale. Calculating where to put
+	// minor and major ticks.
+
+	if( !huds_noticks(options)) {    // If not no ticks...:)
+	    // Calculate x marker offsets
+	    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 + 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%(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,
+					 width, marker_ys );
+			}
+			else {
+			    if( huds_left(options) ) {
+				drawOneLine( marker_xs + 3, marker_ys, marker_xe, marker_ys );
+			    }
+			    else {
+				drawOneLine( marker_xs, marker_ys, marker_xe - 3, marker_ys );
+			    }
+			}
+		    }
+		}
+
+		// Now we work on the major divisions. Since these are also labeled
+		// and no labels are drawn otherwise, we label inside this if
+		// statement.
+
+		if( div_max()) {                  // Major tick mark
+		    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,
+					 width, marker_ys );
+			}
+			else {
+			    drawOneLine( marker_xs, marker_ys, marker_xe, marker_ys );
+			}
+
+			if( !huds_notext(options) ) {
+			    disp_val = i;
+			    sprintf( TextScale, "%d",
+				     FloatToInt(disp_val * data_scaling()/*+.5*/ ));
+
+			    lenstr = getStringWidth( TextScale );
+						
+			    if( huds_left(options) && huds_right(options) ) {
+				text_x = mid_scr.x -  lenstr/2 ;
+			    }
+			    else {
+				if( huds_left(options) )              {
+				    text_x = marker_xs - lenstr;
+				}
+				else {
+				    text_x = marker_xe - lenstr;
+				}
+			    }
+			    // Now we know where to put the text.
+			    text_y = marker_ys;
+			    textString( text_x, text_y, TextScale, GLUT_BITMAP_8_BY_13,0 ); //suma
+			}
+		    }
+		}  //
+	    }  //
+	}  //
+	// Now that the scale is drawn, we draw in the pointer(s). Since labels
+	// 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 + FloatToInt((cur_value - vmin) * factor() /*+.5f*/);
+	//    text_x = marker_xs - scrn_rect.left;
+
+	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( 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,
+		     height);
+
+	drawOneLine( width,    // right tick bar
+		     scrn_rect.top,
+		     width,
+		     height );
+
+	marker_ys = scrn_rect.top;                       // Starting point for
+	marker_ye = height;                              // tick y location calcs
+	marker_xs = scrn_rect.left + FloatToInt((cur_value - vmin) * factor() /*+ .5f*/);
+
+	if( huds_top(options) ) {
+	    drawOneLine( scrn_rect.left,
+			 scrn_rect.top,
+			 width,
+			 scrn_rect.top);                    // Bottom box line
+	  
+	    marker_ye  = scrn_rect.top + scrn_rect.bottom / 2;   // Tick point adjust
+	    // Bottom arrow
+	    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();
+	}
+
+	
+	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()) {
+		    condition = false;
+		}
+	    }
+	    if( condition )        {
+		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()) ) {			
+			// draw in ticks only if they aren't too close to the edge.
+			if((( marker_xs + 5) > scrn_rect.left ) ||
+			   (( marker_xs - 5 )< (width))){
+
+			    if( huds_both(options) ) {
+				drawOneLine( marker_xs, scrn_rect.top,
+					     marker_xs, marker_ys - 4);
+				drawOneLine( marker_xs, marker_ye + 4,
+					     marker_xs, height);
+			    }
+			    else {
+				if( huds_top(options) ) {
+				    drawOneLine( marker_xs, marker_ys,
+						 marker_xs, marker_ye - 4);
+				}
+				else {
+				    drawOneLine( marker_xs, marker_ys + 4,
+						 marker_xs, marker_ye);
+				}
+			    }
+			}
+		    }
+		}
+		if( div_max()) {
+		    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",
+				 FloatToInt(disp_val  * data_scaling()/* +.5*/ ));
+			lenstr = getStringWidth( TextScale);
+						
+			// Draw major ticks and text only if far enough from the edge.
+			if(( (marker_xs - 10)> scrn_rect.left ) &&
+			   ( (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, height);
+
+				if( !huds_notext(options) ) {
+				    textString ( marker_xs - lenstr, marker_ys + 4,
+						 TextScale,  GLUT_BITMAP_8_BY_13 ,0); //suma
+				}
+			    }
+			    else {
+				drawOneLine( marker_xs, marker_ys,
+					     marker_xs, marker_ye );
+				
+				if( !huds_notext(options) ) {
+				    if( huds_top(options) )              {
+					textString ( marker_xs - lenstr,
+						     height - 10,
+						     TextScale, GLUT_BITMAP_8_BY_13,0 ); //suma
+				    }
+				    else  {
+					textString( marker_xs - lenstr, scrn_rect.top,
+						    TextScale, GLUT_BITMAP_8_BY_13,0 );  //suma
+				    }            
+				}
+			    }
+			}
+		    }
+		}
+	    }
+	}
+    }
+}
+
+

src/Cockpit/hud_inst.cxx

@@ -4,7 +4,8 @@
 
 UINT instr_item :: instances = 0;  // Initial value of zero
 int  instr_item :: brightness = BRT_MEDIUM;
-glRGBTRIPLE instr_item :: color = {0.1, 0.7, 0.0};
+//glRGBTRIPLE instr_item :: color = {0.1, 0.7, 0.0};
+glRGBTRIPLE instr_item :: color = {0.0, 1.0, 0.0};
 
 // constructor    ( No default provided )
 instr_item  ::
@@ -15,13 +16,15 @@ instr_item  ::
                FLTFNPTR         data_source,
                float           data_scaling,
                UINT             options,
-               bool             working) :
+               bool             working,
+			   int				digit) : //suma
                       handle         ( ++instances  ),
                       load_value_fn  ( data_source  ),
                       disp_factor    ( data_scaling ),
                       opts           ( options      ),
                       is_enabled     ( working      ),
-                      broken         ( FALSE        )
+                      broken         ( FALSE        ),
+                      digits		 ( digit		) //suma
 {
   scrn_pos.left   = x;
   scrn_pos.top    = y;

src/Cockpit/hud_labl.cxx

@@ -3,9 +3,9 @@
 
 
 #ifdef USE_HUD_TextList
-#define textString( x , y, text, font )  TextString( text, x , y )
+#define textString( x , y, text, font,digit )  TextString( text, x , y,digit ) //suma
 #else
-#define textString( x , y, text, font )  puDrawString ( guiFnt, text, x, y );
+#define textString( x , y, text, font,digit )  puDrawString ( guiFnt, text, x, y ); //suma
 #endif
 
 //======================= Top of instr_label class =========================
@@ -25,9 +25,11 @@ instr_label ::
                       int           blinking,
 				      bool			latitude,
 				      bool			longitude,
-                      bool          working):
+					  bool			label_box,//hud
+                      bool          working,
+					  int			digit):  //suma
                            instr_item( x, y, width, height,
-                                       data_source,scale_data,options, working ),
+                                       data_source,scale_data,options, working, digit), //suma
                            pformat  ( label_format      ),
                            pre_str  ( pre_label_string  ),
                            post_str ( post_label_string ),
@@ -35,7 +37,8 @@ instr_label ::
                            fontSize ( font_size         ),
                            blink    ( blinking          ),
 						   lat		( latitude			),
-						   lon		( longitude			)
+						   lon		( longitude			),
+						   lbox		( label_box			) //hud
 
 {
   if( pre_str != NULL) {
@@ -70,7 +73,8 @@ instr_label :: instr_label( const instr_label & image) :
                               post_str ( image.post_str ),
                               blink    ( image.blink    ),
 							  lat	   ( image.lat		),
-							  lon	   ( image.lon		)	
+							  lon	   ( image.lon		),	
+							  lbox	   (image.lbox		) //hud
 
 {
   if( pre_str != NULL) {
@@ -101,6 +105,7 @@ instr_label & instr_label ::operator = (const instr_label & rhs )
     post_str   = rhs.post_str;
     lat		   = rhs.lat;
     lon		   = rhs.lon;
+	lbox	   = rhs.lbox; //hud
 
 
     strcpy(format_buffer,rhs.format_buffer);	
@@ -128,10 +133,38 @@ draw( void )       // Required method in base class
 	if(lon)    
 		sprintf( label_buffer, format_buffer, coord_format_lon(get_value()) );
 	else
-		sprintf( label_buffer, format_buffer, get_value() );
+	{	
+		if(lbox)//hud
+			{// Box for label
+				float x = scrn_rect.left;
+				float y = scrn_rect.top;
+				float w = scrn_rect.right;
+		        float h = HUD_TextSize;
+
+				glPushMatrix();
+				glLoadIdentity();
+				glBegin(GL_LINES);
+					glVertex2f( x - 2.0,  y - 2.0);
+					glVertex2f( x + w + 2.0, y - 2.0);
+					glVertex2f( x + w + 2.0, y + h + 2.0);
+					glVertex2f( x - 2.0,  y + h + 2.0);
+				glEnd();
+		        glEnable(GL_LINE_STIPPLE);
+				glLineStipple( 1, 0xAAAA );
+				glBegin(GL_LINES);
+					glVertex2f( x + w + 2.0, y - 2.0);
+					glVertex2f( x + w + 2.0, y + h + 2.0);
+					glVertex2f( x - 2.0,  y + h + 2.0);
+					glVertex2f( x - 2.0,  y - 2.0);
+				glEnd();
+		        glDisable(GL_LINE_STIPPLE);
+				glPopMatrix();
+			}//hud
+		sprintf( label_buffer, format_buffer, get_value()*data_scaling() );
+	}
   }
   else {
-    sprintf( label_buffer, format_buffer );
+//    sprintf( label_buffer, format_buffer );
   }
   
   lenstr = getStringWidth( label_buffer );
@@ -143,7 +176,7 @@ draw( void )       // Required method in base class
   fgPrintf( SG_COCKPIT, SG_DEBUG, label_buffer );
   fgPrintf( SG_COCKPIT, SG_DEBUG, "\n" );
 #endif
-//  lenstr = strlen( label_buffer );
+  lenstr = strlen( label_buffer );
 
   if( justify == RIGHT_JUST ) {
 	  posincr = scrn_rect.right - lenstr;
@@ -156,12 +189,12 @@ draw( void )       // Required method in base class
   
   if( fontSize == SMALL ) {
     textString( scrn_rect.left + posincr, scrn_rect.top,
-                label_buffer, GLUT_BITMAP_8_BY_13);
+                label_buffer, GLUT_BITMAP_8_BY_13 ,get_digits()); //suma
     }
   else  {
     if( fontSize == LARGE ) {
       textString( scrn_rect.left + posincr, scrn_rect.top,
-                  label_buffer, GLUT_BITMAP_9_BY_15);
+                  label_buffer, GLUT_BITMAP_9_BY_15 ,get_digits()); //suma
       }
     }
 }

src/Cockpit/hud_ladr.cxx

@@ -29,7 +29,11 @@ HudLadder ::   HudLadder(  string name,
 			   float     glide_slope_val,
 			   bool      worm_energy,
 			   bool      waypoint,
-			   bool      working) :
+			   bool      working,
+   			   int		 zenithsymbol, //suma
+			   int       nadirsymbol, //suma
+			   int		 hat_marker): //suma
+
     dual_instr_item( x, y, width, height,
 		     ptch_source,
 		     roll_source,
@@ -58,7 +62,13 @@ HudLadder ::   HudLadder(  string name,
 
 
 {
-    if( !width_units ) {
+		
+    zenith= zenithsymbol; //suma
+	nadir=nadirsymbol; //suma
+	hat= hat_marker; //suma
+ 
+	if( !width_units ) 
+	{
 	   width_units = 45;
     }
 }
@@ -152,11 +162,11 @@ void HudLadder :: draw( void )
     pla = get_throttleval();
 
     int lgear,wown,wowm,ilcanclaw,ihook;
-    ilcanclaw = get_iaux1();
+    ilcanclaw = get_iaux2();
-    lgear = get_iaux2();
+    lgear = get_iaux3();
-    wown = get_iaux3();
+    wown = get_iaux4();
-    wowm = get_iaux4();
+    wowm = get_iaux5();
-    ihook = get_iaux5();
+    ihook = get_iaux6();
     
     float pitch_value = current_ch1() * SGD_RADIANS_TO_DEGREES;
 	
@@ -166,7 +176,8 @@ void HudLadder :: draw( void )
 	clip_plane = true;
     }
     else
-	if(hudladder_type=="Pitch Ladder") {
+	// hudladder_type=="Pitch Ladder" 
+	{
 	    pitch_ladder = true;
 	    climb_dive_ladder = false;
 	    clip_plane = false;
@@ -239,11 +250,13 @@ void HudLadder :: draw( void )
 	    actslope = atan(up_vel/ground_vel)*SGD_RADIANS_TO_DEGREES;
 	}
 
-	xvvr = (((atan2(Vyy,Vxx)*SGD_RADIANS_TO_DEGREES)-psi)*(640.0/45.0));
+	xvvr = (((atan2(Vyy,Vxx)*SGD_RADIANS_TO_DEGREES)-psi)*
+		(factor/globals->get_current_view()->get_win_ratio()));
 	drift = ((atan2(Vyy,Vxx)*SGD_RADIANS_TO_DEGREES)-psi);
 	yvvr = ((actslope - pitch_value)*factor);
 	vel_y = ((actslope -pitch_value) * cos(roll_value) + drift*sin(roll_value))*factor;
-	vel_x = (-(actslope -pitch_value)*sin(roll_value) + drift*cos(roll_value))*(640/45.0);
+	vel_x = (-(actslope -pitch_value)*sin(roll_value) + drift*cos(roll_value))*
+		(factor/globals->get_current_view()->get_win_ratio());
 	//  printf("%f %f %f %f\n",vel_x,vel_y,drift,psi);
 	//****************************************************************    
 	// OBJECT MOVING RETICLE
@@ -446,7 +459,8 @@ void HudLadder :: draw( void )
 
     //****************************************************************    
 
-    if(climb_dive_ladder) {// CONFORMAL_HUD
+    if(climb_dive_ladder)
+	{                     // CONFORMAL_HUD
 
 	vmin              = pitch_value - (float)width_units;
 	vmax              = pitch_value + (float)width_units; 
@@ -455,7 +469,8 @@ void HudLadder :: draw( void )
 
     }
     else 
-	if (pitch_ladder) {//Default Hud
+	// pitch_ladder - Default Hud
+	{
 
 	    vmin              = pitch_value - (float)width_units * 0.5f;
 	    vmax              = pitch_value + (float)width_units * 0.5f;
@@ -465,8 +480,8 @@ void HudLadder :: draw( void )
     glRotatef(roll_value * SGD_RADIANS_TO_DEGREES, 0.0, 0.0, 1.0);
     // FRL marker not rotated - this line shifted below
 
-    if( div_units ) {
+    if( div_units ) 
-  
+	{
         char     TextLadder[8] ;
         float    label_length ;
         float    label_height ;
@@ -478,12 +493,10 @@ void HudLadder :: draw( void )
     	float    zero_offset = 0.0;
 		
 	if ( climb_dive_ladder ) {
-	    zero_offset = 50.0f ;
+	    zero_offset = 50.0f ; // horizon line is wider by this much (hard coded ??)
 	} else {
-	    if ( pitch_ladder ) {
 		zero_offset = 10.0f ;
     }
-        }
 		
 	fntFont *font      = HUDtext->getFont();
 	float    pointsize = HUDtext->getPointSize();
@@ -499,10 +512,12 @@ void HudLadder :: draw( void )
 
         if( !scr_hole ) {
 	    x_end =  half_span;
-            for( ; i<last ; i++ ) {
+            for( ; i<last ; i++ ) 
+			{
                 
                 y =  (((float)(i - pitch_value) * factor) + .5f);
-                if( !(i % div_units ))    {        //  At integral multiple of div
+                if( !(i % div_units ))            //  At integral multiple of div
+				{
                 
                     sprintf( TextLadder, "%d", i );
                     font->getBBox ( TextLadder, pointsize, italic,
@@ -513,15 +528,30 @@ void HudLadder :: draw( void )
                 
                     x_ini = -half_span;
                     
-                    if( i >= 0 ) {
+                    if( i >= 0 ) 
+					{
                         // Make zero point wider on left
                         if( i == 0 )
                             x_ini -= zero_offset;
+                            
 						// Zero or above draw solid lines
 						Line(x_ini, y, x_end, y);
+						
+						if(i == 90)
+						if(zenith == 1)
+						{
+						  drawZenith(x_ini, x_end,y);
+						}
                     } else {
                         // Below zero draw dashed lines.
                         StippleLine(x_ini, y, x_end, y);
+
+						
+						if(i == -90)
+						if(nadir ==1)
+						{ 
+							drawNadir(x_ini, x_end,y);
+						}
                     }
                     
                     // Calculate the position of the left text and write it.
@@ -536,7 +566,8 @@ void HudLadder :: draw( void )
 
 		x_end = -half_span + hole;
 		x_ini2= half_span  - hole;
-		for( ; i<last ; i++ )      {
+		for( ; i<last ; i++ )      
+		{
 
 		    if(hudladder_type=="Pitch Ladder")
 			y = (((float)(i - pitch_value) * factor) + .5);
@@ -559,30 +590,48 @@ void HudLadder :: draw( void )
 			x_ini = -half_span;
 			x_end2= half_span;
                     
-			if( i >= 0 ) { 
+			if( i >= 0 ) 
+			{ 
 			    // Make zero point wider on left
-			    if( i == 0 ) {
+			    if( i == 0 ) 
+				{
 				    x_ini -= zero_offset;
 					x_end2 +=zero_offset;
-			    } else {
+			    } 
-				if(climb_dive_ladder){
+			    //draw climb bar vertical lines
+				if(climb_dive_ladder)
+				{
 				   // Zero or above draw solid lines
 				   Line(x_end, y-5.0, x_end, y);
 				   Line(x_ini2, y-5.0, x_ini2, y);
 			    }
-			    }
+				// draw pitch / climb bar
-
 			    Line(x_ini, y, x_end, y);
 			    Line(x_ini2, y, x_end2, y);
 
-			} else {
+				if(i == 90)
-			    // Below zero draw dashed lines.
+				if(zenith == 1)
-			    if(climb_dive_ladder) {
+				{  
+				  drawZenith(x_ini2, x_end,y);
+				}
+			}
+			else  // i < 0
+			{
+			    // draw dive bar vertical lines
+			    if(climb_dive_ladder) 
+				{
 					Line(x_end, y+5.0, x_end, y);
 					Line(x_ini2, y+5.0, x_ini2, y);
 			    }
+			    // draw pitch / dive bars
 				StippleLine(x_ini, y, x_end, y);
 			    StippleLine(x_ini2, y, x_end2, y);
+               
+			    if(i == -90)
+			    if(nadir == 1)
+				{
+				    drawNadir(x_ini2, x_end,y);
+				}
 			}
                     
 			// Now calculate the location of the left side label using
@@ -627,8 +676,8 @@ void HudLadder :: draw( void )
 
 	fromwp_lon = get_longitude()*SGD_DEGREES_TO_RADIANS;
 	fromwp_lat = get_latitude()*SGD_DEGREES_TO_RADIANS;
-	towp_lon = get_aux5()*SGD_DEGREES_TO_RADIANS;
+	towp_lon = get_aux2()*SGD_DEGREES_TO_RADIANS;
-	towp_lat = get_aux6()*SGD_DEGREES_TO_RADIANS;
+	towp_lat = get_aux1()*SGD_DEGREES_TO_RADIANS;
 
 	dist = acos(sin(fromwp_lat)*sin(towp_lat)+cos(fromwp_lat)*cos(towp_lat)*cos(fabs(fromwp_lon-towp_lon)));
 	delx= towp_lat - fromwp_lat;
@@ -651,7 +700,9 @@ void HudLadder :: draw( void )
 	// OBJECT MOVING RETICLE
 	// TYPE ARROW
 	// waypoint marker
-	if (fabs(brg-psi) > 10.0) {
+
+   	  if (fabs(brg-psi) > 10.0) 
+	  {
 	    glPushMatrix();
 	    glTranslatef( centroid.x, centroid.y, 0);
 	    glTranslatef( vel_x, vel_y, 0);
@@ -667,8 +718,12 @@ void HudLadder :: draw( void )
 	    glEnd();
 	    glPopMatrix();
 	  }
+
 	  // waypoint marker on heading scale
-	if (fabs(brg-psi) < 12.0) {
+	  if (fabs(brg-psi) < 12.0) 
+	  {
+	  if(hat ==0)
+	  {
 	    glBegin(GL_LINE_LOOP);
 	    glVertex2f(((brg-psi)*60/25)+320,240.0);
 	    glVertex2f(((brg-psi)*60/25)+326,240.0-4);
@@ -678,7 +733,155 @@ void HudLadder :: draw( void )
 	    glVertex2f(((brg-psi)*60/25)+317,240.0-4);
 	    glVertex2f(((brg-psi)*60/25)+314,240.0-4);
 	    glEnd();
+	  } else {//if hat=0
+
+		  float x= (brg-psi)*60/25 + 320,  y=240.0, r=5.0;
+		  float x1,y1;
+								
+		  glEnable(GL_POINT_SMOOTH);
+    										  
+    	  glBegin(GL_POINTS);
+			
+		  for(int count=0; count<=200; count++)
+		  {
+			float temp = count * 3.142 * 3 / (200.0*2.0);
+			float temp1 = temp-(45.0*SGD_DEGREES_TO_RADIANS);
+		    x1 = x + r * cos(temp1); 
+		    y1 = y + r * sin(temp1);
+					 
+			glVertex2f(x1, y1);
 		  }
-	//*************************************************************
+					
+		  glEnd();
+		  glDisable(GL_POINT_SMOOTH); 
+	  } //hat=0
+
+	  } //brg<12
     } // if waypoint_marker
 }//draw
+
+/******************************************************************/
+
+//begin suma
+	//  draws the zenith symbol  for highest possible climb angle (i,e 90 degree climb angle)
+
+void HudLadder :: 
+drawZenith(float xfirst,float xlast,float yvalue )
+{
+
+	     float xcentre = (xfirst + xlast)/2.0;
+		 float ycentre = yvalue;
+
+         Line(xcentre-9.0, ycentre, xcentre-3.0, ycentre+1.3);
+	     Line(xcentre-9.0, ycentre, xcentre-3.0, ycentre-1.3);
+  
+   	     Line(xcentre+9.0, ycentre, xcentre+3.0, ycentre+1.3);
+	     Line(xcentre+9.0, ycentre, xcentre+3.0, ycentre-1.3);
+
+	     Line(xcentre, ycentre+9.0, xcentre-1.3, ycentre+3.0);
+	     Line(xcentre, ycentre+9.0, xcentre+1.3, ycentre+3.0);
+
+		 Line(xcentre-3.9, ycentre+3.9, xcentre-3.0, ycentre+1.3);
+	     Line(xcentre-3.9, ycentre+3.9, xcentre-1.3, ycentre+3.0);
+
+	     Line(xcentre+3.9, ycentre+3.9, xcentre+1.3, ycentre+3.0);
+	     Line(xcentre+3.9, ycentre+3.9, xcentre+3.0, ycentre+1.3);
+
+	     Line(xcentre-3.9, ycentre-3.9, xcentre-3.0, ycentre-1.3);
+	     Line(xcentre-3.9, ycentre-3.9, xcentre-1.3, ycentre-2.6);
+
+	     Line(xcentre+3.9, ycentre-3.9, xcentre+3.0, ycentre-1.3);
+	     Line(xcentre+3.9, ycentre-3.9, xcentre+1.3, ycentre-2.6);
+
+	     Line(xcentre-1.3, ycentre-2.6, xcentre, ycentre-27.0);
+         Line(xcentre+1.3, ycentre-2.6, xcentre, ycentre-27.0);
+
+  
+} 
+	//end suma
+
+//begin suma
+	//  draws the nadir symbol  for lowest possible dive angle (i,e 90 degree dive angle)
+
+
+void HudLadder ::
+drawNadir(float xfirst, float xlast, float yvalue)
+{
+
+	     float xcentre = (xfirst + xlast)/2.0;
+		 float ycentre = yvalue;    
+
+
+		float r = 7.5;
+		float ang,temp;
+		float x1,y1,x2,y2,xcent,ycent;
+
+	
+        // to draw a circle
+
+		float xcent1, xcent2, ycent1, ycent2;
+		xcent1 = xcentre + r * cos(0.0);
+		ycent1 = ycentre + r * sin(0.0);
+    	for(int count=1; count<=400; count++) 
+		{  
+			float temp = count * 2 * 3.142 / 400.0;
+		    xcent2 = xcentre + r * cos(temp); 
+			ycent2 = ycentre + r * sin(temp); 			    
+			
+			Line(xcent1, ycent1, xcent2, ycent2);
+
+			xcent1 = xcent2;
+			ycent1 = ycent2;
+		}     
+		
+		xcent2 = xcentre + r * cos(0.0);
+		ycent2 = ycentre + r * sin(0.0);
+
+        drawOneLine(xcent1, ycent1, xcent2, ycent2); //to connect last point to first point
+		//end circle
+
+
+		Line(xcentre, ycentre+7.5, xcentre, ycentre+22.5); //to draw a line above the circle
+
+		Line(xcentre-7.5, ycentre, xcentre+7.5,ycentre); //line in the middle of circle
+
+		float theta = asin (2.5/7.5);
+		float theta1 = asin(5.0/7.5);
+
+		 x1 = xcentre + r * cos(theta);
+		 y1 = ycentre + 2.5;
+
+		 x2 = xcentre + r * cos((180.0 * SGD_DEGREES_TO_RADIANS) - theta);
+		 y2 = ycentre + 2.5;
+
+		 Line(x1,y1,x2,y2);
+
+		
+		 x1 = xcentre + r * cos(theta1);
+		 y1 = ycentre + 5.0;
+
+		 x2 = xcentre + r * cos((180.0 * SGD_DEGREES_TO_RADIANS)-theta1);
+		 y2 = ycentre + 5.0;
+
+		 Line(x1,y1,x2,y2);
+
+
+ 		 x1 = xcentre + r * cos((180.0 * SGD_DEGREES_TO_RADIANS) +theta);
+		 y1 = ycentre - 2.5;
+
+		 x2 = xcentre + r * cos((360.0* SGD_DEGREES_TO_RADIANS)-theta);
+		 y2 = ycentre - 2.5;
+
+		 Line(x1,y1,x2,y2);
+
+		
+		 x1 = xcentre + r * cos((180.0* SGD_DEGREES_TO_RADIANS) +theta1);
+		 y1 = ycentre - 5.0;
+
+		 x2 = xcentre + r * cos((360.0* SGD_DEGREES_TO_RADIANS)-theta1);
+		 y2 = ycentre - 5.0;
+
+		 Line(x1,y1,x2,y2);
+
+
+}

src/Cockpit/hud_lat.cxx

@@ -3,9 +3,9 @@
 
 
 #ifdef USE_HUD_TextList
-#define textString( x , y, text, font )  TextString( text, x , y )
+#define textString( x , y, text, font,digit )  TextString( text, x , y,digit ) //suma
 #else
-#define textString( x , y, text, font )  puDrawString ( guiFnt, text, x, y );
+#define textString( x , y, text, font,digit )  puDrawString ( guiFnt, text, x, y ); //suma
 #endif
 
 //======================= Top of instr_label class =========================
@@ -23,9 +23,10 @@ lat_label ::
                       fgLabelJust   justification,
                       int           font_size,
                       int           blinking,
-                      bool          working ):
+                      bool          working ,
+					  int			digit): //suma
                            instr_item( x, y, width, height,
-                                       data_source, scale_data,options, working ),
+                                       data_source, scale_data,options, working,digit), //suma
                            pformat  ( label_format      ),
                            pre_str  ( pre_label_string  ),
                            post_str ( post_label_string ),
@@ -137,12 +138,12 @@ draw( void )       // Required method in base class
   
   if( fontSize == SMALL ) {
     textString( scrn_rect.left + posincr, scrn_rect.top,
-                label_buffer, GLUT_BITMAP_8_BY_13);
+                label_buffer, GLUT_BITMAP_8_BY_13, get_digits()); //suma
     }
   else  {
     if( fontSize == LARGE ) {
       textString( scrn_rect.left + posincr, scrn_rect.top,
-                  label_buffer, GLUT_BITMAP_9_BY_15);
+                  label_buffer, GLUT_BITMAP_9_BY_15,get_digits()); //suma
       }
     }
 }

src/Cockpit/hud_lon.cxx

@@ -3,9 +3,9 @@
 
 
 #ifdef USE_HUD_TextList
-#define textString( x , y, text, font )  TextString( text, x , y )
+#define textString( x , y, text, font,digit )  TextString( text, x , y,digit ) //suma
 #else
-#define textString( x , y, text, font )  puDrawString ( guiFnt, text, x, y );
+#define textString( x , y, text, font,digit )  puDrawString ( guiFnt, text, x, y ); //suma
 #endif
 
 //======================= Top of instr_label class =========================
@@ -25,9 +25,10 @@ lon_label ::
                       fgLabelJust   justification,
                       int           font_size,
                       int           blinking,
-                      bool          working ):
+                      bool          working,
+					  int			digit): //suma
                            instr_item( x, y, width, height,
-                                       data_source, scale_data,options, working ),
+                                       data_source, scale_data,options, working,digit ), //suma
                            pformat  ( label_format      ),
                            pre_str  ( pre_label_string  ),
                            post_str ( post_label_string ),
@@ -140,12 +141,12 @@ draw( void )       // Required method in base class
   
   if( fontSize == SMALL ) {
     textString( scrn_rect.left + posincr, scrn_rect.top,
-                label_buffer, GLUT_BITMAP_8_BY_13);
+                label_buffer, GLUT_BITMAP_8_BY_13, get_digits()); //suma
     }
   else  {
     if( fontSize == LARGE ) {
       textString( scrn_rect.left + posincr, scrn_rect.top,
-                  label_buffer, GLUT_BITMAP_9_BY_15);
+                  label_buffer, GLUT_BITMAP_9_BY_15, get_digits()); //suma
       }
     }
 }

src/Cockpit/hud_scal.cxx

@@ -12,7 +12,7 @@
 //    markers) or just over the middle line.
 //
 // 2.  This class was not intended to be instanciated. See moving_scale
-//     and guage_instr classes.
+//     and gauge_instr classes.
 //============================================================================
 instr_scale ::
 instr_scale ( int       x,

src/Cockpit/hud_tbi.cxx

@@ -1,5 +1,6 @@
 
 #include "hud.hxx"
+#include<math.h>
 
 
 //============ Top of fgTBI_instr class member definitions ==============
@@ -14,7 +15,9 @@ fgTBI_instr( int              x,
              float    maxBankAngle,
              float    maxSlipAngle,
              UINT      gap_width,
-             bool      working ) :
+             bool      working,
+			 bool	   tsivalue, //suma
+			 float     radius) : //suma
                dual_instr_item( x, y, width, height,
                                 chn1_source,
                                 chn2_source,
@@ -24,6 +27,8 @@ fgTBI_instr( int              x,
                SlewLimit      ((int)(maxSlipAngle)),
                scr_hole       (gap_width   )
 {
+	tsi=tsivalue; //suma   
+	rad=radius; //suma
 }
 
 fgTBI_instr :: ~fgTBI_instr() {}
@@ -68,22 +73,30 @@ operator = (const fgTBI_instr & rhs )
 	 
      bank_angle     = current_ch2();  // Roll limit +/- 30 degrees
      
-     if( bank_angle < -SGD_PI_2/3 ) {
+     if( bank_angle < -SGD_PI_2/3 ) 
+	 {
          bank_angle = -SGD_PI_2/3;
-     } else if( bank_angle > SGD_PI_2/3 ) {
+     }
+	 else if( bank_angle > SGD_PI_2/3 ) 
+	 {
              bank_angle = SGD_PI_2/3;
      }
      
+         
 	 sideslip_angle = current_ch1(); // Sideslip limit +/- 20 degrees
 
-     if( sideslip_angle < -SGD_PI/9 ) {
+     if( sideslip_angle < -SGD_PI/9 ) 
+	 {
          sideslip_angle = -SGD_PI/9;
-     } else if( sideslip_angle > SGD_PI/9 ) {
+     }
+	 else if( sideslip_angle > SGD_PI/9 ) 
+	 {
              sideslip_angle = SGD_PI/9;
      }
 
      cen_x = centroid.x;
      cen_y = centroid.y;
+     
      bank  = bank_angle * SGD_RADIANS_TO_DEGREES;
 	 tee   = -tee_height;
      fspan = span;
@@ -93,17 +106,23 @@ operator = (const fgTBI_instr & rhs )
 //   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);
     
+	 if(!tsi)
+	 {
+		 
 		glBegin(GL_LINES);
 	     
 		if( !scr_hole )  
 		{
 			glVertex2f( -fspan, zero );
 			glVertex2f(  fspan, zero );
-     } else {
+		} 
+		else
+		{
 			glVertex2f( -fspan, zero );
 			glVertex2f( -hole,  zero );
 			glVertex2f(  hole,  zero );
@@ -124,5 +143,157 @@ operator = (const fgTBI_instr & rhs )
 			glVertex2f( ss_const - hole,  zero);
 		glEnd();
 
+
+	 }
+	 
+
+	 else //if tsi enabled
+	 {
+		 float factor = My_box.right / 6.0;
+
+		 drawOneLine(cen_x-1.0, My_box.top,      cen_x+1.0, My_box.top);
+		 drawOneLine(cen_x-1.0, My_box.top,      cen_x-1.0, My_box.top+10.0);
+		 drawOneLine(cen_x+1.0, My_box.top,      cen_x+1.0, My_box.top+10.0);
+		 drawOneLine(cen_x-1.0, My_box.top+10.0, cen_x+1.0, My_box.top+10.0);
+
+    	 float x1, y1, x2, y2, x3, y3, x4,y4, x5, y5;
+		 float xc, yc, r=rad, r1= rad-10.0, r2=rad-5.0;
+		 
+		 xc = My_box.left + My_box.right/ 2.0 ;
+		 yc = My_box.top + r;
+
+//first n last lines
+		  x1= xc + r * cos (255.0 * SGD_DEGREES_TO_RADIANS);
+		  y1= yc + r * sin (255.0 * SGD_DEGREES_TO_RADIANS);
+
+		  x2= xc + r1 * cos (255.0 * SGD_DEGREES_TO_RADIANS);
+		  y2= yc + r1 * sin (255.0 * SGD_DEGREES_TO_RADIANS);
+		  
+		  drawOneLine(x1,y1,x2,y2);
+
+  		  x1= xc + r * cos (285.0 * SGD_DEGREES_TO_RADIANS);
+		  y1= yc + r * sin (285.0 * SGD_DEGREES_TO_RADIANS);
+
+		  x2= xc + r1 * cos (285.0 * SGD_DEGREES_TO_RADIANS);
+		  y2= yc + r1 * sin (285.0 * SGD_DEGREES_TO_RADIANS);
+
+          drawOneLine(x1,y1,x2,y2);
+
+//second n fifth  lines
+
+		  x1= xc + r * cos (260.0 * SGD_DEGREES_TO_RADIANS);
+		  y1= yc + r * sin (260.0 * SGD_DEGREES_TO_RADIANS);
+		  
+		  x2= xc + r2 * cos (260.0 * SGD_DEGREES_TO_RADIANS);
+		  y2= yc + r2 * sin (260.0 * SGD_DEGREES_TO_RADIANS);
+		  
+		  drawOneLine(x1,y1,x2,y2);
+
+  		  x1= xc + r * cos (280.0 * SGD_DEGREES_TO_RADIANS);
+		  y1= yc + r * sin (280.0 * SGD_DEGREES_TO_RADIANS);
+
+		  
+		  x2= xc + r2 * cos (280.0 * SGD_DEGREES_TO_RADIANS);
+		  y2= yc + r2 * sin (280.0 * SGD_DEGREES_TO_RADIANS);
+
+          drawOneLine(x1,y1,x2,y2);
+
+//third n fourth lines
+
+
+		  x1= xc + r * cos (265.0 * SGD_DEGREES_TO_RADIANS);
+		  y1= yc + r * sin (265.0 * SGD_DEGREES_TO_RADIANS);
+
+		  
+		  x2= xc + r2 * cos (265.0 * SGD_DEGREES_TO_RADIANS);
+		  y2= yc + r2 * sin (265.0 * SGD_DEGREES_TO_RADIANS);
+		  
+		  drawOneLine(x1,y1,x2,y2);
+
+  		  x1= xc + r * cos (275.0 * SGD_DEGREES_TO_RADIANS);
+		  y1= yc + r * sin (275.0 * SGD_DEGREES_TO_RADIANS);
+		  
+		  x2= xc + r2 * cos (275.0 * SGD_DEGREES_TO_RADIANS);
+		  y2= yc + r2 * sin (275.0 * SGD_DEGREES_TO_RADIANS);
+
+          drawOneLine(x1,y1,x2,y2);
+
+		  //to draw marker
+		  
+		  
+		
+			  float  valbank, valsideslip, sideslip;
+			 
+			  r = rad + 5.0;  //5 is added to get a gap 
+			 // upper polygon
+              bank_angle     = current_ch2();
+
+			  bank= bank_angle * SGD_RADIANS_TO_DEGREES;  // Roll limit +/- 30 degrees
+			  if(bank > BankLimit)
+					bank = BankLimit;
+			  if(bank < -1.0*BankLimit)
+					bank = -1.0*BankLimit;
+
+			  valbank = bank * 15.0 / BankLimit; // total span of TSI is 30 degrees
+			  
+			  sideslip_angle = current_ch1(); // Sideslip limit +/- 20 degrees
+			  sideslip= sideslip_angle * SGD_RADIANS_TO_DEGREES;  
+			  if(sideslip > SlewLimit)
+				  sideslip = SlewLimit;
+			  if(sideslip < -1.0*SlewLimit)
+				  sideslip = -1.0*SlewLimit;
+              valsideslip = sideslip * 15.0 / SlewLimit;
+			  
+			  //values 270, 225 and 315 are angles in degrees...
+
+			  x1= xc + r * cos ((valbank+270.0) * SGD_DEGREES_TO_RADIANS);
+			  y1= yc + r * sin ((valbank+270.0) * SGD_DEGREES_TO_RADIANS);
+
+			  x2= x1 + 6.0 * cos (225 * SGD_DEGREES_TO_RADIANS);
+			  y2= y1 + 6.0 * sin (225 * SGD_DEGREES_TO_RADIANS);
+			  
+			  x3= x1 + 6.0 * cos (315 * SGD_DEGREES_TO_RADIANS);
+			  y3= y1 + 6.0 * sin (315 * SGD_DEGREES_TO_RADIANS);
+
+		      drawOneLine(x1, y1, x2, y2);
+			  drawOneLine(x2, y2, x3, y3);
+			  drawOneLine(x3, y3, x1, y1);
+
+  			  //lower polygon...
+			 
+			 
+			  
+			  x1= xc + r * cos ((valbank+270.0) * SGD_DEGREES_TO_RADIANS);
+			  y1= yc + r * sin ((valbank+270.0) * SGD_DEGREES_TO_RADIANS);
+
+			  x2= x1 + 6.0 * cos (225 * SGD_DEGREES_TO_RADIANS);
+			  y2= y1 + 6.0 * sin (225 * SGD_DEGREES_TO_RADIANS);
+			  
+			  x3= x1 + 6.0 * cos (315 * SGD_DEGREES_TO_RADIANS);
+			  y3= y1 + 6.0 * sin (315 * SGD_DEGREES_TO_RADIANS);
+
+			  x4= x1 + 10.0 * cos (225 * SGD_DEGREES_TO_RADIANS);
+			  y4= y1 + 10.0 * sin (225 * SGD_DEGREES_TO_RADIANS);
+			  
+			  x5= x1 + 10.0 * cos (315 * SGD_DEGREES_TO_RADIANS);
+			  y5= y1 + 10.0 * sin (315 * SGD_DEGREES_TO_RADIANS);
+
+			  x2 = x2 + cos (valsideslip * SGD_DEGREES_TO_RADIANS);
+		      y2 = y2 + sin (valsideslip * SGD_DEGREES_TO_RADIANS);
+			  x3 = x3 + cos (valsideslip * SGD_DEGREES_TO_RADIANS);
+			  y3 = y3 + sin (valsideslip * SGD_DEGREES_TO_RADIANS);
+			  x4 = x4 + cos (valsideslip * SGD_DEGREES_TO_RADIANS);
+			  y4 = y4 + sin (valsideslip * SGD_DEGREES_TO_RADIANS);
+ 			  x5 = x5 + cos (valsideslip * SGD_DEGREES_TO_RADIANS);
+			  y5 = y5 + sin (valsideslip * SGD_DEGREES_TO_RADIANS);
+
+			  drawOneLine(x2, y2, x3, y3); 
+			  drawOneLine(x3, y3, x5, y5);
+			  drawOneLine(x5, y5, x4, y4);
+			  drawOneLine(x4, y4, x2, y2);  
+			 
+ 
+	 }
+
 		glPopMatrix();
 }