Changes to toggle panel on and off.

diff --git a/Simulator/Autopilot/autopilot.cxx b/Simulator/Autopilot/autopilot.cxx
index 5dc89252064068c91c3fe03abb12e11632708c8a..279c13fbf2589d5e76e10ce0d84fccdec968ae97 100644 (file)
--- a/Simulator/Autopilot/autopilot.cxx
+++ b/Simulator/Autopilot/autopilot.cxx
@@ -35,6 +35,8 @@
 #include <Include/fg_constants.h>
 #include <Debug/logstream.hxx>
 #include <Main/options.hxx>
+#include <Cockpit/panel.hxx>
+#include <Main/views.hxx>
 
 #include <plib/pu.h>
 
@@ -328,10 +330,18 @@ static void rolloutsmooth_adj( puObject *hs )
 
 static void goAwayAPAdjust (puObject *)
 {
+    FGView *v = &current_view;
     puPopLiveInterface ( ) ;
-    // puPopInterface ( ) ;
     puPopGroup ( ) ;   
     APAdjustDialog -> hide();
+    if ( current_options.get_panel_status() ) {
+       // this seems to be the only way to do this :-(
+       // problem is the viewport has been mucked with
+       // current_options.toggle_panel();
+       // current_options.toggle_panel();
+       xglViewport(0, 0, (GLint)(v->winWidth), (GLint)(v->winHeight) );
+       FGPanel::OurPanel->ReInit(0, 0, 1024, 768);
+    }
 }
 
 void cancelAPAdjust(puObject *)

diff --git a/Simulator/Cockpit/panel.cxx b/Simulator/Cockpit/panel.cxx
index 37a8a59b5367870869ea7463c5694e85055a4f35..4680e477b8e427b628aea67c64a1bb11401b4185 100644 (file)
--- a/Simulator/Cockpit/panel.cxx
+++ b/Simulator/Cockpit/panel.cxx
@@ -73,9 +73,14 @@ static float alpha;
 static int n1;
 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};
+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};
 
 FGPanel* FGPanel::OurPanel = 0;
 
@@ -87,23 +92,33 @@ FGPanel::FGPanel(void){
     GLint test;
     GLubyte *tex = new GLubyte[262144];
 
-OurPanel = this;   
+    if(OurPanel) {
+       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);
-test_instr[4] = new FGTexInstrument(358, 52, 4, 30, 3, 30, -3.0, 3.0, 100,                                          440, 66.15, 66, 2);
-test_instr[5] = new FGTexInstrument(357.5, 167, 5, 25, 4, 30, 0, 10000, 0,                                          360, 194, 191, 1);
-test_instr[6] = new FGTexInstrument(357.5, 167, 5, 32, 3, 30, 0, 3000, 0,                                           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); 
-
-// FontList = glGenLists (256);
-// glListBase(FontList);
-// InitLists();
+       
+    test_instr[3] = new FGTexInstrument(144.375, 166.875, 4, 32, 3, 30, 15.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);
+    test_instr[5] = new FGTexInstrument(357.5, 167, 5, 25, 4, 30, 0, 10000, 0,
+                                       360, 194, 191, 1);
+    test_instr[6] = new FGTexInstrument(357.5, 167, 5, 32, 3, 30, 0, 3000, 0,
+                                       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); 
+       
+    // FontList = glGenLists (256);
+    // glListBase(FontList);
+    // InitLists();
 
 #ifdef GL_VERSION_1_1
     xglGenTextures(2, panel_tex_id);
@@ -148,28 +163,28 @@ test_instr[2] = new FGTexInstrument(462.5, 133, 10, 20, 5.5, 60, 0.0, 1.0,
     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) ){
-//              tex[(y+x*256)*3 + 3] = 0x0;
-//               }
-//           else{
-//             tex[(y+x*256)*3 + 3] = 0xff;
-//             }
-//      }
-// }
+    }
+
+    //    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) ){
+    //              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);
-      xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
+    xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
     xglRasterPos2i(0,0);
     xglPixelZoom(Xzoom, Yzoom);
     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 256);
@@ -186,7 +201,7 @@ test_instr[2] = new FGTexInstrument(462.5, 133, 10, 20, 5.5, 60, 0.0, 1.0,
     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);
-   xglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB,                                  GL_UNSIGNED_BYTE, (GLvoid *)(img)); 
+    xglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB,                                  GL_UNSIGNED_BYTE, (GLvoid *)(img)); 
                  
     xglMatrixMode(GL_MODELVIEW);
     xglPopMatrix();
@@ -194,6 +209,7 @@ test_instr[2] = new FGTexInstrument(462.5, 133, 10, 20, 5.5, 60, 0.0, 1.0,
 
 void FGPanel::ReInit( int x, int y, int finx, int finy){
     fgOPTIONS *o;
+    FGView *v = &current_view;
     int i;
     GLint buffer;
     
@@ -218,7 +234,7 @@ void FGPanel::ReInit( int x, int y, int finx, int finy){
     xglMatrixMode(GL_MODELVIEW);
     xglPushMatrix();
     xglLoadIdentity();
-     xglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    xglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     xglPixelZoom(Xzoom, Yzoom);
     xglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
@@ -226,8 +242,9 @@ void FGPanel::ReInit( int x, int y, int finx, int finy){
     xglPixelStorei(GL_UNPACK_SKIP_ROWS, y);
     xglRasterPos2i(x, y);
     xglPixelZoom(Xzoom, Yzoom);
-    xglDrawPixels(finx - x, finy - y, GL_RGB, GL_UNSIGNED_BYTE,                     (GLvoid *)(background));
-
+    xglDrawPixels(finx - x, finy - y, GL_RGB, GL_UNSIGNED_BYTE,
+                 (GLvoid *)(background));
+       
     // restore original buffer state
     xglDrawBuffer( (GLenum)buffer );
     xglEnable(GL_DEPTH_TEST);
@@ -242,11 +259,11 @@ void FGPanel::Update ( void ) {
     double speed;
     int i;
     
-//    static bool beech_drawn = false;
-//    char *test = "ALM 100";
+    //    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 
+    // factor, to simulate flying a Bonanza 
     var[1] = get_altitude();
     var[2] = get_climb_rate() / 1000.0; 
     var[3] = get_throttleval();
@@ -268,18 +285,18 @@ void FGPanel::Update ( void ) {
     xglPushMatrix();
 
     xglDisable(GL_LIGHTING);
-     test_instr[3]->Render();
-     test_instr[4]->Render();
-     test_instr[5]->Render();
-     test_instr[6]->Render();
+    test_instr[3]->Render();
+    test_instr[4]->Render();
+    test_instr[5]->Render();
+    test_instr[6]->Render();
     xglPopMatrix();
     xglPushMatrix();
     
     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);
+    //   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);
             
@@ -309,8 +326,8 @@ void FGHorizon::Render(void){
     GLboolean Light;
     GLfloat normal[2];
     
-   static int n, dn, rot, tmp1, tmp2;
-   float a;
+    static int n, dn, rot, tmp1, tmp2;
+    float a;
     
     GLfloat material[] = { 0.714844, 0.265625, 0.056875 ,1.0};
     GLfloat material2[] = {0.6640625, 0.921875, 0.984375, 1.0};
@@ -326,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;
     
@@ -351,26 +368,26 @@ void FGHorizon::Render(void){
     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  
@@ -385,13 +402,13 @@ void FGHorizon::Render(void){
     xglLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);
     xglLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, direction);
 
-    #ifdef GL_VERSION_1_1
+#ifdef GL_VERSION_1_1
     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[1]);
-    #elif GL_EXT_texture_object
+#elif GL_EXT_texture_object
     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id[1]);
-    #else
-    #  error port me
-    #endif
+#else
+#  error port me
+#endif
 
     xglLoadIdentity();
     xglTranslatef(0.0, ((pitch / 10) * 0.046875), 0.0);
@@ -401,90 +418,94 @@ void FGHorizon::Render(void){
 
     // the following loop draws the textured part of the AH
     
-   xglMaterialf(GL_FRONT, GL_SHININESS, 85.0);
+    xglMaterialf(GL_FRONT, GL_SHININESS, 85.0);
     
-   xglMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material4);
-   xglMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material5);
-   xglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material3);
+    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);
-               }
-     xglEnd();
+    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);
+    }
+    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;
+       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);
+       xglLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient2);
+       xglLightfv(GL_LIGHT1, GL_DIFFUSE, light_ambient2); 
+       xglLightfv(GL_LIGHT1, GL_SPECULAR, light_ambient2);
         
-    xglBegin(GL_TRIANGLES);
+       xglBegin(GL_TRIANGLES);
     
-    tmp1 = n1; tmp2 = n2;
+       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);
+       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);
+           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();
+           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;
+       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); 
+       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);
+           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();
+           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
@@ -525,29 +546,29 @@ light_ambient2[2] = a;
     xglDisable(GL_LIGHTING);
     xglDisable(GL_LIGHT1);
     xglEnable(GL_LIGHT0);
-    }
+}
 
 // fgHorizonInit - initialize values for the AH
 
 void FGHorizon::Init(void){
-       radius = 28.9;
-       texXPos = 56;
-       texYPos = 174;
-       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;
-           }
+    radius = 28.9;
+    texXPos = 56;
+    texYPos = 174;
+    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;
+    }
 }
 
 void FGTexInstrument::UpdatePointer(void){
@@ -558,12 +579,13 @@ void FGTexInstrument::UpdatePointer(void){
     glEnableClientState(GL_VERTEX_ARRAY);
     glVertexPointer(2, GL_FLOAT, 0, vertices);
 
-    alpha=((((float)((var[variable]) - (value1))) /                                        (value2 - value1))*                                                             (alpha2 - alpha1) + alpha1);
+    alpha=((((float)((var[variable]) - (value1))) /
+           (value2 - value1))* (alpha2 - alpha1) + alpha1);
     
-       if (alpha < alpha1)
-                       alpha = alpha1;
-       if (alpha > alpha2)
-               alpha = alpha2;
+    if (alpha < alpha1)
+       alpha = alpha1;
+    if (alpha > alpha2)
+       alpha = alpha2;
     xglMatrixMode(GL_MODELVIEW);  
     xglPushMatrix();
     xglLoadIdentity();
@@ -582,258 +604,262 @@ void FGTexInstrument::UpdatePointer(void){
 //                 area. Shall be a method of a panel class once.
 
 void fgEraseArea(GLfloat *array, int NumVerti, GLfloat texXPos,                                  GLfloat texYPos, GLfloat XPos, GLfloat YPos,                                    int Texid, float ScaleFactor){
-int i, j;
-int n;
-float a;
-float ififth;
-
-xglEnable(GL_TEXTURE_2D);
-xglEnable(GL_TEXTURE_GEN_S);
-xglEnable(GL_TEXTURE_GEN_T);
-glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
-glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
-xglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-xglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
-xglMatrixMode(GL_TEXTURE);
-xglLoadIdentity();
+    int i, j;
+    int n;
+    float a;
+    float ififth;
+
+    xglEnable(GL_TEXTURE_2D);
+    xglEnable(GL_TEXTURE_GEN_S);
+    xglEnable(GL_TEXTURE_GEN_T);
+    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
+    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
+    xglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    xglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
+    xglMatrixMode(GL_TEXTURE);
+    xglLoadIdentity();
         
-    #ifdef GL_VERSION_1_1
+#ifdef GL_VERSION_1_1
     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[Texid]);
-    #elif GL_EXT_texture_object
+#elif GL_EXT_texture_object
     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id[Texid]);
-    #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);
+#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);
-} 
-       xglEnd();
+    xglBegin(GL_POLYGON);
+    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);
-        xglPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
-        xglDisable(GL_TEXTURE_2D);
-       xglDisable(GL_TEXTURE_GEN_S);
-       xglDisable(GL_TEXTURE_GEN_T);
+    xglLoadIdentity();
+    xglMatrixMode(GL_MODELVIEW);
+    xglPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+    xglPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+    xglDisable(GL_TEXTURE_2D);
+    xglDisable(GL_TEXTURE_GEN_S);
+    xglDisable(GL_TEXTURE_GEN_T);
         
 }
 
 // CreatePointer - calculate the vertices of a pointer 
 
 void FGTexInstrument::CreatePointer(void){
-int i;
-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 = asin(-(width/2)/r);
-
-for(i=0;i<5;i++){
-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];
+    int i;
+    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 = asin(-(width/2)/r);
+
+    for(i=0;i<5;i++){
+       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;
- }
- if(alpha < -56){
- alpha = -56;
- }
+    int n;
+
+    xglDisable(GL_LIGHTING);
+    xglDisable(GL_BLEND);
+    xglEnable(GL_TEXTURE_2D);
+
+    alpha = (get_sideslip() / 1.5) * 560;
+    if(alpha > 56){
+       alpha = 56;
+    }
+    if(alpha < -56){
+       alpha = -56;
+    }
  
- PlaneAlpha = get_roll();
+    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);
-xglTranslatef(0.75 * sin(alphahist[0] * DEG_TO_RAD) * 31,                                     0.3 * (39 - (cos(alphahist[0] * DEG_TO_RAD) * 39)),                             0.0);
-fgEraseArea(vertices, 72, BallTexXPos +                                                     ((0.75 * sin(alphahist[0] * DEG_TO_RAD) * 31) / 0.625),                         BallTexYPos + ((0.3 * (39 - (cos(alphahist[0] * DEG_TO_RAD)                                  * 39))) / 0.625),                                                   BallXPos + (0.75 * sin(alphahist[0] * DEG_TO_RAD) * 31),                       BallYPos + (0.3 * (39 - (cos(alphahist[0] * DEG_TO_RAD)                         * 39))), 1, 1);
-xglDisable(GL_TEXTURE_2D);
-xglEnable(GL_BLEND);
-xglBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE);
-xglMatrixMode(GL_MODELVIEW);
-xglLoadIdentity();
-xglTranslatef(BallXPos, BallYPos, 0.0);
-xglTranslatef(0.75 * sin(alpha * DEG_TO_RAD) * 31,                                            0.3 * (39 - (cos(alpha * DEG_TO_RAD) * 39)), 0.0);
-xglBegin(GL_POLYGON);
-xglColor3f(0.8, 0.8, 0.8);
-for(i=0;i<36;i++){
-xglVertex2f(vertices[2 * i],                                                                vertices[(2 * i) + 1]);
-}
-xglEnd(); 
+    xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
 
-xglDisable(GL_TEXTURE_2D);
-xglDisable(GL_BLEND);
+    xglMatrixMode(GL_MODELVIEW);
+    xglLoadIdentity();
+    xglTranslatef(BallXPos, BallYPos, 0.0);
+    xglTranslatef(0.75 * sin(alphahist[0] * DEG_TO_RAD) * 31,                                     0.3 * (39 - (cos(alphahist[0] * DEG_TO_RAD) * 39)),                             0.0);
+    fgEraseArea(vertices, 72, BallTexXPos +                                                     ((0.75 * sin(alphahist[0] * DEG_TO_RAD) * 31) / 0.625),                         BallTexYPos + ((0.3 * (39 - (cos(alphahist[0] * DEG_TO_RAD)                                  * 39))) / 0.625),                                                   BallXPos + (0.75 * sin(alphahist[0] * DEG_TO_RAD) * 31),                       BallYPos + (0.3 * (39 - (cos(alphahist[0] * DEG_TO_RAD)                         * 39))), 1, 1);
+    xglDisable(GL_TEXTURE_2D);
+    xglEnable(GL_BLEND);
+    xglBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE);
+    xglMatrixMode(GL_MODELVIEW);
+    xglLoadIdentity();
+    xglTranslatef(BallXPos, BallYPos, 0.0);
+    xglTranslatef(0.75 * sin(alpha * DEG_TO_RAD) * 31,                                            0.3 * (39 - (cos(alpha * DEG_TO_RAD) * 39)), 0.0);
+    xglBegin(GL_POLYGON);
+    xglColor3f(0.8, 0.8, 0.8);
+    for(i=0;i<36;i++){
+       xglVertex2f(vertices[2 * i],                                                                vertices[(2 * i) + 1]);
+    }
+    xglEnd(); 
 
-xglMatrixMode(GL_MODELVIEW);
-xglLoadIdentity();
-xglTranslatef(XPos, YPos, 0.0);
-xglRotatef(rollhist[0] * RAD_TO_DEG + 90, 0.0, 0.0, 1.0);
+    xglDisable(GL_TEXTURE_2D);
+    xglDisable(GL_BLEND);
 
-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); 
+    xglMatrixMode(GL_MODELVIEW);
+    xglLoadIdentity();
+    xglTranslatef(XPos, YPos, 0.0);
+    xglRotatef(rollhist[0] * RAD_TO_DEG + 90, 0.0, 0.0, 1.0);
 
-xglLoadIdentity();
-xglTranslatef(XPos, YPos, 0.0);
-xglRotatef(-get_roll() * 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); 
 
-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);
-}
-xglEnd();
-
-xglBegin(GL_POLYGON);
-xglVertex2f(Wings[0], Wings[1]);
-xglVertex2f(Wings[2], Wings[3]);
-xglVertex2f(Wings[4], Wings[5]);
-xglVertex2f(Wings[6], Wings[7]);
-xglVertex2f(Wings[0], Wings[1]);
-xglEnd();
-
-xglBegin(GL_POLYGON);
-xglVertex2f(Elevator[0], Elevator[1]);
-xglVertex2f(Elevator[2], Elevator[3]);
-xglVertex2f(Elevator[4], Elevator[5]);
-xglVertex2f(Elevator[6], Elevator[7]);
-xglVertex2f(Elevator[0], Elevator[1]);
-xglEnd();
-
-xglBegin(GL_POLYGON);
-xglVertex2f(Rudder[0], Rudder[1]);
-xglVertex2f(Rudder[2], Rudder[3]);
-xglVertex2f(Rudder[4], Rudder[5]);
-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);
+    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);
+    }
+    xglEnd();
+
+    xglBegin(GL_POLYGON);
+    xglVertex2f(Wings[0], Wings[1]);
+    xglVertex2f(Wings[2], Wings[3]);
+    xglVertex2f(Wings[4], Wings[5]);
+    xglVertex2f(Wings[6], Wings[7]);
+    xglVertex2f(Wings[0], Wings[1]);
+    xglEnd();
+
+    xglBegin(GL_POLYGON);
+    xglVertex2f(Elevator[0], Elevator[1]);
+    xglVertex2f(Elevator[2], Elevator[3]);
+    xglVertex2f(Elevator[4], Elevator[5]);
+    xglVertex2f(Elevator[6], Elevator[7]);
+    xglVertex2f(Elevator[0], Elevator[1]);
+    xglEnd();
+
+    xglBegin(GL_POLYGON);
+    xglVertex2f(Rudder[0], Rudder[1]);
+    xglVertex2f(Rudder[2], Rudder[3]);
+    xglVertex2f(Rudder[4], Rudder[5]);
+    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);
 }
 
 void FGTurnCoordinator::Init(void){
-int n;
-PlaneTexXPos = 49;
-PlaneTexYPos = 59.75;
-BallXPos = 145;
-BallYPos = 24;
-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;
-       }       
+    int n;
+    PlaneTexXPos = 49;
+    PlaneTexYPos = 59.75;
+    BallXPos = 145;
+    BallYPos = 24;
+    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;
+    }  
 }
 
-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);
+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
+#define ANTIALIASED_INSTRUMENTS
 
-     #ifdef ANTIALIASED_INSTRUMENTS
-     xglEnable(GL_LINE_SMOOTH);
-     xglEnable(GL_BLEND);
-     xglHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
-     #endif
+#ifdef ANTIALIASED_INSTRUMENTS
+    xglEnable(GL_LINE_SMOOTH);
+    xglEnable(GL_BLEND);
+    xglHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
+#endif
      
-     xglMatrixMode(GL_MODELVIEW);
-     xglLoadIdentity();
+    xglMatrixMode(GL_MODELVIEW);
+    xglLoadIdentity();
      
-     xglTranslatef(XPos, YPos, 0.0);
-     xglRotatef(-alpha1, 0.0, 0.0, 1.0);
+    xglTranslatef(XPos, YPos, 0.0);
+    xglRotatef(-alpha1, 0.0, 0.0, 1.0);
      
-     xglLineWidth(LineWidth);
-     xglColor3f(red, green, blue);
+    xglLineWidth(LineWidth);
+    xglColor3f(red, green, blue);
      
-     if(!filled){
-     xglBegin(GL_LINES);
-     }
-     else{
-     xglBegin(GL_QUAD_STRIP);
-     }
+    if(!filled){
+       xglBegin(GL_LINES);
+    }
+    else{
+       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);
-        }
-     xglEnd();
+    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);
+    }
+    xglEnd();
      
-     xglLoadIdentity();
-     xglDisable(GL_LINE_SMOOTH);
-     xglDisable(GL_BLEND);
-     }
+    xglLoadIdentity();
+    xglDisable(GL_LINE_SMOOTH);
+    xglDisable(GL_BLEND);
+}
 
 void DrawBeechcraftLogo(float XPos, float YPos, float width, float height){
-     xglMatrixMode(GL_MODELVIEW);
-     xglLoadIdentity();
-     xglTranslatef(XPos, YPos, 0.0);
-     xglEnable(GL_BLEND);
-     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
+    xglMatrixMode(GL_MODELVIEW);
+    xglLoadIdentity();
+    xglTranslatef(XPos, YPos, 0.0);
+    xglEnable(GL_BLEND);
+    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
+#elif GL_EXT_texture_object
     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id[1]);
-    #else
-    #  error port me
-    #endif
+#else
+#  error port me
+#endif
 
     xglBegin(GL_POLYGON);
     
@@ -850,212 +876,216 @@ 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]);
+    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]);
 }
 
 void FGRpmGauge::Init(void){
-     list = xglGenLists (1);
-     int n;
-     
-     xglNewList(list, GL_COMPILE);
+    list = xglGenLists (1);
+    int n;
      
-     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);
-     }
-     xglEnd();
+    xglNewList(list, GL_COMPILE);
      
-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);
+    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);
+    }
+    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();
-     }
+    xglEndList();
+}
      
 void FGRpmGauge::Render(void){
-     xglMatrixMode(GL_MODELVIEW);
-     xglLoadIdentity();
-     xglTranslatef(XPos, YPos, 0.0);
+    xglMatrixMode(GL_MODELVIEW);
+    xglLoadIdentity();
+    xglTranslatef(XPos, YPos, 0.0);
      
-     xglCallList(list);
+    xglCallList(list);
           
-     }
+}
      
 void FGPanel::DrawTestLetter(float X, float Y){
-     xglEnable(GL_TEXTURE_2D);
-     xglEnable(GL_BLEND);
+    xglEnable(GL_TEXTURE_2D);
+    xglEnable(GL_BLEND);
      
-     xglMatrixMode(GL_TEXTURE);
-     xglLoadIdentity();
-     xglTranslatef(X, Y, 0.0);
+    xglMatrixMode(GL_TEXTURE);
+    xglLoadIdentity();
+    xglTranslatef(X, Y, 0.0);
      
     DrawLetter();
     
-     xglMatrixMode(GL_MODELVIEW); 
-     xglTranslatef(6.0, 0.0, 0.0);
-     xglDisable(GL_TEXTURE_2D);
-     xglDisable(GL_BLEND);
-     }
+    xglMatrixMode(GL_MODELVIEW); 
+    xglTranslatef(6.0, 0.0, 0.0);
+    xglDisable(GL_TEXTURE_2D);
+    xglDisable(GL_BLEND);
+}
     
 void FGPanel::InitLists(void){
-     xglNewList(FontList + 'A', GL_COMPILE);
-     DrawTestLetter(0.391625, 0.29296875);
-     xglEndList();
+    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 + '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 + '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 + '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 + '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 + '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 + '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 + '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 + '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 + '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 + '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 + '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 + 'M', GL_COMPILE);
+    DrawTestLetter(0.80459375, 0.29296875);
+    xglEndList();
      
-     xglNewList(FontList + 'N', GL_COMPILE);
-     DrawTestLetter(0.83975, 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 + 'O', GL_COMPILE);
+    DrawTestLetter(0.871, 0.29296875);
+    xglEndList();
      
-     xglNewList(FontList + 'P', GL_COMPILE);
-     DrawTestLetter(0.90715625, 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 + 'Q', GL_COMPILE);
+    DrawTestLetter(0.9413125, 0.29296875);
+    xglEndList();
      
-     xglNewList(FontList + '1', GL_COMPILE);
-     DrawTestLetter(0.390625, 0.35546875);
-     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 + '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 + '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 + '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 + '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 + '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 + '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 + '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 + '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 + '0', GL_COMPILE);
+    DrawTestLetter(0.383625 + 9*LETTER_OFFSET, 0.3515625); 
+    xglEndList();
      
-     xglNewList(FontList + ' ', GL_COMPILE);
-     xglTranslatef(8.0, 0.0, 0.0);
-     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);
+    xglMatrixMode(GL_MODELVIEW);
+    xglLoadIdentity();
+    xglTranslatef(XPos, YPos, 0.0);
+    xglScalef(size, size, 1.0);
      
-    #ifdef GL_VERSION_1_1
+#ifdef GL_VERSION_1_1
     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[1]);
-    #elif GL_EXT_texture_object
+#elif GL_EXT_texture_object
     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id[1]);
-    #else
-    #  error port me
-    #endif
+#else
+#  error port me
+#endif
     
-     while((*s) != '\0'){
-     xglCallList(FontList + (*s));
-     s++;
-      }
-      xglLoadIdentity();
-     }
+    while((*s) != '\0'){
+       xglCallList(FontList + (*s));
+       s++;
+    }
+    xglLoadIdentity();
+}
      
 void FGTexInstrument::Init(void){
-     CreatePointer();
-     }
+    CreatePointer();
+}
      
 void FGTexInstrument::Render(void){
-xglEnable(GL_TEXTURE_2D);
-     xglLoadIdentity();
-     xglTranslatef(XPos, YPos, 0.0);
-     xglRotatef(-tape[0], 0.0, 0.0, 1.0);
+    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();
+    UpdatePointer();
      
-     xglDisable(GL_TEXTURE_2D);
-     }
+    xglDisable(GL_TEXTURE_2D);
+}
      

diff --git a/Simulator/GUI/gui.cxx b/Simulator/GUI/gui.cxx
index f2d6aa93a9321676169ae66962cb8a9908aa4f5b..cee0a69f599db91360a03a606ffb08a6ccb07c89 100644 (file)
--- a/Simulator/GUI/gui.cxx
+++ b/Simulator/GUI/gui.cxx
@@ -48,9 +48,11 @@
 #include <Debug/logstream.hxx>
 #include <Aircraft/aircraft.hxx>
 #include <Airports/simple.hxx>
+#include <Cockpit/panel.hxx>
 #include <FDM/flight.hxx>
 #include <Main/options.hxx>
 #include <Main/fg_init.hxx>
+#include <Main/views.hxx>
 #include <Time/fg_time.hxx>
 
 #include "gui.h"
@@ -114,7 +116,17 @@ void guiGetMouse(int *x, int *y)
 
 void reInit(puObject *cb)
 {
+    FGView *v = &current_view;
     fgReInitSubsystems();
+    if ( current_options.get_panel_status() ) {
+       // this seems to be the only way to do this :-(
+       // problem is the viewport has been mucked with
+       //              current_options.toggle_panel();
+       //              current_options.toggle_panel();
+       xglViewport(0, 0 ,
+                   (GLint)(v->winWidth), (GLint)(v->winHeight) );
+       FGPanel::OurPanel->ReInit(0, 0, 1024, 768);
+    }
 }
 
 void guiToggleMenu(void)
@@ -124,7 +136,11 @@ void guiToggleMenu(void)
     hideMenuButton -> invokeCallback();
 }
        
-
+void guiTogglePanel(puObject *cb)
+{
+    current_options.toggle_panel();
+}
+       
 void MenuHideMenuCb(puObject *cb)
 {
     mainMenuBar -> hide  ();
@@ -133,34 +149,37 @@ void MenuHideMenuCb(puObject *cb)
 #if defined ( WIN32 ) || defined(__CYGWIN32__)
     glutSetCursor(GLUT_CURSOR_NONE);
 #else  // I guess this is what we want to do ??
-    // puHideCursor(); // does not work with VooDoo
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+    glutWarpPointer( glutGet(GLUT_SCREEN_WIDTH), glutGet(GLUT_SCREEN_HEIGHT));
+#endif
 #endif
 }
 
 void hideMenuCb (puObject *cb)
 {
-    if (cb -> getValue () )
-       {
-           mainMenuBar -> reveal();
-           // printf("Showing Menu\n");
-           hideMenuButton -> setLegend ("Hide Menu");
+    if (cb -> getValue () ) {
+       mainMenuBar -> reveal();
+       // printf("Showing Menu\n");
+       hideMenuButton -> setLegend ("Hide Menu");
 #if defined ( WIN32 ) || defined(__CYGWIN32__)
-           glutSetCursor(GLUT_CURSOR_INHERIT);
+       glutSetCursor(GLUT_CURSOR_INHERIT);
 #else  // I guess this is what we want to do ??
-           //    puShowCursor(); // does not work with VooDoo
+       glutWarpPointer( glutGet(GLUT_SCREEN_WIDTH)/2, 
+                        glutGet(GLUT_SCREEN_HEIGHT)/2 );
 #endif
-       }
-    else
-       {
-           mainMenuBar -> hide  ();
-           // printf("Hiding Menu\n");
-           hideMenuButton -> setLegend ("Show Menu");
+    } else{
+       mainMenuBar -> hide  ();
+       // printf("Hiding Menu\n");
+       hideMenuButton -> setLegend ("Show Menu");
 #if defined ( WIN32 ) || defined(__CYGWIN32__)
-           glutSetCursor(GLUT_CURSOR_NONE);
+       glutSetCursor(GLUT_CURSOR_NONE);
 #else  // I guess this is what we want to do ??
-           //    puHideCursor(); // does not work with VooDoo
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+       glutWarpPointer( glutGet(GLUT_SCREEN_WIDTH), 
+                        glutGet(GLUT_SCREEN_HEIGHT));
 #endif
-       }
+#endif
+    }
 }
 
 void goodBye(puObject *)
@@ -191,7 +210,7 @@ void goAwayCb (puObject *me)
     dialogBox = NULL;
 }
 
-void mkDialog (char *txt)
+void mkDialog (const char *txt)
 {
     dialogBox = new puDialogBox (150, 50);
     {
@@ -301,7 +320,18 @@ static void validateApt (puObject *inpApt)
 void AptDialog_Cancel(puObject *)
 {
     FGTime *t = FGTime::cur_time_params;
+    FGView *v = &current_view;
        
+    if ( current_options.get_panel_status() ) {
+       // this seems to be the only way to do this :-(
+       // problem is the viewport has been mucked with
+       //              current_options.toggle_panel();
+       //              current_options.toggle_panel();
+       xglViewport(0, 0 ,
+                   (GLint)(v->winWidth), (GLint)(v->winHeight) );
+       FGPanel::OurPanel->ReInit(0, 0, 1024, 768);
+    }
+
     delete AptDialogResetButton;
     AptDialogResetButton = NULL;
 
@@ -391,30 +421,41 @@ void NewAirportInit(puObject *cb)
 /* -----------------------------------------------------------------------
    The menu stuff 
    ---------------------------------------------------------------------*/
-char *fileSubmenu        [] = {
+char *fileSubmenu               [] = {
     "Exit", "Close", "---------", "Print", "---------", "Save", "Reset", NULL };
-char *editSubmenu        [] = {
+puCallback fileSubmenuCb        [] = {
+    goodBye, MenuHideMenuCb, NULL, notCb, NULL, notCb, reInit, NULL};
+       
+char *editSubmenu               [] = {
     "Edit text", NULL };
-char *viewSubmenu        [] = {
-    "Cockpit View > ", "View >","------------", "View options...", NULL };
-char *aircraftSubmenu    [] = {
+puCallback editSubmenuCb        [] = {
+    notCb, NULL };
+       
+char *viewSubmenu               [] = {
+    "Cockpit View > ", "View >","------------", "Toggle Panel...", NULL };
+puCallback viewSubmenuCb        [] = {
+    notCb, notCb, NULL, guiTogglePanel, NULL };
+       
+char *aircraftSubmenu           [] = {
     "Autopilot ...", "Engine ...", "Navigation", "Communication", NULL};
-char *environmentSubmenu [] = {
+puCallback aircraftSubmenuCb    [] = {
+    fgAPAdjust, notCb, notCb, notCb, NULL };
+
+char *environmentSubmenu        [] = {
     "Airport", "Terrain", "Weather", NULL};
-char *optionsSubmenu     [] = {
+puCallback environmentSubmenuCb [] = {
+    NewAirportInit, notCb, notCb, NULL };
+
+char *optionsSubmenu            [] = {
     "Preferences", "Realism & Reliablity...", NULL};
-char *helpSubmenu        [] = {
-    "About...", "Help", NULL };
+puCallback optionsSubmenuCb     [] = {
+    notCb, notCb, NULL};
 
-puCallback fileSubmenuCb        [] = { goodBye, MenuHideMenuCb, NULL, notCb, NULL, notCb, reInit, NULL};
-puCallback editSubmenuCb        [] = { notCb, NULL };
-puCallback viewSubmenuCb        [] = { notCb, notCb, NULL, notCb, NULL };
-puCallback aircraftSubmenuCb    [] = { fgAPAdjust, notCb, notCb, notCb, NULL };
-puCallback environmentSubmenuCb [] = { NewAirportInit, notCb, notCb, NULL };
-puCallback optionsSubmenuCb     [] = { notCb, notCb, NULL};
-puCallback helpSubmenuCb        [] = { notCb, helpCb, NULL };
+char *helpSubmenu               [] = {
+    "About...", "Help", NULL };
+puCallback helpSubmenuCb        [] = {
+    notCb, helpCb, NULL };
 
- 
 
 /* -------------------------------------------------------------------------
    init the gui

diff --git a/Simulator/GUI/gui.h b/Simulator/GUI/gui.h
index dcc3e9463023c74c9b41c9f0151331cde83e6d44..f5e6326b067cffb9daa9b2aca654f0221578ec48 100644 (file)
--- a/Simulator/GUI/gui.h
+++ b/Simulator/GUI/gui.h
@@ -31,8 +31,6 @@ extern void guiMotionFunc ( int x, int y );
 extern void guiMouseFunc(int button, int updown, int x, int y);
 extern void guiInit();
 extern void guiToggleMenu(void);
-extern void mkDialog (char *txt);
-
-extern void mkDialog (char *txt);
+void mkDialog (const char *txt);
 
 #endif // _GUI_H_

diff --git a/Simulator/Main/GLUTkey.cxx b/Simulator/Main/GLUTkey.cxx
index ee9d11543335f98e794cc950b73ef7466047aea0..ba09d610b563f7a23c1e47f622c3f20088d238fd 100644 (file)
--- a/Simulator/Main/GLUTkey.cxx
+++ b/Simulator/Main/GLUTkey.cxx
@@ -144,6 +144,9 @@ void GLUTkey(unsigned char k, int x, int y) {
            t->adjust_warp(-60);
            local_update_sky_and_lighting_params();
            return;
+       case 80: // P key
+               current_options.toggle_panel();
+               break;
        case 84: // T key
            t->adjust_warp_delta(-30);
            local_update_sky_and_lighting_params();

diff --git a/Simulator/Main/GLUTmain.cxx b/Simulator/Main/GLUTmain.cxx
index cc2b16fc1e06e81cdd93d1438d0151e6ea7e8bfd..215f8181864318402503d71cec9f3aab292b0c78 100644 (file)
--- a/Simulator/Main/GLUTmain.cxx
+++ b/Simulator/Main/GLUTmain.cxx
@@ -803,9 +803,9 @@ static void fgIdleFunction ( void ) {
     }
 }
 
-
+// options.cxx needs to see this for toggle_panel()
 // Handle new window size or exposure
-static void fgReshape( int width, int height ) {
+void fgReshape( int width, int height ) {
     // Do this so we can call fgReshape(0,0) ourselves without having
     // to know what the values of width & height are.
     if ( (height > 0) && (width > 0) ) {
@@ -859,7 +859,7 @@ int fgGlutInit( int *argc, char **argv ) {
     } else {
        // Open the cool new 'game mode' window
        char game_mode_str[256];
-       sprintf( game_mode_str, "width=%d height=%d bpp=16",
+       sprintf( game_mode_str, "width=%d height=%d bpp=32",
                 current_options.get_xsize(),
                 current_options.get_ysize() );
 

diff --git a/Simulator/Main/options.cxx b/Simulator/Main/options.cxx
index 46aed141447259e310ea32196b1007ed70dcc009..a9477ac25589936f9328ae3458641aca70027363 100644 (file)
--- a/Simulator/Main/options.cxx
+++ b/Simulator/Main/options.cxx
@@ -38,18 +38,22 @@ bool global_fullscreen = true;
 
 #include STL_STRING
 
+#include <Include/fg_constants.h>
+#include <Include/general.hxx>
+#include <Cockpit/cockpit.hxx>
 #include <Debug/logstream.hxx>
-#include <Misc/fgstream.hxx>
 #include <FDM/flight.hxx>
-#include <Include/fg_constants.h>
+#include <Misc/fgstream.hxx>
 #include <Time/fg_time.hxx>
-#include <Main/options.hxx>
 
+#include "options.hxx"
 #include "fg_serial.hxx"
 
 FG_USING_STD(string);
 FG_USING_NAMESPACE(std);
 
+// from GLUTmain.cxx
+extern void fgReshape( int width, int height );
 
 inline double
 atof( const string& str )
@@ -203,6 +207,23 @@ fgOPTIONS::fgOPTIONS() :
                              port_options_list.end() );
 }
 
+void 
+fgOPTIONS::toggle_panel() {
+       
+    if( panel_status ) {
+       panel_status = false;
+    } else {
+       panel_status = true;
+    }
+    if ( panel_status ) {
+       if( FGPanel::OurPanel == 0)
+           new FGPanel;
+       fov *= 0.4232;
+    } else {
+       fov *= (1.0 /0.4232);
+    }
+    fgReshape( xsize, ysize);
+}
 
 double
 fgOPTIONS::parse_time(const string& time_in) {

diff --git a/Simulator/Main/options.hxx b/Simulator/Main/options.hxx
index 90b4e69eabdabdaa1e7bbd1ab148c76d5d16c0d3..fa4c5f497c1bdd9cdc7b8a25afb4c410f279dba8 100644 (file)
--- a/Simulator/Main/options.hxx
+++ b/Simulator/Main/options.hxx
@@ -227,6 +227,7 @@ public:
            xglHint ( GL_FOG_HINT, GL_FASTEST );
        }
     }
+    void toggle_panel();
     inline void set_xsize( int x ) { xsize= x; }
     inline void set_ysize( int y ) { xsize= y; }