path: root/X-Plane-SDK/CHeaders/XPLM/XPLMUtilities.h

#ifndef _XPLMUtilities_h_
#define _XPLMUtilities_h_

/*
 * Copyright 2005-2012 Sandy Barbour and Ben Supnik
 * 
 * All rights reserved.  See license.txt for usage.
 * 
 * X-Plane SDK Version: 2.1.1                                                  
 *
 */

/*
 *                                                                             
 *
 */

#include "XPLMDefs.h"

#ifdef __cplusplus
extern "C" {
#endif

/***************************************************************************
 * X-PLANE USER INTERACTION
 ***************************************************************************/
/*
 * The user interaction APIs let you simulate commands the user can do with a 
 * joystick, keyboard etc.  Note that it is generally safer for future 
 * compatibility to use one of these commands than to manipulate the 
 * underlying sim data.                                                        
 *
 */



/*
 * XPLMCommandKeyID
 * 
 * These enums represent all the keystrokes available within x-plane.  They 
 * can be sent to x-plane directly.  For example, you can reverse thrust using 
 * these  enumerations.                                                        
 *
 */
enum {
          xplm_key_pause=0,
          xplm_key_revthrust,
          xplm_key_jettison,
          xplm_key_brakesreg,
          xplm_key_brakesmax,
          xplm_key_gear,
          xplm_key_timedn,
          xplm_key_timeup,
          xplm_key_fadec,
          xplm_key_otto_dis,
          xplm_key_otto_atr,
          xplm_key_otto_asi,
          xplm_key_otto_hdg,
          xplm_key_otto_gps,
          xplm_key_otto_lev,
          xplm_key_otto_hnav,
          xplm_key_otto_alt,
          xplm_key_otto_vvi,
          xplm_key_otto_vnav,
          xplm_key_otto_nav1,
          xplm_key_otto_nav2,
          xplm_key_targ_dn,
          xplm_key_targ_up,
          xplm_key_hdgdn,
          xplm_key_hdgup,
          xplm_key_barodn,
          xplm_key_baroup,
          xplm_key_obs1dn,
          xplm_key_obs1up,
          xplm_key_obs2dn,
          xplm_key_obs2up,
          xplm_key_com1_1,
          xplm_key_com1_2,
          xplm_key_com1_3,
          xplm_key_com1_4,
          xplm_key_nav1_1,
          xplm_key_nav1_2,
          xplm_key_nav1_3,
          xplm_key_nav1_4,
          xplm_key_com2_1,
          xplm_key_com2_2,
          xplm_key_com2_3,
          xplm_key_com2_4,
          xplm_key_nav2_1,
          xplm_key_nav2_2,
          xplm_key_nav2_3,
          xplm_key_nav2_4,
          xplm_key_adf_1,
          xplm_key_adf_2,
          xplm_key_adf_3,
          xplm_key_adf_4,
          xplm_key_adf_5,
          xplm_key_adf_6,
          xplm_key_transpon_1,
          xplm_key_transpon_2,
          xplm_key_transpon_3,
          xplm_key_transpon_4,
          xplm_key_transpon_5,
          xplm_key_transpon_6,
          xplm_key_transpon_7,
          xplm_key_transpon_8,
          xplm_key_flapsup,
          xplm_key_flapsdn,
          xplm_key_cheatoff,
          xplm_key_cheaton,
          xplm_key_sbrkoff,
          xplm_key_sbrkon,
          xplm_key_ailtrimL,
          xplm_key_ailtrimR,
          xplm_key_rudtrimL,
          xplm_key_rudtrimR,
          xplm_key_elvtrimD,
          xplm_key_elvtrimU,
          xplm_key_forward,
          xplm_key_down,
          xplm_key_left,
          xplm_key_right,
          xplm_key_back,
          xplm_key_tower,
          xplm_key_runway,
          xplm_key_chase,
          xplm_key_free1,
          xplm_key_free2,
          xplm_key_spot,
          xplm_key_fullscrn1,
          xplm_key_fullscrn2,
          xplm_key_tanspan,
          xplm_key_smoke,
          xplm_key_map,
          xplm_key_zoomin,
          xplm_key_zoomout,
          xplm_key_cycledump,
          xplm_key_replay,
          xplm_key_tranID,
          xplm_key_max
};
typedef int XPLMCommandKeyID;

/*
 * XPLMCommandButtonID
 * 
 * These are enumerations for all of the things you can do with a joystick 
 * button in X-Plane.  They currently match the buttons menu in the equipment 
 * setup dialog, but these enums will be stable even if they change in 
 * X-Plane.                                                                    
 *
 */
enum {
          xplm_joy_nothing=0,
          xplm_joy_start_all,
          xplm_joy_start_0,
          xplm_joy_start_1,
          xplm_joy_start_2,
          xplm_joy_start_3,
          xplm_joy_start_4,
          xplm_joy_start_5,
          xplm_joy_start_6,
          xplm_joy_start_7,
          xplm_joy_throt_up,
          xplm_joy_throt_dn,
          xplm_joy_prop_up,
          xplm_joy_prop_dn,
          xplm_joy_mixt_up,
          xplm_joy_mixt_dn,
          xplm_joy_carb_tog,
          xplm_joy_carb_on,
          xplm_joy_carb_off,
          xplm_joy_trev,
          xplm_joy_trm_up,
          xplm_joy_trm_dn,
          xplm_joy_rot_trm_up,
          xplm_joy_rot_trm_dn,
          xplm_joy_rud_lft,
          xplm_joy_rud_cntr,
          xplm_joy_rud_rgt,
          xplm_joy_ail_lft,
          xplm_joy_ail_cntr,
          xplm_joy_ail_rgt,
          xplm_joy_B_rud_lft,
          xplm_joy_B_rud_rgt,
          xplm_joy_look_up,
          xplm_joy_look_dn,
          xplm_joy_look_lft,
          xplm_joy_look_rgt,
          xplm_joy_glance_l,
          xplm_joy_glance_r,
          xplm_joy_v_fnh,
          xplm_joy_v_fwh,
          xplm_joy_v_tra,
          xplm_joy_v_twr,
          xplm_joy_v_run,
          xplm_joy_v_cha,
          xplm_joy_v_fr1,
          xplm_joy_v_fr2,
          xplm_joy_v_spo,
          xplm_joy_flapsup,
          xplm_joy_flapsdn,
          xplm_joy_vctswpfwd,
          xplm_joy_vctswpaft,
          xplm_joy_gear_tog,
          xplm_joy_gear_up,
          xplm_joy_gear_down,
          xplm_joy_lft_brake,
          xplm_joy_rgt_brake,
          xplm_joy_brakesREG,
          xplm_joy_brakesMAX,
          xplm_joy_speedbrake,
          xplm_joy_ott_dis,
          xplm_joy_ott_atr,
          xplm_joy_ott_asi,
          xplm_joy_ott_hdg,
          xplm_joy_ott_alt,
          xplm_joy_ott_vvi,
          xplm_joy_tim_start,
          xplm_joy_tim_reset,
          xplm_joy_ecam_up,
          xplm_joy_ecam_dn,
          xplm_joy_fadec,
          xplm_joy_yaw_damp,
          xplm_joy_art_stab,
          xplm_joy_chute,
          xplm_joy_JATO,
          xplm_joy_arrest,
          xplm_joy_jettison,
          xplm_joy_fuel_dump,
          xplm_joy_puffsmoke,
          xplm_joy_prerotate,
          xplm_joy_UL_prerot,
          xplm_joy_UL_collec,
          xplm_joy_TOGA,
          xplm_joy_shutdown,
          xplm_joy_con_atc,
          xplm_joy_fail_now,
          xplm_joy_pause,
          xplm_joy_rock_up,
          xplm_joy_rock_dn,
          xplm_joy_rock_lft,
          xplm_joy_rock_rgt,
          xplm_joy_rock_for,
          xplm_joy_rock_aft,
          xplm_joy_idle_hilo,
          xplm_joy_lanlights,
          xplm_joy_max
};
typedef int XPLMCommandButtonID;

/*
 * XPLMHostApplicationID
 * 
 * The plug-in system is based on Austin's cross-platform OpenGL framework and 
 * could theoretically be adapted to  run in other apps like WorldMaker.  The 
 * plug-in system also runs against a test harness for internal development 
 * and could be adapted to another flight sim (in theory at least).  So an ID 
 * is providing allowing plug-ins to  indentify what app they are running 
 * under.                                                                      
 *
 */
enum {
     xplm_Host_Unknown                        = 0

    ,xplm_Host_XPlane                         = 1

    ,xplm_Host_PlaneMaker                     = 2

    ,xplm_Host_WorldMaker                     = 3

    ,xplm_Host_Briefer                        = 4

    ,xplm_Host_PartMaker                      = 5

    ,xplm_Host_YoungsMod                      = 6

    ,xplm_Host_XAuto                          = 7


};
typedef int XPLMHostApplicationID;

/*
 * XPLMLanguageCode
 * 
 * These enums define what language the sim is running in.  These enumerations 
 * do not imply that the sim can or does run in all of these languages; they 
 * simply provide a known encoding in the event that a given sim version is 
 * localized to a certain language.                                            
 *
 */
enum {
     xplm_Language_Unknown                    = 0

    ,xplm_Language_English                    = 1

    ,xplm_Language_French                     = 2

    ,xplm_Language_German                     = 3

    ,xplm_Language_Italian                    = 4

    ,xplm_Language_Spanish                    = 5

    ,xplm_Language_Korean                     = 6

#if defined(XPLM200)
    ,xplm_Language_Russian                    = 7

#endif /* XPLM200 */
#if defined(XPLM200)
    ,xplm_Language_Greek                      = 8

#endif /* XPLM200 */
#if defined(XPLM200)
    ,xplm_Language_Japanese                   = 9

#endif /* XPLM200 */
#if defined(XPLM200)
    ,xplm_Language_Chinese                    = 10

#endif /* XPLM200 */

};
typedef int XPLMLanguageCode;

#if defined(XPLM200)
/*
 * XPLMDataFileType
 * 
 * These enums define types of data files you can load or unload using the 
 * SDK.                                                                        
 *
 */
enum {
     /* A situation (.sit) file, which starts off a flight in a given               *
      * configuration.                                                              */
     xplm_DataFile_Situation                  = 1

     /* A situation movie (.smo) file, which replays a past flight.                 */
    ,xplm_DataFile_ReplayMovie                = 2


};
typedef int XPLMDataFileType;
#endif /* XPLM200 */

#if defined(XPLM200)
/*
 * XPLMError_f
 * 
 * An XPLM error callback is a function that you provide to receive debugging 
 * information from the plugin SDK.  See XPLMSetErrorCallback for more 
 * information.  NOTE: for the sake of debugging, your error callback will be 
 * called even if your plugin is not enabled, allowing you to receive debug 
 * info in your XPluginStart and XPluginStop  callbacks.  To avoid causing 
 * logic errors in the management code, do not call any other plugin routines 
 * from your error callback - it is only meant for logging!                    
 *
 */
typedef void (* XPLMError_f)(
                                   const char *         inMessage);    
#endif /* XPLM200 */

/*
 * XPLMSimulateKeyPress
 * 
 * This function simulates a key being pressed for x-plane.  The keystroke 
 * goes directly to x-plane; it is never sent to any plug-ins.  However, since 
 * this is a raw key stroke it may be mapped by the keys file or enter text 
 * into a field. 
 * 
 * WARNING: This function will be deprecated; do not use it.  Instead use 
 * XPLMCommandKeyStroke.                                                       
 *
 */
XPLM_API void                 XPLMSimulateKeyPress(
                                   int                  inKeyType,    
                                   int                  inKey);    

/*
 * XPLMSpeakString
 * 
 * This function displays the string in a translucent overlay over the current 
 * display and also speaks the string if text-to-speech is enabled.  The 
 * string is spoken asynchronously, this function returns immediately.         
 *
 */
XPLM_API void                 XPLMSpeakString(
                                   const char *         inString);    

/*
 * XPLMCommandKeyStroke
 * 
 * This routine simulates a command-key stroke.  However, the keys are done by 
 * function, not by actual letter, so this function works even if the user has 
 * remapped their keyboard.  Examples of things you might do with this include 
 * pausing the simulator.                                                      
 *
 */
XPLM_API void                 XPLMCommandKeyStroke(
                                   XPLMCommandKeyID     inKey);    

/*
 * XPLMCommandButtonPress
 * 
 * This function simulates any of the actions that might be taken by pressing 
 * a joystick button.  However, this lets you call the command directly rather 
 * than have to know which button is mapped where.  Important: you must 
 * release each button you press.  The APIs are separate so that you can 'hold 
 * down' a button for a fixed amount of time.                                  
 *
 */
XPLM_API void                 XPLMCommandButtonPress(
                                   XPLMCommandButtonID  inButton);    

/*
 * XPLMCommandButtonRelease
 * 
 * This function simulates any of the actions that might be taken by pressing 
 * a joystick button.  See XPLMCommandButtonPress                              
 *
 */
XPLM_API void                 XPLMCommandButtonRelease(
                                   XPLMCommandButtonID  inButton);    

/*
 * XPLMGetVirtualKeyDescription
 * 
 * Given a virtual key code (as defined in XPLMDefs.h) this routine returns a 
 * human-readable string describing the character.  This routine is provided 
 * for showing users what keyboard mappings they have set up.  The string may 
 * read 'unknown' or be a blank or NULL string if the virtual key is unknown.  
 *
 */
XPLM_API const char *         XPLMGetVirtualKeyDescription(
                                   char                 inVirtualKey);    

/***************************************************************************
 * X-PLANE MISC
 ***************************************************************************/
/*
 *                                                                             
 *
 */



/*
 * XPLMReloadScenery
 * 
 * XPLMReloadScenery reloads the current set of scenery.  You can use this 
 * function in two typical ways: simply call it to reload the scenery, picking 
 * up any new installed scenery, .env files, etc. from disk.  Or, change the 
 * lat/ref and lon/ref data refs and then call this function to shift the 
 * scenery environment.                                                        
 *
 */
XPLM_API void                 XPLMReloadScenery(void);

/*
 * XPLMGetSystemPath
 * 
 * This function returns the full path to the X-System folder.  Note that this 
 * is a directory path, so it ends in a trailing : or /.  The buffer you pass 
 * should be at least 512 characters long.                                     
 *
 */
XPLM_API void                 XPLMGetSystemPath(
                                   char *               outSystemPath);    

/*
 * XPLMGetPrefsPath
 * 
 * This routine returns a full path to the proper directory to store 
 * preferences in. It ends in a : or /.  The buffer you pass should be at 
 * least 512 characters long.                                                  
 *
 */
XPLM_API void                 XPLMGetPrefsPath(
                                   char *               outPrefsPath);    

/*
 * XPLMGetDirectorySeparator
 * 
 * This routine returns a string with one char and a null terminator that is 
 * the directory separator for the current platform.  This allows you to write 
 * code that concatinates directory paths without having to #ifdef for 
 * platform.                                                                   
 *
 */
XPLM_API const char *         XPLMGetDirectorySeparator(void);

/*
 * XPLMExtractFileAndPath
 * 
 * Given a full path to a file, this routine separates the path from the file. 
 * If the path is a partial directory (e.g. ends in : or \) the trailing 
 * directory separator is removed.  This routine works in-place; a pointer to 
 * the file part of the buffer is returned; the original buffer still starts 
 * with the path.                                                              
 *
 */
XPLM_API char *               XPLMExtractFileAndPath(
                                   char *               inFullPath);    

/*
 * XPLMGetDirectoryContents
 * 
 * This routine returns a list of files in a directory (specified by a full 
 * path, no trailing : or \).  The output is returned as a list of NULL 
 * terminated strings. An index array (if specified) is filled with pointers 
 * into the strings.  This routine The last file is indicated by a zero-length 
 * string (and NULL in the indices).  This routine will return 1 if you had 
 * capacity for all files or 0 if you did not.  You can also skip a given 
 * number of files. 
 * 
 * inDirectoryPath - a null terminated C string containing the full path to 
 * the directory with no trailing directory char. 
 * 
 * inFirstReturn - the zero-based index of the first file in the directory to 
 * return.  (Usually zero to fetch all in one pass.) 
 * 
 * outFileNames - a buffer to receive a series of sequential null terminated 
 * C-string file names.  A zero-length C string will be appended to the very 
 * end. 
 * 
 * inFileNameBufSize - the size of the file name buffer in bytes. 
 * 
 * outIndices - a pointer to an array of character pointers that will become 
 * an index into the directory.  The last file will be followed by a NULL 
 * value.  Pass NULL if you do not want indexing information. 
 * 
 * inIndexCount - the max size of the index in entries. 
 * 
 * outTotalFiles - if not NULL, this is filled in with the number of files in 
 * the  directory. 
 * 
 * outReturnedFiles - if not NULL, the number of files returned by this 
 * iteration. 
 * 
 * Return value - 1 if all info could be returned, 0 if there was a buffer 
 * overrun. 
 * 
 * WARNING: Before X-Plane 7 this routine did not properly iterate through 
 * directories.  If X-Plane 6 compatibility is needed, use your own code to 
 * iterate directories.                                                        
 *
 */
XPLM_API int                  XPLMGetDirectoryContents(
                                   const char *         inDirectoryPath,    
                                   int                  inFirstReturn,    
                                   char *               outFileNames,    
                                   int                  inFileNameBufSize,    
                                   char **              outIndices,    /* Can be NULL */
                                   int                  inIndexCount,    
                                   int *                outTotalFiles,    /* Can be NULL */
                                   int *                outReturnedFiles);    /* Can be NULL */

/*
 * XPLMInitialized
 * 
 * This function returns 1 if X-Plane has properly initialized the plug-in 
 * system. If this routine returns 0, many XPLM functions will not work. 
 * 
 * NOTE: Under normal circumstances a plug-in should never be running while 
 * the  plug-in manager is not initialized. 
 * 
 * WARNING: This function is generally not needed and may be deprecated in the 
 * future.                                                                     
 *
 */
XPLM_API int                  XPLMInitialized(void);

/*
 * XPLMGetVersions
 * 
 * This routine returns the revision of both X-Plane and the XPLM DLL.  All 
 * versions are three-digit decimal numbers (e.g. 606 for version 6.06 of 
 * X-Plane); the current revision of the XPLM is 200 (2.00).  This routine 
 * also returns the host ID of the app running us. 
 * 
 * The most common use of this routine is to special-case around x-plane 
 * version-specific behavior.                                                  
 *
 */
XPLM_API void                 XPLMGetVersions(
                                   int *                outXPlaneVersion,    
                                   int *                outXPLMVersion,    
                                   XPLMHostApplicationID * outHostID);    

/*
 * XPLMGetLanguage
 * 
 * This routine returns the langauge the sim is running in.                    
 *
 */
XPLM_API XPLMLanguageCode     XPLMGetLanguage(void);

/*
 * XPLMDebugString
 * 
 * This routine outputs a C-style string to the Log.txt file.  The file is 
 * immediately flushed so you will not lose  data.  (This does cause a 
 * performance penalty.)                                                       
 *
 */
XPLM_API void                 XPLMDebugString(
                                   const char *         inString);    

#if defined(XPLM200)
/*
 * XPLMSetErrorCallback
 * 
 * XPLMSetErrorCallback installs an error-reporting callback for your plugin.  
 * Normally the plugin system performs minimum diagnostics to maximize 
 * performance.  When you install an error callback, you will receive calls 
 * due to certain plugin errors, such as passing bad parameters or incorrect 
 * data. 
 * 
 * The intention is for you to install the error callback during debug 
 * sections and put a break-point inside your callback.  This will cause you 
 * to break into the debugger from within the SDK at the point in your plugin 
 * where you made an illegal call. 
 * 
 * Installing an error callback may activate error checking code that would 
 * not normally run, and this may adversely affect performance, so do not 
 * leave error callbacks installed in shipping plugins.                        
 *
 */
XPLM_API void                 XPLMSetErrorCallback(
                                   XPLMError_f          inCallback);    
#endif /* XPLM200 */

#if defined(XPLM200)
/*
 * XPLMFindSymbol
 * 
 * This routine will attempt to find the symbol passed in the inString 
 * parameter. If the symbol is found a pointer the function is returned, 
 * othewise the function will return NULL.                                     
 *
 */
XPLM_API void *               XPLMFindSymbol(
                                   const char *         inString);    
#endif /* XPLM200 */

#if defined(XPLM200)
/*
 * XPLMLoadDataFile
 * 
 * Loads a data file of a given type.  Paths must be relative to the X-System 
 * folder. To clear the replay, pass a NULL file name (this is only valid with 
 * replay movies, not sit files).                                              
 *
 */
XPLM_API int                  XPLMLoadDataFile(
                                   XPLMDataFileType     inFileType,    
                                   const char *         inFilePath);    /* Can be NULL */
#endif /* XPLM200 */

#if defined(XPLM200)
/*
 * XPLMSaveDataFile
 * 
 * Saves the current situation or replay; paths are relative to the X-System 
 * folder.                                                                     
 *
 */
XPLM_API int                  XPLMSaveDataFile(
                                   XPLMDataFileType     inFileType,    
                                   const char *         inFilePath);    
#endif /* XPLM200 */

#if defined(XPLM200)
/***************************************************************************
 * X-PLANE COMMAND MANAGEMENT
 ***************************************************************************/
/*
 * The command management APIs let plugins interact with the command-system in 
 * X-Plane, the abstraction behind keyboard presses and joystick buttons.  
 * This API lets you create new commands and modify the behavior (or get 
 * notification) of existing ones. 
 * 
 * An X-Plane command consists of three phases: a beginning, continuous 
 * repetition, and an ending.  The command may be repeated zero times in  the 
 * event that the user presses a button only momentarily.			                   
 *
 */




/*
 * XPLMCommandPhase
 * 
 * The phases of a command.                                                    
 *
 */
enum {
     /* The command is being started.                                               */
     xplm_CommandBegin                        = 0

     /* The command is continuing to execute.                                       */
    ,xplm_CommandContinue                     = 1

     /* The command has ended.                                                      */
    ,xplm_CommandEnd                          = 2


};
typedef int XPLMCommandPhase;

/*
 * XPLMCommandRef
 * 
 * A command ref is an opaque identifier for an X-Plane command.  Command 
 * references stay the same for the life of your plugin but not between 
 * executions of X-Plane.  Command refs are used to execute commands, create 
 * commands, and create callbacks for particular commands. 
 * 
 * Note that a command is not "owned" by a particular plugin.  Since many 
 * plugins may participate in a command's execution, the command does not go 
 * away if the plugin that created it is unloaded.                             
 *
 */
typedef void * XPLMCommandRef;

/*
 * XPLMCommandCallback_f
 * 
 * A command callback is a function in your plugin that is called when a 
 * command is pressed.  Your callback receives the commadn  reference for the 
 * particular command, the phase of the command that is executing, and a 
 * reference pointer that you specify when registering the callback. 
 * 
 * Your command handler should return 1 to let processing of the command 
 * continue to other plugins and X-Plane, or 0 to halt  processing, 
 * potentially bypassing X-Plane code.                                         
 *
 */
typedef int (* XPLMCommandCallback_f)(
                                   XPLMCommandRef       inCommand,    
                                   XPLMCommandPhase     inPhase,    
                                   void *               inRefcon);    

/*
 * XPLMFindCommand
 * 
 * XPLMFindCommand looks up a command by name, and returns its command 
 * reference or NULL if the command does not exist.                            
 *
 */
XPLM_API XPLMCommandRef       XPLMFindCommand(
                                   const char *         inName);    

/*
 * XPLMCommandBegin
 * 
 * XPLMCommandBegin starts the execution of a command, specified by its 
 * command reference.  The  command is "held down" until XPLMCommandEnd is 
 * called.                                                                     
 *
 */
XPLM_API void                 XPLMCommandBegin(
                                   XPLMCommandRef       inCommand);    

/*
 * XPLMCommandEnd
 * 
 * XPLMCommandEnd ends the execution of a given command that was started with 
 * XPLMCommandBegin.                                                           
 *
 */
XPLM_API void                 XPLMCommandEnd(
                                   XPLMCommandRef       inCommand);    

/*
 * XPLMCommandOnce
 * 
 * This executes a given command momentarily, that is, the command begins and 
 * ends immediately.                                                           
 *
 */
XPLM_API void                 XPLMCommandOnce(
                                   XPLMCommandRef       inCommand);    

/*
 * XPLMCreateCommand
 * 
 * XPLMCreateCommand creates a new command for a given string.  If the command 
 * already exists, the  existing command reference is returned.  The 
 * description may appear in user interface contexts, such as the joystick 
 * configuration screen.                                                       
 *
 */
XPLM_API XPLMCommandRef       XPLMCreateCommand(
                                   const char *         inName,    
                                   const char *         inDescription);    

/*
 * XPLMRegisterCommandHandler
 * 
 * XPLMRegisterCommandHandler registers a callback to be called when a command 
 * is executed.  You provide a callback with a reference pointer. 
 * 
 * If inBefore is true, your command handler callback will be executed before 
 * X-Plane executes the command, and returning 0 from your callback will 
 * disable X-Plane's processing of the command.  If inBefore is  false, your 
 * callback will run after X-Plane.  (You can register a single callback both 
 * before and after a command.)                                                
 *
 */
XPLM_API void                 XPLMRegisterCommandHandler(
                                   XPLMCommandRef       inComand,    
                                   XPLMCommandCallback_f inHandler,    
                                   int                  inBefore,    
                                   void *               inRefcon);    

/*
 * XPLMUnregisterCommandHandler
 * 
 * XPLMUnregisterCommandHandler removes a command callback registered with 
 * XPLMRegisterCommandHandler.                                                 
 *
 */
XPLM_API void                 XPLMUnregisterCommandHandler(
                                   XPLMCommandRef       inComand,    
                                   XPLMCommandCallback_f inHandler,    
                                   int                  inBefore,    
                                   void *               inRefcon);    

#endif /* XPLM200 */
#ifdef __cplusplus
}
#endif

#endif