ApplicationApi.h

/*
ApplicationApi.h
*/
#pragma once
#ifndef __API_H__
#define __API_H__


#ifdef _WINDOWS
#if defined(_LIBDLL)
#include <Library.h>
#define SDK_API _declspec(dllexport)
#else
#define SDK_API _declspec(dllimport)
#endif
#else
#if defined(_NOEXPORT)
#include <Library.h>
#endif
#define SDK_API
#endif

#ifdef _WIN32_WCE
typedef void (_cdecl *APPLICATION_HANDLEPROC)(int nEvent, void* pData);
#elif defined _WIN32
typedef void (_stdcall *APPLICATION_HANDLEPROC)(int nEvent, void* pData);
#else
typedef void (*APPLICATION_HANDLEPROC)(int nEvent, void* pData);

typedef int             BOOL;
typedef int             INT;
typedef unsigned long   DWORD;
typedef long            LONG;
typedef unsigned char   BYTE;
typedef char            CHAR;
typedef unsigned short  WORD;
typedef short           SHORT;
typedef double          DOUBLE;
typedef unsigned int    UINT;
typedef unsigned short  USHORT;
typedef void*           LPVOID;
typedef wchar_t         WCHAR;
typedef WCHAR           TCHAR;
typedef WCHAR           TCHAR;
typedef TCHAR*          LPTSTR;
typedef const TCHAR*    LPCTSTR;
typedef void*           HWND;

#ifndef MAXLONG
#define MAXLONG     ((LONG)0x7fffffff)
#endif
#ifndef             NULL
#define NULL        0
#endif
#ifndef TRUE
#define TRUE        1
#endif
#ifndef FALSE
#define FALSE       0
#endif

#endif


#define TRUCK_VERSION

#define DEFAULT_MAX_TIME                0

#define EVENT_APP_STARTED               1010

#define EVENT_EXIT                      1100

#define EVENT_APP_CLOSED                1100

#define EVENT_ROUTE_USERCANCEL          1101

#define EVENT_WAIPOINT_VISITED          1102

#define EVENT_WAYPOINT_VISITED          1102

#define EVENT_ROUTE_FINISH              1103

#define EVENT_ROUTE_COMPUTED            1105

#define EVENT_OPTIMIZATION_FINISHED     1107

#define EVENT_ROUTE_RECOMPUTE           1106

#define EVENT_ITINERARY_CHANGED         1108

#define EVENT_ITINERARY_WARNING         1109

#define EVENT_NEXT_INSTRUCTION          1110

#define EVENT_INVISIBLE_WAYPOINT_VISITED 1111

#define EVENT_MAIN_MENU                 1150

#define EVENT_CONTEXT_MENU              1151

#define EVENT_EXIT_MENU                 1152

#define EVENT_CUSTOM_MENU               1153

#define EVENT_CHANGE_LANGUAGE           1160

#define EVENT_CHANGEORIENTATION         1161

#define EVENT_RADAR_WARNING             1170

#define EVENT_POI_WARNING               1171

#define EVENT_GEOFENCE                  1172

#define EVENT_RESTRICTED_ROAD           1173

#define EVENT_BORDER_CROSSING           1180

#define EVENT_SPEED_EXCEEDING           1181

#define BITMAP_CLICK                    1190

#define EVENT_BITMAP_CLICK              1190

#define EVENT_POI_CLICK                 1191

#define EVENT_BROWSE_MAP_EXIT           1192

#define EVENT_APP_ERROR                 1200

#define EVENT_APP_EXIT                  1200

// Trip book

typedef enum{
    tbdmNoData          = 1000,
    tbdmFullData        = 1001,
    tbdmFullNMEA        = 1002

} TripBookRecordDataMode;

// NavigationParams
class NavigationParams
{
    private: void _doxygen_() { }
    public:
    enum _NavigationParams
    {
        //NpEnable                      = 0x00000001,
        NpAskDeleteRoute                = 0x00000002,
        NpMessageAvoidMotorwaysUnable   = 0x00000004,
        NpMessageAvoidTollRoadsUnable   = 0x00000008,
        NpMessageAvoidFerriesUnable     = 0x00000010,
        NpMessageRouteUnable            = 0x00000020,
        NpMessageWaypointsDistant       = 0x00000040,
    };
};


// poi
class PoiService
{
private: void _doxygen_() { }
public:
    enum _PoiService
    {
        Rent_a_Car_Facility             = 1,
        Tourist_Information_Office      = 2,
        Museum                          = 3,
        Theatre                         = 4,
        Cultural_Centre                 = 5,
        Sports_Centre                   = 6,
        Hospital_Polyclinic             = 7,
        Police_Station                  = 8,
        City_Hall                       = 9,
        Post_Office                     = 10,
        First_Aid_Post                  = 11,
        Pharmacy                        = 12,
        Departement_Store               = 13,
        Bank                            = 14,
        Travel_Agency                   = 15,
        Public_Phone                    = 16,
        Warehouse                       = 17,
        Ski_Lift_Station                = 18,
        Zoo                             = 19,
        Scenic_Panoramic_View           = 20,
        Transport_Company               = 21,
        Casino                          = 22,
        Cinema                          = 23,
        Winery                          = 24,
        Cargo_Centre                    = 25,
        Car_Shipping_Terminal           = 26,
        Camping_Ground                  = 28,
        Caravan_Site                    = 29,
        Coach_and_Lorry_Parking         = 30,
        Community_Centre                = 31,
        Embassy                         = 33,
        Frontier_Crossing               = 34,
        Motoring_Organization_Office    = 35,
        Recreation_Facility             = 36,
        Road_Side_Diner                 = 37,
        School                          = 38,
        Shopping_Centre                 = 39,
        Stadium                         = 40,
        Toll                            = 41,
        College_University              = 42,
        Business_Facility               = 43,
        Airport                         = 44,
        Bus_Station                     = 45,
        Exhibition_Centre               = 46,
        Kindergarten                    = 47,
        Emergency_Call_Station          = 48,
        Emergency_Medical_Service       = 49,
        Fire_Brigade                    = 50,
        Freeport                        = 51,
        Company                         = 52,
        ATM                             = 53,
        Hippodrome                      = 54,
        Beach                           = 55,
        Restaurant_Area                 = 56,
        Ice_Skating_Rink                = 57,
        Courthouse                      = 58,
        Mountain_Peak                   = 59,
        Opera                           = 60,
        Concert_Hall                    = 61,
        Bovag_Garage                    = 62,
        Tennis_Court                    = 63,
        Skating_Rink                    = 64,
        Water_Sport                     = 65,
        Music_Centre                    = 66,
        Doctor                          = 67,
        Dentist                         = 68,
        Veterinarian                    = 69,
        Cafe_Pub                        = 70,
        Convention_Centre               = 71,
        Leisure_Centre                  = 72,
        Nightlife                       = 73,
        Yacht_Basin                     = 74,
        Condominium                     = 75,
        Commercial_Building             = 76,
        Industrial_Building             = 77,
        Natives_Reservation             = 78,
        Cemetery                        = 79,
        Breakdown_Service               = 81,
        Vehicle_Equipment_Provider      = 82,
        Entertainment                   = 83,
        Abbey                           = 84,
        Amusement_Park                  = 85,
        Arts_Centre                     = 86,
        Building_Footprint              = 87,
        Castle                          = 88,
        Church                          = 89,
        Factory_Ground_Philips          = 90,
        Fortress                        = 91,
        Golf_Course                     = 92,
        Holiday_Area                    = 93,
        Library                         = 94,
        Lighthouse                      = 95,
        Military_Cemetery               = 96,
        Monastery                       = 97,
        Monument                        = 98,
        Natural_Reserve                 = 99,
        Prison                          = 100,
        Rocks                           = 101,
        Sports_Hall                     = 102,
        State_Police_Office             = 103,
        Walking_Area                    = 104,
        Water_Mill                      = 105,
        Windmill                        = 106,
        Rent_a_Car_Parking              = 107,
        Car_Racetrack                   = 108,
        Mountain_Pass                   = 109,
        Swimming_Pool                   = 110,
        Government_Office               = 111,
        Parking_Garage                  = 150,
        Place_of_Worship                = 151,
        Ferry_Terminal                  = 152,
        Airline_Access                  = 153,
        Open_Parking_Area               = 154,
        Important_Tourist_Attraction    = 155,
        Railway_Station                 = 156,
        Rest_Area                       = 157,
        Shop                            = 158,
        Park_and_Recreation_Area        = 159,
        Forest_Area                     = 160,
        Military_Installation           = 161,
        Public_Transport_Stop           = 162,
        Car_Repair_Facility             = 200,
        Petrol_Station                  = 201,
        Hotel_or_Motel                  = 202,
        Restaurant                      = 203,
        Cash_Dispenser                  = 204,
        Car_Dealer                      = 205,
        USERDEFINE                      = 255
    };
};

// speed camera
class SpeedCameraType
{
private: void _doxygen_() { }
public:
    enum _SpeedCameraType
    {
        FixedSpeedCamera            = 1,
        RedLightCamera              = 2,
        SemiMobileSpeedCamera       = 3,
        FixedAverageSpeedCamera     = 4,
        MobileSpeedCamera           = 5,
        FixedRedLightAndSpeedCamera = 6,
        MobileAverageSpeedCamera    = 7,
        MobileRedLightCamera        = 8
    };
};


// menu
// {ID= 0, SubID= 0} = main menu
class CApplicationMenu
{
private: void _doxygen_() { }
public:
    class ID
    {
    private: void _doxygen_() { }
    public:
        enum {
            IdMenuMain                  = 1,
            IdMenuManagePoi             = 2,
            IdMenuViewRoute             = 3,
            IdMenuDemonstrate           = 4,
            IdMenuNavigateTo            = 5,
            IdMenuContext               = 10,
            IdMenuExtras                = 12,
            IdBrowseMap                 = 58,
            IdMenuPoiAdd                = 60,
            IdMenuMainAlternative       = 106,
            IdMenuSettings              = 131,
            IdMenuTrafic                = 132,
            IdMenuSettingsHomeLocation  = 308,
            IdMenuSettingsGps           = 328
        };
    };

    class IdMenuMain
    {
    private: void _doxygen_() { }
    public:
        enum {
            OnMainNavigateTo            = 101,
            OnMainBrowseMap             = 102,
            OnMainTraffic               = 103,
            OnMainSettings              = 104,
            OnMainManagePoi             = 105,
            OnMainAlternative           = 106,
            OnMainItinerary             = 107,
            OnViewRoute                 = 109,
            OnSettingGps                = 110,
            OnMainExit                  = 111,
            OnMainExtras                = 112,
            OnMainMemorize              = 116
        };
    };

    class IdMenuManagePoi
    {
    private: void _doxygen_() { }
    public:
        enum {
            OnPoiAdd                    = 60,
            OnPoiDelete                 = 62,
            OnPoiCategoryDelete         = 63,
            OnPoiEnable                 = 64,
            OnPoiWarnWhenNear           = 65,
            OnPoiEdit                   = 66
        };
    };

    class IdMenuViewRoute
    {
    private: void _doxygen_() { }
    public:
        enum {
            OnViewRouteInstructions     = 350,
            OnViewRouteImages           = 351,
            OnViewRouteShowOnMap        = 352,
            OnViewRouteDemonstration    = 353,
            OnViewRouteSummary          = 354,
            OnViewRouteCancel           = 355
        };
    };

    class IdMenuDemonstrate
    {
    private: void _doxygen_() { }
    public:
        enum {
            OnDemonstrateSpeed          = 400,
            OnDemonstrateRepeatOn       = 401,
            OnDemonstrateRepeatOff      = 402,
            OnDemonstrateStop           = 403,
            OnDemonstratePause          = 404,
            OnDemonstrateResume         = 405,
            OnDemonstrateStart          = 406
        };
    };

    class IdMenuSettings
    {
    private: void _doxygen_() { }
    public:
        enum {
            OnSettingsBacklight         = 301,
            OnSettingsDaylight          = 303,
            OnSettingsNight             = 304,
            OnSettingsDisableSounds     = 305,
            OnSettingsEnableSounds      = 306,
            OnSettingsAutoskin          = 307,
            OnSettingsHomeLocation      = 308,
            OnSettingsLanguage          = 309,
            OnSettingsLeft              = 310,
            OnSettingsRight             = 311,
            OnSettingsLoadMap           = 312,
            OnSettingsRegional          = 315,
            OnSettingsVersion           = 316,
            OnSettingsTollCharge        = 317,
            OnSettingsVolume            = 319,
            OnSettings3D                = 320,
            OnSettings2D                = 321,
            OnSettingsKeyboard          = 322,
            OnMainPlanning              = 323,
            OnSettingsVehicle           = 324,
            OnSettingsRotateScreen      = 325,
            OnSettingsGps               = 328,
            OnSettingsGPSLogs           = 329,
            OnSettingsQuickGuide        = 330,
            OnSettingsFeatures          = 331,
            OnSettingsVoice             = 332,
            OnSettingsSigns             = 341,
            OnSettings2DnorthUp         = 343
        };
    };

    class IdMenuTrafic
    {
    private: void _doxygen_() { }
    public:
        enum {
            OnTrafficShowAll            = 370,
            OnTrafficShowRoute          = 371,
            OnTrafficDisable            = 372,
            OnTrafficEnable             = 373,
            OnTrafficOptimize           = 374,
            OnTrafficUpdate             = 375,
            OnTrafficOptions            = 376
        };
    };

    //CApplicationMenu.ID.IdMenuNavigateTo:
    //CApplicationMenu.ID.OnPoiAdd:
    //CApplicationMenu.ID.OnSettingsHomeLocation:
    class IdMenuNavigateTo
    {
    private: void _doxygen_() { }
    public:
        enum {
            OnAddress                   = 201,
            OnFavorite                  = 202,
            OnHistory                   = 203,
            OnPoi                       = 204,
            OnZipCode                   = 205,
            OnHome                      = 206,
            OnPointOnMap                = 207,
            OnCityCentre                = 208,
            OnCurrentGps                = 209,
            OnLastValidPosition         = 210,
            OnEnterPosition             = 212
        };
    };

    class IdMenuBrowseMap
    {
    private: void _doxygen_() { }
    public:
        enum {
            OnShowMenu                  = 1,
            OnMenuFind                  = 50,
            OnMenuShowCurrentPosition   = 51,
            OnMenuShowRoute             = 52,
            OnMenuDisplayPois           = 53,
            OnMenuShowCity              = 54
        };
    };

    class IdMenuSettingsGps
    {
    private: void _doxygen_() { }
    public:
        enum {
            /* \brief OnShowMenu subID displays dialog enabling user to set GPS settings.\n
             * OnShowMenu subID calls the same function like clicking GPS hardware button in Settings menu.
             */
            OnShowMenu                  = 1,
            OnComPort                   = 222,
            OnBaudRate                  = 223
        };
    };

    class IdMenuMainAlternative
    {
    private: void _doxygen_() { }
    public:
        enum {
            OnAlternative               = 360,
            OnAvoidNext                 = 361,
            OnTravelVia                 = 363,
            OnTraffic                   = 364,
            OnOriginal                  = 365,
            OnAvoidNext_500m            = 390,
            OnAvoidNext_1km             = 391,
            OnAvoidNext_5km             = 392,
            OnAvoidNext_10km            = 393,
            OnAvoidNext_15km            = 394,
            OnAvoidNext_20km            = 395
        };
    };

    class IdMenuContext
    {
    private: void _doxygen_() { }
    public:
        enum {
            OnContextImportantPlaces    = 410,
            OnContextAvoidNext          = 411,
            OnContexAddToFavourites     = 412
        };
    };

    class IdMenuExtras
    {
    private: void _doxygen_() { }
    public:
        enum {
            /* \brief OnExtraWorldClock subID displays a dialog enabling user to see multiple time zones clock.\n
             * OnExtraWorldClock subID calls the same function like clicking World Clock button in Extras menu.
             */
            OnExtraWorldClock           = 117,
            OnExtraCountryInfo          = 121,
            OnExtraCalc                 = 123,
            OnExtraConvMain             = 124
        };
    };
};

// LONGPOSITION

struct SDK_API LONGPOSITION
{
    LONG lX;
    LONG lY;

    LONGPOSITION()
    {
        lX = 0;
        lY = 0;
    }

    LONGPOSITION(LONG x, LONG y)
        : lX(x)
        , lY(y)
    {
    }

    BOOL operator == ( LONGPOSITION position ) const
    {
        return ( position.lX == lX && position.lY == lY );
    }

    BOOL operator != ( LONGPOSITION position ) const
    {
        return position.lX != lX || position.lY != lY;
    }
};
typedef LONGPOSITION  *LPLONGPOSITION;

// LONGRECT

struct SDK_API LONGRECT
{
    /* \brief Constructor of LONGRECT.*/
    LONGRECT()
    {
        lLeft       = MAXLONG;
        lTop        = 0;
        lRight      = 0;
        lBottom     = MAXLONG;
    }
    LONG lLeft;
    LONG lTop;
    LONG lRight;
    LONG lBottom;

    BOOL operator==(LONGRECT &l)
    {
        return (l.lLeft == lLeft && l.lTop == lTop && l.lRight == lRight && l.lBottom == lBottom );
    }
};
typedef LONGRECT  *LPLONGRECT;

// SChangeOption

struct SDK_API SChangeOption
{
    enum LOAD_RESTRICTIONS{
        Explosives              = 0x00000001,
        FlammableGases          = 0x00000002,
        FlammableLiquids        = 0x00000004,
        FlammableSolids         = 0x00000008,
        Oxidizers               = 0x00000010,
        Poisonous               = 0x00000020,
        Radioactive             = 0x00000040,
        Corrosive               = 0x00000080,
        Hazardous               = 0x00000100,
        InhalationHazards       = 0x00000200,
        General                 = 0x00000400,
        Explosive               = 0x00000800,
        HarmfulToWater          = 0x00001000,
        Agriculture             = 0x00010000,
        Coal                    = 0x00020000,
        Building                = 0x00040000,
        SanitaryVaste           = 0x00080000,
        SandAndGravel           = 0x00100000,
        Commodity               = 0x00200000,
        NaturalResources        = 0x00400000
    };

    BOOL            bSoundEnabled;
    BOOL            bOperateRightHanded;

    // 0 .. 10
    int             nVolumeMin;
    int             nVolumeMax;

    //MILES(YARDS) = 0, KILOMETERS = 1, MILES(FEETS) = 2
    int             nDistanceUnit;

    //EUROPE = 0, US = 1, UK = 2
    int             nClockFormat;

    //DEGREES = 0, MINUTES = 1, SECONDS = 2
    int             nGPSUnits;

    //ABCD = 1, QWERTY = 2, AZERTY = 3, DVORAK = 4
    int             nKeyboardType;

    // ASK = 1, ALWAYS = 2, NEVER = 3
    int             nAvoidTollRoads;

    BOOL            bAvoidUTurns;

    // ASK=1, FASTEST=2, SHORTEST=3, AVOIDING_MOTORWAYS=4, WALKS=5, BIKES=6, LIMITED=7
    int             nPlanningSettings;

    int             nPlanningSettingsLimitedSpeed;

    BOOL            bAvoidFerries;

    BOOL            bDisableMainMenu;
    BOOL            bDisableRecompute;

    int             nETAMaximumSpeed;
    int             nETAPercentageChange;

    BOOL            bRadarsWarnOn;
    BOOL            bRadarsVisible;
    int             nRadarDistance;
    int             nRadarDistanceInCity;

    int             nSkin; // DAY = 0, NIGHT = 1, AUTO = 2

    int             nTimeZone;

    BOOL            bHideMapCursor;

    int             nSpeedExceedInCity;
    int             nSpeedExceed;
    int             nView;
    int             nSignpostDirection;
    int             nSignpostSize;
    int             bSnapToEveryRoad;
    int             bMaxSpeedWarn;
    BOOL            bTTSEnabled;
    int             nVisiblePointReachDistance;
    int             nInvisiblePointReachDistance;
    BOOL            bAllowClosedRoads;

#ifdef TRUCK_VERSION
    // truck attributes
    BOOL    bTruckInMap;        //readonly
    BOOL    bUseTruckAtt;
    int     nTruckMaxSpeed;     //kmh

    int     nTruckWeightTotal;  //kg
    int     nTruckWeightAxle;   //kg
    int     nTruckTandemWeight;     //kg
    int     nTruckTridemWeight;     //kg
    int     nTruckOtherWeight;      //kg
    int     nTruckUnladenWeight;        //kg
    int     nTruckLenght;       //mm
    int     nTruckAxleLength;       //mm
    int     nTrailerLength;     //mm
    int     nTractorLength;     //mm
    int     nKingpinLastAxle;   //mm
    int     nKingpinLastTandem; //mm
    int     nKingpinEndTrailer; //mm
    int     nTruckOtherLength;      //mm
    int     nTruckWidth;        //mm
    int     nTruckHeight;       //mm

    int     nLoadRestrictions;  //LOAD_RESTRICTIONS enum
#endif // TRUCK_VERSION

    LONGPOSITION    cpHomePosition;
    TCHAR           strHomeLocation[60];
    TCHAR           strLangFile[60];
    TCHAR           strVoiceFolder[60];
    TCHAR           strVoicePerson[60];
    TCHAR           strMaxSpeedSound[60];
    BOOL bAllowItineraryEdit;

    SChangeOption();

};

// SStopOffPoint

struct SDK_API SStopOffPoint
{
    BOOL            bSearchAddress;
    BOOL            bVisited;

    //ViaPoint = 1, Finish = 2, Start = 3, Invisible = 4
    int             nPointType;

    LONGPOSITION    cpLocation;
    LONG            lOffset;
    DWORD           dwID;
    TCHAR           strIso[4];

    TCHAR           strCaption[120];
    TCHAR           strAddress[120];

    SStopOffPoint();
    SStopOffPoint( LONG lX, LONG lY, LPCTSTR lpszCaption, BOOL bSearchAddress = FALSE );

};

// SPoi

struct SDK_API SPoi
{
    BOOL            bSearchAddress;

    LONGPOSITION    cpLocation;

    TCHAR           szCategory[60];
    TCHAR           szName[120];
    TCHAR           szAddress[120];

    SPoi();

};

// SPoi

struct SDK_API SPoiOnRoute
{
    LONGPOSITION    cpLocation;

    INT nTimeRemaining;
    INT nDistanceRemaining;

    TCHAR           szCategory[60];
    TCHAR           szName[120];
    TCHAR           szAddress[120];

    SPoiOnRoute();

};

// SPoiCategory

struct SDK_API  SPoiCategory
{
    LONG            lNotificationDistance;
    BOOL            bNotifyOnlyWhenOnRoad;

    TCHAR           strName[60];
    TCHAR           strSound[60];

    SPoiCategory ( void );
};

typedef SPoi SFavorite;

// SHistoryRecord

struct SDK_API SHistoryRecord
{
    //0 = none, 1 = name hierarchy address, 2 = name hierarchy lpPoi
    //3 = name hierarchy postal, 4 = click point, 5 = favourite, 6 = GPS position
    //7 = homebase, 8 = name hierarchy lpPoi custom
    int             nHistoryType;

    LONGPOSITION    cpLocation;

    TCHAR           szHistoryCaption[120];

    TCHAR           szAddress[120];

    SHistoryRecord();

};

// SSatelliteInfo

struct SDK_API SSatelliteInfo
{
    int             Elevation;
    int             Azimuth;
    int             Quality;
    int             SateliteId;
    int             UsedForFix;

    SSatelliteInfo();
};

// SGpsPosition

struct SDK_API SGpsPosition
{
    SHORT           nSatellites;

    LONG            lLatitude;
    LONG            lLongitude;
    LONG            lAltitude;

    DOUBLE          dCourse;
    DOUBLE          dRealCourse;
    DOUBLE          dSpeed;

    DOUBLE          dHDoP;
    DOUBLE          dTime;
    DWORD           dwDate;

    LONG            lRoadOffset;
    LONG            lFromPointOffset;
    LONG            lToPointOffset;
    TCHAR           szMapIso[4];

    SSatelliteInfo  satellitesInfo[12];

    SGpsPosition();

    void GetTime( BYTE &nHour, BYTE &nMinute, BYTE &nSeconds, WORD &nMiliseconds );
    void GetDate( BYTE &nDay, BYTE &nMonth, WORD &nYear );
};

// SWayPoint

struct SDK_API SWayPoint
{
    LONGPOSITION    cpLocation;

    TCHAR           szAddress[120];

    LPCTSTR         GetAddress();

    SWayPoint();

};

typedef SWayPoint SLocation;

// SRouteInfo

struct SDK_API SRouteInfo
{
    LONG            lTotalDistance;
    LONG            lRemainingDistance;
    LONGRECT        rcBoundaryRectangle;
    DWORD           dwStatus;
    LONG            lEstimatedTimeArival; // use function CApplicationAPI::TimeGetTime() for conversion
    LONG            lRemaningTime; // (s)
    LONG            lTotalTime; // (s)
    LONG            lMotorwaysLength;
    LONG            lTollRoadsLength;
    LONG            lFerriesLength;

    int             *pTimeToWP;
    int             *pDistToWP;
    int             nWPArraySize;

    SRouteInfo();
};

struct SDK_API SRoadInfo
{
    LONG lRoadOffset;
    DWORD dwRoadFlags;
    TCHAR szIsoCode[4];

    LONGPOSITION cpOnroadPosition;

    DWORD dwOffroadDistance;

    SRoadInfo();
};

struct SDK_API SRouteInstruction
{
    enum Instruction
    {
        DirectionKeepRight          =  0,
        DirectionKeepLeft           =  2,
        DirectionEasyRight          =  4,
        DirectionEasyLeft           =  6,
        DirectionRight              =  8,
        DirectionLeft               = 10,
        DirectionSharpRight         = 12,
        DirectionSharpLeft          = 14,
        DirectionStraight           = 16,

        DirectionUTurnRight         = 17,
        DirectionUTurnLeft          = 18,
        DirectionEnd                = 19,
        DirectionStart              = 20,
        DirectionOutOfRoute         = 21,

        DirectionRoundaboutSE       = 23,
        DirectionRoundaboutE        = 24,
        DirectionRoundaboutNE       = 25,
        DirectionRoundaboutN        = 26,
        DirectionRoundaboutNW       = 27,
        DirectionRoundaboutW        = 28,
        DirectionRoundaboutSW       = 29,
        DirectionRoundaboutS        = 30,


        DirectionRoundaboutSW_LS    = 32,
        DirectionRoundaboutW_LS     = 33,
        DirectionRoundaboutNW_LS    = 34,
        DirectionRoundaboutN_LS     = 35,
        DirectionRoundaboutNE_LS    = 36,
        DirectionRoundaboutE_LS     = 37,
        DirectionRoundaboutSE_LS    = 38,
        DirectionRoundaboutS_LS     = 39,

        DirectionFerry              = 40,
        DirectionStateBoundary      = 41,
        DirectionExitRight          = 43,
        DirectionExitLeft           = 44,
        DirectionMotorway           = 45
    };

    LONG lNextTurnX;
    LONG lNextTurnY;

    LONG lDistanceToNextTurn;

    int nInstruction;
    int nRoundaboutExitIndex;
    TCHAR lpszExitIndex[120];

    SRouteInstruction ( void );

};

struct SDK_API STmcEvent
{
    enum EventCode
    {
        TMCTrafficProblem               =  0,
        TMCQueuingProblem               =  1,
        TMCSlowTraffic                  =  2,
        TMCHeavyTraffic                 =  3,
        TMCStationaryTraffic            =  4,
        TMCCongestion                   =  5,
        TMCNormalTraffic                =  6,
        TMCNoProblems                   =  7,
        TMCAccidentCleared              =  8,
        TMCAccidentIncident             =  9,
        TMCClosure                      = 10,
        TMCBridgeTunelBlocked           = 11,
        TMCSeviceClosed                 = 12,
        TMCServiceReopened              = 13,
        TMCLaneClosure                  = 14,
        TMCRoadWorks                    = 15,
        TMCObstacle                     = 16,
        TMCRoadConditions               = 17,
        TMCWeather                      = 18,
        TMCWind                         = 19,
        TMCVisibility                   = 20,
        TMCTemperature                  = 21,
        TMCActivity                     = 22,
        TMCDelay                        = 23,
        TMCDangerousVehicle             = 24,
        TMCExceptionalLoadsVehicles     = 25,
        TMCTrafficEquipment             = 26,
        TMCSizeAndWeightLimits          = 27,
        TMCParkingRestrictions          = 28,
        TMCReferenceToAudioBroadcast    = 29,
        TMCAdditionalInfo               = 30
    };

    WORD wID;

    LONG lX;
    LONG lY;

    int nEventCode;
    BOOL bUserAvoid;

    UINT nValidityYear;
    BYTE nValidityMonth;
    BYTE nValidityDay;
    BYTE nValidityHour;
    BYTE nValidityMinute;

    STmcEvent();

};

struct SDK_API SOnlineServicesSettings
{
    BOOL bWeatherEnabled;
    BOOL bPhotosEnabled;
    BOOL bTrafficEnabled;
    BOOL bTrapsEnabled;
    BOOL bFriendsEnabled;

    // traffic settings
    BOOL bTrafficAutoRecompute;
    BOOL bTrafficShowNotification;
    BOOL bTrafficShowOnMap;

    SOnlineServicesSettings();
};

//SError

struct SDK_API SError
{
    int             nCode;

    TCHAR           szDescription[120];

    SError();

    int     GetCode();
    LPCTSTR GetDescription();
    void    Clear();

};

typedef SError *LpError;

struct SDK_API SRouteComputeSettings
{
    int nDestinationAngle;

    SRouteComputeSettings();
};

void SDK_API  FreeMemory( LPVOID ptr );

class SDK_API CApplicationAPI
{
public:
    static int  InitApi( LPCTSTR lpszPath, APPLICATION_HANDLEPROC pfnApplicationEventHandler, int nLeft, int nTop, int nWidth, int nHeight,
            BOOL bRunInForeground = TRUE, BOOL bNoCaption = FALSE, HWND hParentWnd = NULL );

    static int  CloseApi();

    // application

    static int  IsApplicationRunning( LpError  lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  EndApplication( LpError  lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  BringApplicationToForeground( LpError  lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  BringApplicationToBackground( LpError  lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  GetUniqueDeviceId( LpError  lpError, LPTSTR lpszDeviceID, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  IsApplicationInForeground( LpError lpError, BOOL &bApplicationInForeground, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  GetMapVersion( LpError lpError, LPCTSTR lpszIso, LPTSTR lpszMapVersion, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  GetApplicationVersion( LpError lpError, LPTSTR lpszDriveVersion, LPTSTR lpszBuiltNumber, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  GetSdkVersion( LpError lpError, LPTSTR lpszSdkVersion, LPTSTR lpszBuiltNumber, DWORD dwMaxTime = DEFAULT_MAX_TIME );




    // options

    static int  ChangeApplicationOptions( LpError  lpError, SChangeOption* lpChangeOption, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  SetDefaultValues( LpError  lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  ChangeAppRectangle( LpError  lpError, int nLeft, int nTop, int nWidth, int nHeight, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // navigation

    static int  GetActualGpsPosition( LpError  lpError, SGpsPosition* lpGpsPosition, BOOL bSatellitesInfo, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  GetRouteInfo( LpError  lpError, SRouteInfo* lpRouteInfo, BOOL bExtended = FALSE, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int GetRouteStatus( LpError lpError, LPTSTR &lpRouteStatus, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  StartNavigation( LpError  lpError, SLocation* lpLocation, DWORD dwFlags, BOOL bShowApplication, BOOL bSearchAddress, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  StartNavigation( LpError  lpError, SLocation* lpLocation, DWORD dwFlags, BOOL bCloseDelivery, BOOL bShowApplication, BOOL bSearchAddress, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  StartNavigation( LpError  lpError, SLocation* lpLocation, DWORD dwFlags, BOOL bCloseDelivery, BOOL bShowApplication, BOOL bSearchAddress, SRouteComputeSettings* lpCompSettings, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  StopNavigation( LpError  lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  NavigateToAddress( LpError  lpError, LPCTSTR lpszAddress, BOOL bPostal, DWORD dwFlags, BOOL bShowApplication, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  NavigateToAddress( LpError  lpError, LPCTSTR lpszAddress, BOOL bPostal, DWORD dwFlags, BOOL bCloseDelivery, BOOL bShowApplication, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  LoadComputedRoute( LpError  lpError, LPCTSTR lpszRoutePath, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  LoadComputedRoute( LpError  lpError, LPCTSTR lpszRoutePath, DWORD dwStartWaypointID, LPTSTR lpszApproximationInfo, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  SaveComputedRoute( LpError  lpError, LPCTSTR lpszRoutePath, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int GetRoute(LpError lpError, int nFormat, int nDetail, LPTSTR &lpszRoute, DWORD dwMaxTime = DEFAULT_MAX_TIME);

    // favorites

    static int  GetFavoritesList( LpError  lpError, SFavorite* & lstFavoriteArr, int & nSize,
        BOOL bSearchAddress, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  AddStopOffPointsToFavorites( LpError  lpError, SPoi* lpStopOffPoint, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  RemoveFavoriteFromList( LpError  lpError, SFavorite* lpFavorite, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // history

    static int  AddStopOffPointToHistory( LpError  lpError, SHistoryRecord* lpStopOffPoint, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  GetHistoryList( LpError  lpError, SHistoryRecord* & lstHistoryArr, int & nSize,
        BOOL bSearchAddress, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // poi

    static int  AddPoi( LpError  lpError, SPoi* lpPoi, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  AddPoiCategory( LpError  lpError, LPCTSTR lpszCategory,LPCTSTR lpszBitmapPath, LPCTSTR lpszIsoCode,
        DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  DeletePoiCategory( LpError  lpError, LPCTSTR lpszCategory, LPCTSTR lpszIso, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  DeletePoi( LpError  lpError, SPoi* lpPoi, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  MakeUserPoiVisible( LpError  lpError, DWORD dwCategory, LPCTSTR lpszCategory, BOOL bShow, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  GetPoiList( LpError  lpError, SPoi* &lstPoiArr, int & nSize, LPCTSTR lpszCategory, BOOL bSearchAddress, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  GetPoiOnRoute( LpError  lpError, int nGroup, int nCategory, int minDriveTime, int maxDriveTime, SPoiOnRoute* &lstPoiArr, int & nSize, DWORD dwMaxTime = DEFAULT_MAX_TIME );


    static int  FindNearbyPoi( LpError  lpError, SPoi* & lpPoi, DWORD dwCategoryNumber, LPCTSTR lpszCategoryName,
        long lX, long lY, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  FindNearbyPoi( LpError  lpError, SPoi *&lpPoiList, int &nListSize, DWORD dwCategoryNumber, LPCTSTR lpszCategoryName,
        LONG lX, LONG lY, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int GetPoiCategoryList( LpError lpError, SPoiCategory *&lpPoiCategories, int &nSize, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int SetPoiWarning( LpError lpError, SPoiCategory *lpPoiCategory, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int HighlightPoi( LpError lpError, LPCTSTR lpszPoiCategory, LPCTSTR lpszPoiName, LPCTSTR lpszSound, LONGPOSITION cpPoiLocation, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // location

    static int  GetLocationInfo( LpError  lpError, LONGPOSITION cpLocation, LPTSTR lpszAddress, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  GetLocationInfo( LpError  lpError, LONGPOSITION cpLocation, LPTSTR lpszAddress, SRoadInfo *lpRoadInfo, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  LocationFromAddress( LpError  lpError, LONGPOSITION & cpLocation, LPCTSTR lpszAddress, BOOL bPostal, BOOL bValueMatch, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  LocationFromAddressEx( LpError  lpError, LPCTSTR lpszAddress, BOOL bPostal, SWayPoint * &lpPositions,
        int &nCount, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  LocationFromAddressEx( LpError  lpError, LPCTSTR lpszAddress, BOOL bPostal, BOOL bFuzzySearch, SWayPoint * &lpPositions,
        int &nCount, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  ShowHierarchyDialog( LpError lpError, LPCTSTR lpszIso, LPCTSTR lpszCity, LPCTSTR lpszStreet, BOOL bPostal,
        SWayPoint * &lpPosition, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int GetAddressList( LpError lpError, LPCTSTR lpszAddress, BOOL bPostal, int nMaxCount, SWayPoint * &lpList, int &nCount, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int GetCoordinatesFromOffset( LpError lpError, LPCTSTR lpszIso, LONG lRoadOffset, LONGPOSITION &cpPosition, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // maps

    static int  SwitchMap( LpError  lpError, LPCTSTR lpszLoadPath, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  ShowCoordinatesOnMap( LpError  lpError, LONGPOSITION cpLocation,
        LONG lZoom, BOOL bShowApplication, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  ShowRectangleOnMap( LpError  lpError, LONGRECT rcRect, BOOL bShowApplication, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int AddBitmapToMap( LpError  lpError, LPCTSTR lpszBitmapPath, long lX, long lY,
        UINT &nBitmapID, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int RemoveBitmap( LpError  lpError, UINT nBitmapID, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int RemoveAllBitmaps( LpError  lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int ShowBitmap( LpError  lpError, UINT nBitmapID, BOOL bShow, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int MoveBitmap( LpError  lpError, UINT nBitmapID, long lX, long lY, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // dialogs

    static int  ShowMessage( LpError  lpError, LPCTSTR lpszMessage, int nButtons,
        BOOL bWaitForFeedback, BOOL bShowApplication, int & nUserFeedback, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int OnMenuCommand( LpError  lpError, int nID, int nSubID, BOOL bShowApplication, DWORD dwMaxTime = DEFAULT_MAX_TIME  );

    static int FlashMessage( LpError  lpError, LPCTSTR lpszMessage, BOOL bShowApplication, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int CloseDialogs( LpError lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int ErrorReport ( LpError lpError, DWORD &dwID, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // itinerary

    static int  AddItinerary( LpError  lpError, SStopOffPoint* lstPointArr, int nSize, LPCTSTR lpszItineraryName,
        DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int  AddItinerary( LpError  lpError, LPCTSTR lpszItineraryJson, LPCTSTR lpszItineraryName,
        DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int SetRoute( LpError  lpError, LPCTSTR lpszItineraryName, DWORD dwFlags, BOOL bShowApplication, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int SetRoute( LpError  lpError, LPCTSTR lpszItineraryName, DWORD dwFlags, BOOL bCloseDelivery, BOOL bShowApplication, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int SetRoute( LpError  lpError, LPCTSTR lpszItineraryName, DWORD dwFlags, BOOL bCloseDelivery, BOOL bShowApplication, int &nWrongWaypointsCount, int *&lpWrongWaypoints, DWORD dwMaxTime = DEFAULT_MAX_TIME );


    static int AddEntryToItinerary( LpError  lpError, LPCTSTR lpszItineraryName, SStopOffPoint* lpStopOffPoint, UINT nIndex,
        DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int DeleteEntryInItinerary( LpError  lpError, LPCTSTR lpszItineraryName, UINT nIndex, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int DeleteItinerary( LpError lpError, LPCTSTR lpszItineraryName, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int GetItineraryList( LpError lpError, LPCTSTR lpszItineraryName, SStopOffPoint * &PointsArr, int &nWayPointsCount, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int OptimizeItinerary( LpError lpError, LPCTSTR lpszItineraryName, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int OptimizeRoute( LpError lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int SkipNextWaypoint( LpError lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );


    // gps input

    static int EnableExternalGpsInput( LpError lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int DisableExternalGpsInput( LpError lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static BOOL SendGpsData( LPCTSTR lpszData, int nSize );

    static int GpsSwitchOn( LpError lpError, LPCTSTR lpszPort, DWORD dwBaudRate, BOOL bSwitchOn, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // info

    static int GetCurrentSpeedLimit ( LpError lpError, int &nSpeedLimit, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int GetNextInstruction ( LpError lpError, SRouteInstruction *lpInstruction, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // online

    static int GoOnline( LpError lpError, BOOL bOnline, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int OnlineServicesLogin( LpError lpError, LPCTSTR lpszUserName, LPCTSTR lpszPassword, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int AddTMCEvent( LpError lpError, STmcEvent *lpTmcEvent, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int RemoveTMCEvent( LpError lpError, WORD wTmcEventId, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int ClearTMCTable( LpError lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int OnlineServicesSettings( LpError lpError, SOnlineServicesSettings *lpSettings, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // TTS

    static int PlaySoundTTS( LpError lpError, LPCTSTR lpszText, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // additional

    static int LoadGFFile( LpError lpError, LPCTSTR lpszPath, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int UnloadGFFile( LpError lpError, LPCTSTR lpszPath, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int LoadExternalFile( LpError lpError, LPCTSTR lpszPath, int nFileType, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int UnloadExternalFile( LpError lpError, LPCTSTR lpszPath, int nFileType, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int ReloadExternalFiles( LpError lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    // trip book

    static int TripStart( LpError lpError, LPCTSTR lpszTripname, int nDataMode, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int TripAddUserEvent( LpError lpError, LPCTSTR lpszEventName, UINT nCustomID, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int TripEnd( LpError lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME );

    static int LoadOFGRoute( LpError lpError, LPCTSTR lpszFileName, int nStartFromIndex, int nFlags, DWORD dwMaxTime /*= DEFAULT_MAX_TIME*/ );

    static int GetOFGRouteStatus( LpError lpError, LPTSTR lpszStatus, DWORD dwMaxTime /*= DEFAULT_MAX_TIME*/ );

    static int SaveOFGRoute( LpError lpError, LPCTSTR lpszFileName, int nFromIndex, LONGPOSITION cpFrom, int nToIndex, LONGPOSITION cpTo, DWORD dwMaxTime /*= DEFAULT_MAX_TIME*/ );


    static int GetMobileData(LpError lpError, LPTSTR &lpMobileData, DWORD dwMaxTime = DEFAULT_MAX_TIME);

    static int SetMobileData(LpError lpError, LPCTSTR lpMobileData, DWORD dwMaxTime = DEFAULT_MAX_TIME);

    static int ResetMobileData(LpError lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME);

    
    static int GetMapCorrectionEvents(LpError lpError, LPTSTR &lpszTable, DWORD dwMaxTime = DEFAULT_MAX_TIME);

    static int AddMapCorrectionEvents(LpError lpError, LPCTSTR lpszTable, DWORD dwMaxTime = DEFAULT_MAX_TIME);

    static int ClearMapCorrectionEvents(LpError lpError, DWORD dwMaxTime = DEFAULT_MAX_TIME);


public:
    static BOOL TimeGetTime ( LONG lTime, USHORT *nYear, BYTE *nMonth,
        BYTE *nDay, BYTE *nHour, BYTE *nMinute, BYTE *nSecond );
};

#endif // !defined __API_H__