Gauges.h

Go to the documentation of this file.

/*
 * Gauges.h
 *
 * 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
 *
 */

#ifndef GAUGES_H
#define GAUGES_H


#include "FlyLegacy.h"
#include "Utility.h"


//
// Macro definitions for all valid gauge types.  These correspond to the gauge
//   type in each <gage> object within a PNL file.
//

#define GAUGE_BASE            'gage'
#define GAUGE_BITMAP          'bgge'
#define GAUGE_NEEDLE          'need'
#define GAUGE_NEEDLE_DUAL       '2ned'
#define GAUGE_NEEDLE_TRIPLE       '3ned'
#define GAUGE_DIGITAL_NEEDLE      'dned'
#define GAUGE_ALTIMETER         'alti'
#define GAUGE_ALTIMETER_ROLLING     'altr'
#define GAUGE_HORIZON         'hori'
#define GAUGE_HORIZON_FD        'fdhz'
#define GAUGE_HORIZONTAL_BALL     'hbal'
#define GAUGE_AIRSPEED          'aspd'
#define GAUGE_VERTICAL_SPEED      'vspd'
#define GAUGE_DIRECTIONAL_GYRO      'gyro'
#define GAUGE_VACUUM          'vacu'
#define GAUGE_SUCTION         'suct'
#define GAUGE_FUEL            'fuel'
#define GAUGE_FUEL_FLOW         'fflw'
#define GAUGE_OIL_PRESSURE        'oilp'
#define GAUGE_OIL_TEMPERATURE     'oilt'
#define GAUGE_TACHOMETER        'tach'
#define GAUGE_TACHOMETER_DUAL     'dtch'
#define GAUGE_N1_TACHOMETER       'n1ng'
#define GAUGE_EXHAUST_GAS_TEMP      'egtg'
#define GAUGE_BASIC_COMPASS       'comp'
#define GAUGE_AMMETER         'amms'
#define GAUGE_ANALOG_CLOCK        'aclk'
#define GAUGE_DIGITAL_CLOCK_FLYHAWK   'cdcg'
#define GAUGE_DIGITAL_CLOCK_BASIC   'bdcg'
#define GAUGE_ADF_BASIC         'adfg'
#define GAUGE_DIGITAL_READOUT     'dgrg'
#define GAUGE_DIGITS_READOUT      'drog'
#define GAUGE_CABIN_PRESSURE_RATE   'cprk'
#define GAUGE_CABIN_PRESSURE      'cprs'
#define GAUGE_BRAKE_PRESSURE      'brpg'
#define GAUGE_AOA           'aoan'
#define GAUGE_TURN_COORDINATOR      'turn'
#define GAUGE_SLIP_INDICATOR      'slip'
#define GAUGE_HOBBS_METER       'hobb'
#define GAUGE_NAVIGATION        'navg'
#define GAUGE_AUTOPILOT         'atop'
#define GAUGE_NAV_COMM_KX155      'k155'
#define GAUGE_GPS_KLN89         'kl89'
#define GAUGE_XPDR_KT76         'kt76'
#define GAUGE_ADF_KR87          'kr87'
#define GAUGE_AUTOPILOT_KAP140      'ka14'
#define GAUGE_AUTOPILOT_KFC200      'kf20'
#define GAUGE_AUTOPILOT_KFC150      'kf15'
#define GAUGE_AUDIO_KMA26       'kma2'
#define GAUGE_HSI           'hsi_'
#define GAUGE_FLYHAWK_ELT       'selt'
#define GAUGE_NAV_RADIO_GENERIC     'navr'
#define GAUGE_COMM_RADIO_GENERIC    'comr'
#define GAUGE_TRANSPONDER_GENERIC   'xpdr'
#define GAUGE_ADF_GENERIC       'adf_'
#define GAUGE_RMI_NEEDLE        'rmig'
#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'
#define GAUGE_ANNUNCIATOR       'annc'
#define GAUGE_FLYHAWK_ANNUNCIATOR   'shan'
#define GAUGE_FLYHAWK_ANNUNCIATOR_TEST  'shts'
#define GAUGE_FLYHAWK_NAV_GPS_PANEL   'sngp'
#define GAUGE_FLYHAWK_FUEL_SELECTOR   'shfs'
#define GAUGE_FLYHAWK_ELEVATOR_TRIM   'shet'
#define GAUGE_MALIBU_CHT_INDICATOR    'mcht'
#define GAUGE_MALIBU_CHT_BUTTON     'mchb'
#define GAUGE_MALIBU_NAV_GPS_PANEL    'mngp'
#define GAUGE_MALIBU_DIGITAL_CLOCK    'mdcg'
#define GAUGE_MALIBU_FUEL_SELECT    'mfss'
#define GAUGE_MALIBU_ENGINE_MONITOR   'pmem'
#define GAUGE_NAVAJO_FUEL_SELECTOR    'njfs'
#define GAUGE_NAVAJO_AMMETER      'namp'
#define GAUGE_NAVAJO_RADAR_ALTIMETER  'nral'
#define GAUGE_COLLINS_EFIS_SELECTION  'cesp'
#define GAUGE_COLLINS_VSPEED_PANEL    'cvsp'
#define GAUGE_COLLINS_HF_RADIO      'khfr'
#define GAUGE_COLLINS_PFD       'cpfd'
#define GAUGE_COLLINS_ND        'cnvd'
#define GAUGE_COLLINS_RTU       'crtu'
#define GAUGE_COLLINS_AD        'cadd'
#define GAUGE_COLLINS_MND       'cmnd'
#define GAUGE_UNIVERSAL_FMS       'ufms'
#define GAUGE_PILATUS_EFIS_PANEL    'pefs'
#define GAUGE_WALKER_TEMP_AIRSPEED    'hsat'
#define GAUGE_GYRO_SLAVING        'gslv'
#define GAUGE_VERTICAL_RATE       'vert'
#define GAUGE_PROP_SYNC         'sync'
#define GAUGE_DME           'dmei'
#define GAUGE_DME_2           'dme2'
#define GAUGE_WEATHER_RADAR       'wrad'
#define GAUGE_ANALOG_ALT_PRESELECT    'apre'
#define GAUGE_TCAS            'tcas'

#define GAUGE_HOTSPOT         'hspt'
#define GAUGE_SIMPLE_IN_OUT       'sios'
#define GAUGE_LIT_IN_OUT        'lios'
#define GAUGE_SIMPLE_SWITCH       'swit'
#define GAUGE_BATTERY_SWITCH      'batt'
#define GAUGE_TWO_STATE_ELT       'elt_'
#define GAUGE_SWITCH_PAIR       'pair'
#define GAUGE_SIMPLE_FLOAT_SWITCH   'fswi'
#define GAUGE_DUAL_SWITCH       'dswi'
#define GAUGE_PUSH_PULL_KNOB      'knob'
#define GAUGE_PRIMER_KNOB       'prim'
#define GAUGE_FLAP            'flap'
#define GAUGE_LIT_LANDING_GEAR_KNOB   'llgr'
#define GAUGE_MIXTURE_KNOB        'mixt'
#define GAUGE_REVERSIBLE_THROTTLE_KNOB  'revt'
#define GAUGE_DUAL_KNOB         'dual'
#define GAUGE_FLYHAWK_LIGHT_KNOB    'shlk'
#define GAUGE_TURN_KNOB         'tknb'
#define GAUGE_MAGNETO_SWITCH      'magn'
#define GAUGE_COVERED_SWITCH      'cswi'
#define GAUGE_COVERED_LIGHT_BUTTON    'cbtn'
#define GAUGE_VERTICAL_SLIDER     'vsld'
#define GAUGE_TRIM_WHEEL        'twhl'
#define GAUGE_TRIM_WHEEL_INDICATOR    'twhi'
#define GAUGE_INDICATOR         'indi'
#define GAUGE_FLAPS_INDICATOR     'find'
#define GAUGE_PUSHBUTTON        'push'
#define GAUGE_LIGHT_BUTTON        'lbut'
#define GAUGE_TURN_SWITCH       'tswi'
#define GAUGE_MASTER_CAUTION_BUTTON   'mcwb'
#define GAUGE_KINGAIR_FIRE_EXT      'kafe'
#define GAUGE_WALKER_AP_PANEL     'happ'
#define GAUGE_WALKER_FIRE_PANEL     'rhfp'
#define GAUGE_LIGHT_SWITCH_SET      'lssg'
#define GAUGE_ROCKER_SWITCH       'rock'

//
// Attic.  The following gauge identifiers are listed in the Fly! II class
//   list documentation, but no known examples exist.  They are unimplemented
//   at the present time.
//
#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'


// For convenience in some gauge definitions, this struct represents
//   an art (PBG or PBM) filename plus an x,y offset for the top-left
//   corner of the artwork relative to the top-left of the gauge
typedef struct {
  char    art[64];
  int     x, y;
} SArtOffset;


// For convenience in some gauge definitions, this struct represents
//   an art (PBG or PBM) filename plus an x1,y1 and x2,y2 boundaries
//   of the artwork relative to the top-left corner of the gauge.
typedef struct {
  char    art[64];
  int     x1, y1, x2, y2;
} SArtRectangle;


// For convenience in some gauge definitions, this struct represents
//   a click area within a knob.  The ytop and ybtm are the upper and
//   lower pixel row offsets within the gauge corresponding to the click
//   area.  The help value is the popup help string, and the value field
//   indicates the knob value when this click area is activated.
typedef struct {
  int     ytop;
  int     ybtm;
  float   valu;
  char    help[64];
} SKnobArea;

//
// CGaugeNeedle
//
// Helper class for many types of gauges which use analog needles for data display
//
class CGaugeNeedle : public CStreamObject {
public:
  CGaugeNeedle (void);
  virtual ~CGaugeNeedle (void);

  // CStream methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);

  // CGaugeNeedle methods
  virtual void  Draw (SSurface *surface, float degrees, int cx, int cy);

public:
  Tag   tag;

protected:
  bool  shar;   // Shared across multiple aircraft; currently ignored
  int   sizx;   // X size
  int   sizy;   // Y size
  int   offx;   // X offset
  int   offy;   // Y offset
  int   mind;   // Minimum degrees
  int   maxd;   // Maximum degrees
  char  base[64]; // Base filename of PBG bitmap

  SBitmap *bmap;    // Needle animation bitmap
  int   nFrames;  // Number of frames in the bitmap

  // Temporary kluge to prevent ReadFinished() from being called twice
  bool readFinished;
};


//
// CGaugeRectangle
//
class CGaugeRectangle : public CStreamObject {
public:
  CGaugeRectangle (void);
  virtual ~CGaugeRectangle (void) {}

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

public:
  int   x1, y1, x2, y2;   // (x1, y1) top-left, (x2, y2) bottom-right
};


//
// CGaugeClickArea
//
class CGaugeClickArea : public CGaugeRectangle {
public:
  CGaugeClickArea (void);
  virtual ~CGaugeClickArea (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);

  // CGaugeClickArea methods
  virtual bool          IsHit (int x, int y);
  virtual void          Draw (SSurface *surface, int frame);
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  char  bmap[64];     // Optional bitmap overlay
  char  curs[64];     // Custom cursor when mouse is over click area
  Tag   cursTag;      // Unique tag for custom cursor
  char  help[64];     // Custom popup help

  SBitmap   *bm;      // Optional bitmap
};


//
// CGaugeKnob
//
class CGaugeKnob : public CGaugeClickArea {
public:
  CGaugeKnob (void);
  virtual ~CGaugeKnob (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);

  // CGaugeKnob methods
  virtual void  Draw (float rotation);
  virtual void  SetOffset (int offset_x, int offset_y);

public:
  char  bmap[64];     // Filename of knob artwork
  SBitmap *bmKnob;

  int offset_x, offset_y;   // Offset within owner gauge
  SSurface *surf;
};


//
// CGaugeAnnunciator
//
class CGaugeAnnunciator : public CGaugeClickArea {
public:
  CGaugeAnnunciator (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};



//
// CGauge is the abstract parent class for all gauges.
//

class CGauge : public CStreamObject {
public:
  CGauge (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);

  // CGauge methods
  virtual void        GetSize (int* x1, int* y1, int*x2, int* y2);
  virtual void        Update (void);
  virtual void        Draw (void);
  virtual void        Blit (int xOffset, int yOffset, int y_isiz);
  virtual SSurface*   GetSurface (void);
  void                ClearSurface (void);

  virtual EClickResult  MouseClick (int x, int y, int buttons);
  virtual EClickResult  TrackClick (int x, int y, int buttons);
  virtual EClickResult  StopClick (int x, int y, int buttons);
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  Tag       type;       // Gauge type
  Tag       unid;       // Unique gauge ID within panel
  char      unid_s[8];  // String version of unique ID tag
  int       x, y, w, h; // (x,y) top-left and (w,h) width, height
  int       cx, cy;     // Center offset
  SMessage  mesg;       // Message for indication value
  float     gmin, gmax; // Minimum and maximum gauge value
  CDataMap  gtbl;       // Mapping table of indication to gauge value
  Tag       lite;       // ID of light that illuminates this gauge
  char      mask[64];   // Light mask filename (.RAW)
  bool      fore;       // Draw gauge in foreground
  char      curs[64];   // Custom cursor (.csr filename)
  Tag       cursTag;    // Unique tag for custom cursor
  char      help[64];   // Help popup
  char      dtyp[64];   // Data type
  char      dfmt[64];   // Display format
  bool      nomc;       // No mouse clicks
  bool      igno;       // Ignore match?

  SSurface* surf;       // Drawing surface for the gauge

  int     last_state;   // State value at last update
  float   value;        // Gauge value

public:
  static  int sfx_source;   // Audio manager source to play gauge sound effects
};


//
// CBitmapGauge
//
class CBitmapGauge : public CGauge {
public:
  CBitmapGauge (void);
  virtual ~CBitmapGauge (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);

  // CGauge methods
  virtual void  Draw (void);

  // CBitmapGauge methods
  virtual void  DrawUnderlay (void);
  virtual void  DrawOverlay (void);


protected:
  SArtOffset  bmap;       // Underlay bitmap and offset
  SArtOffset  over;       // Overlay bitmap and offset

  SBitmap   *bmUnderlay, *bmOverlay;
};


//
// CNeedleGauge
//
class CNeedleGauge : public CBitmapGauge {
public:
  CNeedleGauge (void);
  virtual ~CNeedleGauge (void) {}

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);
  virtual void Draw (void);

protected:
  int       radi;   // Radius in pixels
  float     sang;   // Starting angle (degrees)
  float     dunt;   // Degrees per unit
  float     rang_min; // Minimum range (degrees)
  float     rang_max; // Maximum range (degrees)
  int       noff_x;   // Needle center offset
  int       noff_y;
  bool      noac;   // No auto-center
  CGaugeNeedle  nedl;
};


//
// CTwoNeedleGauge
//
class CTwoNeedleGauge : public CBitmapGauge {
public:
  CTwoNeedleGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CNeedleGauge  ndl1;
  CNeedleGauge  ndl2;
};


//
// CThreeNeedleGauge
//
class CThreeNeedleGauge : public CBitmapGauge {
public:
  CThreeNeedleGauge (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

protected:
  CNeedleGauge  ndl1;
  CNeedleGauge  ndl2;
  CNeedleGauge  ndl3;
};


//
// CDigitalNeedleGauge
//
class CDigitalNeedleGauge : public CNeedleGauge {
public:
  CDigitalNeedleGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeNeedle  nndl;
  SArtOffset    nbak;
  SMessage    powr;
};


//
// CAltimeterGauge
//
class CAltimeterGauge : public CBitmapGauge {
public:
  CAltimeterGauge (void);
  virtual ~CAltimeterGauge (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  int             psiz_x, psiz_y;
  CNeedleGauge    *ndl1;
  CNeedleGauge    *ndl2;
  CNeedleGauge    *ndl3;
  char            csrl_csr[64];
  char            csrr_csr[64];       // CSR filenames for custom cursors
  Tag             csrl_tag, csrr_tag; // Unique tags for custom cursors
  CGaugeClickArea koll;
  int             kpxy_x, kpxy_y;
  CGaugeKnob      knob;
  SMessage        kmsg;
};


//
// CRollingAltimeterGauge
//
class CRollingAltimeterGauge : public CBitmapGauge {
public:
  CRollingAltimeterGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  int       psiz_x, psiz_y;
  char      zdig_art[64];
  char      ndig_art[64];
  char      tdig_art[64];
  int       digx[4];
  int       digy;
  int       dsiz_x, dsiz_y;
  CNeedleGauge  ndl1;
  CGaugeClickArea koll;
  CGaugeKnob    knob;
  SMessage    kmsg;
};


//
// CHorizonGauge
//
class CHorizonGauge : public CBitmapGauge {
public:
  CHorizonGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  SArtOffset  foot;
  SArtOffset  horz;
  int     hoff;
  SArtOffset  irim;
  SArtOffset  orim;
  SArtOffset  fron;
  float   pixd;
  int     moff;
  CGaugeKnob  knob;
  char    flag_art[64];
  SMessage  pich;
  SMessage  roll;
};


//
// CFDHorizonGauge
//
class CFDHorizonGauge : public CHorizonGauge {
public:
  CFDHorizonGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SArtOffset  bars;
};


//
// CHorizontalBallGauge
//
class CHorizontalBallGauge : public CBitmapGauge {
public:
  CHorizontalBallGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CAirspeedGauge
//
class CAirspeedGauge : public CNeedleGauge {
public:
  CAirspeedGauge (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  CGaugeKnob    knob;   // Kollsman knob
  CNeedleGauge  mmo_;   // MMO indicator
};


//
// CVerticalSpeedGauge
//
class CVerticalSpeedGauge : public CNeedleGauge {
public:
  CVerticalSpeedGauge (void);
  virtual ~CVerticalSpeedGauge (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

  // CGauge methods
  virtual void Draw (void);

protected:
  SArtOffset    vsbg;
  CGaugeKnob    vskb;
  SMessage      vmsg;

  SBitmap       *bmBug;
};


//
// CDirectionalGyroGauge
//
class CDirectionalGyroGauge : public CNeedleGauge {
public:
  CDirectionalGyroGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SArtOffset    apbg;
  SArtRectangle apkb;
  SArtRectangle knob;
  Tag       bias;
};


//
// CVacuumGauge
//
class CVacuumGauge : public CNeedleGauge {
public:
  CVacuumGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CSuctionGauge
//
class CSuctionGauge : public CNeedleGauge {
public:
  CSuctionGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CFuelGauge
//
class CFuelGauge : public CNeedleGauge {
public:
  CFuelGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CFuelFlowGauge
//
class CFuelFlowGauge : public CNeedleGauge {
public:
  CFuelFlowGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// COilPressureGauge
//
class COilPressureGauge : public CNeedleGauge {
public:
  COilPressureGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// COilTemperatureGauge
//
class COilTemperatureGauge : public CNeedleGauge {
public:
  COilTemperatureGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CTachometerGauge
//
class CTachometerGauge : public CNeedleGauge {
public:
  CTachometerGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  bool    hobb;   // Integrated Hobbs meter
};


//
// CDualTachometerGauge
//
class CDualTachometerGauge : public CTwoNeedleGauge {
public:
  CDualTachometerGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CN1TachometerGauge
//
class CN1TachometerGauge : public CTwoNeedleGauge {
public:
  CN1TachometerGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  CGaugeKnob  knob;
};


//
// CExhaustGasTemperatureGauge
//
class CExhaustGasTemperatureGauge : public CNeedleGauge {
public:
  CExhaustGasTemperatureGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  float egtr;
  char  egtn_art[64];
};


//
// CBasicCompassGauge
//
class CBasicCompassGauge : public CBitmapGauge {
public:
  CBasicCompassGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char  comp_art[64];
  int   wind;
  int   orgx;
  int   nton;
};


//
// CAnalogClockGauge
//
class CAnalogClockGauge : public CTwoNeedleGauge {
public:
  CAnalogClockGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CAmmeterGauge
//
class CAmmeterGauge : public CNeedleGauge {
public:
  CAmmeterGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CFlyhawkDigitalClockGauge
//
class CFlyhawkDigitalClockGauge : public CBitmapGauge {
public:
  CFlyhawkDigitalClockGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  int         oatd_x1, oatd_y1, oatd_x2, oatd_y2; // Outside Air Temp display
  int         clkd_x1, clkd_y1, clkd_x2, clkd_y2; // Clock display
  CGaugeClickArea   bupp;               // Upper button
  CGaugeClickArea   bsel;               // Select button
  CGaugeClickArea   bcon;               // Control button
  CGaugeClickArea   bbot;               // Bottom (both SEL and CON) buttons
  bool        ft13;               // Use 13-point font
  bool        noco;               // No colon between hour and minute
  int         cgap;               // Gap distance (pixels) for colon
  int         frgb_r, frgb_g, frgb_b;       // Font RGB colour
};


//
// CBasicDigitalClockGauge
//
class CBasicDigitalClockGauge : public CFlyhawkDigitalClockGauge {
public:
  CBasicDigitalClockGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  int         tick_x, tick_y;
  int         tkut;
  int         tklt;
  int         tkft;
  int         tket;
};


//
// CBasicADFGauge
//
class CBasicADFGauge : public CNeedleGauge {
public:
  CBasicADFGauge (void);
  virtual ~CBasicADFGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);
  virtual EClickResult  MouseClick (int x, int y, int buttons);
  virtual void          Draw (void);
  virtual void          Blit (int xOffset, int yOffset, int y_isiz);

protected:
  Tag           comp_tag;
  CGaugeNeedle  *comp;
  CGaugeKnob    *knob;
  CGaugeNeedle  *hdng;
  float         compass;      // Compass card setting
};


//
// CDigitalReadoutGauge
//
class CDigitalReadoutGauge : public CBitmapGauge {
public:
  CDigitalReadoutGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  int   maxd;
  char  wdig_art[64];
  char  fdig_art[64];
  int   digY;
  int   num_digX;
  int   *digX;
  bool  whol;     // Whole numbers only
  bool  padz;     // Pad with leading zeroes
};


//
// CDigitsReadoutGauge
//
class CDigitsReadoutGauge : public CGauge {
public:
  CDigitsReadoutGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual void  Draw (void) {}

protected:
  int   frgb_r, frgb_g, frgb_b;
  char  just[64];
};


//
// CCabinPressureRateKnobGauge
//
class CCabinPressureRateKnobGauge : public CBitmapGauge {
public:
  CCabinPressureRateKnobGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  int     ofxy_x, ofxy_y;
  float   alti_min, alti_max;   // Altitude range
  float   rate_min, rate_max;   // Rate range
  CGaugeKnob  knob;         // Rate knob
  CGaugeKnob  cabn;         // Cabin Pressure knob
  char    onsf[64];
  char    ofsf[64];
};


//
// CCabinPressureGauge
//
class CCabinPressureGauge : public CNeedleGauge {
public:
  CCabinPressureGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CNeedleGauge  alti;
  CNeedleGauge  diff;
  CNeedleGauge  rate;
};


//
// CBrakePressureGauge
//
class CBrakePressureGauge : public CTwoNeedleGauge {
public:
  CBrakePressureGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  CGaugeClickArea   left;   // Left help area
  CGaugeClickArea   rght;   // Right help area
};


//
// CAOANeedleGauge
//
class CAOANeedleGauge : public CTwoNeedleGauge {
public:
  CAOANeedleGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  CGaugeKnob      knob;
};


//
// CTurnCoordinatorGauge
//
class CTurnCoordinatorGauge : public CBitmapGauge {
public:
  CTurnCoordinatorGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char    plan_art[64];
  int     poff_x, poff_y;
  char    ball_art[64];
  int     boff_x, boff_y;
  Tag     pcon;
  Tag     bcon;
  int     Ltrn;
  int     Rtrn;
};


//
// CHSIGauge
//
class CHSIGauge : public CBitmapGauge {
public:
  CHSIGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  SArtOffset      comp;       // Compass plate
  SArtOffset      cour;
  SArtOffset      devi;   
  SArtOffset      devb;
  SArtOffset      apbg;       // Autopilot heading bug
  SArtOffset      to;         // TO flag
  SArtOffset      from;       // FROM flag
  SArtOffset      glid;       // Glideslope needle
  CGaugeKnob      knob;
  CGaugeKnob      apkb;       // Autopilot heading knob
  SMessage      obsm;       // OBS message
  SMessage      bugm;       // Autopilot heading message
  SMessage      fcs;        // FCS message
  Tag         radi_tag;
  int         radi_unit;
  float       rang_min, rang_max;
  float       gsdf;       // Glideslope deflection
};


//
// CFlyhawkELTGauge
//
class CFlyhawkELTGauge : public CBitmapGauge {
public:
  CFlyhawkELTGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char        ulit_art[64];
  char        lit_art[64];
  char        csru_csr[64];
  char        csrd_csr[64];
  char        sfxu_wav[64];
  char        sfxd_wav[64];
  int         sfxu_tag;
  int         sfxd_tag;
};


//
// CSlipIndicatorGauge
//
class CSlipIndicatorGauge : public CBitmapGauge {
public:
  CSlipIndicatorGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char    ball_art[64];
};


//
// CHobbsMeterGauge
//
class CHobbsMeterGauge : public CGauge {
public:
  CHobbsMeterGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods

protected:
  char  blak_art[64];
  char  whit_art[64];
};


//
// CNavigationGauge
//
class CNavigationGauge : public CBitmapGauge {
public:
  CNavigationGauge (void);
  virtual ~CNavigationGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished ();

  // CGauge methods
  EClickResult MouseClick (int x, int y, int buttons);
  EClickResult StopClick (int x, int y, int buttons);
  void  Draw (void);
  void  Blit (int xOffset, int yOffset, int y_isiz);

protected:
  Tag       comp_tag;
  CGaugeNeedle  comp_ndl;
  SArtOffset    lndl;
  SArtOffset    gndl;
  SArtRectangle obs;
  char      wtab_art[64];
  char      ttab_art[64];
  char      ftab_art[64];
  int       ntpl_x, ntpl_y;
  int       gspl_x, gspl_y;
  Tag       radi_tag;
  int       radi_unit;
  SMessage    fcs;

  SSurface    *surfObsKnob;
  SBitmap     *bmObsKnob;
  int         nObsKnobFrames;
  SBitmap     *bmLocalizer;
  int         nLocalizerFrames;
  float       localizerFramesPerDeg;
  SBitmap     *bmGlideslope;
  int         nGlideslopeFrames;
  float       glideslopeFramesPerDeg;
  SBitmap     *bmWarnTab;
  SBitmap     *bmToTab;
  SBitmap     *bmFromTab;

  float       obsSetting;
  int         obsRate;
  bool        obsKnobClick;
  float       obsKnobTickRate;
  float       obsKnobTickRateTimer;
  float       obsKnobLastTick;
};


/*
 * Avionics gauges
 */

//
// CBKKX155ComPresets
//
// This helper class implements the 32 preset COM radio channels for the
//   Bendix-King KX155 radio.  As a descendent of CStreamObject, the channel
//   presets can be persistently stored.
//
class CBKKX155ComPresets : public CStreamObject {
public:
  CBKKX155ComPresets (void);

  // CStreamObject methods
  virtual int       Read (SStream *stream, Tag tag);

  // CBKKX155ComPresets methods
  void              Load (const char *txtFilename);
  float             GetFreq (int i);
  void              SetFreq (int i, float freq);

protected:
  float             freq[32];
};

//
// CBKNavComKX155Gauge
//
class CBKNavComKX155Gauge : public CBitmapGauge {
public:
  CBKNavComKX155Gauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);
  virtual EClickResult  MouseClick (int x, int y, int buttons);
  virtual void          Draw (void);

  void    IncComChannel (void);
  void    DecComChannel (void);

protected:
  Tag         radi_tag;
  int         radi_unit;
  CGaugeClickArea   ca01;
  CGaugeClickArea   ca02;
  CGaugeClickArea   ca03;
  CGaugeClickArea   ca04;
  CGaugeClickArea   ca05;
  CGaugeClickArea   ca06;
  CGaugeClickArea   ca07;
  CGaugeClickArea   ca08;
  CGaugeClickArea   ca09;
  CGaugeClickArea   ca10;
  CGaugeClickArea   ca11;
  CGaugeClickArea   ca12;
  CGaugeClickArea   ca13;
  CGaugeClickArea   ca14;
  CGaugeClickArea   ca15;
  CGaugeClickArea   ca16;
  CGaugeClickArea   ca17;
  CGaugeClickArea   ca18;
  CGaugeClickArea   ca19;
  CGaugeClickArea   ca20;
  CGaugeClickArea   ca21;

  SFont             *digi9;       // 9-point LED digits

  // COM Channel Presets
  CBKKX155ComPresets   presets;

  // COM mode variables
  int               comChannel;         // Prog/Select mode current channel
  bool              comProgramFlash;    // Prog mode flash state
  float             comProgramTimer;    // Prog mode flash timer
  bool              comProgramFreq;     // Prog mode, true if freq is being edited
};


//
// CBKGPSKLN89Gauge
//
class CBKGPSKLN89Gauge : public CBitmapGauge {
public:
  CBKGPSKLN89Gauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  Tag         radi;
  CGaugeClickArea   ca01;
  CGaugeClickArea   ca02;
  CGaugeClickArea   ca03;
  CGaugeClickArea   ca04;
  CGaugeClickArea   ca05;
  CGaugeClickArea   ca06;
  CGaugeClickArea   ca07;
  CGaugeClickArea   ca08;
  CGaugeClickArea   ca09;
  CGaugeClickArea   ca10;
  CGaugeClickArea   ca11;
  CGaugeClickArea   ca12;
  CGaugeClickArea   ca13;
  CGaugeClickArea   ca14;
  CGaugeClickArea   ca15;
  CGaugeClickArea   ca16;
  CGaugeClickArea   ca17;
  CGaugeClickArea   ca18;
  CGaugeClickArea   ca19;
  CGaugeClickArea   ca20;
  CGaugeClickArea   ca21;
  CGaugeClickArea   ca22;
};


//
// CBKXPDRKT76Gauge
//
class CBKXPDRKT76Gauge : public CBitmapGauge {
public:
  CBKXPDRKT76Gauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);
  virtual EClickResult  MouseClick (int x, int y, int buttons);
  virtual EClickResult  StopClick (int x, int y, int buttons);
  virtual void          Draw (void);

protected:
  Tag         radi_tag;
  int         radi_unit;
  CGaugeClickArea   ca[17];
  int               nClickAreas;
  int               caClicked;
};


//
// CBKADFKR87Gauge
//
class CBKADFKR87Gauge : public CBitmapGauge {
public:
  CBKADFKR87Gauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);
  virtual EClickResult  MouseClick (int x, int y, int buttons);
  virtual EClickResult  StopClick (int x, int y, int buttons);
  virtual void          Draw (void);

protected:
  Tag               radi_tag;
  int               radi_unit;
  CGaugeClickArea   ca[16];
  int               nClickAreas;
  int               caClicked;
};


//
// CBKAP140Gauge
//
class CBKAP140Gauge : public CBitmapGauge {
public:
  CBKAP140Gauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);
  virtual void          Draw (void);

protected:
  CGaugeClickArea   ca[7];
  int               nClickAreas;
  int               caClicked;
};


//
// CBKKFC200Gauge
//
class CBKKFC200Gauge : public CBitmapGauge {
public:
  CBKKFC200Gauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  CGaugeClickArea   ca01;
  CGaugeClickArea   ca02;
  CGaugeClickArea   ca03;
  CGaugeClickArea   ca04;
  CGaugeClickArea   ca05;
  CGaugeClickArea   ca06;
  CGaugeClickArea   ca07;
  CGaugeClickArea   ca08;
  CGaugeClickArea   ca09;
  CGaugeClickArea   ca10;
  CGaugeClickArea   ca11;
  SArtOffset      fd;
  SArtOffset      alt;
  SArtOffset      hdg;
  SArtOffset      gs;
  SArtOffset      nav;
  SArtOffset      apr;
  SArtOffset      bc;
  SArtOffset      trim;
  SArtOffset      ap;
};


//
// CBKKFC150Gauge
//
class CBKKFC150Gauge : public CBitmapGauge {
public:
  CBKKFC150Gauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  CGaugeClickArea   ca01;
  CGaugeClickArea   ca02;
  CGaugeClickArea   ca03;
  CGaugeClickArea   ca04;
  CGaugeClickArea   ca05;
  CGaugeClickArea   ca06;
  CGaugeClickArea   ca07;
  CGaugeClickArea   ca08;
  CGaugeClickArea   ca09;
  CGaugeClickArea   ca10;
  CGaugeClickArea   ca11;
  SArtOffset      fd;
  SArtOffset      alt;
  SArtOffset      hdg;
  SArtOffset      gs;
  SArtOffset      nav;
  SArtOffset      apr;
  SArtOffset      bc;
  SArtOffset      trim;
  SArtOffset      ap;
};


//
// CBKAudioKMA26Gauge
//
class CBKAudioKMA26Gauge : public CBitmapGauge {
public:
  CBKAudioKMA26Gauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  Tag         radi;
  CGaugeClickArea   ca01;
  CGaugeClickArea   ca02;
  CGaugeClickArea   ca03;
  CGaugeClickArea   ca04;
  CGaugeClickArea   ca05;
  CGaugeClickArea   ca06;
  CGaugeClickArea   ca07;
  CGaugeClickArea   ca08;
  CGaugeClickArea   ca09;
  CGaugeClickArea   ca10;
  CGaugeClickArea   ca11;
  CGaugeClickArea   ca12;
  CGaugeClickArea   ca13;
  CGaugeClickArea   ca14;
  CGaugeClickArea   ca15;
};


//
// CGenericNavRadioGauge
//
class CGenericNavRadioGauge : public CBitmapGauge {
public:
  CGenericNavRadioGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  Tag         radi_tag;
  int         radi_unit;
  CGaugeClickArea   ca01;
  CGaugeClickArea   ca02;
  CGaugeClickArea   ca03;
  CGaugeClickArea   ca04;
  CGaugeClickArea   ca05;
  CGaugeClickArea   ca06;
  bool        sdim;
};


//
// CGenericCommRadioGauge
//
class CGenericCommRadioGauge : public CBitmapGauge {
public:
  CGenericCommRadioGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  Tag         radi_tag;
  int         radi_unit;
  CGaugeClickArea   ca01;
  CGaugeClickArea   ca02;
  CGaugeClickArea   ca03;
  CGaugeClickArea   ca04;
  CGaugeClickArea   ca05;
  CGaugeClickArea   ca06;
  bool        sdim;
};


//
// CGenericTransponderGauge
//
class CGenericTransponderGauge : public CBitmapGauge {
public:
  CGenericTransponderGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  Tag         radi_tag;
  int         radi_unit;
  CGaugeClickArea   tune;
  CGaugeClickArea   mode;
  CGaugeClickArea   idnt;
  CGaugeClickArea   test;
  CGaugeClickArea   ida1;
  CGaugeClickArea   ida2;
  CGaugeClickArea   ida3;
  CGaugeClickArea   ida4;
  CGaugeClickArea   idb1;
  CGaugeClickArea   idb2;
  CGaugeClickArea   idb3;
  CGaugeClickArea   idb4;
};


//
// CGenericADFRadioGauge
//
class CGenericADFRadioGauge : public CBitmapGauge {
public:
  CGenericADFRadioGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  Tag         radi_tag;
  int         radi_unit;
  CGaugeClickArea   dga1;
  CGaugeClickArea   dga2;
  CGaugeClickArea   dga3;
  CGaugeClickArea   dga4;
  CGaugeClickArea   dga5;
  CGaugeClickArea   dgb1;
  CGaugeClickArea   dgb2;
  CGaugeClickArea   dgb3;
  CGaugeClickArea   dgb4;
  CGaugeClickArea   dgb5;
  CGaugeClickArea   tune;
  CGaugeKnob      mode;
  CGaugeClickArea   stor;
  CGaugeClickArea   test;
  bool        sdim;
};


//
// CRMINeedleGauge
//
class CRMINeedleGauge : public CBitmapGauge {
public:
  CRMINeedleGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  Tag       comp_tag;
  CGaugeNeedle  comp;
  int       cpxy_x, cpxy_y;
  CGaugeNeedle  adfn;
  int       anxy_x, anxy_y;
  CGaugeNeedle  rmin;
  int       rnxy_x, rnxy_y;
  Tag       adf1;
  int       adf1_unit;
  Tag       adf2;
  int       adf2_unit;
  Tag       nav1;
  int       nav1_unit;
  Tag       nav2;
  int       nav2_unit;
  SArtOffset    adfa;
  SArtOffset    vora;
  CGaugeClickArea lbtn;
  CGaugeClickArea rbtn;
};


//
// CNavGaugeGroup
//
class CNavGaugeGroup : public CGauge {
public:
  CNavGaugeGroup (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  Tag   nav1;
  Tag   nav2;
};


//
// CRadioGaugeGroup
//
class CRadioGaugeGroup : public CGauge {
public:
  CRadioGaugeGroup (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  Tag   rad1_tag;   // 'rad1' conflicts with Windows #define
  Tag   rad2_tag;   // 'rad2' conflicts with Windows #define
  Tag   key_tag;
};


//
// CAnnunciator
//
class CAnnunciator : public CBitmapGauge {
public:
  CAnnunciator (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CFlyhawkAnnunciator
//
class CFlyhawkAnnunciator : public CGauge {
public:
  CFlyhawkAnnunciator (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char  lowf_art[64];
  char  lowl_art[64];
  char  lowr_art[64];
  char  oilp_art[64];
  char  vacl_art[64];
  char  vacr_art[64];
  char  lowv_art[64];
  char  volt_art[64];
  char  line_art[64];
};


//
// CFlyhawkAnnunciatorTest
//
class CFlyhawkAnnunciatorTest : public CGauge {
public:
  CFlyhawkAnnunciatorTest (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char    swit_art[64];
  char    sfxu_wav[64];
  char    sfxd_wav[64];
  int     sfxu_tag;
  int     sfxd_tag;
  char    csru_csr[64];
  char    csrd_csr[64];
};


//
// CFlyhawkNavGpsPanelGauge
//
class CFlyhawkNavGpsPanelGauge : public CBitmapGauge {
public:
  CFlyhawkNavGpsPanelGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  CGaugeKnob    cnav;
  CGaugeKnob    capr;
  int       xnav_x, xnav_y;
  int       xgps_x, xgps_y;
  int       xapr_x, xapr_y;
  int       xmsg_x, xmsg_y;
  int       xwpt_x, xwpt_y;
};


//
// CFlyhawkFuelSelectorGauge
//
class CFlyhawkFuelSelectorGauge : public CBitmapGauge {
public:
  CFlyhawkFuelSelectorGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  char        swit_art[64];
  CGaugeClickArea   left;
  CGaugeClickArea   both;
  CGaugeClickArea   righ;
  SMessage      Lmsg;
  SMessage      Rmsg;
};


//
// CFlyhawkElevatorTrimGauge
//
class CFlyhawkElevatorTrimGauge : public CBitmapGauge {
public:
  CFlyhawkElevatorTrimGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  SArtOffset    trmw;
  SArtOffset    trmi;
  CGaugeClickArea down;
  CGaugeClickArea up;
};


//
// CMalybooCHTIndicatorGauge
//
class CMalybooCHTIndicatorGauge : public CBitmapGauge {
public:
  CMalybooCHTIndicatorGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  int   xoff[6];
  int   yoff;
};


//
// CMalybooCHTButtonGauge
//
class CMalybooCHTButtonGauge : public CBitmapGauge {
public:
  CMalybooCHTButtonGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CMalybooNavGpsPanelGauge
//
class CMalybooNavGpsPanelGauge : public CBitmapGauge {
public:
  CMalybooNavGpsPanelGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeClickArea cnav;
  int       xnav_x, xnav_y;
  int       xgps_x, xgps_y;
  CGaugeClickArea capr;
  int       xapr_x, xapr_y;
  int       xarm_x, xarm_y;
  int       xact_x, xact_y;
  CGaugeClickArea ccrs;
  int       xcrs_x, xcrs_y;
  int       xobs_x, xobs_y;
  int       xleg_x, xleg_y;
  CGaugeClickArea cmsg;
  int       xmsg_x, xmsg_y;
  int       xwpt_x, xwpt_y;
  CGaugeClickArea cyaw;
  int       xyaw_x, xyaw_y;
};


//
// CMalybooDigitalClockGauge
//
class CMalybooDigitalClockGauge : public CBitmapGauge {
public:
  CMalybooDigitalClockGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  int       clkd_x1, clkd_y1, clkd_x2, clkd_y2;   // Clock display area
  CGaugeClickArea mode;   // Mode button
  CGaugeClickArea powr;   // Power button
  CGaugeClickArea play;   // Play button
  CGaugeClickArea rec;    // Rec button
  CGaugeClickArea set;    // Set button
};

//
// CMalybooEngineMonitorGauge
//
class CMalybooEngineMonitorGauge : public CBitmapGauge {
public:
  CMalybooEngineMonitorGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeClickArea   fuel;
  CGaugeClickArea   inst;
  CGaugeClickArea   blk_;
  CGaugeClickArea   fill;
  CGaugeClickArea   pwr_;
  CGaugeClickArea   set_;
  CGaugeClickArea   MAP_;
  CGaugeClickArea   RPM_;
  CGaugeClickArea   TIT;
  CGaugeClickArea   FF__;
  CGaugeClickArea   OT__;
  CGaugeClickArea   OP__;
  CGaugeClickArea   CHT_;
  CGaugeClickArea   VAC_;
  CGaugeClickArea   LQTY;
  CGaugeClickArea   RQTY;
  char        rlit_art[64];
  char        glit_art[64];
  char        ylit_art[64];
};


//
// CNavajoFuelSelectorGauge
//
class CNavajoFuelSelectorGauge : public CBitmapGauge {
public:
  CNavajoFuelSelectorGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char        swit[64];   // Switch PBG artwork
  CGaugeClickArea   obca;     // Outboard
  CGaugeClickArea   ofca;     // Off
  CGaugeClickArea   ibca;     // Inboard
  SMessage      obms;     // Outboard tank message
  SMessage      ibms;     // Inboard tank message
};


//
// CNavajoFuelAmmeterGauge
//
class CNavajoAmmeterGauge : public CNeedleGauge {
public:
  CNavajoAmmeterGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SMessage      mChg;     // Charge message
  SMessage      mLtM;     // Left ammeter message
  SMessage      mRtM;     // Right ammeter message
  SMessage      mLtS;     // Left switch message
  SMessage      mRtS;     // Right switch message
  CGaugeClickArea   ca01;     // Left switch
  CGaugeClickArea   ca02;     // Right switch
};


//
// CNavajoRadarAltimeterGauge
//
class CNavajoRadarAltimeterGauge : public CNeedleGauge {
public:
  CNavajoRadarAltimeterGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SMessage        bMsg;     // DH Bug message
  CDataMap        dhbt;     // DH Bug table
  SArtOffset      bug;      // DH Bug PBG artwork and offset
  SArtOffset      plit;     // Power light PBG artwork and offset
  SMessage        dhms;     // DH message
  CGaugeKnob      knob;     // DH Knob
};


//
// CCollinsEFISSelectionGauge
//
class CCollinsEFISSelectionGauge : public CBitmapGauge {
public:
  CCollinsEFISSelectionGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeClickArea   brg_;     // Bearing
  CGaugeClickArea   brgm;     // Bearing mode
  CGaugeKnob      brgk;     // Bearing knob
  CGaugeKnob      dh__;     // DH knob
  CGaugeClickArea   form;     // Display format
  CGaugeClickArea   crs_;     // Course
  CGaugeClickArea   crsm;     // Course mode
  CGaugeKnob      crsk;     // Course knob
  CGaugeClickArea   wx__;     // Weather display
  CGaugeClickArea   nav_;     // Nav Data Toggle
  SMessage      pfdm;     // PFD message
  SMessage      ehim;     // EHSI message
  SMessage      mndm;     // Multi Nav Display message
  SMessage      adm_;     // Air Data message
  SMessage      aplt;     // Autopilot message
};


//
// CCollinsVspeedPanel
//
class CCollinsVspeedPanel : public CBitmapGauge {
public:
  CCollinsVspeedPanel (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeClickArea   sped;
  CGaugeClickArea   vsel;
};


//
// CCollinsHFRadioGauge
//
class CCollinsHFRadioGauge : public CBitmapGauge {
public:
  CCollinsHFRadioGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeClickArea     tel;    //
  CGaugeClickArea     am;     // Amplitude Modulation button
  CGaugeClickArea     usb;    // Upper Sideband button
  CGaugeClickArea     lsb;    // Lower Sideband button
  CGaugeClickArea     mhz;    // MHz button
  CGaugeClickArea     khz;    // KHz button
  CGaugeClickArea     stor;   // Store button
  CGaugeClickArea     tune;   // Tune button
  CGaugeClickArea     volu;   // Volume button
  CGaugeClickArea     dash;   // 
  CGaugeClickArea     tx;     // Tx button
  CGaugeClickArea     chan;   // Channel button
  bool          ft13;   // Use 13-point font
};


//
// CCollinsPFDGauge
//
class CCollinsPFDGauge : public CBitmapGauge {
public:
  CCollinsPFDGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CCollinsNDGauge
//
class CCollinsNDGauge : public CBitmapGauge {
public:
  CCollinsNDGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CCollinsRTUGauge
//
class CCollinsRTUGauge : public CBitmapGauge {
public:
  CCollinsRTUGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeRectangle   lin1;     // Line 1
  CGaugeRectangle   lin2;     // Line 2
  CGaugeRectangle   lin3;     // Line 3
  CGaugeRectangle   lin4;     // Line 4
  CGaugeRectangle   lin5;     // Line 5
  CGaugeClickArea   btn1;     // Button 1
  CGaugeClickArea   btn2;     // Button 2
  CGaugeClickArea   btn3;     // Button 3
  CGaugeClickArea   btn4;     // Button 4
  CGaugeClickArea   btn5;     // Button 5
  CGaugeClickArea   cmaw;     // COM Active Whole MHz
  CGaugeClickArea   cmaf;     // COM Active Fract MHz
  CGaugeClickArea   cmsw;     // COM Stby Whole MHz
  CGaugeClickArea   cmsf;     // COM Stby Fract MHz
  CGaugeClickArea   nvaw;     // NAV Active Whole MHz
  CGaugeClickArea   nvaf;     // NAV Active Fract MHz
  CGaugeClickArea   adf1;     // ADF Digit 1
  CGaugeClickArea   adf2;     // ADF Digit 2
  CGaugeClickArea   adf3;     // ADF Digit 3
  CGaugeClickArea   adf4;     // ADF Digit 4
  CGaugeClickArea   adf5;     // ADF Digit 5
  CGaugeClickArea   xpd1;     // Transponder Digit 1
  CGaugeClickArea   xpd2;     // Transponder Digit 2
  CGaugeClickArea   xpd3;     // Transponder Digit 3
  CGaugeClickArea   xpd4;     // Transponder Digit 4
  SMessage      rtu_;     // RTU subsystem message
  SMessage      dme1;     // DME 1 message
  SMessage      dme2;     // DME 2 message
  SArtOffset      dmeH;     // DME Hold announcer
  SArtOffset      repl;     // XPDR Replyl announcer
  CGaugeClickArea   atci;     // ATC ID
  CGaugeClickArea   dmeh;     // DME Hold button
  CGaugeClickArea   coms;     // COM Squelch button
  CGaugeClickArea   atcs;     // ATC Standby button
  CGaugeClickArea   b1_2;     // 1/2 button
  CGaugeClickArea   adft;     // ADF Test button
  int         side;     // Side
};


//
// CCollinsAirDataGauge
//
class CCollinsAirDataGauge : public CBitmapGauge {
public:
  CCollinsAirDataGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeRectangle   scrn;     // Display screen
  CGaugeKnob      baro;     // Barometric Setting knob
  CGaugeClickArea   vs__;     // VS reference knob
  CGaugeClickArea   alt_;     // Altitude Preselect knob
  CGaugeClickArea   in__;     // Inches button
  CGaugeClickArea   mb__;     // Millibars button
};


//
// CCollinsMNDGauge
//
class CCollinsMNDGauge : public CBitmapGauge {
public:
  CCollinsMNDGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SMessage      obs_;     // OBS message
  SMessage      ap__;     // AP message
  CGaugeClickArea   frmt;     // Display Format
  CGaugeClickArea   hdg_;     // Heading
  CGaugeClickArea   crs_;     // Course
  CGaugeClickArea   brgt;     // Brightness
};


//
// CUniversalFMSGauge
//
class CUniversalFMSGauge : public CBitmapGauge {
public:
  CUniversalFMSGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeClickArea   scrn;     // Display screen
  CGaugeClickArea   l1;       // Left Select Key 1
  CGaugeClickArea   l2;       // Left Select Key 2
  CGaugeClickArea   l3;       // Left Select Key 3
  CGaugeClickArea   l4;       // Left Select Key 4
  CGaugeClickArea   l5;       // Left Select Key 5
  CGaugeClickArea   r1;       // Right Select Key 1
  CGaugeClickArea   r2;       // Right Select Key 2
  CGaugeClickArea   r3;       // Right Select Key 3
  CGaugeClickArea   r4;       // Right Select Key 4
  CGaugeClickArea   r5;       // Right Select Key 5
  CGaugeClickArea   data;     // DATA key
  CGaugeClickArea   nav;      // NAV key
  CGaugeClickArea   vnav;     // VNAV key
  CGaugeClickArea   dto;      // DTO key
  CGaugeClickArea   list;     // LIST key
  CGaugeClickArea   prev;     // PREV key
  CGaugeClickArea   fuel;     // FUEL key
  CGaugeClickArea   fpl;      // FPL key
  CGaugeClickArea   perf;     // PERF key
  CGaugeClickArea   tune;     // TUNE key
  CGaugeClickArea   menu;     // MENU key
  CGaugeClickArea   next;     // NEXT key
  CGaugeClickArea   key1;     // 1 key
  CGaugeClickArea   key2;     // 2 key
  CGaugeClickArea   key3;     // 3 key
  CGaugeClickArea   key4;     // 4 key
  CGaugeClickArea   key5;     // 5 key
  CGaugeClickArea   key6;     // 6 key
  CGaugeClickArea   key7;     // 7 key
  CGaugeClickArea   key8;     // 8 key
  CGaugeClickArea   key9;     // 9 key
  CGaugeClickArea   back;     // BACK key
  CGaugeClickArea   key0;     // 0 key
  CGaugeClickArea   msg;      // MSG key
  CGaugeClickArea   dim;      // DIM key
  CGaugeClickArea   plus;     // +/- key
  CGaugeClickArea   entr;     // ENT key
  CGaugeClickArea   keyA;     // A key
  CGaugeClickArea   keyB;     // B key
  CGaugeClickArea   keyC;     // C key
  CGaugeClickArea   keyD;     // D key
  CGaugeClickArea   keyE;     // E key
  CGaugeClickArea   keyF;     // F key
  CGaugeClickArea   keyG;     // G key
  CGaugeClickArea   keyH;     // H key
  CGaugeClickArea   keyI;     // I key
  CGaugeClickArea   keyJ;     // J key
  CGaugeClickArea   keyK;     // K key
  CGaugeClickArea   keyL;     // L key
  CGaugeClickArea   keyM;     // M key
  CGaugeClickArea   keyN;     // N key
  CGaugeClickArea   keyO;     // O key
  CGaugeClickArea   keyP;     // P key
  CGaugeClickArea   keyQ;     // Q key
  CGaugeClickArea   keyR;     // R key
  CGaugeClickArea   keyS;     // S key
  CGaugeClickArea   keyT;     // T key
  CGaugeClickArea   keyU;     // U key
  CGaugeClickArea   keyV;     // V key
  CGaugeClickArea   keyW;     // W key
  CGaugeClickArea   keyX;     // X key
  CGaugeClickArea   keyY;     // Y key
  CGaugeClickArea   keyZ;     // Z key
};


//
// CPilatusEFISPanel
//
class CPilatusEFISPanel : public CBitmapGauge {
public:
  CPilatusEFISPanel (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SMessage      pfdm;     // PFD message
  SMessage      navm;     // ND message
  CGaugeKnob      dh;       // DH knob
  CGaugeKnob      brt;      // BRT knob
  CGaugeKnob      crs;      // CRS knob
  CGaugeKnob      hdg;      // HDG knob
  CGaugeKnob      hsi;      // HSI knob
  CGaugeKnob      arc;      // ARC knob
  CGaugeKnob      nav;      // NAV knob
  CGaugeKnob      rgup;     // Range Up knob
  CGaugeKnob      rgdn;     // Range Down knob
  CGaugeKnob      nav1;     // NAV1 knob
  CGaugeKnob      nav2;     // NAV2 knob
  CGaugeKnob      k1_2;     // 1/2 knob
};


//
// CWalkerTempAirspeedGauge
//
class CWalkerTempAirspeedGauge : public CBitmapGauge {
public:
  CWalkerTempAirspeedGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeClickArea     tat;      // True Air Temp button
  CGaugeClickArea     sat;      // Static Air Temp button
  CGaugeClickArea     tas;      // True Airspeed button
};


//
// CGyroSlavingGauge
//
class CGyroSlavingGauge : public CBitmapGauge {
public:
  CGyroSlavingGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);

protected:
  SArtOffset        nedl;           // Needle bitmap
  SArtOffset        slvb;           // Slave switch bitmap
  SArtOffset        ccwb;           // Mode switch bitmap
  CGaugeRectangle     err;            // Error window
  CGaugeClickArea     slav;           // Slave button
  CGaugeClickArea     free;           // Free button
  CGaugeClickArea     mode;           // Slave/Free Toggle button
  CGaugeClickArea     ccw;            // CCW switch
  CGaugeClickArea     cw;             // CW switch
  int           lrgb_r, lrgb_g, lrgb_b;   // Line RGB colour
  char          sfxu_wav[64];
  char          sfxd_wav[64];
  int           sfxu_tag;
  int          sfxd_tag;

};


//
// CVerticalRateGauge
//
class CVerticalRateGauge : public CBitmapGauge {
public:
  CVerticalRateGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeKnob        eng;      // Engage button
  CGaugeKnob        arm;      // Arm button
  CGaugeKnob        knob;     // VS knob
  CGaugeRectangle     led;      // LED Display area
  Tag           avil;     // Avionics light subsytem
};


//
// CPropSyncGauge
//
class CPropSyncGauge : public CBitmapGauge {
public:
  CPropSyncGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CDMEGauge
//
class CDMEGauge : public CBitmapGauge {
public:
  CDMEGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  bool        hold;       // Hold mode
  int         dist_x, dist_y;   // Distance text location
  int         sped_x, sped_y;   // Speed text location
  int         time_x, time_y;   // Time text location
  CGaugeKnob      knob;       // Distance text location
  bool        tiny;       // Use tiny fonts
};


//
// CDME2Gauge
//
class CDME2Gauge : public CBitmapGauge {
public:
  CDME2Gauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  bool        hold;       // Hold mode
  int         left_x, left_y;   // DME text location
  int         rght_x, rght_y;   // SEL text location
  CGaugeClickArea   ch;         // Channel button
  CGaugeClickArea   sel;        // Select button
  CGaugeClickArea   pwr;        // Power button
};


//
// CWeatherRadarGauge
//
class CWeatherRadarGauge : public CBitmapGauge {
public:
  CWeatherRadarGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeRectangle   scrn;   // Display screen
  CGaugeClickArea   wx;     // WX button
  CGaugeClickArea   vp;     // VP button
  CGaugeClickArea   map;    // MAP button
  CGaugeClickArea   nav;    // NAV button
  CGaugeClickArea   rngp;   // RNG+ button
  CGaugeClickArea   rngm;   // RNG- button
  CGaugeClickArea   trkp;   // TRK+ button
  CGaugeClickArea   trkm;   // TRK- button
  CGaugeKnob      mode;   // Mode knob
  CGaugeKnob      tilt;   // Tile knob
  CGaugeKnob      gain;   // Gain knob
  CGaugeKnob      brit;   // Brightness knob
};


//
// CAnalogAltPreselectGauge
//
class CAnalogAltPreselectGauge : public CBitmapGauge {
public:
  CAnalogAltPreselectGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeKnob      knob;   // Altitude Select knob
  char        fdig_art[64]; // FL Digits strip PBM filename
  char        digi_art[64]; // Digits strip PBM filename
  char        zero_art[64]; // Zero digits strip PBM filename
  int         thou_x, thou_y; // Thousands digit offset
  int         hund_x, hund_y; // Hundreds digit offset
  int         ones_x, ones_y; // Ones digit offset
  int         dspc;     // Digits spacing
  int         zspc;     // Zero spacing
  CGaugeClickArea   aler;     // Altitude alert
};



/*
 * Switch gauge types
 *
 * The following gauges implement user-interactive objects such as switches, knobs,
 *   wheels, etc.
 */

//
// CMomentaryHotSpotGauge
//
class CMomentaryHotSpotGauge : public CBitmapGauge {
public:
  CMomentaryHotSpotGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};

//
// CSimpleInOutStateSwitch
//
class CSimpleInOutStateSwitch : public CBitmapGauge {
public:
  CSimpleInOutStateSwitch (void);
  virtual ~CSimpleInOutStateSwitch (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);

  //
  virtual void  Draw (void);
  virtual EClickResult  MouseClick (int x, int y, int buttons);

protected:
  char    sbmp_art[64]; // PBG artwork for switch animation
  SBitmap*  sbmp;     // Bitmap artwork
  int     onvl;     // ON value
  int     ofvl;     // OFF value
  bool    stat;     // On/Off state
  char    onht[64];   // ON help text
  char    ofht[64];   // OFF help text

  // Sound effects
  char    onsf_wav[64]; // ON sound effect
  char    ofsf_wav[64]; // OFF sound effect
  int     onsf_tag, ofsf_tag;

  char    sstr_off[64]; // ON popup string value
  char    sstr_on[64];  // OFF popup string value
  bool    mmnt;     // Momentary contact
};


//
// CLitInOutSwitch
//
class CLitInOutSwitch : public CSimpleInOutStateSwitch {
public:
  CLitInOutSwitch (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SMessage  powr;
};


//
// CSimpleSwitch
//
class CSimpleSwitch : public CGauge {
public:
  CSimpleSwitch (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);

  // CGauge methods
  virtual void  Draw (void);
  virtual ECursorResult MouseMoved (int x, int y);
  virtual EClickResult  MouseClick (int x, int y, int buttons);

protected:
  void DecState (void);
  void IncState (void);

protected:
  char    bmap_art[64]; // PBG artwork for switch animation
  SBitmap   *bmap;      // Bitmap artwork

  // Sound effects
  char    sfxu_wav[64]; // Sound effect for switch up
  char    sfxd_wav[64]; // Sound effect for switch down
  int     sfxu_tag;
  int     sfxd_tag;

  // Cursors
  char    csru_csr[64]; // Cursor for switch up region
  char    csrd_csr[64]; // Cursor for switch down region
  Tag     csru_tag;     // Unique tag for switch up cursor
  Tag     csrd_tag;     // Unique tag for switch down cursor

  // States
  int     stat_n;     // Number of states
  int     *stat;      // Array of state values
  int     sstr_n;     // Number of state strings
  char    **sstr;     // Array of stat strings
  int     orie;     // Orientation
  int     ordr;     // Order
  int     indx;     // Default index
  bool    mmnt;     // Momentary contact
  bool    mntO;     // Momentary open
};


//
// CBasicBatterySwitch
//
class CBasicBatterySwitch : public CSimpleSwitch {
public:
  CBasicBatterySwitch (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  virtual void  Draw (void);
  virtual EClickResult  MouseClick (int x, int y, int buttons);

protected:
  Tag     altt;
  Tag     batt;
  SMessage  mesgBatt;
  SMessage  mesgAlt;
  bool    stateAlt;
  bool    stateBatt;
};


//
// CTwoStateELTGauge
//
class CTwoStateELTGauge : public CSimpleSwitch {
public:
  CTwoStateELTGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CSwitchPairGauge
//
class CSwitchPairGauge : public CSimpleSwitch {
public:
  CSwitchPairGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  SMessage    s1ms;
  SMessage    s2ms;
  CGaugeClickArea s1of;
  CGaugeClickArea s1on;
  CGaugeClickArea s2of;
  CGaugeClickArea s2on;
};


//
// CSimpleFloatSwitch
//
class CSimpleFloatSwitch : public CGauge {
public:
  CSimpleFloatSwitch (void);
  virtual ~CSimpleFloatSwitch (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);

protected:
  char    bmap_art[64];

  // Cursors
  char    csru_csr[64];
  char    csrd_csr[64];
  int     csru_tag, csrd_tag;

  // Sound effects
  char    sfxu_wav[64];
  char    sfxd_wav[64];
  int     sfxu_tag, sfxd_tag;

  int     stat_n;
  float   *stat;
  int     sstr_n;
  char    **sstr;
  bool    mmnt;
};


//
// CDualSwitch
//
class CDualSwitch : public CSimpleSwitch {
public:
  CDualSwitch (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  int     nums;
  int     orie;
  SMessage  usrl;
  SMessage  usrr;
  bool    mmnt;
};


//
// CPushPullKnobGauge
//
class CPushPullKnobGauge : public CGauge {
public:
  CPushPullKnobGauge (void);
  virtual ~CPushPullKnobGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char    bmap_art[64];
  SMessage  mesg;
  SMessage  lnk1;
  int     ytop;
  int     ybtm;
  int     valu_n;
  SKnobArea *valu;
  float     lowv;
  float   high;
  bool    poll;
};


//
// CPrimerKnobGauge
//
class CPrimerKnobGauge : public CPushPullKnobGauge {
public:
  CPrimerKnobGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


class CFlapsSwitchGauge : public CPushPullKnobGauge {
public:
  CFlapsSwitchGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


class CLitLandingGearKnobGauge : public CPushPullKnobGauge {
public:
  CLitLandingGearKnobGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};



class CMixtureKnobGauge : public CPushPullKnobGauge {
public:
  CMixtureKnobGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


class CReversibleThrottleKnobGauge : public CPushPullKnobGauge {
public:
  CReversibleThrottleKnobGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SMessage    rvsr;
  char      rbmp_art[64];
  int       rtop;
  int       rbtm;
};


class CDualKnobGauge : public CGauge {
public:
  CDualKnobGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  SMessage    imsg;
  SMessage    omsg;
  float     iinc;
  float     idec;
  float     oinc;
  float     odec;
  CGaugeClickArea inca;
  CGaugeClickArea ouca;
};


class CFlyhawkLightKnobGauge : public CDualKnobGauge {
public:
  CFlyhawkLightKnobGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


class CTurnKnobGauge : public CGauge {
public:
  CTurnKnobGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char      bmap_art[64];
  float     incr;
  float     decr;
};


class CBasicMagnetoSwitch : public CSimpleSwitch {
public:
  CBasicMagnetoSwitch (void);

  // CStreamObject methods
  virtual void  Draw (void);

  // CGauge methods
  virtual EClickResult  MouseClick (int x, int y, int buttons);
  virtual EClickResult  StopClick (int x, int y, int buttons);

protected:
};


class CCoveredSwitch : public CSimpleSwitch {
public:
  CCoveredSwitch (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


class CCoveredLightButtonGauge : public CCoveredSwitch {
public:
  CCoveredLightButtonGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char    lbmp_art[64];     // Lighted button art
  SMessage  lmsg;         // Light message
};


class CVerticalSliderGauge : public CGauge {
public:
  CVerticalSliderGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};

class CTrimWheelGauge : public CGauge {
public:
  CTrimWheelGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  char      bmap_art[64];
  CGaugeClickArea down;
  CGaugeClickArea up;
};


class CTrimWheelIndicatorGauge : public CTrimWheelGauge {
public:
  CTrimWheelIndicatorGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


class CIndicatorGauge : public CGauge {
public:
  CIndicatorGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char    bmap_art[64];
  float   lval;
  float   hval;
};


class CFlapsIndicatorGauge : public CIndicatorGauge {
public:
  CFlapsIndicatorGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


class CPushButtonGauge : public CGauge {
public:
  CPushButtonGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  char    bmap_art[64];
  char    curs_csr[64];
  bool    mmnt;
};


class CLightButtonGauge : public CPushButtonGauge {
public:
  CLightButtonGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SMessage  lmsg;
  int     stat_off, stat_on;
  char    sstr_off[64];
  char    sstr_on[64];
};


class CTurnSwitchGauge : public CSimpleSwitch {
public:
  CTurnSwitchGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


class CMasterCautionWarningButtonGauge : public CGauge {
public:
  CMasterCautionWarningButtonGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);

protected:
  char    bmap_art[64];

  // Sound effect
  char      sfx_wav[64];
  int       sfx_tag;

  SMessage  smsg;
  SMessage  lmsg;
};


class CKAFireExtinguisherButton : public CGauge {
public:
  CKAFireExtinguisherButton (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);

protected:
  SArtOffset      fire;
  SArtOffset      ok;
  SArtOffset      dsch;
  
  // Sound effects
  char            sfx_wav[64];
  int             sfx_tag;

  // Cursors
  char            curs_csr[64];
  int             curs_tag;
};


class CWalkerAPPanel : public CGauge {
public:
  CWalkerAPPanel (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  CGaugeClickArea   left;
  CGaugeClickArea   rght;
  CGaugeClickArea   up;
  CGaugeClickArea   down;
  CGaugeClickArea   xfer;
  CGaugeClickArea   turb;
  CGaugeClickArea   ydon;
  CGaugeClickArea   ydof;
  CGaugeClickArea   apon;
  CGaugeClickArea   apof;
  char        enga_yd_art[64];
  char        enga_ap_art[64];
  char        knob_bnk_art[64];
  char        knob_trm_art[64];
};


class CWalkerFirePanel : public CGauge {
public:
  CWalkerFirePanel (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SMessage      fir1;
  SMessage      fir2;
  CGaugeKnob      ext1;
  CGaugeKnob      ext2;
  CGaugeClickArea   bel1;
  CGaugeClickArea   bel2;
  CGaugeRectangle   ef1;
  CGaugeRectangle   ef2;
  CGaugeAnnunciator ann1;
  CGaugeAnnunciator ann2;
};


class CLightSwitchSetGauge : public CBitmapGauge {
public:
  CLightSwitchSetGauge (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SMessage      lmsg;
};


class CRockerSwitch : public CSimpleSwitch {
public:
  CRockerSwitch (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);

  // CGauge methods
  virtual ECursorResult MouseMoved (int x, int y);

protected:
  CGaugeClickArea   one;
  CGaugeClickArea   two;
  SMessage      msg1;
  SMessage      msg2;
  char        sfx1_wav[64];
  char        sfx2_wav[64];
  int               sfx1_tag, sfx2_tag;
};


#endif    // GAUGES_H


/*

//
// CNavRadioGroup
//
class CNavRadioGroup : public CGauge {
public:
  CNavRadioGroup (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CComRadioGroup
//
class CComRadioGroup : public CGauge {
public:
  CComRadioGroup (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CTransponderRadioGroup
//
class CTransponderRadioGroup : public CGauge {
public:
  CTransponderRadioGroup (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};


//
// CAdfRadioGroup
//
class CAdfRadioGroup : public CGauge {
public:
  CAdfRadioGroup (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
};

//
// CMalybooFuelSelectGauge
//
class CMalybooFuelSelectGauge : public CBitmapGauge {
public:
  CMalybooFuelSelectGauge (void);

  // CStreamObject methods
//  int   Read (SStream *stream, Tag tag);

protected:
};

//
// CTCASGauge
//
class CTCASGauge : public CBitmapGauge {
public:
  CTCASGauge (void);

  // CStreamObject methods
//  int   Read (SStream *stream, Tag tag);

protected:
};


*/

Documentation generated by