Menu.cpp

Go to the documentation of this file.

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


static void toggle_window (FuiEventNoticeCb handler, Tag id, const char* winFilename)
{
  if (globals->fuimgr) {
    if (globals->fuimgr->IsWindowCreated (id)) {
      // Destroy
      globals->fuimgr->DestroyFuiWindow (id);
    } else {
      // Create
      globals->fuimgr->CreateFuiWindow (handler, id, winFilename);
    }
  }
}

//
// Local helper function to open a FUI window in response to a menu action.
//   If the window is already open then nothing is done.
//
static void open_window (FuiEventNoticeCb handler, Tag id, const char* winFilename)
{
  if (globals->fuimgr) {
    if (!globals->fuimgr->IsWindowCreated (id)) {
      // Create
      globals->fuimgr->CreateFuiWindow (handler, id, winFilename);
    }
  }
}

//
// Local helper function to close a FUI window if it is open
//
static void close_window (Tag id)
{
  if (globals->fuimgr) {
    if (globals->fuimgr->IsWindowCreated (id)) {
      globals->fuimgr->DestroyFuiWindow (id);
    }
  }
}

//
// UI notification function for File->Load window.
//
void FileLoadEventNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
  switch (event) {
  case EVENT_OPENWINDOW:
    globals->fuimgr->SetWindowTitle (id, "Load Situation");
    break;

  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'okok':
      // OK
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'canc':
      // Close window without exiting program
      globals->fuimgr->DestroyFuiWindow (id);
    }
    break;

  default:
    // Do nothing
    ;
  }
}


//
// UI notification function for File->Save window.
//
void FileSaveEventNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
  switch (event) {
  case EVENT_OPENWINDOW:
    globals->fuimgr->SetWindowTitle (id, "Save Situation");
    break;

  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'okok':
      // OK
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'canc':
      // Close window without exiting program
      globals->fuimgr->DestroyFuiWindow (id);
    }
    break;

  default:
    // Do nothing
    ;
  }
}


//
// UI notification function for File->SaveAs window.
//
void FileSaveAsEventNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
  switch (event) {
  case EVENT_OPENWINDOW:
    globals->fuimgr->SetWindowTitle (id, "Save Situation As");
    break;

  case EVENT_CLOSEWINDOW:
    DrawNoticeToUser ("Close File SaveAs", 5);
    break;

  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'okok':
      // OK
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'canc':
      // Close window without exiting program
      globals->fuimgr->DestroyFuiWindow (id);
    }
    break;

  default:
    // Do nothing
    ;
  }
}


//
// UI notification function for File->Quit window.
//
void FileQuitEventNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
  switch (event) {
  case EVENT_OPENWINDOW:
    globals->fuimgr->SetWindowTitle (id, "Confirm Program Quit");
    globals->fuimgr->SetComponentText (id, 'mesg',
                                       "Are you sure you want to quit?");
    break;

  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'okok':
      // Quit gracefully by setting application mode.  This will cause shutdown
      //   on the next redraw() cycle
      globals->appState = APP_EXIT_SCREEN;
      break;

    case 'canc':
      // Close window without exiting program
      globals->fuimgr->DestroyFuiWindow (id);
    }
    break;

  default:
    // Do nothing
    ;
  }
}


//
// File Menu
//
void file_load_situation_cb (puObject* obj)
{
  open_window (FileLoadEventNotify,
               FUI_WINDOW_SITUATION_LOAD,
               "UI\\TEMPLATES\\OPENFILE.WIN");
}

void file_save_situation_cb (puObject* obj)
{
  open_window (FileSaveEventNotify,
               FUI_WINDOW_SITUATION_SAVE,
               "UI\\TEMPLATES\\OPENFILE.WIN");
}

void file_save_situation_as_cb (puObject* obj)
{
  open_window (FileSaveAsEventNotify,
               FUI_WINDOW_SITUATION_SAVE_AS,
               "UI\\TEMPLATES\\OPENFILE.WIN");
}

void file_quit_cb (puObject* obj)
{
  open_window (FileQuitEventNotify,
               FUI_WINDOW_QUIT, 
               "UI\\TEMPLATES\\YESNO.WIN");
}

char *file_legends[] =
{
  "Quit",
  "--------------------",
  "Save Situation As...",
  "Save Situation...",
  "Load Situation...",
  NULL
};

puCallback file_cb[] =
{
  file_quit_cb,
  NULL,
  file_save_situation_as_cb,
  file_save_situation_cb,
  file_load_situation_cb,
  NULL
};


//
// Options menu
//
void options_mute_cb (puObject* obj)
{
  DrawNoticeToUser ("Options -> Mute", 5);
}

void options_pause_cb (puObject* obj)
{
  if (globals->timemgr->GetPauseState ()) {
    globals->timemgr->Pause ();
  } else {
    globals->timemgr->Unpause ();
  }
}

static void OptionsSceneryNotify (Tag id,
                                  Tag component,
                                  EFuiEvents event,
                                  EFuiEvents subevent)
{
  switch (event) {
  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'okok':
      // OK button
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'canc':
      // Cancel
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    default:
      {
        // Debug : Display button ID
        char s[8];
        char debug[80];
        TagToString (s, component);
        sprintf (debug, "Button : %s", s);
        DrawNoticeToUser (debug, 3);
      }
    }
    break;

  default:
    // Do nothing
    ;
  }
}

void options_scenery_cb (puObject* obj)
{
  open_window (OptionsSceneryNotify,
               FUI_WINDOW_OPTIONS_SCENERY,
               "UI\\TEMPLATES\\SCENERY.WIN");
}

static void OptionsRealismNotify (Tag id,
                                  Tag component,
                                  EFuiEvents event,
                                  EFuiEvents subevent)
{
  switch (event) {
  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'okok':
      // OK button
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'canc':
      // Cancel
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    default:
      {
        // Debug : Display button ID
        char s[8];
        char debug[80];
        TagToString (s, component);
        sprintf (debug, "Button : %s", s);
        DrawNoticeToUser (debug, 3);
      }
    }
    break;

  default:
    // Do nothing
    ;
  }
}

void options_realism_cb (puObject* obj)
{
  open_window (OptionsRealismNotify,
               FUI_WINDOW_OPTIONS_REALISM,
               "UI\\TEMPLATES\\REALISM.WIN");
}

static void OptionsStartupNotify (Tag id,
                                  Tag component,
                                  EFuiEvents event,
                                  EFuiEvents subevent)
{
  switch (event) {
  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'okok':
      // OK button
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'canc':
      // Cancel
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    default:
      {
        // Debug : Display button ID
        char s[8];
        char debug[80];
        TagToString (s, component);
        sprintf (debug, "Button : %s", s);
        DrawNoticeToUser (debug, 3);
      }
    }
    break;

  default:
    // Do nothing
    ;
  }
}

void options_startup_cb (puObject* obj)
{
  open_window (OptionsStartupNotify,
               FUI_WINDOW_OPTIONS_STARTUP,
               "UI\\TEMPLATES\\STARTUP.WIN");
}

static void OptionsCockpitNotify (Tag id,
                                  Tag component,
                                  EFuiEvents event,
                                  EFuiEvents subevent)
{
  char s[8];
  char debug[80];

  switch (event) {
  case EVENT_BUTTONPRESSED:
    // Dump button names
    TagToString (s, component);
    sprintf (debug, "Button : %s", s);
    DrawNoticeToUser (debug, 3);
    break;

  default:
    // Do nothing
    ;
  }
}

void options_cockpit_cb (puObject* obj)
{
  open_window (OptionsCockpitNotify,
               FUI_WINDOW_OPTIONS_COCKPIT,
               "UI\\TEMPLATES\\COCKPIT.WIN");
}

static void OptionsTestControlsNotify (Tag id,
                                       Tag component,
                                       EFuiEvents event,
                                       EFuiEvents subevent)
{
  switch (event) {
  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'dump':
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    default:
      {
        // Debug : Display button ID
        char s[8];
        char debug[80];
        TagToString (s, component);
        sprintf (debug, "Button : %s", s);
        DrawNoticeToUser (debug, 3);
      }
    }
    break;

  default:
    // Do nothing
    ;
  }
}

void options_test_controls_cb (puObject* obj)
{
  open_window (OptionsTestControlsNotify,
               FUI_WINDOW_OPTIONS_TEST_CONTROLS,
               "UI\\TEMPLATES\\TESTCONTROLS.WIN");
}

static void OptionsSetupAxesNotify (Tag id,
                                    Tag component,
                                    EFuiEvents event,
                                    EFuiEvents subevent)
{
  switch (event) {
  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'test':
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'clra':
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'defa':
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    default:
      {
        // Debug : Display button ID
        char s[8];
        char debug[80];
        TagToString (s, component);
        sprintf (debug, "Button : %s", s);
        DrawNoticeToUser (debug, 3);
      }
    }
    break;

  default:
    // Do nothing
    ;
  }
}

void options_setup_axes_cb (puObject* obj)
{
  open_window (OptionsSetupAxesNotify, 'axes', "UI\\TEMPLATES\\AXES.WIN");
}

static void OptionsKeysButtonsNotify (Tag id,
                                      Tag component,
                                      EFuiEvents event,
                                      EFuiEvents subevent)
{
  switch (event) {
  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'clrk':
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'clrb':
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'defk':
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'defb':
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    default:
      {
        // Debug : Display button ID
        char s[8];
        char debug[80];
        TagToString (s, component);
        sprintf (debug, "Button : %s", s);
        DrawNoticeToUser (debug, 3);
      }
    }
    break;

  default:
    // Do nothing
    ;
  }
}

void options_keys_buttons_cb (puObject* obj)
{
  open_window (OptionsKeysButtonsNotify,
               FUI_WINDOW_OPTIONS_KEYS_BUTTONS,
               "UI\\TEMPLATES\\KEYS.WIN");
}

static void OptionsDateTimeNotify (Tag id,
                                   Tag component,
                                   EFuiEvents event,
                                   EFuiEvents subevent)
{
  switch (event) {
  case EVENT_OPENWINDOW:
    break;

  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'okok':
      // Set new date/time

      // Close window
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'canc':
      // Close window without exiting program
      globals->fuimgr->DestroyFuiWindow (id);
    }
    break;

  default:
    // Do nothing
    ;
  }
}

void options_date_time_cb (puObject* obj)
{
  open_window (OptionsDateTimeNotify,
               FUI_WINDOW_OPTIONS_DATE_TIME,
               "UI\\TEMPLATES\\DATETIME.WIN");
}

static void OptionsSoundsNotify (Tag id,
                                 Tag component,
                                 EFuiEvents event,
                                 EFuiEvents subevent)
{
  switch (event) {
  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'okok':
      // OK button
      globals->fuimgr->DestroyFuiWindow (id);
      break;

    case 'canc':
      // Close window without exiting program
      globals->fuimgr->DestroyFuiWindow (id);
      break;
    }
    break;

  default:
    // Do nothing
    ;
  }
}

void options_sound_cb (puObject* obj)
{
  open_window (OptionsSoundsNotify,
               FUI_WINDOW_OPTIONS_SOUND,
               "UI\\TEMPLATES\\SOUNDS.WIN");
}

char *options_legends[] =
{
  "Mute",
  "--------------------",
  "Pause",
  "--------------------",
  "Scenery...",
  "Realism...",
  "--------------------",
  "Startup...",
  "--------------------",
  "Cockpit...",
  "--------------------",
  "Test Controls...",
  "Setup Axes...",
  "Keys & Buttons...",
  "--------------------",
  "Date & Time...",
  "Sound...",
  NULL
};

puCallback options_cb[] =
{
  options_mute_cb,
  NULL,
  options_pause_cb,
  NULL,
  options_scenery_cb,
  options_realism_cb,
  NULL,
  options_startup_cb,
  NULL,
  options_cockpit_cb,
  NULL,
  options_test_controls_cb,
  options_setup_axes_cb,
  options_keys_buttons_cb,
  NULL,
  options_date_time_cb,
  options_sound_cb,
  NULL
};


//
// QuickFlight menu
//
static void AdventuresNotify (Tag id,
                              Tag component,
                              EFuiEvents event,
                              EFuiEvents subevent)
{
}

void quickflight_adventures_cb (puObject* obj)
{
  open_window (AdventuresNotify,
               FUI_WINDOW_ADVENTURES,
               "UI\\TEMPLATES\\ADVENTURES.WIN");
}

static void QuickFlightNotify (Tag id,
                               Tag component,
                               EFuiEvents event,
                               EFuiEvents subevent)
{
}

void quickflight_quickflight_cb (puObject* obj)
{
  open_window (QuickFlightNotify,
               FUI_WINDOW_QUICKFLIGHT,
               "UI\\TEMPLATES\\QUICKFLIGHT.WIN");
}

char *quickflight_legends[] =
{
  "Adventures...",
  "QuickFlight...",
  NULL
};

puCallback quickflight_cb[] =
{
  quickflight_adventures_cb,
  quickflight_quickflight_cb,
  NULL
};


//
// Flight Plan menu
//
void flightplan_logbook_cb (puObject* obj)
{
  DrawNoticeToUser ("Aircraft -> Log Book", 5);
}

void flightplan_checklist_cb (puObject* obj)
{
  DrawNoticeToUser ("Aircraft -> Checklist", 5);
}

void flightplan_navlog_cb (puObject* obj)
{
  DrawNoticeToUser ("Aircraft -> Navigation Log", 5);
}

void flightplan_directory_cb (puObject* obj)
{
  DrawNoticeToUser ("Aircraft -> Directory", 5);
}

void flightplan_waypoint_cb (puObject* obj)
{
  DrawNoticeToUser ("Aircraft -> Current Waypoint", 5);
}

void flightplanner_cb (puObject* obj)
{
  DrawNoticeToUser ("Aircraft -> Flight Planner", 5);
}

char *flightplan_legends[] =
{
  "Log Book...",
  "--------------------",
  "Check List...",
  "Navigation Log...",
  "--------------------",
  "Directory...",
  "Current Waypoint...",
  "--------------------",
  "Flight Planner...",
  NULL
};

puCallback flightplan_cb[] =
{
  flightplan_logbook_cb,
  NULL,
  flightplan_checklist_cb,
  flightplan_navlog_cb,
  NULL,
  flightplan_directory_cb,
  flightplan_waypoint_cb,
  NULL,
  flightplanner_cb,
  NULL
};


//
// Aircraft menu
//
void aircraft_slew_cb (puObject* obj)
{
  CSlewManager *slew = globals->slewmgr;
  if (slew->IsEnabled ()) {
    slew->Disable ();
  } else {
    slew->Enable ();
  }
}

void LatArcsecToDMS (double lat, bool &n, float &d, float &m, float &s)
{
  if (lat >= 0) {
    n = true;
  } else {
    n = false;
    lat = -lat;
  }

  d = floor (lat / 3600.0);
  lat -= (d * 3600.0);
  m = floor (lat / 60.0);
  lat -= (m * 60.0);
  s = lat;
}

void LonArcsecToDMS (double lon, bool &w, float &d, float &m, float &s)
{
  if (lon >= (180.0 * 3600.0)) {
    w = true;
    lon = (360.0 * 3600.0) - lon;
  } else {
    w = false;
  }

  d = floor (lon / 3600.0);
  lon -= (d * 3600.0);
  m = floor (lon / 60.0);
  lon -= (m * 60.0);
  s = lon;
}

void TeleportDirectoryNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
  CFuiManager *fui = globals->fuimgr;

  switch (event) {
  case EVENT_OPENWINDOW:
    {
      // Populate waypoint type popup menu
      fui->AddPopupItem (id, 'type', ENTRY_AIRPORT, "Airport");
      fui->AddPopupItem (id, 'type', ENTRY_NAVAID, "Navaid");
      fui->AddPopupItem (id, 'type', ENTRY_WAYPOINT, "Waypoint");
      fui->SelectPopupItem (id, 'type', ENTRY_AIRPORT);

      // Get default country and state from INI settings
      char sCountry[256];
      char sCountryKey[8];
      memset (sCountry, 0, 256);
      memset (sCountryKey, 0, 8);
      GetIniString ("UI", "defaultSearchCountry", sCountry, 256);

      char sState[256];
      memset (sState, 0, 256);
      GetIniString ("UI", "defaultSearchState", sState, 256);

      unsigned int iCountry = 0;

      // Populate country list
      unsigned long nCountries = dbCountry->GetNumRecords ();
      fui->AddListColumn (id, 'clst', -1, "Country");
      for (unsigned long i=0; i<nCountries; i++) {
        CDatabaseRecord *record = dbCountry->GetRecordByIndex (i);
        if (record != NULL) {
          CDatabaseField *field = record->GetField (1);
          if (field != NULL) {
            fui->AddListRow (id, 'clst', 12);
            fui->SetListCellText (id, 'clst', i, 0, field->data.charData);

            if (stricmp (sCountry, field->data.charData) == 0) {
              iCountry = i;
              
              // Get key field to lookup states
              CDatabaseField *fCountry = record->GetField (0);
              if (fCountry != NULL) {
                strcpy (sCountryKey, fCountry->data.charData);
              }
            }
          }
        }
      }
      fui->ScrollListToRow (id, 'clst', iCountry);
      fui->SelectListRow (id, 'clst', iCountry);

      fui->DeleteAllListRows (id, 'slst');
      fui->DeleteAllListColumns (id, 'slst');
      fui->AddListColumn (id, 'slst', -1, "State");

      int iState = 0;
      unsigned long offset = dbState->Search ('sctr', sCountryKey);
      while (offset != 0) {
        // Get database record
        CDatabaseRecord *record = dbState->GetRecordByOffset (offset);
        CDatabaseField *f = record->GetField (3);
        if (f != NULL) {
          fui->AddListRow (id, 'slst', 12);
          fui->SetListCellText (id, 'slst', iState, 0, f->data.charData);
        }

        // Advance to next record
        offset = dbState->SearchNext ();
        iState++;
      }
    }
    break;

  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'warp':    // Teleport
      {
        DrawNoticeToUser ("Waypoint teleports", 5);
      }
      break;
    case 'wsel':    // Select
      {
        DrawNoticeToUser ("Waypoint select", 5);
      }
      break;
    case 'detl':    // Details
      {
        DrawNoticeToUser ("Waypoint details", 5);
      }
      break;
    case 'srch':    // Search
      {
        DrawNoticeToUser ("Waypoint search", 5);
      }
      break;
    }

  default:
    // Do nothing
    ;
  }
}

void TeleportAlertNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
  CFuiManager *fui = globals->fuimgr;

  switch (event) {
  case EVENT_OPENWINDOW:
    // Set alert message
    fui->SetComponentText (id, 'mesg', "Teleporting...please wait");
    break;

  default:
    // Do nothing
    ;
  }
}

void AircraftTeleportNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
  CVehicleObject *user = globals->sit->GetUserVehicle ();
  CFuiManager *fui = globals->fuimgr;

  DrawNoticeToUser ("Teleport event", 1);
  char t[8];
  TagToString (t, component);
      
  switch (event) {
  case EVENT_OPENWINDOW:
    {
      // Set current lat/lon position text fields and initialize radio buttons
      SPosition pos = user->GetPosition();
      bool hemi;
      float d, m, s;

      // Populate latitude widgets
      LatArcsecToDMS (pos.lat, hemi, d, m, s);
      char latd[8];
      sprintf (latd, "%02.0f", d);
      char latm[8];
      sprintf (latm, "%02.0f", m);
      char lats[8];
      sprintf (lats, "%02.0f", s);

      if (hemi) {
        // Northern hemisphere
        fui->SetRadioState (id, 'dirN', 1);
        fui->SetRadioState (id, 'dirS', 0);
      } else {
        // Southern hemisphere
        fui->SetRadioState (id, 'dirN', 0);
        fui->SetRadioState (id, 'dirS', 1);
      }
      fui->SetTextText (id, 'lath', latd);
      fui->SetTextText (id, 'latm', latm);
      fui->SetTextText (id, 'lats', lats);

      // Populate longitude widgets
      LonArcsecToDMS (pos.lon, hemi, d, m, s);
      char lond[8];
      sprintf (lond, "%02.0f", d);
      char lonm[8];
      sprintf (lonm, "%02.0f", m);
      char lons[8];
      sprintf (lons, "%2.0f", s);

      fui->SetTextText (id, 'lonh', lond);
      fui->SetTextText (id, 'lonm', lonm);
      fui->SetTextText (id, 'lons', lons);

      if (hemi) {
        // Western hemisphere
        fui->SetRadioState (id, 'dirE', 0);
        fui->SetRadioState (id, 'dirW', 1);
      } else {
        // Eastern hemisphere
        fui->SetRadioState (id, 'dirE', 1);
        fui->SetRadioState (id, 'dirW', 0);
      }
    }
    break;

  case EVENT_CHECKED:
    switch (component) {
      case 'dirN':
        // N latitude radio button
        fui->SetRadioState (id, 'dirS', 0);
        break;
      case 'dirS':
        // S latitude radio button
        fui->SetRadioState (id, 'dirN', 0);
        break;
      case 'dirW':
        // W longitude radio button
        fui->SetRadioState (id, 'dirE', 0);
        break;
      case 'dirE':
        // E longitude radio button
        fui->SetRadioState (id, 'dirW', 0);
        break;
    }  
    break;
    
  case EVENT_BUTTONPRESSED:
    switch (component) {
    case 'okok':
    {
      // Get new position
      SPosition pos = user->GetPosition();
      float d, m, s;
      char t[8];
      strcpy (t, fui->GetTextText (id, 'lath'));
      d = atof (t);
      strcpy (t, fui->GetTextText (id, 'latm'));
      m = atof (t);
      strcpy (t, fui->GetTextText (id, 'lats'));
      s = atof (t);
      pos.lat = (d * 3600.0) + (m * 60.0) + s;
      if (fui->GetRadioState (id, 'dirS') != 0) {
        // S hemisphere
        pos.lat = -pos.lat;
      }

      strcpy (t, fui->GetTextText (id, 'lonh'));
      d = atof (t);
      strcpy (t, fui->GetTextText (id, 'lonm'));
      m = atof (t);
      strcpy (t, fui->GetTextText (id, 'lons'));
      s = atof (t);
      pos.lon = (d * 3600.0) + (m * 60.0) + s;
      if (fui->GetRadioState (id, 'dirW') != 0) {
        // W hemisphere
        pos.lon = (360.0 * 3600.0) - pos.lon;
      }

      // Leave altitude (which is feet AGL) unchanged.

      // Create "Teleporting..." dialog
      open_window (TeleportAlertNotify,
                   FUI_WINDOW_TELEPORT_ALERT,
                   "UI\\TEMPLATES\\ALERT.WIN");

      // Display user message
      DrawNoticeToUser ("Teleporting...", 5);

      // Set user position
      user->SetPosition (pos);

      // Destroy "Teleporting..." dialog
      close_window (id);
    }
    break;

    case 'dirc':
      // Create airport directory dialog
      open_window (TeleportDirectoryNotify,
                   FUI_WINDOW_TELEPORT_DIRECTORY,
                   "UI\\TEMPLATES\\WAYPTDIR.WIN");
      break;
    }
    break;

  default:
    // Do nothing
    ;
  }
}

void aircraft_teleport_cb (puObject* obj)
{
  open_window (AircraftTeleportNotify,
               FUI_WINDOW_TELEPORT,
               "UI\\TEMPLATES\\TELEPORT.WIN");
}

void AircraftOptionsNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void aircraft_options_cb (puObject* obj)
{
  open_window (AircraftOptionsNotify,
               FUI_WINDOW_AIRCRAFT_OPTIONS,
               "UI\\TEMPLATES\\VEHOPTIONS.WIN");
}

void AircraftCgNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void aircraft_cg_cb (puObject* obj)
{
  open_window (AircraftCgNotify,
               FUI_WINDOW_AIRCRAFT_CG,
               "UI\\TEMPLATES\\CG.WIN");
}

void AircraftTuneRadiosNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void aircraft_tune_radios_cb (puObject* obj)
{
  open_window (AircraftTuneRadiosNotify,
               FUI_WINDOW_AIRCRAFT_AUTOTUNE,
               "UI\\TEMPLATES\\AUTOTUNE.WIN");
}

void AircraftFuelNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void aircraft_fuel_loadout_cb (puObject* obj)
{
  open_window (AircraftFuelNotify,
               FUI_WINDOW_AIRCRAFT_FUEL,
               "UI\\TEMPLATES\\FUEL.WIN");
}

void AircraftWeightBalanceNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void aircraft_weight_balance_cb (puObject* obj)
{
  open_window (AircraftWeightBalanceNotify,
               FUI_WINDOW_AIRCRAFT_WEIGHT_BALANCE,
               "UI\\TEMPLATES\\WEIGHT.WIN");
}

void AircraftDamageNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void aircraft_damage_report_cb (puObject* obj)
{
  open_window (AircraftDamageNotify,
               FUI_WINDOW_AIRCRAFT_DAMAGE,
               "UI\\TEMPLATES\\DAMAGE.WIN");
}

void AircraftSelectNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void aircraft_select_cb (puObject* obj)
{
  open_window (AircraftSelectNotify,
               FUI_WINDOW_AIRCRAFT_SELECT,
               "UI\\TEMPLATES\\SETUPAIR.WIN");
}

char *aircraft_legends[] =
{
  "Slew",
  "Teleport",
  "--------------------",
  "Options",
  "CG Indicator",
  "--------------------",
  "Tune Radios",
  "Fuel Loadout",
  "Weight & Balance",
  "--------------------",
  "Damage Report",
  "Select Aircraft",
  NULL
};

puCallback aircraft_cb[] =
{
  aircraft_slew_cb,
  aircraft_teleport_cb,
  NULL,
  aircraft_options_cb,
  aircraft_cg_cb,
  NULL,
  aircraft_tune_radios_cb,
  aircraft_fuel_loadout_cb,
  aircraft_weight_balance_cb,
  NULL,
  aircraft_damage_report_cb,
  aircraft_select_cb,
  NULL
};


//
// Weather menu
//
void WeatherMetarNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void weather_metar_cb (puObject* obj)
{
  open_window (WeatherMetarNotify,
               FUI_WINDOW_WEATHER_METAR,
               "UI\\TEMPLATES\\METAR.WIN");
}

void WeatherOtherNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void weather_other_cb (puObject* obj)
{
  open_window (WeatherOtherNotify,
               FUI_WINDOW_WEATHER_OTHER,
               "UI\\TEMPLATES\\MOREENV.WIN");
}

void WeatherWindsNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void weather_winds_cb (puObject* obj)
{
  open_window (WeatherWindsNotify,
               FUI_WINDOW_WEATHER_WINDS,
               "UI\\TEMPLATES\\WINDS.WIN");
}

void WeatherCloudsNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void weather_clouds_cb (puObject* obj)
{
  open_window (WeatherCloudsNotify,
               FUI_WINDOW_WEATHER_WINDS,
               "UI\\TEMPLATES\\CLOUDS.WIN");
}

void WeatherSkyTweakerNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void weather_sky_tweaker_cb (puObject* obj)
{
  open_window (WeatherSkyTweakerNotify, 
               FUI_WINDOW_WEATHER_SKY_TWEAKER,
               "UI\\TEMPLATES\\SKYTWEAK.WIN");
}

void weather_almanac_cb (puObject* obj)
{
  DrawNoticeToUser ("Weather -> Almanac not implemented", 5);
}

void WeatherOverviewNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent)
{
}

void weather_overview_cb (puObject* obj)
{
  open_window (WeatherOverviewNotify, 'envr', "UI\\TEMPLATES\\WEATHER.WIN");
}

char *weather_legends[] =
{
  "Load METAR...",
  "--------------------",
  "Other",
  "Winds",
  "Clouds",
  "--------------------",
  "Sky Tweaker",
  "--------------------",
  "Almanac",
  "Overview",
  NULL
};

puCallback weather_cb[] =
{
  weather_metar_cb,
  NULL,
  weather_other_cb,
  weather_winds_cb,
  weather_clouds_cb,
  NULL,
  weather_sky_tweaker_cb,
  NULL,
  weather_almanac_cb,
  weather_overview_cb,
  NULL
};


//
// Multiplayer menu
//

void multiplayer_connect_cb (puObject* obj)
{
  DrawNoticeToUser ("Windows -> Connect", 5);
}

void multiplayer_disconnect_cb (puObject* obj)
{
  DrawNoticeToUser ("Windows -> Disconnect", 5);
}

void multiplayer_chat_cb (puObject* obj)
{
  DrawNoticeToUser ("Windows -> Chat", 5);
}

void multiplayer_find_pilot_cb (puObject* obj)
{
  DrawNoticeToUser ("Windows -> Find Pilot", 5);
}

void multiplayer_motd_cb (puObject* obj)
{
  DrawNoticeToUser ("Windows -> Show MOTD", 5);
}

void multiplayer_sysop_cb (puObject* obj)
{
  DrawNoticeToUser ("Windows -> Sysop", 5);
}

char *multiplayer_legends[] =
{
  "Sysop",
  "Show MOTD",
  "--------------------",
  "Find Pilot",
  "Chat Window",
  "--------------------",
  "Disconnect",
  "Connect",
  NULL
};

puCallback multiplayer_cb[] =
{
  multiplayer_sysop_cb,
  multiplayer_motd_cb,
  NULL,
  multiplayer_find_pilot_cb,
  multiplayer_chat_cb,
  NULL,
  multiplayer_disconnect_cb,
  multiplayer_connect_cb,
  NULL
};


//
// Windows menu
//
void windows_replay_cb (puObject* obj)
{
  toggle_window (ReplayNotify,
                 FUI_WINDOW_INSTANT_REPLAY,
                 "UI\\TEMPLATES\\REPLAY.WIN");
}

void windows_axis_cb (puObject* obj)
{
  toggle_window (AxisNotify,
                 FUI_WINDOW_AXIS,
                 "UI\\TEMPLATES\\AXISIND.WIN");
}

void windows_vector_cb (puObject* obj)
{
  toggle_window (VectorMapNotify,
                 FUI_WINDOW_VECTOR_MAP,
                 "UI\\TEMPLATES\\RASTRMAP.WIN");
}

void windows_map_cb (puObject* obj)
{
  toggle_window (MapNotify,
                 FUI_WINDOW_MAP,
                 "UI\\TEMPLATES\\SLCTMAP.WIN");
}

void windows_gps_cb (puObject* obj)
{
  DrawNoticeToUser ("Windows -> GPS", 5);
}

char *windows_legends[] =
{
  "Instant Replay",
  "--------------------",
  "Axis Window",
  "--------------------",
  "Vector Window",
  "Map Window",
  "GPS Window",
  NULL
};

puCallback windows_cb[] =
{
  windows_replay_cb,
  NULL,
  windows_axis_cb,
  NULL,
  windows_vector_cb,
  windows_map_cb,
  windows_gps_cb,
  NULL
};

/*
//
// Databases menu
//
void database_airports_cb (puObject* obj)
{
  DrawNoticeToUser ("Database Airports callback", 5);
}

void database_runways_cb (puObject* obj)
{
  DrawNoticeToUser ("Database Runways callback", 5);
}

void database_navaids_cb (puObject* obj)
{
  DrawNoticeToUser ("Database Navaids callback", 5);
}

void database_waypoints_cb (puObject* obj)
{
  DrawNoticeToUser ("Database Waypoints callback", 5);
}

void database_comms_cb (puObject* obj)
{
  DrawNoticeToUser ("Database Comms callback", 5);
}

void database_ils_cb (puObject* obj)
{
  DrawNoticeToUser ("Database ILS callback", 5);
}


//
// Countries Database dialog
//
static puDialogBox*   dlgCountries = NULL;

static void db_countries_ok_cb (puObject* obj)
{
  delete dlgCountries;
  dlgCountries = NULL;
}

static void db_countries_select_cb (puObject* obj)
{
  puSelectBox *select = (puSelectBox*) obj;

  DataItem d = dbCountry->GetDataItem (select->getCurrentItem (), 1);
  char ctry[60];
  FormatDataItem (d, ctry);
  char s[80];
  sprintf (s, "Country = %s", ctry);
  DrawNoticeToUser (s, 5);
}

static void database_countries_cb (puObject* obj)
{
  if (dlgCountries != NULL) return;

  // Instantiate and initalize dialog
  dlgCountries = new puDialogBox (50, 50);
  {
    // Combo box displays key values
    int nRecords = dbCountry->GetNumDataRecords ();
    char **list = new char*[nRecords + 1];
    list[nRecords] = NULL;
    for (int i=(nRecords-1); i>=0; i--) {
      DataItem key = dbCountry->GetDataItem (i, 0);
      int iList = nRecords - i - 1;
      list[iList] = new char[key.length + 1];
      FormatDataItem (key, list[iList]);
    }
    puComboBox *combo = new puComboBox (40, 10, 100, 40, list);
    combo->setPosition (20, 260);
    combo->setCurrentItem (0);
    combo->setCallback (db_countries_select_cb);

    puOneShot *ok = new puOneShot (40, 20, "Close");
    ok->setPosition (180, 20);
    ok->makeReturnDefault (true);
    ok->setCallback (db_countries_ok_cb);
  }
  dlgCountries->close ();
  dlgCountries->reveal ();
}

//
// States Database dialog
//
void database_states_cb (puObject* obj)
{
  DrawNoticeToUser ("Database States callback", 5);
}

char *database_legends[] =
{
  "States",
  "Countries",
  "ILS",
  "Comms",
  "Waypoints",
  "Navaids",
  "Runways",
  "Airports",
  NULL
};

puCallback database_cb[] =
{
  database_states_cb,
  database_countries_cb,
  database_ils_cb,
  database_airports_cb,
  database_runways_cb,
  database_navaids_cb,
  database_waypoints_cb,
  database_comms_cb,
  NULL
};
*/

//
// Debug menu
//

void debug_dump_fui_cb (puObject* obj)
{
  const char *debugFilename = "Debug\\Fui.txt";
  FILE *f = fopen (debugFilename, "w");
  if (f) {
    globals->fuimgr->Print (f);
    fclose (f);
  }

  char debug[80];
  sprintf (debug, "FUI Manager dumped to %s", debugFilename);
  DrawNoticeToUser (debug, 5);
}

void debug_dump_system_pfs_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\pfs.txt", "w");
  if (f) {
    pfsdump (&globals->pfs, f);
    fclose (f);
  }

  DrawNoticeToUser ("Default POD filesystem dumped to \"pfs.txt\"", 5);
}

void debug_messaging_cb (puObject* obj)
{
  msg_debug_dlg_create ();
}

void debug_dump_keymap_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\keymap.txt", "w");
  if (f) {
    globals->keymap->Print (f);
    fclose (f);
  }

  DrawNoticeToUser ("Key mappings dumped to \"keymap.txt\"", 5);
}
/*
void debug_dump_wptdb_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\waypoint.txt", "w");
  if (f) {
    dbWaypoint->Dump (f);
    fclose (f);
  }

  DrawNoticeToUser ("Waypoint database dumped to \"waypoint.txt\"", 5);
}

void debug_dump_obsdb_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\obstruct.txt", "w");
  if (f) {
    dbObstruct->Dump (f);
    fclose (f);
  }

  DrawNoticeToUser ("Obstruction database dumped to \"obstruct.txt\"", 5);
}

void debug_dump_ilsdb_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\ils.txt", "w");
  if (f) {
    dbIls->Dump (f);
    fclose (f);
  }

  DrawNoticeToUser ("ILS database dumped to \"ils.txt\"", 5);
}

void debug_dump_statdb_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\state.txt", "w");
  if (f) {
    dbState->Dump (f);
    fclose (f);
  }

  DrawNoticeToUser ("State database dumped to \"state.txt\"", 5);
}

void debug_dump_ctrydb_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\country.txt", "w");
  if (f) {
    dbCountry->Dump (f);
    fclose (f);
  }

  DrawNoticeToUser ("Country database dumped to \"country.txt\"", 5);
}

void debug_dump_commdb_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\comm.txt", "w");
  if (f) {
    dbComm->Dump (f);
    fclose (f);
  }

  DrawNoticeToUser ("Comm database dumped to \"comm.txt\"", 5);
}

void debug_dump_atsdb_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\atsroute.txt", "w");
  if (f) {
    dbAtsRoute->Dump (f);
    fclose (f);
  }

  DrawNoticeToUser ("ATS Route database dumped to \"ats.txt\"", 5);
}

void debug_dump_navdb_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\navaids.txt", "w");
  if (f) {
    dbNavaid->Dump (f);
    fclose (f);
  }

  DrawNoticeToUser ("Navaid database dumped to \"navaids.txt\"", 5);
}

void debug_dump_rwydb_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\runways.txt", "w");
  if (f) {
    dbRunway->Dump (f);
    fclose (f);
  }

  DrawNoticeToUser ("Runway database dumped to \"runways.txt\"", 5);
}
*/
void debug_dump_apdb_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\airport.txt", "w");
  if (f) {
    dbAirport->Dump (f);
    fclose (f);
  }

  DrawNoticeToUser ("Airport database dumped to \"airport.txt\"", 5);
}

void debug_dump_time_cb (puObject* obj)
{
  CTimeManager *time = globals->timemgr;
  if (time != NULL) {
    FILE *f = fopen ("Debug\\time.txt", "w");
    if (f) {
      time->Print (f);
      fclose (f);
    }
  }

  DrawNoticeToUser ("Time manager dumped to \"time.txt\"", 5);
}


void debug_dump_camera_cb (puObject* obj)
{
  CCameraManager *camera = globals->sit->GetUserVehicle()->GetCameraManager ();
  if (camera != NULL) {
    FILE *f = fopen ("Debug\\camera.txt", "w");
    if (f) {
      camera->Print (f);
      fclose (f);
    }
  }

  DrawNoticeToUser ("Camera manager dumped to \"camera.txt\"", 5);
}


void debug_dump_terrain_cb (puObject* obj)
{
  CTerrainManager *terrain = globals->terrainmgr;
  if (terrain != NULL) {
    FILE *f = fopen ("Debug\\terrain.txt", "w");
    if (f) {
      terrain->Print (f);
      fclose (f);
    }
  }

  DrawNoticeToUser ("Terrain root dumped to \"terrain.txt\"", 5);
}


void debug_dump_sky_cb (puObject* obj)
{
  CSkyManager *sky = globals->skymgr;
  if (sky != NULL) {
    FILE *f = fopen ("Debug\\sky.txt", "w");
    if (f) {
      sky->Print (f);
      fclose (f);
    }
  }

  DrawNoticeToUser ("Sky root dumped to \"sky.txt\"", 5);
}


void debug_dump_user_cb (puObject* obj)
{
  FILE *f = fopen ("Debug\\uservehicle.txt", "w");
  if (f) {
    globals->sit->PrintUserVehicle(f);
    fclose (f);
  }

  DrawNoticeToUser ("User vehicle root dumped to \"uservehicle.txt\"", 5);
}

#ifdef _DEBUG
void debug_breakpoint_cb (puObject* obj)
{
#ifdef HAVE__ASM
  _asm { int 3 }
#endif // HAVE__ASM
}
#endif // _DEBUG

void debug_dump_electrical_cb (puObject* obj)
{
  CVehicleObject *user = globals->sit->GetUserVehicle ();
  if (user != NULL) {
    if (user->GetType () == TYPE_FLY_AIRPLANE) {
      CAirplaneObject *planeObject = (CAirplaneObject *)user;
      CAirplane *plane = planeObject->pAirplane;
      if (plane != NULL) {
        CElectricalSystem *amp = plane->amp;
        if (amp != NULL) {
          FILE *f = fopen ("Debug\\electrical.txt", "w");
          if (f) {
            amp->Print (f);
            fclose (f);
          }
        }
      }
    }
  }

  DrawNoticeToUser ("Aircraft electrical system dumped to \"elecrical.txt\"", 5);
}


char *debug_legends[] =
{
  "Dump FUI Manager",
  "Dump Electrical Systems",
  "Dump POD Filesystem",
  "Messaging",
  "Dump Key Mappings",
//  "Dump Waypoint Database",
//  "Dump Obstruction Database",
//  "Dump ILS Database",
//  "Dump State Database",
//  "Dump Country Database",
//  "Dump Comm Database",
//  "Dump ATS Route Database",
//  "Dump Navaid Database",
//  "Dump Runway Database",
//  "Dump Airport Database",
  "Dump Time Manager",
  "Dump Camera",
  "Dump Terrain",
  "Dump Sky",
  "Dump User Vehicle",
#ifdef _DEBUG
  "Breakpoint",
#endif
  NULL
};

puCallback debug_cb[] =
{
  debug_dump_fui_cb,
  debug_dump_electrical_cb,
  debug_dump_system_pfs_cb,
  debug_messaging_cb,
  debug_dump_keymap_cb,
//  debug_dump_wptdb_cb,
//  debug_dump_obsdb_cb,
//  debug_dump_ilsdb_cb,
//  debug_dump_statdb_cb,
//  debug_dump_ctrydb_cb,
//  debug_dump_commdb_cb,
//  debug_dump_atsdb_cb,
//  debug_dump_navdb_cb,
//  debug_dump_rwydb_cb,
//  debug_dump_apdb_cb,
  debug_dump_time_cb,
  debug_dump_camera_cb,
  debug_dump_terrain_cb,
  debug_dump_sky_cb,
  debug_dump_user_cb,
#ifdef _DEBUG
  debug_breakpoint_cb,
#endif
  NULL
};


//
// Help menu
//
void helpAbout_cb (puObject* obj)
{
  DrawNoticeToUser ("Help About callback", 5);
}

char *help_legends[] =
{
  "About...",
  NULL
};

puCallback help_cb[] =
{
  helpAbout_cb,
  NULL
};


//
// Menu initialization
//
static puMenuBar *menu;

void init_menu (void)
{
  menu = new puMenuBar(-1);
  menu->add_submenu ("File", file_legends, file_cb);
  menu->add_submenu ("Options", options_legends, options_cb);
  menu->add_submenu ("QuickFlight", quickflight_legends, quickflight_cb);
  menu->add_submenu ("Flight Plan", flightplan_legends, flightplan_cb);
  menu->add_submenu ("Aircraft", aircraft_legends, aircraft_cb);
  menu->add_submenu ("Weather", weather_legends, weather_cb);
  menu->add_submenu ("Multiplayer", multiplayer_legends, multiplayer_cb);
  menu->add_submenu ("Windows", windows_legends, windows_cb);
//  menu->add_submenu ("Database", database_legends, database_cb);
  menu->add_submenu ("Debug", debug_legends, debug_cb);
  menu->add_submenu ("Help", help_legends, help_cb);
  menu->close ();

  // Hide menu by default
  hide_menu ();
}

void cleanup_menu (void)
{
  menu->empty();
  delete menu;
}

void hide_menu (void)
{
  menu->hide ();
}

void show_menu (void)
{
  menu->reveal ();
}

void toggle_menu (void)
{
  if (menu->isVisible()) {
    menu->hide ();
  } else {
    menu->reveal ();
  }
}

Documentation generated by