FuiManager.cpp

Go to the documentation of this file.

/*
 * FuiManager.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/Fui.h"
#include "../Include/Globals.h"   // For globals->pfs
#include "../Include/Utility.h"   // For stream functions
#include "../Include/Ui.h"

using namespace std;


//
// CFuiManager
//
CFuiManager::CFuiManager(void)
{
  // When parsing master theme schema, theme identifiers and filenames
  //   are stored in the following map.  Only after the master schema
  //   file has been processed are the individual themes instantiated
  map<Tag,string> themename;
  
  // Load themes
  const char* masterFilename = "UI\\THEMES\\STDTHEMES.SCH";
  PODFILE *p = popen (&globals->pfs, masterFilename);
  if (p != NULL) {
    // Begin parsing lines
    char s[256];
    pgets (s, 256, p);
    const char *delimiters = " \t";
    while (!peof(p)) {
      // Trim trailing whitespace
      TrimTrailingWhitespace (s);

      // Check for comment or blank line
      if ((strcmp (s, "//") == 0) || (strlen(s) == 0)) {
        pgets (s, 256, p);
        continue;
      }

      // Check first token
      char *token = strtok (s, delimiters);
      if (stricmp (token, "THEMEID") == 0) {
        // THEMEID token just identifies unique ID for this theme set
      } else if (stricmp (token, "THEMEFILE") == 0) {
        // THEMENAME specifies a new theme; parse theme ID and filename
        token = strtok (NULL, delimiters);
        Tag tag = StringToTag (token);
        token = strtok (NULL, delimiters);
        themename[tag] = token;
      } else if (stricmp (token, "END") == 0) {
        // END token indicates end of the schema list
        break;
      } else {
        gtfo ("CFuiManager : Unknown token %s in master theme file %s",
          token, masterFilename);
      }        
      
      // Get next line
      pgets (s, 256, p);
    }  
    pclose (p);
  } else {
    gtfo ("CFuiManager : Cannot open master theme file %s", masterFilename);
  }

  // Load the individual themes
  map<Tag,string>::iterator i;
  for (i = themename.begin(); i != themename.end(); i++) {
    CFuiTheme *theme = new CFuiTheme (i->second.c_str());
    themeMap[i->first] = theme;
  }

  // Initialize text popups
  slew = new CFuiTextPopup;
  slew->SetText ("Slew");
  slew->SetPosition (globals->screenWidth - 60, globals->screenHeight - 40);

  pause = new CFuiTextPopup;
  pause->SetText ("Paused");
  pause->SetPosition (globals->screenWidth - 60, globals->screenHeight - 40);

  usermsg = new CFuiTextPopup;
  usermsg->SetPosition (12, globals->screenHeight - 40);
}

CFuiManager::~CFuiManager (void)
{
  // Delete themes
  map<Tag,CFuiTheme*>::iterator i;
  for (i=themeMap.begin(); i!=themeMap.end(); i++) {
    delete i->second;
  }

  // Delete special widgets
  delete slew;
  delete pause;
  delete usermsg;

  // @todo Close all open windows
}

void CFuiManager::CreateFuiWindow (FuiEventNoticeCb handler,
                                   Tag windowId,
                                   const char *winFilename)
{
  // Instantiate a new CFuiWindow object and add to the window map
  CFuiWindow *window = new CFuiWindow (winFilename, windowId, handler);
  windowMap[windowId] = window;

  // Send event notification to window handler
  GenerateEventNotice (windowId, windowId, EVENT_OPENWINDOW, EVENT_NOSUBEVENT);
}

void CFuiManager::DestroyFuiWindow (Tag windowId)
{
  CFuiWindow *window = GetFuiWindow (windowId);
  if (window != NULL) {
    // Send event notification to window handler
    GenerateEventNotice (windowId, windowId, EVENT_CLOSEWINDOW, EVENT_NOSUBEVENT);
    window->Close ();
  }
}

bool CFuiManager::IsWindowCreated (Tag windowId)
{
  // @todo : Change to find() lookup
  CFuiWindow *window = windowMap[windowId];
  return (window != NULL);
}


void CFuiManager::Draw (void)
{
  // Check for user message expiry
  if (userMsgActive) {
    if (globals->timemgr->GetElapsedSimTime() >= userMsgExpiry) {
      usermsg->SetText (NULL);
      userMsgActive = false;
    }
  }

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

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

  // Close any windows if necessary before drawing
  map <Tag,CFuiWindow*>::iterator i;
  for (i=windowMap.begin(); i!=windowMap.end(); i++) {
    CFuiWindow *window = i->second;

    if (window->GetState() == FUI_WINDOW_CLOSED) {
      // Window has been closed; delete and remove from window list
      delete window;
      windowMap.erase(i);
    }
  }

  // Draw windows
  i = windowMap.begin();
  while (i != windowMap.end()) {
    CFuiWindow *window = i->second;

    // Check to see if the window has been closed; if so, remove it
    EFuiWindowState state = window->GetState ();
    switch (state) {
    case FUI_WINDOW_INIT:
      // Window is still being initialized; do nothing until it is open
      i++;
      break;

    case FUI_WINDOW_OPEN:
    case FUI_WINDOW_MOVE:
      // Window is open; draw it
      window->Draw ();
      i++;
      break;

    case FUI_WINDOW_CLOSED:
      // Window has been closed; delete and remove from window list
      delete window;
      windowMap.erase(i);
      i = windowMap.begin();
      break;

    default:
      // Invalid state for drawing
      gtfo ("CFuiManager::Draw : Invalid window state %d", state);
    }
  }

  // Draw Slew / Pause indicator if applicable
  if (globals->slewmgr->IsEnabled()) {
    // Slew mode is enabled
    slew->Draw ();
  } else if (globals->timemgr->GetPauseState()) {
    // Sim is paused
    pause->Draw ();
  }

  // Draw user message
  usermsg->Draw ();

  // Restore original OpenGL state
  glPopAttrib();

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

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

CFuiTheme *CFuiManager::GetTheme (Tag tag)
{
  CFuiTheme *rc = NULL;

  map<Tag,CFuiTheme*>::iterator i = themeMap.find(tag);
  if (i != themeMap.end()) {
    rc = i->second;
  }

  return rc;
}

//
CFuiThemeWidget *CFuiManager::GetThemeWidget (Tag tag, string name)
{
  CFuiThemeWidget *rc = NULL;

  CFuiTheme *theme = GetTheme (tag);
  if (theme != NULL) {
    rc = theme->GetWidget (name);
  }

  return rc;
}

void CFuiManager::GenerateEventNotice (Tag windowId, Tag componentId,
                                       EFuiEvents event, EFuiEvents subevent)
{
  CFuiWindow *window = GetFuiWindow (windowId);
  if (window != NULL) {
    window->GenerateEventNotice (componentId, event, subevent);
  }
}


void CFuiManager::DrawNoticeToUser (const char *text, float timeout)
{
  usermsg->SetText (text);
  userMsgActive = true;
  userMsgExpiry = globals->timemgr->GetElapsedSimTime() + timeout;
}

void DrawNoticeToUser (const char* text, float timeout)
{
  globals->fuimgr->DrawNoticeToUser (text, timeout);
}

CFuiWindow *CFuiManager::GetFuiWindow (Tag tag)
{
  CFuiWindow *rc = NULL;

  map<Tag,CFuiWindow*>::iterator i = windowMap.find(tag);
  if (i != windowMap.end()) {
    rc = i->second;
  }

  return rc;
}

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

  // @todo Only send mouse motion to window in focus
  map<Tag,CFuiWindow*>::iterator i;
  for (i=windowMap.begin(); i!=windowMap.end() && !rc; i++) {
    CFuiWindow *window = i->second;
    rc = window->MouseMove (mx, my);
  }

  return rc;
}

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

  // @todo Send mouse click to window in focus
  map<Tag,CFuiWindow*>::iterator i;
  for (i=windowMap.begin(); i!=windowMap.end() && !rc; i++) {
    CFuiWindow *window = i->second;
    rc = window->MouseClick (mx, my, button);
  }

  return rc;
}

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

  // @todo Send mouse click to window in focus
  map<Tag,CFuiWindow*>::iterator i;
  for (i=windowMap.begin(); i!=windowMap.end() && !rc; i++) {
    CFuiWindow *window = i->second;
    rc = window->MouseStopClick (mx, my, button);
  }

  return rc;
}

void CFuiManager::SetComponentText (Tag window, Tag component, const char* text)
{
  CFuiWindow *w = GetFuiWindow (window);
  if (w != NULL) {
    CFuiComponent *c = w->GetComponent (component);
    if (c != NULL) {
      c->SetText (text);
    }
  }
}

void CFuiManager::SetWindowTitle (Tag window, const char* title)
{
  CFuiWindow *w = GetFuiWindow (window);
  if (w != NULL) {
    w->SetTitle (title);
  }
}

void CFuiManager::Print (FILE *f)
{
  map<Tag,CFuiTheme*>::iterator i;
  for (i=themeMap.begin(); i!=themeMap.end(); i++) {
    i->second->Print (f);
    fprintf (f, "\n");
  }
}

typedef struct {
  char                  *name;
  EFuiComponentTypes    type;
} SFuiNameLookup;

static SFuiNameLookup nameLookupTable[] =
{
  {"Window",               COMPONENT_WINDOW},
  {"Button",               COMPONENT_BUTTON},
  {"DoubleButton",         COMPONENT_DOUBLE_BUTTON},
  {"DefaultButton",        COMPONENT_DEFAULT_BUTTON},
  {"PopupMenu",            COMPONENT_POPUPMENU},
  {"MenuBar",              COMPONENT_MENUBAR},
  {"WindowMenuBar",        COMPONENT_WINDOW_MENUBAR},
  {"Menu",                 COMPONENT_MENU},
  {"CheckBox",             COMPONENT_CHECKBOX},
  {"RadioButton",          COMPONENT_RADIOBUTTON},
  {"Label",                COMPONENT_LABEL},
  {"Line",                 COMPONENT_LINE},
  {"Box",                  COMPONENT_BOX},
  {"Picture",              COMPONENT_PICTURE},
  {"Scrollbar",            COMPONENT_SCROLLBAR},
  {"Slider",               COMPONENT_SLIDER},
  {"Groupbox",             COMPONENT_GROUPBOX},
  {"Gauge",                COMPONENT_GAUGE},
  {"List",                 COMPONENT_LIST},
  {"ScrollArea",           COMPONENT_SCROLLAREA},
  {"TextField",            COMPONENT_TEXTFIELD},
  {"TextArea",             COMPONENT_TEXTAREA},
  {"Progress",             COMPONENT_PROGRESS},
  {"Map",                  COMPONENT_MAP},
  {"TabPage",              COMPONENT_TABPAGE},
  {"TabButton",            COMPONENT_TABBUTTON},
  {"TabControl",           COMPONENT_TABCONTROL},
  {"Graph",                COMPONENT_GRAPH},
  {"DLLView",              COMPONENT_DLLVIEW},
  {"Disclosure",           COMPONENT_DISCLOSURE},
  {"Canvas",               COMPONENT_CANVAS},
  {"RunwayCanvas",         COMPONENT_RUNWAY_CANVAS},
  {"Marquee",              COMPONENT_MARQUEE},
  {"HorizMarquee",         COMPONENT_HORIZ_MARQUEE},
  {"WindowNoResize",       COMPONENT_WINDOW_NORESIZE},
  {"WindowTitle",          COMPONENT_TITLE},
  {"PaletteWindow",        COMPONENT_PALETTE_WINDOW},
  {"PaletteWindowTitle",   COMPONENT_PALETTE_WINDOW_TITLE},
  {"WindowCloseButton",    COMPONENT_CLOSE_BUTTON},
  {"WindowMinimizeButton", COMPONENT_MINIMIZE_BUTTON},
  {"WindowZoomButton",     COMPONENT_ZOOM_BUTTON}
};

Tag CFuiManager::GetComponentType (const char *name)
{
  Tag rc = 0;

  int i;
  int n = sizeof(nameLookupTable) / sizeof(SFuiNameLookup);
  for (i=0; i<n; i++) {
    SFuiNameLookup *lkup = &nameLookupTable[i];
    if (strcmp (lkup->name, name) == 0) {
      // Found the name->type translation
      rc = lkup->type;
      break;
    }
  }

  if (rc == 0) {
    globals->logWarning->Write ("CFuiManager::GetComponentType : Unknown type %s", name);
  }
  return rc;
}

void CFuiManager::SetLabelColour (Tag window, Tag labelID, unsigned int colour)
{
  CFuiLabel *label = FindLabel (window, labelID);
  if (label != NULL) {
    label->SetColour (colour);
  }
}

int CFuiManager::GetCheckboxState(Tag windowID, Tag checkID)
{
  int rc = 0;
  
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (checkID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_CHECKBOX)) {
        CFuiCheckbox *checkbox = (CFuiCheckbox*)comp;
        rc = checkbox->GetState();
      }
    }  
  }
  return rc;
}
  
void CFuiManager::SetCheckboxState(Tag windowID, Tag checkID, int state)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (checkID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_CHECKBOX)) {
        CFuiCheckbox *checkbox = (CFuiCheckbox*)comp;
        checkbox->SetState(state);
      }
    }  
  }  
}

int CFuiManager::GetRadioState(Tag windowID, Tag radioID)
{
  int rc = 0;
  
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (radioID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_RADIOBUTTON)) {
        CFuiRadioButton *radio = (CFuiRadioButton*)comp;
        rc = radio->GetState();
      }
    }  
  }
  return rc;
}

void CFuiManager::SetRadioState(Tag windowID, Tag radioID, int state)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (radioID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_RADIOBUTTON)) {
        CFuiRadioButton *radio = (CFuiRadioButton*)comp;
        radio->SetState(state);
      }
    }  
  }
}

void CFuiManager::SetTextMaxChars(Tag windowID, Tag textID, int maxChars)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (textID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_TEXTFIELD)) {
        CFuiTextField *tf = (CFuiTextField*)comp;
        tf->SetMaxChars (maxChars);
      }
    }  
  }
}

int CFuiManager::GetTextMaxChars(Tag windowID, Tag textID)
{
  int rc = 0;
  
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (textID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_TEXTFIELD)) {
        CFuiTextField *tf = (CFuiTextField*)comp;
        rc = tf->GetMaxChars ();
      }
    }  
  }
  
  return rc;
}

void CFuiManager::UseTextPassword(Tag windowID, Tag textID, int passwordFlag)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (textID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_TEXTFIELD)) {
        CFuiTextField *tf = (CFuiTextField*)comp;
        tf->UsePassword (passwordFlag);
      }
    }  
  }
}

int CFuiManager::IsTextPassword(Tag windowID, Tag textID)
{
  int rc = 0;
  
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (textID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_TEXTFIELD)) {
        CFuiTextField *tf = (CFuiTextField*)comp;
        tf->IsPassword ();
      }
    }  
  }
  
  return rc;
}

int CFuiManager::GetTextLength(Tag windowID, Tag textID)
{
  int rc = 0;
  
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (textID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_TEXTFIELD)) {
        CFuiTextField *tf = (CFuiTextField*)comp;
        rc = tf->GetLength ();
      }
    }  
  }
  
  return rc;
}

void CFuiManager::SetTextText(Tag windowID, Tag textID, char *text)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (textID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_TEXTFIELD)) {
        CFuiTextField *tf = (CFuiTextField*)comp;
        tf->SetText (text);
      }
    }  
  }
}

char* CFuiManager::GetTextText(Tag windowID, Tag textID)
{
  char *rc = NULL;
  
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (textID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_TEXTFIELD)) {
        CFuiTextField *tf = (CFuiTextField*)comp;
        rc = tf->GetText ();
      }
    }  
  }
  return rc;
}

void CFuiManager::SetTextSelection(Tag windowID, Tag textID, int firstChar, int lastChar)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (textID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_TEXTFIELD)) {
        CFuiTextField *tf = (CFuiTextField*)comp;
        tf->SetSelection (firstChar, lastChar);
      }
    }  
  }
}

void CFuiManager::GetTextSelection(Tag windowID, Tag textID, int *firstChar, int *lastChar)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (textID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_TEXTFIELD)) {
        CFuiTextField *tf = (CFuiTextField*)comp;
        tf->GetSelection (firstChar, lastChar);
      }
    }  
  }
}

void CFuiManager::AddPopupItem (Tag windowID, Tag popupID, Tag itemID, const char *label)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (popupID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_POPUPMENU)) {
        CFuiPopupMenu *pm = (CFuiPopupMenu*)comp;
        pm->AddItem (itemID, label);
      }
    }  
  }
}

void CFuiManager::AddPopupSeperator (Tag windowID, Tag popupID)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (popupID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_POPUPMENU)) {
        CFuiPopupMenu *pm = (CFuiPopupMenu*)comp;
        pm->AddSeparator ();
      }
    }  
  }
}

void CFuiManager::RemovePopupItem (Tag windowID, Tag popupID, Tag itemID)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (popupID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_POPUPMENU)) {
        CFuiPopupMenu *pm = (CFuiPopupMenu*)comp;
        pm->RemoveItem (itemID);
      }
    }  
  }
}

void CFuiManager::ClearPopupItems (Tag windowID, Tag popupID)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (popupID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_POPUPMENU)) {
        CFuiPopupMenu *pm = (CFuiPopupMenu*)comp;
        pm->ClearItems ();
      }
    }  
  }
}

void CFuiManager::SelectPopupItem (Tag windowID, Tag popupID, Tag itemID)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (popupID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_POPUPMENU)) {
        CFuiPopupMenu *pm = (CFuiPopupMenu*)comp;
        pm->SelectItem (itemID);
      }
    }  
  }
}

Tag CFuiManager::GetPopupItemSelection(Tag windowID, Tag popupID, char *outText)
{
  Tag rc = 0;

  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (popupID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_POPUPMENU)) {
        CFuiPopupMenu *pm = (CFuiPopupMenu*)comp;
        rc = pm->GetItemSelection (outText);
      }
    }  
  }

  return rc;
}

void CFuiManager::SetGroupBoxLabel (Tag windowID, Tag groupID, char *label)
{
  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    CFuiComponent *comp = window->GetComponent (groupID);
    if (comp != NULL) {
      if (comp->IsType(COMPONENT_GROUPBOX)) {
        CFuiGroupBox *gb = (CFuiGroupBox*)comp;
        gb->SetText (label);
      }
    }  
  }
}

void CFuiManager::SetSliderMajorTickSpacing (Tag windowID, Tag sliderID, float spacing)
{
  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    slider->SetMajorTickSpacing (spacing);
  }
}

void CFuiManager::SetSliderMinorTickSpacing (Tag windowID, Tag sliderID, float spacing)
{
  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    slider->SetMinorTickSpacing (spacing);
  }
}

void CFuiManager::SetSliderSnapToTicks (Tag windowID, Tag sliderID, int snapFlag)
{
  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    slider->SetSnapToTicks (snapFlag);
  }
}

void CFuiManager::SetSliderDrawMajorTicks (Tag windowID, Tag sliderID, int drawFlag)
{
  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    slider->SetDrawMajorTicks (drawFlag);
  }
}

void CFuiManager::SetSliderDrawMinorTicks (Tag windowID, Tag sliderID, int drawFlag)
{
  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    slider->SetDrawMinorTicks (drawFlag);
  }
}

float CFuiManager::GetSliderMajorTickSpacing (Tag windowID, Tag sliderID)
{
  float rc = 0;

  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    rc = slider->GetMajorTickSpacing ();
  }

  return rc;
}

float CFuiManager::GetSliderMinorTickSpacing (Tag windowID, Tag sliderID)
{
  float rc = 0;

  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    rc = slider->GetMinorTickSpacing ();
  }

  return rc;
}

int CFuiManager::GetSliderSnapToTicks (Tag windowID, Tag sliderID)
{
  int rc = 0;

  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    rc = slider->GetSnapToTicks ();
  }

  return rc;
}

int CFuiManager::GetSliderDrawMajorTicks (Tag windowID, Tag sliderID)
{
  int rc = 0;

  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    rc = slider->GetDrawMajorTicks ();
  }

  return rc;
}

int CFuiManager::GetSliderDrawMinorTicks (Tag windowID, Tag sliderID)
{
  int rc = 0;

  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    rc = slider->GetDrawMinorTicks ();
  }

  return rc;
}

void CFuiManager::ScrollListToRow (Tag windowID, Tag listID, int row)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->ScrollToRow (row);
  }
}

void CFuiManager::ScrollListToColumn (Tag windowID, Tag listID, int column)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->ScrollToColumn (column);
  }
}

int CFuiManager::GetListRowCount (Tag windowID, Tag listID)
{
  int rc = 0;

  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    rc = list->GetRowCount ();
  }

  return rc;
}

int CFuiManager::GetListColumnCount (Tag windowID, Tag listID)
{
  int rc = 0;

  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    rc = list->GetColumnCount ();
  }

  return rc;
}

void CFuiManager::AddListColumn (Tag windowID, Tag listID, int width, char *title)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->AddColumn (width, title);
  }
}

void CFuiManager::DeleteListColumn (Tag windowID, Tag listID, int column)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->DeleteColumn (column);
  }
}

void CFuiManager::DeleteAllListColumns (Tag windowID, Tag listID)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->DeleteAllColumns ();
  }
}

void CFuiManager::SetListColumnWidth (Tag windowID, Tag listID, int column, int width)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->SetColumnWidth (column, width);
  }
}

void CFuiManager::AddListRow (Tag windowID, Tag listID, int height)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->AddRow (height);
  }
}

void CFuiManager::DeleteListRow (Tag windowID, Tag listID, int row)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->DeleteRow (row);
  }
}

void CFuiManager::DeleteAllListRows (Tag windowID, Tag listID)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->DeleteAllRows ();
  }
}

int CFuiManager::CountListSelectedRows (Tag windowID, Tag listID)
{
  int rc = 0;

  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    rc = list->CountSelectedRows ();
  }

  return rc;
}

int CFuiManager::GetListSelectedRow (Tag windowID, Tag listID, int index)
{
  int rc = 0;

  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    rc = list->GetSelectedRow (index);
  }

  return rc;
}

void CFuiManager::SelectListRow (Tag windowID, Tag listID, int row)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->SelectRow (row);
  }
}

void CFuiManager::ClearListSelection (Tag windowID, Tag listID)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->ClearSelection ();
  }
}

void CFuiManager::SetListCellText (Tag windowID, Tag listID, int row, int column, char *text)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->SetCellText (row, column, text);
  }
}

void CFuiManager::SetListCellIcon (Tag windowID, Tag listID, int row, int column, char *filename)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->SetCellIcon (row, column, filename);
  }
}

void CFuiManager::ClearListCellText (Tag windowID, Tag listID, int row, int column)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->ClearCellText (row, column);
  }
}

void CFuiManager::ClearListCellIcon (Tag windowID, Tag listID, int row, int column)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->ClearCellIcon (row, column);
  }
}

void CFuiManager::GetListCellText (Tag windowID, Tag listID, int row, int column, char *outtext)
{
  CFuiList *list = FindList (windowID, listID);
  if (list != NULL) {
    list->GetCellText (row, column, outtext);
  }
}


void CFuiManager::SetSliderLabel (Tag windowID, Tag sliderID, char *label)
{
  CFuiSlider *slider = FindSlider (windowID, sliderID);
  if (slider != NULL) {
    slider->SetText (label);
  }
}

void CFuiManager::AddGraphTrace (Tag windowID, Tag graphID, Tag traceID, int traceType)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->AddTrace (traceID, traceType);
  }
}

void CFuiManager::RemoveGraphTrace (Tag windowID, Tag graphID, Tag traceID)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->RemoveTrace (traceID);
  }
}

void CFuiManager::RemoveAllGraphTraces (Tag windowID, Tag graphID)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->RemoveAllTraces ();
  }
}

void CFuiManager::AddGraphTracePoint (Tag windowID, Tag graphID, Tag traceID,
                                      float x, float y)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->AddTracePoint (traceID, x, y);
  }
}

void CFuiManager::ClearGraphTracePoints (Tag windowID, Tag graphID, Tag traceID)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->ClearTracePoints (traceID);
  }
}

void CFuiManager::SetGraphTraceRange (Tag windowID, Tag graphID, Tag traceID,
                                      float minX, float minY, float maxX, float maxY)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->SetTraceRange (traceID, minX, minY, maxX, maxY);
  }
}

void CFuiManager::SetGraphTraceColour (Tag windowID, Tag graphID, Tag traceID,
                                       unsigned int colour)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->SetTraceColour (traceID, colour);
  }
}

void CFuiManager::SetGraphUseGrid (Tag windowID, Tag graphID, int useGrid)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->SetUseGrid (useGrid);
  }
}

void CFuiManager::SetGraphGridRange (Tag windowID, Tag graphID,
                                     float minX, float minY, float maxX, float maxY)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->SetGridRange (minX, minY, maxX, maxY);
  }
}

void CFuiManager::SetGraphGridSpacing (Tag windowID, Tag graphID,
                                       float stepX, float stepY)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->SetGridSpacing (stepX, stepY);
  }
}

void CFuiManager::SetGridColour (Tag windowID, Tag graphID,
                                 unsigned int colour)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->SetGridColour (colour);
  }
}

void CFuiManager::SetGridBackColour (Tag windowID, Tag graphID,
                                     unsigned int colour)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->SetGridBackColour (colour);
  }
}

void CFuiManager::GetGraphGridRange (Tag windowID, Tag graphID,
                                     float *minX, float *minY, float *maxX, float *maxY)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->GetGridRange (minX, minY, maxX, maxY);
  }
}

void CFuiManager::GetGraphGridSpacing (Tag windowID, Tag graphID,
                                       float *stepX, float *stepY)
{
  CFuiGraph *graph = FindGraph (windowID, graphID);
  if (graph != NULL) {
    graph->GetGridSpacing (stepX, stepY);
  }
}


//
// Protected methods
//

CFuiComponent* CFuiManager::FindComponent (Tag windowID, Tag id)
{
  CFuiComponent *rc = NULL;

  CFuiWindow *window = GetFuiWindow (windowID);
  if (window != NULL) {
    rc = window->GetComponent (id);
  }

  return rc;
}

CFuiLabel* CFuiManager::FindLabel (Tag windowID, Tag labelID)
{
  CFuiLabel *rc = NULL;

  CFuiComponent *comp = FindComponent (windowID, labelID);
  if (comp != NULL) {
    if (comp->IsType(COMPONENT_LABEL)) {
      rc = (CFuiLabel *)comp;
    }
  }

  return rc;
}

CFuiCheckbox* CFuiManager::FindCheckbox (Tag windowID, Tag checkboxID)
{
  CFuiCheckbox *rc = NULL;

  CFuiComponent *comp = FindComponent (windowID, checkboxID);
  if (comp != NULL) {
    if (comp->IsType(COMPONENT_CHECKBOX)) {
      rc = (CFuiCheckbox *)comp;
    }
  }

  return rc;
}

CFuiSlider* CFuiManager::FindSlider (Tag windowID, Tag sliderID)
{
  CFuiSlider *rc = NULL;

  CFuiComponent *comp = FindComponent (windowID, sliderID);
  if (comp != NULL) {
    if (comp->IsType(COMPONENT_SLIDER)) {
      rc = (CFuiSlider *)comp;
    }
  }

  return rc;
}

CFuiList* CFuiManager::FindList (Tag windowID, Tag listID)
{
  CFuiList *rc = NULL;

  CFuiComponent *comp = FindComponent (windowID, listID);
  if (comp != NULL) {
    if (comp->IsType(COMPONENT_LIST)) {
      rc = (CFuiList *)comp;
    }
  }

  return rc;
}

CFuiGraph* CFuiManager::FindGraph (Tag windowID, Tag graphID)
{
  CFuiGraph *rc = NULL;

  CFuiComponent *comp = FindComponent (windowID, graphID);
  if (comp != NULL) {
    if (comp->IsType(COMPONENT_GRAPH)) {
      rc = (CFuiGraph *)comp;
    }
  }

  return rc;
}

Documentation generated by