Gauges.cpp

Go to the documentation of this file.

/*
 * Gauges.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/Gauges.h"
#include "../Include/Utility.h"
#include "../Include/Ui.h"
#include "../Include/Globals.h"
#include "../Include/Subsystems.h"


static int ClickAreaFromTag (Tag tag)
{
  int rc = 0;

  // Check that upper bytes are 'CA' or 'ca'
  unsigned long upper = (tag & 0xFFFF0000) >> 16;
  if ((upper == 0x4341) || (upper == 0x6361)) {
    unsigned long d1 = ((tag & 0x0000FF00) >> 8) - '0';
    unsigned long d0 =  (tag & 0x000000FF) - '0';
    rc = (d1 * 10) + d0;
  }

  return rc;
}


//
// Helper function to blit a SSurface to the screen, taking into account
//   OpenGL row order and DrawPixels trick
//
static void BlitSurface (SSurface *surface, int xOffset, int yOffset, int y_isiz)
{
  glRasterPos2i (xOffset, -yOffset);
  int xMove = -xOffset + surface->xScreen;
  int yMove = yOffset + y_isiz - surface->yScreen - surface->ySize;
  glBitmap (0, 0, 0, 0, xMove, yMove, NULL);

  BlitTransparent (surface, 0);
}


//
// CGaugeNeedle
//
CGaugeNeedle::CGaugeNeedle (void)
{
  shar = false;
  sizx = sizy = 0;
  offx = offy = 0;
  mind = 0;
  maxd = 360;
  strcpy (base, "");

  bmap = NULL;

  readFinished = false;
}

CGaugeNeedle::~CGaugeNeedle (void)
{
  if (bmap != NULL) {
    FreeBitmap (bmap);
    delete bmap;
  }
}

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

  switch (tag) {
  case 'file':
    // Refers to a NDL stream file containing the needle specification
    {
      char file[64];
      ReadString (file, 64, stream);
      SStream *s = new SStream;
      strcpy (s->filename, "Data\\");
      strcat (s->filename, file);
      strcpy (s->mode, "r");
      if (OpenStream (s)) {
        ReadFrom (this, s);
        CloseStream (s);
      }
      delete s;
      rc = TAG_READ;
    }
    break;

  case 'shar':
    // This needle is shared across multiple aircraft.  For now this has no effect
    shar = true;
    rc = TAG_READ;
    break;

  case 'sizx':
    ReadInt (&sizx, stream);
    rc = TAG_READ;
    break;

  case 'sizy':
    ReadInt (&sizy, stream);
    rc = TAG_READ;
    break;

  case 'offx':
    ReadInt (&offx, stream);
    rc = TAG_READ;
    break;

  case 'offy':
    ReadInt (&offy, stream);
    rc = TAG_READ;
    break;

  case 'mind':
    ReadInt (&mind, stream);
    rc = TAG_READ;
    break;

  case 'maxd':
    ReadInt (&maxd, stream);
    rc = TAG_READ;
    break;

  case 'base':
    ReadString (base, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    if (globals->logWarning)
      globals->logWarning->Write ("CGaugeNeedle::Read : Unknown tag %s", s);
  }

  return rc;
}

void CGaugeNeedle::ReadFinished (void)
{
  if (readFinished) return;

  if (strlen(base) > 0) {
    // Load bitmap
    bmap = new SBitmap;
    strcpy (bmap->bitmapName, "ART\\");
    strcat (bmap->bitmapName, base);
    strcat (bmap->bitmapName, ".PBG");
    LoadBitmap (bmap);
    nFrames = NumBitmapFrames (bmap);

    // <offx> and <offy> represent offsets of the center of the needle;
    //   adjust for the top-left corner for use in Draw() if they were specified
    int w, h;
    GetBitmapSize (bmap, &w, &h);
    if (offx != 0) {
      offx -= w / 2;
    }

    if (offy != 0) {
      offy -= h / 2;
    }
  }

  readFinished = true;
}

void CGaugeNeedle::Draw (SSurface *surface, float degrees, int cx, int cy)
{
  degrees = Wrap360 (degrees);

  if (bmap != NULL) {
    // Clamp to the min/max degrees
    if (degrees < mind) degrees = mind;
    if (degrees > maxd) degrees = maxd;

    // Convert degrees to frame number
    float fFrame = nFrames * (degrees - mind) / (maxd - mind);
    int frame = (int)fFrame;

    // cx, cy indicate offset to gauge center in the surface; calculate
    //   offset of top-left corner of needle bitmap within gauge
    int w, h;
    GetBitmapSize (bmap, &w, &h);

    // Adjust by half-width and half-height, rounding up
    cx -= (w+1)/2;
    cy -= (h+1)/2;

    // Finally draw the animation frame on the supplied surface
    DrawBitmap (surface, bmap, offx + cx, offy + cy, frame);
  }
}


//
// CGaugeRectangle
//
CGaugeRectangle::CGaugeRectangle (void)
{
  x1 = y1 = x2 = y2 = 0;
}

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

  switch (tag) {
  case 'rect':
    ReadInt (&x1, stream);
    ReadInt (&y1, stream);
    ReadInt (&x2, stream);
    ReadInt (&y2, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    if (globals->logWarning)
      globals->logWarning->Write ("CGaugeRectangle::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CGaugeClickArea
//
CGaugeClickArea::CGaugeClickArea (void)
{
  strcpy (bmap, "");
  strcpy (curs, "");
  cursTag = 0;
  strcpy (help, "");
  bm = NULL;
}

CGaugeClickArea::~CGaugeClickArea (void)
{
  if (bm != NULL) {
    FreeBitmap (bm);
    delete bm;
  }
}

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

  switch (tag) {
  case 'bmap':
    ReadString (bmap, 64, stream);
    rc = TAG_READ;
    break;

  case 'curs':
    ReadString (curs, 64, stream);
    rc = TAG_READ;
    break;

  case 'help':
    ReadString (help, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGaugeRectangle::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    if (globals->logWarning)
      globals->logWarning->Write ("CGaugeClickArea::Read : Unknown tag %s", s);
  }

  return rc;
}

void CGaugeClickArea::ReadFinished (void)
{
  // Load bitmap
  if (strlen (bmap) > 0) {
    bm = new SBitmap;
    strcpy (bm->bitmapName, "ART\\");
    strcat (bm->bitmapName, bmap);
    LoadBitmap (bm);
  }

  // Bind cursor to be used when mousing over this gauge
  cursTag = 0;
  if (strlen (curs) > 0) {
    cursTag = globals->cursormgr->BindCursor (curs);
  }
}

bool CGaugeClickArea::IsHit (int x, int y)
{
  return ((x >= x1) && (x <= x2) && (y >= y1) && (y <= y2));
}

ECursorResult CGaugeClickArea::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Check that the position is within click area bounds
  if ((cursTag != 0) && IsHit (x, y)) {
    globals->cursormgr->SetCursor (cursTag);
    rc = CURSOR_WAS_CHANGED;
  }

  return rc;
}

void CGaugeClickArea::Draw (SSurface *surface, int frame)
{
  if ((surface != NULL) && (bm != NULL)) {
//    int x = x1;
//    int y = surface->ySize - y2;
    DrawBitmap (surface, bm, x1, y1, frame);  // ***
  }
}


//
// CGaugeKnob
//
CGaugeKnob::CGaugeKnob (void)
{
  strcpy (bmap, "");
  surf = NULL;
  bmKnob = NULL;
}

CGaugeKnob::~CGaugeKnob (void)
{
  if (bmKnob != NULL) {
    FreeBitmap (bmKnob);
    delete bmKnob;
    FreeSurface (surf);
  }
}

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

  switch (tag) {
  case 'bmap':
    ReadString (bmap, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGaugeClickArea::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CGaugeClickArea::Read : Unknown tag %s", s);
  }

  return rc;
}

void CGaugeKnob::ReadFinished (void)
{
  CGaugeClickArea::ReadFinished();

  // Check if knob bitmap has been specified
  if (strlen(bmap) > 0) {
    // Load bitmap image
    bmKnob = new SBitmap;
    strcpy (bmKnob->bitmapName, "ART\\");
    strcat (bmKnob->bitmapName, bmap);
    LoadBitmap (bmKnob);

    // Create surface to draw knob on
    surf = CreateSurface ((x2 - x1 + 1), (y2 - y1 + 1));
  }
}

void CGaugeKnob::SetOffset (int offset_x, int offset_y)
{
  this->offset_x = offset_x;
  this->offset_y = offset_y;
}

void CGaugeKnob::Draw (float rotation)
{
  if ((bmKnob != NULL) && (surf != NULL)) {
    // Clamp rotation to range 0.0..1.0
    while (rotation < 0.0f) rotation += 1.0f;
    while (rotation >= 1.0f) rotation -= 1.0f;

    // Convert rotation amount to frame number
    float fFrame = NumBitmapFrames (bmKnob) * rotation;
    int frame = (int)fFrame;

    // Draw the knob animation frame
    EraseSurface (surf);
    surf->xScreen = offset_x + x1;
    surf->yScreen = offset_y + y1;
    DrawBitmap (surf, bmKnob, 0, 0, frame);
    Blit (surf);
  }
}

//  *** Memory leak cleanup complete to here

//
// CGaugeAnnunciator
//
CGaugeAnnunciator::CGaugeAnnunciator (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CGaugeClickArea::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CGaugeAnnunciator::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CGauge
//
int CGauge::sfx_source = 0;

CGauge::CGauge (void)
{
  type = GAUGE_BASE;
  unid = 0;
  x = y = w = h = 0;
  cx = cy = 0;
  memset (&mesg, 0, sizeof(SMessage));
  gmin = gmax = 0.0f;
  lite = 0;
  strcpy (mask, "");
  fore = false;
  strcpy (curs, "");
  strcpy (help, "");
  strcpy (dtyp, "");
  strcpy (dfmt, "");
  nomc = false;
  igno = false;
  surf = NULL;
}

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

  switch (tag) {
  case 'unid':
    ReadTag (&unid, stream);
    TagToString (unid_s, unid);
    rc = TAG_READ;
    break;

  case 'size':
    ReadInt (&x, stream);
    ReadInt (&y, stream);
    ReadInt (&w, stream);
    ReadInt (&h, stream);
    rc = TAG_READ;
    break;

  case 'cntr':
    ReadInt (&cx, stream);
    ReadInt (&cy, stream);
    rc = TAG_READ;
    break;

  case 'mesg':
    ReadMessage (&mesg, stream);
    rc = TAG_READ;
    break;

  case 'gmin':
    ReadFloat (&gmin, stream);
    rc = TAG_READ;
    break;

  case 'gmax':
    ReadFloat (&gmax, stream);
    rc = TAG_READ;
    break;

  case 'gtbl':
//    SkipObject (stream);
    ReadFrom (&gtbl, stream);
    rc = TAG_READ;
    break;

  case 'lite':
    ReadTag (&lite, stream);
    rc = TAG_READ;
    break;

  case 'mask':
    ReadString (mask, 64, stream);
    rc = TAG_READ;
    break;

  case 'fore':
    fore = true;
    rc = TAG_READ;
    break;

  case 'curs':
  case 'crsr':
    ReadString (curs, 64, stream);
    rc = TAG_READ;
    break;

  case 'help':
    ReadString (help, 64, stream);
    rc = TAG_READ;
    break;

  case 'dtyp':
    ReadString (dtyp, 64, stream);
    rc = TAG_READ;
    break;

  case 'dfmt':
    ReadString (dfmt, 64, stream);
    rc = TAG_READ;
    break;

  case 'nomc':
    nomc = true;
    rc = TAG_READ;
    break;

  case 'igno':
    nomc = true;
    rc = TAG_READ;
    break;

  case 'conn':
    // DEPRECATED
    {
      Tag tag;
      ReadTag (&tag, stream);
      mesg.group = (unsigned int) tag;
    }
    rc = TAG_READ;
    break;

  case 'user':
    // DEPRECATED
    {
      char user[64];
      ReadString (user, 64, stream);
    }
    rc = TAG_READ;
    break;

  case 'unit':
    // DEPRECATED
    ReadUInt (&mesg.user.u.unit, stream);
    rc = TAG_READ;
    break;

  case 'dtag':
    // DEPRECATED
    ReadUInt (&mesg.user.u.datatag, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


void CGauge::ReadFinished (void)
{
  // Create drawing surface for the gauge
  if ((w > 0) && (h > 0)) {
    surf = CreateSurface (w, h);
    surf->xScreen = x;
    surf->yScreen = y;
  }

  // Bind cursor to be used when mousing over this gauge
  cursTag = 0;
  if (strlen (curs) > 0) {
    cursTag = globals->cursormgr->BindCursor (curs);
  }
}


void CGauge::GetSize (int* x, int* y, int*w, int* h)
{
  *x = this->x;
  *y = this->y;
  *w = this->w;
  *h = this->h;
}


SSurface *CGauge::GetSurface (void)
{
  return surf;
}


//
// Update the gauge's indication value
//
void CGauge::Update (void)
{
  // Send the 'mesg' message to the supplier subsystem
  SendMessage (&mesg);

  // All gauge values resolve to floating point values
  value = 0;
  switch (mesg.dataType) {
  case TYPE_INT:
    value = (float)mesg.intData;
    break;

  case TYPE_INTPTR:
    if (mesg.intPtrData) {
      value = (float)*(mesg.intPtrData);
    }
    break;

  case TYPE_REAL:
    value = mesg.realData;
    break;

  case TYPE_REALPTR:
    if (mesg.realPtrData) {
      value = *(mesg.realPtrData);
    }
    break;

  case TYPE_NONE:
  case TYPE_VOID:
  case TYPE_CHAR:
  case TYPE_CHARPTR:
    // These are not handled by the CGauge base class.  Derived classes
    //   must implement their own Update() methods to handle returned
    //   strings and pointers.
    break;
  }

  // Clamp to gauge minimum and maximum values
  if (value < gmin) value = gmin;
  if (value > gmax) value = gmax;

  // Apply gauge translation table if appropriate
  value = gtbl.Lookup (value);
}


EClickResult CGauge::MouseClick (int x, int y, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Temporary debug
//  char debug[80];
//  sprintf (debug, "'%4s': Click at %d, %d", unid_s, x, y);
//  DrawNoticeToUser (debug, 1);

  return rc;
}


EClickResult CGauge::TrackClick (int x, int y, int buttons)
{
  // Default return code is for tracking to be ON.  This allows a gauge
  //   to handle just MouseClick and StopClick events by preserving
  //   the click result as TRACKING_ON when CPanel calls this default method
  return MOUSE_TRACKING_ON;
}


EClickResult CGauge::StopClick (int x, int y, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Temporary debug
//  char debug[80];
//  sprintf (debug, "'%4s': Stop at %d, %d", unid_s, x, y);
//  DrawNoticeToUser (debug, 1);

  return rc;
}

ECursorResult CGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Update cursor if necessary
  if (cursTag != 0) {
    // Change to this gauge's cursor
    globals->cursormgr->SetCursor (cursTag);
    rc = CURSOR_WAS_CHANGED;
  }

// Temporary debug
//  char debug[80];
//  sprintf (debug, "'%4s':  Move to %d, %d", unid_s, x, y);
//  DrawNoticeToUser (debug, 1);

  return rc;
}

void CGauge::ClearSurface (void)
{
  EraseSurface (surf);
}

void CGauge::Draw (void)
{
  ClearSurface ();
}

void CGauge::Blit (int xOffset, int yOffset, int y_isiz)
{
  BlitSurface (surf, xOffset, yOffset, y_isiz);
}


//
// CBitmapGauge
//
CBitmapGauge::CBitmapGauge (void)
{
  strcpy (bmap.art, "");
  bmap.x = bmap.y = 0;

  strcpy (over.art, "");
  over.x = over.y = 0;

  bmUnderlay = NULL;
  bmOverlay = NULL;
}


CBitmapGauge::~CBitmapGauge()
{
  if (bmUnderlay != NULL) {
    FreeBitmap (bmUnderlay);
    delete bmUnderlay;
  }

  if (bmOverlay != NULL) {
    FreeBitmap (bmOverlay);
    delete bmOverlay;
  }
}


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

  switch (tag) {
  case 'bmap':
    ReadString (bmap.art, 64, stream);
    ReadInt (&bmap.x, stream);
    ReadInt (&bmap.y, stream);
    rc = TAG_READ;
    break;

  case 'over':
    ReadString (over.art, 64, stream);
    ReadInt (&over.x, stream);
    ReadInt (&over.y, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBitmapGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


void CBitmapGauge::ReadFinished (void)
{
  CGauge::ReadFinished ();

  char *mark1 = new char[32];
  strcpy (mark1, "bmg start");

  // Load underlay and overlay bitmaps when required
  if (strlen (bmap.art) > 0) {
    bmUnderlay = new SBitmap;
    strcpy (bmUnderlay->bitmapName, "ART\\");
    strcat (bmUnderlay->bitmapName, bmap.art);
    LoadBitmap (bmUnderlay);
  }

  if (strlen (over.art) > 0) {
    bmOverlay = new SBitmap;
    strcpy (bmOverlay->bitmapName, "ART\\");
    strcat (bmOverlay->bitmapName, over.art);
    LoadBitmap (bmOverlay);
  }
  char *mark2 = new char[32];
  strcpy (mark2, "bmg end");
}


void CBitmapGauge::DrawUnderlay (void)
{
  // Draw underlay bitmap
  if (bmUnderlay != NULL) {
    DrawBitmap (surf, bmUnderlay, bmap.x, bmap.y, 0);
  }
}

void CBitmapGauge::DrawOverlay (void)
{
  // Draw overlay bitmap
  if (bmOverlay != NULL) {
    DrawBitmap (surf, bmOverlay, over.x, over.y, 0);
  }
}

void CBitmapGauge::Draw (void)
{
  ClearSurface ();
  DrawUnderlay ();
  DrawOverlay ();
}


//
// CNeedleGauge
//
CNeedleGauge::CNeedleGauge (void)
{
  radi = 0;
  sang = 0.0f;
  dunt = 1.0f;
  rang_min = 0.0f;
  rang_max = 0.0f;
  noff_x = noff_y = 0;
  noac = false;
}


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

  switch (tag) {
  case 'radi':
    ReadInt (&radi, stream);
    rc = TAG_READ;
    break;

  case 'sang':
    ReadFloat (&sang, stream);
    rc = TAG_READ;
    break;

  case 'dunt':
    ReadFloat (&dunt, stream);
    rc = TAG_READ;
    break;

  case 'rang':
    ReadFloat (&rang_min, stream);
    ReadFloat (&rang_max, stream);
    rc = TAG_READ;
    break;

  case 'noff':
    ReadInt (&noff_x, stream);
    ReadInt (&noff_y, stream);
    rc = TAG_READ;
    break;

  case 'noac':
    noac = true;
    rc = TAG_READ;
    break;

  case 'nedl':
    ReadTag (&nedl.tag, stream);
    ReadFrom (&nedl, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CNeedleGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

void CNeedleGauge::Draw (void)
{
  ClearSurface ();
  DrawUnderlay ();

  // Get indication value, this updates the 'value' field
  mesg.id = MSG_GETDATA;
  CGauge::Update ();

  // Determine animation frame corresponding to gauge angle
  float degrees = value + sang;

  // Draw needle into gauge surface
  nedl.Draw (surf, degrees, cx, cy);

  DrawOverlay ();
}



//
// CTwoNeedleGauge
//
CTwoNeedleGauge::CTwoNeedleGauge (void)
{
}


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

  switch (tag) {
  case 'ndl1':
    ReadFrom (&ndl1, stream);
    rc = TAG_READ;
    break;

  case 'ndl2':
    ReadFrom (&ndl2, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CTwoNeedleGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CThreeNeedleGauge
//
CThreeNeedleGauge::CThreeNeedleGauge (void)
{
}


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

  switch (tag) {
  case 'ndl1':
    ReadFrom (&ndl1, stream);
    rc = TAG_READ;
    break;

  case 'ndl2':
    ReadFrom (&ndl2, stream);
    rc = TAG_READ;
    break;

  case 'ndl3':
    ReadFrom (&ndl3, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CThreeNeedleGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CDigitalNeedleGauge
//
CDigitalNeedleGauge::CDigitalNeedleGauge (void)
{
  strcpy (nbak.art, "");
  nbak.x = nbak.y = 0;
  memset (&powr, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'nbak':
    ReadString (nbak.art, 64, stream);
    ReadInt (&nbak.x, stream);
    ReadInt (&nbak.y, stream);
    rc = TAG_READ;
    break;

  case 'powr':
    ReadMessage (&powr, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDigitalNeedleGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CAltimeterGauge
//
CAltimeterGauge::CAltimeterGauge (void)
{
  // Initialize members
  psiz_x = psiz_y = 0;
  strcpy (csrl_csr, "");
  strcpy (csrr_csr, "");
  csrl_tag = csrr_tag = 0;
  kpxy_x = kpxy_y = 0;
  memset (&kmsg, 0, sizeof(SMessage));
  ndl1 = ndl2 = ndl3 = NULL;
}

CAltimeterGauge::~CAltimeterGauge (void)
{
  if (ndl1 != NULL) delete ndl1;
  if (ndl2 != NULL) delete ndl2;
  if (ndl3 != NULL) delete ndl3;
}

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

  switch (tag) {
  case 'psiz':
    ReadInt (&psiz_x, stream);
    ReadInt (&psiz_y, stream);
    rc = TAG_READ;
    break;

  case 'ndl1':
    ndl1 = new CNeedleGauge;
    ReadFrom (ndl1, stream);
    rc = TAG_READ;
    break;

  case 'ndl2':
    ndl2 = new CNeedleGauge;
    ReadFrom (ndl2, stream);
    rc = TAG_READ;
    break;

  case 'ndl3':
    ndl3 = new CNeedleGauge;
    ReadFrom (ndl3, stream);
    rc = TAG_READ;
    break;

  case 'csrl':
    ReadString (csrl_csr, 64, stream);
    rc = TAG_READ;
    break;

  case 'csrr':
    ReadString (csrr_csr, 64, stream);
    rc = TAG_READ;
    break;

  case 'koll':
    ReadFrom (&koll, stream);
    rc = TAG_READ;
    break;

  case 'kpxy':
    ReadInt (&kpxy_x, stream);
    ReadInt (&kpxy_y, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    ReadFrom (&knob, stream);
    break;

  case 'kmsg':
    ReadMessage (&kmsg, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CAltimeterGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CAltimeterGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = koll.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = knob.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CRollingAltimeterGauge
//
CRollingAltimeterGauge::CRollingAltimeterGauge (void)
{
  // Initialize members
  psiz_x = psiz_y = 0;
  strcpy (zdig_art, "");
  strcpy (ndig_art, "");
  digx[0] = digx[1] = digx[2] = digx[3] = 0;
  digy = 0;
  dsiz_x = dsiz_y = 0;
  memset (&kmsg, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'psiz':
    ReadInt (&psiz_x, stream);
    ReadInt (&psiz_y, stream);
    rc = TAG_READ;
    break;

  case 'ndl1':
    ReadFrom (&ndl1, stream);
    rc = TAG_READ;
    break;

  case 'zdig':
    ReadString (zdig_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'ndig':
    ReadString (ndig_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'tdig':
    ReadString (tdig_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'digx':
    ReadInt (&digx[0], stream);
    ReadInt (&digx[1], stream);
    ReadInt (&digx[2], stream);
    ReadInt (&digx[3], stream);
    rc = TAG_READ;
    break;

  case 'digy':
    ReadInt (&digy, stream);
    rc = TAG_READ;
    break;

  case 'dsiz':
    ReadInt (&dsiz_x, stream);
    ReadInt (&dsiz_y, stream);
    rc = TAG_READ;
    break;

  case 'koll':
    ReadFrom (&koll, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;

  case 'kmsg':
    ReadMessage (&kmsg, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CRollingAltimeterGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CRollingAltimeterGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = koll.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = knob.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}



//
// CHorizonGauge
//
CHorizonGauge::CHorizonGauge (void)
{
  hoff = 0;
  pixd = 0;
  moff = 0;
  strcpy (flag_art, "");
}

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

  switch (tag) {
  case 'foot':
    ReadString (foot.art, 64, stream);
    ReadInt (&foot.x, stream);
    ReadInt (&foot.y, stream);
    rc = TAG_READ;
    break;

  case 'horz':
    ReadString (horz.art, 64, stream);
    ReadInt (&horz.x, stream);
    ReadInt (&horz.y, stream);
    rc = TAG_READ;
    break;

  case 'hoff':
    ReadInt (&hoff, stream);
    rc = TAG_READ;
    break;

  case 'irim':
    ReadString (irim.art, 64, stream);
    ReadInt (&irim.x, stream);
    ReadInt (&irim.y, stream);
    rc = TAG_READ;
    break;

  case 'orim':
    ReadString (orim.art, 64, stream);
    ReadInt (&orim.x, stream);
    ReadInt (&orim.y, stream);
    rc = TAG_READ;
    break;

  case 'fron':
    ReadString (fron.art, 64, stream);
    ReadInt (&fron.x, stream);
    ReadInt (&fron.y, stream);
    rc = TAG_READ;
    break;

  case 'pixd':
    ReadFloat (&pixd, stream);
    rc = TAG_READ;
    break;

  case 'moff':
    ReadInt (&moff, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;

  case 'flag':
    ReadString (flag_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'pich':
    ReadMessage (&pich, stream);
    rc = TAG_READ;
    break;

  case 'roll':
    ReadMessage (&roll, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CHorizonGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CHorizonGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = knob.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CFDHorizonGauge
//
CFDHorizonGauge::CFDHorizonGauge (void)
{
  strcpy (bars.art, "");
  bars.x = bars.y = 0;
}


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

  switch (tag) {
  case 'bars':
    ReadString (bars.art, 64, stream);
    ReadInt (&bars.x, stream);
    ReadInt (&bars.y, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CHorizonGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFDHorizonGauge::Read : Unknown tag %s", s);
  }

  return rc;
}



//
// CHorizontalBallGauge
//
CHorizontalBallGauge::CHorizontalBallGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CHorizontalBallGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CAirspeedGauge
//
CAirspeedGauge::CAirspeedGauge (void)
{
}

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

  switch (tag) {
  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;

  case 'mmo_':
    ReadFrom (&mmo_, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CAirspeedGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CAirspeedGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = knob.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CVerticalSpeedGauge
//
CVerticalSpeedGauge::CVerticalSpeedGauge (void)
{
  strcpy (vsbg.art, "");
  vsbg.x = vsbg.y = 0;
  memset (&vmsg, 0, sizeof(SMessage));
  bmBug = NULL;
}

CVerticalSpeedGauge::~CVerticalSpeedGauge (void)
{
  if (bmBug != NULL) {
    FreeBitmap (bmBug);
    delete bmBug;
  }
}

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

  switch (tag) {
  case 'vsbg':
    ReadString (vsbg.art, 64, stream);
    ReadInt (&vsbg.x, stream);
    ReadInt (&vsbg.y, stream);
    rc = TAG_READ;
    break;

  case 'vskb':
    ReadFrom (&vskb, stream);
    rc = TAG_READ;
    break;

  case 'vmsg':
    ReadMessage (&vmsg, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CVerticalSpeedGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

void CVerticalSpeedGauge::ReadFinished (void)
{
  if (strlen (vsbg.art) > 0) {
    strcpy (bmBug->bitmapName, "ART\\");
    strcat (bmBug->bitmapName, vsbg.art);
    LoadBitmap (bmBug);
  }

  CNeedleGauge::ReadFinished ();
}

ECursorResult CVerticalSpeedGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = vskb.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}

void CVerticalSpeedGauge::Draw (void)
{
  // Draw vertical speed needle
  CNeedleGauge::Draw ();

  if (bmBug != NULL) {
    // Get vertical speed bug value
    vmsg.id = MSG_GETDATA;
    vmsg.dataType = TYPE_REAL;
    SendMessage (&vmsg);
    int frame = 0;
    if (vmsg.result == MSG_PROCESSED) {
    }

    DrawBitmap (surf, bmBug, vsbg.x, vsbg.y, frame);
  }
}


//
// CDirectionalGyroGauge
//
CDirectionalGyroGauge::CDirectionalGyroGauge (void)
{
  strcpy (apbg.art, "");
  apbg.x = apbg.y = 0;

  strcpy (apkb.art, "");
  apkb.x1 = apkb.y1 = apkb.x2 = apkb.y2 = 0;

  strcpy (knob.art, "");
  knob.x1 = knob.y1 = knob.x2 = knob.y2 = 0;
}

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

  switch (tag) {
  case 'apbg':
    ReadString (apbg.art, 64, stream);
    ReadInt (&apbg.x, stream);
    ReadInt (&apbg.y, stream);
    rc = TAG_READ;
    break;

  case 'apkb':
    ReadString (apkb.art, 64, stream);
    ReadInt (&apkb.x1, stream);
    ReadInt (&apkb.y1, stream);
    ReadInt (&apkb.x2, stream);
    ReadInt (&apkb.y2, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    ReadString (knob.art, 64, stream);
    ReadInt (&knob.x1, stream);
    ReadInt (&knob.y1, stream);
    ReadInt (&knob.x2, stream);
    ReadInt (&knob.y2, stream);
    rc = TAG_READ;
    break;

  case 'bias':
    ReadTag (&bias, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDirectionalGyroGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CVacuumGauge
//
CVacuumGauge::CVacuumGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CVacuumGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

//
// CSuctionGauge
//
CSuctionGauge::CSuctionGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CSuctionGauge::Read : Unknown tag %s", s);
  }

  return rc;
}



//
// CFuelGauge
//
CFuelGauge::CFuelGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CFuelFlowGauge
//
CFuelFlowGauge::CFuelFlowGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelFlowGauge::Read : Unknown tag %s", s);
  }

  return rc;
}



//
// COilPressureGauge
//
COilPressureGauge::COilPressureGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("COilPressureGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// COilTemperatureGauge
//
COilTemperatureGauge::COilTemperatureGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("COilTemperatureGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CTachometerGauge
//
CTachometerGauge::CTachometerGauge (void)
{
  hobb = false;
}

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

  switch (tag) {
  case 'hobb':
    SkipObject (stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CTachometerGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CDualTachometerGauge
//
CDualTachometerGauge::CDualTachometerGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CTwoNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDualTachometerGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CN1TachometerGauge
//
CN1TachometerGauge::CN1TachometerGauge (void)
{
}

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

  switch (tag) {
  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CTwoNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CN1TachometerGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CN1TachometerGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = knob.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CExhaustGasTemperatureGauge
//
CExhaustGasTemperatureGauge::CExhaustGasTemperatureGauge (void)
{
  egtr = 0.0f;
  strcpy (egtn_art, "");
}

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

  switch (tag) {
  case 'egtr':
    ReadFloat (&egtr, stream);
    rc = TAG_READ;
    break;

  case 'egtn':
    ReadString (egtn_art, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CExhaustGasTemperatureGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CBasicCompassGauge
//
CBasicCompassGauge::CBasicCompassGauge (void)
{
  strcpy (comp_art, "");
  wind = 0;
  orgx = 0;
  nton = 0;
}

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

  switch (tag) {
  case 'comp':
    ReadString (comp_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'wind':
    ReadInt (&wind, stream);
    rc = TAG_READ;
    break;

  case 'orgx':
    ReadInt (&orgx, stream);
    rc = TAG_READ;
    break;

  case 'nton':
    ReadInt (&nton, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBasicCompassGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CAnalogClockGauge
//
CAnalogClockGauge::CAnalogClockGauge (void)
{
}


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

  if (rc == TAG_IGNORED) {
    rc = CTwoNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CAnalogClockGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CAmmeterGauge
//
CAmmeterGauge::CAmmeterGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CAmmeterGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CFlyhawkDigitalClockGauge
//
CFlyhawkDigitalClockGauge::CFlyhawkDigitalClockGauge (void)
{
  oatd_x1 = oatd_y1 = oatd_x2 = oatd_y2 = 0;
  clkd_x1 = clkd_y1 = clkd_x2 = clkd_y2 = 0;
  ft13 = false;
  noco = false;
  cgap = 0;
  frgb_r = frgb_g = frgb_b = 240;
}

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

  switch (tag) {
  case 'oatd':
    ReadInt (&oatd_x1, stream);
    ReadInt (&oatd_y1, stream);
    ReadInt (&oatd_x2, stream);
    ReadInt (&oatd_y2, stream);
    rc = TAG_READ;
    break;

  case 'clkd':
    ReadInt (&clkd_x1, stream);
    ReadInt (&clkd_y1, stream);
    ReadInt (&clkd_x2, stream);
    ReadInt (&clkd_y2, stream);
    rc = TAG_READ;
    break;

  case 'bupp':
    ReadFrom (&bupp, stream);
    rc = TAG_READ;
    break;

  case 'bcon':
    ReadFrom (&bcon, stream);
    rc = TAG_READ;
    break;

  case 'bsel':
    ReadFrom (&bsel, stream);
    rc = TAG_READ;
    break;

  case 'bbot':
    ReadFrom (&bbot, stream);
    rc = TAG_READ;
    break;

  case 'ft13':
    {
      int i;
      ReadInt (&i, stream);
      ft13 = (i != 0);
    }
    rc = TAG_READ;
    break;

  case 'noco':
    {
      int i;
      ReadInt (&i, stream);
      noco = (i != 0);
    }
    rc = TAG_READ;
    break;

  case 'cgap':
    ReadInt (&cgap, stream);
    rc = TAG_READ;
    break;

  case 'frgb':
    ReadInt (&frgb_r, stream);
    ReadInt (&frgb_g, stream);
    ReadInt (&frgb_b, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlyhawkDigitalClockGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CFlyhawkDigitalClockGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = bupp.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = bsel.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = bcon.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = bbot.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CBasicDigitalClockGauge
//
CBasicDigitalClockGauge::CBasicDigitalClockGauge (void)
{
  tick_x = tick_y = 0;
  tkut = tklt = tkft = tket = 0;
}

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

  switch (tag) {
  case 'tick':
    ReadInt (&tick_x, stream);
    ReadInt (&tick_y, stream);
    rc = TAG_READ;
    break;

  case 'tkut':
    ReadInt (&tkut, stream);
    rc = TAG_READ;
    break;

  case 'tklt':
    ReadInt (&tklt, stream);
    rc = TAG_READ;
    break;

  case 'tkft':
    ReadInt (&tkft, stream);
    rc = TAG_READ;
    break;

  case 'tket':
    ReadInt (&tket, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CFlyhawkDigitalClockGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBasicDigitalClockGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CBasicADFGauge
//
CBasicADFGauge::CBasicADFGauge (void)
{
  comp_tag = 0;

  comp = NULL;
  knob = NULL;
  hdng = NULL;

  compass = 0;
}

CBasicADFGauge::~CBasicADFGauge (void)
{
  if (comp != NULL) delete comp;
  if (knob != NULL) delete knob;
  if (hdng != NULL) delete hdng;
}

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

  switch (tag) {
  case 'comp':
    ReadTag (&comp_tag, stream);
    comp = new CGaugeNeedle;
    ReadFrom (comp, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    knob = new CGaugeKnob;
    ReadFrom (knob, stream);
    rc = TAG_READ;
    break;

  case 'hdng':
    hdng = new CGaugeNeedle;
    ReadFrom (hdng, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBasicADFGaugeGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

void CBasicADFGauge::ReadFinished (void)
{
  CNeedleGauge::ReadFinished ();

  if (knob != NULL) knob->SetOffset (x, y);
}

ECursorResult CBasicADFGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (knob != NULL) {
    if (rc == CURSOR_NOT_CHANGED) rc = knob->MouseMoved (x, y);
  }

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CNeedleGauge::MouseMoved (x, y);
  }

  return rc;
}

EClickResult CBasicADFGauge::MouseClick (int x, int y, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Only handle left/right mouse clicks
  if ((buttons & (MOUSE_BUTTON_LEFT | MOUSE_BUTTON_RIGHT)) == 0) {
    return rc;
  }

  if (knob != NULL) {
    if (knob->IsHit(x, y)) {
      // Increment/Decrement compass card setting
      if (buttons & MOUSE_BUTTON_LEFT) {
        compass = Wrap360 (compass - 1.0f);
      } else {
        compass = Wrap360 (compass + 1.0f);
      }
    }
  }

  return rc;
}

void CBasicADFGauge::Draw (void)
{
  ClearSurface ();
  DrawUnderlay ();

  // Get navaid pointer from ADF radio
  mesg.id = MSG_GETDATA;
  mesg.user.u.datatag = 'navd';
  SendMessage (&mesg);
  float navd = mesg.realData;

  // Draw compass card
  if (comp != NULL) comp->Draw (surf, compass, cx, cy);

  // Draw default needle, ADF direction finder
  nedl.Draw (surf, navd, cx, cy);

  // Draw heading pointer (not used in any default aircraft?)
  if (hdng != NULL) hdng->Draw (surf, navd, cx, cy);

  // Draw knob surface, one knob rotation per 30 degrees?
  float degPerRev = 30.0f;
  if (knob != NULL) knob->Draw (fmodf(compass, degPerRev) / degPerRev);

  DrawOverlay ();
}

void CBasicADFGauge::Blit (int xOffset, int yOffset, int y_isiz)
{
  BlitSurface (surf, xOffset, yOffset, y_isiz);
  BlitSurface (knob->surf, xOffset, yOffset, y_isiz);
}


//
// CDigitalReadoutGauge
//
CDigitalReadoutGauge::CDigitalReadoutGauge (void)
{
  maxd = 0;
  strcpy (wdig_art, "");
  strcpy (fdig_art, "");
  digY = 0;
  num_digX = 0;
  digX = NULL;
  whol = false;
  padz = false;
}

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

  switch (tag) {
  case 'maxd':
    ReadInt (&maxd, stream);
    rc = TAG_READ;
    break;

  case 'wdig':
    ReadString (wdig_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'fdig':
    ReadString (fdig_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'digY':
    ReadInt (&digY, stream);
    rc = TAG_READ;
    break;

  case 'digX':
    {
      ReadInt (&num_digX, stream);
      digX = new int[num_digX];
      for (int i=0; i<num_digX; i++) {
        ReadInt (&digX[i], stream);
      }
    }
    rc = TAG_READ;
    break;

  case 'whol':
    {
      int i;
      ReadInt (&i, stream);
      whol = (i != 0);
    }
    rc = TAG_READ;
    break;

  case 'padz':
    {
      int i;
      ReadInt (&i, stream);
      padz = (i != 0);
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDigitalReadoutGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CDigitsReadoutGauge
//
CDigitsReadoutGauge::CDigitsReadoutGauge (void)
{
  frgb_r = frgb_g = frgb_b = 240;
  strcpy (just, "");
}

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

  switch (tag) {
  case 'frgb':
    ReadInt (&frgb_r, stream);
    ReadInt (&frgb_g, stream);
    ReadInt (&frgb_b, stream);
    rc = TAG_READ;
    break;

  case 'just':
    ReadString (just, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDigitsReadoutGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CCabinPressureRateKnobGauge
//
CCabinPressureRateKnobGauge::CCabinPressureRateKnobGauge (void)
{
  ofxy_x = ofxy_y = 0;
  alti_min = alti_max = 0;
  rate_min = rate_max = 0;
  strcpy (onsf, "");
  strcpy (ofsf, "");
}


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

  switch (tag) {
  case 'ofxy':
    ReadInt (&ofxy_x, stream);
    ReadInt (&ofxy_y, stream);
    rc = TAG_READ;
    break;

  case 'alti':
    ReadFloat (&alti_min, stream);
    ReadFloat (&alti_max, stream);
    rc = TAG_READ;
    break;

  case 'rate':
    ReadFloat (&rate_min, stream);
    ReadFloat (&rate_max, stream);
    rc = TAG_READ;
    break;

  case 'cabn':
    ReadFrom (&cabn, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;

  case 'onsf':
    ReadString (onsf, 64, stream);
    rc = TAG_READ;
    break;

  case 'ofsf':
    ReadString (ofsf, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCabinPressureRateKnobGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CCabinPressureRateKnobGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = cabn.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = knob.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CCabinPressureGauge
//
CCabinPressureGauge::CCabinPressureGauge (void)
{
}

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

  switch (tag) {
  case 'alti':
    ReadFrom (&alti, stream);
    rc = TAG_READ;
    break;

  case 'diff':
    ReadFrom (&diff, stream);
    rc = TAG_READ;
    break;

  case 'rate':
    ReadFrom (&rate, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCabinPressureGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CBrakePressureGauge
//
CBrakePressureGauge::CBrakePressureGauge (void)
{
}

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

  switch (tag) {
  case 'left':
    ReadFrom (&left, stream);
    rc = TAG_READ;
    break;

  case 'rght':
    ReadFrom (&rght, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CTwoNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBrakePressureGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CBrakePressureGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = left.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = rght.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CAOANeedleGauge
//
CAOANeedleGauge::CAOANeedleGauge (void)
{
}

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

  switch (tag) {
  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CTwoNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CAOANeedleGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CAOANeedleGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = knob.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CTurnCoordinatorGauge
//
CTurnCoordinatorGauge::CTurnCoordinatorGauge (void)
{
  strcpy (plan_art, "");
  poff_x = poff_y = 0;
  strcpy (ball_art, "");
  boff_x = boff_y = 0;
  pcon = bcon = 0;
  Ltrn = Rtrn = 0;
}

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

  switch (tag) {
  case 'plan':
    ReadString (plan_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'poff':
    ReadInt (&poff_x, stream);
    ReadInt (&poff_y, stream);
    rc = TAG_READ;
    break;

  case 'ball':
    ReadString (ball_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'boff':
    ReadInt (&boff_x, stream);
    ReadInt (&boff_y, stream);
    rc = TAG_READ;
    break;

  case 'pcon':
    ReadTag (&pcon, stream);
    rc = TAG_READ;
    break;

  case 'bcon':
    ReadTag (&bcon, stream);
    rc = TAG_READ;
    break;

  case 'Ltrn':
    ReadInt (&Ltrn, stream);
    rc = TAG_READ;
    break;

  case 'Rtrn':
    ReadInt (&Rtrn, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CTurnCoordinatorGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

//
// CHSIGauge
//
CHSIGauge::CHSIGauge (void)
{
  rang_min = 0;
  rang_max = 360;
  memset (&obsm, 0, sizeof(SMessage));
  memset (&bugm, 0, sizeof(SMessage));
  memset (&fcs, 0, sizeof(SMessage));
  radi_tag = 0;
  radi_unit = 0;
  gsdf = 0;
}

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

  switch (tag) {
  case 'comp':
    ReadString (comp.art, 64, stream);
    ReadInt (&comp.x, stream);
    ReadInt (&comp.y, stream);
    rc = TAG_READ;
    break;

  case 'cour':
    ReadString (cour.art, 64, stream);
    ReadInt (&cour.x, stream);
    ReadInt (&cour.y, stream);
    rc = TAG_READ;
    break;

  case 'devi':
    ReadString (devi.art, 64, stream);
    ReadInt (&devi.x, stream);
    ReadInt (&devi.y, stream);
    rc = TAG_READ;
    break;

  case 'devb':
    ReadString (devb.art, 64, stream);
    ReadInt (&devb.x, stream);
    ReadInt (&devb.y, stream);
    rc = TAG_READ;
    break;

  case 'apbg':
    ReadString (apbg.art, 64, stream);
    ReadInt (&apbg.x, stream);
    ReadInt (&apbg.y, stream);
    rc = TAG_READ;
    break;

  case 'to__':
    ReadString (to.art, 64, stream);
    ReadInt (&to.x, stream);
    ReadInt (&to.y, stream);
    rc = TAG_READ;
    break;

  case 'from':
    ReadString (from.art, 64, stream);
    ReadInt (&from.x, stream);
    ReadInt (&from.y, stream);
    rc = TAG_READ;
    break;

  case 'glid':
    ReadString (glid.art, 64, stream);
    ReadInt (&glid.x, stream);
    ReadInt (&glid.y, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;

  case 'apkb':
    ReadFrom (&apkb, stream);
    rc = TAG_READ;
    break;

  case 'obsm':
    ReadMessage (&obsm, stream);
    rc = TAG_READ;
    break;

  case 'bugm':
    ReadMessage (&bugm, stream);
    rc = TAG_READ;
    break;

  case 'fcs_':
    ReadMessage (&fcs, stream);
    rc = TAG_READ;
    break;

  case 'rang':
    ReadFloat (&rang_min, stream);
    ReadFloat (&rang_max, stream);
    rc = TAG_READ;
    break;

  case 'radi':
    ReadTag (&radi_tag, stream);
    ReadInt (&radi_unit, stream);
    rc = TAG_READ;
    break;

  case 'gsdf':
    ReadFloat (&gsdf, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CHSIGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CHSIGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = knob.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = apkb.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CFlyhawkELTGauge
//
CFlyhawkELTGauge::CFlyhawkELTGauge (void)
{
  strcpy (ulit_art, "");
  strcpy (lit_art, "");
  strcpy (csru_csr, "");
  strcpy (csrd_csr, "");
  strcpy (sfxu_wav, "");
  strcpy (sfxd_wav, "");
}

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

  switch (tag) {
  case 'ulit':
    ReadString (ulit_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'lit ':
    ReadString (lit_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'csru':
    ReadString (csru_csr, 64, stream);
    rc = TAG_READ;
    break;

  case 'csrd':
    ReadString (csrd_csr, 64, stream);
    rc = TAG_READ;
    break;

  case 'sfxu':
    ReadString (sfxu_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'sfxd':
    ReadString (sfxd_wav, 64, stream);
    rc = TAG_READ;
    break;
  }
  
  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlyhawkELTGauge::Read : Unknown tag %s", s);
  }

  return rc;
}



//
// CSlipIndicatorGauge
//
CSlipIndicatorGauge::CSlipIndicatorGauge (void)
{
  strcpy (ball_art, "");
}


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

  switch (tag) {
  case 'ball':
    ReadString (ball_art, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CHSIGauge::Read : Unknown tag %s", s);
  }

  return rc;
}



//
// CHobbsMeterGauge
//
CHobbsMeterGauge::CHobbsMeterGauge (void)
{
  strcpy (blak_art, "");
  strcpy (whit_art, "");
}


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

  switch (tag) {
  case 'blak':
    ReadString (blak_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'whit':
    ReadString (whit_art, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CHobbsMeterGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CNavigationGauge
//
CNavigationGauge::CNavigationGauge (void)
{
  // Subsystem message
  radi_tag = 0;
  radi_unit = 0;
  // Compass card needle
  comp_tag = 0;
  // Localizer needle
  strcpy (lndl.art, "");
  lndl.x = lndl.y = 0;
  // Glideslope needle
  strcpy (gndl.art, "");
  gndl.x = gndl.y = 0;

  // OBS
  strcpy (obs.art, "");
  obs.x1 = obs.y1 = obs.x2 = obs.y2 = 0;

  obsSetting = 0;
  obsKnobClick = false;

  // To/From flags
  strcpy (wtab_art, "");
  strcpy (ttab_art, "");
  strcpy (ftab_art, "");
  ntpl_x = ntpl_y = 0;
  gspl_x = gspl_y = 0;
  memset (&fcs, 0, sizeof(SMessage));

  // Initialize surfaces
  surfObsKnob = NULL;

  // Initialize bitmaps
  bmObsKnob = NULL;
  nObsKnobFrames = 0;
  bmLocalizer = NULL;
  bmGlideslope = NULL;
  bmWarnTab = NULL;
  bmFromTab = NULL;
  bmToTab = NULL;
}

CNavigationGauge::~CNavigationGauge (void)
{
  if (bmObsKnob != NULL) {
    FreeBitmap (bmObsKnob);
    delete bmObsKnob;
  }
  if (bmLocalizer != NULL) {
    FreeBitmap (bmLocalizer);
    delete bmLocalizer;
  }
  if (bmGlideslope != NULL) {
    FreeBitmap (bmGlideslope);
    delete bmGlideslope;
  }
  if (bmWarnTab != NULL) {
    FreeBitmap (bmWarnTab);
    delete bmWarnTab;
  }
  if (bmFromTab != NULL) {
    FreeBitmap (bmFromTab);
    delete bmFromTab;
  }
  if (bmToTab != NULL) {
    FreeBitmap (bmToTab);
    delete bmToTab;
  }
}

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

  switch (tag) {
  case 'comp':
    ReadTag (&comp_tag, stream);
    ReadFrom (&comp_ndl, stream);
    rc = TAG_READ;
    break;

  case 'lndl':
    ReadString (lndl.art, 64, stream);
    ReadInt (&lndl.x, stream);
    ReadInt (&lndl.y, stream);
    rc = TAG_READ;
    break;

  case 'gndl':
    ReadString (gndl.art, 64, stream);
    ReadInt (&gndl.x, stream);
    ReadInt (&gndl.y, stream);
    rc = TAG_READ;
    break;

  case 'obs_':
    ReadString (obs.art, 64, stream);
    ReadInt (&obs.x1, stream);
    ReadInt (&obs.y1, stream);
    ReadInt (&obs.x2, stream);
    ReadInt (&obs.y2, stream);
    rc = TAG_READ;
    break;

  case 'wtab':
    ReadString (wtab_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'ttab':
    ReadString (ttab_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'ftab':
    ReadString (ftab_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'ntpl':
    ReadInt (&ntpl_x, stream);
    ReadInt (&ntpl_y, stream);
    rc = TAG_READ;
    break;

  case 'gspl':
    ReadInt (&gspl_x, stream);
    ReadInt (&gspl_y, stream);
    rc = TAG_READ;
    break;

  case 'radi':
    ReadTag (&radi_tag, stream);
    ReadInt (&radi_unit, stream);
    rc = TAG_READ;
    break;

  case 'fcs_':
    ReadMessage (&fcs, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CNavigationGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

void CNavigationGauge::ReadFinished ()
{
  CBitmapGauge::ReadFinished ();

  // Initialize message attributes
  mesg.group = radi_tag;
  mesg.user.u.unit = radi_unit;

  if (strlen (obs.art) > 0) {
    // Create surface for OBS knob
    surfObsKnob = CreateSurface ((obs.x2 - obs.x1) + 1, (obs.y2 - obs.y1) + 1);
    surfObsKnob->xScreen = obs.x1 + x;
    surfObsKnob->yScreen = obs.y1 + y;

    // Load OBS knob bitmap
    bmObsKnob = new SBitmap;
    strcpy (bmObsKnob->bitmapName, "ART\\");
    strcat (bmObsKnob->bitmapName, obs.art);
    LoadBitmap (bmObsKnob);
    nObsKnobFrames = NumBitmapFrames (bmObsKnob);
  }

  if (strlen (lndl.art) > 0) {
    // Load localizer needle bitmap
    bmLocalizer = new SBitmap;
    strcpy (bmLocalizer->bitmapName, "ART\\");
    strcat (bmLocalizer->bitmapName, lndl.art);
    LoadBitmap (bmLocalizer);
    nLocalizerFrames = NumBitmapFrames (bmLocalizer);
    localizerFramesPerDeg = (float)nLocalizerFrames / 20.0f;
  }

  if (strlen(gndl.art) > 0) {
    // Load glideslope needle bitmap
    bmGlideslope = new SBitmap;
    strcpy (bmGlideslope->bitmapName, "ART\\");
    strcat (bmGlideslope->bitmapName, gndl.art);
    LoadBitmap (bmGlideslope);
    nGlideslopeFrames = NumBitmapFrames (bmGlideslope);
    glideslopeFramesPerDeg = (float)nGlideslopeFrames / 20.0f;
  }

  if (strlen(wtab_art) > 0) {
    // Load WARN flag bitmap
    bmWarnTab = new SBitmap;
    strcpy (bmWarnTab->bitmapName, "ART\\");
    strcat (bmWarnTab->bitmapName, wtab_art);
    LoadBitmap (bmWarnTab);
  }

  if (strlen(ttab_art) > 0) {
    // Load TO flag bitmap
    bmToTab = new SBitmap;
    strcpy (bmToTab->bitmapName, "ART\\");
    strcat (bmToTab->bitmapName, ttab_art);
    LoadBitmap (bmToTab);
  }

  if (strlen(ftab_art) > 0) {
    // Load FROM flag bitmap
    bmFromTab = new SBitmap;
    strcpy (bmFromTab->bitmapName, "ART\\");
    strcat (bmFromTab->bitmapName, ftab_art);
    LoadBitmap (bmFromTab);
  }
}

EClickResult CNavigationGauge::MouseClick (int x, int y, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Only handle left/right mouse clicks
  if ((buttons & (MOUSE_BUTTON_LEFT | MOUSE_BUTTON_RIGHT)) == 0) {
    return rc;
  }

  // Check for hit on OBS knob
  if ((x >= obs.x1) && (x <= obs.x2) &&
      (y >= obs.y1) && (y <= obs.y2))
  {
    // Initialize OBS knob hold-down values
    obsKnobClick = true;
    obsKnobTickRate = 0.5f;
    obsKnobTickRateTimer = globals->timemgr->GetElapsedSimTime();
    obsKnobLastTick = 0;

    if (buttons & MOUSE_BUTTON_LEFT) {
      // Set OBS decrement rate to -1 deg per tick
      obsRate = -1;
    } else {
      // Set OBS decrement rate to +1 deg per tick
      obsRate = +1;
    }
    rc = MOUSE_TRACKING_ON;
  }

  return rc;
}

EClickResult CNavigationGauge::StopClick (int x, int y, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Release OBS knob click if it is set
  if (obsKnobClick) obsKnobClick = false;

  return rc;
}

void CNavigationGauge::Draw (void)
{
  ClearSurface ();
  DrawUnderlay ();

  // Check for OBS increment
  if (obsKnobClick) {
    float simElapsed = globals->timemgr->GetElapsedSimTime();
    // Check for tick rate increase
    if ((simElapsed - obsKnobTickRateTimer) >= 2.0f) {
      // Double the rate, up to a reasonable maximum
      obsKnobTickRateTimer += 2.0f;
      if (obsKnobTickRate > 0.05f) {
        obsKnobTickRate /= 2;
      }
    }

    // Check for OBS update
    if ((simElapsed - obsKnobLastTick) >= obsKnobTickRate) {
      obsKnobLastTick = simElapsed;
      obsSetting = Wrap360 (obsSetting + (float)obsRate);
    }
  }

  // Get navaid pointer from radio subsystem
  bool navdTuned = false;
  float navd = 0;
  mesg.id = MSG_GETDATA;
  mesg.user.u.datatag = 'navd';
  SendMessage (&mesg);
  if (mesg.dataType == TYPE_REAL) {
    navdTuned = true;
    navd = mesg.realData;
  }

  // Draw compass card
  comp_ndl.Draw (surf, obsSetting, cx, cy);

  // Draw localizer flags
  if (navdTuned) {
    float diff = fabs(navd - obsSetting);
    static const float deadZone = 7.0f;    // Degrees of dead zone around 90-deg offset
    if (diff > (90.0f + deadZone)) {
      // Display FR flag
      DrawBitmap (surf, bmFromTab, ntpl_x, ntpl_y, 0);
    } else if (diff < (90.0f - deadZone)) {
      // Display TO flag
      DrawBitmap (surf, bmToTab, ntpl_x, ntpl_y, 0);
    } else {
      // Display WARN flag
      DrawBitmap (surf, bmWarnTab, ntpl_x, ntpl_y, 0);
    }
  } else {
    // No navaid tuned...display WARN flag
    DrawBitmap (surf, bmWarnTab, ntpl_x, ntpl_y, 0);
  }

  // Draw localizer needle
  if (bmLocalizer) {
    int frame = nLocalizerFrames / 2;
    if (navdTuned) {
      float diff = navd - obsSetting;
      frame += (int)(diff * localizerFramesPerDeg);
      if (frame < 0) frame = 0;
      if (frame >= nLocalizerFrames) frame = nLocalizerFrames - 1;

      char debug[80];
      sprintf (debug, "navd=%f  obs=%f   diff=%f  frame=%d",
        navd, obsSetting, diff, frame);
      DrawNoticeToUser (debug, 1);
    }
    DrawBitmap (surf, bmLocalizer, lndl.x, lndl.y, frame);
  }

  // Draw glideslope needle
  if (bmGlideslope) {
    int frame = nGlideslopeFrames / 2;
    DrawBitmap (surf, bmGlideslope, gndl.x, gndl.y, frame);
  }

  // Draw OBS knob, one rotation per 30 degrees
  float degPerRev = 30.0f;
  float obsRotation = fmodf(obsSetting, degPerRev) / degPerRev;
  int obsFrame = (int)((float)nObsKnobFrames * obsRotation);
  if ((surfObsKnob != NULL) && (bmObsKnob != NULL)) {
    EraseSurface (surfObsKnob);
    DrawBitmap (surfObsKnob, bmObsKnob, 0, 0, obsFrame);
  }

  DrawOverlay ();
}

void CNavigationGauge::Blit (int xOffset, int yOffset, int y_isiz)
{
  BlitSurface (surf, xOffset, yOffset, y_isiz);
  BlitSurface (surfObsKnob, xOffset, yOffset, y_isiz);
}


//
// CBKKX155ComPresets
//

CBKKX155ComPresets::CBKKX155ComPresets (void)
{
  for (int i=0; i<32; i++) {
    freq[i] = 118.000;
  }
}

void CBKKX155ComPresets::Load (const char *txtFilename)
{
}

int CBKKX155ComPresets::Read (SStream *stream, Tag tag)
{
  int rc = 0;
  return rc;
}

float CBKKX155ComPresets::GetFreq (int i)
{
  float rc = 0;

  if ((i >= 1) && (i <= 32)) rc = freq[i-1];

  return rc;
}

void CBKKX155ComPresets::SetFreq (int i, float f)
{
  if ((i >= 1) && (i <= 32)) freq[i-1] = f;
}


//
// CBKNavComKX155Gauge
//
CBKNavComKX155Gauge::CBKNavComKX155Gauge (void)
{
  radi_tag = 0;
  radi_unit = 0;

  comChannel = 1;
  comProgramFlash = true;
  comProgramTimer = 0;
  comProgramFreq = false;
}

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

  switch (tag) {
  case 'radi':
    ReadTag (&radi_tag, stream);
    ReadInt (&radi_unit, stream);
    rc = TAG_READ;
    break;

  case 'ca01':
    ReadFrom (&ca01, stream);
    rc = TAG_READ;
    break;

  case 'ca02':
    ReadFrom (&ca02, stream);
    rc = TAG_READ;
    break;

  case 'ca03':
    ReadFrom (&ca03, stream);
    rc = TAG_READ;
    break;

  case 'ca04':
    ReadFrom (&ca04, stream);
    rc = TAG_READ;
    break;

  case 'ca05':
    ReadFrom (&ca05, stream);
    rc = TAG_READ;
    break;

  case 'ca06':
    ReadFrom (&ca06, stream);
    rc = TAG_READ;
    break;

  case 'ca07':
    ReadFrom (&ca07, stream);
    rc = TAG_READ;
    break;

  case 'ca08':
    ReadFrom (&ca08, stream);
    rc = TAG_READ;
    break;

  case 'ca09':
    ReadFrom (&ca09, stream);
    rc = TAG_READ;
    break;

  case 'ca10':
    ReadFrom (&ca10, stream);
    rc = TAG_READ;
    break;

  case 'ca11':
    ReadFrom (&ca11, stream);
    rc = TAG_READ;
    break;

  case 'ca12':
    ReadFrom (&ca12, stream);
    rc = TAG_READ;
    break;

  case 'ca13':
    ReadFrom (&ca13, stream);
    rc = TAG_READ;
    break;

  case 'ca14':
    ReadFrom (&ca14, stream);
    rc = TAG_READ;
    break;

  case 'ca15':
    ReadFrom (&ca15, stream);
    rc = TAG_READ;
    break;

  case 'ca16':
    ReadFrom (&ca16, stream);
    rc = TAG_READ;
    break;

  case 'ca17':
    ReadFrom (&ca17, stream);
    rc = TAG_READ;
    break;

  case 'ca18':
    ReadFrom (&ca18, stream);
    rc = TAG_READ;
    break;

  case 'ca19':
    ReadFrom (&ca19, stream);
    rc = TAG_READ;
    break;

  case 'ca20':
    ReadFrom (&ca20, stream);
    rc = TAG_READ;
    break;

  case 'ca21':
    ReadFrom (&ca21, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKNavComKX155Gauge::Read : Unknown tag %s", s);
  }

  return rc;
}

void CBKNavComKX155Gauge::ReadFinished (void)
{
  CBitmapGauge::ReadFinished ();

  // Initialize messaging parameters
  mesg.group = radi_tag;
  mesg.user.u.unit = radi_unit;

  // Get fonts from global defaults
  digi9 = &(globals->fonts.ftdigi9);
  
}

ECursorResult CBKNavComKX155Gauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  rc = ca01.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca02.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca03.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca04.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca05.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca06.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca07.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca08.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca09.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca10.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca11.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca12.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca13.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca14.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca15.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca16.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca17.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca18.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca19.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca20.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca21.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}

void CBKNavComKX155Gauge::IncComChannel (void)
{
  comChannel++;
  if (comChannel > 32) comChannel -= 32;
}

void CBKNavComKX155Gauge::DecComChannel (void)
{
  comChannel--;
  if (comChannel < 1) comChannel += 32;
}

EClickResult CBKNavComKX155Gauge::MouseClick (int x, int y, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Only handle left/right mouse clicks
  if ((buttons & (MOUSE_BUTTON_LEFT | MOUSE_BUTTON_RIGHT)) == 0) {
    return rc;
  }

  // For direct frequency edit click areas, the left mouse button decrements
  //   the value and the right mouse button increments
  bool increment = (buttons & MOUSE_BUTTON_RIGHT) != 0;
  
  if (ca01.IsHit (x, y)) {
    // COM Active Whole MHz
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'caw+' : 'caw-';
    SendMessage (&mesg);
  } else if (ca02.IsHit (x, y)) {
    // COM Active Fract MHz
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'caf+' : 'caf-';
    SendMessage (&mesg);
  } else if (ca03.IsHit (x, y)) {
    // COM Standby Whole MHz
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'csw+' : 'csw-';
    SendMessage (&mesg);
  } else if (ca04.IsHit (x, y)) {
    // COM Standby Fract MHz
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'csf+' : 'csf-';
    SendMessage (&mesg);
  } else if (ca05.IsHit (x, y)) {
    // NAV Active Whole MHz
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'naw+' : 'naw-';
    SendMessage (&mesg);
  } else if (ca06.IsHit (x, y)) {
    // NAV Active Fract MHz
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'naf+' : 'naf-';
    SendMessage (&mesg);
  } else if (ca07.IsHit (x, y)) {
    // NAV Standby Whole MHz
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'nsw+' : 'nsw-';
    SendMessage (&mesg);
  } else if (ca08.IsHit (x, y)) {
    // NAV Standby Fract MHz
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'nsf+' : 'nsf-';
    SendMessage (&mesg);
  } else if (ca09.IsHit (x, y)) {
    // COM Tune knob
    // Get COM mode
    mesg.id = MSG_GETDATA;
    mesg.user.u.datatag = 'cmod';
    SendMessage (&mesg);
    EBKKX155ComMode comMode = (EBKKX155ComMode) mesg.intData;

    switch (comMode) {
    case COM_MODE_NORMAL:
      // Increment/decrement standby frequency
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = increment ? 'csf+' : 'csw+';
      SendMessage (&mesg);
      break;
    case COM_MODE_SELECT:
      // Increment/decrement channel
      if (increment) {
        IncComChannel();
      } else {
        DecComChannel();
      }
      break;
    case COM_MODE_PROGRAM:
      if (comProgramFreq) {
        // Increment/decrement channel frequency
      } else {
        // Increment/decrement channel
        if (increment) {
          IncComChannel();
        } else {
          DecComChannel();
        }
      }
      break;
    }
  } else if (ca10.IsHit (x, y)) {
    // NAV Tune knob
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'nsf+' : 'nsw+';
    SendMessage (&mesg);
  } else if (ca11.IsHit (x, y)) {
    // COM channel button
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = 'cmod';
    SendMessage (&mesg);
  } else if (ca12.IsHit (x, y)) {
    // NAV mode button
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = 'nmod';
    SendMessage (&mesg);
  } else if (ca13.IsHit (x, y)) {
    // COM Transfer
    // Get COM mode
    mesg.id = MSG_GETDATA;
    mesg.user.u.datatag = 'cmod';
    SendMessage (&mesg);
    EBKKX155ComMode comMode = (EBKKX155ComMode) mesg.intData;

    switch (comMode) {
    case COM_MODE_NORMAL:
      {
        // COM Transfer, first get current active and standby freqs
        mesg.id = MSG_GETDATA;
        mesg.user.u.datatag = 'comA';
        SendMessage (&mesg);
        float comA = mesg.realData;
        mesg.user.u.datatag = 'comS';
        SendMessage (&mesg);
        float comS = mesg.realData;

        // Flip frequencies and set
        mesg.id = MSG_SETDATA;
        mesg.user.u.datatag = 'comA';
        mesg.realData = comS;
        SendMessage (&mesg);

        mesg.user.u.datatag = 'comS';
        mesg.realData = comA;
        SendMessage (&mesg);
      }
      break;
    case COM_MODE_SELECT:
      {
        // Swap active to standby, and set active to selected channel
        mesg.id = MSG_GETDATA;
        mesg.user.u.datatag = 'comA';
        SendMessage (&mesg);
        float comA = mesg.realData;

        mesg.id = MSG_SETDATA;
        mesg.user.u.datatag = 'comA';
        mesg.realData = presets.GetFreq(comChannel);
        SendMessage (&mesg);

        mesg.id = MSG_SETDATA;
        mesg.user.u.datatag = 'comS';
        mesg.realData = comA;
        SendMessage (&mesg);

        // Send COM channel mode button press to reset mode
        mesg.user.u.datatag = 'cmod';
        SendMessage (&mesg);
      }
      break;
    case COM_MODE_PROGRAM:
      {
        // Toggle channel/frequency programming
        comProgramFreq = !comProgramFreq;
      }
      break;
    }
  } else if (ca14.IsHit (x, y)) {
    // NAV Transfer, first get current active and standby freqs
    mesg.id = MSG_GETDATA;
    mesg.user.u.datatag = 'navA';
    SendMessage (&mesg);
    float navA = mesg.realData;
    mesg.user.u.datatag = 'navS';
    SendMessage (&mesg);
    float navS = mesg.realData;

    // Flip frequencies and set
    mesg.id = MSG_GETDATA;
    mesg.user.u.datatag = 'navA';
    mesg.realData = navS;
    SendMessage (&mesg);

    mesg.user.u.datatag = 'navS';
    mesg.realData = navA;
    SendMessage (&mesg);
  }

  return rc;
}


static void ConvertFreq (float f, int *whole, int *fract)
{
  *whole = (int)floorf(f);
  *fract = (int)floorf((fmodf(f, 1.0f) * 1000 + 0.5));
}


void CBKNavComKX155Gauge::Draw (void)
{
  ClearSurface ();
  DrawUnderlay ();

  // Get activity status of subsystem
  mesg.id = MSG_GETDATA;
  mesg.user.u.datatag = 'actv';
  SendMessage (&mesg);
  bool active = (mesg.intData != 0);
  int frame = active ? 1 : 0;

  // Draw button images
  // ca11 = COM Channel   SKYHBT02.PBG
  // ca12 = NAV Mode      SKYHBT02.PBG
  // ca13 = COM Transfer, SKYHBT01.PBG
  // ca14 = NAV Transfer, SKYHBT01.PBG
  ca11.Draw (surf, frame);
  ca12.Draw (surf, frame);
  ca13.Draw (surf, frame);
  ca14.Draw (surf, frame);

  // Draw active/standby frequencies in the appropriate click areas
  // ca01 = COM Active MHz
  // ca02 = COM Active KHz
  // ca03 = COM Standby MHz
  // ca04 = COM Standby KHz
  // ca05 = NAV Active MHz
  // ca06 = NAV Active KHz
  // ca07 = NAV Standby MHz
  // ca08 = NAV Standby KHz

  if (active) {
    unsigned int amber = MakeRGB (215, 90, 0);
    char s[8];
    int whole, fract;

    // Get COM mode
    mesg.user.u.datatag = 'cmod';
    SendMessage (&mesg);
    EBKKX155ComMode comMode = (EBKKX155ComMode)mesg.intData;

    // Display COM Active region
    switch (comMode) {
    case COM_MODE_NORMAL:
      // Active COM frequency
      mesg.user.u.datatag = 'comA';
      SendMessage (&mesg);
      ConvertFreq (mesg.realData, &whole, &fract);
      sprintf (s, "%3d.", whole);
      DrawText (surf, digi9, ca01.x1, ca01.y1, amber, s);
      sprintf (s, "%02d", fract/10);
      DrawText (surf, digi9, ca02.x1, ca02.y1, amber, s);
      break;
    case COM_MODE_SELECT:
      sprintf (s, "%02d", comChannel);
      DrawTextR (surf, digi9, ca02.x2, ca02.y1, amber, s);
      break;
    case COM_MODE_PROGRAM:
      // Current channel number
      sprintf (s, "%02d", comChannel);
      DrawTextR (surf, digi9, ca02.x2, ca02.y1, amber, s);
      break;
    }

    // Display COM Standby region
    switch (comMode) {
    case COM_MODE_NORMAL:
      // Standby COM frequency
      mesg.user.u.datatag = 'comS';
      SendMessage (&mesg);
      ConvertFreq (mesg.realData, &whole, &fract);
      sprintf (s, "%3d.", whole);
      DrawText (surf, digi9, ca03.x1, ca03.y1, amber, s);
      sprintf (s, "%02d", fract/10);
      DrawText (surf, digi9, ca04.x1, ca04.y1, amber, s);
      break;
    case COM_MODE_SELECT:
      // Current preset channel frequency
      ConvertFreq (presets.GetFreq(comChannel), &whole, &fract);
      sprintf (s, "%3d.", whole);
      DrawText (surf, digi9, ca03.x1, ca03.y1, amber, s);
      sprintf (s, "%02d", fract/10);
      DrawText (surf, digi9, ca04.x1, ca04.y1, amber, s);
      break;
    case COM_MODE_PROGRAM:
      // Current preset channel frequency (flashing)
      ConvertFreq (presets.GetFreq(comChannel), &whole, &fract);
      sprintf (s, "%3d.", whole);
      DrawText (surf, digi9, ca03.x1, ca03.y1, amber, s);
      sprintf (s, "%02d", fract/10);
      DrawText (surf, digi9, ca04.x1, ca04.y1, amber, s);
      break;
    }

    // Display NAV Active region
    mesg.user.u.datatag = 'navA';
    SendMessage (&mesg);
    float navActive = mesg.realData;
    int navActiveWhole, navActiveFract;
    ConvertFreq (navActive, &navActiveWhole, &navActiveFract);
    sprintf (s, "%3d.", navActiveWhole);
    DrawText (surf, digi9, ca05.x1, ca05.y1, amber, s);
    sprintf (s, "%02d", navActiveFract/10);
    DrawText (surf, digi9, ca06.x1, ca06.y1, amber, s);

    // Display NAV Standby region
    mesg.user.u.datatag = 'navS';
    SendMessage (&mesg);
    float navStby = mesg.realData;
    int navStbyWhole, navStbyFract;
    ConvertFreq (navStby, &navStbyWhole, &navStbyFract);
    sprintf (s, "%3d.", navStbyWhole);
    DrawText (surf, digi9, ca07.x1, ca07.y1, amber, s);
    sprintf (s, "%02d", navStbyFract/10);
    DrawText (surf, digi9, ca08.x1, ca08.y1, amber, s);
  }

  DrawOverlay ();
}


//
// CBKXPDRKT76Gauge
//
CBKXPDRKT76Gauge::CBKXPDRKT76Gauge (void)
{
  radi_tag = 0;
  radi_unit = 0;

  nClickAreas = 16;
  caClicked = 0;
}

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

  // Check for click area tags
  int ica = ClickAreaFromTag (tag);
  if ((ica >= 1) && (ica <= nClickAreas)) {
    // Valid click area
    ReadFrom (&ca[ica], stream);
    rc = TAG_READ;
  }

  switch (tag) {
  case 'radi':
    ReadTag (&radi_tag, stream);
    ReadInt (&radi_unit, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKXPDRKT76Gauge::Read : Unknown tag %s", s);
  }

  return rc;
}

void CBKXPDRKT76Gauge::ReadFinished (void)
{
  CBitmapGauge::ReadFinished ();

  // Initialize messaging parameters
  mesg.group = radi_tag;
  mesg.user.u.unit = radi_unit;
}

ECursorResult CBKXPDRKT76Gauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  for (int i=1; i<=nClickAreas && (rc == CURSOR_NOT_CHANGED); i++) {
    rc = ca[i].MouseMoved (x, y);
  }

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}

EClickResult CBKXPDRKT76Gauge::MouseClick (int x, int y, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Only handle left/right mouse clicks
  if ((buttons & (MOUSE_BUTTON_LEFT | MOUSE_BUTTON_RIGHT)) == 0) {
    return rc;
  }

  // For direct frequency edit click areas, the left mouse button decrements
  //   the value and the right mouse button increments
  bool increment = (buttons & MOUSE_BUTTON_RIGHT) != 0;

  caClicked = 0;
  for (int i=1; (i<=nClickAreas) && (caClicked==0); i++) {
    if (ca[i].IsHit(x, y)) {
      caClicked = i;
      rc = MOUSE_TRACKING_ON;
      break;
    }
  }

  switch (caClicked) {
  case 1:
    // Active digit 1
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'i11+' : 'i11-';
    SendMessage (&mesg);
    break;
  case 2:
    // Active digit 2
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'i12+' : 'i12-';
    SendMessage (&mesg);
    break;
  case 3:
    // Active digit 3
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'i13+' : 'i13-';
    SendMessage (&mesg);
    break;
  case 4:
    // Active digit 4
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'i14+' : 'i14-';
    SendMessage (&mesg);
    break;
  }

  return rc;
}

EClickResult CBKXPDRKT76Gauge::StopClick (int x, int y, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Find click area that mouse is in
  int caStop = 0;
  for (int i=1; (i<=nClickAreas) && (caStop==0); i++) {
    if (ca[i].IsHit(x, y)) caStop = i;
  }

  // Check that the release occurred in the same areas that was clicked
  if (caStop == caClicked) {
    switch (caClicked) {
    case 5:
      // IDT button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = 'idt_';
      SendMessage (&mesg);
      break;
    case 6:
      // Zero button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = '___0';
      SendMessage (&mesg);
      break;
    case 7:
      // One button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = '___1';
      SendMessage (&mesg);
      break;
    case 8:
      // Two button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = '___2';
      SendMessage (&mesg);
      break;
    case 9:
      // Three button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = '___3';
      SendMessage (&mesg);
      break;
    case 10:
      // Four button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = '___4';
      SendMessage (&mesg);
      break;
    case 11:
      // Five Button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = '___5';
      SendMessage (&mesg);
      break;
    case 12:
      // Six Button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = '___6';
      SendMessage (&mesg);
      break;
    case 13:
      // Seven Button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = '___7';
      SendMessage (&mesg);
      break;
    case 14:
      // CLR Button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = 'clr_';
      SendMessage (&mesg);
      break;
    case 15:
      // VFR Button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = 'vfr_';
      SendMessage (&mesg);
      break;
    }
  }

  caClicked = 0;

  return rc;
}

void CBKXPDRKT76Gauge::Draw (void)
{
  ClearSurface ();
  DrawUnderlay ();

  // Get activity status of subsystem
  mesg.id = MSG_GETDATA;
  mesg.user.u.datatag = 'actv';
  SendMessage (&mesg);
  bool active = (mesg.intData != 0);
  int frame = active ? 1 : 0;

  // Draw button images
  // ca05 = Ident button
  // ca06..ca13 = Zero..Seven
  // ca14 = Clear button
  // ca15 = VFR button
  ca[5].Draw (surf, frame);
  ca[6].Draw (surf, frame);
  ca[7].Draw (surf, frame);
  ca[8].Draw (surf, frame);
  ca[9].Draw (surf, frame);
  ca[10].Draw (surf, frame);
  ca[11].Draw (surf, frame);
  ca[12].Draw (surf, frame);
  ca[13].Draw (surf, frame);
  ca[14].Draw (surf, frame);
  ca[15].Draw (surf, frame);

  // Get switch mode and draw knob
  mesg.user.u.datatag = 'smod';
  SendMessage (&mesg);
  ca[16].Draw (surf, mesg.intData);

  if (active) {
    // Initialize font display information
    SFont *fttiny7 = &globals->fonts.fttiny7;
    SFont *ftdigi9 = &globals->fonts.ftdigi9;
    unsigned int amber = MakeRGB (215, 90, 0);
    int x, y;

    // Initialize display strings and flags
    bool fl = false;
    bool alt = false;
    bool on = false;
    bool reply = false;
    bool sby = false;
    char left[8];
    char right[8];

    // Get transponder code
    mesg.user.u.datatag = 'tune';
    SendMessage (&mesg);
    char sCode[8];
    if (mesg.dataType == TYPE_INT) {
      sprintf (sCode, "%04d", mesg.intData);
    } else if (mesg.dataType == TYPE_CHARPTR) {
      strcpy (sCode, mesg.charPtrData);
    }

    // Get operating mode
    mesg.user.u.datatag = 'mode';
    SendMessage (&mesg);
    ETransponderMode mode = (ETransponderMode)mesg.intData;
    switch (mode) {
    case XPDR_OFF:
      strcpy (left, "");
      strcpy (right, "");
      break;

    case XPDR_STARTUPA1:
      strcpy (left, "AA1");
      strcpy (right, "1234");
      break;

    case XPDR_STARTUPA2:
      strcpy (left, "AA2");
      strcpy (right, "5678");
      break;

    case XPDR_STANDBY:
      strcpy (left, "");
      strcpy (right, sCode);
      break;

    case XPDR_TEST:
      strcpy (left, "-888");
      strcpy (right, "8888");
      break;
      
    case XPDR_ON:
      strcpy (left, "");
      strcpy (right, sCode);
      break;

    case XPDR_ALT:
      mesg.user.u.datatag = 'alti';
      SendMessage (&mesg);
      sprintf (left, "%4d", mesg.intData);
      strcpy (right, sCode);
      break;
    }

    // Get FL flag
    mesg.user.u.datatag = 'fl__';
    SendMessage (&mesg);
    fl = (mesg.intData != 0);

    // Get ALT flag
    mesg.user.u.datatag = 'alt_';
    SendMessage (&mesg);
    alt = (mesg.intData != 0);

    // Get ON flag
    mesg.user.u.datatag = 'on__';
    SendMessage (&mesg);
    on = (mesg.intData != 0);

    // Get reply flag
    mesg.user.u.datatag = 'rply';
    SendMessage (&mesg);
    reply = (mesg.intData != 0);

    // Get standby flag
    mesg.user.u.datatag = 'sby_';
    SendMessage (&mesg);
    sby = (mesg.intData != 0);

    // Display appropriate data and flags
    // Left display area and flag locations are not specified by click area objects
    //   in the gauge specification use hard-coded values that fit the normal gauge

    if (fl) {
      // Display FL flag
      x = 40;
      y = 14;
      DrawText (surf, fttiny7, x, y, amber, "FL");
    }

    if (alt) {
      // Display ALT flag
      x = 80;
      y = 6;
      DrawText (surf, fttiny7, x, y, amber, "ALT");
    }

    if (on) {
      // Display ON flag
      x = 80;
      y = 14;
      DrawText (surf, fttiny7, x, y, amber, "ON");
    }

    if (reply) {
      // Display Reply flag
      x = 100;
      y = 6;
      DrawText (surf, fttiny7, x, y, amber, "R");
    }

    if (sby) {
      // Display Standby flag
      x = 100;
      y = 14;
      DrawText (surf, fttiny7, x, y, amber, "SBY");
    }

    // Display left string
    x = 50;
    y = 8;
    DrawText (surf, ftdigi9, x, y, amber, left);

    // Display right string
    x = ca[1].x1;
    y = ca[1].y1;
    DrawText (surf, ftdigi9, x, y, amber, right);
  }
}


//
// CBKADFKR87Gauge
//
CBKADFKR87Gauge::CBKADFKR87Gauge (void)
{
  radi_tag = 0;
  radi_unit = 0;

  nClickAreas = 15;
  caClicked = 0;
}

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

  // Check for click area tags
  int ica = ClickAreaFromTag (tag);
  if ((ica >= 1) && (ica <= nClickAreas)) {
    // Valid click area
    ReadFrom (&ca[ica], stream);
    rc = TAG_READ;
  }

  // Check for non-click area tags
  switch (tag) {
  case 'radi':
    ReadTag (&radi_tag, stream);
    ReadInt (&radi_unit, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKADFKR87Gauge::Read : Unknown tag %s", s);
  }

  return rc;
}

void CBKADFKR87Gauge::ReadFinished (void)
{
  CBitmapGauge::ReadFinished ();

  // Initialize messaging parameters
  mesg.group = radi_tag;
  mesg.user.u.unit = radi_unit;
}

ECursorResult CBKADFKR87Gauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  for (int i=1; i<=nClickAreas && (rc == CURSOR_NOT_CHANGED); i++) {
    rc = ca[i].MouseMoved (x, y);
  }

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}

EClickResult CBKADFKR87Gauge::MouseClick (int x, int y, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Only handle left/right mouse clicks
  if ((buttons & (MOUSE_BUTTON_LEFT | MOUSE_BUTTON_RIGHT)) == 0) {
    return rc;
  }

  // For direct frequency edit click areas, the left mouse button decrements
  //   the value and the right mouse button increments
  bool increment = (buttons & MOUSE_BUTTON_RIGHT) != 0;

  caClicked = 0;
  for (int i=1; (i<=nClickAreas) && (caClicked==0); i++) {
    if (ca[i].IsHit(x, y)) {
      caClicked = i;
      rc = MOUSE_TRACKING_ON;
      break;
    }
  }

  // Handle areas that are activated on mouse click
  switch (caClicked) {
  case 1:
    // Active digit 1
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'ad1+' : 'ad1-';
    SendMessage (&mesg);
    break;
  case 2:
    // Active digit 2
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'ad2+' : 'ad2-';
    SendMessage (&mesg);
    break;
  case 3:
    // Active digit 3
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'ad3+' : 'ad3-';
    SendMessage (&mesg);
    break;
  case 4:
    // Active digit 4
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'ad4+' : 'ad4-';
    SendMessage (&mesg);
    break;
  case 5:
    // Standby digit 1
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'sd1+' : 'sd1-';
    SendMessage (&mesg);
  case 6:
    // Standby digit 2
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'sd2+' : 'sd2-';
    SendMessage (&mesg);
    break;
  case 7:
    // Standby digit 3
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'sd3+' : 'sd3-';
    SendMessage (&mesg);
    break;
  case 8:
    // Standby digit 4
    mesg.id = MSG_SETDATA;
    mesg.user.u.datatag = increment ? 'sd4+' : 'sd4-';
    SendMessage (&mesg);
  }

  return rc;
}

EClickResult CBKADFKR87Gauge::StopClick (int x, int y, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Find click area that mouse is in
  int caStop = 0;
  for (int i=1; (i<=nClickAreas) && (caStop==0); i++) {
    if (ca[i].IsHit(x, y)) caStop = i;
  }

  // Check that the release occurred in the same areas that was clicked
  if (caStop == caClicked) {
    switch (caClicked) {
    case 11:
      // ADF Button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = 'adf_';
      SendMessage (&mesg);
      break;
    case 12:
      // BFO Button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = 'bfo_';
      SendMessage (&mesg);
      break;
    case 13:
      // FRQ Button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = 'freq';
      SendMessage (&mesg);
      break;
    case 14:
      // FLT Button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = 'flt_';
      SendMessage (&mesg);
      break;
    case 15:
      // SET Button
      mesg.id = MSG_SETDATA;
      mesg.user.u.datatag = 'rset';
      SendMessage (&mesg);
      break;
    }
  }

  caClicked = 0;

  return rc;
}

void CBKADFKR87Gauge::Draw (void)
{
  ClearSurface ();
  DrawUnderlay ();

  // Get activity status of subsystem
  mesg.id = MSG_GETDATA;
  mesg.user.u.datatag = 'actv';
  SendMessage (&mesg);
  bool active = (mesg.intData != 0);
  int frame = active ? 1 : 0;

  // Draw button images
  // ca11 = ADF button
  // ca12 = BFO button
  // ca13 = FRQ button
  // ca14 = FLT button
  // ca15 = SET button
  ca[11].Draw (surf, frame);
  ca[12].Draw (surf, frame);
  ca[13].Draw (surf, frame);
  ca[14].Draw (surf, frame);
  ca[15].Draw (surf, frame);

  if (active) {
    // Initialize font display information
    SFont *fttiny7 = &globals->fonts.fttiny7;
    SFont *ftdigi9 = &globals->fonts.ftdigi9;
    unsigned int amber = MakeRGB (215, 90, 0);
    int x, y;

    // Get mode flags
    mesg.id = MSG_GETDATA;
    mesg.user.u.datatag = 'iADF';
    SendMessage (&mesg);
    bool adf = (mesg.intData != 0);

    mesg.user.u.datatag = 'iBFO';
    SendMessage (&mesg);
    bool bfo = (mesg.intData != 0);
    
    mesg.user.u.datatag = 'iFRQ';
    SendMessage (&mesg);
    bool frq = (mesg.intData != 0);

    mesg.user.u.datatag = 'iFLT';
    SendMessage (&mesg);
    bool flt = (mesg.intData != 0);

    mesg.user.u.datatag = 'iET_';
    SendMessage (&mesg);
    bool et = (mesg.intData != 0);

    // Char buffers for active and standby display areas
    char sActive[8];
    char sStandby[8];

    // Get active frequency
    mesg.id = MSG_GETDATA;
    mesg.user.u.datatag = 'tune';
    SendMessage (&mesg);
    int freqActive = (int)(floorf (mesg.realData + 0.5));
    sprintf (sActive, "%04d", freqActive);

    // Get standby frequency/timer mode
    mesg.user.u.datatag = 'stby';
    SendMessage (&mesg);
    int freqStandby = (int)(floorf (mesg.realData + 0.5));
    sprintf (sStandby, "%04d", freqStandby);

    // Left-hand display is always the active tuned frequency
    if (adf) {
      // Display ADF tag
      x = ca[1].x1 / 2;
      y = ca[1].y2 + 3 - TextHeight (fttiny7, "ADF");
      DrawTextC (surf, fttiny7, x, y, amber, "ADF");
    } else {
      // Display ANT tag
      x = ca[1].x1 / 2;
      y = ca[1].y1 - 3;
      DrawTextC (surf, fttiny7, x, y, amber, "ANT");
    }

    if (bfo) {
      // Display BFO tag
      x = ca[4].x2 + 5;
      y = ca[5].y1 - 3;
      DrawText (surf, fttiny7, x, y, amber, "BFO");
    }

    // ca01 = Active digit 1
    DrawChar (surf, ftdigi9, ca[1].x1, ca[1].y1, amber, sActive[0]);
    // ca02 = Active digit 2
    DrawChar (surf, ftdigi9, ca[2].x1, ca[2].y1, amber, sActive[1]);
    // ca03 = Active digit 3
    DrawChar (surf, ftdigi9, ca[3].x1, ca[3].y1, amber, sActive[2]);
    // ca04 = Active digit 4
    DrawChar (surf, ftdigi9, ca[4].x1, ca[4].y1, amber, sActive[3]);

    // Right-hand display is either standby frequency or one of the timers
    if (frq) {
      // Display FRQ tag
      x = ca[5].x1 - 5;
      y = ca[5].y2 + 3 - TextHeight (fttiny7, "FRQ");
      DrawTextR (surf, fttiny7, x, y, amber, "FRQ");

      // ca05 = Standby digit 1
      DrawChar (surf, ftdigi9, ca[5].x1, ca[5].y1, amber, sStandby[0]);
      // ca06 = Standby digit 2
      DrawChar (surf, ftdigi9, ca[6].x1, ca[6].y1, amber, sStandby[1]);
      // ca07 = Standby digit 3
      DrawChar (surf, ftdigi9, ca[7].x1, ca[7].y1, amber, sStandby[2]);
      // ca08 = Standby digit 4
      DrawChar (surf, ftdigi9, ca[8].x1, ca[8].y1, amber, sStandby[3]);
    } else if (flt) {
      // Get flight timer value
      mesg.user.u.datatag = 'ftim';
      SendMessage (&mesg);
      int ftime = mesg.intData;

      // Display FLT tag
      x = ca[8].x2 + 15;
      y = ca[8].y1 - 3;
      DrawTextR (surf, fttiny7, x, y, amber, "FLT");

      // Display flight time
      char sTime[8];
      sprintf (sTime, "%02d:%02d", ftime / 60, ftime % 60);
      x = ca[5].x1;
      y = ca[5].y1;
      DrawText (surf, ftdigi9, x, y, amber, sTime);
    } else if (et) {
      // Get elapsed timer value
      mesg.user.u.datatag = 'etim';
      SendMessage (&mesg);
      int etime = mesg.intData;

      // Display ET tag
      x = ca[8].x2 + 15;
      y = ca[8].y2 + 3 - TextHeight (fttiny7, "ET");
      DrawTextR (surf, fttiny7, x, y, amber, "ET");

      // Display elapsed time
      char sTime[8];
      sprintf (sTime, "%02d:%02d", etime / 60, etime % 60);
      x = ca[5].x1;
      y = ca[5].y1;
      DrawText (surf, ftdigi9, x, y, amber, sTime);
    }
  }
}


//
// CBKGPSKLN89Gauge
//
CBKGPSKLN89Gauge::CBKGPSKLN89Gauge (void)
{
  radi = 0;
}

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

  switch (tag) {
  case 'radi':
    ReadTag (&radi, stream);
    rc = TAG_READ;
    break;

  case 'ca01':
    ReadFrom (&ca01, stream);
    rc = TAG_READ;
    break;

  case 'ca02':
    ReadFrom (&ca02, stream);
    rc = TAG_READ;
    break;

  case 'ca03':
    ReadFrom (&ca03, stream);
    rc = TAG_READ;
    break;

  case 'ca04':
    ReadFrom (&ca04, stream);
    rc = TAG_READ;
    break;

  case 'ca05':
    ReadFrom (&ca05, stream);
    rc = TAG_READ;
    break;

  case 'ca06':
    ReadFrom (&ca06, stream);
    rc = TAG_READ;
    break;

  case 'ca07':
    ReadFrom (&ca07, stream);
    rc = TAG_READ;
    break;

  case 'ca08':
    ReadFrom (&ca08, stream);
    rc = TAG_READ;
    break;

  case 'ca09':
    ReadFrom (&ca09, stream);
    rc = TAG_READ;
    break;

  case 'ca10':
    ReadFrom (&ca10, stream);
    rc = TAG_READ;
    break;

  case 'ca11':
    ReadFrom (&ca11, stream);
    rc = TAG_READ;
    break;

  case 'ca12':
    ReadFrom (&ca12, stream);
    rc = TAG_READ;
    break;

  case 'ca13':
    ReadFrom (&ca13, stream);
    rc = TAG_READ;
    break;

  case 'ca14':
    ReadFrom (&ca14, stream);
    rc = TAG_READ;
    break;

  case 'ca15':
    ReadFrom (&ca15, stream);
    rc = TAG_READ;
    break;

  case 'ca16':
    ReadFrom (&ca16, stream);
    rc = TAG_READ;
    break;

  case 'ca17':
    ReadFrom (&ca17, stream);
    rc = TAG_READ;
    break;

  case 'ca18':
    ReadFrom (&ca18, stream);
    rc = TAG_READ;
    break;

  case 'ca19':
    ReadFrom (&ca19, stream);
    rc = TAG_READ;
    break;

  case 'ca20':
    ReadFrom (&ca20, stream);
    rc = TAG_READ;
    break;

  case 'ca21':
    ReadFrom (&ca21, stream);
    rc = TAG_READ;
    break;

  case 'ca22':
    ReadFrom (&ca22, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKGPSKLN89Gauge::Read : Unknown tag %s", s);
  }

  return rc;
}


ECursorResult CBKGPSKLN89Gauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  rc = ca01.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca02.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca03.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca04.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca05.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca06.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca07.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca08.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca09.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca10.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca11.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca12.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca13.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca14.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca15.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca16.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca17.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca18.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca19.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca20.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca21.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca22.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CBKAP140Gauge
//
CBKAP140Gauge::CBKAP140Gauge (void)
{
  nClickAreas = 6;
  caClicked = 0;
}

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

  // Check for click area tags
  int ica = ClickAreaFromTag (tag);
  if ((ica >= 1) && (ica <= nClickAreas)) {
    // Valid click area
    ReadFrom (&ca[ica], stream);
    rc = TAG_READ;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKAP140Gauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CBKAP140Gauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  for (int i=1; i<=nClickAreas && (rc == CURSOR_NOT_CHANGED); i++) {
    rc = ca[i].MouseMoved (x, y);
  }

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}

void CBKAP140Gauge::Draw (void)
{
  ClearSurface ();
  DrawUnderlay ();

  // Get activity status of subsystem
  mesg.id = MSG_GETDATA;
  mesg.user.u.datatag = 'actv';
  SendMessage (&mesg);
  bool active = (mesg.intData != 0);
  int frame = active ? 1 : 0;

  // Draw button images
  // ca01 = AP button
  // ca02 = HDG button
  // ca03 = NAV button
  // ca04 = APR button
  // ca05 = RVS button
  ca[1].Draw (surf, frame);
  ca[2].Draw (surf, frame);
  ca[3].Draw (surf, frame);
  ca[4].Draw (surf, frame);
  ca[5].Draw (surf, frame);

  if (active) {
    // ca06 = Engage button
  }
}


//
// CBKKFC200Gauge
//
CBKKFC200Gauge::CBKKFC200Gauge (void)
{
  strcpy (fd.art, "");
  fd.x = fd.y = 0;

  strcpy (alt.art, "");
  alt.x = alt.y = 0;

  strcpy (hdg.art, "");
  hdg.x = hdg.y = 0;

  strcpy (gs.art, "");
  gs.x = gs.y = 0;

  strcpy (nav.art, "");
  nav.x = nav.y = 0;

  strcpy (apr.art, "");
  apr.x = apr.y = 0;

  strcpy (bc.art, "");
  bc.x = bc.y = 0;

  strcpy (trim.art, "");
  trim.x = trim.y = 0;

  strcpy (ap.art, "");
  ap.x = ap.y = 0;
}

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

  switch (tag) {
  case 'ca01':
    ReadFrom (&ca01, stream);
    rc = TAG_READ;
    break;

  case 'ca02':
    ReadFrom (&ca02, stream);
    rc = TAG_READ;
    break;

  case 'ca03':
    ReadFrom (&ca03, stream);
    rc = TAG_READ;
    break;

  case 'ca04':
    ReadFrom (&ca04, stream);
    rc = TAG_READ;
    break;

  case 'ca05':
    ReadFrom (&ca05, stream);
    rc = TAG_READ;
    break;

  case 'ca06':
    ReadFrom (&ca06, stream);
    rc = TAG_READ;
    break;

  case 'ca07':
    ReadFrom (&ca07, stream);
    rc = TAG_READ;
    break;

  case 'ca08':
    ReadFrom (&ca08, stream);
    rc = TAG_READ;
    break;

  case 'ca09':
    ReadFrom (&ca09, stream);
    rc = TAG_READ;
    break;

  case 'ca10':
    ReadFrom (&ca10, stream);
    rc = TAG_READ;
    break;

  case 'ca11':
    ReadFrom (&ca11, stream);
    rc = TAG_READ;
    break;

  case 'fd__':
    ReadString (fd.art, 64, stream);
    ReadInt (&fd.x, stream);
    ReadInt (&fd.y, stream);
    rc = TAG_READ;
    break;

  case 'alt_':
    ReadString (alt.art, 64, stream);
    ReadInt (&alt.x, stream);
    ReadInt (&alt.y, stream);
    rc = TAG_READ;
    break;

  case 'hdg_':
    ReadString (hdg.art, 64, stream);
    ReadInt (&hdg.x, stream);
    ReadInt (&hdg.y, stream);
    rc = TAG_READ;
    break;

  case 'gs__':
    ReadString (gs.art, 64, stream);
    ReadInt (&gs.x, stream);
    ReadInt (&gs.y, stream);
    rc = TAG_READ;
    break;

  case 'nav_':
    ReadString (nav.art, 64, stream);
    ReadInt (&nav.x, stream);
    ReadInt (&nav.y, stream);
    rc = TAG_READ;
    break;

  case 'apr_':
    ReadString (apr.art, 64, stream);
    ReadInt (&apr.x, stream);
    ReadInt (&apr.y, stream);
    rc = TAG_READ;
    break;

  case 'bc__':
    ReadString (bc.art, 64, stream);
    ReadInt (&bc.x, stream);
    ReadInt (&bc.y, stream);
    rc = TAG_READ;
    break;

  case 'trim':
    ReadString (trim.art, 64, stream);
    ReadInt (&trim.x, stream);
    ReadInt (&trim.y, stream);
    rc = TAG_READ;
    break;

  case 'ap__':
    ReadString (ap.art, 64, stream);
    ReadInt (&ap.x, stream);
    ReadInt (&ap.y, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKKFC200Gauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CBKKFC200Gauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  rc = ca01.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca02.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca03.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca04.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca05.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca06.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca07.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca08.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca09.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca10.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca11.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CBKKFC150Gauge
//
CBKKFC150Gauge::CBKKFC150Gauge (void)
{
  strcpy (fd.art, "");
  fd.x = fd.y = 0;

  strcpy (alt.art, "");
  alt.x = alt.y = 0;

  strcpy (hdg.art, "");
  hdg.x = hdg.y = 0;

  strcpy (gs.art, "");
  gs.x = gs.y = 0;

  strcpy (nav.art, "");
  nav.x = nav.y = 0;

  strcpy (apr.art, "");
  apr.x = apr.y = 0;

  strcpy (bc.art, "");
  bc.x = bc.y = 0;

  strcpy (trim.art, "");
  trim.x = trim.y = 0;

  strcpy (ap.art, "");
  ap.x = ap.y = 0;
}

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

  switch (tag) {
  case 'ca01':
    ReadFrom (&ca01, stream);
    rc = TAG_READ;
    break;

  case 'ca02':
    ReadFrom (&ca02, stream);
    rc = TAG_READ;
    break;

  case 'ca03':
    ReadFrom (&ca03, stream);
    rc = TAG_READ;
    break;

  case 'ca04':
    ReadFrom (&ca04, stream);
    rc = TAG_READ;
    break;

  case 'ca05':
    ReadFrom (&ca05, stream);
    rc = TAG_READ;
    break;

  case 'ca06':
    ReadFrom (&ca06, stream);
    rc = TAG_READ;
    break;

  case 'ca07':
    ReadFrom (&ca07, stream);
    rc = TAG_READ;
    break;

  case 'ca08':
    ReadFrom (&ca08, stream);
    rc = TAG_READ;
    break;

  case 'ca09':
    ReadFrom (&ca09, stream);
    rc = TAG_READ;
    break;

  case 'ca10':
    ReadFrom (&ca10, stream);
    rc = TAG_READ;
    break;

  case 'ca11':
    ReadFrom (&ca11, stream);
    rc = TAG_READ;
    break;

  case 'fd__':
    ReadString (fd.art, 64, stream);
    ReadInt (&fd.x, stream);
    ReadInt (&fd.y, stream);
    rc = TAG_READ;
    break;

  case 'alt_':
    ReadString (alt.art, 64, stream);
    ReadInt (&alt.x, stream);
    ReadInt (&alt.y, stream);
    rc = TAG_READ;
    break;

  case 'hdg_':
    ReadString (hdg.art, 64, stream);
    ReadInt (&hdg.x, stream);
    ReadInt (&hdg.y, stream);
    rc = TAG_READ;
    break;

  case 'gs__':
    ReadString (gs.art, 64, stream);
    ReadInt (&gs.x, stream);
    ReadInt (&gs.y, stream);
    rc = TAG_READ;
    break;

  case 'nav_':
    ReadString (nav.art, 64, stream);
    ReadInt (&nav.x, stream);
    ReadInt (&nav.y, stream);
    rc = TAG_READ;
    break;

  case 'apr_':
    ReadString (apr.art, 64, stream);
    ReadInt (&apr.x, stream);
    ReadInt (&apr.y, stream);
    rc = TAG_READ;
    break;

  case 'bc__':
    ReadString (bc.art, 64, stream);
    ReadInt (&bc.x, stream);
    ReadInt (&bc.y, stream);
    rc = TAG_READ;
    break;

  case 'trim':
    ReadString (trim.art, 64, stream);
    ReadInt (&trim.x, stream);
    ReadInt (&trim.y, stream);
    rc = TAG_READ;
    break;

  case 'ap__':
    ReadString (ap.art, 64, stream);
    ReadInt (&ap.x, stream);
    ReadInt (&ap.y, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKKFC150Gauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CBKKFC150Gauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  rc = ca01.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca02.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca03.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca04.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca05.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca06.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca07.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca08.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca09.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca10.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca11.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CBKAudioKMA26Gauge
//
CBKAudioKMA26Gauge::CBKAudioKMA26Gauge (void)
{
  radi = 0;
}

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

  switch (tag) {
  case 'radi':
    ReadTag (&radi, stream);
    rc = TAG_READ;
    break;

  case 'ca01':
    ReadFrom (&ca01, stream);
    rc = TAG_READ;
    break;

  case 'ca02':
    ReadFrom (&ca02, stream);
    rc = TAG_READ;
    break;

  case 'ca03':
    ReadFrom (&ca03, stream);
    rc = TAG_READ;
    break;

  case 'ca04':
    ReadFrom (&ca04, stream);
    rc = TAG_READ;
    break;

  case 'ca05':
    ReadFrom (&ca05, stream);
    rc = TAG_READ;
    break;

  case 'ca06':
    ReadFrom (&ca06, stream);
    rc = TAG_READ;
    break;

  case 'ca07':
    ReadFrom (&ca07, stream);
    rc = TAG_READ;
    break;

  case 'ca08':
    ReadFrom (&ca08, stream);
    rc = TAG_READ;
    break;

  case 'ca09':
    ReadFrom (&ca09, stream);
    rc = TAG_READ;
    break;

  case 'ca10':
    ReadFrom (&ca10, stream);
    rc = TAG_READ;
    break;

  case 'ca11':
    ReadFrom (&ca11, stream);
    rc = TAG_READ;
    break;

  case 'ca12':
    ReadFrom (&ca12, stream);
    rc = TAG_READ;
    break;

  case 'ca13':
    ReadFrom (&ca13, stream);
    rc = TAG_READ;
    break;

  case 'ca14':
    ReadFrom (&ca14, stream);
    rc = TAG_READ;
    break;

  case 'ca15':
    ReadFrom (&ca15, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKKMA26Gauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CBKAudioKMA26Gauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  rc = ca01.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca02.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca03.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca04.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca05.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca06.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca07.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca08.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca09.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca10.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca11.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca12.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca13.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca14.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca15.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CGenericNavRadioGauge
//
CGenericNavRadioGauge::CGenericNavRadioGauge (void)
{
  radi_tag = 0;
  radi_unit = 0;
  sdim = false;
}

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

  switch (tag) {
  case 'radi':
    ReadTag (&radi_tag, stream);
    ReadInt (&radi_unit, stream);
    rc = TAG_READ;
    break;

  case 'ca01':
    ReadFrom (&ca01, stream);
    rc = TAG_READ;
    break;

  case 'ca02':
    ReadFrom (&ca02, stream);
    rc = TAG_READ;
    break;

  case 'ca03':
    ReadFrom (&ca03, stream);
    rc = TAG_READ;
    break;

  case 'ca04':
    ReadFrom (&ca04, stream);
    rc = TAG_READ;
    break;

  case 'ca05':
    ReadFrom (&ca05, stream);
    rc = TAG_READ;
    break;

  case 'ca06':
    ReadFrom (&ca06, stream);
    rc = TAG_READ;
    break;

  case 'sdim':
    sdim = true;
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CGenericNavRadioGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


ECursorResult CGenericNavRadioGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  rc = ca01.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca02.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca03.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca04.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca05.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca06.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CGenericCommRadioGauge
//
CGenericCommRadioGauge::CGenericCommRadioGauge (void)
{
  radi_tag = 0;
  radi_unit = 0;
  sdim = false;
}

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

  switch (tag) {
  case 'radi':
    ReadTag (&radi_tag, stream);
    ReadInt (&radi_unit, stream);
    rc = TAG_READ;
    break;

  case 'ca01':
    ReadFrom (&ca01, stream);
    rc = TAG_READ;
    break;

  case 'ca02':
    ReadFrom (&ca02, stream);
    rc = TAG_READ;
    break;

  case 'ca03':
    ReadFrom (&ca03, stream);
    rc = TAG_READ;
    break;

  case 'ca04':
    ReadFrom (&ca04, stream);
    rc = TAG_READ;
    break;

  case 'ca05':
    ReadFrom (&ca05, stream);
    rc = TAG_READ;
    break;

  case 'ca06':
    ReadFrom (&ca06, stream);
    rc = TAG_READ;
    break;

  case 'sdim':
    sdim = true;
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CGenericCommRadioGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CGenericCommRadioGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  rc = ca01.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca02.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca03.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca04.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca05.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ca06.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CGenericTransponderGauge
//
CGenericTransponderGauge::CGenericTransponderGauge (void)
{
  radi_tag = 0;
  radi_unit = 0;
}

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

  switch (tag) {
  case 'radi':
    ReadTag (&radi_tag, stream);
    ReadInt (&radi_unit, stream);
    rc = TAG_READ;
    break;

  case 'tune':
    ReadFrom (&tune, stream);
    rc = TAG_READ;
    break;

  case 'mode':
    ReadFrom (&mode, stream);
    rc = TAG_READ;
    break;

  case 'idnt':
    ReadFrom (&idnt, stream);
    rc = TAG_READ;
    break;

  case 'test':
    ReadFrom (&test, stream);
    rc = TAG_READ;
    break;

  case 'ida1':
    ReadFrom (&ida1, stream);
    rc = TAG_READ;
    break;

  case 'ida2':
    ReadFrom (&ida2, stream);
    rc = TAG_READ;
    break;

  case 'ida3':
    ReadFrom (&ida3, stream);
    rc = TAG_READ;
    break;

  case 'ida4':
    ReadFrom (&ida4, stream);
    rc = TAG_READ;
    break;

  case 'idb1':
    ReadFrom (&idb1, stream);
    rc = TAG_READ;
    break;

  case 'idb2':
    ReadFrom (&idb2, stream);
    rc = TAG_READ;
    break;

  case 'idb3':
    ReadFrom (&idb3, stream);
    rc = TAG_READ;
    break;

  case 'idb4':
    ReadFrom (&idb4, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CGenericTransponderGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


ECursorResult CGenericTransponderGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = tune.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = mode.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = idnt.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = test.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ida1.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ida2.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ida3.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ida4.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = idb1.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = idb2.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = idb3.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = idb4.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}



//
// CGenericADFRadioGauge
//
CGenericADFRadioGauge::CGenericADFRadioGauge (void)
{
  radi_tag = 0;
  radi_unit = 0;
  sdim = false;
}

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

  switch (tag) {
  case 'radi':
    ReadTag (&radi_tag, stream);
    ReadInt (&radi_unit, stream);
    rc = TAG_READ;
    break;

  case 'dga1':
    ReadFrom (&dga1, stream);
    rc = TAG_READ;
    break;

  case 'dga2':
    ReadFrom (&dga2, stream);
    rc = TAG_READ;
    break;

  case 'dga3':
    ReadFrom (&dga3, stream);
    rc = TAG_READ;
    break;

  case 'dga4':
    ReadFrom (&dga4, stream);
    rc = TAG_READ;
    break;

  case 'dga5':
    ReadFrom (&dga5, stream);
    rc = TAG_READ;
    break;

  case 'dgb1':
    ReadFrom (&dgb1, stream);
    rc = TAG_READ;
    break;

  case 'dgb2':
    ReadFrom (&dgb2, stream);
    rc = TAG_READ;
    break;

  case 'dgb3':
    ReadFrom (&dgb3, stream);
    rc = TAG_READ;
    break;

  case 'dgb4':
    ReadFrom (&dgb4, stream);
    rc = TAG_READ;
    break;

  case 'dgb5':
    ReadFrom (&dgb5, stream);
    rc = TAG_READ;
    break;

  case 'tune':
    ReadFrom (&tune, stream);
    rc = TAG_READ;
    break;

  case 'mode':
    ReadFrom (&mode, stream);
    rc = TAG_READ;
    break;

  case 'stor':
    ReadFrom (&stor, stream);
    rc = TAG_READ;
    break;

  case 'test':
    ReadFrom (&test, stream);
    rc = TAG_READ;
    break;


  case 'sdim':
    sdim = true;
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CGenericADFRadioGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CGenericADFRadioGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = dga1.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = dga2.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = dga3.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = dga4.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = dga5.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = dgb1.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = dgb2.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = dgb3.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = dgb4.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = dgb5.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = tune.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = mode.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = stor.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = test.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}



CRMINeedleGauge::CRMINeedleGauge (void)
{
  comp_tag = 0;
  cpxy_x = cpxy_y = 0;
  anxy_x = anxy_y = 0;
  rnxy_x = rnxy_y = 0;
  adf1 = adf2 = nav1 = nav2 = 0;
  adf1_unit = adf2_unit = nav1_unit = nav2_unit = 0;
  strcpy (adfa.art, "");
  adfa.x = adfa.y = 0;
  strcpy (vora.art, "");
  vora.x = vora.y = 0;
}

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

  switch (tag) {
  case 'comp':
    ReadTag (&comp_tag, stream);
    ReadFrom (&comp, stream);
    rc = TAG_READ;
    break;

  case 'cpxy':
    ReadInt (&cpxy_x, stream);
    ReadInt (&cpxy_y, stream);
    rc = TAG_READ;
    break;

  case 'adfn':
    ReadFrom (&adfn, stream);
    rc = TAG_READ;
    break;

  case 'anxy':
    ReadInt (&anxy_x, stream);
    ReadInt (&anxy_y, stream);
    rc = TAG_READ;
    break;

  case 'rmin':
    ReadFrom (&rmin, stream);
    rc = TAG_READ;
    break;

  case 'rnxy':
    ReadInt (&rnxy_x, stream);
    ReadInt (&rnxy_y, stream);
    rc = TAG_READ;
    break;

  case 'adf1':
  case 'adfr':
    ReadTag (&adf1, stream);
    ReadInt (&adf1_unit, stream);
    rc = TAG_READ;
    break;

  case 'adf2':
    ReadTag (&adf2, stream);
    ReadInt (&adf2_unit, stream);
    rc = TAG_READ;
    break;

  case 'nav1':
    ReadTag (&nav1, stream);
    ReadInt (&nav1_unit, stream);
    rc = TAG_READ;
    break;

  case 'nav2':
    ReadTag (&nav2, stream);
    ReadInt (&nav2_unit, stream);
    rc = TAG_READ;
    break;

  case 'adfa':
    ReadString (adfa.art, 64, stream);
    ReadInt (&adfa.x, stream);
    ReadInt (&adfa.y, stream);
    rc = TAG_READ;
    break;

  case 'vora':
    ReadString (vora.art, 64, stream);
    ReadInt (&vora.x, stream);
    ReadInt (&vora.y, stream);
    rc = TAG_READ;
    break;

  case 'lbtn':
    ReadFrom (&lbtn, stream);
    rc = TAG_READ;
    break;

  case 'rbtn':
    ReadFrom (&rbtn, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CRMINeedleGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CRMINeedleGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = lbtn.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = rbtn.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CNavGaugeGroup
//

CNavGaugeGroup::CNavGaugeGroup (void)
{
  nav1 = nav2 = 0;
}

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

  switch (tag) {
  case 'nav1':
    ReadTag (&nav1, stream);
    rc = TAG_READ;
    break;

  case 'nav2':
    ReadTag (&nav2, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CNavGaugeGroup::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CRadioGaugeGroup
//
CRadioGaugeGroup::CRadioGaugeGroup (void)
{
  rad1_tag = rad2_tag = key_tag = 0;
}

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

  switch (tag) {
  case 'rad1':
    ReadTag (&rad1_tag, stream);
    rc = TAG_READ;
    break;

  case 'rad2':
    ReadTag (&rad2_tag, stream);
    rc = TAG_READ;
    break;

  case 'key_':
    ReadTag (&key_tag, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CRadioGaugeGroup::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CAnnunciator
//
CAnnunciator::CAnnunciator (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CAnnunciator::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CFlyhawkAnnunciator
//

CFlyhawkAnnunciator::CFlyhawkAnnunciator (void)
{
  strcpy (lowf_art, "");
  strcpy (lowl_art, "");
  strcpy (lowr_art, "");
  strcpy (oilp_art, "");
  strcpy (vacl_art, "");
  strcpy (vacr_art, "");
  strcpy (lowv_art, "");
  strcpy (volt_art, "");
  strcpy (line_art, "");
}

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

  switch (tag) {
  case 'lowf':
    ReadString (lowf_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'lowl':
    ReadString (lowl_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'lowr':
    ReadString (lowr_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'oilp':
    ReadString (oilp_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'vacl':
    ReadString (vacl_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'vacr':
    ReadString (vacr_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'lowv':
    ReadString (lowv_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'volt':
    ReadString (volt_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'line':
    ReadString (line_art, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlyhawkAnnunciator::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CFlyhawkAnnunciatorTest
//

CFlyhawkAnnunciatorTest::CFlyhawkAnnunciatorTest (void)
{
  strcpy (swit_art, "");
  strcpy (sfxu_wav, "");
  strcpy (sfxd_wav, "");
  strcpy (csru_csr, "");
  strcpy (csrd_csr, "");
}

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

  switch (tag) {
  case 'swit':
    ReadString (swit_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'sfxu':
    ReadString (sfxu_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'sfxd':
    ReadString (sfxd_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'csru':
    ReadString (csru_csr, 64, stream);
    rc = TAG_READ;
    break;

  case 'csrd':
    ReadString (csrd_csr, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlyhawkAnnunciatorTest::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CFlyhawkNavGpsPanelGauge
//

CFlyhawkNavGpsPanelGauge::CFlyhawkNavGpsPanelGauge (void)
{
  xnav_x = xnav_y = 0;
  xgps_x = xgps_y = 0;
  xapr_x = xapr_y = 0;
  xmsg_x = xmsg_y = 0;
  xwpt_x = xwpt_y = 0;
}

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

  switch (tag) {
  case 'cnav':
    ReadFrom (&cnav, stream);
    rc = TAG_READ;
    break;

  case 'capr':
    ReadFrom (&capr, stream);
    rc = TAG_READ;
    break;

  case 'xnav':
    ReadInt (&xnav_x, stream);
    ReadInt (&xnav_y, stream);
    rc = TAG_READ;
    break;

  case 'xgps':
    ReadInt (&xgps_x, stream);
    ReadInt (&xgps_y, stream);
    rc = TAG_READ;
    break;

  case 'xapr':
    ReadInt (&xapr_x, stream);
    ReadInt (&xapr_y, stream);
    rc = TAG_READ;
    break;

  case 'xmsg':
    ReadInt (&xmsg_x, stream);
    ReadInt (&xmsg_y, stream);
    rc = TAG_READ;
    break;

  case 'xwpt':
    ReadInt (&xwpt_x, stream);
    ReadInt (&xwpt_y, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlyhawkNavGpsPanelGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CFlyhawkNavGpsPanelGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = cnav.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = capr.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CFlyhawkFuelSelectorGauge
//

CFlyhawkFuelSelectorGauge::CFlyhawkFuelSelectorGauge (void)
{
  strcpy (swit_art, "");
  memset (&Lmsg, 0, sizeof(SMessage));
  memset (&Rmsg, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'swit':
    ReadString (swit_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'left':
    ReadFrom (&left, stream);
    rc = TAG_READ;
    break;

  case 'both':
    ReadFrom (&both, stream);
    rc = TAG_READ;
    break;

  case 'righ':
    ReadFrom (&righ, stream);
    rc = TAG_READ;
    break;

  case 'Lmsg':
    ReadMessage (&Lmsg, stream);
    rc = TAG_READ;
    break;

  case 'Rmsg':
    ReadMessage (&Rmsg, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlyhawkFuelSelectorGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CFlyhawkFuelSelectorGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = left.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = righ.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = both.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CFlyhawkElevatorTrimGauge
//

CFlyhawkElevatorTrimGauge::CFlyhawkElevatorTrimGauge (void)
{
  strcpy (trmw.art, "");
  trmw.x = trmw.y = 0;
  strcpy (trmi.art, "");
  trmi.x = trmi.y = 0;
}

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

  switch (tag) {
  case 'trmw':
    ReadString (trmw.art, 64, stream);
    ReadInt (&trmw.x, stream);
    ReadInt (&trmw.y, stream);
    rc = TAG_READ;
    break;

  case 'trmi':
    ReadString (trmi.art, 64, stream);
    ReadInt (&trmi.x, stream);
    ReadInt (&trmi.y, stream);
    rc = TAG_READ;
    break;

  case 'down':
    ReadFrom (&down, stream);
    rc = TAG_READ;
    break;

  case 'up  ':
    ReadFrom (&up, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlyhawkElevatorTrimGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CFlyhawkElevatorTrimGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = down.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = up.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CMalybooCHTIndicatorGauge
//
CMalybooCHTIndicatorGauge::CMalybooCHTIndicatorGauge (void)
{
  for (int i=0; i<6; i++) xoff[i] = 0;
  yoff = 0;
}

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

  switch (tag) {
  case 'xoff':
    ReadInt (&xoff[0], stream);
    ReadInt (&xoff[1], stream);
    ReadInt (&xoff[2], stream);
    ReadInt (&xoff[3], stream);
    ReadInt (&xoff[4], stream);
    ReadInt (&xoff[5], stream);
    rc = TAG_READ;
    break;

  case 'yoff':
    ReadInt (&yoff, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CMalybooCHTIndicatorGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CMalybooCHTButtonGauge
//
CMalybooCHTButtonGauge::CMalybooCHTButtonGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CMalybooCHTButtonGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CMalybooNavGpsPanelGauge
//

CMalybooNavGpsPanelGauge::CMalybooNavGpsPanelGauge (void)
{
  xnav_x = xnav_y = 0;
  xgps_x = xgps_y = 0;
  xapr_x = xapr_y = 0;
  xarm_x = xarm_y = 0;
  xact_x = xact_y = 0;
  xcrs_x = xcrs_y = 0;
  xobs_x = xobs_y = 0;
  xleg_x = xleg_y = 0;
  xmsg_x = xmsg_y = 0;
  xwpt_x = xwpt_y = 0;
  xyaw_x = xyaw_y = 0;
}

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

  switch (tag) {
  case 'cnav':
    ReadFrom (&cnav, stream);
    rc = TAG_READ;
    break;

  case 'xnav':
    ReadInt (&xnav_x, stream);
    ReadInt (&xnav_y, stream);
    rc = TAG_READ;
    break;

  case 'xgps':
    ReadInt (&xgps_x, stream);
    ReadInt (&xgps_y, stream);
    rc = TAG_READ;
    break;

  case 'capr':
    ReadFrom (&cnav, stream);
    rc = TAG_READ;
    break;

  case 'xapr':
    ReadInt (&xapr_x, stream);
    ReadInt (&xapr_y, stream);
    rc = TAG_READ;
    break;

  case 'xarm':
    ReadInt (&xarm_x, stream);
    ReadInt (&xarm_y, stream);
    rc = TAG_READ;
    break;

  case 'xact':
    ReadInt (&xact_x, stream);
    ReadInt (&xact_y, stream);
    rc = TAG_READ;
    break;

  case 'ccrs':
    ReadFrom (&cnav, stream);
    rc = TAG_READ;
    break;

  case 'xcrs':
    ReadInt (&xcrs_x, stream);
    ReadInt (&xcrs_y, stream);
    rc = TAG_READ;
    break;

  case 'xobs':
    ReadInt (&xobs_x, stream);
    ReadInt (&xobs_y, stream);
    rc = TAG_READ;
    break;

  case 'xleg':
    ReadInt (&xleg_x, stream);
    ReadInt (&xleg_y, stream);
    rc = TAG_READ;
    break;

  case 'cmsg':
    ReadFrom (&cnav, stream);
    rc = TAG_READ;
    break;

  case 'xmsg':
    ReadInt (&xmsg_x, stream);
    ReadInt (&xmsg_y, stream);
    rc = TAG_READ;
    break;

  case 'xwpt':
    ReadInt (&xwpt_x, stream);
    ReadInt (&xwpt_y, stream);
    rc = TAG_READ;
    break;

  case 'cyaw':
    ReadFrom (&cnav, stream);
    rc = TAG_READ;
    break;

  case 'xyaw':
    ReadInt (&xyaw_x, stream);
    ReadInt (&xyaw_y, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CMalybooNavGpsPanelGauge::Read : Unknown tag %s", s);
  }

  return rc;
}



//
// CMalybooDigitalClockGauge
//

CMalybooDigitalClockGauge::CMalybooDigitalClockGauge (void)
{
  clkd_x1 = clkd_y1 = clkd_x2 = clkd_y2 = 0;
}

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

  switch (tag) {
  case 'clkd':
    ReadInt (&clkd_x1, stream);
    ReadInt (&clkd_y1, stream);
    ReadInt (&clkd_x2, stream);
    ReadInt (&clkd_y2, stream);
    rc = TAG_READ;
    break;

  case 'mode':
    ReadFrom (&mode, stream);
    rc = TAG_READ;
    break;

  case 'powr':
    ReadFrom (&powr, stream);
    rc = TAG_READ;
    break;

  case 'play':
    ReadFrom (&play, stream);
    rc = TAG_READ;
    break;

  case 'rec_':
    ReadFrom (&rec, stream);
    rc = TAG_READ;
    break;

  case 'set_':
    ReadFrom (&set, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CMalybooDigitalClockGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CMalybooEngineMonitorGauge
//
CMalybooEngineMonitorGauge::CMalybooEngineMonitorGauge (void)
{
  strcpy (rlit_art, "");
  strcpy (glit_art, "");
  strcpy (ylit_art, "");
}

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

  switch (tag) {
  case 'fuel':
    ReadFrom (&fuel, stream);
    rc = TAG_READ;
    break;

  case 'inst':
    ReadFrom (&inst, stream);
    rc = TAG_READ;
    break;

  case 'blk_':
    ReadFrom (&blk_, stream);
    rc = TAG_READ;
    break;

  case 'fill':
    ReadFrom (&fill, stream);
    rc = TAG_READ;
    break;

  case 'pwr_':
    ReadFrom (&pwr_, stream);
    rc = TAG_READ;
    break;

  case 'set_':
    ReadFrom (&set_, stream);
    rc = TAG_READ;
    break;

  case 'MAP_':
    ReadFrom (&MAP_, stream);
    rc = TAG_READ;
    break;

  case 'RPM_':
    ReadFrom (&RPM_, stream);
    rc = TAG_READ;
    break;

  case 'TIT_':
    ReadFrom (&TIT, stream);
    rc = TAG_READ;
    break;

  case 'FF__':
    ReadFrom (&FF__, stream);
    rc = TAG_READ;
    break;

  case 'OT__':
    ReadFrom (&OT__, stream);
    rc = TAG_READ;
    break;

  case 'OP__':
    ReadFrom (&OP__, stream);
    rc = TAG_READ;
    break;

  case 'CHT_':
    ReadFrom (&CHT_, stream);
    rc = TAG_READ;
    break;

  case 'VAC_':
    ReadFrom (&VAC_, stream);
    rc = TAG_READ;
    break;

  case 'LQTY':
    ReadFrom (&LQTY, stream);
    rc = TAG_READ;
    break;

  case 'RQTY':
    ReadFrom (&RQTY, stream);
    rc = TAG_READ;
    break;

  case 'rlit':
    ReadString (rlit_art, 64, stream);
//    ReadString (glit_art, 64, stream);
//    ReadString (ylit_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'glit':
    ReadString (glit_art, 64, stream);
//    ReadString (glit_art, 64, stream);
//    ReadString (ylit_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'ylit':
    ReadString (ylit_art, 64, stream);
//    ReadString (glit_art, 64, stream);
//    ReadString (ylit_art, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CMalybooEngineMonitorGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CNavajoFuelSelectorGauge
//
CNavajoFuelSelectorGauge::CNavajoFuelSelectorGauge (void)
{
  strcpy (swit, "");
  memset (&obms, 0, sizeof(SMessage));
  memset (&ibms, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'swit':
    ReadString (swit, 64, stream);
    rc = TAG_READ;
    break;

  case 'obca':
    ReadFrom (&obca, stream);
    rc = TAG_READ;
    break;

  case 'ofca':
    ReadFrom (&ofca, stream);
    rc = TAG_READ;
    break;

  case 'ibca':
    ReadFrom (&obca, stream);
    rc = TAG_READ;
    break;

  case 'obms':
    ReadMessage (&obms, stream);
    rc = TAG_READ;
    break;

  case 'ibms':
    ReadMessage (&ibms, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CNavajoFuelSelectorGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CNavajoFuelAmmeterGauge
//
CNavajoAmmeterGauge::CNavajoAmmeterGauge (void)
{
  memset (&mChg, 0, sizeof(SMessage));
  memset (&mLtM, 0, sizeof(SMessage));
  memset (&mRtM, 0, sizeof(SMessage));
  memset (&mLtS, 0, sizeof(SMessage));
  memset (&mRtS, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'nedl':
    ReadFrom (&nedl, stream);
    rc = TAG_READ;
    break;

  case 'mChg':
    ReadMessage (&mChg, stream);
    rc = TAG_READ;
    break;

  case 'mLtM':
    ReadMessage (&mLtM, stream);
    rc = TAG_READ;
    break;

  case 'mRtM':
    ReadMessage (&mRtM, stream);
    rc = TAG_READ;
    break;

  case 'mLtS':
    ReadMessage (&mLtS, stream);
    rc = TAG_READ;
    break;

  case 'mRtS':
    ReadMessage (&mRtS, stream);
    rc = TAG_READ;
    break;

  case 'ca01':
    ReadFrom (&ca01, stream);
    rc = TAG_READ;
    break;

  case 'ca02':
    ReadFrom (&ca02, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CNavajoAmmeterGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CNavajoRadarAltimeterGauge
//
CNavajoRadarAltimeterGauge::CNavajoRadarAltimeterGauge (void)
{
  memset (&bMsg, 0, sizeof(SMessage));
  strcpy (bug.art, "");
  bug.x = bug.y = 0;
  strcpy (plit.art, "");
  plit.x = plit.y = 0;
  memset (&dhms, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'bMsg':
    ReadMessage (&bMsg, stream);
    rc = TAG_READ;
    break;

  case 'dhbt':
    SkipObject (stream);
//    ReadTable (&dhbt, stream);
    rc = TAG_READ;
    break;

  case 'bug ':
    ReadString (bug.art, 64, stream);
    ReadInt (&bug.x, stream);
    ReadInt (&bug.y, stream);
    rc = TAG_READ;
    break;

  case 'plit':
    ReadString (plit.art, 64, stream);
    ReadInt (&plit.x, stream);
    ReadInt (&plit.y, stream);
    rc = TAG_READ;
    break;

  case 'dhms':
    ReadMessage (&dhms, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CNeedleGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CNavajoRadarAltimeterGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CCollinsEFISSelectionGauge
//
CCollinsEFISSelectionGauge::CCollinsEFISSelectionGauge (void)
{
  memset (&pfdm, 0, sizeof(SMessage));
  memset (&ehim, 0, sizeof(SMessage));
  memset (&mndm, 0, sizeof(SMessage));
  memset (&adm_, 0, sizeof(SMessage));
  memset (&aplt, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'brg_':
    ReadFrom (&brg_, stream);
    rc = TAG_READ;
    break;

  case 'brgm':
    ReadFrom (&brgm, stream);
    rc = TAG_READ;
    break;

  case 'brgk':
    ReadFrom (&brgk, stream);
    rc = TAG_READ;
    break;

  case 'dh__':
    ReadFrom (&dh__, stream);
    rc = TAG_READ;
    break;

  case 'form':
    ReadFrom (&form, stream);
    rc = TAG_READ;
    break;

  case 'crs_':
    ReadFrom (&crs_, stream);
    rc = TAG_READ;
    break;

  case 'crsm':
    ReadFrom (&crsm, stream);
    rc = TAG_READ;
    break;

  case 'crsk':
    ReadFrom (&crsk, stream);
    rc = TAG_READ;
    break;

  case 'wx__':
    ReadFrom (&wx__, stream);
    rc = TAG_READ;
    break;

  case 'nav_':
    ReadFrom (&nav_, stream);
    rc = TAG_READ;
    break;

  case 'pfdm':
    ReadMessage (&pfdm, stream);
    rc = TAG_READ;
    break;

  case 'ehim':
    ReadMessage (&ehim, stream);
    rc = TAG_READ;
    break;

  case 'mndm':
    ReadMessage (&mndm, stream);
    rc = TAG_READ;
    break;

  case 'adm_':
    ReadMessage (&adm_, stream);
    rc = TAG_READ;
    break;

  case 'aplt':
    ReadMessage (&aplt, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCollinsEFISSelectionGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CCollinsVspeedPanel
//
CCollinsVspeedPanel::CCollinsVspeedPanel (void)
{
}

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

  switch (tag) {
  case 'sped':
    ReadFrom (&sped, stream);
    rc = TAG_READ;
    break;

  case 'vsel':
    ReadFrom (&vsel, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCollinsVspeedPanel::Read : Unknown tag %s", s);
  }

  return rc;
}



//
// CCollinsHFRadioGauge
//
CCollinsHFRadioGauge::CCollinsHFRadioGauge (void)
{
  ft13 = false;
}

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

  switch (tag) {
  case 'tel_':
    ReadFrom (&tel, stream);
    rc = TAG_READ;
    break;

  case 'am__':
    ReadFrom (&am, stream);
    rc = TAG_READ;
    break;

  case 'usb_':
    ReadFrom (&usb, stream);
    rc = TAG_READ;
    break;

  case 'lsb_':
    ReadFrom (&lsb, stream);
    rc = TAG_READ;
    break;

  case 'mhz_':
    ReadFrom (&mhz, stream);
    rc = TAG_READ;
    break;

  case 'khz_':
    ReadFrom (&khz, stream);
    rc = TAG_READ;
    break;

  case 'stor':
    ReadFrom (&stor, stream);
    rc = TAG_READ;
    break;

  case 'tune':
    ReadFrom (&tune, stream);
    rc = TAG_READ;
    break;

  case 'volu':
    ReadFrom (&volu, stream);
    rc = TAG_READ;
    break;

  case 'dash':
    ReadFrom (&dash, stream);
    rc = TAG_READ;
    break;

  case 'tx__':
    ReadFrom (&tx, stream);
    rc = TAG_READ;
    break;

  case 'chan':
    ReadFrom (&chan, stream);
    rc = TAG_READ;
    break;

  case 'ft13':
    ft13 = true;
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCollinsHFRadioGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CCollinsPFDGauge
//
CCollinsPFDGauge::CCollinsPFDGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCollinsPFDGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CCollinsNDGauge
//
CCollinsNDGauge::CCollinsNDGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCollinsNDGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CCollinsRTUGauge
//
CCollinsRTUGauge::CCollinsRTUGauge (void)
{
  memset (&rtu_, 0, sizeof(SMessage));
  memset (&dme1, 0, sizeof(SMessage));
  memset (&dme2, 0, sizeof(SMessage));
  strcpy (dmeH.art, "");
  dmeH.x = dmeH.y = 0;
  strcpy (repl.art, "");
  repl.x = repl.y = 0;
  side = 0;
}

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

  switch (tag) {
  case 'lin1':
    ReadFrom (&lin1, stream);
    rc = TAG_READ;
    break;

  case 'lin2':
    ReadFrom (&lin2, stream);
    rc = TAG_READ;
    break;

  case 'lin3':
    ReadFrom (&lin3, stream);
    rc = TAG_READ;
    break;

  case 'lin4':
    ReadFrom (&lin4, stream);
    rc = TAG_READ;
    break;

  case 'lin5':
    ReadFrom (&lin4, stream);
    rc = TAG_READ;
    break;

  case 'btn1':
    ReadFrom (&btn1, stream);
    rc = TAG_READ;
    break;

  case 'btn2':
    ReadFrom (&btn2, stream);
    rc = TAG_READ;
    break;

  case 'btn3':
    ReadFrom (&btn3, stream);
    rc = TAG_READ;
    break;

  case 'btn4':
    ReadFrom (&btn4, stream);
    rc = TAG_READ;
    break;

  case 'btn5':
    ReadFrom (&btn5, stream);
    rc = TAG_READ;
    break;

  case 'cmaw':
    ReadFrom (&cmaw, stream);
    rc = TAG_READ;
    break;

  case 'cmaf':
    ReadFrom (&cmaf, stream);
    rc = TAG_READ;
    break;

  case 'cmsw':
    ReadFrom (&cmsw, stream);
    rc = TAG_READ;
    break;

  case 'cmsf':
    ReadFrom (&cmsf, stream);
    rc = TAG_READ;
    break;

  case 'nvaw':
    ReadFrom (&nvaw, stream);
    rc = TAG_READ;
    break;

  case 'nvaf':
    ReadFrom (&nvaf, stream);
    rc = TAG_READ;
    break;

  case 'adf1':
    ReadFrom (&adf1, stream);
    rc = TAG_READ;
    break;

  case 'adf2':
    ReadFrom (&adf2, stream);
    rc = TAG_READ;
    break;

  case 'adf3':
    ReadFrom (&adf3, stream);
    rc = TAG_READ;
    break;

  case 'adf4':
    ReadFrom (&adf4, stream);
    rc = TAG_READ;
    break;

  case 'adf5':
    ReadFrom (&adf5, stream);
    rc = TAG_READ;
    break;

  case 'xpd1':
    ReadFrom (&xpd1, stream);
    rc = TAG_READ;
    break;

  case 'xpd2':
    ReadFrom (&xpd2, stream);
    rc = TAG_READ;
    break;

  case 'xpd3':
    ReadFrom (&xpd3, stream);
    rc = TAG_READ;
    break;

  case 'xpd4':
    ReadFrom (&xpd4, stream);
    rc = TAG_READ;
    break;

  case 'atci':
    ReadFrom (&atci, stream);
    rc = TAG_READ;
    break;

  case 'dmeh':
    ReadFrom (&dmeh, stream);
    rc = TAG_READ;
    break;

  case 'coms':
    ReadFrom (&coms, stream);
    rc = TAG_READ;
    break;

  case 'atcs':
    ReadFrom (&atcs, stream);
    rc = TAG_READ;
    break;

  case '1/2_':
    ReadFrom (&b1_2, stream);
    rc = TAG_READ;
    break;

  case 'adft':
    ReadFrom (&xpd1, stream);
    rc = TAG_READ;
    break;

  case 'rtu_':
    ReadMessage (&rtu_, stream);
    rc = TAG_READ;
    break;

  case 'dme1':
    ReadMessage (&dme1, stream);
    rc = TAG_READ;
    break;

  case 'dme2':
    ReadMessage (&dme2, stream);
    rc = TAG_READ;
    break;

  case 'dmeH':
    ReadString (dmeH.art, 64, stream);
    ReadInt (&dmeH.x, stream);
    ReadInt (&dmeH.y, stream);
    rc = TAG_READ;
    break;

  case 'repl':
    ReadString (repl.art, 64, stream);
    ReadInt (&repl.x, stream);
    ReadInt (&repl.y, stream);
    rc = TAG_READ;
    break;

  case 'side':
    ReadInt (&side, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCollinsRTUGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CCollinsAirDataGauge
//
CCollinsAirDataGauge::CCollinsAirDataGauge (void)
{
}

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

  switch (tag) {
  case 'scrn':
    ReadFrom (&scrn, stream);
    rc = TAG_READ;
    break;

  case 'baro':
    ReadFrom (&baro, stream);
    rc = TAG_READ;
    break;

  case 'vs__':
    ReadFrom (&vs__, stream);
    rc = TAG_READ;
    break;

  case 'alt_':
    ReadFrom (&alt_, stream);
    rc = TAG_READ;
    break;

  case 'in__':
    ReadFrom (&in__, stream);
    rc = TAG_READ;
    break;

  case 'mb__':
    ReadFrom (&mb__, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCollinsAirDataGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CCollinsMNDGauge
//
CCollinsMNDGauge::CCollinsMNDGauge (void)
{
  memset (&obs_, 0, sizeof(SMessage));
  memset (&ap__, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'obs_':
    ReadMessage (&obs_, stream);
    rc = TAG_READ;
    break;

  case 'ap__':
    ReadMessage (&ap__, stream);
    rc = TAG_READ;
    break;

  case 'frmt':
    ReadFrom (&frmt, stream);
    rc = TAG_READ;
    break;

  case 'hdg_':
    ReadFrom (&hdg_, stream);
    rc = TAG_READ;
    break;

  case 'crs_':
    ReadFrom (&crs_, stream);
    rc = TAG_READ;
    break;

  case 'brgt':
    ReadFrom (&brgt, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCollinsMNDGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CUniversalFMSGauge
//
CUniversalFMSGauge::CUniversalFMSGauge (void)
{
}

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

  switch (tag) {
  case 'scrn':
    ReadFrom (&scrn, stream);
    rc = TAG_READ;
    break;

  case 'l1__':
    ReadFrom (&l1, stream);
    rc = TAG_READ;
    break;

  case 'l2__':
    ReadFrom (&l2, stream);
    rc = TAG_READ;
    break;

  case 'l3__':
    ReadFrom (&l3, stream);
    rc = TAG_READ;
    break;

  case 'l4__':
    ReadFrom (&l4, stream);
    rc = TAG_READ;
    break;

  case 'l5__':
    ReadFrom (&l5, stream);
    rc = TAG_READ;
    break;

  case 'r1__':
    ReadFrom (&r1, stream);
    rc = TAG_READ;
    break;

  case 'r2__':
    ReadFrom (&r2, stream);
    rc = TAG_READ;
    break;

  case 'r3__':
    ReadFrom (&r3, stream);
    rc = TAG_READ;
    break;

  case 'r4__':
    ReadFrom (&r4, stream);
    rc = TAG_READ;
    break;

  case 'r5__':
    ReadFrom (&r5, stream);
    rc = TAG_READ;
    break;

  case 'data':
    ReadFrom (&data, stream);
    rc = TAG_READ;
    break;

  case 'nav_':
    ReadFrom (&nav, stream);
    rc = TAG_READ;
    break;

  case 'vnav':
    ReadFrom (&vnav, stream);
    rc = TAG_READ;
    break;

  case 'dto_':
    ReadFrom (&dto, stream);
    rc = TAG_READ;
    break;

  case 'list':
    ReadFrom (&list, stream);
    rc = TAG_READ;
    break;

  case 'prev':
    ReadFrom (&prev, stream);
    rc = TAG_READ;
    break;

  case 'fuel':
    ReadFrom (&fuel, stream);
    rc = TAG_READ;
    break;

  case 'fpl_':
    ReadFrom (&fpl, stream);
    rc = TAG_READ;
    break;

  case 'perf':
    ReadFrom (&perf, stream);
    rc = TAG_READ;
    break;

  case 'tune':
    ReadFrom (&tune, stream);
    rc = TAG_READ;
    break;

  case 'menu':
    ReadFrom (&menu, stream);
    rc = TAG_READ;
    break;

  case 'next':
    ReadFrom (&next, stream);
    rc = TAG_READ;
    break;

  case '1___':
    ReadFrom (&key1, stream);
    rc = TAG_READ;
    break;

  case '2___':
    ReadFrom (&key2, stream);
    rc = TAG_READ;
    break;

  case '3___':
    ReadFrom (&key3, stream);
    rc = TAG_READ;
    break;

  case '4___':
    ReadFrom (&key4, stream);
    rc = TAG_READ;
    break;

  case '5___':
    ReadFrom (&key5, stream);
    rc = TAG_READ;
    break;

  case '6___':
    ReadFrom (&key6, stream);
    rc = TAG_READ;
    break;

  case '7___':
    ReadFrom (&key7, stream);
    rc = TAG_READ;
    break;

  case '8___':
    ReadFrom (&key8, stream);
    rc = TAG_READ;
    break;

  case '9___':
    ReadFrom (&key9, stream);
    rc = TAG_READ;
    break;

  case 'back':
    ReadFrom (&back, stream);
    rc = TAG_READ;
    break;

  case '0___':
    ReadFrom (&key0, stream);
    rc = TAG_READ;
    break;

  case 'msg_':
    ReadFrom (&msg, stream);
    rc = TAG_READ;
    break;

  case 'dim_':
    ReadFrom (&dim, stream);
    rc = TAG_READ;
    break;

  case '+-__':
    ReadFrom (&plus, stream);
    rc = TAG_READ;
    break;

  case 'entr':
    ReadFrom (&entr, stream);
    rc = TAG_READ;
    break;

  case 'A___':
    ReadFrom (&keyA, stream);
    rc = TAG_READ;
    break;

  case 'B___':
    ReadFrom (&keyB, stream);
    rc = TAG_READ;
    break;

  case 'C___':
    ReadFrom (&keyC, stream);
    rc = TAG_READ;
    break;

  case 'D___':
    ReadFrom (&keyD, stream);
    rc = TAG_READ;
    break;

  case 'E___':
    ReadFrom (&keyE, stream);
    rc = TAG_READ;
    break;

  case 'F___':
    ReadFrom (&keyF, stream);
    rc = TAG_READ;
    break;

  case 'G___':
    ReadFrom (&keyG, stream);
    rc = TAG_READ;
    break;

  case 'H___':
    ReadFrom (&keyH, stream);
    rc = TAG_READ;
    break;

  case 'I___':
    ReadFrom (&keyI, stream);
    rc = TAG_READ;
    break;

  case 'J___':
    ReadFrom (&keyJ, stream);
    rc = TAG_READ;
    break;

  case 'K___':
    ReadFrom (&keyK, stream);
    rc = TAG_READ;
    break;

  case 'L___':
    ReadFrom (&keyL, stream);
    rc = TAG_READ;
    break;

  case 'M___':
    ReadFrom (&keyM, stream);
    rc = TAG_READ;
    break;

  case 'N___':
    ReadFrom (&keyN, stream);
    rc = TAG_READ;
    break;

  case 'O___':
    ReadFrom (&keyO, stream);
    rc = TAG_READ;
    break;

  case 'P___':
    ReadFrom (&keyP, stream);
    rc = TAG_READ;
    break;

  case 'Q___':
    ReadFrom (&keyQ, stream);
    rc = TAG_READ;
    break;

  case 'R___':
    ReadFrom (&keyR, stream);
    rc = TAG_READ;
    break;

  case 'S___':
    ReadFrom (&keyS, stream);
    rc = TAG_READ;
    break;

  case 'T___':
    ReadFrom (&keyT, stream);
    rc = TAG_READ;
    break;

  case 'U___':
    ReadFrom (&keyU, stream);
    rc = TAG_READ;
    break;

  case 'V___':
    ReadFrom (&keyV, stream);
    rc = TAG_READ;
    break;

  case 'W___':
    ReadFrom (&keyW, stream);
    rc = TAG_READ;
    break;

  case 'X___':
    ReadFrom (&keyX, stream);
    rc = TAG_READ;
    break;

  case 'Y___':
    ReadFrom (&keyY, stream);
    rc = TAG_READ;
    break;

  case 'Z___':
    ReadFrom (&keyZ, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CUniversalFMSGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CPilatusEFISPanel
//
CPilatusEFISPanel::CPilatusEFISPanel (void)
{
  memset (&pfdm, 0, sizeof(SMessage));
  memset (&navm, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'pfdm':
    ReadMessage (&pfdm, stream);
    rc = TAG_READ;
    break;

  case 'navm':
    ReadMessage (&navm, stream);
    rc = TAG_READ;
    break;

  case 'dh__':
    ReadFrom (&dh, stream);
    rc = TAG_READ;
    break;

  case 'brt_':
    ReadFrom (&brt, stream);
    rc = TAG_READ;
    break;

  case 'crs_':
    ReadFrom (&crs, stream);
    rc = TAG_READ;
    break;

  case 'hdg_':
    ReadFrom (&hdg, stream);
    rc = TAG_READ;
    break;

  case 'hsi_':
    ReadFrom (&hsi, stream);
    rc = TAG_READ;
    break;

  case 'arc_':
    ReadFrom (&arc, stream);
    rc = TAG_READ;
    break;

  case 'nav_':
    ReadFrom (&nav, stream);
    rc = TAG_READ;
    break;

  case 'rgup':
    ReadFrom (&rgup, stream);
    rc = TAG_READ;
    break;

  case 'rgdn':
    ReadFrom (&rgdn, stream);
    rc = TAG_READ;
    break;

  case 'nav1':
    ReadFrom (&nav1, stream);
    rc = TAG_READ;
    break;

  case 'nav2':
    ReadFrom (&nav2, stream);
    rc = TAG_READ;
    break;

  case 'k1_2':
    ReadFrom (&k1_2, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CPilatusEFISPanel::Read : Unknown tag %s", s);
  }

  return rc;
}

//
// CWalkerTempAirspeedGauge
//
CWalkerTempAirspeedGauge::CWalkerTempAirspeedGauge (void)
{
}

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

  switch (tag) {
  case 'tat_':
    ReadFrom (&tat, stream);
    rc = TAG_READ;
    break;

  case 'sat_':
    ReadFrom (&sat, stream);
    rc = TAG_READ;
    break;

  case 'tas_':
    ReadFrom (&tas, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CWalkerTempAirspeedGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

//
// CGyroSlavingGauge
//
CGyroSlavingGauge::CGyroSlavingGauge (void)
{
  strcpy (slvb.art, "");
  slvb.x = slvb.y = 0;
  strcpy (ccwb.art, "");
  ccwb.x = ccwb.y = 0;
  lrgb_r = lrgb_g = lrgb_b = 0;
  strcpy (sfxu_wav, "");
  strcpy (sfxd_wav, "");
  sfxu_tag = sfxd_tag = 0;
}

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

  switch (tag) {
  case 'nedl':
    ReadString (nedl.art, 64, stream);
    ReadInt (&nedl.x, stream);
    ReadInt (&nedl.y, stream);
    rc = TAG_READ;
    break;

  case 'slvb':
    ReadString (slvb.art, 64, stream);
    ReadInt (&slvb.x, stream);
    ReadInt (&slvb.y, stream);
    rc = TAG_READ;
    break;

  case 'ccwb':
    ReadString (ccwb.art, 64, stream);
    ReadInt (&ccwb.x, stream);
    ReadInt (&ccwb.y, stream);
    rc = TAG_READ;
    break;

  case 'err_':
    ReadFrom (&err, stream);
    rc = TAG_READ;
    break;

  case 'slav':
    ReadFrom (&slav, stream);
    rc = TAG_READ;
    break;

  case 'free':
    ReadFrom (&free, stream);
    rc = TAG_READ;
    break;
  
  case 'mode':
    ReadFrom (&mode, stream);
    rc = TAG_READ;
    break;

  case 'ccw_':
    ReadFrom (&ccw, stream);
    rc = TAG_READ;
    break;

  case 'cw__':
    ReadFrom (&cw, stream);
    rc = TAG_READ;
    break;

  case 'lrgb':
    ReadInt (&lrgb_r, stream);
    ReadInt (&lrgb_g, stream);
    ReadInt (&lrgb_b, stream);
    rc = TAG_READ;
    break;

  case 'sfx_':
    ReadString (sfxu_wav, 64, stream);
    ReadString (sfxd_wav, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CGyroSlavingGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

void CGyroSlavingGauge::ReadFinished (void)
{
  CBitmapGauge::ReadFinished ();

  // Load sound effects
  if (strlen (sfxu_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, sfxu_wav);
    sfxu_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }
  if (strlen (sfxd_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, sfxd_wav);
    sfxd_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }
}


//
// CVerticalRateGauge
//
CVerticalRateGauge::CVerticalRateGauge (void)
{
  avil = 0;
}

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

  switch (tag) {
  case 'eng_':
    ReadFrom (&eng, stream);
    rc = TAG_READ;
    break;

  case 'arm_':
    ReadFrom (&arm, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;

  case 'led_':
    ReadFrom (&led, stream);
    rc = TAG_READ;
    break;

  case 'avil':
    ReadTag (&avil, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CVerticalRateGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

//
// CPropSyncGauge
//
CPropSyncGauge::CPropSyncGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CPropSyncGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

//
// CDMEGauge
//
CDMEGauge::CDMEGauge (void)
{
  hold = false;
  dist_x = dist_y = 0;
  sped_x = sped_y = 0;
  time_x = time_y = 0;
  tiny = false;
}

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

  switch (tag) {
  case 'hold':
    hold = true;
    rc = TAG_READ;
    break;

  case 'dist':
    ReadInt (&dist_x, stream);
    ReadInt (&dist_y, stream);
    rc = TAG_READ;
    break;

  case 'sped':
    ReadInt (&sped_x, stream);
    ReadInt (&sped_y, stream);
    rc = TAG_READ;
    break;

  case 'time':
    ReadInt (&time_x, stream);
    ReadInt (&time_y, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;

  case 'tiny':
    tiny = true;
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDMEGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CDMEGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = knob.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CDME2Gauge
//
CDME2Gauge::CDME2Gauge (void)
{
  hold = false;
  left_x = left_y = 0;
  rght_x = rght_y = 0;
}

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

  switch (tag) {
  case 'hold':
    hold = true;
    rc = TAG_READ;
    break;

  case 'left':
    ReadInt (&left_x, stream);
    ReadInt (&left_y, stream);
    rc = TAG_READ;
    break;

  case 'rght':
    ReadInt (&rght_x, stream);
    ReadInt (&rght_y, stream);
    rc = TAG_READ;
    break;

  case 'ch__':
    ReadFrom (&ch, stream);
    rc = TAG_READ;
    break;

  case 'sel_':
    ReadFrom (&sel, stream);
    rc = TAG_READ;
    break;

  case 'pwr_':
    ReadFrom (&pwr, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDME2Gauge::Read : Unknown tag %s", s);
  }

  return rc;
}


ECursorResult CDME2Gauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = ch.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = sel.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = pwr.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CBitmapGauge::MouseMoved (x, y);
  }

  return rc;
}

//
// CWeatherRadarGauge
//
CWeatherRadarGauge::CWeatherRadarGauge (void)
{
}

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

  switch (tag) {
  case 'scrn':
    ReadFrom (&scrn, stream);
    rc = TAG_READ;
    break;

  case 'wx__':
    ReadFrom (&wx, stream);
    rc = TAG_READ;
    break;

  case 'vp__':
    ReadFrom (&vp, stream);
    rc = TAG_READ;
    break;

  case 'map_':
    ReadFrom (&map, stream);
    rc = TAG_READ;
    break;

  case 'nav_':
    ReadFrom (&nav, stream);
    rc = TAG_READ;
    break;

  case 'rng+':
    ReadFrom (&rngp, stream);
    rc = TAG_READ;
    break;

  case 'rng-':
    ReadFrom (&rngm, stream);
    rc = TAG_READ;
    break;

  case 'trk+':
    ReadFrom (&trkp, stream);
    rc = TAG_READ;
    break;

  case 'trk-':
    ReadFrom (&trkm, stream);
    rc = TAG_READ;
    break;

  case 'mode':
    ReadFrom (&mode, stream);
    rc = TAG_READ;
    break;

  case 'tilt':
    ReadFrom (&tilt, stream);
    rc = TAG_READ;
    break;

  case 'gain':
    ReadFrom (&gain, stream);
    rc = TAG_READ;
    break;

  case 'brit':
    ReadFrom (&brit, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CWeatherRadarGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CAnalogAltPreselectGauge
//
CAnalogAltPreselectGauge::CAnalogAltPreselectGauge (void)
{
  strcpy (fdig_art, "");
  strcpy (digi_art, "");
  strcpy (zero_art, "");
  thou_x = thou_y = 0;
  hund_x = hund_y = 0;
  ones_x = ones_y = 0;
  dspc = 0;
  zspc = 0;
}

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

  switch (tag) {
  case 'knob':
    ReadFrom (&knob, stream);
    rc = TAG_READ;
    break;

  case 'fdig':
    ReadString (fdig_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'digi':
    ReadString (digi_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'zero':
    ReadString (zero_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'thou':
    ReadInt (&thou_x, stream);
    ReadInt (&thou_y, stream);
    rc = TAG_READ;
    break;

  case 'hund':
    ReadInt (&hund_x, stream);
    ReadInt (&hund_y, stream);
    rc = TAG_READ;
    break;

  case 'ones':
    ReadInt (&ones_x, stream);
    ReadInt (&ones_y, stream);
    rc = TAG_READ;
    break;

  case 'dspc':
    ReadInt (&dspc, stream);
    rc = TAG_READ;
    break;

  case 'zspc':
    ReadInt (&zspc, stream);
    rc = TAG_READ;
    break;

  case 'aler':
    ReadFrom (&aler, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CAnalogAltPreselectGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CMomentaryHotSpotGauge
//

CMomentaryHotSpotGauge::CMomentaryHotSpotGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CMomentaryHotSpotGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CLitInOutSwitch
//

CLitInOutSwitch::CLitInOutSwitch (void)
{
  memset (&powr, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'powr':
    ReadMessage (&powr, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CSimpleInOutStateSwitch::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CLitInOutSwitchGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CSimpleSwitch
//

CSimpleSwitch::CSimpleSwitch (void)
{
  strcpy (bmap_art, "");
  bmap = NULL;

  // Sound effect initialization
  strcpy (sfxu_wav, "");
  strcpy (sfxd_wav, "");
  sfxu_tag = sfxd_tag = 0;

  // Cursor initialization
  strcpy (csru_csr, "");
  strcpy (csrd_csr, "");
  csru_tag = csrd_tag = 0;

  stat_n = 0;
  stat = NULL;
  sstr_n = 0;
  sstr = NULL;
  orie = 0;
  ordr = 0;
  indx = 0;
  mmnt = false;
  mntO = false;
}

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

  switch (tag) {
  case 'bmap':
    ReadString (bmap_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'sfxi':
  case 'sfxd':
  case 'sfxl':
    ReadString (sfxd_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'sfxo':
  case 'sfxu':
  case 'sfxr':
    ReadString (sfxu_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'csrd':
  case 'csrl':
    ReadString (csrd_csr, 64, stream);
    rc = TAG_READ;
    break;

  case 'csru':
  case 'csrr':
    ReadString (csru_csr, 64, stream);
    rc = TAG_READ;
    break;

  case 'stat':
    {
      ReadInt (&stat_n, stream);
      if (stat_n > 16) {
        gtfo ("CSimpleSwitch : <stat> maximum 16 states exceeded");
      }
      stat = new int[stat_n];
      for (int i=0; i<stat_n; i++) {
        ReadInt (&stat[i], stream);
      }
    }
    rc = TAG_READ;
    break;

  case 'sstr':
    {
      ReadInt (&sstr_n, stream);
      if (sstr_n > 16) {
        gtfo ("CSimpleSwitch : <sstr> maximum 16 states exceeded");
      }
      sstr = new char*[sstr_n];
      for (int i=0; i<sstr_n; i++) {
        sstr[i] = new char[64];
        ReadString (sstr[i], 64, stream);
      }
    }
    rc = TAG_READ;
    break;

  case 'orie':
    ReadInt (&orie, stream);
    rc = TAG_READ;
    break;

  case 'ordr':
    ReadInt (&orie, stream);
    rc = TAG_READ;
    break;

  case 'indx':
    ReadInt (&indx, stream);
    rc = TAG_READ;
    break;

  case 'mmnt':
    mmnt = true;
    rc = TAG_READ;
    break;

  case 'mntO':
    mntO = true;
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CSimpleSwitch::Read : Unknown tag %s", s);
  }

  return rc;
}


void CSimpleSwitch::ReadFinished (void)
{
  CGauge::ReadFinished ();

  // Load bitmap artwork
  if (strlen (bmap_art) > 0) {
    bmap = new SBitmap;
    strcpy (bmap->bitmapName, "ART\\");
    strcat (bmap->bitmapName, bmap_art);
    LoadBitmap (bmap);
  }

  // Load sound effects
  if (strlen (sfxu_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, sfxu_wav);
    sfxu_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }
  if (strlen (sfxd_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, sfxd_wav);
    sfxd_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }

  // Bind cursors
  if (strlen (csru_csr) > 0) {
    csru_tag = globals->cursormgr->BindCursor (csru_csr);
  }

  if (strlen (csrd_csr) > 0) {
    csrd_tag = globals->cursormgr->BindCursor (csrd_csr);
  }

  // Initialize default state
  if (stat_n > 0) {
    if (indx < stat_n) {
      last_state = stat[indx];
    } else {
      // Warning : Default index exceeds upper bound of state array
      globals->logWarning->Write ("CSimpleSwitch: Index (%d) exceeds size of state array (%d)",
        indx, stat_n);
    }
  } else {
    // No <stat> tag was specified, default to two states, 0 (off) and 1 (on)
    stat_n = 2;
    stat = new int[2];
    stat[0] = 0;
    stat[1] = 1;
    last_state = indx = 0;
  }
}


void CSimpleSwitch::Draw (void)
{
  // Get subsystem state
  mesg.id = MSG_GETDATA;
  mesg.user.u.datatag = 'st8t';
  if (SendMessage (&mesg) == MSG_PROCESSED) {
    // If state value has changed, lookup new index
    if (last_state != mesg.intData) {
      for (int i=0; i <stat_n; i++) {
        if (mesg.intData == stat[i]) {
          // Found a match
          indx = i;
        }
      }
      last_state = mesg.intData;
    }
  }

  // Draw appropriate bitmap frame
  if (bmap != NULL) {
    DrawBitmap (surf, bmap, 0, 0, indx);
  }
}


// Increment switch state
void CSimpleSwitch::IncState (void)
{
  bool changed = false;

  // Check upper bound and increment index
  if (indx < (stat_n - 1)) {
    // State change is valid
    indx++;
    changed = true;
  }

  // Update subsystem is state has changed
  if (changed) {
    // Play sound effect
    if (sfxu_tag != 0) {
      globals->audiomgr->PlaySfx (sfx_source, sfxu_tag);
    }

    // Send message
    mesg.id = MSG_SETDATA;
    mesg.intData = stat[indx];
    mesg.user.u.datatag = 'st8t';
    SendMessage (&mesg);
  }
}


// Decrement switch state
void CSimpleSwitch::DecState (void)
{
  bool changed = false;

  // Check upper bound and increment index
  if (indx > 0) {
    // State change is valid
    indx--;
    changed = true;
  }

  // Update subsystem is state has changed
  if (changed) {
    // Play sound effect
    if (sfxd_tag != 0) {
      globals->audiomgr->PlaySfx (sfx_source, sfxd_tag);
    }

    // Send message
    mesg.id = MSG_SETDATA;
    mesg.intData = indx;
    mesg.user.u.datatag = 'st8t';
    SendMessage (&mesg);
  }
}


ECursorResult CSimpleSwitch::MouseMoved (int mouseX, int mouseY)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  switch (orie) {
  case 0:
    // Default, vertical orientation
    if (mouseY < (h/2)) {
      // Upper half of gauge increments the state
      if (csru_tag != 0) {
        globals->cursormgr->SetCursor (csru_tag);
        rc = CURSOR_WAS_CHANGED;
      }
    } else {
      // Bottom half of the gauge decrements the state
      if (csrd_tag != 0) {
        globals->cursormgr->SetCursor (csrd_tag);
        rc = CURSOR_WAS_CHANGED;
      }
    }
    break;

  case 1:
    // Horizontal orientation
    if (mouseX < (w/2)) {
      // Left half of the gauge decrements the state
      if (csrd_tag != 0) {
        globals->cursormgr->SetCursor (csrd_tag);
        rc = CURSOR_WAS_CHANGED;
      }
    } else {
      // Right half of the gauge increments the state
      if (csru_tag != 0) {
        globals->cursormgr->SetCursor (csru_tag);
        rc = CURSOR_WAS_CHANGED;
      }
    }
  }

  // Call parent method if necessary
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CGauge::MouseMoved (mouseX, mouseY);
  }

  return rc;
}

EClickResult CSimpleSwitch::MouseClick (int mouseX, int mouseY, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  switch (orie) {
  case 0:
    // Default, vertical orientation
    if (mouseY < (h/2)) {
      // Top half of the gauge increments the state
      IncState ();
    } else {
      // Bottom half of the gauge decrements the state
      DecState ();
    }
    break;

  case 1:
    // Horizontal orientation
    if (mouseX < (w/2)) {
      // Left half of the gauge decrements the state
      DecState ();
    } else {
      // Right half of the gauge increments the state
      IncState ();
    }
  }
  return rc;
}



//
// CSimpleInOutStateSwitch
//

CSimpleInOutStateSwitch::CSimpleInOutStateSwitch (void)
{
  type = GAUGE_SIMPLE_IN_OUT;
  strcpy (sbmp_art, "");
  sbmp = NULL;
  onvl = 1;
  ofvl = 0;
  stat = false;
  strcpy (onht, "");
  strcpy (ofht, "");
  strcpy (onsf_wav, "");
  strcpy (ofsf_wav, "");
  onsf_tag = ofsf_tag = 0;
  strcpy (sstr_off, "");
  strcpy (sstr_on, "");
  mmnt = false;
}

CSimpleInOutStateSwitch::~CSimpleInOutStateSwitch (void)
{
  if (sbmp != NULL) {
    FreeBitmap (sbmp);
    delete sbmp;
  }
}

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

  switch (tag) {
  case 'sbmp':
    ReadString (sbmp_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'onvl':
  case 'in__':
    ReadInt (&onvl, stream);
    rc = TAG_READ;
    break;

  case 'ofvl':
  case 'out_':
    ReadInt (&ofvl, stream);
    rc = TAG_READ;
    break;

  case 'stat':
  case 'st8t':
    ReadInt ((int*)&stat, stream);
    rc = TAG_READ;
    break;

  case 'onht':
    ReadString (onht, 64, stream);
    rc = TAG_READ;
    break;

  case 'ofht':
    ReadString (ofht, 64, stream);
    rc = TAG_READ;
    break;

  case 'onsf': // Might also be onfx
  case 'sfxu':
    ReadString (onsf_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'ofsf':  // Might also be offx
  case 'sfxd':
    ReadString (ofsf_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'sstr':
    ReadString (sstr_off, 64, stream);
    ReadString (sstr_on, 64, stream);
    rc = TAG_READ;
    break;

  case 'mmnt':
    mmnt = true;
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CSimpleInOutSwitchGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


void CSimpleInOutStateSwitch::ReadFinished (void)
{
  CGauge::ReadFinished ();

  // Load bitmap artwork
  if (strlen (sbmp_art) > 0) {
    sbmp = new SBitmap;
    strcpy (sbmp->bitmapName, "ART\\");
    strcat (sbmp->bitmapName, sbmp_art);
    LoadBitmap (sbmp);
  }

  // Load sound effects
  if (strlen (onsf_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, onsf_wav);
    onsf_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }
  if (strlen (ofsf_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, ofsf_wav);
    ofsf_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }
}

void CSimpleInOutStateSwitch::Draw (void)
{
  // Get subsystem state
  mesg.id = MSG_GETDATA;
  mesg.user.u.datatag = 'st8t';
  if (SendMessage (&mesg) == MSG_PROCESSED) {
    if (mesg.intData == onvl) {
      // Switch is in ON state
      stat = true;
    } else if (mesg.intData == ofvl) {
      // Dependent subsystem is in OFF state
      stat = false;
    }
  }

  // Draw appropriate bitmap frame
  if (sbmp != NULL) {
    DrawBitmap (surf, sbmp, 0, 0, stat ? 1 : 0);
  }
}


EClickResult CSimpleInOutStateSwitch::MouseClick (int mouseX, int mouseY, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  // Any mouse click toggles the gauge state in/out
  stat = !stat;

  // Play sound effect
  if (stat && (onsf_tag != 0)) {
    globals->audiomgr->PlaySfx (sfx_source, onsf_tag);
  } else if (!stat && (ofsf_tag != 0)) {
    globals->audiomgr->PlaySfx (sfx_source, ofsf_tag);
  }

  // Send update message to dependent subsystem
  mesg.id = MSG_SETDATA;
  mesg.intData = stat ? onvl : ofvl;
  mesg.user.u.datatag = 'st8t';
  mesg.user.u.hw = HW_SWITCH;
  SendMessage (&mesg);

  return rc;
}


//
// CBasicBatterySwitch
//

CBasicBatterySwitch::CBasicBatterySwitch (void)
{
  altt = batt = 0;
  stateAlt = stateBatt = false;

  // Initialize messages
  memset (&mesgBatt, 0, sizeof(SMessage));
  mesgBatt.user.u.hw = HW_SWITCH;

  memset (&mesgAlt, 0, sizeof(SMessage));
  mesgAlt.user.u.hw = HW_SWITCH;
}


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

  switch (tag) {
  case 'altt':
    {
      Tag t;
      ReadTag (&t, stream);
      mesgAlt.group = (unsigned long) t;
    }
    rc = TAG_READ;
    break;

  case 'batt':
    {
      Tag t;
      ReadTag (&t, stream);
      mesgBatt.group = (unsigned long) t;
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CSimpleSwitch::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CBasicBatterySwitchGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


void CBasicBatterySwitch::Draw (void)
{
  // Get battery and alternator states
  mesgBatt.id = MSG_GETDATA;
  if (SendMessage (&mesgBatt) == MSG_PROCESSED) {
    stateBatt = (mesgBatt.intData != 0);
  }

  mesgAlt.id = MSG_GETDATA;
  if (SendMessage (&mesgAlt) == MSG_PROCESSED) {
    stateAlt = (mesgAlt.intData != 0);
  }

  // Calculate frame number:
  //   0 = Both OFF
  //   1 = Alternator ON, Battery OFF
  //   2 = Alternator OFF, Battery ON
  //   3 = Both ON
  int frame = 0;
  if (stateAlt) frame += 1;
  if (stateBatt) frame += 2;

  // Draw appropriate bitmap frame
  if (bmap != NULL) {
    DrawBitmap (surf, bmap, 0, 0, frame);
  }

}


EClickResult CBasicBatterySwitch::MouseClick (int mouseX, int mouseY, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  if (mouseX < (w/2)) {
    // Left half of the switch controls the alternator
    bool changed = false;
    if (mouseY < (h/2)) {
      // Top half turns the switch ON
      if (!stateAlt) {
        stateAlt = true;
        changed = true;

        // Special case : Turning the alternator OFF to ON causes battery
        //   switch to be turned ON
        stateBatt = true;
      }
    } else {
      // Bottom half turns the switch OFF
      if (stateAlt) {
        stateAlt = false;
        changed = true;
      }
    }

    // Play sound effect if alternator state has changed
    if (changed) {
      if (stateAlt && (sfxu_tag != 0)) {
        globals->audiomgr->PlaySfx (sfx_source, sfxu_tag);
      } else if (!stateAlt && (sfxd_tag != 0)) {
        globals->audiomgr->PlaySfx (sfx_source, sfxd_tag);
      }
    }

  } else {
    // Right half of the switch controls the battery
    bool changed = false;
    if (mouseY < (h/2)) {
      // Top half turns the switch ON
      if (!stateBatt) {
        stateBatt = true;
        changed = true;
      }
    } else {
      // Bottom half turns the switch OFF
      if (stateBatt) {
        stateBatt = false;
        changed = true;
      }
    }

    // Play sound effect if alternator state has changed
    if (changed) {
      if (stateBatt && (sfxu_tag != 0)) {
        globals->audiomgr->PlaySfx (sfx_source, sfxu_tag);
      } else if (!stateBatt && (sfxd_tag != 0)) {
        globals->audiomgr->PlaySfx (sfx_source, sfxd_tag);
      }
    }
  }

  // Update battery and alternator subsystems
  mesgBatt.id = MSG_SETDATA;
  mesgBatt.dataType = TYPE_INT;
  mesgBatt.intData = stateBatt ? 1 : 0;
  mesgBatt.user.u.datatag = 'stat';
  SendMessage (&mesgBatt);

  mesgAlt.id = MSG_SETDATA;
  mesgAlt.dataType = TYPE_INT;
  mesgAlt.intData = stateAlt ? 1 : 0;
  mesgAlt.user.u.datatag = 'stat';
  SendMessage (&mesgAlt);

  return rc;
}


//
// CBasicMagnetoSwitch
//
// This gauge type implements a basic turn-switch for magnetos.  The switch
//   has five positions:
//   0 = None
//   1 = Right
//   2 = Left
//   3 = Both
//   4 = Start (momentary contact)
//
// Clicking the right mouse button increments the gauge state, and clicking the
//   left button decrements the state.
//
// This gauge is intended to be connected to a rotary ignition subsystem ('rign')
//
CBasicMagnetoSwitch::CBasicMagnetoSwitch (void)
{
}


typedef enum {
  MAGNETO_SWITCH_OFF = 0,
  MAGNETO_SWITCH_RIGHT = 1,
  MAGNETO_SWITCH_LEFT = 2,
  MAGNETO_SWITCH_BOTH = 3,
  MAGNETO_SWITCH_START = 4
} EMagnetoSwitch;

void CBasicMagnetoSwitch::Draw (void)
{
  // Get magneto subsystem state
  mesg.id = MSG_GETDATA;
  if (SendMessage (&mesg) == MSG_PROCESSED) {
    indx = mesg.intData;
  }

  // Draw appropriate bitmap frame
  if (bmap != NULL) {
    DrawBitmap (surf, bmap, 0, 0, indx);
  }
}


EClickResult CBasicMagnetoSwitch::MouseClick (int mouseX, int mouseY, int buttons)
{
  EClickResult rc = MOUSE_TRACKING_OFF;

  if (buttons == MOUSE_BUTTON_LEFT) {
    // Decrement state unless we are already in the OFF state
    if (indx > MAGNETO_SWITCH_OFF) {
      indx--;

      // Play sound effect
      if (sfxd_tag != 0) {
        globals->audiomgr->PlaySfx (sfx_source, sfxd_tag);
      }
    }
  } else if (buttons == MOUSE_BUTTON_RIGHT) {
    // Increment state unless we are already in the START state
    if (indx < MAGNETO_SWITCH_START) {
      indx++;

      // Play sound effect
      if (sfxu_tag != 0) {
        globals->audiomgr->PlaySfx (sfx_source, sfxu_tag);
      }

      // If we are now in START state, set return code so that we are notified
      //  of the click release
      if (indx == MAGNETO_SWITCH_START) {
        rc = MOUSE_TRACKING_ON;
      }
    }
  }

  // Update magneto subsystem
  mesg.id = MSG_SETDATA;
  mesg.dataType = TYPE_INT;
  mesg.intData = indx;
  SendMessage (&mesg);

  return rc;
}

EClickResult CBasicMagnetoSwitch::StopClick (int mouseX, int mouseY, int buttons)
{
  // The only time this method should be called is when the switch is in the
  //   START state and the right mouse button is released.  Switch back
  //   to BOTH state
  indx = MAGNETO_SWITCH_BOTH;

  // Play sound effect
  if (sfxd_tag != 0) {
    globals->audiomgr->PlaySfx (sfx_source, sfxd_tag);
  }

  // Update magneto subsystem
  mesg.id = MSG_SETDATA;
  mesg.dataType = TYPE_INT;
  mesg.intData = indx;
  SendMessage (&mesg);

  return MOUSE_TRACKING_OFF;
}


//
// CTwoStateELTGauge
//

CTwoStateELTGauge::CTwoStateELTGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CSimpleSwitch::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CTwoStateELTGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CSwitchPairGauge
//

CSwitchPairGauge::CSwitchPairGauge (void)
{
  memset (&s1ms, 0, sizeof(SMessage));
  memset (&s2ms, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 's1ms':
    ReadMessage (&s1ms, stream);
    rc = TAG_READ;
    break;

  case 's2ms':
    ReadMessage (&s2ms, stream);
    rc = TAG_READ;
    break;

  case 's1of':
    ReadFrom (&s1of, stream);
    rc = TAG_READ;
    break;

  case 's1on':
    ReadFrom (&s1on, stream);
    rc = TAG_READ;
    break;

  case 's2on':
    ReadFrom (&s2on, stream);
    rc = TAG_READ;
    break;

  case 's2of':
    ReadFrom (&s2of, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CSimpleSwitch::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CSwitchPairGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CSwitchPairGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = s1of.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = s1on.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = s2of.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = s2on.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CSimpleSwitch::MouseMoved (x, y);
  }

  return rc;
}


//
// CSimpleFloatSwitch
//

CSimpleFloatSwitch::CSimpleFloatSwitch (void)
{
  strcpy (bmap_art, "");
  strcpy (csru_csr, "");
  strcpy (csrd_csr, "");
  csru_tag = csrd_tag = 0;
  strcpy (sfxu_wav, "");
  strcpy (sfxd_wav, "");
  sfxu_tag = sfxd_tag = 0;
  stat_n = 0;
  stat = NULL;
  sstr_n = 0;
  sstr = NULL;
  mmnt = false;
}

CSimpleFloatSwitch::~CSimpleFloatSwitch (void)
{
  if (stat != NULL) delete[] stat;
  if (sstr != NULL) {
    for (int i=0; i<sstr_n; i++) {
      delete[] sstr[i];
    }
    delete[] sstr;
  }
}

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

  switch (tag) {
  case 'bmap':
    ReadString (bmap_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'csru':
    ReadString (csru_csr, 64, stream);
    rc = TAG_READ;
    break;

  case 'csrd':
    ReadString (csrd_csr, 64, stream);
    rc = TAG_READ;
    break;

  case 'sfxu':
    ReadString (sfxu_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'sfxd':
    ReadString (sfxd_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'stat':
    {
      ReadInt (&stat_n, stream);
      if (stat_n > 16) {
        gtfo ("CSimpleFloatSwitch : <stat> maximum 16 states exceeded");
      }
      stat = new float[stat_n];
      for (int i=0; i<stat_n; i++) {
        ReadFloat (&stat[i], stream);
      }
    }
    rc = TAG_READ;
    break;

  case 'sstr':
    {
      ReadInt (&sstr_n, stream);
      if (sstr_n > 16) {
        gtfo ("CSimpleFloatSwitchGauge : <sstr> maximum 16 states exceeded");
      }
      sstr = new char*[sstr_n];
      for (int i=0; i<sstr_n; i++) {
        sstr[i] = new char[64];
        ReadString (sstr[i], 64, stream);
      }
    }
    rc = TAG_READ;
    break;

  case 'mmnt':
    {
      int i;
      ReadInt (&i, stream);
      mmnt = (i != 0);
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CSimpleFloatSwitch::Read : Unknown tag %s", s);
  }

  return rc;
}

void CSimpleFloatSwitch::ReadFinished (void)
{
  CGauge::ReadFinished ();

  // Bind cursors
  if (strlen (csru_csr) > 0) {
    csru_tag = globals->cursormgr->BindCursor (csru_csr);
  }
  if (strlen (csrd_csr) > 0) {
    csrd_tag = globals->cursormgr->BindCursor (csrd_csr);
  }

  // Load sound effects
  if (strlen (sfxu_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, sfxu_wav);
    sfxu_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }
}



//
// CDualSwitch
//

CDualSwitch::CDualSwitch (void)
{
  nums = 0;
  orie = 0;
  memset (&usrl, 0, sizeof(SMessage));
  memset (&usrr, 0, sizeof(SMessage));
  mmnt = false;
}

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

  switch (tag) {
  case 'nums':
    ReadInt (&nums, stream);
    rc = TAG_READ;
    break;

  case 'orie':
    ReadInt (&orie, stream);
    rc = TAG_READ;
    break;

  case 'usrl':
    ReadMessage (&usrl, stream);
    rc = TAG_READ;
    break;

  case 'usrr':
    ReadMessage (&usrr, stream);
    rc = TAG_READ;
    break;

  case 'mmnt':
    {
      int i;
      ReadInt (&i, stream);
      mmnt = (i != 0);
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CSimpleSwitch::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDualSwitchGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CPushPullKnobGauge
//

CPushPullKnobGauge::CPushPullKnobGauge (void)
{
  strcpy (bmap_art, "");
  memset (&mesg, 0, sizeof(SMessage));
  memset (&lnk1, 0, sizeof(SMessage));
  ytop = ybtm = 0;
  valu_n = 0;
  valu = NULL;
  lowv = high = 0;
  poll = false;
}

CPushPullKnobGauge::~CPushPullKnobGauge (void)
{
  if (valu != NULL) {
    delete[] valu;
  }
}

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

  switch (tag) {
  case 'bmap':
    ReadString (bmap_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'mesg':
    ReadMessage (&mesg, stream);
    rc = TAG_READ;
    break;

  case 'lnk1':
    ReadMessage (&lnk1, stream);
    rc = TAG_READ;
    break;

  case 'ytop':
    ReadInt (&ytop, stream);
    rc = TAG_READ;
    break;

  case 'ybtm':
    ReadInt (&ybtm, stream);
    rc = TAG_READ;
    break;

  case 'valu':
    {
      ReadInt (&valu_n, stream);
      if (valu_n > 32) {
        gtfo ("CPushPullKnobGauge : <valu> maximum 32 values exceeded");
      }
      valu = new SKnobArea[valu_n];
      for (int i=0; i<valu_n; i++) {
        ReadInt (&valu[i].ytop, stream);
        ReadInt (&valu[i].ybtm, stream);
        ReadFloat (&valu[i].valu, stream);
        ReadString (valu[i].help, 64, stream);
      }
    }
    rc = TAG_READ;
    break;

  case 'lowv':
    ReadFloat (&lowv, stream);
    rc = TAG_READ;
    break;

  case 'high':
    ReadFloat (&high, stream);
    rc = TAG_READ;
    break;

  case 'poll':
    {
      int i;
      ReadInt (&i, stream);
      poll = (i != 0);
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CPushPullKnobGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CPrimerKnobGauge
//

CPrimerKnobGauge::CPrimerKnobGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CPushPullKnobGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CPrimerKnobGauge::Read : Unknown tag %s", s);
  }

  return rc;

}

//
// CFlapsSwitchGauge
//

CFlapsSwitchGauge::CFlapsSwitchGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CPushPullKnobGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlapsSwitchGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CLitLandingGearKnobGauge
//

CLitLandingGearKnobGauge::CLitLandingGearKnobGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CPushPullKnobGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CLitLandingGearKnobGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CMixtureKnobGauge
//

CMixtureKnobGauge::CMixtureKnobGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CPushPullKnobGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CMixtureKnobGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CReversibleThrottleKnobGauge
//

CReversibleThrottleKnobGauge::CReversibleThrottleKnobGauge (void)
{
  memset (&rvsr, 0, sizeof(SMessage));
  strcpy (rbmp_art, "");
  rtop = rbtm = 0;
}

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

  switch (tag) {
  case 'rvsr':
    ReadMessage (&rvsr, stream);
    rc = TAG_READ;
    break;

  case 'rbmp':
    ReadString (rbmp_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'rtop':
    ReadInt (&rtop, stream);
    rc = TAG_READ;
    break;

  case 'rbtm':
    ReadInt (&rbtm, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CPushPullKnobGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CReversibleThrottleKnobGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CDualKnobGauge
//

CDualKnobGauge::CDualKnobGauge (void)
{
  memset (&imsg, 0, sizeof(SMessage));
  memset (&omsg, 0, sizeof(SMessage));
  iinc = idec = oinc = odec = 0;
}

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

  switch (tag) {
  case 'imsg':
    ReadMessage (&imsg, stream);
    rc = TAG_READ;
    break;

  case 'usri':
    {
      // DEPRECATED
      char s[64];
      ReadString (s, 64, stream);
      
      // Convert USER string to SMessage field value
    }
    rc = TAG_READ;
    break;

  case 'igrp':
    {
      // DEPRECATED
      Tag tag;
      ReadTag (&tag, stream);
      imsg.group = tag;
    }
    rc = TAG_READ;
    break;

  case 'omsg':
    ReadMessage (&omsg, stream);
    rc = TAG_READ;
    break;

  case 'usro':
    {
      // DEPRECATED
      char s[64];
      ReadString (s, 64, stream);
      
      // Convert USER string to SMessage field value
    }
    rc = TAG_READ;
    break;

  case 'ogrp':
    {
      // DEPRECATED
      Tag tag;
      ReadTag (&tag, stream);
      omsg.group = tag;
    }
    rc = TAG_READ;
    break;

  case 'iinc':
    ReadFloat (&iinc, stream);
    rc = TAG_READ;
    break;

  case 'idec':
    ReadFloat (&idec, stream);
    rc = TAG_READ;
    break;

  case 'oinc':
    ReadFloat (&oinc, stream);
    rc = TAG_READ;
    break;

  case 'odec':
    ReadFloat (&odec, stream);
    rc = TAG_READ;
    break;

  case 'inca':
    ReadFrom (&inca, stream);
    rc = TAG_READ;
    break;

  case 'ouca':
    ReadFrom (&ouca, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDualKnobGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CDualKnobGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = inca.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = ouca.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CFlyhawkLightKnobGauge
//

CFlyhawkLightKnobGauge::CFlyhawkLightKnobGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CDualKnobGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlyhawkLightKnobGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CTurnKnobGauge
//

CTurnKnobGauge::CTurnKnobGauge (void)
{
  strcpy (bmap_art, "");
  incr = decr = 0;
}

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

  switch (tag) {
  case 'bmap':
    ReadString (bmap_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'incr':
  case 'rght':
    ReadFloat (&incr, stream);
    rc = TAG_READ;
    break;

  case 'decr':
  case 'left':
    ReadFloat (&decr, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CTurnKnobGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CCoveredSwitch
//

CCoveredSwitch::CCoveredSwitch (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CSimpleSwitch::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCoveredSwitch::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CCoveredLightButtonGauge
//

CCoveredLightButtonGauge::CCoveredLightButtonGauge (void)
{
  strcpy (lbmp_art, "");
  memset (&lmsg, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'lbmp':
    ReadString (lbmp_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'lmsg':
    ReadMessage (&lmsg, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CCoveredSwitch::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CCoveredLightButtonGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CVerticalSliderGauge
//

CVerticalSliderGauge::CVerticalSliderGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CVerticalSliderGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CTrimWheelGauge
//

CTrimWheelGauge::CTrimWheelGauge (void)
{
  strcpy (bmap_art, "");
}

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

  switch (tag) {
  case 'bmap':
    ReadString (bmap_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'down':
  case 'left':
    ReadFrom (&down, stream);
    rc = TAG_READ;
    break;

  case 'up  ':
  case 'rght':
    ReadFrom (&up, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CTrimWheelGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

ECursorResult CTrimWheelGauge::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = down.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = up.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CGauge::MouseMoved (x, y);
  }

  return rc;
}


//
// CTrimWheelIndicatorGauge
//

CTrimWheelIndicatorGauge::CTrimWheelIndicatorGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CTrimWheelGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CTrimWheelIndicatorGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CIndicatorGauge
//

CIndicatorGauge::CIndicatorGauge (void)
{
  strcpy (bmap_art, "");
  lval = hval = 0;
}

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

  switch (tag) {
  case 'bmap':
    ReadString (bmap_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'lval':
    ReadFloat (&lval, stream);
    rc = TAG_READ;
    break;

  case 'hval':
    ReadFloat (&hval, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CIndicatorGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CFlapsIndicatorGauge
//

CFlapsIndicatorGauge::CFlapsIndicatorGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CIndicatorGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlapsIndicatorGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CPushButtonGauge
//

CPushButtonGauge::CPushButtonGauge (void)
{
  strcpy (bmap_art, "");
  strcpy (curs_csr, "");
  mmnt = false;
}

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

  switch (tag) {
  case 'bmap':
    ReadString (bmap_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'curs':
    ReadString (curs_csr, 64, stream);
    rc = TAG_READ;
    break;

  case 'mmnt':
    mmnt = true;
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CPushButtonGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CLightButtonGauge
//

CLightButtonGauge::CLightButtonGauge (void)
{
  memset (&lmsg, 0, sizeof(SMessage));
  stat_off = stat_on = 0;
  strcpy (sstr_off, "");
  strcpy (sstr_on, "");
}

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

  switch (tag) {
  case 'lmsg':
    ReadMessage (&lmsg, stream);
    rc = TAG_READ;
    break;

  case 'stat':
    ReadInt (&stat_off, stream);
    ReadInt (&stat_on, stream);
    rc = TAG_READ;
    break;

  case 'sstr':
    ReadString (sstr_off, 64, stream);
    ReadString (sstr_on, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CPushButtonGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CLightButtonGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CTurnSwitchGauge
//

CTurnSwitchGauge::CTurnSwitchGauge (void)
{
}

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

  if (rc == TAG_IGNORED) {
    rc = CSimpleSwitch::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CTurnSwitchGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CMasterCautionWarningButtonGauge
//

CMasterCautionWarningButtonGauge::CMasterCautionWarningButtonGauge (void)
{
  strcpy (bmap_art, "");
  strcpy (sfx_wav, "");
  sfx_tag = 0;
  memset (&smsg, 0, sizeof(SMessage));
  memset (&lmsg, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'bmap':
    ReadString (bmap_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'sfx_':
    ReadString (sfx_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'smsg':
  case 'swch':
    ReadMessage (&smsg, stream);
    rc = TAG_READ;
    break;

  case 'lmsg':
    ReadMessage (&lmsg, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CMasterCautionWarningButtonGauge::Read : Unknown tag %s", s);
  }

  return rc;
}

void CMasterCautionWarningButtonGauge::ReadFinished (void)
{
  CGauge::ReadFinished ();

  // Load sound effects
  if (strlen (sfx_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, sfx_wav);
    sfx_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }
}


//
// CKAFireExtinguisherButton
//

CKAFireExtinguisherButton::CKAFireExtinguisherButton (void)
{
  strcpy (fire.art, "");
  fire.x = fire.y = 0;
  strcpy (ok.art, "");
  ok.x = ok.y = 0;
  strcpy (dsch.art, "");
  dsch.x = dsch.y = 0;
  strcpy (sfx_wav, "");
  sfx_tag = 0;
  strcpy (curs_csr, "");
  curs_tag = 0;
}

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

  switch (tag) {
  case 'd___':
    ReadString (dsch.art, 64, stream);
    ReadInt (&dsch.x, stream);
    ReadInt (&dsch.y, stream);
    rc = TAG_READ;
    break;

  case 'ok__':
    ReadString (ok.art, 64, stream);
    ReadInt (&ok.x, stream);
    ReadInt (&ok.y, stream);
    rc = TAG_READ;
    break;

  case 'fire':
    ReadString (fire.art, 64, stream);
    ReadInt (&fire.x, stream);
    ReadInt (&fire.y, stream);
    rc = TAG_READ;
    break;

  case 'sfx_':
    ReadString (sfx_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'curs':
    ReadString (curs_csr, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CKAFireExtinguisherButton::Read : Unknown tag %s", s);
  }

  return rc;
}

void CKAFireExtinguisherButton::ReadFinished (void)
{
  CGauge::ReadFinished ();

  // Bind cursors
  if (strlen (curs_csr) > 0) {
    curs_tag = globals->cursormgr->BindCursor (curs_csr);
  }

  // Load sound effects
  if (strlen (sfx_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, sfx_wav);
    sfx_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }
}


//
// CWalkerAPPanel
//

CWalkerAPPanel::CWalkerAPPanel (void)
{
  strcpy (enga_yd_art, "");
  strcpy (enga_ap_art, "");
  strcpy (knob_bnk_art, "");
  strcpy (knob_trm_art, "");
}

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

  switch (tag) {
  case 'left':
    ReadFrom (&left, stream);
    rc = TAG_READ;
    break;

  case 'rght':
    ReadFrom (&rght, stream);
    rc = TAG_READ;
    break;

  case 'up__':
    ReadFrom (&up, stream);
    rc = TAG_READ;
    break;

  case 'down':
    ReadFrom (&down, stream);
    rc = TAG_READ;
    break;

  case 'xfer':
    ReadFrom (&xfer, stream);
    rc = TAG_READ;
    break;

  case 'turb':
    ReadFrom (&turb, stream);
    rc = TAG_READ;
    break;

  case 'ydon':
    ReadFrom (&ydon, stream);
    rc = TAG_READ;
    break;

  case 'ydof':
    ReadFrom (&ydof, stream);
    rc = TAG_READ;
    break;

  case 'apon':
    ReadFrom (&apon, stream);
    rc = TAG_READ;
    break;

  case 'apof':
    ReadFrom (&apof, stream);
    rc = TAG_READ;
    break;

  case 'enga':
    ReadString (enga_yd_art, 64, stream);
    ReadString (enga_ap_art, 64, stream);
    rc = TAG_READ;
    break;

  case 'knob':
    ReadString (knob_bnk_art, 64, stream);
    ReadString (knob_trm_art, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CWalkerAPPanel::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CWalkerFirePanel
//

CWalkerFirePanel::CWalkerFirePanel (void)
{
}

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

  switch (tag) {
  case 'fir1':
    ReadMessage (&fir1, stream);
    rc = TAG_READ;
    break;

  case 'fir2':
    ReadMessage (&fir2, stream);
    rc = TAG_READ;
    break;

  case 'ext1':
    ReadFrom (&ext1, stream);
    rc = TAG_READ;
    break;

  case 'ext2':
    ReadFrom (&ext2, stream);
    rc = TAG_READ;
    break;

  case 'bel1':
    ReadFrom (&bel1, stream);
    rc = TAG_READ;
    break;

  case 'bel2':
    ReadFrom (&bel2, stream);
    rc = TAG_READ;
    break;

  case 'ann1':
    ReadFrom (&ann1, stream);
    rc = TAG_READ;
    break;

  case 'ann2':
    ReadFrom (&ann2, stream);
    rc = TAG_READ;
    break;

  case 'ef1_':
    ReadFrom (&ef1, stream);
    rc = TAG_READ;
    break;

  case 'ef2_':
    ReadFrom (&ef2, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CWalkerFirePanel::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CLightSwitchSetGauge
//

CLightSwitchSetGauge::CLightSwitchSetGauge (void)
{
  memset (&lmsg, 0, sizeof(SMessage));
}

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

  switch (tag) {
  case 'lmsg':
    ReadMessage (&lmsg, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CBitmapGauge::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CLightSwitchSetGauge::Read : Unknown tag %s", s);
  }

  return rc;
}


//
// CRockerSwitch
//

CRockerSwitch::CRockerSwitch (void)
{
  memset (&msg1, 0, sizeof(SMessage));
  memset (&msg2, 0, sizeof(SMessage));
  strcpy (sfx1_wav, "");
  strcpy (sfx2_wav, "");
  sfx1_tag = sfx2_tag = 0;
}

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

  switch (tag) {
  case 'one_':
    ReadFrom (&one, stream);
    rc = TAG_READ;
    break;

  case 'two_':
    ReadFrom (&two, stream);
    rc = TAG_READ;
    break;

  case 'msg1':
    ReadMessage (&msg1, stream);
    rc = TAG_READ;
    break;

  case 'msg2':
    ReadMessage (&msg2, stream);
    rc = TAG_READ;
    break;

  case 'sfx1':
    ReadString (sfx1_wav, 64, stream);
    rc = TAG_READ;
    break;

  case 'sfx2':
    ReadString (sfx2_wav, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    rc = CSimpleSwitch::Read (stream, tag);
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CRockerSwitch::Read : Unknown tag %s", s);
  }

  return rc;
}

void CRockerSwitch::ReadFinished (void)
{
  CGauge::ReadFinished ();

  // Load sound effects
  if (strlen (sfx1_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, sfx1_wav);
    sfx1_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }
  if (strlen (sfx2_wav) > 0) {
    char sfxFullname[64];
    strcpy (sfxFullname, "SOUND\\");
    strcat (sfxFullname, sfx2_wav);
    sfx2_tag = globals->audiomgr->CreateSfx (&globals->pfs, sfxFullname);
  }
}

ECursorResult CRockerSwitch::MouseMoved (int x, int y)
{
  ECursorResult rc = CURSOR_NOT_CHANGED;

  // Send updated mouse position to all click areas
  if (rc == CURSOR_NOT_CHANGED) rc = one.MouseMoved (x, y);
  if (rc == CURSOR_NOT_CHANGED) rc = two.MouseMoved (x, y);

  // Call parent method if cursor not changed
  if (rc == CURSOR_NOT_CHANGED) {
    rc = CSimpleSwitch::MouseMoved (x, y);
  }

  return rc;
}

Documentation generated by