isobus_virtual_terminal_client.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef ISOBUS_VIRTUAL_TERMINAL_CLIENT_HPP
#define ISOBUS_VIRTUAL_TERMINAL_CLIENT_HPP
 
#include "isobus/isobus/can_internal_control_function.hpp"
#include "isobus/isobus/can_partnered_control_function.hpp"
#include "isobus/isobus/isobus_language_command_interface.hpp"
#include "isobus/isobus/isobus_virtual_terminal_objects.hpp"
#include "isobus/utility/event_dispatcher.hpp"
#include "isobus/utility/processing_flags.hpp"
#include "isobus/utility/thread_synchronization.hpp"
 
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#if !defined CAN_STACK_DISABLE_THREADS && !defined ARDUINO
#include <thread>
#endif
 
namespace isobus
{
    //================================================================================================
    //================================================================================================
    class VirtualTerminalClient
    {
    public:
        enum class Function : std::uint8_t
        {
            SoftKeyActivationMessage = 0x00,
            ButtonActivationMessage = 0x01,
            PointingEventMessage = 0x02,
            VTSelectInputObjectMessage = 0x03,
            VTESCMessage = 0x04,
            VTChangeNumericValueMessage = 0x05,
            VTChangeActiveMaskMessage = 0x06,
            VTChangeSoftKeyMaskMessage = 0x07,
            VTChangeStringValueMessage = 0x08,
            VTOnUserLayoutHideShowMessage = 0x09,
            VTControlAudioSignalTerminationMessage = 0x0A,
            ObjectPoolTransferMessage = 0x11,
            EndOfObjectPoolMessage = 0x12,
            AuxiliaryAssignmentTypeOneCommand = 0x20,
            AuxiliaryInputTypeOneStatus = 0x21,
            PreferredAssignmentCommand = 0x22,
            AuxiliaryInputTypeTwoMaintenanceMessage = 0x23,
            AuxiliaryAssignmentTypeTwoCommand = 0x24,
            AuxiliaryInputStatusTypeTwoEnableCommand = 0x25,
            AuxiliaryInputTypeTwoStatusMessage = 0x26,
            AuxiliaryCapabilitiesRequest = 0x27,
            SelectActiveWorkingSet = 0x90,
            ESCCommand = 0x92,
            HideShowObjectCommand = 0xA0,
            EnableDisableObjectCommand = 0xA1,
            SelectInputObjectCommand = 0xA2,
            ControlAudioSignalCommand = 0xA3,
            SetAudioVolumeCommand = 0xA4,
            ChangeChildLocationCommand = 0xA5,
            ChangeSizeCommand = 0xA6,
            ChangeBackgroundColourCommand = 0xA7,
            ChangeNumericValueCommand = 0xA8,
            ChangeEndPointCommand = 0xA9,
            ChangeFontAttributesCommand = 0xAA,
            ChangeLineAttributesCommand = 0xAB,
            ChangeFillAttributesCommand = 0xAC,
            ChangeActiveMaskCommand = 0xAD,
            ChangeSoftKeyMaskCommand = 0xAE,
            ChangeAttributeCommand = 0xAF,
            ChangePriorityCommand = 0xB0,
            ChangeListItemCommand = 0xB1,
            DeleteObjectPoolCommand = 0xB2,
            ChangeStringValueCommand = 0xB3,
            ChangeChildPositionCommand = 0xB4,
            ChangeObjectLabelCommand = 0xB5,
            ChangePolygonPointCommand = 0xB6,
            ChangePolygonScaleCommand = 0xB7,
            GraphicsContextCommand = 0xB8,
            GetAttributeValueMessage = 0xB9,
            SelectColourMapCommand = 0xBA,
            IdentifyVTMessage = 0xBB,
            ExecuteExtendedMacroCommand = 0xBC,
            LockUnlockMaskCommand = 0xBD,
            ExecuteMacroCommand = 0xBE,
            GetMemoryMessage = 0xC0,
            GetSupportedWidecharsMessage = 0xC1,
            GetNumberOfSoftKeysMessage = 0xC2,
            GetTextFontDataMessage = 0xC3,
            GetWindowMaskDataMessage = 0xC4,
            GetSupportedObjectsMessage = 0xC5,
            GetHardwareMessage = 0xC7,
            StoreVersionCommand = 0xD0,
            LoadVersionCommand = 0xD1,
            DeleteVersionCommand = 0xD2,
            ExtendedGetVersionsMessage = 0xD3,
            ExtendedStoreVersionCommand = 0xD4,
            ExtendedLoadVersionCommand = 0xD5,
            ExtendedDeleteVersionCommand = 0xD6,
            GetVersionsMessage = 0xDF,
            GetVersionsResponse = 0xE0,
            UnsupportedVTFunctionMessage = 0xFD,
            VTStatusMessage = 0xFE,
            WorkingSetMaintenanceMessage = 0xFF
        };
 
        enum class HideShowObjectCommand : std::uint8_t
        {
            HideObject = 0, 
            ShowObject = 1 
        };
 
        enum class EnableDisableObjectCommand : std::uint8_t
        {
            DisableObject = 0, 
            EnableObject = 1 
        };
 
        enum class SelectInputObjectOptions : std::uint8_t
        {
            ActivateObjectForDataInput = 0x00, 
            SetFocusToObject = 0xFF 
        };
 
        enum class VTVersion
        {
            Version2OrOlder, 
            Version3, 
            Version4, 
            Version5, 
            Version6, 
            ReservedOrUnknown, 
        };
 
        enum class LineDirection : std::uint8_t
        {
            TopLeftToBottomRightOfEnclosingVirtualRectangle = 0, 
            BottomLeftToTopRightOfEnclosingVirtualRectangle = 1 
        };
 
        enum class FontSize : std::uint8_t
        {
            Size6x8 = 0, 
            Size8x8 = 1, 
            Size8x12 = 2, 
            Size12x16 = 3, 
            Size16x16 = 4, 
            Size16x24 = 5, 
            Size24x32 = 6, 
            Size32x32 = 7, 
            Size32x48 = 8, 
            Size48x64 = 9, 
            Size64x64 = 10, 
            Size64x96 = 11, 
            Size96x128 = 12, 
            Size128x128 = 13, 
            Size128x192 = 14 
        };
 
        enum class FontStyleBits : std::uint8_t
        {
            Bold = 0, 
            CrossedOut = 1, 
            Underlined = 2, 
            Italic = 3, 
            Inverted = 4, 
            Flashing = 5, 
            FlashingHidden = 6, 
            ProportionalFontRendering = 7 
        };
 
        enum class FontType : std::uint8_t
        {
            ISO8859_1 = 0, 
            ISO8859_15 = 1, 
            ISO8859_2 = 2, 
            Reserved_1 = 3, 
            ISO8859_4 = 4, 
            ISO8859_5 = 5, 
            Reserved_2 = 6, 
            ISO8859_7 = 7, 
            ReservedEnd = 239, 
            ProprietaryBegin = 240, 
            ProprietaryEnd = 255 
        };
 
        enum class FillType : std::uint8_t
        {
            NoFill = 0, 
            FillWithLineColour = 1, 
            FillWithSpecifiedColourInFillColourAttribute = 2, 
            FillWithPatternGivenByFillPatternAttribute = 3 
        };
 
        enum class MaskType : std::uint8_t
        {
            DataMask = 1, 
            AlarmMask = 2 
        };
 
        enum class AlarmMaskPriority : std::uint8_t
        {
            High = 0, 
            Medium = 1, 
            Low = 2 
        };
 
        enum class MaskLockState : std::uint8_t
        {
            UnlockMask = 0, 
            LockMask = 1 
        };
 
        enum class KeyActivationCode : std::uint8_t
        {
            ButtonUnlatchedOrReleased = 0, 
            ButtonPressedOrLatched = 1, 
            ButtonStillHeld = 2, 
            ButtonPressAborted = 3 
        };
 
        enum class ESCMessageErrorCode : std::uint8_t
        {
            NoError = 0, 
            NoInputFieldOpen = 1, 
            OtherError = 5 
        };
 
        enum class MacroEventID : std::uint8_t
        {
            Reserved = 0, 
            OnActivate = 1, 
            OnDeactivate = 2, 
            OnShow = 3, 
            OnHide = 4, 
            OnEnable = 5, 
            OnDisable = 6, 
            OnChangeActiveMask = 7, 
            OnChangeSoftKeyMask = 8, 
            OnChangeAttribute = 9, 
            OnChangeBackgroundColour = 10, 
            OnChangeFontAttributes = 11, 
            OnChangeLineAttributes = 12, 
            OnChangeFillAttributes = 13, 
            OnChangeChildLocation = 14, 
            OnChangeSize = 15, 
            OnChangeValue = 16, 
            OnChangePriority = 17, 
            OnChangeEndPoint = 18, 
            OnInputFieldSelection = 19, 
            OnInputFieldDeselection = 20, 
            OnESC = 21, 
            OnEntryOfValue = 22, 
            OnEntryOfNewValue = 23, 
            OnKeyPress = 24, 
            OnKeyRelease = 25, 
            OnChangeChildPosition = 26, 
            OnPointingEventPress = 27, 
            OnPointingEventRelease = 28, 
            ReservedBegin = 29, 
            ReservedEnd = 254, 
            UseExtendedMacroReference = 255 
        };
 
        enum class GraphicMode : std::uint8_t
        {
            Monochrome = 0, 
            SixteenColour = 1, 
            TwoHundredFiftySixColour = 2 
        };
 
        enum class AuxiliaryTypeTwoFunctionType : std::uint8_t
        {
            BooleanLatching = 0, 
            AnalogueLatching = 1, 
            BooleanMomentary = 2, 
            AnalogueMomentaryTwoWay = 3, 
            AnalogueMomentaryOneWay = 4, 
            DualBooleanLatching = 5, 
            DualBooleanMomentary = 6, 
            DualBooleanLatchingUpOnly = 7, 
            DualBooleanLatchingDownpOnly = 8, 
            AnalogueMomentaryBooleanLatching = 9, 
            AnalogueLatchingBooleanLatching = 10, 
            QuadratureBooleanMomentary = 11, 
            QuadratureAnalogueLatching = 12, 
            QuadratureAnalogueMomentary = 13, 
            BidirectionalEncoder = 14, 
            Reserved = 30, 
            ReservedRemoveAssignment = 31 
        };
 
        enum class StateMachineState : std::uint8_t
        {
            Disconnected, 
            WaitForPartnerVTStatusMessage, 
            SendWorkingSetMasterMessage, 
            ReadyForObjectPool, 
            SendGetMemory, 
            WaitForGetMemoryResponse, 
            SendGetNumberSoftkeys, 
            WaitForGetNumberSoftKeysResponse, 
            SendGetTextFontData, 
            WaitForGetTextFontDataResponse, 
            SendGetHardware, 
            WaitForGetHardwareResponse, 
            SendGetVersions, 
            WaitForGetVersionsResponse, 
            SendStoreVersion, 
            WaitForStoreVersionResponse, 
            SendLoadVersion, 
            WaitForLoadVersionResponse, 
            UploadObjectPool, 
            SendEndOfObjectPool, 
            WaitForEndOfObjectPoolResponse, 
            Connected, 
            Failed 
        };
 
        class AssignedAuxiliaryFunction
        {
        public:
            AssignedAuxiliaryFunction(std::uint16_t functionObjectID, std::uint16_t inputObjectID, AuxiliaryTypeTwoFunctionType functionType);
 
            bool operator==(const AssignedAuxiliaryFunction &other) const;
 
            std::uint16_t functionObjectID; 
            std::uint16_t inputObjectID; 
            AuxiliaryTypeTwoFunctionType functionType; 
        };
 
        VirtualTerminalClient(std::shared_ptr<PartneredControlFunction> partner, std::shared_ptr<InternalControlFunction> clientSource);
 
        VirtualTerminalClient(VirtualTerminalClient &) = delete;
 
        ~VirtualTerminalClient();
 
        // Setup Functions
        void initialize(bool spawnThread);
 
        bool get_is_initialized() const;
 
        bool get_is_connected() const;
 
        void terminate();
 
        void restart_communication();
 
        std::shared_ptr<PartneredControlFunction> get_partner_control_function() const;
 
        std::shared_ptr<InternalControlFunction> get_internal_control_function() const;
 
        std::uint8_t get_active_working_set_master_address() const;
 
        struct VTKeyEvent
        {
            VirtualTerminalClient *parentPointer; 
            std::uint16_t objectID; 
            std::uint16_t parentObjectID; 
            std::uint8_t keyNumber; 
            KeyActivationCode keyEvent; 
        };
 
        struct VTPointingEvent
        {
            VirtualTerminalClient *parentPointer; 
            std::uint16_t xPosition; 
            std::uint16_t yPosition; 
            std::uint16_t parentObjectID; 
            KeyActivationCode keyEvent; 
        };
 
        struct VTSelectInputObjectEvent
        {
            VirtualTerminalClient *parentPointer; 
            std::uint16_t objectID; 
            bool objectSelected; 
            bool objectOpenForInput; 
        };
 
        struct VTESCMessageEvent
        {
            VirtualTerminalClient *parentPointer; 
            std::uint16_t objectID; 
            ESCMessageErrorCode errorCode; 
        };
 
        struct VTChangeNumericValueEvent
        {
            VirtualTerminalClient *parentPointer; 
            std::uint32_t value; 
            std::uint16_t objectID; 
        };
 
        struct VTChangeActiveMaskEvent
        {
            VirtualTerminalClient *parentPointer; 
            std::uint16_t maskObjectID; 
            std::uint16_t errorObjectID; 
            std::uint16_t parentObjectID; 
            bool missingObjects; 
            bool maskOrChildHasErrors; 
            bool anyOtherError; 
            bool poolDeleted; 
        };
 
        struct VTChangeSoftKeyMaskEvent
        {
            VirtualTerminalClient *parentPointer; 
            std::uint16_t dataOrAlarmMaskObjectID; 
            std::uint16_t softKeyMaskObjectID; 
            bool missingObjects; 
            bool maskOrChildHasErrors; 
            bool anyOtherError; 
            bool poolDeleted; 
        };
 
        struct VTChangeStringValueEvent
        {
            std::string value; 
            VirtualTerminalClient *parentPointer; 
            std::uint16_t objectID; 
        };
 
        struct VTUserLayoutHideShowEvent
        {
            VirtualTerminalClient *parentPointer; 
            std::uint16_t objectID; 
            bool isHidden; 
        };
 
        struct VTAudioSignalTerminationEvent
        {
            VirtualTerminalClient *parentPointer; 
            bool isTerminated; 
        };
 
        struct AuxiliaryFunctionEvent
        {
            AssignedAuxiliaryFunction function; 
            VirtualTerminalClient *parentPointer; 
            std::uint16_t value1; 
            std::uint16_t value2; 
        };
 
        EventDispatcher<VTKeyEvent> &get_vt_soft_key_event_dispatcher();
 
        EventDispatcher<VTKeyEvent> &get_vt_button_event_dispatcher();
 
        EventDispatcher<VTPointingEvent> &get_vt_pointing_event_dispatcher();
 
        EventDispatcher<VTSelectInputObjectEvent> &get_vt_select_input_object_event_dispatcher();
 
        EventDispatcher<VTESCMessageEvent> &get_vt_esc_message_event_dispatcher();
 
        EventDispatcher<VTChangeNumericValueEvent> &get_vt_change_numeric_value_event_dispatcher();
 
        EventDispatcher<VTChangeActiveMaskEvent> &get_vt_change_active_mask_event_dispatcher();
 
        EventDispatcher<VTChangeSoftKeyMaskEvent> &get_vt_change_soft_key_mask_event_dispatcher();
 
        EventDispatcher<VTChangeStringValueEvent> &get_vt_change_string_value_event_dispatcher();
 
        EventDispatcher<VTUserLayoutHideShowEvent> &get_vt_user_layout_hide_show_event_dispatcher();
 
        EventDispatcher<VTAudioSignalTerminationEvent> &get_vt_control_audio_signal_termination_event_dispatcher();
 
        EventDispatcher<AuxiliaryFunctionEvent> &get_auxiliary_function_event_dispatcher();
 
        void set_auxiliary_input_model_identification_code(std::uint16_t modelIdentificationCode);
 
        bool get_auxiliary_input_learn_mode_enabled() const;
 
        void add_auxiliary_input_object_id(const std::uint16_t auxiliaryInputID);
 
        void remove_auxiliary_input_object_id(const std::uint16_t auxiliaryInputID);
 
        void update_auxiliary_input(const std::uint16_t auxiliaryInputID, const std::uint16_t value1, const std::uint16_t value2, const bool controlLocked = false);
 
        // Command Messages
 
        bool send_hide_show_object(std::uint16_t objectID, HideShowObjectCommand command);
 
        bool send_enable_disable_object(std::uint16_t objectID, EnableDisableObjectCommand command);
 
        bool send_select_input_object(std::uint16_t objectID, SelectInputObjectOptions option);
 
        bool send_ESC();
 
        bool send_control_audio_signal(std::uint8_t activations, std::uint16_t frequency_hz, std::uint16_t duration_ms, std::uint16_t offTimeDuration_ms);
 
        bool send_set_audio_volume(std::uint8_t volume_percent);
 
        bool send_change_child_location(std::uint16_t objectID, std::uint16_t parentObjectID, std::uint8_t relativeXPositionChange, std::uint8_t relativeYPositionChange);
 
        bool send_change_child_position(std::uint16_t objectID, std::uint16_t parentObjectID, std::uint16_t xPosition, std::uint16_t yPosition);
 
        bool send_change_size_command(std::uint16_t objectID, std::uint16_t newWidth, std::uint16_t newHeight);
 
        bool send_change_background_colour(std::uint16_t objectID, std::uint8_t colour);
 
        bool send_change_numeric_value(std::uint16_t objectID, std::uint32_t value);
 
        bool send_change_string_value(std::uint16_t objectID, uint16_t stringLength, const char *value);
 
        bool send_change_string_value(std::uint16_t objectID, const std::string &value);
 
        bool send_change_endpoint(std::uint16_t objectID, std::uint16_t width_px, std::uint16_t height_px, LineDirection direction);
 
        bool send_change_font_attributes(std::uint16_t objectID, std::uint8_t colour, FontSize size, std::uint8_t type, std::uint8_t styleBitfield);
 
        bool send_change_line_attributes(std::uint16_t objectID, std::uint8_t colour, std::uint8_t width, std::uint16_t lineArtBitmask);
 
        bool send_change_fill_attributes(std::uint16_t objectID, FillType fillType, std::uint8_t colour, std::uint16_t fillPatternObjectID);
 
        bool send_change_active_mask(std::uint16_t workingSetObjectID, std::uint16_t newActiveMaskObjectID);
 
        bool send_change_softkey_mask(MaskType type, std::uint16_t dataOrAlarmMaskObjectID, std::uint16_t newSoftKeyMaskObjectID);
 
        bool send_change_attribute(std::uint16_t objectID, std::uint8_t attributeID, std::uint32_t value);
 
        bool send_change_attribute(std::uint16_t objectID, std::uint8_t attributeID, float value);
 
        bool send_change_priority(std::uint16_t alarmMaskObjectID, AlarmMaskPriority priority);
 
        bool send_change_list_item(std::uint16_t objectID, std::uint8_t listIndex, std::uint16_t newObjectID);
 
        bool send_lock_unlock_mask(MaskLockState state, std::uint16_t objectID, std::uint16_t timeout_ms);
 
        bool send_execute_macro(std::uint16_t objectID);
 
        bool send_change_object_label(std::uint16_t objectID, std::uint16_t labelStringObjectID, std::uint8_t fontType, std::uint16_t graphicalDesignatorObjectID);
 
        bool send_change_polygon_point(std::uint16_t objectID, std::uint8_t pointIndex, std::uint16_t newXValue, std::uint16_t newYValue);
 
        bool send_change_polygon_scale(std::uint16_t objectID, std::uint16_t widthAttribute, std::uint16_t heightAttribute);
 
        bool send_select_colour_map_or_palette(std::uint16_t objectID);
 
        bool send_execute_extended_macro(std::uint16_t objectID);
 
        bool send_select_active_working_set(std::uint64_t NAMEofWorkingSetMasterForDesiredWorkingSet);
 
        // Graphics Context Commands:
        bool send_set_graphics_cursor(std::uint16_t objectID, std::int16_t xPosition, std::int16_t yPosition);
 
        bool send_move_graphics_cursor(std::uint16_t objectID, std::int16_t xOffset, std::int16_t yOffset);
 
        bool send_set_foreground_colour(std::uint16_t objectID, std::uint8_t colour);
 
        bool send_set_background_colour(std::uint16_t objectID, std::uint8_t colour);
 
        bool send_set_line_attributes_object_id(std::uint16_t objectID, std::uint16_t lineAttributeobjectID);
 
        bool send_set_fill_attributes_object_id(std::uint16_t objectID, std::uint16_t fillAttributeobjectID);
 
        bool send_set_font_attributes_object_id(std::uint16_t objectID, std::uint16_t fontAttributesObjectID);
 
        bool send_erase_rectangle(std::uint16_t objectID, std::uint16_t width, std::uint16_t height);
 
        bool send_draw_point(std::uint16_t objectID, std::int16_t xOffset, std::int16_t yOffset);
 
        bool send_draw_line(std::uint16_t objectID, std::int16_t xOffset, std::int16_t yOffset);
 
        bool send_draw_rectangle(std::uint16_t objectID, std::uint16_t width, std::uint16_t height);
 
        bool send_draw_closed_ellipse(std::uint16_t objectID, std::uint16_t width, std::uint16_t height);
 
        bool send_draw_polygon(std::uint16_t objectID, std::uint8_t numberOfPoints, const std::int16_t *listOfXOffsetsRelativeToCursor, const std::int16_t *listOfYOffsetsRelativeToCursor);
 
        bool send_draw_text(std::uint16_t objectID, bool transparent, std::uint8_t textLength, const char *value);
 
        bool send_pan_viewport(std::uint16_t objectID, std::int16_t xAttribute, std::int16_t yAttribute);
 
        bool send_zoom_viewport(std::uint16_t objectID, float zoom);
 
        bool send_pan_and_zoom_viewport(std::uint16_t objectID, std::int16_t xAttribute, std::int16_t yAttribute, float zoom);
 
        bool send_change_viewport_size(std::uint16_t objectID, std::uint16_t width, std::uint16_t height);
 
        bool send_draw_vt_object(std::uint16_t graphicsContextObjectID, std::uint16_t VTObjectID);
 
        bool send_copy_canvas_to_picture_graphic(std::uint16_t graphicsContextObjectID, std::uint16_t objectID);
 
        bool send_copy_viewport_to_picture_graphic(std::uint16_t graphicsContextObjectID, std::uint16_t objectID);
 
        // VT Querying
        bool send_get_attribute_value(std::uint16_t objectID, std::uint8_t attributeID);
 
        // Get Softkeys Response
        std::uint8_t get_softkey_x_axis_pixels() const;
 
        std::uint8_t get_softkey_y_axis_pixels() const;
 
        std::uint8_t get_number_virtual_softkeys() const;
 
        std::uint8_t get_number_physical_softkeys() const;
 
        // Get Text Font Data Response
        bool get_font_size_supported(FontSize value) const;
 
        bool get_font_style_supported(FontStyleBits value) const;
 
        // Get Hardware Responses
        GraphicMode get_graphic_mode() const;
 
        bool get_support_touchscreen_with_pointing_message() const;
 
        bool get_support_pointing_device_with_pointing_message() const;
 
        bool get_multiple_frequency_audio_output() const;
 
        bool get_has_adjustable_volume_output() const;
 
        bool get_support_simultaneous_activation_physical_keys() const;
 
        bool get_support_simultaneous_activation_buttons_and_softkeys() const;
 
        bool get_support_drag_operation() const;
 
        bool get_support_intermediate_coordinates_during_drag_operations() const;
 
        std::uint16_t get_number_x_pixels() const;
 
        std::uint16_t get_number_y_pixels() const;
 
        VTVersion get_connected_vt_version() const;
 
        bool is_vt_version_supported(VTVersion value) const;
 
        std::uint16_t get_visible_data_mask() const;
 
        std::uint16_t get_visible_soft_key_mask() const;
 
        // ************************************************
        // Object Pool Interface
        // ************************************************
        // These are the functions for specifying your pool to upload.
        // You have a few options:
        // 1. Upload in one blob of contigious memory
        // This is good for small pools or pools where you have all the data in memory.
        // 2. Get a callback at some interval to provide data in chunks
        // This is probably better for huge pools if you are RAM constrained, or if your
        // pool is stored on some external device that you need to get data from in pages.
        // This is also the best way to load from IOP files!
        // If using callbacks, The object pool and pointer MUST NOT be deleted or leave scope until upload is done.
        // Version must be the same for all pools uploaded to this VT server!!!
 
        void set_object_pool(std::uint8_t poolIndex,
                             const std::uint8_t *pool,
                             std::uint32_t size,
                             std::string version = "");
 
        void set_object_pool(std::uint8_t poolIndex,
                             const std::vector<std::uint8_t> *pool,
                             std::string version = "");
 
        void set_object_pool_scaling(std::uint8_t poolIndex,
                                     std::uint32_t originalDataMaskDimensions_px,
                                     std::uint32_t originalSoftKyeDesignatorHeight_px);
 
        void register_object_pool_data_chunk_callback(std::uint8_t poolIndex, std::uint32_t poolTotalSize, DataChunkCallback value, std::string version = "");
 
        void update();
 
        LanguageCommandInterface languageCommandInterface;
 
    protected:
        enum class GraphicsContextSubCommandID : std::uint8_t
        {
            SetGraphicsCursor = 0x00, 
            MoveGraphicsCursor = 0x01, 
            SetForegroundColour = 0x02, 
            SetBackgroundColour = 0x03, 
            SetLineAttributesObjectID = 0x04, 
            SetFillAttributesObjectID = 0x05, 
            SetFontAttributesObjectID = 0x06, 
            EraseRectangle = 0x07, 
            DrawPoint = 0x08, 
            DrawLine = 0x09, 
            DrawRectangle = 0x0A, 
            DrawClosedEllipse = 0x0B, 
            DrawPolygon = 0x0C, 
            DrawText = 0x0D, 
            PanViewport = 0x0E, 
            ZoomViewport = 0x0F, 
            PanAndZoomViewport = 0x10, 
            ChangeViewportSize = 0x11, 
            DrawVTObject = 0x12, 
            CopyCanvasToPictureGraphic = 0x13, 
            CopyViewportToPictureGraphic = 0x14 
        };
 
        enum class TransmitFlags : std::uint32_t
        {
            SendWorkingSetMaintenance = 0, 
            SendAuxiliaryMaintenance = 1, 
 
            NumberFlags 
        };
 
        enum class CurrentObjectPoolUploadState : std::uint8_t
        {
            Uninitialized, 
            InProgress, 
            Success, 
            Failed 
        };
 
        struct ObjectPoolDataStruct
        {
            const std::uint8_t *objectPoolDataPointer; 
            const std::vector<std::uint8_t> *objectPoolVectorPointer; 
            std::vector<std::uint8_t> scaledObjectPool; 
            DataChunkCallback dataCallback; 
            std::string versionLabel; 
            std::uint32_t objectPoolSize; 
            std::uint32_t autoScaleDataMaskOriginalDimension; 
            std::uint32_t autoScaleSoftKeyDesignatorOriginalHeight; 
            bool useDataCallback; 
            bool uploaded; 
        };
 
        struct AssignedAuxiliaryInputDevice
        {
            const std::uint64_t name; 
            const std::uint16_t modelIdentificationCode; 
            std::vector<AssignedAuxiliaryFunction> functions; 
        };
 
        struct AuxiliaryInputState
        {
            std::uint64_t lastStatusUpdate; 
            bool enabled; 
            bool hasInteraction; 
            bool controlLocked; 
            std::uint16_t value1; 
            std::uint16_t value2; 
        };
 
        static constexpr std::uint64_t AUXILIARY_INPUT_STATUS_DELAY = 1000; 
        static constexpr std::uint64_t AUXILIARY_INPUT_STATUS_DELAY_INTERACTION = 50; 
 
        bool send_message_to_vt(const std::uint8_t *dataBuffer, std::uint32_t dataLength, CANIdentifier::CANPriority priority = CANIdentifier::CANPriority::Priority5) const;
 
        // Object Pool Managment
        bool send_delete_object_pool() const;
 
        bool send_working_set_maintenance(bool initializing) const;
 
        bool send_get_memory(std::uint32_t requiredMemory) const;
 
        bool send_get_number_of_softkeys() const;
 
        bool send_get_text_font_data() const;
 
        bool send_get_hardware() const;
 
        bool send_get_supported_widechars() const;
 
        bool send_get_window_mask_data() const;
 
        bool send_get_supported_objects() const;
 
        bool send_get_versions() const;
 
        bool send_store_version(std::array<std::uint8_t, 7> versionLabel) const;
 
        bool send_load_version(std::array<std::uint8_t, 7> versionLabel) const;
 
        bool send_delete_version(std::array<std::uint8_t, 7> versionLabel) const;
 
        bool send_extended_get_versions() const;
 
        bool send_extended_store_version(std::array<std::uint8_t, 32> versionLabel) const;
 
        bool send_extended_load_version(std::array<std::uint8_t, 32> versionLabel) const;
 
        bool send_extended_delete_version(std::array<std::uint8_t, 32> versionLabel) const;
 
        bool send_end_of_object_pool() const;
 
        bool send_working_set_master() const;
 
        bool send_auxiliary_functions_preferred_assignment() const;
 
        bool send_auxiliary_function_assignment_response(std::uint16_t functionObjectID, bool hasError, bool isAlreadyAssigned) const;
 
        bool send_auxiliary_input_maintenance() const;
 
        bool send_auxiliary_input_status_enable_response(std::uint16_t objectID, bool isEnabled, bool hasError) const;
 
        void update_auxiliary_input_status();
 
        bool update_auxiliary_input_status(std::uint16_t objectID);
 
        void set_state(StateMachineState value);
 
        static void process_flags(std::uint32_t flag, void *parent);
 
        static void process_rx_message(const CANMessage &message, void *parentPointer);
 
        static void process_callback(std::uint32_t parameterGroupNumber,
                                     std::uint32_t dataLength,
                                     std::shared_ptr<InternalControlFunction> sourceControlFunction,
                                     std::shared_ptr<ControlFunction> destinationControlFunction,
                                     bool successful,
                                     void *parentPointer);
 
        static bool process_internal_object_pool_upload_callback(std::uint32_t callbackIndex,
                                                                 std::uint32_t bytesOffset,
                                                                 std::uint32_t numberOfBytesNeeded,
                                                                 std::uint8_t *chunkBuffer,
                                                                 void *parentPointer);
 
        bool get_any_pool_needs_scaling() const;
 
        bool scale_object_pools();
 
        static bool get_is_object_scalable(VirtualTerminalObjectType type);
 
        FontSize get_font_or_next_smallest_font(FontSize originalFont) const;
 
        static FontSize remap_font_to_scale(FontSize originalFont, float scaleFactor);
 
        static std::uint32_t get_minimum_object_length(VirtualTerminalObjectType type);
 
        static std::uint32_t get_number_bytes_in_object(std::uint8_t *buffer);
 
        static void process_standard_object_height_and_width(std::uint8_t *buffer, float scaleFactor);
 
        bool resize_object(std::uint8_t *buffer, float scaleFactor, VirtualTerminalObjectType type);
 
        bool is_function_unsupported(Function function) const;
 
        bool is_function_unsupported(std::uint8_t functionCode) const;
 
        bool send_command(const std::vector<std::uint8_t> &data);
 
        bool queue_command(const std::vector<std::uint8_t> &data, bool replace = false);
 
        bool replace_command(const std::vector<std::uint8_t> &data);
 
        void process_command_queue();
 
        void worker_thread_function();
 
        static constexpr std::uint32_t VT_STATUS_TIMEOUT_MS = 3000; 
        static constexpr std::uint32_t WORKING_SET_MAINTENANCE_TIMEOUT_MS = 1000; 
        static constexpr std::uint32_t AUXILIARY_MAINTENANCE_TIMEOUT_MS = 100; 
 
        std::shared_ptr<PartneredControlFunction> partnerControlFunction; 
        std::shared_ptr<InternalControlFunction> myControlFunction; 
 
        ProcessingFlags txFlags; 
 
        // Status message contents from the VT
        std::uint32_t lastVTStatusTimestamp_ms = 0; 
        std::uint16_t activeWorkingSetDataMaskObjectID = NULL_OBJECT_ID; 
        std::uint16_t activeWorkingSetSoftKeyMaskObjectID = NULL_OBJECT_ID; 
        std::uint8_t activeWorkingSetMasterAddress = NULL_CAN_ADDRESS; 
        std::uint8_t busyCodesBitfield = 0; 
        std::uint8_t currentCommandFunctionCode = 0; 
 
        std::uint8_t connectedVTVersion = 0; 
 
        // Softkey capabilities
        std::uint8_t softKeyXAxisPixels = 0; 
        std::uint8_t softKeyYAxisPixels = 0; 
        std::uint8_t numberVirtualSoftkeysPerSoftkeyMask = 0; 
        std::uint8_t numberPhysicalSoftkeys = 0; 
 
        // Text Font Capabilities
        std::uint8_t smallFontSizesBitfield = 0; 
        std::uint8_t largeFontSizesBitfield = 0; 
        std::uint8_t fontStylesBitfield = 0; 
 
        // Hardware Capabilities, from the get hardware message
        GraphicMode supportedGraphicsMode = GraphicMode::TwoHundredFiftySixColour; 
        std::uint16_t xPixels = 0; 
        std::uint16_t yPixels = 0; 
        std::uint8_t hardwareFeaturesBitfield = 0; 
 
        // Internal client state variables
        StateMachineState state = StateMachineState::Disconnected; 
        CurrentObjectPoolUploadState currentObjectPoolState = CurrentObjectPoolUploadState::Uninitialized; 
        std::uint32_t stateMachineTimestamp_ms = 0; 
        std::uint32_t lastWorkingSetMaintenanceTimestamp_ms = 0; 
        std::uint32_t lastAuxiliaryMaintenanceTimestamp_ms = 0; 
        std::vector<ObjectPoolDataStruct> objectPools; 
        std::vector<std::uint8_t> unsupportedFunctions; 
        std::vector<AssignedAuxiliaryInputDevice> assignedAuxiliaryInputDevices; 
        std::uint16_t ourModelIdentificationCode = 1; 
        std::map<std::uint16_t, AuxiliaryInputState> ourAuxiliaryInputs; 
#if !defined CAN_STACK_DISABLE_THREADS && !defined ARDUINO
        std::thread *workerThread = nullptr; 
#endif
        bool firstTimeInState = false; 
        bool initialized = false; 
        bool sendWorkingSetMaintenance = false; 
        bool sendAuxiliaryMaintenance = false; 
        bool shouldTerminate = false; 
 
        // Command queue
        std::vector<std::vector<std::uint8_t>> commandQueue; 
        bool commandAwaitingResponse = false; 
        std::uint32_t lastCommandTimestamp_ms = 0; 
        Mutex commandQueueMutex; 
 
        // Activation event callbacks
        EventDispatcher<VTKeyEvent> softKeyEventDispatcher; 
        EventDispatcher<VTKeyEvent> buttonEventDispatcher; 
        EventDispatcher<VTPointingEvent> pointingEventDispatcher; 
        EventDispatcher<VTSelectInputObjectEvent> selectInputObjectEventDispatcher; 
        EventDispatcher<VTESCMessageEvent> escMessageEventDispatcher; 
        EventDispatcher<VTChangeNumericValueEvent> changeNumericValueEventDispatcher; 
        EventDispatcher<VTChangeActiveMaskEvent> changeActiveMaskEventDispatcher; 
        EventDispatcher<VTChangeSoftKeyMaskEvent> changeSoftKeyMaskEventDispatcher; 
        EventDispatcher<VTChangeStringValueEvent> changeStringValueEventDispatcher; 
        EventDispatcher<VTUserLayoutHideShowEvent> userLayoutHideShowEventDispatcher; 
        EventDispatcher<VTAudioSignalTerminationEvent> audioSignalTerminationEventDispatcher; 
        EventDispatcher<AuxiliaryFunctionEvent> auxiliaryFunctionEventDispatcher; 
 
        // Object Pool info
        DataChunkCallback objectPoolDataCallback = nullptr; 
        std::uint32_t lastObjectPoolIndex = 0; 
    };
 
} // namespace isobus
 
// Required for FontSize to be used as a key in std::unordered_map, issue in C++11: https://cplusplus.github.io/LWG/issue2148
#if __cplusplus < 201402L
namespace std
{
    template<>
    struct hash<isobus::VirtualTerminalClient::FontSize>
    {
        size_t operator()(const isobus::VirtualTerminalClient::FontSize &fontSize) const
        {
            return static_cast<size_t>(fontSize);
        }
    };
}
#endif
 
#endif // ISOBUS_VIRTUAL_TERMINAL_CLIENT_HPP