Fui.cpp

Go to the documentation of this file.

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

using namespace std;


// Forward declaration of local helper functions
static CFuiComponent *CreateFuiComponent (EFuiComponentTypes type);
// static CFuiComponent *CreateFuiComponent (const char* name);
static bool           ValidFuiComponentType (Tag tag);


static SFont* FuiFont (Tag fontTag)
{
  SFont* rc = NULL;

  switch (fontTag) {
  case 'deff':
    // Default 10-point font
    rc = &globals->fonts.ftasci10;
    break;

  case 'tath':
    // Thin 24-point font
    rc = &globals->fonts.ftthin24;
    break;

  case 'butn':
    // Button uses default 10-point font
    rc = &globals->fonts.ftasci10;
    break;

  case 'micr':
    // Micro 5-point font
    rc = &globals->fonts.ftmicro5;
    break;

  default:
    WARNINGLOG ("Unsupported FUI font 0x%08X", fontTag);
    rc = &globals->fonts.ftasci10;
  }

  return rc;
}


//
// CFuiComponent
//
CFuiComponent::CFuiComponent (int x, int y, int w, int h, Tag window)
{
  this->x = x;
  this->y = y;
  this->w = w;
  this->h = h;
  this->parentWindowId = window;

  type = (EFuiComponentTypes)0;
  id = 0;
  bind = 0;
  strcpy (widgetName, "");
  widgetTag = 0;
  strcpy (text, "");
  xParent = yParent = 0;
  enable = 1;
  show = 1;
  fontTag = 0;
  font = NULL;
  surface = NULL;

  // If width/height values were supplied to the constructor, create the drawing surface
//  if ((w != 0) && (h != 0)) {
//    MakeSurface ();
//  }
}

CFuiComponent::~CFuiComponent (void)
{
  // Temporarily commented out surface deletion since it was causing a crash
  //   (double free of the drawBuffer I think) when a window was closed.
  //   This causes a memory leak and must be fixed soon!
/*
  if (surface != NULL) {
    FreeSurface (surface);
    surface = NULL;
  }  
*/
}

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

  switch (tag) {
  case 'ID  ':
  case 'id  ':
    ReadTag (&id, stream);
    rc = TAG_READ;
    break;
  case 'bind':
    {
      int i;
      ReadInt (&i, stream);
      bind = (EFuiBinding) i;
    }
    rc = TAG_READ;
    break;
  case 'widg':
    ReadString (widgetName, 64, stream);
    ReadTag (&widgetTag, stream);
    rc = TAG_READ;
    break;
  case 'text':
    ReadString (text, 256, stream);
    rc = TAG_READ;
    break;
  case 'loc ':
    ReadInt (&x, stream);
    ReadInt (&y, stream);
    rc = TAG_READ;
    break;
  case 'size':
    ReadInt (&w, stream);
    ReadInt (&h, stream);
    rc = TAG_READ;
    break;
  case 'enab':
    ReadInt (&enable, stream);
    rc = TAG_READ;
    break;
  case 'show':
    ReadInt (&show, stream);
    rc = TAG_READ;
    break;
  case 'font':
    ReadTag (&fontTag, stream);
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[8];
    globals->logWarning->Write ("%s : Unknown tag %s", widgetName, TagString (s, tag));
  }

  return rc;
}

void CFuiComponent::ReadFinished (void)
{
  font = FuiFont (fontTag);
  MakeSurface ();
}

void CFuiComponent::SetParentWindowId (Tag parentWindowId)
{
  this->parentWindowId = parentWindowId;
}


//
// Create drawing surface for the component.  This may be called either from
//   ReadFinished() following the parsing of all tags from a .win file,
//   or in the constructor that takes the component size/location.
//
void CFuiComponent::MakeSurface (void)
{
  surface = CreateSurface (w, h);
  surface->xScreen = xParent + x;
  surface->yScreen = yParent + y;
  EraseSurface (surface);
}

void CFuiComponent::SetText (const char *text)
{
  memset (this->text, 0, 256);
  if (text != NULL) {
    strncpy (this->text, text, 255);
  }
}

void CFuiComponent::SetPosition (int x, int y)
{
  // Validate new position before applying
  if ((x >= 0) && (x < (globals->screenWidth - this->w)) &&
      (y >= 0) && (y < (globals->screenHeight - this->h)))
  {
    this->x = x;
    this->y = y;

    if (surface != NULL) {
      surface->xScreen = xParent + x;
      surface->yScreen = yParent + y;
    }
  }
}

void CFuiComponent::SetParentPosition (int xParent, int yParent)
{
  this->xParent = xParent;
  this->yParent = yParent;

  if (surface != NULL) {
    surface->xScreen = xParent + x;
    surface->yScreen = yParent + y;
  }
}

void CFuiComponent::SetSize (int w, int h)
{
  if ((w != this->w) || (h != this->h)) {
    this->w = w;
    this->h = h;

    // Replace surface if required
    if (surface != NULL) {
      FreeSurface (surface);
      surface = CreateSurface (w, h);
      surface->xScreen = xParent + x;
      surface->yScreen = yParent + y;
    }
  }
}

void CFuiComponent::SetPositionSize (int x, int y, int w, int h)
{
  SetPosition (x, y);
  SetSize (w, h);
}

void CFuiComponent::Draw (void)
{
  // Only draw if surface has been created and the component is visible
  if ((surface != NULL) && show) {
    glDrawBuffer (GL_BACK);
    // Starting raster position is bottom-left corner of the surface,
    //   with (0,0) at top-left of the screen
    glRasterPos2i (surface->xScreen, surface->yScreen + surface->ySize);
    glDrawPixels (surface->xSize, surface->ySize,
      GL_RGBA,
      GL_UNSIGNED_BYTE,
      surface->drawBuffer);
  }
}

bool CFuiComponent::MouseHit (int mx, int my)
{
  // Calculate component starting screen locations
  int cx = xParent + x;
  int cy = yParent + y;
  return (mx >= cx) && (mx < (cx + w)) && (my >= cy) && (my < (cy + h));
}

bool CFuiComponent::MouseMove (int x, int y)
{
  bool rc = false;
  return rc;
}

bool CFuiComponent::MouseClick (int x, int y, EMouseButton button)
{
  bool rc = false;
  return rc;
}

bool CFuiComponent::MouseStopClick (int x, int y, EMouseButton button)
{
  bool rc = false;
  return rc;
}

//
// CFuiWindowTitle
//
CFuiWindowTitle::CFuiWindowTitle (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  widgetTag = 'defa';
  strcpy (widgetName, "WindowTitle");

  bmBack = NULL;
  bmAltBack = NULL;
  bmLeft = NULL;
  bmRight = NULL;
  colText = MakeRGB (255, 255, 255);
  font = FuiFont ('deff');

  back = left = right = NULL;

  Fill ();
}

void CFuiWindowTitle::Fill (void)
{
  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    gtfo ("CFuiWindowTitle : Cannot get theme widget %s", s);
  }

  // Get window backdrop bitmap from the theme.  If no bitmap exists, a blank
  //   canvas component is used as the backdrop.
  bmBack = tw->GetBitmap ("BACK");
  back = new CFuiPicture;
  back->SetBitmap (bmBack);
  back->SetPositionSize (0, 0, w, h);
  childVector.push_back (back);


  // Get optional left frame bitmap
  bmLeft = tw->GetBitmap ("LEFT");
  int bmwLeft = 0, bmhLeft = 0;
  if (bmLeft != NULL) {
    GetBitmapSize (bmLeft, &bmwLeft, &bmhLeft);
    left = new CFuiPicture;
    left->SetBitmap (bmLeft);
    left->SetPositionSize (0, 0, bmwLeft, h);
    childVector.push_back (left);
  }

  // Get optional right frame bitmap
  bmRight = tw->GetBitmap ("RIGHT");
  int bmwRight = 0, bmhRight = 0;
  if (bmRight != NULL) {
    GetBitmapSize (bmRight, &bmwRight, &bmhRight);
    right = new CFuiPicture;
    right->SetBitmap (bmRight);
    right->SetPositionSize (w-bmwRight, 0, bmwRight, h);
    childVector.push_back (right);
  }

  // Get text colour
  colText = tw->GetColour ("TEXT");
}

void CFuiWindowTitle::SetParentPosition (int xParent, int yParent)
{
  CFuiComponent::SetParentPosition (xParent, yParent);

  // Update all children
  vector<CFuiComponent*>::iterator i;
  for (i=childVector.begin(); i!=childVector.end(); i++) {
    (*i)->SetParentPosition(xParent + x, yParent + y);
  }
}

void CFuiWindowTitle::Draw (void)
{
  // Draw each component
  vector<CFuiComponent*>::iterator i;
  for (i=childVector.begin(); i!=childVector.end(); i++) {
    (*i)->Draw();
  }

  // Draw text
  int th = TextHeight (font, text);
  DrawTextC (surface, font, w/2, (h-th)/2, colText, text);
//  int th = TextHeight (&globals->fonts.ftasci10, text);
//  DrawTextC (surface, &globals->fonts.ftasci10, w/2, (h-th)/2, colText, text);

  CFuiComponent::Draw ();
}


//
// CFuiCloseButton
//
CFuiCloseButton::CFuiCloseButton (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_CLOSE_BUTTON;
  widgetTag = 'defa';
  strcpy (widgetName, "WindowCloseButton");

  bmBack = NULL;
  back = NULL;
  state = false;

  Fill ();
}

void CFuiCloseButton::Fill (void)
{
  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    gtfo ("%s : Cannot get theme widget %s", widgetName, s);
  }

  bmBack = tw->GetBitmap ("BACK");
  if (bmBack != NULL) {
    int bmwBack = 0, bmhBack = 0;
    GetBitmapSize (bmBack, &bmwBack, &bmhBack);
    back = new CFuiPicture (0, 0, bmwBack, bmhBack);
    back->SetBitmap (bmBack);
    back->SetFrame (0);
  }
  SetParentPosition (x, y);
}

void CFuiCloseButton::SetParentPosition (int xParent, int yParent)
{
  CFuiComponent::SetParentPosition (xParent, yParent);

  // Update all children
  if (back != NULL) {
    back->SetParentPosition (xParent + x, yParent + y);
  }
}

void CFuiCloseButton::Draw (void)
{
  // Draw the backdrop bitmap
  if (back != NULL) {
    back->Draw ();
  }
}

bool CFuiCloseButton::MouseMove (int x, int y)
{
  bool rc = false;
  if ((state == true) && !MouseHit (x, y)) {
    state = false;
    back->SetFrame (0);
    rc = true;
  }
  return rc;
}

bool CFuiCloseButton::MouseClick (int x, int y, EMouseButton button)
{
  bool rc = false;
  if (MouseHit (x, y)) {
    state = true;
    back->SetFrame (1);
    rc = true;
  }
  return rc;
}

bool CFuiCloseButton::MouseStopClick (int x, int y, EMouseButton button)
{
  bool rc = false;
  if (state == true) {
    state = false;
    back->SetFrame (0);
    rc = true;
  }
  return rc;
}

//
// CFuiMinimizeButton
//
CFuiMinimizeButton::CFuiMinimizeButton (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_MINIMIZE_BUTTON;
  widgetTag = 'defa';
  strcpy (widgetName, "WindowMinimizeButton");

  bmBack = NULL;
  back = NULL;
  state = false;

  Fill ();
}

void CFuiMinimizeButton::Fill (void)
{
  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    gtfo ("%s : Cannot get theme widget %s", widgetName, s);
  }

  bmBack = tw->GetBitmap ("BACK");
  if (bmBack != NULL) {
    int bmwBack = 0, bmhBack = 0;
    GetBitmapSize (bmBack, &bmwBack, &bmhBack);
    back = new CFuiPicture (0, 0, bmwBack, bmhBack);
    back->SetBitmap (bmBack);
  }
  SetParentPosition (x, y);
}

void CFuiMinimizeButton::SetParentPosition (int xParent, int yParent)
{
  CFuiComponent::SetParentPosition (xParent, yParent);

  // Update all children
  if (back != NULL) {
    back->SetParentPosition (xParent + x, yParent + y);
  }
}

void CFuiMinimizeButton::Draw (void)
{
  // Draw the backdrop bitmap
  if (back != NULL) {
    back->Draw ();
  }
}

bool CFuiMinimizeButton::MouseMove (int x, int y)
{
  bool rc = false;
  if ((state == true) && !MouseHit (x, y)) {
    state = false;
    back->SetFrame (0);
    rc = true;
  }
  return rc;
}

bool CFuiMinimizeButton::MouseClick (int x, int y, EMouseButton button)
{
  bool rc = false;
  if (MouseHit (x, y)) {
    state = true;
    back->SetFrame (1);
    rc = true;
  }
  return rc;
}

bool CFuiMinimizeButton::MouseStopClick (int x, int y, EMouseButton button)
{
  bool rc = false;
  if (state == true) {
    state = false;
    back->SetFrame (0);
    rc = true;
  }
  return rc;
}


//
// CFuiZoomButton
//
CFuiZoomButton::CFuiZoomButton (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_ZOOM_BUTTON;
  widgetTag = 'defa';
  strcpy (widgetName, "WindowZoomButton");

  bmBack = NULL;
  back = NULL;
  state = false;

  Fill ();
}

void CFuiZoomButton::Fill (void)
{
  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    gtfo ("%s : Cannot get theme widget %s", widgetName, s);
  }

  bmBack = tw->GetBitmap ("BACK");
  if (bmBack != NULL) {
    int bmwBack = 0, bmhBack = 0;
    GetBitmapSize (bmBack, &bmwBack, &bmhBack);
    back = new CFuiPicture (0, 0, bmwBack, bmhBack);
    back->SetBitmap (bmBack);
  }
  SetParentPosition (x, y);
}

void CFuiZoomButton::SetParentPosition (int xParent, int yParent)
{
  CFuiComponent::SetParentPosition (xParent, yParent);

  // Update all children
  if (back != NULL) {
    back->SetParentPosition (xParent + x, yParent + y);
  }
}

void CFuiZoomButton::Draw (void)
{
  // Draw the backdrop bitmap
  if (back != NULL) {
    back->Draw ();
  }
}

bool CFuiZoomButton::MouseMove (int x, int y)
{
  bool rc = false;
  if ((state == true) && !MouseHit (x, y)) {
    state = false;
    back->SetFrame (0);
    rc = true;
  }
  return rc;
}

bool CFuiZoomButton::MouseClick (int x, int y, EMouseButton button)
{
  bool rc = false;
  if (MouseHit (x, y)) {
    state = true;
    back->SetFrame (1);
    rc = true;
  }
  return rc;
}

bool CFuiZoomButton::MouseStopClick (int x, int y, EMouseButton button)
{
  bool rc = false;
  if (state == true) {
    state = false;
    back->SetFrame (0);
    rc = true;
  }
  return rc;
}


//
// CFuiWindow
//
CFuiWindow::CFuiWindow (const char* winFilename, Tag windowId, FuiEventNoticeCb handler)
: CFuiComponent()
{
  this->state = FUI_WINDOW_INIT;
  this->windowId = windowId;
  type = COMPONENT_WINDOW;
  strcpy (this->winFilename, winFilename);
  this->handler = handler;

  mini = zoom = close = 0;

  surface = NULL;
  bmBack = NULL;
  bmTop = NULL;
  bmBottom = NULL;
  bmLeft = NULL;
  bmRight = NULL;
  bmTopLeft = NULL;
  bmTopRight = NULL;
  bmBottomLeft = NULL;
  bmBottomRight = NULL;

  windowTitle = NULL;
  btnClose = NULL;
  btnMini = NULL;
  btnZoom = NULL;

  // Open stream
  SStream stream;
  strcpy (stream.filename, winFilename);
  strcpy (stream.mode, "r");
  if (OpenStream (&globals->pfs, &stream)) {
    ReadFrom (this, &stream);
    CloseStream (&stream);
  }
}

CFuiWindow::~CFuiWindow (void)
{
  // Free drawing surface
  if (surface != NULL) {
    FreeSurface (surface);
    surface = NULL;
  }

  // Delete decoration components
  list<CFuiComponent*>::iterator i;
  for (i=decorationList.begin(); i!=decorationList.end(); i++) {
    CFuiComponent *c = *i;
    delete c;
  }

  // Delete child components
  for (i=childList.begin(); i!=childList.end(); i++) delete (*i);
}

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

  switch (tag) {
  case 'wsiz':
    ReadInt (&xWsiz, stream);
    ReadInt (&yWsiz, stream);
    rc = TAG_READ;
    break;
  case 'ipos':
    ReadInt (&x1, stream);
    ReadInt (&y1, stream);
    ReadInt (&x2, stream);
    ReadInt (&y2, stream);
    rc = TAG_READ;
    break;
  case 'titl':
    ReadInt (&title, stream);
    rc = TAG_READ;
    break;
  case 'clos':
    ReadInt (&close, stream);
    rc = TAG_READ;
    break;
  case 'mini':
    ReadInt (&mini, stream);
    rc = TAG_READ;
    break;
  case 'zoom':
    ReadInt (&zoom, stream);
    rc = TAG_READ;
    break;
  case 'rsiz':
    ReadInt (&resize, stream);
    rc = TAG_READ;
    break;
  case 'move':
    ReadInt (&move, stream);
    rc = TAG_READ;
    break;
  case 'bord':
    ReadInt (&border, stream);
    rc = TAG_READ;
    break;
  case 'bsiz':
    ReadInt (&borderSize, stream);
    rc = TAG_READ;
    break;
  case 'layr':
    {
      int i;
      ReadInt (&i, stream);
      layer = (EFuiLayer) i;
    }
    rc = TAG_READ;
    break;
  case 'trns':
    ReadInt (&trns, stream);
    rc = TAG_READ;
    break;
  case 'save':
    ReadInt (&save, stream);
    rc = TAG_READ;
    break;
  }

  // Add subcomponent if applicable
  if (rc == TAG_IGNORED) {
    if (ValidFuiComponentType (tag)) {
      CFuiComponent *c = CreateFuiComponent ((EFuiComponentTypes)tag);
      if (c != NULL) {
        ReadFrom (c, stream);
        c->SetParentWindowId (this->windowId);
        c->SetParentPosition (x, y);
        childList.push_back (c);
        rc = TAG_READ;
      } else {
        char s[8];
        globals->logWarning->Write ("CFuiWindow : Skipping unsupported widget %s",
          TagString (s, tag));
        SkipObject (stream);
      }
      rc = TAG_READ;
    }
  }

  // Send tag to parent class for processing.
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiWindow::ReadFinished (void)
{
  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    gtfo ("CFuiWindow : Invalid theme identifier %s in window file %s", s, winFilename);
  }

  // Set overall window location and size
  w = xWsiz;
  h = yWsiz;

  // Locals for bitmap width/height
  int bmw, bmh;

  // Get window backdrop bitmap from the theme.  If no bitmap exists, a blank
  //   canvas component is used as the backdrop.
  bmBack = tw->GetBitmap ("BACK");
  if (bmBack != NULL) {
    CFuiPicture *back = new CFuiPicture (0, 0, w, h);
    back->SetBitmap (bmBack);
    back->SetParentPosition (x, y);
    decorationList.push_back (back);
  }

  // Get optional top frame bitmap
  bmTop = tw->GetBitmap ("TOP");
  if (bmTop != NULL) {
    GetBitmapSize (bmTop, &bmw, &bmh);
    CFuiPicture *top = new CFuiPicture (0, 0, w, bmh);
    top->SetBitmap (bmTop);
    top->SetParentPosition (x, y);
    decorationList.push_back (top);
  }

  // Get optional bottom frame bitmap
  bmBottom = tw->GetBitmap ("BOTTOM");
  if (bmBottom != NULL) {
    GetBitmapSize (bmBottom, &bmw, &bmh);
    CFuiPicture *bottom = new CFuiPicture (0, h-bmh, w, bmh);
    bottom->SetBitmap (bmBottom);
    bottom->SetParentPosition (x, y);
    decorationList.push_back (bottom);
  }

  // Get optional left frame bitmap
  bmLeft = tw->GetBitmap ("LEFT");
  if (bmLeft != NULL) {
    GetBitmapSize (bmLeft, &bmw, &bmh);
    CFuiPicture *left = new CFuiPicture (0, 0, bmw, h);
    left->SetBitmap (bmLeft);
    left->SetParentPosition (x, y);
    decorationList.push_back (left);
  }

  // Get optional right frame bitmap
  bmRight = tw->GetBitmap ("RIGHT");
  if (bmRight != NULL) {
    GetBitmapSize (bmRight, &bmw, &bmh);
    CFuiPicture *right = new CFuiPicture (w-bmw, 0, bmw, h);
    right->SetBitmap (bmRight);
    right->SetParentPosition (x, y);
    decorationList.push_back (right);
  }

  // Get optional top-left corner bitmap
  bmTopLeft = tw->GetBitmap ("TOPLEFT");
  if (bmTopLeft != NULL) {
    GetBitmapSize (bmTopLeft, &bmw, &bmh);
    CFuiPicture *topleft = new CFuiPicture (0, 0, bmw, bmh);
    topleft->SetBitmap (bmTopLeft);
    topleft->SetParentPosition (x, y);
    decorationList.push_back (topleft);
  }

  // Get optional top-right corner bitmap
  bmTopRight = tw->GetBitmap ("TOPRIGHT");
  if (bmTopRight != NULL) {
    GetBitmapSize (bmTopRight, &bmw, &bmh);
    CFuiPicture *topright = new CFuiPicture (w-bmw, 0, bmw, bmh);
    topright->SetBitmap (bmTopRight);
    topright->SetParentPosition (x, y);
    decorationList.push_back (topright);
  }

  // Get optional bottom-left corner bitmap
  bmBottomLeft = tw->GetBitmap ("BOTLEFT");
  if (bmBottomLeft != NULL) {
    GetBitmapSize (bmBottomLeft, &bmw, &bmh);
    CFuiPicture *botleft = new CFuiPicture (0, h-bmh, bmw, bmh);
    botleft->SetBitmap (bmBottomLeft);
    botleft->SetParentPosition (x, y);
    decorationList.push_back (botleft);
  }

  // Get optional bottom-right corner bitmap
  bmBottomRight = tw->GetBitmap ("BOTRIGHT");
  if (bmBottomRight != NULL) {
    GetBitmapSize (bmBottomRight, &bmw, &bmh);
    CFuiPicture *botright = new CFuiPicture (w-bmw, h-bmh, bmw, bmh);
    botright->SetBitmap (bmBottomRight);
    botright->SetParentPosition (x, y);
    decorationList.push_back (botright);
  }

  if (title) {
    // Create title bar
    // @todo Use theme to determine window title type
    // @todo Get height of backdrop bitmap instead of hard-coded height
    windowTitle = new CFuiWindowTitle (0, -20, w, 20);
    windowTitle->SetText (text);
    windowTitle->SetParentPosition (x, y);
    decorationList.push_back (windowTitle);
  }

  // Maintain running count of right-hand edge to align title bar buttons
  int wMax = w - 20;

  // Add optional window decoration components
  if (close) {
    btnClose = new CFuiCloseButton (wMax, -16, 20, 20);
    btnClose->SetParentPosition (x, y);
    decorationList.push_back (btnClose);
    wMax -= 20;
  }
  if (zoom) {
    btnZoom = new CFuiZoomButton (wMax, -16, 20, 20);
    btnZoom->SetParentPosition (x, y);
    decorationList.push_back (btnZoom);
    wMax -= 20;
  }
  if (mini) {
    btnMini = new CFuiMinimizeButton (wMax, -16, 20, 20);
    btnMini->SetParentPosition (x, y);
    decorationList.push_back (btnMini);
  }

  // Set window state to open
  state = FUI_WINDOW_OPEN;
}

EFuiWindowState CFuiWindow::GetState (void)
{
  return state;
}

void CFuiWindow::Close (void)
{
  state = FUI_WINDOW_CLOSED;
}

void CFuiWindow::Draw (SSurface *surface)
{
  // Draw window decoration components
  list<CFuiComponent*>::iterator i;
  for (i=decorationList.begin(); i!=decorationList.end(); i++) {
    (*i)->Draw();
  }

  // Draw child components
  for (i=childList.begin(); i!=childList.end(); i++) {
    (*i)->Draw();
  }
}

void CFuiWindow::Draw (void)
{
  Draw (surface);
}

//
// Set the position of the window relative to the top-left corner of the screen
//
void CFuiWindow::SetPosition (int sx, int sy)
{
  CFuiComponent::SetPosition (sx, sy);

  // Update parent position of window decorations
  list<CFuiComponent*>::iterator i;
  for (i=decorationList.begin(); i!=decorationList.end(); i++) {
    (*i)->SetParentPosition (x, y);
  }

  // Update parent position of child widgets
  for (i=childList.begin(); i!=childList.end(); i++) {
    (*i)->SetParentPosition(x, y);
  }
}

bool CFuiWindow::MouseMove (int mx, int my)
{
  bool rc = false;

  if (state == FUI_WINDOW_MOVE) {
    int dx = mx - lastX;
    int dy = my - lastY;

    int nx = x + dx;
    int ny = y + dy;

    SetPosition (nx, ny);

    lastX = mx;
    lastY = my;

    rc = true;
  }

  // If mouse click has not been handled yet, send to child widgets
  list<CFuiComponent*>::iterator i;
  for (i=childList.begin(); i!=childList.end() && !rc; i++) {
    rc = (*i)->MouseMove (mx, my);
  }

  return rc;
}

bool CFuiWindow::MouseClick (int mx, int my, EMouseButton button)
{
  bool rc = false;

  // Check for hits on standard window decorations
  if (!rc && btnClose) {
    rc = btnClose->MouseClick (mx, my, button);
  }
  if (!rc && btnZoom) {
    rc = btnZoom->MouseClick (mx, my, button);
  }
  if (!rc && btnMini) {
    rc = btnMini->MouseClick (mx, my, button);
  }

  if (!rc && (windowTitle && windowTitle->MouseHit (mx, my))) {
    // Clicked on window title frame
    if (button == MOUSE_BUTTON_LEFT) {
      state = FUI_WINDOW_MOVE;
      lastX = mx;
      lastY = my;
      rc = true;
    }
  }

  // If mouse click has not been handled yet, send to child widgets
  list<CFuiComponent*>::iterator i;
  for (i=childList.begin(); i!=childList.end() && !rc; i++) {
    rc = (*i)->MouseClick (mx, my, button);
  }

  return rc;
}

bool CFuiWindow::MouseStopClick (int mx, int my, EMouseButton button)
{
  bool rc = false;

  if ((state == FUI_WINDOW_MOVE) && (button == MOUSE_BUTTON_LEFT)) {
    state = FUI_WINDOW_OPEN;
    rc = true;
  }

  if (!rc && btnClose) {
    rc = btnClose->MouseStopClick (mx, my, button);
    if (rc) {
      Close ();
    }
  }
  if (!rc && btnZoom) {
    rc = btnZoom->MouseStopClick (mx, my, button);
  }
  if (!rc && btnMini) {
    rc = btnMini->MouseStopClick (mx, my, button);
  }

  // If mouse click has not been handled yet, send to child widgets
  list<CFuiComponent*>::iterator i;
  for (i=childList.begin(); i!=childList.end() && !rc; i++) {
    rc = (*i)->MouseStopClick (mx, my, button);
  }

  return rc;
}

void CFuiWindow::SetTitle (const char* title)
{
  if (windowTitle != NULL) {
    windowTitle->SetText (title);
  }
}

CFuiComponent *CFuiWindow::GetComponent (Tag component)
{
  CFuiComponent *rc = NULL;

  list<CFuiComponent*>::iterator i;
  for (i=childList.begin(); i!=childList.end(); i++) {
    if ((*i)->GetId() == component) {
      rc = (*i);
    }
  }

  return rc;
}

void CFuiWindow::GenerateEventNotice (Tag componentId,
                                      EFuiEvents event,
                                      EFuiEvents subevent)
{
  if (handler != NULL) {
    handler (windowId, componentId, event, subevent);
  }
}


//
// CFuiButton
//
CFuiButton::CFuiButton (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_BUTTON;
  widgetTag = 'defa';
  strcpy (widgetName, "Button");

  bmLeft = NULL;
  bmBack = NULL;
  bmRight = NULL;

  left = NULL;
  back = NULL;
  right = NULL;

  ok = 0;
  canc = 0;
  rrpt = 0;
  rate = 0.0f;
  strcpy (psiz, "");
  xLsiz = yLsiz = 0;
  xBsiz = yBsiz = 0;
}

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

  switch (tag) {
  case 'ok  ':
    ReadInt (&ok, stream);
    if (ok != 0) id = 'okok';
    rc = TAG_READ;
    break;
  case 'canc':
    ReadInt (&canc, stream);
    if (canc != 0) id = 'canc';
    rc = TAG_READ;
    break;
  case 'rrpt':
    ReadInt (&rrpt, stream);
    rc = TAG_READ;
    break;
  case 'rate':
    ReadFloat (&rate, stream);
    rc = TAG_READ;
    break;
  case 'psiz':
    ReadString (psiz, 64, stream);
    rc = TAG_READ;
  case 'lsiz':
    ReadInt (&xLsiz, stream);
    ReadInt (&yLsiz, stream);
    rc = TAG_READ;
    break;
  case 'bsiz':
    ReadInt (&xBsiz, stream);
    ReadInt (&yBsiz, stream);
    rc = TAG_READ;
    break;
  }

  // Send tag to parent class for processing
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiButton::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    gtfo ("Cannot get theme widget %s", s);
  }

  int bmwLeft = 0, bmhLeft = 0;
  int bmwBack = 0, bmhBack = 0;
  int bmwRight = 0, bmhRight = 0;

  // Left button edge bitmap
  bmLeft = tw->GetBitmap ("LEFT");
  if (bmLeft != NULL) {
    GetBitmapSize (bmLeft, &bmwLeft, &bmhLeft);
    left = new CFuiPicture (0, 0, bmwLeft, bmhLeft);
    left->SetBitmap (bmLeft);
  }

  // Right button edge bitmap
  bmRight = tw->GetBitmap ("RIGHT");
  if (bmRight != NULL) {
    GetBitmapSize (bmRight, &bmwRight, &bmhRight);
    right = new CFuiPicture (xBsiz - bmwRight - 1, 0, bmwRight, bmhRight);
    right->SetBitmap (bmRight);
  }

  // Back button bitmap is tiled across actual button size
  int wBack = xBsiz - bmwLeft - bmwRight;
  int hBack = yBsiz;
  bmBack = tw->GetBitmap ("BACK");
  if (bmBack != NULL) {
    GetBitmapSize (bmBack, &bmwBack, &bmhBack);
    back = new CFuiPicture (bmwLeft, 0, wBack, hBack);
    back->SetBitmap (bmBack);
  }

  // Get theme components
  colText = tw->GetColour ("TEXT");

  SetParentPosition (x, y);

  state = false;
}

void CFuiButton::SetParentPosition (int xParent, int yParent)
{
  CFuiComponent::SetParentPosition (xParent, yParent);

  // Update all children
  if (left != NULL) {
    left->SetParentPosition (xParent + x, yParent + y);
  }
  if (back != NULL) {
    back->SetParentPosition (xParent + x, yParent + y);
  }
  if (left != NULL) {
    right->SetParentPosition (xParent + x, yParent + y);
  }
}

void CFuiButton::Draw (void)
{
  // Draw button components
  if (left != NULL) left->Draw ();
  if (back != NULL) back->Draw ();
  if (right != NULL) right->Draw ();

  // Draw label
  int th = TextHeight (font, text);
  if (surface != NULL) {
    DrawTextC (surface, font, xBsiz/2, (yBsiz-th)/2, colText, text);
  }

  CFuiComponent::Draw ();
}

bool CFuiButton::MouseMove (int x, int y)
{
  bool rc = false;
  
  // If button is currently pressed and mouse is moved outside of button
  //   hit area, then set state to unpressed but don't send BUTTONPRESS event
  if ((state == true) && !MouseHit (x, y)) {
    state = false;
    if (left) left->SetFrame (0);
    if (back) back->SetFrame (0);
    if (right) right->SetFrame (0);
  }
  return rc;
}

bool CFuiButton::MouseClick (int x, int y, EMouseButton button)
{
  bool rc = false;

  // If mouse clicked inside button area, set state to pressed.  The BUTTONPRESS
  //   event is only sent when the button is clicked and released
  if (MouseHit (x, y)) {
    state = true;
    if (left) left->SetFrame (1);
    if (back) back->SetFrame (1);
    if (right) right->SetFrame (1);
    rc = true;
  }

  return rc;
}

bool CFuiButton::MouseStopClick (int x, int y, EMouseButton button)
{
  bool rc = false;

  // If mouse is released inside button area and it was in the pressed state,
  //   then set it to unpressed and send the BUTTONPRESS event
  if (state == true) {
    state = false;
    globals->fuimgr->GenerateEventNotice (parentWindowId, id,
                                          EVENT_BUTTONPRESSED, EVENT_NOSUBEVENT);
    if (left) left->SetFrame (0);
    if (back) back->SetFrame (0);
    if (right) right->SetFrame (0);
    rc = true;
  }

  return rc;
}


//
// CFuiPopupMenu
//
CFuiPopupMenu::CFuiPopupMenu (int x, int y, int w, int h, Tag window)
: CFuiButton (x, y, w, h, window)
{
  type = COMPONENT_POPUPMENU;

  just1 = just2 = just3 = 0;

  bmBack = NULL;
  bmLeft = NULL;
  bmRight = NULL;

  colText = MakeRGB (255, 255, 255);
  colSelection = MakeRGB (0, 0, 0);

  popupActive = false;
  selection = 0;
  xText  = yText = 0;
}

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

  switch (tag) {
  case 'just':
    {
      int i;
      ReadInt (&i, stream);
      just1 = (EFuiJustify) i;
      ReadInt (&i, stream);
      just2 = (EFuiJustify) i;
      ReadInt (&i, stream);
      just3 = (EFuiJustify) i;
    }
    rc = TAG_READ;
    break;
  }

  // Send tag to parent class for processing
  if (rc == TAG_IGNORED) {
    rc = CFuiButton::Read (stream, tag);
  }

  return rc;
}

void CFuiPopupMenu::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    globals->logWarning->Write ("CFuiPopupMenu : Cannot get theme widget %s", s);
  } else {
    // Locals for bitmap width/height
    int bmw = 0;
    int bmh = 0;

    // Width of left and right bitmaps determines size of center (back) bitmap
    int wLeft = 0;
    int wRight = 0;

    // Get optional left frame bitmap
    bmLeft = tw->GetBitmap ("LEFT");
    if (bmLeft != NULL) {
      GetBitmapSize (bmLeft, &bmw, &bmh);
      xText = bmw;
      wLeft = bmw;
      CFuiPicture *left = new CFuiPicture (0, 0, bmw, bmh);
      left->SetBitmap (bmLeft);
      left->SetParentPosition (x, y);
      decorationList.push_back (left);
    }

    // Get optional right frame bitmap
    bmRight = tw->GetBitmap ("RIGHT");
    if (bmRight != NULL) {
      GetBitmapSize (bmRight, &bmw, &bmh);
      wRight = bmw;
      CFuiPicture *right = new CFuiPicture (w-wRight, 0, bmw, bmh);
      right->SetBitmap (bmRight);
      right->SetParentPosition (x, y);
      decorationList.push_back (right);
    }

    // Get optional backdrop frame bitmap
    bmBack = tw->GetBitmap ("BACK");
    if (bmBack != NULL) {
      GetBitmapSize (bmBack, &bmw, &bmh);
      CFuiPicture *back = new CFuiPicture (wLeft, 0, w-wLeft-wRight, bmh);
      back->SetBitmap (bmBack);
      back->SetParentPosition (x, y);
      decorationList.push_back (back);
    }

    // Get text colour
    colText = tw->GetColour ("TEXT");
    colSelection = tw->GetColour ("SELECTION");
  }
}

void CFuiPopupMenu::SetParentPosition (int xParent, int yParent)
{
  CFuiComponent::SetParentPosition (xParent, yParent);

  // Update all decorations
  list<CFuiComponent*>::iterator i;
  for (i=decorationList.begin(); i!=decorationList.end(); i++) {
    (*i)->SetParentPosition (xParent + x, yParent + y);
  }
}

void CFuiPopupMenu::Draw (void)
{
  if (surface != NULL) {
    // Draw decoration components
    list<CFuiComponent*>::iterator i;
    for (i=decorationList.begin(); i!=decorationList.end(); i++) {
      CFuiComponent *component = *i;
      if (component->IsType (COMPONENT_PICTURE)) {
        CFuiPicture *picture = (CFuiPicture *)component;
        picture->Draw ();
      }
    }

    // If active, draw all choices on popup surface
    if (popupActive) {
    } else {
      // Popup is not active; just display current selection
      char s[256];
      GetItemSelection (s);
      DrawText (surface, font, xText, yText, colText, s);
    }
  }

  CFuiComponent::Draw ();
}

void CFuiPopupMenu::ClearItems (void)
{
  items.clear();
}

void CFuiPopupMenu::AddItem (Tag item, const char *label)
{
  items[item] = label;
}

void CFuiPopupMenu::AddSeparator (void)
{
  // @todo Implement popup menu separator, may require item storage in multimap
}

void CFuiPopupMenu::RemoveItem (Tag item)
{
  items.erase(item);
}

void CFuiPopupMenu::SelectItem (Tag item)
{
  selection = item;
}

Tag CFuiPopupMenu::GetItemSelection (char *outText)
{
  Tag rc = 0;
  strcpy (outText, "");

  map<Tag, string>::iterator i = items.find(selection);
  if (i != items.end()) {
    rc = selection;
    strcpy (outText, i->second.c_str());
  }

  return rc;
}


//
// CFuiCheckbox
//
CFuiCheckbox::CFuiCheckbox (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_CHECKBOX;
  widgetTag = 'defa';
  strcpy (widgetName, "CheckBox");

  bmBack = NULL;
  state = 0;
  pressed = false;
}

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

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

  // Send tag to parent class for processing
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiCheckbox::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    gtfo ("Cannot get theme widget %s", s);
  }

  // Get backdrop bitmap, this is a 2-frame bitmap for the on/off radio button state
  bmBack = tw->GetBitmap ("BACK");
}

void CFuiCheckbox::Draw (void)
{
  // Draw checkbox
  if (surface) {
    int dx = 0;
    int dy = 0;

    // Draw bitmap
    if (bmBack) {
      int frame = state;
      if (pressed) frame += 3;
      DrawBitmap (surface, bmBack, 0, 0, frame);
      GetBitmapSize (bmBack, &dx, &dy);
    }

    // Draw label
    unsigned int black = MakeRGB (0, 0, 0);
    int m = TextWidth (font, "m");
    DrawText (surface, font, dx+m, 0, black, text);
  }

  CFuiComponent::Draw ();
}

int CFuiCheckbox::GetState (void)
{
  return state;
}

void CFuiCheckbox::SetState (int state)
{
  this->state = state;
}

bool CFuiCheckbox::MouseClick (int x, int y, EMouseButton button)
{
  bool rc = false;
  if (MouseHit (x, y)) {
    pressed = true;
    rc = true;
  }
  return rc;
}

bool CFuiCheckbox::MouseStopClick (int x, int y, EMouseButton button)
{
  bool rc = false;

  // Only set the checkbox state if the widget was in the pressed state
  if (MouseHit (x, y) && pressed) {
    // Toggle state
    if (state == 0) {
      // Check
      SetState (1);
      globals->fuimgr->GenerateEventNotice (parentWindowId, id,
                                            EVENT_CHECKED, EVENT_NOSUBEVENT);
    } else {
      // Uncheck
      SetState (0);
      globals->fuimgr->GenerateEventNotice (parentWindowId, id,
                                            EVENT_UNCHECKED, EVENT_NOSUBEVENT);
    }
    pressed = false;
    rc = true;
  }

  return rc;
}


//
// CFuiRadioButton
//
CFuiRadioButton::CFuiRadioButton (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_RADIOBUTTON;
  widgetTag = 'defa';
  strcpy (widgetName, "RadioButton");

  bmBack = NULL;
  state = 0;
  pressed = false;
}

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

  switch (tag) {
  case 'stat':
    ReadInt (&state, stream);
    SetState (state);
    rc = TAG_READ;
    break;
  }

  // Send tag to parent class for processing
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiRadioButton::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    gtfo ("Cannot get theme widget %s", s);
  }

  // Get backdrop bitmap, this is a 2-frame bitmap for the on/off radio button state
  bmBack = tw->GetBitmap ("BACK");
}

void CFuiRadioButton::Draw (void)
{
  // Draw radio button
  if (surface) {
    int dx = 0;
    int dy = 0;

    // Draw bitmap
    // Radio button bitmaps are 9-frame PBGs with the following frame layout:
    //   0 - Unchecked normal
    //   1 - Checked normal
    //   2 - N/A normal
    //   3 - Unchecked depressed
    //   4 - Checked depressed
    //   5 - N/A depressed
    //   6 - Unchecked grayed-out
    //   7 - Checked grayed-out
    //   8 - N/A grayed-out

    if (bmBack) {
      int frame = 0;
      // @todo Check for grayed out
      frame = state;
      if (pressed) frame += 3;
      DrawBitmap (surface, bmBack, 0, 0, frame);
      GetBitmapSize (bmBack, &dx, &dy);
    }

    // Draw label separated by m-width from bitmap
    unsigned int black = MakeRGB (0, 0, 0);
    int m = TextWidth (font, "m");
    DrawText (surface, font, dx+m, 0, black, text);
  }

  CFuiComponent::Draw ();
}

int CFuiRadioButton::GetState (void)
{
  return state;
}

void CFuiRadioButton::SetState (int state)
{
  this->state = state;
}

//
// Clicking does not change the state; the owner application must 
//   change state in response to EVENT_CHECKED
//
bool CFuiRadioButton::MouseClick (int x, int y, EMouseButton button)
{
  bool rc = false;
  if (MouseHit (x, y)) {
    pressed = true;
    rc = true;
  }
  return rc;
}

bool CFuiRadioButton::MouseStopClick (int x, int y, EMouseButton button)
{
  bool rc = false;

  // Always reset pressed flag, it will only be set if mouse was clicked inside
  //   the radio button
  pressed = false;

  // If mouse clicked inside button area, send EVENT_CHECKED.  The state
  //   of linked radio buttons must be set by the controlling application.
  //   event is only sent when the button is clicked and released
  if (MouseHit (x, y)) {
    SetState (1);
    globals->fuimgr->GenerateEventNotice (parentWindowId, id,
                                          EVENT_CHECKED, EVENT_NOSUBEVENT);
    rc = true;
  }

  return rc;
}



//
// CFuiLabel
//
CFuiLabel::CFuiLabel (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_LABEL;
  widgetTag = 'defa';
  strcpy (widgetName, "Label");

  just = wrap = 0;

  colText = MakeRGB (255, 255, 255);
  colShadow = MakeRGB (0, 0, 0);
  useShadow = false;
}

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

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

  // Send tag to parent class for processing
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiLabel::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    globals->logWarning->Write ("CFuiLabel : Cannot get theme widget %s", s);
  }

  // Get theme components
  colText = tw->GetColour ("TEXT");
  colShadow = tw->GetColour ("SHADOW");
  useShadow = tw->GetFlag ("USESHADOW");
}

void CFuiLabel::Draw (void)
{
  if (surface != NULL) {
    EraseSurface (surface);

    // Calculate y-offset
    int y = 0;
    if (just & JUSTIFY_V_TOP) {
      y = 0;
    } else if (just & JUSTIFY_V_CENTER) {
      y = (surface->ySize - MaxCharHeight(font)) / 2;
    } else if (just & JUSTIFY_V_BOTTOM) {
      y = surface->ySize - MaxCharHeight(font);
    }

    // Draw justified text
    if (just & JUSTIFY_H_LEFT) {
      DrawText (surface, font, 0, y, colText, text);
    } else if (just & JUSTIFY_H_CENTER) {
      DrawTextC (surface, font, w/2, y, colText, text);
    } else if (just & JUSTIFY_H_RIGHT) {
      int tw = TextWidth (font, text);
      DrawTextR (surface, font, w-tw, y, colText, text);
    } else {
      globals->logWarning->Write ("CFuiLabel : No horizontal justification (%d)", just);
    }
  }

  CFuiComponent::Draw ();
}

void CFuiLabel::SetColour (unsigned int colour)
{
  colText = colour;
}

//
// CFuiTextField
//
CFuiTextField::CFuiTextField (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_TEXTFIELD;
  widgetTag = 'defa';
  strcpy (widgetName, "TextField");

  bmBack = NULL;
  bmTop = NULL;
  bmBottom = NULL;
  bmLeft = NULL;
  bmRight = NULL;
  bmTopLeft = NULL;
  bmTopRight = NULL;
  bmBottomLeft = NULL;
  bmBottomRight = NULL;

  colText = MakeRGB (0, 0, 0);
  colHighlight = MakeRGB (128, 0, 128);
  colTextHighlight = MakeRGB (255, 255, 255);
  colLine = MakeRGB (0, 0, 0);
  colFill = MakeRGB (0, 0, 0);
  colFillDisabled = MakeRGB (128, 0, 128);
  colCaret = MakeRGB (0, 0, 0);

  pass = false;
  nChars = 0;
  data = NULL;
  numb = 0;
  ignore_background = false;
}

CFuiTextField::~CFuiTextField (void)
{
  if (data != NULL) delete[] data;
}
  
int CFuiTextField::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

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

  case 'chrs':
    ReadInt (&nChars, stream);
    SetMaxChars (nChars);
    rc = TAG_READ;
    break;

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

  // Send tag to parent class for processing.
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiTextField::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    globals->logWarning->Write ("CFuiLabel : Cannot get theme widget %s", s);
  } else {
    // Locals for bitmap width/height
    int bmw = 0;
    int bmh = 0;

    // Get optional top-left corner bitmap
    bmTopLeft = tw->GetBitmap ("TOPLEFT");
    if (bmTopLeft != NULL) {
      GetBitmapSize (bmTopLeft, &bmw, &bmh);
      CFuiPicture *topleft = new CFuiPicture (0, 0, bmw, bmh);
      topleft->SetBitmap (bmTopLeft);
      topleft->SetParentPosition (x, y);
      decorationList.push_back (topleft);
    }

    // Get optional top frame bitmap
    bmTop = tw->GetBitmap ("TOP");
    if (bmTop != NULL) {
      GetBitmapSize (bmTop, &bmw, &bmh);
      CFuiPicture *top = new CFuiPicture (0, 0, w, bmh);
      top->SetBitmap (bmTop);
      top->SetParentPosition (x, y);
      decorationList.push_back (top);
    }

    // Get optional bottom frame bitmap
    bmBottom = tw->GetBitmap ("BOTTOM");
    if (bmBottom != NULL) {
      GetBitmapSize (bmBottom, &bmw, &bmh);
      CFuiPicture *bottom = new CFuiPicture (0, h-bmh, w, bmh);
      bottom->SetBitmap (bmBottom);
      bottom->SetParentPosition (x, y);
      decorationList.push_back (bottom);
    }

    // Get optional left frame bitmap
    bmLeft = tw->GetBitmap ("LEFT");
    if (bmLeft != NULL) {
      GetBitmapSize (bmLeft, &bmw, &bmh);
      CFuiPicture *left = new CFuiPicture (0, 0, bmw, h);
      left->SetBitmap (bmLeft);
      left->SetParentPosition (x, y);
      decorationList.push_back (left);
    }

    // Get optional right frame bitmap
    bmRight = tw->GetBitmap ("RIGHT");
    if (bmRight != NULL) {
      GetBitmapSize (bmRight, &bmw, &bmh);
      CFuiPicture *right = new CFuiPicture (w-bmw, 0, bmw, h);
      right->SetBitmap (bmRight);
      right->SetParentPosition (x, y);
      decorationList.push_back (right);
    }

    // Get optional top-right corner bitmap
    bmTopRight = tw->GetBitmap ("TOPRIGHT");
    if (bmTopRight != NULL) {
      GetBitmapSize (bmTopRight, &bmw, &bmh);
      CFuiPicture *topright = new CFuiPicture (w-bmw, 0, bmw, bmh);
      topright->SetBitmap (bmTopRight);
      topright->SetParentPosition (x, y);
      decorationList.push_back (topright);
    }

    // Get optional bottom-left corner bitmap
    bmBottomLeft = tw->GetBitmap ("BOTLEFT");
    if (bmBottomLeft != NULL) {
      GetBitmapSize (bmBottomLeft, &bmw, &bmh);
      CFuiPicture *botleft = new CFuiPicture (0, h-bmh, bmw, bmh);
      botleft->SetBitmap (bmBottomLeft);
      botleft->SetParentPosition (x, y);
      decorationList.push_back (botleft);
    }

    // Get optional bottom-right corner bitmap
    bmBottomRight = tw->GetBitmap ("BOTRIGHT");
    if (bmBottomRight != NULL) {
      GetBitmapSize (bmBottomRight, &bmw, &bmh);
      CFuiPicture *botright = new CFuiPicture (w-bmw, h-bmh, bmw, bmh);
      botright->SetBitmap (bmBottomRight);
      botright->SetParentPosition (x, y);
      decorationList.push_back (botright);
    }

    // Get window backdrop bitmap from the theme.  This is not added to the decoration
    //   list since the ignore_backdrop flag will determine if it is drawn or not.
    bmBack = tw->GetBitmap ("BACK");

    // Get text colours
    colText = tw->GetColour ("TEXT");
    colHighlight = tw->GetColour ("HILITE");
    colTextHighlight = tw->GetColour ("TEXTHILITE");
    colLine = tw->GetColour ("LINE");
    colFill = tw->GetColour ("FILL");
    colFillDisabled = tw->GetColour ("FILLDISABLED");
    colCaret = tw->GetColour ("CARET");
    ignore_background = tw->GetFlag ("IGNORE_BITMAP_BACKGROUND");
  }
}

void CFuiTextField::SetParentPosition (int xParent, int yParent)
{
  CFuiComponent::SetParentPosition (xParent, yParent);

  // Update all decorations
  list<CFuiComponent*>::iterator i;
  for (i=decorationList.begin(); i!=decorationList.end(); i++) {
    (*i)->SetParentPosition (xParent + x, yParent + y);
  }
}

void CFuiTextField::Draw (void)
{
  if (surface != NULL) {
    // Fill surface with fill colour
    // @todo Check for enable/disable state
    EraseSurfaceRGB (surface, colFill);

    // Draw background bitmap if not transparent
    if ((bmBack != NULL) && !ignore_background) {
      DrawBitmap (surface, bmBack, 0, 0, 0);
    }

    // Draw decoration components
    list<CFuiComponent*>::iterator i;
    for (i=decorationList.begin(); i!=decorationList.end(); i++) {
      (*i)->Draw();
    }

    if (data != NULL) {
      DrawText (surface, font, 0, 0, colText, data);
    }
    
    // @todo If this text field is active, draw caret
  }

  CFuiComponent::Draw ();
}

void CFuiTextField::SetMaxChars (int maxChars)
{
  // If new buffer size is the same as old buffer size, do nothing
  if (nChars == maxChars) return;
  
  // Allocate new char buffer
  char *newData = new char[maxChars+1];
  memset (newData, 0, maxChars+1);
  nChars = maxChars;
  
  // If a buffer already existed, copy contents to new buffer before deleting
  if (data != NULL) {
    strncpy (newData, data, nChars);
    delete data;
    data = newData;
  }
}

int CFuiTextField::GetMaxChars (void)
{
  return nChars;
}

void CFuiTextField::UsePassword (int passwordFlag)
{
  this->pass = passwordFlag;
}

int CFuiTextField::IsPassword (void)
{
  return pass;
}

int CFuiTextField::GetLength (void)
{
  // Return actual number of used characters in data buffer
  return strlen (data);
}

void CFuiTextField::SetText (char *text)
{
  if (data != NULL) {
    strncpy (data, text, nChars);
  } else {
    // No data buffer exists, create it
    nChars = strlen(text) + 1;
    data = new char[nChars];
    strcpy (data, text);
  }  
}

char* CFuiTextField::GetText(void)
{
  return data;
}

void CFuiTextField::SetSelection(int firstChar, int lastChar)
{
}

void CFuiTextField::GetSelection(int *firstChar, int *lastChar)
{
}

//
// CFuiLine
//
CFuiLine::CFuiLine (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_LINE;
  widgetTag = 'defa';
  strcpy (widgetName, "Line");

  direction = FUI_LINE_HORIZONTAL;
  thickness = 1;
}

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

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

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

  // Send tag to parent class for processing
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiLine::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    globals->logWarning->Write ("CFuiLabel : Cannot get theme widget %s", s);
  } else {
    // Get theme components
    colLine = tw->GetColour ("LINE");
  }
}

void CFuiLine::Draw (void)
{
  if (surface != NULL) {
    DrawLine (surface, x, y, x+w, y+h, colLine);
  }

  CFuiComponent::Draw ();
}


//
// CFuiBox
//
CFuiBox::CFuiBox (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_BOX;
  widgetTag = 'defa';
  strcpy (widgetName, "Box");

  thickness = 0;
  colLine = MakeRGB (0, 0, 0);
  colFill = MakeRGB (0, 0, 0);
}

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

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

  // Send tag to parent class for processing
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiBox::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    globals->logWarning->Write ("CFuiLabel : Cannot get theme widget %s", s);
  } else {
    // Get theme components
    colLine = tw->GetColour ("LINE");
    colFill = tw->GetColour ("FILL");
  }
}

void CFuiBox::Draw (void)
{
  if (surface != NULL) {
  }

  CFuiComponent::Draw ();
}


//
// CFuiPicture
//
CFuiPicture::CFuiPicture (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_PICTURE;
  widgetTag = 'defa';
  strcpy (widgetName, "Picture");
  bm = NULL;
  destroyBitmap = false;

  // Initialize frame index, ensuring that first call to Draw() will force
  //   the bitmap to be drawn on the component surface
  lastFrame = -1;
  frame = 0;
}

CFuiPicture::~CFuiPicture (void)
{
  if (destroyBitmap) {
    // Bitmap was instantiated by this widget instance, so it must be
    //   freed and deleted
    FreeBitmap (bm);
    delete bm;
  }
}

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

  switch (tag) {
  case 'back':
    destroyBitmap = true;
    bm = new SBitmap;
    ReadString (bm->bitmapName, 64, stream);
    LoadBitmap (bm);
    rc = TAG_READ;
    break;
  }

  // Send tag to parent class for processing
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiPicture::ReadFinished (void)
{
  CFuiComponent::ReadFinished();

  if (bm == NULL) {
    // No bitmap is currently defined.  Load default from theme
    CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
    if (tw == NULL) {
      char s[8];
      TagToString (s, widgetTag);
      globals->logWarning->Write ("CFuiLabel : Cannot get theme widget %s", s);
    } else {
      // Get theme components
      bm = tw->GetBitmap ("BACK");
      if (bm == NULL) {
        bm = tw->GetBitmap ("ALTBACK");
      }
    }
  }

  // Finally, if a bitmap was available from any source, assign it to the widget
  if (bm != NULL) {
    SetBitmap (bm);
  }
}

void CFuiPicture::SetBitmap (SBitmap *bm)
{
  if (bm != NULL) {
    this->bm = bm;

    // If no width/height has been specified, use the bitmap width/height
    if ((this->w == 0) && (this->h == 0)) {
      GetBitmapSize (bm, &this->w, &this->h);
    }
    MakeSurface ();
  }
}

void CFuiPicture::DrawTiledBitmap (SBitmap *bitmap)
{
  if (frame != lastFrame) {
    // Frame number has changed, redraw bitmap tiled across surface
    int bx, by;
    GetBitmapSize (bitmap, &bx, &by);
    for (int iy=0; iy<(int)surface->ySize; iy+=by) {
      for (int ix=0; ix<(int)surface->xSize; ix+=bx) {
        DrawBitmap (surface, bitmap, ix, iy, frame);
      }
    }
    lastFrame = frame;
  }
}

void CFuiPicture::Draw (void)
{
  if (surface != NULL) {
    if (bm != NULL) {
      DrawTiledBitmap (bm);
    }
  }

  CFuiComponent::Draw ();
}

void CFuiPicture::DrawNoTiling (void)
{
  if ((surface != NULL) && (frame != lastFrame)) {
    // Redraw bitmap at top-left corner of surface
    if (bm != NULL) {
      DrawBitmap (surface, bm, 0, 0, frame);
    }
    lastFrame = frame;
  }

  CFuiComponent::Draw ();
}

void CFuiPicture::SetFrame (int i)
{
  frame = i;
}


//
// CFuiMenuBar
//

//
// CFuiScrollBar
//

//
// CFuiSlider
//
CFuiSlider::CFuiSlider (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_SLIDER;
  widgetTag = 'defa';
  strcpy (widgetName, "Slider");

  bmBack = NULL;
  bmAltBack = NULL;
  bmHThumb = NULL;
  bmVThumb = NULL;
  bmHLTick = NULL;
  bmHSTick = NULL;
  bmVLTick = NULL;
  bmVSTick = NULL;

  back = NULL;

  minv = 0.0f;
  maxv = 100.0f;
  curv = 0.0f;
  majt = 20.0f;
  dmjt = true;
  mint = 10.0f;
  dmnt = true;
  snap = true;
  link = 0;

  vertical = false;
}

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

  switch (tag) {
  case 'maxv':
    ReadFloat (&maxv, stream);
    rc = TAG_READ;
    break;
  case 'minv':
    ReadFloat (&minv, stream);
    rc = TAG_READ;
    break;
  case 'curv':
    ReadFloat (&curv, stream);
    rc = TAG_READ;
    break;
  case 'majt':
    ReadFloat (&majt, stream);
    rc = TAG_READ;
    break;
  case 'dmjt':
    {
      int i;
      ReadInt (&i, stream);
      dmjt = (i != 0);
    }
    rc = TAG_READ;
    break;
  case 'mint':
    ReadFloat (&mint, stream);
    rc = TAG_READ;
    break;
  case 'dmnt':
    {
      int i;
      ReadInt (&i, stream);
      dmnt = (i != 0);
    }
    rc = TAG_READ;
    break;
  case 'snap':
    {
      int i;
      ReadInt (&i, stream);
      snap = (i != 0);
    }
    rc = TAG_READ;
    break;
  case 'link':
    ReadTag (&link, stream);
    rc = TAG_READ;
    break;
  }
  
  // Send tag to parent class for processing.
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiSlider::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    globals->logWarning->Write ("CFuiLabel : Cannot get theme widget %s", s);
  } else {
    // Get backdrop bitmap
    bmBack = tw->GetBitmap ("BACK");
    if (bmBack != NULL) {
      int bmw, bmh;
      GetBitmapSize (bmBack, &bmw, &bmh);
      back = new CFuiPicture (0, 0, w, bmh);
      back->SetBitmap (bmBack);
      back->SetParentPosition (x, y);
    }

    // Get alternate backdrop bitmap
    bmAltBack = tw->GetBitmap ("ALTBACK");

    // Get horizontal thumb bitmap
    bmHThumb = tw->GetBitmap ("HTHUMB");

    // Get vertical thumb bitmap
    bmVThumb = tw->GetBitmap ("VTHUMB");

    // Get horizontal major tick bitmap
    bmHLTick = tw->GetBitmap ("HLTICK");

    // Get horizontal minor tick bitmap
    bmHSTick = tw->GetBitmap ("HSTICK");

    // Get vertical major tick bitmap
    bmVLTick = tw->GetBitmap ("VLTICK");

    // Get vertical minor tick bitmap
    bmVSTick = tw->GetBitmap ("VSTICK");
  }
}

void CFuiSlider::SetParentPosition (int xParent, int yParent)
{
  CFuiComponent::SetParentPosition (xParent, yParent);

  // Update position of slider backdrop
  back->SetParentPosition (xParent + x, yParent + y);
}

void CFuiSlider::Draw (void)
{
  if (surface != NULL) {
    // Draw backdrop bitmap if it exists.  The bitmap width or height will be 
    //   used to offset the drawing of any tick marks.
    if (back != NULL) {
      back->Draw ();
    }

    // Select horizontal or vertical bitmap sets
    if (vertical) {
      // Get thumb bitmap size in order to offset any tick marks
      int bmw = 0;
      int bmh = 0;
      if (bmVThumb) {
        GetBitmapSize (bmVThumb, &bmw, &bmh);
      }

      // Draw minor ticks
      if (dmnt && bmVSTick && (mint > 0)) {
        for (float f=minv; f<=maxv; f+=mint) {
          int yTick = (int)((float)h * ((f - minv) / (maxv - minv)));
          DrawBitmap (surface, bmVSTick, bmw, yTick, 0);
        }
      }

      // Draw major ticks
      if (dmjt && bmVLTick && (majt > 0)) {
        for (float f=0; f<=maxv; f+=majt) {
          int yTick = (int)((float)h * ((f - minv) / (maxv - minv)));
          DrawBitmap (surface, bmVSTick, bmw, yTick, 0);
        }
      }

      // Draw indicator
      if (bmVThumb) {
        DrawBitmap (surface, bmVThumb, 0, 0, 0);
      }

    } else {
      // Get thumb bitmap size in order to offset any tick marks
      int bmw = 0;
      int bmh = 0;
      if (bmHThumb) {
        GetBitmapSize (bmHThumb, &bmw, &bmh);
      }

      // Draw minor ticks
      if (dmnt && bmHSTick && (mint > 0)) {
        for (float f=minv; f<=maxv; f+=mint) {
          int xTick = (int)((float)w * ((f - minv) / (maxv - minv)));
          DrawBitmap (surface, bmHSTick, xTick, bmh, 0);
        }
      }

      // Draw major ticks
      if (dmjt && bmHLTick && (majt > 0)) {
        for (float f=minv; f<=maxv; f+=majt) {
          int xTick = (int)((float)w * ((f - minv) / (maxv - minv)));
          DrawBitmap (surface, bmHSTick, xTick, bmh, 0);
        }
      }

      // Draw indicator
      if (bmHThumb) {
        DrawBitmap (surface, bmHThumb, 0, 0, 0);
      }
    }
  }

  CFuiComponent::Draw ();
}

void CFuiSlider::SetMajorTickSpacing (float spacing)
{
  majt = spacing;
}

void CFuiSlider::SetMinorTickSpacing (float spacing)
{
  mint = spacing;
}

void CFuiSlider::SetSnapToTicks (int snapFlag)
{
  snap = snapFlag;
}

void CFuiSlider::SetDrawMajorTicks (int drawFlag)
{
  dmjt = drawFlag;
}

void CFuiSlider::SetDrawMinorTicks (int drawFlag)
{
  dmnt = drawFlag;
}

float CFuiSlider::GetMajorTickSpacing (void)
{
  return majt;
}

float CFuiSlider::GetMinorTickSpacing (void)
{
  return mint;
}

int CFuiSlider::GetSnapToTicks (void)
{
  return snap;
}

int CFuiSlider::GetDrawMajorTicks (void)
{
  return dmjt;
}

int CFuiSlider::GetDrawMinorTicks (void)
{
  return dmnt;
}


//
// CFuiGauge
//



//
// CFuiGroupBox
//
CFuiGroupBox::CFuiGroupBox (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_GROUPBOX;
  widgetTag = 'defa';
  strcpy (widgetName, "GroupBox");

  bmBack = NULL;
  bmTop = NULL;
  bmBottom = NULL;
  bmLeft = NULL;
  bmRight = NULL;
  bmTopLeft = NULL;
  bmTopRight = NULL;
  bmBottomLeft = NULL;
  bmBottomRight = NULL;

  transparent = true;
  colText = MakeRGB (0, 0, 0);
  xText = 0;
}

// @todo CFuiGroupBox destructor

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

  // Add subcomponent if applicable
  if (ValidFuiComponentType (tag)) {
    CFuiComponent *c = CreateFuiComponent ((EFuiComponentTypes)tag);
    if (c != NULL) {
      ReadFrom (c, stream);
      c->SetParentPosition (x, y);
      childList.push_back (c);
      rc = TAG_READ;
    } else {
      char s[8];
      globals->logWarning->Write ("CFuiGroupBox : Skipping unsupported widget %s",
        TagString (s, tag));
      SkipObject (stream);
    }
    rc = TAG_READ;
  }

  // Send tag to parent class for processing.
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiGroupBox::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    globals->logWarning->Write ("CFuiLabel : Cannot get theme widget %s", s);
  } else {
    // Locals for bitmap width/height
    int bmw = 0;
    int bmh = 0;

    // Get optional top-left corner bitmap
    bmTopLeft = tw->GetBitmap ("TOPLEFT");
    if (bmTopLeft != NULL) {
      GetBitmapSize (bmTopLeft, &bmw, &bmh);
      CFuiPicture *topleft = new CFuiPicture (0, 0, bmw, bmh);
      topleft->SetBitmap (bmTopLeft);
      topleft->SetParentPosition (x, y);
      decorationList.push_back (topleft);
    }

    // Set x offset for text label to width of top-left bitmap
    xText = bmw;

    // Get optional top frame bitmap
    bmTop = tw->GetBitmap ("TOP");
    if (bmTop != NULL) {
      GetBitmapSize (bmTop, &bmw, &bmh);
      CFuiPicture *top = new CFuiPicture (0, 0, w, bmh);
      top->SetBitmap (bmTop);
      top->SetParentPosition (x, y);
      decorationList.push_back (top);
    }

    // Get optional bottom frame bitmap
    bmBottom = tw->GetBitmap ("BOTTOM");
    if (bmBottom != NULL) {
      GetBitmapSize (bmBottom, &bmw, &bmh);
      CFuiPicture *bottom = new CFuiPicture (0, h-bmh, w, bmh);
      bottom->SetBitmap (bmBottom);
      bottom->SetParentPosition (x, y);
      decorationList.push_back (bottom);
    }

    // Get optional left frame bitmap
    bmLeft = tw->GetBitmap ("LEFT");
    if (bmLeft != NULL) {
      GetBitmapSize (bmLeft, &bmw, &bmh);
      CFuiPicture *left = new CFuiPicture (0, 0, bmw, h);
      left->SetBitmap (bmLeft);
      left->SetParentPosition (x, y);
      decorationList.push_back (left);
    }

    // Get optional right frame bitmap
    bmRight = tw->GetBitmap ("RIGHT");
    if (bmRight != NULL) {
      GetBitmapSize (bmRight, &bmw, &bmh);
      CFuiPicture *right = new CFuiPicture (w-bmw, 0, bmw, h);
      right->SetBitmap (bmRight);
      right->SetParentPosition (x, y);
      decorationList.push_back (right);
    }

    // Get optional top-right corner bitmap
    bmTopRight = tw->GetBitmap ("TOPRIGHT");
    if (bmTopRight != NULL) {
      GetBitmapSize (bmTopRight, &bmw, &bmh);
      CFuiPicture *topright = new CFuiPicture (w-bmw, 0, bmw, bmh);
      topright->SetBitmap (bmTopRight);
      topright->SetParentPosition (x, y);
      decorationList.push_back (topright);
    }

    // Get optional bottom-left corner bitmap
    bmBottomLeft = tw->GetBitmap ("BOTLEFT");
    if (bmBottomLeft != NULL) {
      GetBitmapSize (bmBottomLeft, &bmw, &bmh);
      CFuiPicture *botleft = new CFuiPicture (0, h-bmh, bmw, bmh);
      botleft->SetBitmap (bmBottomLeft);
      botleft->SetParentPosition (x, y);
      decorationList.push_back (botleft);
    }

    // Get optional bottom-right corner bitmap
    bmBottomRight = tw->GetBitmap ("BOTRIGHT");
    if (bmBottomRight != NULL) {
      GetBitmapSize (bmBottomRight, &bmw, &bmh);
      CFuiPicture *botright = new CFuiPicture (w-bmw, h-bmh, bmw, bmh);
      botright->SetBitmap (bmBottomRight);
      botright->SetParentPosition (x, y);
      decorationList.push_back (botright);
    }

    // Get window backdrop bitmap from the theme.  This is not added to the decoration
    //   list since the transparent flag will determine if it is drawn or not.
    bmBack = tw->GetBitmap ("BACK");

    // Get text colour
    colText = tw->GetColour ("TEXT");
  }
}

void CFuiGroupBox::SetParentPosition (int xParent, int yParent)
{
  CFuiComponent::SetParentPosition (xParent, yParent);

  // Update all decorations
  list<CFuiComponent*>::iterator i;
  for (i=decorationList.begin(); i!=decorationList.end(); i++) {
    (*i)->SetParentPosition (xParent + x, yParent + y);
  }

  // Update all children
  for (i=childList.begin(); i!=childList.end(); i++) {
    (*i)->SetParentPosition(xParent + x, yParent + y);
  }
}

void CFuiGroupBox::Draw (void)
{
  if (surface != NULL) {
    // Draw background bitmap if groupbox is not transparent
    if ((bmBack != NULL) && !transparent) {
      DrawBitmap (surface, bmBack, 0, 0, 0);
    }

    // Draw groupbox decoration components
    list<CFuiComponent*>::iterator i;
    for (i=decorationList.begin(); i!=decorationList.end(); i++) {
      (*i)->Draw();
    }

    DrawText (surface, font, xText, 0, colText, text);

    // Draw child components
    for (i=childList.begin(); i!=childList.end(); i++) {
      (*i)->Draw();
    }
  }

  CFuiComponent::Draw ();
}

bool CFuiGroupBox::MouseMove (int mx, int my)
{
  bool rc = false;

  // Send directly to child widgets
  list<CFuiComponent*>::iterator i;
  for (i=childList.begin(); i!=childList.end() && !rc; i++) {
    rc = (*i)->MouseMove (mx, my);
  }

  return rc;
}

bool CFuiGroupBox::MouseClick (int mx, int my, EMouseButton button)
{
  bool rc = false;

  // Send directly to child widgets
  list<CFuiComponent*>::iterator i;
  for (i=childList.begin(); i!=childList.end() && !rc; i++) {
    rc = (*i)->MouseClick (mx, my, button);
  }

  return rc;
}

bool CFuiGroupBox::MouseStopClick (int mx, int my, EMouseButton button)
{
  bool rc = false;

  // Send directly to child widgets
  list<CFuiComponent*>::iterator i;
  for (i=childList.begin(); i!=childList.end() && !rc; i++) {
    rc = (*i)->MouseStopClick (mx, my, button);
  }

  return rc;
}



//
// CFuiGauge
//


//
// CFuiListRow
//

CFuiListRow::CFuiListRow (void)
{
  height = 0;
}

void CFuiListRow::SetHeight (unsigned int height)
{
  this->height = height;
}

unsigned int CFuiListRow::GetHeight (void)
{
  return height;
}

void CFuiListRow::SetText (const char *text)
{
  this->text = text;
}

const char* CFuiListRow::GetText (void)
{
  return text.c_str();
}


//
// CFuiListColumn
//
CFuiListColumn::CFuiListColumn (void)
{
  width = minWidth = 0;
}

void CFuiListColumn::SetWidth (unsigned int width)
{
  this->width = width;
}

unsigned int CFuiListColumn::GetWidth (void)
{
  return width;
}

void CFuiListColumn::SetTitle (const char *title)
{
  this->title = title;
}

void CFuiListColumn::AddRow (CFuiListRow row)
{
  // @todo Adjust minimum width

  // Add row to list
  rows.push_back (row);
}

void CFuiListColumn::DeleteRow (unsigned int row)
{
  vector<CFuiListRow>::iterator i = rows.begin();
  for (unsigned int ir=0; (ir <= row) && (i != rows.end()); ir++, i++);
  if (i != rows.end()) {
    rows.erase (i);
  }
}

void CFuiListColumn::DeleteAllRows (void)
{
  rows.clear();
}

CFuiListRow& CFuiListColumn::GetRow (unsigned int i)
{
  return rows[i];
}

unsigned int CFuiListColumn::GetRowCount (void)
{
  return rows.size();
}


//
// CFuiList
//
CFuiList::CFuiList (int x, int y, int w, int h, Tag window)
: CFuiComponent (x, y, w, h, window)
{
  type = COMPONENT_LIST;
  widgetTag = 'defa';
  strcpy (widgetName, "List");

  utit = usrr = 0;
  multiselect = 0;
  vscroll = 0;
  hscroll = 0;
  dwidth = dheight = 0;
  autowidth = 0;

  bmTop = NULL;
  bmBottom = NULL;
  bmLeft = NULL;
  bmRight = NULL;
  bmTopLeft = NULL;
  bmTopRight = NULL;
  bmBottomLeft = NULL;
  bmBottomRight = NULL;
  bmHighlight = NULL;
  bmBack = NULL;

  colText = MakeRGB (0, 0, 0);
  colTextHighlight = MakeRGB (0, 0, 0);
  colHighlight = MakeRGB (255, 255, 0);

  scrollRow = scrollCol = 0;
  nRows = 0;
}

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

  switch (tag) {
  case 'utit':
    ReadInt (&utit, stream);
    rc = TAG_READ;
    break;
  case 'usrr':
    ReadInt (&usrr, stream);
    rc = TAG_READ;
    break;
  case 'msel':
    ReadInt (&multiselect, stream);
    rc = TAG_READ;
    break;
  case 'vscr':
    ReadInt (&vscroll, stream);
    rc = TAG_READ;
    break;
  case 'hscr':
    ReadInt (&hscroll, stream);
    rc = TAG_READ;
    break;
  case 'dwid':
    ReadInt (&dwidth, stream);
    rc = TAG_READ;
    break;
  case 'dhgt':
    ReadInt (&dheight, stream);
    rc = TAG_READ;
    break;
  case 'autw':
    ReadInt (&autowidth, stream);
    rc = TAG_READ;
    break;
  }

  // Send tag to parent class for processing
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiList::ReadFinished (void)
{
  CFuiComponent::ReadFinished ();

  // Get FUI theme for this component
  CFuiThemeWidget *tw = globals->fuimgr->GetThemeWidget (widgetTag, widgetName);
  if (tw == NULL) {
    char s[8];
    TagToString (s, widgetTag);
    globals->logWarning->Write ("CFuiList : Cannot get theme widget %s", s);
  } else {
    // Locals for bitmap width/height
    int bmw = 0;
    int bmh = 0;

    // Get optional top frame bitmap
    bmTop = tw->GetBitmap ("TOP");
    if (bmTop != NULL) {
      GetBitmapSize (bmTop, &bmw, &bmh);
      CFuiPicture *top = new CFuiPicture (0, 0, w, bmh);
      top->SetBitmap (bmTop);
      top->SetParentPosition (x, y);
      decorationList.push_back (top);
    }

    // Get optional bottom frame bitmap
    bmBottom = tw->GetBitmap ("BOTTOM");
    if (bmBottom != NULL) {
      GetBitmapSize (bmBottom, &bmw, &bmh);
      CFuiPicture *bottom = new CFuiPicture (0, h-bmh, w, bmh);
      bottom->SetBitmap (bmBottom);
      bottom->SetParentPosition (x, y);
      decorationList.push_back (bottom);
    }

    // Get optional left frame bitmap
    bmLeft = tw->GetBitmap ("LEFT");
    if (bmLeft != NULL) {
      GetBitmapSize (bmLeft, &bmw, &bmh);
      CFuiPicture *left = new CFuiPicture (0, 0, bmw, h);
      left->SetBitmap (bmLeft);
      left->SetParentPosition (x, y);
      decorationList.push_back (left);
    }

    // Get optional right frame bitmap
    bmRight = tw->GetBitmap ("RIGHT");
    if (bmRight != NULL) {
      GetBitmapSize (bmRight, &bmw, &bmh);
      CFuiPicture *right = new CFuiPicture (w-bmw, 0, bmw, h);
      right->SetBitmap (bmRight);
      right->SetParentPosition (x, y);
      decorationList.push_back (right);
    }

    // Get optional top-left corner bitmap
    bmTopLeft = tw->GetBitmap ("TOPLEFT");
    if (bmTopLeft != NULL) {
      GetBitmapSize (bmTopLeft, &bmw, &bmh);
      CFuiPicture *topleft = new CFuiPicture (0, 0, bmw, bmh);
      topleft->SetBitmap (bmTopLeft);
      topleft->SetParentPosition (x, y);
      decorationList.push_back (topleft);
    }

    // Get optional top-right corner bitmap
    bmTopRight = tw->GetBitmap ("TOPRIGHT");
    if (bmTopRight != NULL) {
      GetBitmapSize (bmTopRight, &bmw, &bmh);
      CFuiPicture *topright = new CFuiPicture (w-bmw, 0, bmw, bmh);
      topright->SetBitmap (bmTopRight);
      topright->SetParentPosition (x, y);
      decorationList.push_back (topright);
    }

    // Get optional bottom-left corner bitmap
    bmBottomLeft = tw->GetBitmap ("BOTLEFT");
    if (bmBottomLeft != NULL) {
      GetBitmapSize (bmBottomLeft, &bmw, &bmh);
      CFuiPicture *botleft = new CFuiPicture (0, h-bmh, bmw, bmh);
      botleft->SetBitmap (bmBottomLeft);
      botleft->SetParentPosition (x, y);
      decorationList.push_back (botleft);
    }

    // Get optional bottom-right corner bitmap
    bmBottomRight = tw->GetBitmap ("BOTRIGHT");
    if (bmBottomRight != NULL) {
      GetBitmapSize (bmBottomRight, &bmw, &bmh);
      CFuiPicture *botright = new CFuiPicture (w-bmw, h-bmh, bmw, bmh);
      botright->SetBitmap (bmBottomRight);
      botright->SetParentPosition (x, y);
      decorationList.push_back (botright);
    }

    // Get optional highlight bitmap
    bmHighlight = tw->GetBitmap ("HIGHLIGHT");
    if (bmHighlight != NULL) {
      GetBitmapSize (bmHighlight, &bmw, &bmh);
      CFuiPicture *highlight = new CFuiPicture (0, 0, bmw, bmh);
      highlight->SetBitmap (bmBottomRight);
      highlight->SetParentPosition (x, y);
      decorationList.push_back (highlight);
    }

    // Get window backdrop bitmap from the theme.  This is not added to the decoration
    //   list since the transparent flag will determine if it is drawn or not.
    bmBack = tw->GetBitmap ("BACK");

    // Get text colour
    colText = tw->GetColour ("TEXT");
    colTextHighlight = tw->GetColour ("TEXTHILITE");
    colHighlight = tw->GetColour ("HILITE");

    // Get optional DONT_DRAW_BACKGROUND flag
    noBackground = tw->GetFlag ("DONT_DRAW_BACKGROUND");
  }
}

void CFuiList::SetParentPosition (int xParent, int yParent)
{
  CFuiComponent::SetParentPosition (xParent, yParent);

  // Update all decorations
  list<CFuiComponent*>::iterator i;
  for (i=decorationList.begin(); i!=decorationList.end(); i++) {
    (*i)->SetParentPosition (xParent + x, yParent + y);
  }
}

void CFuiList::Draw (void)
{
  if (surface != NULL) {
    // Draw background bitmap
    if ((bmBack != NULL) && !noBackground) {
      DrawBitmap (surface, bmBack, 0, 0, 0);
    }

    // Draw decoration components
    list<CFuiComponent*>::iterator i;
    for (i=decorationList.begin(); i!=decorationList.end(); i++) {
      (*i)->Draw();
    }

    // @todo Process data to determine layout to accomodate for different row heights

    // Display data
    vector<CFuiListColumn>::iterator c;
    int x = 0;
    int iStartRow = scrollRow;
    for (c=cols.begin(); c!=cols.end(); c++) {
      int y = 0;
      for (unsigned int i=iStartRow; i<c->GetRowCount(); i++) {
        CFuiListRow &row = c->GetRow (i);
        DrawText (surface, font, x, y, colText, row.GetText());
        y += row.GetHeight();
        
        // Stop displaying rows when bottom edge of surface has been reached
        if (y >= h) break;
      }
      x += c->GetWidth();

      // Stop displaying columns when right edge of surface has been reached
      if (x >= w) break;
    }
  }

  CFuiComponent::Draw ();
}

void CFuiList::ScrollToRow (unsigned int row)
{
  if (row <= GetRowCount()) scrollRow = row;
}

void CFuiList::ScrollToColumn (unsigned int column)
{
  if (column <= GetColumnCount()) scrollCol = column;
}

unsigned int CFuiList::GetRowCount (void)
{
  return nRows;;
}

unsigned int CFuiList::GetColumnCount (void)
{
  return cols.size();
}

void CFuiList::AddColumn (unsigned int width, char *title)
{
  CFuiListColumn c;
  c.SetWidth (width);
  c.SetTitle (title);
  cols.push_back (c);
}

void CFuiList::DeleteColumn (unsigned int column)
{
  // Adjust scroll column if necessary
  if ((scrollCol == column) && (scrollCol != 0)) scrollCol--;

  // Erase the column from the list
  vector<CFuiListColumn>::iterator i = cols.begin();
  for (unsigned int ic=0; (i != cols.end()) && (ic < column); ic++, i++);
  if (i != cols.end()) {
    cols.erase (i);
  }
}

void CFuiList::DeleteAllColumns (void)
{
  cols.erase (cols.begin(), cols.end());
  scrollCol = 0;
}

void CFuiList::SetColumnWidth (unsigned int column, unsigned int width)
{
  if (column <= GetColumnCount()) {
    cols[column].SetWidth (width);
  }
}

void CFuiList::AddRow (unsigned int height)
{
  // Add row to all columns
  vector<CFuiListColumn>::iterator i;
  for (i=cols.begin(); i!=cols.end(); i++) {
    CFuiListRow r;
    r.SetHeight (height);
    i->AddRow (r);
    nRows++;
  }
}

void CFuiList::DeleteRow (unsigned int row)
{
  // Delete row from all columns
  vector<CFuiListColumn>::iterator i;
  for (i=cols.begin(); i!=cols.end(); i++) {
    i->DeleteRow (row);
  }
}

void CFuiList::DeleteAllRows (void)
{
  // Delete all rows from all columns
  vector<CFuiListColumn>::iterator i;
  for (i=cols.begin(); i!=cols.end(); i++) {
    i->DeleteAllRows ();
  }
}

unsigned int CFuiList::CountSelectedRows (void)
{
  int rc = 0;

  // @todo Count selected rows
  
  return rc;
}

unsigned int CFuiList::GetSelectedRow (unsigned int index)
{
  int rc = 0;

  // @todo Get selected row

  return rc;
}

void CFuiList::SelectRow (unsigned int row)
{
  // @todo Select row
}

void CFuiList::ClearSelection (void)
{
  // @todo Clear selection
}

void CFuiList::SetCellText (unsigned int row, unsigned int column, char *text)
{
  if (column <= GetColumnCount()) {
    CFuiListColumn& c = cols[column];
    if (row <= c.GetRowCount()) {
      CFuiListRow& r = c.GetRow (row);
      r.SetText (text);
    }
  }
}

void CFuiList::SetCellIcon (unsigned int row, unsigned int column, char *filename)
{
  // @todo Set cell icon
}

void CFuiList::ClearCellText (unsigned int row, unsigned int column)
{
  SetCellText (row, column, "");
}

void CFuiList::ClearCellIcon (unsigned int row, unsigned int column)
{
  // @todo Clear cell icon
}

void CFuiList::GetCellText (unsigned int row, unsigned int column, char *outtext)
{
  if (column <= GetColumnCount()) {
    CFuiListColumn& c = cols[column];
    if (row <= c.GetRowCount()) {
      CFuiListRow& r = c.GetRow (row);
      strcpy (outtext, r.GetText());
    }
  }
}


//
// CFuiTextPopup
//
void CFuiTextPopup::SetText (const char* text = NULL)
{
  // Call parent class method
  CFuiComponent::SetText (text);

  // Delete previous SSurface if it was created
  if (surface != NULL) {
    FreeSurface (surface);
    surface = NULL;
  }

  if (text != NULL) {
    // Use default font
    SFont *font = &globals->fonts.ftasci10;

    // Define colours
    unsigned int black = MakeRGB (0, 0, 0);
    unsigned int darkgrey = MakeRGB (100, 100, 100);
    unsigned int mediumgrey = MakeRGB (164, 164, 164);
    unsigned int lightgrey = MakeRGB (212, 212, 212);
    unsigned int white = MakeRGB (255, 255, 255);

    // Create surface
    int xSpace = 12;
    int ySpace = 4;
    w = TextWidth (font, this->text) + (2 * xSpace);
    h = TextHeight (font, this->text) + (2 * ySpace);
    surface = CreateSurface (w, h);
    surface->xScreen = x;
    surface->yScreen = y;
    EraseSurfaceRGB (surface, mediumgrey);

    // Draw borders
    DrawRect (surface, 2, 2, w-1, h-1, lightgrey);
    DrawRect (surface, 1, 1, w-2, h-2, darkgrey);

    // Draw shadowed text
    DrawText (surface, font, xSpace+1, ySpace+1, black, this->text);
    DrawText (surface, font, xSpace, ySpace, white, this->text);
  }
}


//
// CFuiGraphTrace
//
CFuiGraphTrace::CFuiGraphTrace (Tag id, int type)
{
  this->id = id;
  this->type = type;
  colour = MakeRGB (255, 255, 255);
  minX = minY = 0.0f;
  maxX = maxY = 100.0f;
}

void CFuiGraphTrace::AddPoint (float x, float y)
{
  SFuiGraphTracePoint p;
  p.x = x;
  p.y = y;
  points.push_back (p);
}

void CFuiGraphTrace::ClearPoints (void)
{
  points.erase (points.begin(), points.end());
}

void CFuiGraphTrace::SetRange (float minX, float minY, float maxX, float maxY)
{
  this->minX = minX;
  this->minY = minY;
  this->maxX = maxX;
  this->maxY = maxY;
}

void CFuiGraphTrace::SetColour (unsigned int colour)
{
  this->colour = colour;
}

void CFuiGraphTrace::Draw (SSurface *surface)
{
  static int prevX = 0;
  static int prevY = 0;

  vector<SFuiGraphTracePoint>::iterator i;
  for (i=points.begin(); i!=points.end(); i++) {
    float x = i->x;
    float y = i->y;

    float dx = (x - minX) / (maxX - minX);
    float dy = (maxY - y) / (maxY - minY);
    if (dx < 0) dx = 0;
    if (dx > 1.0f) dx = 1.0f;
    if (dy < 0) dy = 0;
    if (dy > 1.0f) dy = 1.0f;

    int px = (int)((float)surface->xSize * dx);
    int py = (int)((float)surface->ySize * dy);

    if (i == points.begin()) {
      // Initialize previous x and y offets for line trace
      prevX = px;
      prevY = py;
    }

    switch (type) {
    case FUI_GRAPH_TRACE_POINT:
      DrawDot (surface, px, py, colour);
      break;

    case FUI_GRAPH_TRACE_LINE:
      DrawLine (surface, prevX, prevY, px, py, colour);
      prevX = px;
      prevY = py;
      break;
    }
  }
}


//
// CFuiGraph
//
CFuiGraph::CFuiGraph (void)
{
  type = COMPONENT_GRAPH;
  widgetTag = 'defa';
  strcpy (widgetName, "Graph");

  useGrid = false;
  minX = minY = 0;
  maxX = maxY = 100.0f;
  stepX = stepY = 10.0f;

  // Initialize background and grid colours
  bgColour = MakeRGB (1, 1, 1);
  gridColour = MakeRGB (64, 64, 64);
}

int CFuiGraph::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;
  switch (tag) {
  case 'grid':
    {
      int i = 0;
      ReadInt (&i, stream);
      useGrid = (i != 0);
    }
    rc = TAG_READ;
    break;
  case 'grdr':
    ReadFloat (&minX, stream);
    ReadFloat (&minY, stream);
    ReadFloat (&maxX, stream);
    ReadFloat (&maxY, stream);
    ReadFloat (&stepX, stream);
    ReadFloat (&stepY, stream);
    rc = TAG_READ;
    break;
  }

  // Send tag to parent class for processing
  if (rc == TAG_IGNORED) {
    rc = CFuiComponent::Read (stream, tag);
  }

  return rc;
}

void CFuiGraph::Draw (void)
{
  if (surface != NULL) {

    // Fill surface with background colour
    EraseSurfaceRGB (surface, bgColour);

    // Draw grid if necessary
    if (useGrid) {
      // Horizontal grid lines
      float y = stepY;
      while (y <= surface->ySize) {
        float dy = (maxY - y) / (maxY - minY);
        if (dy < 0) dy = 0;
        if (dy > 1.0f) dy = 1.0f;
        int py = (int)((float)surface->ySize * dy);
        DrawLine (surface, 0, py, surface->xSize, py, gridColour);
        y += stepY;
      }

      // Vertical grid lines
      float x = stepX;
      while (x <= surface->xSize) {
        float dx = (x - minX) / (maxX - minX);
        if (dx < 0) dx = 0;
        if (dx > 1.0f) dx = 1.0f;
        int px = (int)((float)surface->xSize * dx);
        DrawLine (surface, px, 0, px, surface->ySize, gridColour);
        x += stepX;
      }
    }

    // Notify application to update trace data
    globals->fuimgr->GenerateEventNotice (parentWindowId, id,
                                          EVENT_UPDATE, EVENT_NOSUBEVENT);

    // Draw traces
    map<Tag,CFuiGraphTrace*>::iterator i;
    for (i=traces.begin(); i!=traces.end(); i++) {
      CFuiGraphTrace *t = i->second;
      t->Draw (surface);
    }
  }

  CFuiComponent::Draw ();
}

void CFuiGraph::AddTrace (Tag traceID, int traceType)
{
  map<Tag,CFuiGraphTrace*>::iterator i = traces.find(traceID);
  if (i == traces.end()) {
    traces[traceID] = new CFuiGraphTrace (traceID, traceType);
  } else {
    WARNINGLOG ("CFuiGraph::AddTrace : Duplicate trace");
  }
}

void CFuiGraph::RemoveTrace (Tag traceID)
{
  map<Tag,CFuiGraphTrace*>::iterator i = traces.find(traceID);
  if (i != traces.end()) {
    traces.erase (i);
  } else {
    WARNINGLOG ("CFuiGraph::RemoveTrace : Non-existent trace");
  }
}

void CFuiGraph::RemoveAllTraces (void)
{
  traces.erase (traces.begin(), traces.end());
}

void CFuiGraph::AddTracePoint(Tag traceID, float x, float y)
{
  map<Tag,CFuiGraphTrace*>::iterator i = traces.find(traceID);
  if (i != traces.end()) {
    CFuiGraphTrace* t = i->second;
    t->AddPoint (x, y);
  } else {
    WARNINGLOG ("CFuiGraph::AddTracePoint : Non-existent trace");
  }
}

void CFuiGraph::ClearTracePoints (Tag traceID)
{
  map<Tag,CFuiGraphTrace*>::iterator i = traces.find(traceID);
  if (i != traces.end()) {
    CFuiGraphTrace* t = i->second;
    t->ClearPoints ();
  } else {
    WARNINGLOG ("CFuiGraph::ClearTracePoints : Non-existent trace");
  }
}

void CFuiGraph::SetTraceRange (Tag traceID, float minX, float minY, float maxX, float maxY)
{
  map<Tag,CFuiGraphTrace*>::iterator i = traces.find(traceID);
  if (i != traces.end()) {
    CFuiGraphTrace* t = i->second;
    t->SetRange (minX, minY, maxX, maxY);
  } else {
    WARNINGLOG ("CFuiGraph::SetTraceRange : Non-existent trace");
  }
}

void CFuiGraph::SetTraceColour (Tag traceID, unsigned int colour)
{
  map<Tag,CFuiGraphTrace*>::iterator i = traces.find(traceID);
  if (i != traces.end()) {
    CFuiGraphTrace* t = i->second;
    t->SetColour (colour);
  } else {
    WARNINGLOG ("CFuiGraph::SetTraceColour : Non-existent trace");
  }
}

void CFuiGraph::SetUseGrid (int useGrid)
{
  this->useGrid = (useGrid != 0);
}

void CFuiGraph::SetGridRange (float minX, float minY, float maxX, float maxY)
{
  this->minX = minX;
  this->minY = minY;
  this->maxX = maxX;
  this->maxY = maxY;
}

void CFuiGraph::SetGridSpacing (float stepX, float stepY)
{
  this->stepX = stepX;
  this->stepY = stepY;
}

void CFuiGraph::SetGridColour (unsigned int colour)
{
  this->gridColour = colour;
}

void CFuiGraph::SetGridBackColour (unsigned int colour)
{
  this->bgColour = colour;
}

void CFuiGraph::GetGridRange(float *minX, float *minY, float *maxX, float *maxY)
{
  *minX = this->minX;
  *minY = this->minY;
  *maxX = this->maxX;
  *maxY = this->maxY;
}

void CFuiGraph::GetGridSpacing(float *stepX, float *stepY)
{
  *stepX = this->stepX;
  *stepY = this->stepY;
}


//
// Local helper functions
//

//
// Validate a tag value suspected to be a FUI component type
//
static bool ValidFuiComponentType (Tag tag)
{
  bool rc = false;

  switch (tag) {
  case COMPONENT_WINDOW:
  case COMPONENT_BUTTON:
  case COMPONENT_DOUBLE_BUTTON:
  case COMPONENT_DEFAULT_BUTTON:
  case COMPONENT_POPUPMENU:
  case COMPONENT_MENUBAR:
  case COMPONENT_WINDOW_MENUBAR:
  case COMPONENT_MENU:
  case COMPONENT_CHECKBOX:
  case COMPONENT_RADIOBUTTON:
  case COMPONENT_LABEL:
  case COMPONENT_LINE:
  case COMPONENT_BOX:
  case COMPONENT_PICTURE:
  case COMPONENT_SCROLLBAR:
  case COMPONENT_SLIDER:
  case COMPONENT_GROUPBOX:
  case COMPONENT_GAUGE:
  case COMPONENT_LIST:
  case COMPONENT_SCROLLAREA:
  case COMPONENT_TEXTFIELD:
  case COMPONENT_TEXTAREA:
  case COMPONENT_PROGRESS:
  case COMPONENT_MAP:
  case COMPONENT_TABPAGE:
  case COMPONENT_TABBUTTON:
  case COMPONENT_TABCONTROL:
  case COMPONENT_GRAPH:
  case COMPONENT_DLLVIEW:
  case COMPONENT_DISCLOSURE:
  case COMPONENT_CANVAS:
  case COMPONENT_RUNWAY_CANVAS:
  case COMPONENT_MARQUEE:
  case COMPONENT_HORIZ_MARQUEE:
  case COMPONENT_WINDOW_NORESIZE:
  case COMPONENT_TITLE:
  case COMPONENT_PALETTE_WINDOW:
  case COMPONENT_PALETTE_WINDOW_TITLE:
  case COMPONENT_CLOSE_BUTTON:
  case COMPONENT_MINIMIZE_BUTTON:
  case COMPONENT_ZOOM_BUTTON:
    rc = true;
  }

  return rc;
}

//
// Helper function instantiates a FUI component given its component type
//
static CFuiComponent *CreateFuiComponent (EFuiComponentTypes type)
{
  switch (type) {
  case COMPONENT_TITLE:
    return new CFuiWindowTitle;
    break;

  case COMPONENT_CLOSE_BUTTON:
    return new CFuiCloseButton;
    break;

  case COMPONENT_MINIMIZE_BUTTON:
    return new CFuiMinimizeButton;
    break;

  case COMPONENT_ZOOM_BUTTON:
    return new CFuiZoomButton;
    break;

  case COMPONENT_BUTTON:
    return new CFuiButton;
    break;

  case COMPONENT_LABEL:
    return new CFuiLabel;
    break;

  case COMPONENT_TEXTFIELD:
    return new CFuiTextField;
    break;

  case COMPONENT_PICTURE:
    return new CFuiPicture;
    break;

  case COMPONENT_CHECKBOX:
    return new CFuiCheckbox;
    break;

  case COMPONENT_RADIOBUTTON:
    return new CFuiRadioButton;
    break;

  case COMPONENT_LINE:
    return new CFuiLine;
    break;

  case COMPONENT_BOX:
    return new CFuiBox;
    break;

  case COMPONENT_GROUPBOX:
    return new CFuiGroupBox;
    break;

  case COMPONENT_SLIDER:
    return new CFuiSlider;
    break;

  case COMPONENT_LIST:
    return new CFuiList;
    break;

  case COMPONENT_POPUPMENU:
    return new CFuiPopupMenu;
    break;

  case COMPONENT_GRAPH:
    return new CFuiGraph;
    break;

  case COMPONENT_SCROLLBAR:
//    return new CFuiScrollbar;
    break;

  case COMPONENT_DOUBLE_BUTTON:
//    return new CFuiDoubleButton;
    break;

  case COMPONENT_DEFAULT_BUTTON:
//    return new CFuiDefaultButton;
    break;

  case COMPONENT_MENUBAR:
//    return new CFuiMenuBar;
    break;

  case COMPONENT_WINDOW_MENUBAR:
//    return new CFuiWindowMenuBar;
    break;

  case COMPONENT_MENU:
//    return new CFuiMenu;
    break;

  case COMPONENT_GAUGE:
//    return new CFuiGauge;
    break;

  case COMPONENT_SCROLLAREA:
//    return new CFuiScrollArea;
    break;

  case COMPONENT_TEXTAREA:
//    return new CFuiTextArea;
    break;

  case COMPONENT_PROGRESS:
//    return new CFuiProgress;
    break;

  case COMPONENT_MAP:
//    return new CFuiMap;
    break;

  case COMPONENT_TABPAGE:
//    return new CFuiTabPage;
    break;

  case COMPONENT_TABBUTTON:
//    return new CFuiTabButton;
    break;

  case COMPONENT_TABCONTROL:
//    return new CFuiTabControl;
    break;

  case COMPONENT_DLLVIEW:
//    return new CFuiDLLView;
    break;

  case COMPONENT_DISCLOSURE:
//    return new CFuiDisclosure;
    break;

  case COMPONENT_CANVAS:
//    return new CFuiCanvas;
    break;

  case COMPONENT_RUNWAY_CANVAS:
//    return new CFuiRunwayCanvas;
    break;

  case COMPONENT_MARQUEE:
//    return new CFuiMarquee;
    break;

  case COMPONENT_HORIZ_MARQUEE:
//    return new CFuiHorizMarquee;
    break;

  case COMPONENT_WINDOW_NORESIZE:
//    return new CFuiWindowNoResize;
    break;

  case COMPONENT_PALETTE_WINDOW:
//    return new CFuiPaletteWindow;
    break;

  case COMPONENT_PALETTE_WINDOW_TITLE:
//    return new CFuiPaletteWindowTitle;
    break;

  default:
    // No action required
    ;
  }

  return NULL;
}

/* Function is currently unused, leave commented unless necessary

//
// Helper function instantiates a FUI component given its name
//
static CFuiComponent *CreateFuiComponent (const char* name)
{
  CFuiComponent *rc = NULL;

  Tag type = CFuiManager::GetComponentType (name);
  if (type != 0) {
    rc = CreateFuiComponent ((EFuiComponentTypes)type);
  }
  
  return rc;
}

*/

Documentation generated by