Panels.cpp

Go to the documentation of this file.

/*
 * Panels.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "../Include/Globals.h"
#include "../Include/FlyLegacy.h"
#include "../Include/Panels.h"
#include "../Include/Gauges.h"
#include "../Include/Utility.h"
#include "../Include/Ui.h"

using namespace std;


/*
 * CPanel
 */

CPanel::CPanel (Tag id, const char* filename)
{
  this->id = id;
  strcpy (this->filename, filename);
  surface = NULL;
  memset (&bmPanl, 0, sizeof(SBitmap));

  // Initialize to window dimensions
  xScreen = globals->screenWidth;
  yScreen = globals->screenHeight;

  // Initialize panel viewing parameters
  x_3Dxy = y_3Dxy = 0;
  x_3Dsz = y_3Dsz = 0;
  x_isiz = y_isiz = 0;

  // Initialize keep flag to false
//  keep = false;

  // TEMP : Initialize keep flag to true, there appears to be a memory leak
  //   when creating/deleting non-permanent views
  keep = true;

  // Initialize panel scrolling offsets
  xOffset = yOffset = 0;

  // Initialize creeping flags
  creep_up = creep_down = creep_left = creep_right = false;

  // Initialize mouse handling data members
  track = MOUSE_TRACKING_OFF;
  buttonsDown = 0;

  // If the filename has a .PNL extension, then this is a dynamic panel,
  //   otherwise it is static

  SStream s;
  strcpy (s.filename, "Data\\");
  strcat (s.filename, filename);
  strcpy (s.mode, "r");

  char *p = strrchr (filename, '.');
  if (p && (stricmp (p, ".PNL") == 0)) {
    type = PANEL_INTERACTIVE;
  } else {
    type = PANEL_STATIC;

    // Filename suffix is the screen height in pixels
    char ext[16];
    sprintf (ext, ".%d", yScreen);
    strcat (s.filename, ext);
  }

  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}


CPanel::~CPanel (void)
{
  // Delete gauges
  vector<CGauge*>::iterator iter;
  for (iter=gage.begin(); iter!=gage.end(); iter++) {
    delete *iter;
  }


  // Delete panel backdrop
  FreeBitmap (&bmPanl);

  // Free surface created for panel backdrop
  FreeSurface (surface);
}


int CPanel::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'panl':
    // Panel base bitmap
    ReadString (panl, 64, stream);
    rc = TAG_READ;
    break;

  case '3Dxy':
    // XY offset of panel in 3D space
    ReadInt (&x_3Dxy, stream);
    ReadInt (&y_3Dxy, stream);
    rc = TAG_READ;
    break;

  case '3Dsz':
    // Size of panel in 3D space
    ReadInt (&x_3Dsz, stream);
    ReadInt (&y_3Dsz, stream);
    rc = TAG_READ;
    break;

  case 'isiz':
    // Base bitmap image size
    ReadInt (&x_isiz, stream);
    ReadInt (&y_isiz, stream);
    rc = TAG_READ;
    break;

  case 'hoff':
    // Horizontal offset for various screen resolutions
    {
      int width, x;
      ReadInt (&width, stream);
      ReadInt (&x, stream);
      hoff[width] = x;
    }
    rc = TAG_READ;
    break;

  case 'home':
    // Home (x,y) offset for various screen resolutions
    {
      int width;
      SPanelOffset offset;
      ReadInt (&width, stream);
      ReadInt (&offset.x, stream);
      ReadInt (&offset.y, stream);
      home[width] = offset;
    }
    rc = TAG_READ;
    break;

  case 'keep':
    // Keep panel resident in memory when not visible
    keep = true;
    rc = TAG_READ;
    break;

  case 'scrl':
    // This is a scrolling panel
    scrl = true;
    rc = TAG_READ;
    break;

  case 'lite':
    // Panel light
    {
      SkipObject (stream);
//      CPanelLight *light = new CPanelLight;
//      ReadFrom (light, stream);
//      lite.addEntity (light);
    }
    rc = TAG_READ;
    break;

  case 'mlsw':
    // Master light switch message
    SkipObject (stream);
    rc = TAG_READ;
    break;

  case 'clao':
    // Cockpit lights are always on
    clao = true;
    rc = TAG_READ;
    break;

  case 'dlid':
    // Default light ID
    ReadTag (&dlid, stream);
    rc = TAG_READ;
    break;

  case 'gage':
    // Read gauge type
    {
      Tag type;
      ReadTag (&type, stream);

      switch (type) {
      case GAUGE_BASE:
        // This is the unique tag of the abstract gauge base.  There should
        //   be no instances of this in any panel
        globals->logWarning->Write ("CPanel : Read gauge type 'gage'");
        break;

      case GAUGE_BITMAP:
        {
          CBitmapGauge *g = new CBitmapGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_NEEDLE:
        {
          CNeedleGauge *g = new CNeedleGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_NEEDLE_DUAL:
        {
          CTwoNeedleGauge *g = new CTwoNeedleGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_NEEDLE_TRIPLE:
        {
          CThreeNeedleGauge *g = new CThreeNeedleGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_DIGITAL_NEEDLE:
        {
          CDigitalNeedleGauge *g = new CDigitalNeedleGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_ALTIMETER:
        {
          CAltimeterGauge *g = new CAltimeterGauge;
      char *mark1 = new char[32];
      strcpy (mark1, "gauge start");
          ReadFrom (g, stream);
      char *mark2 = new char[32];
      strcpy (mark2, "gauge end");
          this->gage.push_back (g);
        }
        break;

      case GAUGE_ALTIMETER_ROLLING:
        {
          CRollingAltimeterGauge *g = new CRollingAltimeterGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_HORIZON:
        {
          CHorizonGauge *g = new CHorizonGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_HORIZON_FD:
        {
          CFDHorizonGauge *g = new CFDHorizonGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_HORIZONTAL_BALL:
        {
          CHorizontalBallGauge *g = new CHorizontalBallGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_AIRSPEED:
        {
          CAirspeedGauge *g = new CAirspeedGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_VERTICAL_SPEED:
        {
          CVerticalSpeedGauge *g = new CVerticalSpeedGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_DIRECTIONAL_GYRO:
        {
          CDirectionalGyroGauge *g = new CDirectionalGyroGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_VACUUM:
        {
          CVacuumGauge *g = new CVacuumGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_SUCTION:
        {
          CSuctionGauge *g = new CSuctionGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_FUEL:
        {
          CFuelGauge *g = new CFuelGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_FUEL_FLOW:
        {
          CFuelFlowGauge *g = new CFuelFlowGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_OIL_PRESSURE:
        {
          COilPressureGauge *g = new COilPressureGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_OIL_TEMPERATURE:
        {
          COilTemperatureGauge *g = new COilTemperatureGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_TACHOMETER:
        {
          CTachometerGauge *g = new CTachometerGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_TACHOMETER_DUAL:
        {
          CDualTachometerGauge *g = new CDualTachometerGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_N1_TACHOMETER:
        {
          CN1TachometerGauge *g = new CN1TachometerGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_EXHAUST_GAS_TEMP:
        {
          CExhaustGasTemperatureGauge *g = new CExhaustGasTemperatureGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_BASIC_COMPASS:
        {
          CBasicCompassGauge *g = new CBasicCompassGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_AMMETER:
        {
          CAmmeterGauge *g = new CAmmeterGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_ANALOG_CLOCK:
        {
          CAnalogClockGauge *g = new CAnalogClockGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_DIGITAL_CLOCK_FLYHAWK:
        {
          CFlyhawkDigitalClockGauge *g = new CFlyhawkDigitalClockGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_DIGITAL_CLOCK_BASIC:
        {
          CBasicDigitalClockGauge *g = new CBasicDigitalClockGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_ADF_BASIC:
        {
          CBasicADFGauge *g = new CBasicADFGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_DIGITAL_READOUT:
        {
          CDigitalReadoutGauge *g = new CDigitalReadoutGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_DIGITS_READOUT:
        {
          CDigitsReadoutGauge *g = new CDigitsReadoutGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_CABIN_PRESSURE_RATE:
        {
          CCabinPressureRateKnobGauge *g = new CCabinPressureRateKnobGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_CABIN_PRESSURE:
        {
          CCabinPressureGauge *g = new CCabinPressureGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_BRAKE_PRESSURE:
        {
          CBrakePressureGauge *g = new CBrakePressureGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_AOA:
        {
          CAOANeedleGauge *g = new CAOANeedleGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_TURN_COORDINATOR:
        {
          CTurnCoordinatorGauge *g = new CTurnCoordinatorGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_SLIP_INDICATOR:
        {
          CSlipIndicatorGauge *g = new CSlipIndicatorGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_HOBBS_METER:
        {
          CHobbsMeterGauge *g = new CHobbsMeterGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_NAVIGATION:
        {
          CNavigationGauge *g = new CNavigationGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_NAV_COMM_KX155:
        {
          CBKNavComKX155Gauge *g = new CBKNavComKX155Gauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_GPS_KLN89:
        {
//          CBKGPSKLN89Gauge *g = new CBKGPSKLN89Gauge;
          SkipObject (stream);
//          ReadFrom (g, stream);
//          this->gage.push_back (g);
        }
        break;

      case GAUGE_XPDR_KT76:
        {
          CBKXPDRKT76Gauge *g = new CBKXPDRKT76Gauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_ADF_KR87:
        {
          CBKADFKR87Gauge *g = new CBKADFKR87Gauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_AUTOPILOT_KAP140:
        {
          CBKAP140Gauge *g = new CBKAP140Gauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_AUTOPILOT_KFC200:
        {
          CBKKFC200Gauge *g = new CBKKFC200Gauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_AUTOPILOT_KFC150:
        {
          CBKKFC150Gauge *g = new CBKKFC150Gauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_AUDIO_KMA26:
        {
          CBKAudioKMA26Gauge *g = new CBKAudioKMA26Gauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_HSI:
        {
          CHSIGauge *g = new CHSIGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_FLYHAWK_ELT:
        {
          CFlyhawkELTGauge *g = new CFlyhawkELTGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_NAV_RADIO_GENERIC:
        {
          CGenericNavRadioGauge *g = new CGenericNavRadioGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_COMM_RADIO_GENERIC:
        {
          CGenericCommRadioGauge *g = new CGenericCommRadioGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_TRANSPONDER_GENERIC:
        {
          CGenericTransponderGauge *g = new CGenericTransponderGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_ADF_GENERIC:
        {
          CGenericADFRadioGauge *g = new CGenericADFRadioGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_RMI_NEEDLE:
        {
          CRMINeedleGauge *g = new CRMINeedleGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_RADIO_GAUGE_GROUP:
        {
          CRadioGaugeGroup *g = new CRadioGaugeGroup;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_NAV_GAUGE_GROUP:
        {
          CNavGaugeGroup *g = new CNavGaugeGroup;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_ANNUNCIATOR:
        {
          CAnnunciator *g = new CAnnunciator;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_FLYHAWK_ANNUNCIATOR:
        {
          CFlyhawkAnnunciator *g = new CFlyhawkAnnunciator;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_FLYHAWK_ANNUNCIATOR_TEST:
        {
          CFlyhawkAnnunciatorTest *g = new CFlyhawkAnnunciatorTest;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_FLYHAWK_NAV_GPS_PANEL:
        {
          CFlyhawkNavGpsPanelGauge *g = new CFlyhawkNavGpsPanelGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_FLYHAWK_FUEL_SELECTOR:
        {
          CFlyhawkFuelSelectorGauge *g = new CFlyhawkFuelSelectorGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_FLYHAWK_ELEVATOR_TRIM:
        {
          CFlyhawkElevatorTrimGauge *g = new CFlyhawkElevatorTrimGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_MALIBU_CHT_INDICATOR:
        {
          CMalybooCHTIndicatorGauge *g = new CMalybooCHTIndicatorGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_MALIBU_CHT_BUTTON:
        {
          CMalybooCHTButtonGauge *g = new CMalybooCHTButtonGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_MALIBU_NAV_GPS_PANEL:
        {
          CMalybooNavGpsPanelGauge *g = new CMalybooNavGpsPanelGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_MALIBU_DIGITAL_CLOCK:
        {
          CMalybooDigitalClockGauge *g = new CMalybooDigitalClockGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

//      case GAUGE_MALIBU_FUEL_SELECT:
//        {
//          CMalybooFuelSelectGauge *g = new CMalybooFuelSelectGauge;
//          ReadFrom (g, stream);
//          this->gage.push_back (g);
//        }
//        break;

      case GAUGE_MALIBU_ENGINE_MONITOR:
        {
          CMalybooEngineMonitorGauge *g = new CMalybooEngineMonitorGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_NAVAJO_FUEL_SELECTOR:
        {
          CNavajoFuelSelectorGauge *g = new CNavajoFuelSelectorGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_NAVAJO_AMMETER:
        {
          CNavajoAmmeterGauge *g = new CNavajoAmmeterGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_NAVAJO_RADAR_ALTIMETER:
        {
          CNavajoRadarAltimeterGauge *g = new CNavajoRadarAltimeterGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_COLLINS_EFIS_SELECTION:
        {
          CCollinsEFISSelectionGauge *g = new CCollinsEFISSelectionGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_COLLINS_VSPEED_PANEL:
        {
          CCollinsVspeedPanel *g = new CCollinsVspeedPanel;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;


      case GAUGE_COLLINS_HF_RADIO:
        {
          CCollinsHFRadioGauge *g = new CCollinsHFRadioGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;


      case GAUGE_COLLINS_PFD:
        {
          CCollinsPFDGauge *g = new CCollinsPFDGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;


      case GAUGE_COLLINS_ND:
        {
          CCollinsNDGauge *g = new CCollinsNDGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_COLLINS_RTU:
        {
          CCollinsRTUGauge *g = new CCollinsRTUGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;


      case GAUGE_COLLINS_AD:
        {
          CCollinsAirDataGauge *g = new CCollinsAirDataGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_COLLINS_MND:
        {
          CCollinsMNDGauge *g = new CCollinsMNDGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_UNIVERSAL_FMS:
        {
          CUniversalFMSGauge *g = new CUniversalFMSGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_PILATUS_EFIS_PANEL:
        {
          CPilatusEFISPanel *g = new CPilatusEFISPanel;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_WALKER_TEMP_AIRSPEED:
        {
          CWalkerTempAirspeedGauge *g = new CWalkerTempAirspeedGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_GYRO_SLAVING:
        {
          CGyroSlavingGauge *g = new CGyroSlavingGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_VERTICAL_RATE:
        {
          CVerticalRateGauge *g = new CVerticalRateGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_PROP_SYNC:
        {
          CPropSyncGauge *g = new CPropSyncGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_DME:
        {
          CDMEGauge *g = new CDMEGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_DME_2:
        {
          CDME2Gauge *g = new CDME2Gauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_WEATHER_RADAR:
        {
          CWeatherRadarGauge *g = new CWeatherRadarGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

      case GAUGE_ANALOG_ALT_PRESELECT:
        {
          CAnalogAltPreselectGauge *g = new CAnalogAltPreselectGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;

//      case GAUGE_TCAS:
//        {
//          CTCASGauge *g = new CTCASGauge;
//          ReadFrom (g, stream);
//          this->gage.push_back (g);
//        }
//        break;

      case GAUGE_HOTSPOT:
        {
          CMomentaryHotSpotGauge *g = new CMomentaryHotSpotGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_SIMPLE_IN_OUT:
        {
          CSimpleInOutStateSwitch *g = new CSimpleInOutStateSwitch;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_LIT_IN_OUT:
        {
          CLitInOutSwitch *g = new CLitInOutSwitch;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_SIMPLE_SWITCH:
        {
          CSimpleSwitch *g = new CSimpleSwitch;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_BATTERY_SWITCH:
        {
          CBasicBatterySwitch *g = new CBasicBatterySwitch;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_TWO_STATE_ELT:
        {
          CTwoStateELTGauge *g = new CTwoStateELTGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_SWITCH_PAIR:
        {
          CSwitchPairGauge *g = new CSwitchPairGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_SIMPLE_FLOAT_SWITCH:
        {
          CSimpleFloatSwitch *g = new CSimpleFloatSwitch;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_DUAL_SWITCH:
        {
          CDualSwitch *g = new CDualSwitch;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_PUSH_PULL_KNOB:
        {
          CPushPullKnobGauge *g = new CPushPullKnobGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_PRIMER_KNOB:
        {
          CPrimerKnobGauge *g = new CPrimerKnobGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_FLAP:
        {
          CFlapsSwitchGauge *g = new CFlapsSwitchGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_LIT_LANDING_GEAR_KNOB:
        {
          CLitLandingGearKnobGauge *g = new CLitLandingGearKnobGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_MIXTURE_KNOB:
        {
          CMixtureKnobGauge *g = new CMixtureKnobGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_REVERSIBLE_THROTTLE_KNOB:
        {
          CReversibleThrottleKnobGauge *g = new CReversibleThrottleKnobGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_DUAL_KNOB:
        {
          CDualKnobGauge *g = new CDualKnobGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_FLYHAWK_LIGHT_KNOB:
        {
          CFlyhawkLightKnobGauge *g = new CFlyhawkLightKnobGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_TURN_KNOB:
        {
          CTurnKnobGauge *g = new CTurnKnobGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_MAGNETO_SWITCH:
        {
          CBasicMagnetoSwitch *g = new CBasicMagnetoSwitch;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_COVERED_SWITCH:
        {
          CCoveredSwitch *g = new CCoveredSwitch;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_COVERED_LIGHT_BUTTON:
        {
          CCoveredLightButtonGauge *g = new CCoveredLightButtonGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_VERTICAL_SLIDER:
        {
          CVerticalSliderGauge *g = new CVerticalSliderGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_TRIM_WHEEL:
        {
          CTrimWheelGauge *g = new CTrimWheelGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_TRIM_WHEEL_INDICATOR:
        {
          CTrimWheelIndicatorGauge *g = new CTrimWheelIndicatorGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_INDICATOR:
        {
          CIndicatorGauge *g = new CIndicatorGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_FLAPS_INDICATOR:
        {
          CFlapsIndicatorGauge *g = new CFlapsIndicatorGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_PUSHBUTTON:
        {
          CPushButtonGauge *g = new CPushButtonGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_LIGHT_BUTTON:
        {
          CLightButtonGauge *g = new CLightButtonGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_TURN_SWITCH:
        {
          CTurnSwitchGauge *g = new CTurnSwitchGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_MASTER_CAUTION_BUTTON:
        {
          CMasterCautionWarningButtonGauge *g = new CMasterCautionWarningButtonGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_KINGAIR_FIRE_EXT:
        {
          CKAFireExtinguisherButton *g = new CKAFireExtinguisherButton;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_WALKER_AP_PANEL:
        {
          CWalkerAPPanel *g = new CWalkerAPPanel;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_WALKER_FIRE_PANEL:
        {
          CWalkerFirePanel *g = new CWalkerFirePanel;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_LIGHT_SWITCH_SET:
        {
          CLightSwitchSetGauge *g = new CLightSwitchSetGauge;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      case GAUGE_ROCKER_SWITCH:
        {
          CRockerSwitch *g = new CRockerSwitch;
          ReadFrom (g, stream);
          this->gage.push_back (g);
        }
        break;
      
      default:
        char s[16];
        TagToString (s, type);
        globals->logWarning->Write ("CPanel : Skipping gauge type <%s>", s);
        SkipObject (stream);
        rc = TAG_READ;
      }
    }
    rc = TAG_READ;
    break;
  }

/*
//
// Unknown syntax (no known examples)
//
#define GAUGE_ATTITUDE_INDICATOR    'atti'
#define GAUGE_GHOST           'ghst'
#define GAUGE_NAV_RADIO         'nrdg'
#define GAUGE_NAV_RADIO_KN53      'kn53'
#define GAUGE_NAV_RADIO_KN80      'kn80'
#define GAUGE_COMM_RADIO        'comm'
#define GAUGE_COMM_RADIO_KY96     'ky96'
#define GAUGE_TRANSPONDER_KT79      'kt79'
#define GAUGE_AUTOPILOT         'atop'

//
// Unknown semantics
//
#define GAUGE_NAV_RADIO_GROUP     'ngrp'
#define GAUGE_COM_RADIO_GROUP     'cgrp'
#define GAUGE_NAV_GAUGE_GROUP     'ogrp'
#define GAUGE_TRANSPONDER_RADIO_GROUP 'tgrp'
#define GAUGE_ADF_RADIO_GROUP     'agrp'
#define GAUGE_RADIO_GAUGE_GROUP     'radg'
*/

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CPanel::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CPanel::ReadFinished (void)
{
  // Set panel offsets to home position
  Home ();

  // Check the 'keep' flag which indicates that this panel should remain
  //   resident in memory even when it is not displayed.  If it is set,
  //   then pre-create the backdrop surface, load the backdrop bitmap
  //   and draw the bitmap into the surface
  if (keep) {
    Activate ();
  }

  // Set scrolling limits
  int temp;
  xMinLimit = 0;
  xMaxLimit = x_3Dsz - globals->screenWidth;
  if (xMinLimit > xMaxLimit) {
    temp = xMinLimit;
    xMinLimit = xMaxLimit;
    xMaxLimit = temp;
  }

  if (y_3Dxy <= 0) {
    yMinLimit = 0;
    yMaxLimit = -(y_3Dsz - globals->screenHeight - y_3Dxy);
  } else {
    yMinLimit = y_3Dxy;
    yMaxLimit = globals->screenHeight - y_isiz;
  }

  if (yMinLimit > yMaxLimit) {
    temp = yMinLimit;
    yMinLimit = yMaxLimit;
    yMaxLimit = temp;
  }

  // Validate offsets against limits
  if (yOffset < yMinLimit) yOffset = yMinLimit;
  if (yOffset > yMaxLimit) yOffset = yMaxLimit;
  if (xOffset < xMinLimit) xOffset = xMinLimit;
  if (xOffset > xMaxLimit) xOffset = xMaxLimit;
}


void CPanel::Activate (void)
{
  // Create the backdrop drawing surface if needed
  if (surface == NULL) {
    if ((x_isiz > 0) && (x_isiz <= 2048) &&
        (y_isiz > 0) && (y_isiz <= 2048))
    {
      surface = CreateSurface (x_isiz, y_isiz);
      EraseSurface (surface);
    }
  }

  // Load backdrop bitmap
  if (bmPanl.bitmap == NULL) {
    strcpy (bmPanl.bitmapName, "ART\\");
    strcat (bmPanl.bitmapName, panl);
    LoadBitmap (&bmPanl);

    // Draw backdrop bitmap to surface
    DrawBitmap (surface, &bmPanl, 0, 0, 1);
  }
}


void CPanel::Deactivate (void)
{
  if (!keep) {
    // Panel should not be kept in memory; deallocate all bitmaps and surface
    FreeSurface (surface);
    FreeBitmap (&bmPanl);
  }
}


void CPanel::CreepUp (void)
{
  if (scrl) {
    yOffset -= globals->panelCreepStep;
    if (yOffset < yMinLimit) yOffset = yMinLimit;
  }
}


void CPanel::CreepDown (void)
{
  if (scrl) {
    yOffset += globals->panelCreepStep;
    if (yOffset > yMaxLimit) yOffset = yMaxLimit;
  }
}


void CPanel::CreepLeft (void)
{
  if (scrl) {
    xOffset -= globals->panelCreepStep;
    if (xOffset < xMinLimit) xOffset = xMinLimit;
  }
}


void CPanel::CreepRight (void)
{
  if (scrl) {
    xOffset += globals->panelCreepStep;
    if (xOffset > xMaxLimit) xOffset = xMaxLimit;
  }
}


bool CPanel::GaugeHit (int mouseX, int mouseY, int& i, CGauge **gptr, int &x, int &y)
{
  // Sanity check
  if (!gptr) return false;

  bool hit = false;

  // Check for intersection with a gauge
  vector<CGauge*>::iterator iter;
  for (iter=gage.begin(); iter!=gage.end() && !hit; iter++) {
    CGauge *g = *iter;
    if (g) {
      // Determine the screen position of the gauge
      int w, h;
      g->GetSize (&x, &y, &w, &h);
      x -= xOffset;
      y -= yOffset - (globals->screenHeight - y_isiz);

      // Check for a hit between the mouse position and the gauge bounds
      hit = (mouseX > x) && (mouseX < (x + w)) && (mouseY > y) && (mouseY < (y + h));
      if (hit) *gptr = g;
    } else {
      GTFO ("CPanel::GaugeHit : Panel gauge list contains NULL pointer.");
    }
  }

  return hit;
}

void CPanel::GaugeMouseClick (int mouseX, int mouseY)
{
  int i, x, y;
  CGauge *g = NULL;
  if (GaugeHit (mouseX, mouseY, i, &g, x, y)) {
    // Send mouse click to the gauge
    track = g->MouseClick ((mouseX - x), (mouseY - y), buttonsDown);
  }
}

void CPanel::GaugeTrackClick (int mouseX, int mouseY)
{
  int i, x, y;
  CGauge *g = NULL;
  if (GaugeHit (mouseX, mouseY, i, &g, x, y)) {
    // Send mouse click to the gauge
    track = g->TrackClick ((mouseX - x), (mouseY - y), buttonsDown);
  }
}

void CPanel::GaugeStopClick (int mouseX, int mouseY)
{
  int i, x, y;
  CGauge *g = NULL;
  if (GaugeHit (mouseX, mouseY, i, &g, x, y)) {
    // Send mouse click to the gauge
    track = g->StopClick ((mouseX - x), (mouseY - y), buttonsDown);
  }
}

void CPanel::MouseMotion (int mouseX, int mouseY)
{
  if (globals->mouseScrollingEnabled) {
    // Update creep settings.  Panel will actually be scrolled in Draw() method
    creep_up = (mouseY <= 0);
    creep_down = (mouseY >= globals->screenHeight-1);
    creep_left = (mouseX <= 0);
    creep_right = (mouseX >= globals->screenWidth-1);
  }

  // DEBUG
//  char debug[80];
//  sprintf (debug, "Mouse moved to %d, %d (offset %d, %d)",
//    mouseX, mouseY, xOffset, yOffset);
//  DrawNoticeToUser (debug, 2);

  int i, x, y;
  CGauge *g = NULL;
  if (GaugeHit (mouseX, mouseY, i, &g, x, y)) {
    if (buttonsDown != 0) {
      // At least one button is pressed; call gauge's TrackClick method
      //   only if the tracking flag is set
      if (track) {
        track = g->TrackClick ((mouseX - x), (mouseY - y), buttonsDown);
      }
    } else {
      // No buttons are pressed; always call gauge's MouseMoved method
      ECursorResult cursor = g->MouseMoved ((mouseX - x), (mouseY - y));

      // Update cursor if gauge has not set it
      if (cursor == CURSOR_NOT_CHANGED) {
        globals->cursormgr->SetCursor (globals->crsrArrow);
      }
    }
  } else {
    // No gauge area hit...set default cursor
    globals->cursormgr->SetCursor (globals->crsrArrow);
  }
}


//
// Process mouse click event
//
void CPanel::MouseClick (int button, int updown, int mouseX, int mouseY)
{
  // DEBUG
//  char debug[80];
//  sprintf (debug, "Mouse button %d state %d at %d, %d", button, updown, x, y);
//  DrawNoticeToUser (debug, 2);

  // Update current set of pressed buttons
  switch (updown) {
  case GLUT_DOWN:
    switch (button) {
    case GLUT_LEFT_BUTTON:
      buttonsDown |= MOUSE_BUTTON_LEFT;
      break;

    case GLUT_MIDDLE_BUTTON:
      buttonsDown |= MOUSE_BUTTON_MIDDLE;
      break;

    case GLUT_RIGHT_BUTTON:
      buttonsDown |= MOUSE_BUTTON_RIGHT;
      break;
    }

    // Button down events are always sent to the underlying gauge
    GaugeMouseClick (mouseX, mouseY);
    break;

  case GLUT_UP:
    switch (button) {
    case GLUT_LEFT_BUTTON:
      buttonsDown &= ~MOUSE_BUTTON_LEFT;
      break;

    case GLUT_MIDDLE_BUTTON:
      buttonsDown &= ~MOUSE_BUTTON_MIDDLE;
      break;

    case GLUT_RIGHT_BUTTON:
      buttonsDown &= ~MOUSE_BUTTON_RIGHT;
      break;
    }

    // Button up events are only sent to the underlying gauge if tracking is ON
    if (track == MOUSE_TRACKING_ON) {
      GaugeStopClick (mouseX, mouseY);
    }
    break;
  }

  // All mouse down events are sent to the gauge over which the mouse is sitting.
  //   Mouse button up events are only sent to the gauge if mouse tracking is on.
  if ((updown == GLUT_DOWN) || (track == MOUSE_TRACKING_ON))
  {
  }
}


void CPanel::ScrollUp (void)
{
  if (scrl) {
    yOffset -= globals->panelScrollStep;
    if (yOffset < yMinLimit) yOffset = yMinLimit;
  }
}


void CPanel::ScrollDown (void)
{
  if (scrl) {
    yOffset += globals->panelScrollStep;
    if (yOffset > yMaxLimit) yOffset = yMaxLimit;
  }
}


void CPanel::ScrollLeft (void)
{
  if (scrl) {
    xOffset -= globals->panelScrollStep;
    if (xOffset < xMinLimit) xOffset = xMinLimit;
  }
}


void CPanel::ScrollRight (void)
{
  if (scrl) {
    xOffset += globals->panelScrollStep;
    if (xOffset > xMaxLimit) xOffset = xMaxLimit;
  }
}


//
// Reset the xOffset and yOffset values to the "home" position for the panel
//
void CPanel::Home (void)
{
  // See if there is a horizontal offset defined for this panel
  //   at the current screen resolution
  {
    map<int,int>::iterator i = hoff.find(xScreen);
    if (i != hoff.end()) {
      xOffset = i->second + x_3Dxy;
      yOffset = 0;
    }
  }

  // See if there is an offset (both horizontal and vertical) defined for
  //   this panel at the current screen resolution.  This overrides
  //   a horizontal offset if one was defined
  {
    map<int,SPanelOffset>::iterator i = home.find(xScreen);
    if (i != home.end()) {
      xOffset = i->second.x + x_3Dxy;
      yOffset = i->second.y + y_3Dxy;
    }
  }
}


//
// Set the panel y-offset to the maximum "up" scrolled position
//
void CPanel::PageUp (void) {}


//
// Set the panel y-offset to the maximum "down" scrolled position
//
void CPanel::PageDown (void) {}


//
// Return the unique ID tag value for this panel instance
//
Tag CPanel::GetId (void)
{
  return id;
}


//
// Draw the panel, including all contained gauges
//
void CPanel::Draw (void)
{
  // Creep the panel if any flags are set
  if (creep_up) CreepUp ();
  if (creep_down) CreepDown ();
  if (creep_left) CreepLeft ();
  if (creep_right) CreepRight ();

  // DEBUG
//  char debug[80];
//  sprintf (debug, "xOffset=%d yOffset = %d", xOffset, yOffset);
//  DrawNoticeToUser (debug, 1);

  // Set projection matrix to 2D screen size
  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();
  gluOrtho2D (xOffset, (xOffset + globals->screenWidth),
             -yOffset, (-yOffset + globals->screenHeight));

  // Set up OpenGL drawing state
  glPushAttrib (GL_ENABLE_BIT);
  glEnable (GL_ALPHA_TEST);
  glDisable (GL_DEPTH_TEST);
  glDisable (GL_LIGHTING);
  glDisable (GL_COLOR_MATERIAL);
  glDisable (GL_TEXTURE_2D);

  // Draw the panel backdrop.  The backdrop origin is always 0,0 which may
  //   be outside the clipping planes of the view.  A trick is used to position
  //   the raster point inside the viewing frustrum, drawing a NULL bitmap,
  //   then moving the raster position via the glBitmap function.
  if (surface != NULL) {
    glRasterPos2i (xOffset, -yOffset);
    glBitmap (0, 0, 0, 0, -xOffset, yOffset, NULL);
    BlitTransparent (surface, 0);
  }

  //
  // Not sure how to handle this...should all of the gauge surfaces be copied
  //   onto the backdrop, which is then blitted to the screen?  Or should
  //   the backdrop be blitted followed by individual gauges?  Probably the
  //   latter...eventually, different lighting attributes will be applied
  //   to the individual gauges, and this will allow GL to handle the different
  //   conditions in glDrawPixels (called in Blit())
  //
  // In part it depends which is faster, DrawBitmap() or Blit()
  //

  // Draw gauges which are even partially visible on screen
  vector<CGauge*>::iterator iter;
  for (iter=gage.begin(); iter!=gage.end(); iter++) {
    CGauge* g = *iter;

    if (g) {
      // Determine the screen position of the gauge
      int x, y, w, h;
      g->GetSize (&x, &y, &w, &h);
      x -= xOffset;
      y = y_isiz - y;   // Invert to GL coordinates
      y -= yOffset + (globals->screenHeight - y_isiz);

      bool onScreen = (x+w > 0) &&
                      (y+h > 0) &&
                      (x < globals->screenWidth) &&
                      (y < globals->screenHeight);
      if (onScreen) {
        // Tell the gauge to draw itself
        g->Draw ();

        // Blit gauge surface to the screen
        g->Blit (xOffset, yOffset, y_isiz);
      }
    } else {
      GTFO ("CPanel::Draw : Panel gauge list contains NULL pointer.");
    }
  }

  // Restore original OpenGL state
  glPopAttrib();

  // Restore original projection matrix
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  // Check for an OpenGL error
  GLenum e = glGetError ();
  if (e != GL_NO_ERROR) {
    gtfo ("CPanel::Draw:Return : GL Error 0x%04X", e);
  }
}

Documentation generated by