# Host files

File path: `out/dir/api.rs`

```rust
// Host code
/* Rust API */
#[derive(Debug)]
pub enum Commands {
    Trinitrix(trinitrix::Trinitrix),
}
pub mod trinitrix {
    #[derive(Debug)]
    pub enum Trinitrix {
        Std(std::Std),
        Api(api::Api),
    }
    /// Language specific functions, which mirror the `trinitrix.api` namespace.
    /// That is, if you have to choose between a `std` and a `api` function choose the `std`
    /// one as it will most likely be more high-level and easier to use (as it isn't abstracted
    /// over multiple languages). Feel free to drop down to the lower level api, if you feel
    /// like that more, it should be as stable and user-oriented as the `std` functions
    pub mod std {
        #[derive(Debug)]
        pub enum Std {}
    }
    /// General API to change stuff in Trinitrix
    pub mod api {
        #[derive(Debug)]
        pub enum Api {
            /// Closes the application
            #[allow(non_camel_case_types)]
            exit,
            /// Send a message to the current room
            /// The send message is interpreted literally.
            #[allow(non_camel_case_types)]
            room_message_send { message: String },
            Ui(ui::Ui),
            Keymaps(keymaps::Keymaps),
            Raw(raw::Raw),
        }
        /// Function that change the UI, or UI state
        pub mod ui {
            #[allow(non_camel_case_types)]
            #[derive(Debug)]
            pub enum Mode {
                /// Default mode (navigation mode)
                Normal,
                /// Allows you to insert things
                Insert,
                /// actives the command line
                Command,
            }
            impl From<crate::trinitrix_c::api_c::ui_c::Mode_c> for Mode {
                fn from(value: crate::trinitrix_c::api_c::ui_c::Mode_c) -> Self {
                    match value {
                        Mode_c::Normal => Self::Normal,
                        Mode_c::Insert => Self::Insert,
                        Mode_c::Command => Self::Command,
                    }
                }
            }
            #[derive(Debug)]
            pub enum Ui {
                /// Change the active mode
                #[allow(non_camel_case_types)]
                set_mode { mode: crate::trinitrix::api::ui::Mode },
                /// Go to the next plane
                #[allow(non_camel_case_types)]
                cycle_planes,
                /// Go to the previous plane
                #[allow(non_camel_case_types)]
                cycle_planes_rev,
            }
        }
        /// Manipulate keymappings, the mode is specified as a String build up of all mode
        /// the keymapping should be active in. The mapping works as follows:
        ///     n => normal Mode
        ///     c => command Mode
        ///     i => insert Mode
        ///
        /// The key works in a similar matter, specifying the required keypresses to trigger the
        /// callback. For example "aba" for require the user to press "a" then "b" then "a" again
        /// to trigger the mapping. Special characters are encoded as follows:
        ///     "<C-a>ba" => "Ctrl+a" then "b" then "a"
        ///     "<S-a>" => "A" or "Shift+a"
        ///     "A" => "A"
        ///     "<M-a> " => "Alt+a" (<A-a>) or "Meta+a"(<M-a>) (most terminals can't really differentiate between these characters)
        ///     "a<C-b><C-a>" => "a" then "Ctrl+b" then "Ctrl+a" (also works for Shift, Alt and Super)
        ///     "<CSM-b>" => "Ctrl+Shift+Alt+b" (the ordering doesn't matter)
        ///     "a " => "a" then a literal space (" ")
        ///     "å🙂" => "å" then "🙂" (full Unicode support!)
        ///     "<ESC>" => escape key
        ///     "<F3>" => F3 key
        ///     "<BACKSPACE>" => backspace key (and so forth)
        ///     "<DASH>" => a literal "-"
        ///     "<ANGULAR_BRACKET_OPEN>" or "<ABO>"  => a literal "<"
        ///     "<ANGULAR_BRACKET_CLOSE>" or "<ABC>" => a literal ">"
        ///
        /// The callback MUST be registered first by calling
        /// `trinitrix.api.register_function()` the returned value can than be used to
        /// set the keymap.
        pub mod keymaps {
            #[derive(Debug)]
            pub enum Keymaps {
                /// Add a new keymapping
                #[allow(non_camel_case_types)]
                add { mode: String, key: String, callback: fn() },
                /// Remove a keymapping
                ///
                /// Does nothing, if the keymapping doesn't exists yet
                #[allow(non_camel_case_types)]
                remove { mode: String, key: String },
                /// List declared keymappings
                #[allow(non_camel_case_types)]
                get { mode: String },
            }
        }
        /// Functions only used internally within Trinitrix
        pub mod raw {
            #[derive(Debug)]
            pub enum Raw {
                /// Send an error to the default error output
                #[allow(non_camel_case_types)]
                raise_error { error_message: String },
                /// Send output to the default output
                /// This is mainly used to display the final
                /// output of evaluated lua commands.
                #[allow(non_camel_case_types)]
                display_output { output_message: String },
                /// Input a character without checking for possible keymaps
                /// If the current state does not expect input, this character is ignored
                /// The encoding is the same as in the `trinitrix.api.keymaps` commands
                #[allow(non_camel_case_types)]
                send_input_unprocessed { input: String },
                Private(__private::Private),
            }
            /// This namespace is used to store some command specific data (like functions, as
            /// ensuring memory locations stay allocated in garbage collected language is hard)
            ///
            /// Treat it as an implementation detail
            pub mod __private {
                #[derive(Debug)]
                pub enum Private {}
            }
        }
    }
}
/* C API */
pub mod trinitrix_c {}
pub mod std_c {}
pub mod api_c {}
#[no_mangle]
pub extern "C" fn trinitrix_api_exit() -> core::ffi::c_int {
    callback_function(trinitrix_api_exit);
    return 1;
}
#[no_mangle]
pub extern "C" fn trinitrix_api_room_message_send(message: String) -> core::ffi::c_int {
    callback_function(trinitrix_api_room_message_send);
    return 1;
}
pub mod ui_c {
    #[allow(non_camel_case_types)]
    #[repr(C)]
    #[derive(Debug)]
    pub enum Mode_c {
        /// Default mode (navigation mode)
        Normal,
        /// Allows you to insert things
        Insert,
        /// actives the command line
        Command,
    }
    impl From<crate::trinitrix::api::ui::Mode> for Mode_c {
        fn from(value: crate::trinitrix::api::ui::Mode) -> Self {
            match value {
                Mode::Normal => Self::Normal,
                Mode::Insert => Self::Insert,
                Mode::Command => Self::Command,
            }
        }
    }
}
#[no_mangle]
pub extern "C" fn trinitrix_api_ui_set_mode(
    mode: crate::trinitrix::api::ui::Mode,
) -> core::ffi::c_int {
    callback_function(trinitrix_api_ui_set_mode);
    return 1;
}
#[no_mangle]
pub extern "C" fn trinitrix_api_ui_cycle_planes() -> core::ffi::c_int {
    callback_function(trinitrix_api_ui_cycle_planes);
    return 1;
}
#[no_mangle]
pub extern "C" fn trinitrix_api_ui_cycle_planes_rev() -> core::ffi::c_int {
    callback_function(trinitrix_api_ui_cycle_planes_rev);
    return 1;
}
pub mod keymaps_c {}
#[no_mangle]
pub extern "C" fn trinitrix_api_keymaps_add(
    mode: String,
    key: String,
    callback: fn(),
) -> core::ffi::c_int {
    callback_function(trinitrix_api_keymaps_add);
    return 1;
}
#[no_mangle]
pub extern "C" fn trinitrix_api_keymaps_remove(
    mode: String,
    key: String,
) -> core::ffi::c_int {
    callback_function(trinitrix_api_keymaps_remove);
    return 1;
}
#[no_mangle]
pub extern "C" fn trinitrix_api_keymaps_get(mode: String) -> core::ffi::c_int {
    callback_function(trinitrix_api_keymaps_get);
    return 1;
}
pub mod raw_c {}
#[no_mangle]
pub extern "C" fn trinitrix_api_raw_raise_error(
    error_message: String,
) -> core::ffi::c_int {
    callback_function(trinitrix_api_raw_raise_error);
    return 1;
}
#[no_mangle]
pub extern "C" fn trinitrix_api_raw_display_output(
    output_message: String,
) -> core::ffi::c_int {
    callback_function(trinitrix_api_raw_display_output);
    return 1;
}
#[no_mangle]
pub extern "C" fn trinitrix_api_raw_send_input_unprocessed(
    input: String,
) -> core::ffi::c_int {
    callback_function(trinitrix_api_raw_send_input_unprocessed);
    return 1;
}
pub mod __private_c {}
// vim: filetype=rust
```

# Auxiliary files

File path: `dist/interface.h`

```c
#if !defined TRIXY_MAIN_HEADER
#define TRIXY_MAIN_HEADER

#include "errno.h"
#include "string.h"
#include "vec.h"

/**
 * Closes the application
 */
extern int trinitrix_api_exit ();

/**
 * Send a message to the current room
 * The send message is interpreted literally.
 */
extern int trinitrix_api_room_message_send (const char *message);

enum Mode
{
  /**
   * Default mode (navigation mode)
   */
  Normal,
  /**
   * Allows you to insert things
   */
  Insert,
  /**
   * actives the command line
   */
  Command,
};

/**
 * Change the active mode
 */
extern int trinitrix_api_ui_set_mode (enum Mode mode);

/**
 * Go to the next plane
 */
extern int trinitrix_api_ui_cycle_planes ();

/**
 * Go to the previous plane
 */
extern int trinitrix_api_ui_cycle_planes_rev ();

/**
 * Add a new keymapping
 */
extern int trinitrix_api_keymaps_add (const char *mode, const char *key,
                                      void (*callback) ());

/**
 * Remove a keymapping
 *
 * Does nothing, if the keymapping doesn't exists yet
 */
extern int trinitrix_api_keymaps_remove (const char *mode, const char *key);

/**
 * List declared keymappings
 */
extern int trinitrix_api_keymaps_get (const char *mode);

/**
 * Send an error to the default error output
 */
extern int trinitrix_api_raw_raise_error (const char *error_message);

/**
 * Send output to the default output
 * This is mainly used to display the final
 * output of evaluated lua commands.
 */
extern int trinitrix_api_raw_display_output (const char *output_message);

/**
 * Input a character without checking for possible keymaps
 * If the current state does not expect input, this character is ignored
 * The encoding is the same as in the `trinitrix.api.keymaps` commands
 */
extern int trinitrix_api_raw_send_input_unprocessed (const char *input);

/**
 * Language specific functions, which mirror the `trinitrix.api` namespace.
 * That is, if you have to choose between a `std` and a `api` function choose
 * the `std` one as it will most likely be more high-level and easier to use
 * (as it isn't abstracted over multiple languages). Feel free to drop down to
 * the lower level api, if you feel like that more, it should be as stable and
 * user-oriented as the `std` functions
 */
struct std
{
};

/**
 * Function that change the UI, or UI state
 */
struct ui
{
  int (*set_mode) ();
  int (*cycle_planes) (void);
  int (*cycle_planes_rev) (void);
};

/**
 * Manipulate keymappings, the mode is specified as a String build up of all
 * mode the keymapping should be active in. The mapping works as follows: n =>
 * normal Mode c => command Mode i => insert Mode
 *
 * The key works in a similar matter, specifying the required keypresses to
 * trigger the callback. For example "aba" for require the user to press "a"
 * then "b" then "a" again to trigger the mapping. Special characters are
 * encoded as follows:
 *     "<C-a>ba" => "Ctrl+a" then "b" then "a"
 *     "<S-a>" => "A" or "Shift+a"
 *     "A" => "A"
 *     "<M-a> " => "Alt+a" (<A-a>) or "Meta+a"(<M-a>) (most terminals can't
 * really differentiate between these characters) "a<C-b><C-a>" => "a" then
 * "Ctrl+b" then "Ctrl+a" (also works for Shift, Alt and Super)
 *     "<CSM-b>" => "Ctrl+Shift+Alt+b" (the ordering doesn't matter)
 *     "a " => "a" then a literal space (" ")
 *     "å🙂" => "å" then "🙂" (full Unicode support!)
 *     "<ESC>" => escape key
 *     "<F3>" => F3 key
 *     "<BACKSPACE>" => backspace key (and so forth)
 *     "<DASH>" => a literal "-"
 *     "<ANGULAR_BRACKET_OPEN>" or "<ABO>"  => a literal "<"
 *     "<ANGULAR_BRACKET_CLOSE>" or "<ABC>" => a literal ">"
 *
 * The callback MUST be registered first by calling
 * `trinitrix.api.register_function()` the returned value can than be used to
 * set the keymap.
 */
struct keymaps
{
  int (*add) ();
  int (*remove) ();
  int (*get) ();
};

/**
 * This namespace is used to store some command specific data (like functions,
 * as ensuring memory locations stay allocated in garbage collected language is
 * hard)
 *
 * Treat it as an implementation detail
 */
struct __private
{
};

/**
 * Functions only used internally within Trinitrix
 */
struct raw
{
  int (*raise_error) ();
  int (*display_output) ();
  int (*send_input_unprocessed) ();
  struct __private __private;
};

/**
 * General API to change stuff in Trinitrix
 */
struct api
{
  int (*exit) (void);
  int (*room_message_send) ();
  struct ui ui;
  struct keymaps keymaps;
  struct raw raw;
};

struct trinitrix
{
  struct std std;
  struct api api;
};

const struct std std = {};
const struct ui ui = {
  .set_mode = trinitrix_api_ui_set_mode,
  .cycle_planes = trinitrix_api_ui_cycle_planes,
  .cycle_planes_rev = trinitrix_api_ui_cycle_planes_rev,
};
const struct keymaps keymaps = {
  .add = trinitrix_api_keymaps_add,
  .remove = trinitrix_api_keymaps_remove,
  .get = trinitrix_api_keymaps_get,
};
const struct __private __private = {};
const struct raw raw = {
  .raise_error = trinitrix_api_raw_raise_error,
  .display_output = trinitrix_api_raw_display_output,
  .send_input_unprocessed = trinitrix_api_raw_send_input_unprocessed,
  .__private = __private,
};
const struct api api = {
  .exit = trinitrix_api_exit,
  .room_message_send = trinitrix_api_room_message_send,
  .ui = ui,
  .keymaps = keymaps,
  .raw = raw,
};
const struct trinitrix trinitrix = {
  .std = std,
  .api = api,
};

#endif // if !defined TRIXY_MAIN_HEADER
// vim: filetype=c
```