src/Cockpit/panel.cxx

   1 //  panel.cxx - default, 2D single-engine prop instrument panel
   2 //
   3 //  Written by David Megginson, started January 2000.
   4 //
   5 //  This program is free software; you can redistribute it and/or
   6 //  modify it under the terms of the GNU General Public License as
   7 //  published by the Free Software Foundation; either version 2 of the
   8 //  License, or (at your option) any later version.
   9 //
  10 //  This program is distributed in the hope that it will be useful, but
  11 //  WITHOUT ANY WARRANTY; without even the implied warranty of
  12 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 //  General Public License for more details.
  14 //
  15 //  You should have received a copy of the GNU General Public License
  16 //  along with this program; if not, write to the Free Software
  17 //  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 //
  19 //  $Id$
  20
  21 #ifdef HAVE_CONFIG_H
  22 #  include <config.h>
  23 #endif
  24
  25 #ifdef HAVE_WINDOWS_H
  26 #  include <windows.h>
  27 #endif
  28
  29 #include <stdio.h>      // sprintf
  30 #include <string.h>
  31
  32 #include <plib/ssg.h>
  33 #include <plib/fnt.h>
  34
  35 #include <simgear/debug/logstream.hxx>
  36 #include <simgear/misc/sg_path.hxx>
  37
  38 #include <Main/globals.hxx>
  39 #include <Main/fg_props.hxx>
  40 #include <Main/viewmgr.hxx>
  41 #include <Objects/texload.h>
  42 #include <Time/light.hxx>
  43
  44 #include "hud.hxx"
  45 #include "panel.hxx"
  46
  47 #define WIN_X 0
  48 #define WIN_Y 0
  49 #define WIN_W 1024
  50 #define WIN_H 768
  51
  52 #if defined( NONE ) && defined( _MSC_VER )
  53 #  pragma message( "A sloppy coder has defined NONE as a macro!!!" )
  54 #  undef NONE
  55 #elif defined( NONE )
  56 #  pragma warn A sloppy coder has defined NONE as a macro!!!
  57 #  undef NONE
  58 #endif
  59
  60 \f
  61 ////////////////////////////////////////////////////////////////////////
  62 // Local functions.
  63 ////////////////////////////////////////////////////////////////////////
  64
  65
  66 /**
  67  * Calculate the aspect adjustment for the panel.
  68  */
  69 static float
  70 get_aspect_adjust (int xsize, int ysize)
  71 {
  72   float ideal_aspect = float(WIN_W) / float(WIN_H);
  73   float real_aspect = float(xsize) / float(ysize);
  74   return (real_aspect / ideal_aspect);
  75 }
  76
  77
  78 \f
  79 ////////////////////////////////////////////////////////////////////////
  80 // Global functions.
  81 ////////////////////////////////////////////////////////////////////////
  82
  83 bool
  84 fgPanelVisible ()
  85 {
  86     return (fgGetBool("/sim/virtual-cockpit") ||
  87             ((current_panel != 0) &&
  88              (current_panel->getVisibility()) &&
  89              (globals->get_viewmgr()->get_current() == 0) &&
  90              (globals->get_current_view()->get_view_offset() == 0.0)));
  91 }
  92
  93
  94 \f
  95 ////////////////////////////////////////////////////////////////////////
  96 // Implementation of FGTextureManager.
  97 ////////////////////////////////////////////////////////////////////////
  98
  99 map<string,ssgTexture *> FGTextureManager::_textureMap;
 100
 101 ssgTexture *
 102 FGTextureManager::createTexture (const string &relativePath)
 103 {
 104   ssgTexture * texture = _textureMap[relativePath];
 105   if (texture == 0) {
 106     SG_LOG( SG_COCKPIT, SG_DEBUG,
 107             "Texture " << relativePath << " does not yet exist" );
 108     SGPath tpath(globals->get_fg_root());
 109     tpath.append(relativePath);
 110     texture = new ssgTexture((char *)tpath.c_str(), false, false);
 111     _textureMap[relativePath] = texture;
 112     if (_textureMap[relativePath] == 0)
 113       SG_LOG( SG_COCKPIT, SG_ALERT, "Texture *still* doesn't exist" );
 114     SG_LOG( SG_COCKPIT, SG_DEBUG, "Created texture " << relativePath
 115             << " handle=" << texture->getHandle() );
 116   }
 117
 118   return texture;
 119 }
 120
 121
 122
 123 \f
 124 ////////////////////////////////////////////////////////////////////////
 125 // Implementation of FGCropped Texture.
 126 ////////////////////////////////////////////////////////////////////////
 127
 128
 129 FGCroppedTexture::FGCroppedTexture ()
 130   : _path(""), _texture(0),
 131     _minX(0.0), _minY(0.0), _maxX(1.0), _maxY(1.0)
 132 {
 133 }
 134
 135
 136 FGCroppedTexture::FGCroppedTexture (const string &path,
 137                                     float minX, float minY,
 138                                     float maxX, float maxY)
 139   : _path(path), _texture(0),
 140     _minX(minX), _minY(minY), _maxX(maxX), _maxY(maxY)
 141 {
 142 }
 143
 144
 145 FGCroppedTexture::~FGCroppedTexture ()
 146 {
 147 }
 148
 149
 150 ssgTexture *
 151 FGCroppedTexture::getTexture ()
 152 {
 153   if (_texture == 0) {
 154     _texture = FGTextureManager::createTexture(_path);
 155   }
 156   return _texture;
 157 }
 158
 159
 160 \f
 161 ////////////////////////////////////////////////////////////////////////
 162 // Implementation of FGPanel.
 163 ////////////////////////////////////////////////////////////////////////
 164
 165 FGPanel * current_panel = NULL;
 166 static fntRenderer text_renderer;
 167 static fntTexFont *default_font;
 168 static fntTexFont *led_font;
 169
 170 /**
 171  * Constructor.
 172  */
 173 FGPanel::FGPanel ()
 174   : _mouseDown(false),
 175     _mouseInstrument(0),
 176     _width(WIN_W), _height(int(WIN_H * 0.5768 + 1)),
 177     _x_offset(0), _y_offset(0), _view_height(int(WIN_H * 0.4232)),
 178     _bound(false),
 179     _jitter(0.0),
 180     _xsize_node(fgGetNode("/sim/startup/xsize", true)),
 181     _ysize_node(fgGetNode("/sim/startup/ysize", true))
 182 {
 183   setVisibility(fgPanelVisible());
 184 }
 185
 186
 187 /**
 188  * Destructor.
 189  */
 190 FGPanel::~FGPanel ()
 191 {
 192   if (_bound)
 193     unbind();
 194   for (instrument_list_type::iterator it = _instruments.begin();
 195        it != _instruments.end();
 196        it++) {
 197     delete *it;
 198     *it = 0;
 199   }
 200 }
 201
 202
 203 /**
 204  * Add an instrument to the panel.
 205  */
 206 void
 207 FGPanel::addInstrument (FGPanelInstrument * instrument)
 208 {
 209   _instruments.push_back(instrument);
 210 }
 211
 212
 213 /**
 214  * Initialize the panel.
 215  */
 216 void
 217 FGPanel::init ()
 218 {
 219     SGPath base_path;
 220     char* envp = ::getenv( "FG_FONTS" );
 221     if ( envp != NULL ) {
 222         base_path.set( envp );
 223     } else {
 224         base_path.set( globals->get_fg_root() );
 225         base_path.append( "Fonts" );
 226     }
 227
 228     SGPath fntpath;
 229
 230     // Install the default font
 231     fntpath = base_path;
 232     fntpath.append( "typewriter.txf" );
 233     default_font = new fntTexFont ;
 234     default_font -> load ( (char *)fntpath.c_str() ) ;
 235
 236     // Install the LED font
 237     fntpath = base_path;
 238     fntpath.append( "led.txf" );
 239     led_font = new fntTexFont ;
 240     led_font -> load ( (char *)fntpath.c_str() ) ;
 241 }
 242
 243
 244 /**
 245  * Bind panel properties.
 246  */
 247 void
 248 FGPanel::bind ()
 249 {
 250   fgTie("/sim/panel/visibility", &_visibility);
 251   fgSetArchivable("/sim/panel/visibility");
 252   fgTie("/sim/panel/x-offset", &_x_offset);
 253   fgSetArchivable("/sim/panel/x-offset");
 254   fgTie("/sim/panel/y-offset", &_y_offset);
 255   fgSetArchivable("/sim/panel/y-offset");
 256   fgTie("/sim/panel/jitter", &_jitter);
 257   fgSetArchivable("/sim/panel/jitter");
 258   _bound = true;
 259 }
 260
 261
 262 /**
 263  * Unbind panel properties.
 264  */
 265 void
 266 FGPanel::unbind ()
 267 {
 268   fgUntie("/sim/panel/visibility");
 269   fgUntie("/sim/panel/x-offset");
 270   fgUntie("/sim/panel/y-offset");
 271   _bound = false;
 272 }
 273
 274
 275 /**
 276  * Update the panel.
 277  */
 278 void
 279 FGPanel::update (int dt)
 280 {
 281                                 // Do nothing if the panel isn't visible.
 282     if ( !fgPanelVisible() ) {
 283         return;
 284     }
 285
 286                                 // If the mouse is down, do something
 287     if (_mouseDown) {
 288         _mouseDelay--;
 289         if (_mouseDelay < 0) {
 290             _mouseInstrument->doMouseAction(_mouseButton, _mouseX, _mouseY);
 291             _mouseDelay = 2;
 292         }
 293     }
 294
 295                                 // Now, draw the panel
 296     float aspect_adjust = get_aspect_adjust(_xsize_node->getIntValue(),
 297                                             _ysize_node->getIntValue());
 298     if (aspect_adjust <1.0)
 299         update(WIN_X, int(WIN_W * aspect_adjust), WIN_Y, WIN_H);
 300     else
 301         update(WIN_X, WIN_W, WIN_Y, int(WIN_H / aspect_adjust));
 302 }
 303
 304
 305 void
 306 FGPanel::update (GLfloat winx, GLfloat winw, GLfloat winy, GLfloat winh)
 307 {
 308                                 // Calculate accelerations
 309                                 // and jiggle the panel accordingly
 310                                 // The factors and bounds are just
 311                                 // initial guesses; using sqrt smooths
 312                                 // out the spikes.
 313   double x_offset = _x_offset;
 314   double y_offset = _y_offset;
 315
 316   if (_jitter != 0.0) {
 317     double a_x_pilot = current_aircraft.fdm_state->get_A_X_pilot();
 318     double a_y_pilot = current_aircraft.fdm_state->get_A_Y_pilot();
 319     double a_z_pilot = current_aircraft.fdm_state->get_A_Z_pilot();
 320
 321     double a_zx_pilot = a_z_pilot - a_x_pilot;
 322
 323     int x_adjust = int(sqrt(fabs(a_y_pilot) * _jitter)) *
 324                    (a_y_pilot < 0 ? -1 : 1);
 325     int y_adjust = int(sqrt(fabs(a_zx_pilot) * _jitter)) *
 326                    (a_zx_pilot < 0 ? -1 : 1);
 327
 328                                 // adjustments in screen coordinates
 329     x_offset += x_adjust;
 330     y_offset += y_adjust;
 331   }
 332
 333   if(fgGetBool("/sim/virtual-cockpit")) {
 334       setupVirtualCockpit();
 335   } else {
 336       glMatrixMode(GL_PROJECTION);
 337       glPushMatrix();
 338       glLoadIdentity();
 339       gluOrtho2D(winx, winx + winw, winy, winy + winh); /* right side up */
 340       // gluOrtho2D(winx + winw, winx, winy + winh, winy); /* up side down */
 341
 342       glMatrixMode(GL_MODELVIEW);
 343       glPushMatrix();
 344       glLoadIdentity();
 345
 346       glTranslated(x_offset, y_offset, 0);
 347   }
 348
 349   // Draw the background
 350   glEnable(GL_TEXTURE_2D);
 351   glDisable(GL_LIGHTING);
 352   glEnable(GL_BLEND);
 353   glEnable(GL_ALPHA_TEST);
 354   glEnable(GL_COLOR_MATERIAL);
 355   // glColor4f(1.0, 1.0, 1.0, 1.0);
 356   if ( cur_light_params.sun_angle * SGD_RADIANS_TO_DEGREES < 95.0 ) {
 357       glColor4fv( cur_light_params.scene_diffuse );
 358   } else {
 359       glColor4f(0.7, 0.2, 0.2, 1.0);
 360   }
 361   if (_bg != 0) {
 362     glBindTexture(GL_TEXTURE_2D, _bg->getHandle());
 363     // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 364     // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 365     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 366     glBegin(GL_POLYGON);
 367     glTexCoord2f(0.0, 0.0); glVertex3f(WIN_X, WIN_Y, 0);
 368     glTexCoord2f(1.0, 0.0); glVertex3f(WIN_X + _width, WIN_Y, 0);
 369     glTexCoord2f(1.0, 1.0); glVertex3f(WIN_X + _width, WIN_Y + _height, 0);
 370     glTexCoord2f(0.0, 1.0); glVertex3f(WIN_X, WIN_Y + _height, 0);
 371     glEnd();
 372   } else {
 373     for (int i = 0; i < 4; i ++) {
 374       // top row of textures...(1,3,5,7)
 375       glBindTexture(GL_TEXTURE_2D, _mbg[i*2]->getHandle());
 376       glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 377       glBegin(GL_POLYGON);
 378       glTexCoord2f(0.0, 0.0); glVertex3f(WIN_X + (_width/4) * i, WIN_Y + (_height/2), 0);
 379       glTexCoord2f(1.0, 0.0); glVertex3f(WIN_X + (_width/4) * (i+1), WIN_Y + (_height/2), 0);
 380       glTexCoord2f(1.0, 1.0); glVertex3f(WIN_X + (_width/4) * (i+1), WIN_Y + _height, 0);
 381       glTexCoord2f(0.0, 1.0); glVertex3f(WIN_X + (_width/4) * i, WIN_Y + _height, 0);
 382       glEnd();
 383       // bottom row of textures...(2,4,6,8)
 384       glBindTexture(GL_TEXTURE_2D, _mbg[(i*2)+1]->getHandle());
 385       glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 386       glBegin(GL_POLYGON);
 387       glTexCoord2f(0.0, 0.0); glVertex3f(WIN_X + (_width/4) * i, WIN_Y, 0);
 388       glTexCoord2f(1.0, 0.0); glVertex3f(WIN_X + (_width/4) * (i+1), WIN_Y, 0);
 389       glTexCoord2f(1.0, 1.0); glVertex3f(WIN_X + (_width/4) * (i+1), WIN_Y + (_height/2), 0);
 390       glTexCoord2f(0.0, 1.0); glVertex3f(WIN_X + (_width/4) * i, WIN_Y + (_height/2), 0);
 391       glEnd();
 392     }
 393
 394   }
 395
 396                                 // Draw the instruments.
 397   instrument_list_type::const_iterator current = _instruments.begin();
 398   instrument_list_type::const_iterator end = _instruments.end();
 399
 400   for ( ; current != end; current++) {
 401     FGPanelInstrument * instr = *current;
 402     glPushMatrix();
 403     glTranslated(instr->getXPos(), instr->getYPos(), 0);
 404     instr->draw();
 405     glPopMatrix();
 406   }
 407
 408   if(fgGetBool("/sim/virtual-cockpit")) {
 409       cleanupVirtualCockpit();
 410   } else {
 411       glMatrixMode(GL_PROJECTION);
 412       glPopMatrix();
 413       glMatrixMode(GL_MODELVIEW);
 414       glPopMatrix();
 415   }
 416
 417   ssgForceBasicState();
 418   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 419 }
 420
 421 void
 422 FGPanel::setupVirtualCockpit()
 423 {
 424     int i;
 425     FGViewer* view = globals->get_current_view();
 426
 427     // Generate corners for the panel quad.  Put the top edge of the
 428     // panel 1m in and 6 degrees down from the forward direction, and
 429     // make the whole thing 60 degrees wide.  In principle, these
 430     // should be settable per-panel, so that you can have lots of
 431     // panel objects plastered about the cockpit in realistic
 432     // positions and orientations.
 433     float a[3], b[3], c[3];
 434     float pw = tan(30*SGD_DEGREES_TO_RADIANS);
 435     float ph = 2 * pw * (float)_height/(float)_width;
 436     float ptop = -tan(6*SGD_DEGREES_TO_RADIANS);
 437     a[0] = -pw; a[1] = ptop-ph; a[2] = -1; // bottom left
 438     b[0] =  pw; b[1] = ptop-ph; b[2] = -1; // bottom right
 439     c[0] = -pw; c[1] = ptop;    c[2] = -1; // top left
 440
 441     // A standard projection, in meters, with especially close clip
 442     // planes.
 443     glMatrixMode(GL_PROJECTION);
 444     glPushMatrix();
 445     glLoadIdentity();
 446     gluPerspective(view->get_v_fov(), 1/view->get_aspect_ratio(),
 447                    0.01, 100);
 448
 449     glMatrixMode(GL_MODELVIEW);
 450     glPushMatrix();
 451     glLoadIdentity();
 452
 453     // Generate a "look at" matrix using OpenGL (!) coordinate
 454     // conventions.
 455     float lookat[3];
 456     float pitch = view->get_view_tilt();
 457     float rot = view->get_view_offset();
 458     lookat[0] = -sin(rot);
 459     lookat[1] = sin(pitch) / cos(pitch);
 460     lookat[2] = -cos(rot);
 461     if(fabs(lookat[1]) > 9999) lookat[1] = 9999; // FPU sanity
 462     gluLookAt(0, 0, 0, lookat[0], lookat[1], lookat[2], 0, 1, 0);
 463
 464     // Translate the origin to the location of the panel quad
 465     glTranslatef(a[0], a[1], a[2]);
 466
 467     // Generate a matrix to translate unit square coordinates from the
 468     // panel to real world coordinates.  Use a transposed basis for
 469     // the panel quad.  Note: this matrix is relatively expensive to
 470     // compute, and is invariant.  Consider precomputing and storing
 471     // it.  Also, consider using the plib vector math routines, so the
 472     // reuse junkies don't yell at me.  (Fine, I hard-coded a cross
 473     // product.  Just shoot me and be done with it.)
 474     float u[3], v[3], w[3], m[16];
 475     for(i=0; i<3; i++) u[i] = b[i] - a[i]; // U = B - A
 476     for(i=0; i<3; i++) v[i] = c[i] - a[i]; // V = C - A
 477     w[0] = u[1]*v[2] - v[1]*u[2];          // W = U x V
 478     w[1] = u[2]*v[0] - v[2]*u[0];
 479     w[2] = u[0]*v[1] - v[0]*u[1];
 480
 481     m[0] = u[0]; m[4] = v[0]; m[8]  = w[0]; m[12] = 0; //     |Ux Vx Wx|
 482     m[1] = u[1]; m[5] = v[1]; m[9]  = w[1]; m[13] = 0; // m = |Uy Vy Wy|
 483     m[2] = u[2]; m[6] = v[2]; m[10] = w[2]; m[14] = 0; //     |Uz Vz Wz|
 484     m[3] = 0;    m[7] = 0;    m[11] = 0;    m[15] = 1;
 485     glMultMatrixf(m);
 486
 487     // Finally, a scaling factor to map the panel's width and height
 488     // to the unit square.
 489     glScalef(1./_width, 1./_height, 1);
 490
 491     // Now, turn off the Z buffer.  The panel code doesn't need
 492     // it, and we're using different clip planes anyway (meaning we
 493     // can't share it without glDepthRange() hackery or much
 494     // framebuffer bandwidth wasteage)
 495     glDisable(GL_DEPTH_TEST);
 496 }
 497
 498 void
 499 FGPanel::cleanupVirtualCockpit()
 500 {
 501     glMatrixMode(GL_PROJECTION);
 502     glPopMatrix();
 503     glMatrixMode(GL_MODELVIEW);
 504     glPopMatrix();
 505     glEnable(GL_DEPTH_TEST);
 506 }
 507
 508
 509 /**
 510  * Set the panel's visibility.
 511  */
 512 void
 513 FGPanel::setVisibility (bool visibility)
 514 {
 515   _visibility = visibility;
 516 }
 517
 518
 519 /**
 520  * Return true if the panel is visible.
 521  */
 522 bool
 523 FGPanel::getVisibility () const
 524 {
 525   return _visibility;
 526 }
 527
 528
 529 /**
 530  * Set the panel's background texture.
 531  */
 532 void
 533 FGPanel::setBackground (ssgTexture * texture)
 534 {
 535   _bg = texture;
 536 }
 537
 538 /**
 539  * Set the panel's multiple background textures.
 540  */
 541 void
 542 FGPanel::setMultiBackground (ssgTexture * texture, int idx)
 543 {
 544   _bg = 0;
 545   _mbg[idx] = texture;
 546 }
 547
 548 /**
 549  * Set the panel's x-offset.
 550  */
 551 void
 552 FGPanel::setXOffset (int offset)
 553 {
 554   if (offset <= 0 && offset >= -_width + WIN_W)
 555     _x_offset = offset;
 556 }
 557
 558
 559 /**
 560  * Set the panel's y-offset.
 561  */
 562 void
 563 FGPanel::setYOffset (int offset)
 564 {
 565   if (offset <= 0 && offset >= -_height)
 566     _y_offset = offset;
 567 }
 568
 569
 570 /**
 571  * Perform a mouse action.
 572  */
 573 bool
 574 FGPanel::doMouseAction (int button, int updown, int x, int y)
 575 {
 576                                 // FIXME: this same code appears in update()
 577   int xsize = _xsize_node->getIntValue();
 578   int ysize = _ysize_node->getIntValue();
 579   float aspect_adjust = get_aspect_adjust(xsize, ysize);
 580
 581                                 // Note a released button and return
 582   // cerr << "Doing mouse action\n";
 583   if (updown == 1) {
 584     _mouseDown = false;
 585     _mouseInstrument = 0;
 586     return true;
 587   }
 588
 589                                 // Scale for the real window size.
 590   if (aspect_adjust < 1.0) {
 591     x = int(((float)x / xsize) * WIN_W * aspect_adjust);
 592     y = int(WIN_H - ((float(y) / ysize) * WIN_H));
 593   } else {
 594     x = int(((float)x / xsize) * WIN_W);
 595     y = int((WIN_H - ((float(y) / ysize) * WIN_H)) / aspect_adjust);
 596   }
 597
 598                                 // Adjust for offsets.
 599   x -= _x_offset;
 600   y -= _y_offset;
 601
 602                                 // Search for a matching instrument.
 603   for (int i = 0; i < (int)_instruments.size(); i++) {
 604     FGPanelInstrument *inst = _instruments[i];
 605     int ix = inst->getXPos();
 606     int iy = inst->getYPos();
 607     int iw = inst->getWidth() / 2;
 608     int ih = inst->getHeight() / 2;
 609     if (x >= ix - iw && x < ix + iw && y >= iy - ih && y < iy + ih) {
 610       _mouseDown = true;
 611       _mouseDelay = 20;
 612       _mouseInstrument = inst;
 613       _mouseButton = button;
 614       _mouseX = x - ix;
 615       _mouseY = y - iy;
 616                                 // Always do the action once.
 617       _mouseInstrument->doMouseAction(_mouseButton, _mouseX, _mouseY);
 618       return true;
 619     }
 620   }
 621   return false;
 622 }
 623
 624
 625 \f
 626 ////////////////////////////////////////////////////////////////////////.
 627 // Implementation of FGPanelAction.
 628 ////////////////////////////////////////////////////////////////////////
 629
 630 FGPanelAction::FGPanelAction ()
 631 {
 632 }
 633
 634 FGPanelAction::FGPanelAction (int button, int x, int y, int w, int h)
 635   : _button(button), _x(x), _y(y), _w(w), _h(h)
 636 {
 637   for (unsigned int i = 0; i < _bindings.size(); i++)
 638     delete _bindings[i];
 639 }
 640
 641 FGPanelAction::~FGPanelAction ()
 642 {
 643 }
 644
 645 void
 646 FGPanelAction::addBinding (FGBinding * binding)
 647 {
 648   _bindings.push_back(binding);
 649 }
 650
 651 void
 652 FGPanelAction::doAction ()
 653 {
 654   if (test()) {
 655     int nBindings = _bindings.size();
 656     for (int i = 0; i < nBindings; i++) {
 657       _bindings[i]->fire();
 658     }
 659   }
 660 }
 661
 662
 663 \f
 664 ////////////////////////////////////////////////////////////////////////
 665 // Implementation of FGPanelTransformation.
 666 ////////////////////////////////////////////////////////////////////////
 667
 668 FGPanelTransformation::FGPanelTransformation ()
 669   : table(0)
 670 {
 671 }
 672
 673 FGPanelTransformation::~FGPanelTransformation ()
 674 {
 675   delete table;
 676 }
 677
 678
 679 \f
 680 ////////////////////////////////////////////////////////////////////////
 681 // Implementation of FGPanelInstrument.
 682 ////////////////////////////////////////////////////////////////////////
 683
 684
 685 FGPanelInstrument::FGPanelInstrument ()
 686 {
 687   setPosition(0, 0);
 688   setSize(0, 0);
 689 }
 690
 691 FGPanelInstrument::FGPanelInstrument (int x, int y, int w, int h)
 692 {
 693   setPosition(x, y);
 694   setSize(w, h);
 695 }
 696
 697 FGPanelInstrument::~FGPanelInstrument ()
 698 {
 699   for (action_list_type::iterator it = _actions.begin();
 700        it != _actions.end();
 701        it++) {
 702     delete *it;
 703     *it = 0;
 704   }
 705 }
 706
 707 void
 708 FGPanelInstrument::setPosition (int x, int y)
 709 {
 710   _x = x;
 711   _y = y;
 712 }
 713
 714 void
 715 FGPanelInstrument::setSize (int w, int h)
 716 {
 717   _w = w;
 718   _h = h;
 719 }
 720
 721 int
 722 FGPanelInstrument::getXPos () const
 723 {
 724   return _x;
 725 }
 726
 727 int
 728 FGPanelInstrument::getYPos () const
 729 {
 730   return _y;
 731 }
 732
 733 int
 734 FGPanelInstrument::getWidth () const
 735 {
 736   return _w;
 737 }
 738
 739 int
 740 FGPanelInstrument::getHeight () const
 741 {
 742   return _h;
 743 }
 744
 745 void
 746 FGPanelInstrument::addAction (FGPanelAction * action)
 747 {
 748   _actions.push_back(action);
 749 }
 750
 751                                 // Coordinates relative to centre.
 752 bool
 753 FGPanelInstrument::doMouseAction (int button, int x, int y)
 754 {
 755   if (test()) {
 756     action_list_type::iterator it = _actions.begin();
 757     action_list_type::iterator last = _actions.end();
 758     for ( ; it != last; it++) {
 759       if ((*it)->inArea(button, x, y)) {
 760         (*it)->doAction();
 761         return true;
 762       }
 763     }
 764   }
 765   return false;
 766 }
 767
 768
 769 \f
 770 ////////////////////////////////////////////////////////////////////////
 771 // Implementation of FGLayeredInstrument.
 772 ////////////////////////////////////////////////////////////////////////
 773
 774 FGLayeredInstrument::FGLayeredInstrument (int x, int y, int w, int h)
 775   : FGPanelInstrument(x, y, w, h)
 776 {
 777 }
 778
 779 FGLayeredInstrument::~FGLayeredInstrument ()
 780 {
 781   for (layer_list::iterator it = _layers.begin(); it != _layers.end(); it++) {
 782     delete *it;
 783     *it = 0;
 784   }
 785 }
 786
 787 void
 788 FGLayeredInstrument::draw ()
 789 {
 790   if (test()) {
 791     for (int i = 0; i < (int)_layers.size(); i++) {
 792       glPushMatrix();
 793       if(!fgGetBool("/sim/virtual-cockpit"))
 794           glTranslatef(0.0, 0.0, (i / 100.0) + 0.1);
 795       _layers[i]->draw();
 796       glPopMatrix();
 797     }
 798   }
 799 }
 800
 801 int
 802 FGLayeredInstrument::addLayer (FGInstrumentLayer *layer)
 803 {
 804   int n = _layers.size();
 805   if (layer->getWidth() == -1) {
 806     layer->setWidth(getWidth());
 807   }
 808   if (layer->getHeight() == -1) {
 809     layer->setHeight(getHeight());
 810   }
 811   _layers.push_back(layer);
 812   return n;
 813 }
 814
 815 int
 816 FGLayeredInstrument::addLayer (FGCroppedTexture &texture,
 817                                int w, int h)
 818 {
 819   return addLayer(new FGTexturedLayer(texture, w, h));
 820 }
 821
 822 void
 823 FGLayeredInstrument::addTransformation (FGPanelTransformation * transformation)
 824 {
 825   int layer = _layers.size() - 1;
 826   _layers[layer]->addTransformation(transformation);
 827 }
 828
 829
 830 \f
 831 ////////////////////////////////////////////////////////////////////////
 832 // Implementation of FGInstrumentLayer.
 833 ////////////////////////////////////////////////////////////////////////
 834
 835 FGInstrumentLayer::FGInstrumentLayer (int w, int h)
 836   : _w(w),
 837     _h(h)
 838 {
 839 }
 840
 841 FGInstrumentLayer::~FGInstrumentLayer ()
 842 {
 843   for (transformation_list::iterator it = _transformations.begin();
 844        it != _transformations.end();
 845        it++) {
 846     delete *it;
 847     *it = 0;
 848   }
 849 }
 850
 851 void
 852 FGInstrumentLayer::transform () const
 853 {
 854   transformation_list::const_iterator it = _transformations.begin();
 855   transformation_list::const_iterator last = _transformations.end();
 856   while (it != last) {
 857     FGPanelTransformation *t = *it;
 858     if (t->test()) {
 859       float val = (t->node == 0 ? 0.0 : t->node->getFloatValue());
 860       if (val < t->min) {
 861         val = t->min;
 862       } else if (val > t->max) {
 863         val = t->max;
 864       }
 865       if(t->table==0) {
 866         val = val * t->factor + t->offset;
 867       } else {
 868         val = t->table->interpolate(val) * t->factor + t->offset;
 869       }
 870
 871       switch (t->type) {
 872       case FGPanelTransformation::XSHIFT:
 873         glTranslatef(val, 0.0, 0.0);
 874         break;
 875       case FGPanelTransformation::YSHIFT:
 876         glTranslatef(0.0, val, 0.0);
 877         break;
 878       case FGPanelTransformation::ROTATION:
 879         glRotatef(-val, 0.0, 0.0, 1.0);
 880         break;
 881       }
 882     }
 883     it++;
 884   }
 885 }
 886
 887 void
 888 FGInstrumentLayer::addTransformation (FGPanelTransformation * transformation)
 889 {
 890   _transformations.push_back(transformation);
 891 }
 892
 893
 894 \f
 895 ////////////////////////////////////////////////////////////////////////
 896 // Implementation of FGGroupLayer.
 897 ////////////////////////////////////////////////////////////////////////
 898
 899 FGGroupLayer::FGGroupLayer ()
 900 {
 901 }
 902
 903 FGGroupLayer::~FGGroupLayer ()
 904 {
 905   for (unsigned int i = 0; i < _layers.size(); i++)
 906     delete _layers[i];
 907 }
 908
 909 void
 910 FGGroupLayer::draw ()
 911 {
 912   if (test()) {
 913     int nLayers = _layers.size();
 914     for (int i = 0; i < nLayers; i++)
 915       _layers[i]->draw();
 916   }
 917 }
 918
 919 void
 920 FGGroupLayer::addLayer (FGInstrumentLayer * layer)
 921 {
 922   _layers.push_back(layer);
 923 }
 924
 925
 926 \f
 927 ////////////////////////////////////////////////////////////////////////
 928 // Implementation of FGTexturedLayer.
 929 ////////////////////////////////////////////////////////////////////////
 930
 931
 932 FGTexturedLayer::FGTexturedLayer (const FGCroppedTexture &texture, int w, int h)
 933   : FGInstrumentLayer(w, h)
 934 {
 935   setTexture(texture);
 936 }
 937
 938
 939 FGTexturedLayer::~FGTexturedLayer ()
 940 {
 941 }
 942
 943
 944 void
 945 FGTexturedLayer::draw ()
 946 {
 947   if (test()) {
 948     int w2 = _w / 2;
 949     int h2 = _h / 2;
 950
 951     transform();
 952     glBindTexture(GL_TEXTURE_2D, _texture.getTexture()->getHandle());
 953     glBegin(GL_POLYGON);
 954
 955                                 // From Curt: turn on the panel
 956                                 // lights after sundown.
 957     if ( cur_light_params.sun_angle * SGD_RADIANS_TO_DEGREES < 95.0 ) {
 958       glColor4fv( cur_light_params.scene_diffuse );
 959     } else {
 960       glColor4f(0.7, 0.2, 0.2, 1.0);
 961     }
 962
 963
 964     glTexCoord2f(_texture.getMinX(), _texture.getMinY()); glVertex2f(-w2, -h2);
 965     glTexCoord2f(_texture.getMaxX(), _texture.getMinY()); glVertex2f(w2, -h2);
 966     glTexCoord2f(_texture.getMaxX(), _texture.getMaxY()); glVertex2f(w2, h2);
 967     glTexCoord2f(_texture.getMinX(), _texture.getMaxY()); glVertex2f(-w2, h2);
 968     glEnd();
 969   }
 970 }
 971
 972
 973 \f
 974 ////////////////////////////////////////////////////////////////////////
 975 // Implementation of FGTextLayer.
 976 ////////////////////////////////////////////////////////////////////////
 977
 978 FGTextLayer::FGTextLayer (int w, int h)
 979   : FGInstrumentLayer(w, h), _pointSize(14.0), _font_name("default")
 980 {
 981   _then.stamp();
 982   _color[0] = _color[1] = _color[2] = 0.0;
 983   _color[3] = 1.0;
 984 }
 985
 986 FGTextLayer::~FGTextLayer ()
 987 {
 988   chunk_list::iterator it = _chunks.begin();
 989   chunk_list::iterator last = _chunks.end();
 990   for ( ; it != last; it++) {
 991     delete *it;
 992   }
 993 }
 994
 995 void
 996 FGTextLayer::draw ()
 997 {
 998   if (test()) {
 999     glPushMatrix();
1000     glColor4fv(_color);
1001     transform();
1002     if ( _font_name == "led" ) {
1003         text_renderer.setFont(led_font);
1004     } else {
1005         text_renderer.setFont(guiFntHandle);
1006     }
1007     text_renderer.setPointSize(_pointSize);
1008     text_renderer.begin();
1009     text_renderer.start3f(0, 0, 0);
1010
1011     _now.stamp();
1012     if (_now - _then > 100000) {
1013       recalc_value();
1014       _then = _now;
1015     }
1016     text_renderer.puts((char *)(_value.c_str()));
1017
1018     text_renderer.end();
1019     glColor4f(1.0, 1.0, 1.0, 1.0);      // FIXME
1020     glPopMatrix();
1021   }
1022 }
1023
1024 void
1025 FGTextLayer::addChunk (FGTextLayer::Chunk * chunk)
1026 {
1027   _chunks.push_back(chunk);
1028 }
1029
1030 void
1031 FGTextLayer::setColor (float r, float g, float b)
1032 {
1033   _color[0] = r;
1034   _color[1] = g;
1035   _color[2] = b;
1036   _color[3] = 1.0;
1037 }
1038
1039 void
1040 FGTextLayer::setPointSize (float size)
1041 {
1042   _pointSize = size;
1043 }
1044
1045 void
1046 FGTextLayer::setFontName(const string &name)
1047 {
1048   _font_name = name;
1049 }
1050
1051
1052 void
1053 FGTextLayer::setFont(fntFont * font)
1054 {
1055   text_renderer.setFont(font);
1056 }
1057
1058
1059 void
1060 FGTextLayer::recalc_value () const
1061 {
1062   _value = "";
1063   chunk_list::const_iterator it = _chunks.begin();
1064   chunk_list::const_iterator last = _chunks.end();
1065   for ( ; it != last; it++) {
1066     _value += (*it)->getValue();
1067   }
1068 }
1069
1070
1071 \f
1072 ////////////////////////////////////////////////////////////////////////
1073 // Implementation of FGTextLayer::Chunk.
1074 ////////////////////////////////////////////////////////////////////////
1075
1076 FGTextLayer::Chunk::Chunk (const string &text, const string &fmt)
1077   : _type(FGTextLayer::TEXT), _fmt(fmt)
1078 {
1079   _text = text;
1080   if (_fmt == "")
1081     _fmt = "%s";
1082 }
1083
1084 FGTextLayer::Chunk::Chunk (ChunkType type, const SGPropertyNode * node,
1085                            const string &fmt, float mult)
1086   : _type(type), _fmt(fmt), _mult(mult)
1087 {
1088   if (_fmt == "") {
1089     if (type == TEXT_VALUE)
1090       _fmt = "%s";
1091     else
1092       _fmt = "%.2f";
1093   }
1094   _node = node;
1095 }
1096
1097 const char *
1098 FGTextLayer::Chunk::getValue () const
1099 {
1100   if (test()) {
1101     switch (_type) {
1102     case TEXT:
1103       sprintf(_buf, _fmt.c_str(), _text.c_str());
1104       return _buf;
1105     case TEXT_VALUE:
1106       sprintf(_buf, _fmt.c_str(), _node->getStringValue().c_str());
1107       break;
1108     case DOUBLE_VALUE:
1109       sprintf(_buf, _fmt.c_str(), _node->getFloatValue() * _mult);
1110       break;
1111     }
1112     return _buf;
1113   } else {
1114     return "";
1115   }
1116 }
1117
1118
1119 \f
1120 ////////////////////////////////////////////////////////////////////////
1121 // Implementation of FGSwitchLayer.
1122 ////////////////////////////////////////////////////////////////////////
1123
1124 FGSwitchLayer::FGSwitchLayer (int w, int h, const SGPropertyNode * node,
1125                               FGInstrumentLayer * layer1,
1126                               FGInstrumentLayer * layer2)
1127   : FGInstrumentLayer(w, h), _node(node), _layer1(layer1), _layer2(layer2)
1128 {
1129 }
1130
1131 FGSwitchLayer::~FGSwitchLayer ()
1132 {
1133   delete _layer1;
1134   delete _layer2;
1135 }
1136
1137 void
1138 FGSwitchLayer::draw ()
1139 {
1140   if (test()) {
1141     transform();
1142     if (_node->getBoolValue()) {
1143       _layer1->draw();
1144     } else {
1145       _layer2->draw();
1146     }
1147   }
1148 }
1149
1150 \f
1151 // end of panel.cxx
1152
1153