path: root/X-Plane-SDK/Delphi/XPLM/XPLMUtilities.pas

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

UNIT XPLMUtilities;
INTERFACE
{
                                                                               
}

USES   XPLMDefs;
   {$A4}
{$IFDEF MSWINDOWS}
   {$DEFINE DELPHI}
{$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.                                                        
   }
TYPE
   XPLMCommandKeyID = (
          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
   );
   PXPLMCommandKeyID = ^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.                                                                    
   }
   XPLMCommandButtonID = (
          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
   );
   PXPLMCommandButtonID = ^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.                                                                      
   }
   XPLMHostApplicationID = (
      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
 
   );
   PXPLMHostApplicationID = ^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.                                            
   }
   XPLMLanguageCode = (
      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
 
{$IFDEF XPLM200}
     ,xplm_Language_Russian                    = 7
{$ENDIF}
 
{$IFDEF XPLM200}
     ,xplm_Language_Greek                      = 8
{$ENDIF}
 
{$IFDEF XPLM200}
     ,xplm_Language_Japanese                   = 9
{$ENDIF}
 
{$IFDEF XPLM200}
     ,xplm_Language_Chinese                    = 10
{$ENDIF}
 
   );
   PXPLMLanguageCode = ^XPLMLanguageCode;

{$IFDEF XPLM200}
   {
    XPLMDataFileType
    
    These enums define types of data files you can load or unload using the 
    SDK.                                                                        
   }
   XPLMDataFileType = (
     { 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
 
   );
   PXPLMDataFileType = ^XPLMDataFileType;
{$ENDIF}

{$IFDEF 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!                    
   }
     XPLMError_f = PROCEDURE(
                                    inMessage           : Pchar); cdecl;   
{$ENDIF}

   {
    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.                                                       
   }
   PROCEDURE XPLMSimulateKeyPress(
                                        inKeyType           : integer;    
                                        inKey               : integer);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.         
   }
   PROCEDURE XPLMSpeakString(
                                        inString            : Pchar);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.                                                      
   }
   PROCEDURE XPLMCommandKeyStroke(
                                        inKey               : XPLMCommandKeyID);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.                                  
   }
   PROCEDURE XPLMCommandButtonPress(
                                        inButton            : XPLMCommandButtonID);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    XPLMCommandButtonRelease
    
    This function simulates any of the actions that might be taken by pressing 
    a joystick button.  See XPLMCommandButtonPress                              
   }
   PROCEDURE XPLMCommandButtonRelease(
                                        inButton            : XPLMCommandButtonID);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.  
   }
   FUNCTION XPLMGetVirtualKeyDescription(
                                        inVirtualKey        : char) : Pchar;    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

{___________________________________________________________________________
 * 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.                                                        
   }
   PROCEDURE XPLMReloadScenery;
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.                                     
   }
   PROCEDURE XPLMGetSystemPath(
                                        outSystemPath       : Pchar);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.                                                  
   }
   PROCEDURE XPLMGetPrefsPath(
                                        outPrefsPath        : Pchar);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.                                                                   
   }
   FUNCTION XPLMGetDirectorySeparator: Pchar;
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.                                                              
   }
   FUNCTION XPLMExtractFileAndPath(
                                        inFullPath          : Pchar) : Pchar;    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.                                                        
   }
   FUNCTION XPLMGetDirectoryContents(
                                        inDirectoryPath     : Pchar;    
                                        inFirstReturn       : integer;    
                                        outFileNames        : Pchar;    
                                        inFileNameBufSize   : integer;    
                                        outIndices          : PPchar;    { Can be nil }
                                        inIndexCount        : integer;    
                                        outTotalFiles       : Pinteger;    { Can be nil }
                                        outReturnedFiles    : Pinteger) : integer;    { Can be nil }
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.                                                                     
   }
   FUNCTION XPLMInitialized: integer;
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.                                                  
   }
   PROCEDURE XPLMGetVersions(
                                        outXPlaneVersion    : Pinteger;    
                                        outXPLMVersion      : Pinteger;    
                                        outHostID           : PXPLMHostApplicationID);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    XPLMGetLanguage
    
    This routine returns the langauge the sim is running in.                    
   }
   FUNCTION XPLMGetLanguage: XPLMLanguageCode;
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.)                                                       
   }
   PROCEDURE XPLMDebugString(
                                        inString            : Pchar);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

{$IFDEF 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.                        
   }
   PROCEDURE XPLMSetErrorCallback(
                                        inCallback          : XPLMError_f);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}
{$ENDIF}

{$IFDEF 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.                                     
   }
   FUNCTION XPLMFindSymbol(
                                        inString            : Pchar) : pointer;    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}
{$ENDIF}

{$IFDEF 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).                                              
   }
   FUNCTION XPLMLoadDataFile(
                                        inFileType          : XPLMDataFileType;    
                                        inFilePath          : Pchar) : integer;    { Can be nil }
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}
{$ENDIF}

{$IFDEF XPLM200}
   {
    XPLMSaveDataFile
    
    Saves the current situation or replay; paths are relative to the X-System 
    folder.                                                                     
   }
   FUNCTION XPLMSaveDataFile(
                                        inFileType          : XPLMDataFileType;    
                                        inFilePath          : Pchar) : integer;    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}
{$ENDIF}

{$IFDEF 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.                                                    
   }
TYPE
   XPLMCommandPhase = (
     { The command is being started.                                               }
      xplm_CommandBegin                        = 0
 
     { The command is continuing to execute.                                       }
     ,xplm_CommandContinue                     = 1
 
     { The command has ended.                                                      }
     ,xplm_CommandEnd                          = 2
 
   );
   PXPLMCommandPhase = ^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.                             
   }
   XPLMCommandRef = pointer;
   PXPLMCommandRef = ^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.                                         
   }
     XPLMCommandCallback_f = FUNCTION(
                                    inCommand           : XPLMCommandRef;    
                                    inPhase             : XPLMCommandPhase;    
                                    inRefcon            : pointer) : integer; cdecl;   

   {
    XPLMFindCommand
    
    XPLMFindCommand looks up a command by name, and returns its command 
    reference or NULL if the command does not exist.                            
   }
   FUNCTION XPLMFindCommand(
                                        inName              : Pchar) : XPLMCommandRef;    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    XPLMCommandBegin
    
    XPLMCommandBegin starts the execution of a command, specified by its 
    command reference.  The  command is "held down" until XPLMCommandEnd is 
    called.                                                                     
   }
   PROCEDURE XPLMCommandBegin(
                                        inCommand           : XPLMCommandRef);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    XPLMCommandEnd
    
    XPLMCommandEnd ends the execution of a given command that was started with 
    XPLMCommandBegin.                                                           
   }
   PROCEDURE XPLMCommandEnd(
                                        inCommand           : XPLMCommandRef);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    XPLMCommandOnce
    
    This executes a given command momentarily, that is, the command begins and 
    ends immediately.                                                           
   }
   PROCEDURE XPLMCommandOnce(
                                        inCommand           : XPLMCommandRef);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.                                                       
   }
   FUNCTION XPLMCreateCommand(
                                        inName              : Pchar;    
                                        inDescription       : Pchar) : XPLMCommandRef;    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    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.)                                                
   }
   PROCEDURE XPLMRegisterCommandHandler(
                                        inComand            : XPLMCommandRef;    
                                        inHandler           : XPLMCommandCallback_f;    
                                        inBefore            : integer;    
                                        inRefcon            : pointer);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

   {
    XPLMUnregisterCommandHandler
    
    XPLMUnregisterCommandHandler removes a command callback registered with 
    XPLMRegisterCommandHandler.                                                 
   }
   PROCEDURE XPLMUnregisterCommandHandler(
                                        inComand            : XPLMCommandRef;    
                                        inHandler           : XPLMCommandCallback_f;    
                                        inBefore            : integer;    
                                        inRefcon            : pointer);    
{$IFDEF DELPHI}
                                       cdecl; external 'XPLM.DLL';
{$ELSE}
                                       cdecl; external '';
{$ENDIF}

{$ENDIF}
IMPLEMENTATION
END.