Keyboard.cpp

Go to the documentation of this file.

/*
 * Keyboard.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/Ui.h"
#include "../Include/Globals.h"
#include "../Include/UserVehicles.h"
#include "../Include/Situation.h"
#include "../Include/Cameras.h"
#include "../Include/KeyMap.h"


bool KeyMenuLoadScenario (int keyid, int code, int modifiers)
{
  return false;
}

bool KeyMenuSaveScenario (int keyid, int code, int modifiers)
{
  return false;
}

bool KeyMenuSaveScenarioAs (int keyid, int code, int modifiers)
{
  return false;
}

bool KeyMenuQuit (int keyid, int code, int modifiers)
{
  // Quit gracefully by setting application mode.  This will cause shutdown
  //   on the next redraw() cycle
  globals->appState = APP_EXIT_SCREEN;
  return true;
}


static void BindMenuKeys (CKeyMap *keymap)
{
  // 'esc ' Escape
  // 'retn' Return
  // 'entr' Enter
//  keymap->Bind ('clos', KeyMenuCloseWindow);
  keymap->Bind ('load', KeyMenuLoadScenario);
  keymap->Bind ('save', KeyMenuSaveScenario);
  keymap->Bind ('sava', KeyMenuSaveScenarioAs);
//  keymap->Bind ('prnt', KeyMenuPrint);
  keymap->Bind ('quit', KeyMenuQuit);
//  keymap->Bind ('ogrp', KeyMenuGraphics);
//  keymap->Bind ('osnd', KeyMenuSound);
//  keymap->Bind ('keys', KeyMenuKeysButtons);
//  keymap->Bind ('axes', KeyMenuAxes);
//  keymap->Bind ('tstc', KeyMenuTestControls);
//  keymap->Bind ('ockp', KeyMenuCockpit);
//  keymap->Bind ('otun', KeyMenuTuneRadios);
//  keymap->Bind ('oair', KeyMenuAircraft);
//  keymap->Bind ('real', KeyMenuRealism);
//  keymap->Bind ('tree', KeyMenuScenery);
//  keymap->Bind ('date', KeyMenuDateTime);
//  keymap->Bind ('gogo', KeyMenuStartup);
//  keymap->Bind ('mute', KeyMenuMute);
//  keymap->Bind ('sfly', KeyMenuAdventures);
//  keymap->Bind ('qfly', KeyMenuQuickFlight);
//  keymap->Bind ('goto', KeyMenuTeleport);
}


/*
 * Global Keys
 */

bool KeyGlobalCockpitToggle (int keyid, int code, int modifiers)
{
  return false;
}

bool KeyGlobalNextVehicle (int keyid, int code, int modifiers)
{
  return false;
}

bool KeyGlobalPrevVehicle (int keyid, int code, int modifiers)
{
  return false;
}

bool KeyGlobalHomeVehicle (int keyid, int code, int modifiers)
{
  return false;
}

bool KeyGlobalCameraNext (int keyid, int code, int modifiers)
{
  // Command camera manager of user vehicle to cycle to the next camera
  CCameraManager *cam = globals->sit->user->GetCameraManager ();
  cam->NextCamera ();

  return true;
}

bool KeyGlobalCameraPrev (int keyid, int code, int modifiers)
{
  // Command camera manager of user vehicle to cycle to the next camera
  CCameraManager *cam = globals->sit->user->GetCameraManager ();
  cam->PrevCamera ();

  return true;
}

bool KeyGlobalMenu (int keyid, int code, int modifiers)
{
  toggle_menu ();

  return true;
}

bool KeyGlobalTimeForward (int keyid, int code, int modifiers)
{
  SDateTimeDelta delta;
  delta.dYears = delta.dMonths = delta.dDays = delta.dHours = 0;
  delta.dMinutes = 30;
  delta.dSeconds = delta.dMillisecs = 0;

  SDateTime dt = globals->timemgr->GetUTCDateTime ();
  dt = globals->timemgr->AddTimeDelta (dt, delta);
  globals->timemgr->SetUTCDateTime (dt);

  // 
  // Archived code increases the sim timescale x2
  //
/*
  float scale = globals->timemgr->GetTimeScale ();
  globals->timemgr->SetTimeScale (scale * 2);

  // Display a message to the user indicating the new time scale
  char msg[80];
  sprintf (msg, "Time Scale = %2.1fx", globals->timemgr->GetTimeScale());
  DrawNoticeToUser (msg, 5);
*/

  return true;
}

bool KeyGlobalTimeBackward (int keyid, int code, int modifiers)
{
  SDateTimeDelta delta;
  delta.dYears = delta.dMonths = delta.dDays = delta.dHours = 0;
  delta.dMinutes = 30;
  delta.dSeconds = delta.dMillisecs = 0;

  SDateTime dt = globals->timemgr->GetUTCDateTime ();
  dt = globals->timemgr->SubtractTimeDelta (dt, delta);
  globals->timemgr->SetUTCDateTime (dt);

  // 
  // Archived code increases the sim timescale x2
  //
/*
  float scale = globals->timemgr->GetTimeScale ();
  globals->timemgr->SetTimeScale (scale / 2);

  // Display a message to the user indicating the new time scale
  char msg[80];
  sprintf (msg, "Time Scale = %2.1fx", globals->timemgr->GetTimeScale());
  DrawNoticeToUser (msg, 5);
*/

  return true;
}

bool KeyGlobalPause (int keyid, int code, int modifiers)
{
  if (globals->timemgr->GetPauseState ()) {
    globals->timemgr->Pause ();
  } else {
    globals->timemgr->Unpause ();
  }

  return true;
}


bool KeyGlobal (int id, int code, int modifiers)
{
  bool rc = false;

  switch (id) {
  case 'mwin':
    // Map window
    globals->fuimgr->CreateFuiWindow (MapNotify,
                                      FUI_WINDOW_MAP,
                                      "UI\\TEMPLATES\\SLCTMAP.WIN");
    rc = true;
    break;

  case 'vwin':
    // Vector map window
    globals->fuimgr->CreateFuiWindow (VectorMapNotify,
                                      FUI_WINDOW_VECTOR_MAP,
                                      "UI\\TEMPLATES\\RASTRMAP.WIN");
    rc = true;
    break;

  case 'fpsw':
    // Frame rate window
    globals->fuimgr->CreateFuiWindow (FrameRateNotify,
                                      FUI_WINDOW_FRAME_RATE,
                                      "UI\\TEMPLATES\\FRAMRATE.WIN");
    rc = true;
    break;
  }

  return rc;
}


static void BindGlobalKeys (CKeyMap *keymap)
{
  keymap->Bind ('cock', KeyGlobalCockpitToggle);
  keymap->Bind ('nveh', KeyGlobalNextVehicle);
  keymap->Bind ('pveh', KeyGlobalPrevVehicle);
  keymap->Bind ('hveh', KeyGlobalHomeVehicle);
  keymap->Bind ('camn', KeyGlobalCameraNext);
  keymap->Bind ('camn', KeyGlobalCameraPrev);
  keymap->Bind ('menu', KeyGlobalMenu);
  keymap->Bind ('timf', KeyGlobalTimeForward);
  keymap->Bind ('timb', KeyGlobalTimeBackward);
  keymap->Bind ('paus', KeyGlobalPause);
  keymap->Bind ('mwin', KeyGlobal);
  keymap->Bind ('vwin', KeyGlobal);
  keymap->Bind ('fpsw', KeyGlobal);

/*
KeySet 'glob' Global Keys
  'stat' Status Bar
  'rsit' Reset Situation
  'ival' Increase Value
  'dval' Decrease Value
  'cycl' Cycle Windows
  'mwin' Map Window
  'vwin' Vector Window
  'gwin' GPS Window
  'cklw' Checklist Window
  'ssht' Screen Shot
  'cdis' Compress Distance
  'ddis' Decompress Distance
  'bbox' Instant Replay
  'mike' Microphone/LiveMic
  'axis' Axis Window
  'menu' Menu Bar
  'mnud' Menu Down
  'mnuu' Menu Up
  'mnul' Menu Left
  'mnur' Menu Right
  'mnua' Menu Accept
  'mnux' Menu Abort
  'atct' ATC On/Off
  'attn' Auto Tune Comm 1
  'atcm' ATC Menu
  'atc1' ATC Phrase #1
  'atc2' ATC Phrase #2
  'atc3' ATC Phrase #3
  'atc4' ATC Phrase #4
  'atc5' ATC Phrase #5
  'atc6' ATC Phrase #6
  'atc7' ATC Phrase #7
  'atc8' ATC Phrase #8
  'atc9' ATC Phrase #9
  'atc0' ATC Phrase #10
  'chat' Chat Window
  'phlp' Range Finder
  'vsfr' Sim Frame Rate
  'ifr_' Toggle VFR/IFR Panels
  'sprf' Show Profiler Dialog
  'skyt' Sky Tweaker
  'dbgS' Sim Debug Displays
  'dllw' DLL Task Window
  'carg' Jettison Cargo
  'repr' Repair & Revive
  'moov' Toggle Movie Capture
  'jpeg' JPEG Screenshot
  'g430' GNS430 Popup Window
  'ftkR' FlyTrak Record
  'ftkP' FlyTrak Playback
  'ftkC' FlyTrak Configuration
*/
}


//
// The following key mappings are camera mode selectors which are sent to the
//   camera manager, not specifically to the current camera
//

bool KeyCameraCockpit (int id, int code, int mod)
{
  // Command camera manager of user vehicle to cycle to the next camera
  CCameraManager *cam = globals->sit->user->GetCameraManager ();
  cam->SelectCamera (CAMERA_COCKPIT);

  return true;
}

bool KeyCameraSpot (int id, int code, int mod)
{
  // Command camera manager of user vehicle to cycle to the next camera
  CCameraManager *cam = globals->sit->user->GetCameraManager ();
  cam->SelectCamera (CAMERA_SPOT);

  return true;
}

bool KeyCameraChase (int id, int code, int mod)
{
  return false;
}

bool KeyCameraStationary (int id, int code, int mod)
{
  return false;
}

bool KeyCameraFlyby (int id, int code, int mod)
{
  // Command camera manager of user vehicle to cycle to the next camera
  CCameraManager *cam = globals->sit->user->GetCameraManager ();
  cam->SelectCamera (CAMERA_FLYBY);

  return true;
}

bool KeyCameraTower (int id, int code, int mod)
{
  // Command camera manager of user vehicle to cycle to the next camera
  CCameraManager *cam = globals->sit->user->GetCameraManager ();
  cam->SelectCamera (CAMERA_TOWER);

  return true;
}


//
// The following camera key mappings are generally applicable to external cameras
//
bool KeyCameraZoomIn (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->ZoomIn ();

  return true;
}

bool KeyCameraZoomInSlow (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->ZoomInSlow ();

  return true;
}

bool KeyCameraZoomInFast (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->ZoomInFast ();

  return true;
}

bool KeyCameraZoomOut (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->ZoomOut ();

  return true;
}

bool KeyCameraZoomOutSlow (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->ZoomOutSlow ();

  return true;
}

bool KeyCameraZoomOutFast (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->ZoomOutFast ();

  return true;
}

bool KeyCameraZoomReset (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->ZoomReset ();

  return true;
}

bool KeyCameraZoomRatioIn (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->ZoomRatioIn ();

  return true;
}

bool KeyCameraZoomRatioOut (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->ZoomRatioOut ();

  return true;
}

bool KeyCameraPanLeft (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->PanLeft ();

  return true;
}

bool KeyCameraPanRight (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->PanRight ();

  return true;
}

bool KeyCameraPanUp (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->PanUp ();

  return true;
}

bool KeyCameraPanDown (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->PanDown ();

  return true;
}

//
// The following camera key mappings are applicable only to interior cameras
//

bool KeyCameraUser1 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->User1 ();

  return true;
}

bool KeyCameraDefineUser1 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->DefineUser1 ();

  return true;
}

bool KeyCameraUser2 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->User2 ();

  return true;
}

bool KeyCameraDefineUser2 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->DefineUser2 ();

  return true;
}

bool KeyCameraUser3 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->User3 ();

  return true;
}

bool KeyCameraDefineUser3 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->DefineUser3 ();

  return true;
}

bool KeyCameraUser4 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->User4 ();

  return true;
}

bool KeyCameraDefineUser4 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->DefineUser4 ();

  return true;
}

bool KeyCameraUser5 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->User5 ();

  return true;
}

bool KeyCameraDefineUser5 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->DefineUser5 ();

  return true;
}

bool KeyCameraUser6 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->User6 ();

  return true;
}

bool KeyCameraDefineUser6 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->DefineUser6 ();

  return true;
}

bool KeyCameraUser7 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->User7 ();

  return true;
}

bool KeyCameraDefineUser7 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->DefineUser7 ();

  return true;
}

bool KeyCameraUser8 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->User8 ();

  return true;
}

bool KeyCameraDefineUser8 (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->DefineUser8 ();

  return true;
}

bool KeyCameraHeadPitchUp (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->HeadPitchUp ();

  return true;
}

bool KeyCameraHeadPitchDown (int id, int code, int mod)
{
  CCamera *cam = globals->sit->GetCurrentCamera ();
  cam->HeadPitchDown ();

  return true;
}

bool KeyCameraCockpitScrollUp (int id, int code, int mod)
{
  CPanel *panel = globals->sit->GetCurrentPanel ();
  if (panel != NULL) panel->ScrollUp ();

  return true;
}

bool KeyCameraCockpitScrollDown (int id, int code, int mod)
{
  CPanel *panel = globals->sit->GetCurrentPanel ();
  if (panel != NULL) panel->ScrollDown ();

  return true;
}

bool KeyCameraCockpitScrollLeft (int id, int code, int mod)
{
  CPanel *panel = globals->sit->GetCurrentPanel ();
  if (panel != NULL) panel->ScrollLeft ();

  return true;
}

bool KeyCameraCockpitScrollRight (int id, int code, int mod)
{
  CPanel *panel = globals->sit->GetCurrentPanel ();
  if (panel != NULL) panel->ScrollRight ();

  return true;
}

bool KeyCameraCockpitHome (int id, int code, int mod)
{
//  CPanel *panel = globals->sit->GetCurrentPanel ();
//  panel->CockpitPageUp ();
  return false;
}

bool KeyCameraCockpitPageUp (int id, int code, int mod)
{
//  CPanel *panel = globals->sit->GetCurrentPanel ();
//  panel->CockpitPageUp ();
  return false;
}

bool KeyCameraCockpitPageDown (int id, int code, int mod)
{
//  CPanel *panel = globals->sit->GetCurrentPanel ();
//  panel->CockpitPageUp ();
  return false;
}

  
static void BindCameraKeys (CKeyMap *keymap)
{
  keymap->Bind ('czin', KeyCameraZoomIn);
  keymap->Bind ('czis', KeyCameraZoomInSlow);
  keymap->Bind ('czif', KeyCameraZoomInFast);
  keymap->Bind ('czot', KeyCameraZoomOut);
  keymap->Bind ('czos', KeyCameraZoomOutSlow);
  keymap->Bind ('czof', KeyCameraZoomOutFast);
  keymap->Bind ('czrs', KeyCameraZoomReset);

  keymap->Bind ('cs01', KeyCameraUser1);
  keymap->Bind ('cd01', KeyCameraDefineUser1);
  keymap->Bind ('cs02', KeyCameraUser2);
  keymap->Bind ('cd02', KeyCameraDefineUser1);
  keymap->Bind ('cs03', KeyCameraUser3);
  keymap->Bind ('cd03', KeyCameraDefineUser1);
  keymap->Bind ('cs04', KeyCameraUser4);
  keymap->Bind ('cd04', KeyCameraDefineUser1);
  keymap->Bind ('cs05', KeyCameraUser5);
  keymap->Bind ('cd05', KeyCameraDefineUser1);
  keymap->Bind ('cs06', KeyCameraUser6);
  keymap->Bind ('cd06', KeyCameraDefineUser1);
  keymap->Bind ('cs07', KeyCameraUser7);
  keymap->Bind ('cd07', KeyCameraDefineUser1);
  keymap->Bind ('cs08', KeyCameraUser8);
  keymap->Bind ('cd08', KeyCameraDefineUser1);
  keymap->Bind ('chpu', KeyCameraHeadPitchUp);
  keymap->Bind ('chpd', KeyCameraHeadPitchDown);
  keymap->Bind ('czri', KeyCameraZoomRatioIn);
  keymap->Bind ('czr0', KeyCameraZoomRatioOut);
  keymap->Bind ('cam1', KeyCameraCockpit);
  keymap->Bind ('cam2', KeyCameraSpot);
  keymap->Bind ('cam3', KeyCameraChase);
  keymap->Bind ('cam4', KeyCameraStationary);
  keymap->Bind ('cam5', KeyCameraFlyby);
  keymap->Bind ('cam6', KeyCameraTower);
  keymap->Bind ('cplf', KeyCameraPanLeft);
  keymap->Bind ('cprt', KeyCameraPanRight);
  keymap->Bind ('cpup', KeyCameraPanUp);
  keymap->Bind ('cpdn', KeyCameraPanDown);
  keymap->Bind ('ckup', KeyCameraCockpitScrollUp);
  keymap->Bind ('ckdn', KeyCameraCockpitScrollDown);
  keymap->Bind ('cklf', KeyCameraCockpitScrollLeft);
  keymap->Bind ('ckri', KeyCameraCockpitScrollRight);
  keymap->Bind ('ckhm', KeyCameraCockpitHome);
  keymap->Bind ('ckpu', KeyCameraCockpitPageUp);
  keymap->Bind ('ckpd', KeyCameraCockpitPageDown);
}


/*
 * Flight Planner Keys
 */

/*
  'sfpl' Flight Planner
  'navl' Navigation Log...
  'fpck' FP CheckList...
  'logb' Log Book...
  'vdir' Directory...
  'cwpt' Current Waypoint
  'sair' Select Aircraft
  'ouch' Damage Report
  'sful' Setup Fuel
  'sbag' Weight & Baggage
  'cgin' CG Indicator
  'adet' Aircraft Details
  'envo' Weather Overview
  'envc' Clouds
  'envw' Winds
  'envm' Other Weather
  'metr' Load METAR
  'MPst' Multiplayer...
  'dcon' Disconnect
  'fndp' Find Pilot...
  'motd' Show MOTD...
  'admn' Sysop...
  'who ' About Fly
  'webs' Support Web Site
  'webt' TRI Web Site
  'webg' Gathering Web Site
  'uedt' UI Editor...
  'thmn' Theme Manager...
  'medt' Model Editor...
  'sedt' Scenery Editor...
 */

/*
 * Airplane Control Keys
 */

bool KeyAirplane (int id, int code, int mod)
{
  // These keys are only applicable if the user vehicle is an airplane
  EFlyObjectType type = globals->sit->GetUserVehicleType ();
  if (type != TYPE_FLY_AIRPLANE) {
    return false;
  }

  // Inhibit aircraft control when in slew mode
  if (globals->slewmgr->IsEnabled ()) {
    return false;
  }

  bool rc = true;
  CAirplane *plane = ((CAirplaneObject *)globals->sit->GetUserVehicle ())->pAirplane;

  switch (id) {
  case 'adel':
    // Elevator down
    plane->ElevatorDecr ();
    break;

  case 'auel':
    // Elevator up
    plane->ElevatorIncr ();
    break;

  case 'alai':
    // Aileron Left
    plane->AileronDecr ();
    break;

  case 'arai':
    // Aileron Right
    plane->AileronIncr ();
    break;

  case 'alrd':
    // Rudder Left
    plane->RudderDecr ();
    break;

  case 'arrd':
    // Rudder Right
    plane->RudderIncr ();
    break;

  case 'adtr':
    // Trim Elevator Down
    plane->ElevatorTrimDecr ();
    break;

  case 'autr':
    // Trim Elevator Up
    plane->ElevatorTrimIncr ();
    break;

  case 'atal':
    // Trim Aileron Left
    plane->AileronTrimDecr ();
    break;

  case 'atar':
    // Trim Aileron Right
    plane->AileronTrimIncr ();
    break;

  case 'atrl':
    // Trim Rudder Left
    plane->RudderTrimIncr ();
    break;

  case 'atlr':
    // Trim Rudder Right
    plane->RudderTrimIncr ();
    break;

  default:
    rc = false;
  }

  return rc;
}


static void BindAirplaneKeys (CKeyMap *keymap)
{
  keymap->Bind ('adel', KeyAirplane);
  keymap->Bind ('auel', KeyAirplane);
  keymap->Bind ('arai', KeyAirplane);
  keymap->Bind ('alai', KeyAirplane);
  keymap->Bind ('alrd', KeyAirplane);
  keymap->Bind ('arrd', KeyAirplane);
  keymap->Bind ('actr', KeyAirplane);
  keymap->Bind ('acta', KeyAirplane);
  keymap->Bind ('autr', KeyAirplane);
  keymap->Bind ('adtr', KeyAirplane);
  keymap->Bind ('atal', KeyAirplane);
  keymap->Bind ('atar', KeyAirplane);
  keymap->Bind ('atrl', KeyAirplane);
  keymap->Bind ('atrr', KeyAirplane);

/*
  'amfl' Mixture Full Lean
  'amfr' Mixture Full Rich
  'admx' Mixture Down
  'aimx' Mixture Up
  'amix' Mixture Power|Economy
  'appl' Prop Pitch Low
  'apph' Prop Pitch High
  'appd' Prop Pitch Decrease
  'appi' Prop Pitch Increase
  'amit' Throttle Off
  'amat' Throttle Full
  'adth' Throttle Down
  'aith' Throttle Up
  'adt2' Throttle Down (Alt.)
  'ait2' Throttle Up (Alt.)
  'arev' Reverse Thrust (On/Off)
  'beta' Beta Thrust (On/Off)
  'affu' Flaps (Full Up)
  'afrt' Flaps (Retract)
  'afex' Flaps (Extend)
  'affd' Flaps (Full Down)
  'actn' Coordinated Turn
  'abrk' Brakes (Ground)
  'pbrk' Brakes (Parking)
  'lbrk' Brakes (Left)
  'rbrk' Brakes (Right)
  'aabk' Brakes (Air)
  'aabm' Brakes (Air,Max)
  'aeng' Engine On/Off
  'aenf' Engine Focus (next)
  'aefp' Engine Focus (prev)
  'agtg' Gear Up/Down
  'agfd' Gear Down (Forced)
  'aspl' Extend/Retract Spoilers
  'aasp' Arm auto-spoilers
  'acht' Carburetor Heat On/Off
  'apht' Pitot Heat On/Off
  'alnd' Auto Land
  'aipa' Co-Pilot Abort
  'aprm' Engine Primer
  'acfg' Toggle Hi Lift Device
  'amag' Magneto switch
  'aifr' IFR Hood On/Off
  'apen' Autopilot Enable
  'aphg' Autopilot Hdg Hold
  'apal' Autopilot Alt Hold
  'apSy' Autopilot Sync
  'anlt' Lights (Navigation)
  'allt' Lights (Landing/Taxi)
  'acpl' Lights (Panel)
  'aadf' Select ADF
  'acom' Select COM radio
  'adme' Select DME
  'anav' Select NAV radio
  'atns' Select Transponder
  'aobs' Select OBS
  'rad1' Select Radio 1
  'rad2' Select Radio 2
  'rad3' Select Radio 3
  'rad4' Select Radio 4
*/
}

/*
 * Helicopter keys
 */

/*
KeySet 'heli' Helicopter Keys
  'fcyc' Fore Cyclic
  'acyc' Aft Cyclic
  'rcyc' Right Cyclic
  'lcyc' Left Cyclic
  'ltrt' Left Tail Rotor
  'rtrt' Right Tail Rotor
  'upcl' Up Collective
  'dncl' Down Collective
  'mfcy' Max Fore Cyclic
  'macy' Max Aft Cyclic
  'mrcy' Max Right Cyclic
  'mlcy' Max Left Cyclic
  'mltr' Max Left Tail Rotor
  'mrtr' Max Right Tail Rotor
  'mucl' Max Up Collective
  'mdcl' Max Down Collective
  'mvrt' Min Vertical Rate
  'zvrt' Zero Vertical Rate
  'altt' Altimeter Mode
  'hctr' Center Controls (Partial)
  'hcta' Center Controls (All)
  'hmit' Throttle Off
  'hmat' Throttle Full
  'hdth' Throttle Down
  'hith' Throttle Up
  'fcyT' Fore Cyclic Trim
  'acyT' Aft Cyclic Trim
  'rcyT' Right Cyclic Trim
  'lcyT' Left Cyclic Trim
  'ltrT' Left Tail Rotor Trim
  'rtrT' Right Tail Rotor Trim
  'upcT' Up Collective Trim
  'dncT' Down Collective Trim
KeySet 'grnd' Ground Vehicle Keys
  'strl' Steer Left
  'strr' Steer Right
  'trup' Throttle Up
  'trdn' Throttle Down
  'maxs' Max Speed
  'mins' Min Speed
  'gctr' Center Controls (Partial)
  'gcta' Center Controls (All)
*/

/*
 * Slew Keys
 */

bool KeySlew (int id, int code, int mod)
{
  CSlewManager *slew = globals->slewmgr;
  if (slew->IsEnabled ()) {
    slew->Disable ();
  } else {
    slew->Enable ();
  }

  return true;
}

bool KeySlewForward (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    slew->SetNorthRate (slew->GetNorthRate() + 1.0);
    rc = true;
  }

  return rc;
}

bool KeySlewBackward (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    slew->SetNorthRate (slew->GetNorthRate() - 1.0);
    rc = true;
  }

  return rc;
}

bool KeySlewLeft (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    slew->SetEastRate (slew->GetEastRate() - 1.0);
    rc = true;
  }

  return rc;
}

bool KeySlewRight (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    slew->SetEastRate (slew->GetEastRate() + 1.0);
    rc = true;
  }

  return rc;
}

bool KeySlewBankLeft (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    // Get current user vehicle orientation
    CVehicleObject *vehicle = globals->sit->GetUserVehicle();
    SVector v = vehicle->GetOrientation();

    // Update orientation
    v.h += DegToRad (1.0f);
    vehicle->SetOrientation (v);

    rc = true;
  }

  return rc;
}

bool KeySlewBankRight (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    // Get current user vehicle orientation
    CVehicleObject *vehicle = globals->sit->GetUserVehicle();
    SVector v = vehicle->GetOrientation();

    // Update orientation
    v.h += DegToRad (-1.0f);
    vehicle->SetOrientation (v);

    rc = true;
  }

  return rc;
}

bool KeySlewRotateLeft (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    // Get current user vehicle orientation
    CVehicleObject *vehicle = globals->sit->GetUserVehicle();
    SVector v = vehicle->GetOrientation();

    // Update orientation
    v.r += DegToRad (1.0f);
    vehicle->SetOrientation (v);

    rc = true;
  }

  return rc;
}

bool KeySlewRotateRight (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    // Get current user vehicle orientation
    CVehicleObject *vehicle = globals->sit->GetUserVehicle();
    SVector v = vehicle->GetOrientation();

    // Update orientation
    v.r += DegToRad (-1.0f);
    vehicle->SetOrientation (v);

    rc = true;
  }

  return rc;
}

bool KeySlewRotateLeft45 (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    // Get current user vehicle orientation
    CVehicleObject *vehicle = globals->sit->GetUserVehicle();
    SVector v = vehicle->GetOrientation();

    // Update orientation
    v.r += DegToRad (45.0f);
    vehicle->SetOrientation (v);

    rc = true;
  }

  return rc;
}

bool KeySlewRotateRight45 (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    // Get current user vehicle orientation
    CVehicleObject *vehicle = globals->sit->GetUserVehicle();
    SVector v = vehicle->GetOrientation();

    // Update orientation
    v.r += DegToRad (-45.0f);
    vehicle->SetOrientation (v);

    rc = true;
  }

  return rc;
}

bool KeySlewPitchUp (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    // Get current user vehicle orientation
    CVehicleObject *vehicle = globals->sit->GetUserVehicle();
    SVector v = vehicle->GetOrientation();

    // Update orientation
    v.p += DegToRad (-1.0f);
    vehicle->SetOrientation (v);

    rc = true;
  }

  DrawNoticeToUser ("Slew pitch up", 1);
  return rc;
}

bool KeySlewPitchDown (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    // Get current user vehicle orientation
    CVehicleObject *vehicle = globals->sit->GetUserVehicle();
    SVector v = vehicle->GetOrientation();

    // Update orientation
    v.p += DegToRad (1.0f);
    vehicle->SetOrientation (v);

    rc = true;
  }

  DrawNoticeToUser ("Slew pitch down", 1);
  return rc;
}

bool KeySlewUp (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    slew->SetAltRate (slew->GetAltRate() + 10.0);
    rc = true;
  }

  return rc;
}

bool KeySlewDown (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    slew->SetAltRate (slew->GetAltRate() - 10.0);
    rc = true;
  }

  return rc;
}

bool KeySlewReorient (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    rc = true;
  }

  return rc;
}

bool KeySlewStop (int id, int code, int mod)
{
  bool rc = false;

  CSlewManager *slew = globals->slewmgr;

  if (slew->IsEnabled ()) {
    slew->ZeroRate ();
    rc = true;
  }

  return rc;
}

static void BindSlewKeys (CKeyMap *keymap)
{
  keymap->Bind ('slew', KeySlew);
  keymap->Bind ('sfwd', KeySlewForward);
  keymap->Bind ('sbkw', KeySlewBackward);
  keymap->Bind ('slft', KeySlewLeft);
  keymap->Bind ('srgt', KeySlewRight);
  keymap->Bind ('sbnl', KeySlewBankLeft);
  keymap->Bind ('sbnr', KeySlewBankRight);
  keymap->Bind ('srtl', KeySlewRotateLeft);
  keymap->Bind ('srtr', KeySlewRotateRight);
  keymap->Bind ('srl4', KeySlewRotateLeft45);
  keymap->Bind ('srr4', KeySlewRotateRight45);
  keymap->Bind ('sptu', KeySlewPitchUp);
  keymap->Bind ('sptd', KeySlewPitchDown);
  keymap->Bind ('slup', KeySlewUp);
  keymap->Bind ('sldn', KeySlewDown);
  keymap->Bind ('sreo', KeySlewReorient);
  keymap->Bind ('sstp', KeySlewStop);
}


/*
 * Debug Keys
 */

/*
  KeySet 'dbug' Debug Keys
  'grph' Graph
  'dbps' Debug Pause
  'dbss' Debug Single Step
  'aipl' AI Pilot
  'wpln' Weapon Launch
  'pttr' Pitch Trim
  'hovr' Hover
  'ahld' Altitude Hold
  'hhld' Heading Hold
  'phld' Pitch Hold
  'bhld' Bank Hold
  'shld' Speed Hold
  'aagl' Altitude AGL Hold
  'vrhl' Vertical Rate Hold
  'albu' Altitude Bump Up
  'hdbu' Heading Bump Up
  'ptbu' Pitch Bump Up
  'bnbu' Bank Bump Up
  'spbu' Speed Bump Up
  'aabu' Altitude AGL Bump Up
  'vrbu' Vertical Rate BumpUp
  'mxvr' Max Vertical Rate
  'albd' Altitude Bump Down
  'hdbd' Heading Bump Down
  'ptbd' Pitch Bump Down
  'bbdn' Bank Bump Down
  'spbd' Speed Bump Down
  'aabd' Altitude AGL Bump Dn
  'vrbd' Vertical Rate BumpDn
  'push' Push
  'pshb' Push Back
  'mrep' Memory report
  'clon' Clone
  'kill' Kill
KeySet 'misc' Misc Vehicle Keys
  'vvup' Virtual View Up
  'vvdn' Virtual View Down
  'vvlt' Virtual View Left
  'vvrt' Virtual View Right
  'mids' Mid Speed
  'away' Add Waypoint
*/


void BindAllKeys (CKeyMap *keymap)
{
  BindMenuKeys (keymap);
  BindGlobalKeys (keymap);
  BindCameraKeys (keymap);
  BindAirplaneKeys (keymap);
  BindSlewKeys (keymap);
}

/*
 * Keyboard input handlers
 */

//
// This table is a simple mapping of GLUT key codes to FlyLegacy key codes.
//
typedef struct {
  int           glut;
  EKeyboardKeys flylegacy;
} SGlutToFlyLegacyKey;

SGlutToFlyLegacyKey glutKeyMap[] =
{
  // Control keys
  { 1,            KB_KEY_A },
  { 2,            KB_KEY_B },
  { 3,            KB_KEY_C },
  { 4,            KB_KEY_D },
  { 5,            KB_KEY_E },
  { 6,            KB_KEY_F },
  { 7,            KB_KEY_G },
  { 8,            KB_KEY_H },
  { 9,            KB_KEY_I },
  { 10,           KB_KEY_J },
  { 11,           KB_KEY_K },
  { 12,           KB_KEY_L },
  { 13,           KB_KEY_M },
  { 14,           KB_KEY_N },
  { 15,           KB_KEY_O },
  { 16,           KB_KEY_P },
  { 17,           KB_KEY_Q },
  { 18,           KB_KEY_R },
  { 19,           KB_KEY_S },
  { 20,           KB_KEY_T },
  { 21,           KB_KEY_U },
  { 22,           KB_KEY_V },
  { 23,           KB_KEY_W },
  { 24,           KB_KEY_X },
  { 25,           KB_KEY_Y },
  { 26,           KB_KEY_Z },

  // Top row
  { 27,           KB_KEY_ESC },
  { '`',          KB_KEY_REVERSE_SINGLE_QUOTE },
  { '1',          KB_KEY_1 },
  { '2',          KB_KEY_2 },
  { '3',          KB_KEY_3 },
  { '4',          KB_KEY_4 },
  { '5',          KB_KEY_5  },
  { '6',          KB_KEY_6 },
  { '7',          KB_KEY_7 },
  { '8',          KB_KEY_8 },
  { '9',          KB_KEY_9 },
  { '0',          KB_KEY_0 },
  { '-',          KB_KEY_MINUS },
  { '=',          KB_KEY_EQUALS },

  // Shifted top row
  { '~',          KB_KEY_REVERSE_SINGLE_QUOTE },
  { '!',          KB_KEY_1 },
  { '@',          KB_KEY_2 },
  { '#',          KB_KEY_3 },
  { '$',          KB_KEY_4 },
  { '%',          KB_KEY_5  },
  { '^',          KB_KEY_6 },
  { '&',          KB_KEY_7 },
  { '*',          KB_KEY_8 },
  { '(',          KB_KEY_9 },
  { ')',          KB_KEY_0 },
  { '_',          KB_KEY_MINUS },
  { '+',          KB_KEY_EQUALS },

  // Second row
  { '\t',         KB_KEY_TAB },
  { 'q',          KB_KEY_Q },
  { 'w',          KB_KEY_W },
  { 'e',          KB_KEY_E },
  { 'r',          KB_KEY_R },
  { 't',          KB_KEY_T },
  { 'y',          KB_KEY_Y },
  { 'u',          KB_KEY_U },
  { 'i',          KB_KEY_I },
  { 'o',          KB_KEY_O },
  { 'p',          KB_KEY_P },
  { '[',          KB_KEY_FORWARD_BRACKET },
  { ']',          KB_KEY_REVERSE_BRACKET },
  { '\\',         KB_KEY_BACKSLASH },

  // Shifted second row
  { 'Q',          KB_KEY_Q },
  { 'W',          KB_KEY_W },
  { 'E',          KB_KEY_E },
  { 'R',          KB_KEY_R },
  { 'T',          KB_KEY_T },
  { 'Y',          KB_KEY_Y },
  { 'U',          KB_KEY_U },
  { 'I',          KB_KEY_I },
  { 'O',          KB_KEY_O },
  { 'P',          KB_KEY_P },
  { '{',          KB_KEY_FORWARD_BRACKET },
  { '}',          KB_KEY_REVERSE_BRACKET },
  { '|',          KB_KEY_BACKSLASH },

  // Third row
  { 'a',          KB_KEY_A },
  { 's',          KB_KEY_S },
  { 'd',          KB_KEY_D },
  { 'f',          KB_KEY_F },
  { 'g',          KB_KEY_G },
  { 'h',          KB_KEY_H },
  { 'j',          KB_KEY_J },
  { 'k',          KB_KEY_K },
  { 'l',          KB_KEY_L },
  { ';',          KB_KEY_SEMI_COLON },
  { '\'',         KB_KEY_SINGLE_QUOTE},
  { '\13',        KB_KEY_ENTER},

  // Shifted third row
  { 'A',          KB_KEY_A },
  { 'S',          KB_KEY_S },
  { 'D',          KB_KEY_D },
  { 'F',          KB_KEY_F },
  { 'G',          KB_KEY_G },
  { 'H',          KB_KEY_H },
  { 'J',          KB_KEY_J },
  { 'K',          KB_KEY_K },
  { 'L',          KB_KEY_L },
  { ':',          KB_KEY_SEMI_COLON },
  { '\"',         KB_KEY_SINGLE_QUOTE},

  // Fourth row
  { 'z',          KB_KEY_Z },
  { 'x',          KB_KEY_X },
  { 'c',          KB_KEY_C },
  { 'v',          KB_KEY_V },
  { 'b',          KB_KEY_B },
  { 'n',          KB_KEY_N },
  { 'm',          KB_KEY_M },
  { ',',          KB_KEY_COMMA },
  { '.',          KB_KEY_PERIOD },
  { '/',          KB_KEY_SLASH },

  // Shifted fourth row
  { 'Z',          KB_KEY_Z },
  { 'X',          KB_KEY_X },
  { 'C',          KB_KEY_C },
  { 'V',          KB_KEY_V },
  { 'B',          KB_KEY_B },
  { 'N',          KB_KEY_N },
  { 'M',          KB_KEY_M },
  { '<',          KB_KEY_COMMA },
  { '>',          KB_KEY_PERIOD },
  { '?',          KB_KEY_SLASH },

  // Space
  { ' ',          KB_KEY_SPACE },
};

SGlutToFlyLegacyKey glutSpecialMap[] =
{
  { GLUT_KEY_F1,      KB_KEY_F1 },
  { GLUT_KEY_F2,      KB_KEY_F2 },
  { GLUT_KEY_F3,      KB_KEY_F3 },
  { GLUT_KEY_F4,      KB_KEY_F4 },
  { GLUT_KEY_F5,      KB_KEY_F5 },
  { GLUT_KEY_F6,      KB_KEY_F6 },
  { GLUT_KEY_F7,      KB_KEY_F7 },
  { GLUT_KEY_F8,      KB_KEY_F8 },
  { GLUT_KEY_F9,      KB_KEY_F9 },
  { GLUT_KEY_F10,     KB_KEY_F10 },
  { GLUT_KEY_F11,     KB_KEY_F11 },
  { GLUT_KEY_F12,     KB_KEY_F12 },
  { GLUT_KEY_HOME,    KB_KEY_HOME },
  { GLUT_KEY_UP,      KB_KEY_UP },
  { GLUT_KEY_PAGE_UP,   KB_KEY_PGUP },
  { GLUT_KEY_LEFT,    KB_KEY_LEFT },
  { GLUT_KEY_RIGHT,   KB_KEY_RIGHT },
  { GLUT_KEY_END,     KB_KEY_END },
  { GLUT_KEY_DOWN,    KB_KEY_DOWN },
  { GLUT_KEY_PAGE_DOWN, KB_KEY_PGDN },
  { GLUT_KEY_INSERT,    KB_KEY_INSERT },
  { 127,          KB_KEY_DEL }
};

SGlutToFlyLegacyKey glutKeyboard[128];
SGlutToFlyLegacyKey glutSpecial[128];

EKeyboardModifiers glutModifiersToFlyLegacyModifiers (int glutmod)
{
  int flymod = KB_MODIFIER_NONE;
  if (glutmod & GLUT_ACTIVE_SHIFT) flymod |= KB_MODIFIER_SHIFT;
  if (glutmod & GLUT_ACTIVE_CTRL) flymod |= KB_MODIFIER_CTRL;
  if (glutmod & GLUT_ACTIVE_ALT) flymod |= KB_MODIFIER_ALT;

  return (EKeyboardModifiers)flymod;
}


bool glutKeyToFlyLegacyKey (int glutkey, EKeyboardKeys *flykey)
{
  *flykey = glutKeyboard[glutkey].flylegacy;

//  char debug[80];
//  sprintf (debug, "glut=%d flylegacy=%d", glutkey, *flykey);
//  DrawNoticeToUser (debug, 2);

  return (*flykey != KB_KEY_META);
}


bool glutSpecialToFlyLegacyKey (int glutkey, EKeyboardKeys *flykey)
{
  *flykey = glutSpecial[glutkey].flylegacy;

//  char debug[80];
//  sprintf (debug, "glut=%d flylegacy=%d", glutkey, *flykey);
//  DrawNoticeToUser (debug, 2);

  return (*flykey != KB_KEY_META);
}


/*
 * Keyboard initialization
 *
 * This function must be called prior to any keyboard events being handled
 */

void init_keyboard (void)
{
  int i;

  // Load key mappings
  globals->keymap = new CKeyMap ("System\\default.key");
  BindAllKeys (globals->keymap);

  // Initialize all entries in GLUT->FlyLegacy mapping tables to META (unused)
  for (i=0; i<128; i++) {
    glutKeyboard[i].glut = i;
    glutKeyboard[i].flylegacy = KB_KEY_META;
    glutSpecial[i].glut = i;
    glutSpecial[i].flylegacy = KB_KEY_META;
  }

  // Now set all values specified in the actual maps
  int nKeys = sizeof (glutKeyMap) / sizeof (SGlutToFlyLegacyKey);
  for (i=0; i<nKeys; i++) {
    glutKeyboard[glutKeyMap[i].glut].flylegacy = glutKeyMap[i].flylegacy;
  }

  int nSpecialKeys = sizeof (glutSpecialMap) / sizeof (SGlutToFlyLegacyKey);
  for (i=0; i<nSpecialKeys; i++) {
    glutSpecial[glutSpecialMap[i].glut].flylegacy = glutSpecialMap[i].flylegacy;
  }
}

Documentation generated by