CartoTypeWrapper.h

/*
CartoTypeWrapper.h
Copyright (C) CartoType Ltd 2011-2022.
See www.cartotype.com for more information.
*/
 
#pragma once
 
#include "CartoTypeGeometry.h"
#include "CartoTypeMetaData.h"
 
using namespace System;
using namespace System::Collections::Generic;
 
#using "System.Drawing.dll"
 
namespace CartoType
{
 
// forward declarations
class CFramework;
class CMapObject;
class TCoordinateTransform;
class TNavigatorTurn;
class MInternetAccessor;
class CRoute;
class CRouteSegment;
class TRouteProfile;
class TNearestRoadInfo;
class TNearestSegmentInfo;
class CAddress;
class CLegend;
class CMapRenderer;
class TRouteCoordSet;
class TExtendedNoticePosition;
class CTimeAndDistanceMatrix;
 
ref class Framework;
ref class Route;
ref class Address;
ref class Geometry;
ref class Legend;
ref class FindAsyncHelper;
ref class FindAsyncGroupHelper;
ref class CreateRouteAsyncHelper;
 
public enum class Result
    {
    Success = 0,
    
    ErrorNone = 0,
 
    ErrorGeneral = 1,
 
    ErrorNoMemory = 2,
 
    ErrorEndOfData = 3,
 
    ErrorTextUnmodifiable = 4,
 
    ErrorTextTruncated = 5,
 
    ErrorNotFound = 6,
 
    ErrorUnimplemented = 7,
 
    ErrorInvalidOutline = 8,
 
    ErrorIo = 9,
 
    ErrorCorrupt = 10,
 
    ErrorUnknownDataFormat = 11,
 
    ErrorNoInverse = 12,
 
    ErrorProjectionOverflow = 13,
 
    ErrorCancel = 14,
 
    ErrorInvalidArgument = 15,
 
    ErrorUnknownVersion = 16,
 
    ErrorOverflow = 17,
 
    // ABOLISHED: ErrorOverlap = 18,
 
    ErrorParallelLines = 19,
 
    // ABOLISHED: ErrorPathLengthExceeded = 20,
 
    // ABOLISHED: ErrorMaxTurnExceeded = 21,
 
    ErrorNoPalette = 22,
 
    ErrorDuplicate = 23,
 
    ErrorNoProjection = 24,
 
    ErrorPaletteFull = 25,
 
    ErrorInvalidDashArray = 26,
 
    ErrorCentralPath = 27,
 
    ErrorNoRoute = 28,
 
    ErrorZoomLimitReached = 29,
 
    ErrorAlreadyProjected = 30,
 
    ErrorConditionsTooDeeplyNested = 31,
 
    ErrorNullFont = 32,
 
    ErrorInternetIo = 33,
 
    ErrorDivideByZero = 34,
 
    ErrorTransformFailed = 35,
 
    ErrorPngRead = 36,
 
    ErrorJpgRead = 37,
 
    ErrorNoIntersection = 38,
 
    ErrorInterrupt = 39,
 
    ErrorMapDataBaseFormatMismatch = 40,
 
    ErrorEncryptionKeyTooShort = 41,
 
    ErrorNoEncryptionKey = 42,
 
    ErrorEmergencyMessage = 43,
 
    ErrorAlertMessage = 44,
 
    ErrorCriticalMessage = 45,
 
    ErrorErrorMessage = 46,
 
    ErrorWarningMessage = 47,
 
    ErrorNoticeMessage = 48,
 
    ErrorInfoMessage = 49,
 
    ErrorDebugMessage = 50,
 
    ErrorNotNavigating = 51,
 
    ErrorNoFramework = 52,
 
    ErrorFrameworkAlreadyExists = 53,
 
    ErrorUntransliterable = 54,
 
    ErrorPngWrite = 55,
 
    ErrorReadOnlyMapDataBase = 56,
 
    ErrorProj4 = 57,
 
    ErrorUnlicensed = 58,
 
    ErrorNoRoadsNearStartOfRoute = 59,
 
    ErrorNoRoadsNearEndOfRoute = 60,
 
    ErrorNoRouteConnectivity = 61,
 
    ErrorXmlFeatureNotSupported = 62,
 
    ErrorMapNotFound = 63,
 
    ErrorFontNotFound = 64,
 
    ErrorStyleSheetNotFound = 65,
 
    StandardErrorCodeCount = 66,
 
    ErrorXmlRangeStart = 0x10000000,
 
    ErrorXmlRangeEnd = 0x2AFFFFFF,
 
    ErrorSQLite = 0x30000000
    };
 
public enum class MapObjectType
    {
    Point,
    Line,
    Polygon,
    Array,
    TypeCount
    };
 
public enum class StringMatchMethod
    {
    PrefixFlag = 1,
    IgnoreSymbolsFlag = 2,
    FoldAccentsFlag = 4,
    FuzzyFlag = 8,
    FoldCaseFlag = 16,
    IgnoreWhitespaceFlag = 32,
 
    Exact = 0,
    FoldCase = FoldCaseFlag,
    Prefix = PrefixFlag,
    IgnoreNonAlphanumerics = IgnoreSymbolsFlag | IgnoreWhitespaceFlag,
    Loose = IgnoreNonAlphanumerics | FoldAccentsFlag | FoldCaseFlag,
    Fuzzy = IgnoreNonAlphanumerics | FoldAccentsFlag | FuzzyFlag | FoldCaseFlag,
    };
 
public enum class LetterCase
    {
    None,
    Lower,
    Upper,
    Title
    };
 
public enum class PointOfInterestType
    {
    None,
    Airport,
    Bar,
    Beach,
    BusStation,
    Cafe,
    Camping,
    FastFood,
    Fuel,
    GolfCourse,
    Hospital,
    Hotel,
    Pharmacy,
    Police,
    Restaurant,
    Shops,
    SportsCenter,
    Supermarket,
    SwimmingPool,
    Tourism,
    TrainStation
    };
 
public ref class FindNearbyParam
    {
    public:
    PointOfInterestType m_type;
    String^ m_text;
    Geometry^ m_location;
    };
 
public ref class FindParam
    {
    public:
    FindParam() { }
    FindParam(FindNearbyParam^ aFindNearbyParam);
 
    int m_max_object_count = 0x7FFFFFFF;
    Geometry^ m_clip = nullptr;
    Geometry^ m_location;
    String^ m_layers = nullptr;
    String^ m_attributes = nullptr;
    String^ m_text = nullptr;
    StringMatchMethod m_string_match_method = StringMatchMethod::Exact;
    String^ m_condition;
    bool m_merge = true;
    double m_timeout = 0.5;
    };
 
public ref class MapObject: public Path
    {
    public:
    ~MapObject();
    
    String^ GetLabel();
    int GetIntegerAttribute();
    String^ GetStringAttribute(String^ aName);
    SortedDictionary<String^,String^>^ GetStringAttributes();
    Int64 GetId();
    MapObjectType GetType();
    String^ GetLayerName();
    double GetArea();
    double GetLengthOrPerimeter();
    Result GetCenter(Point^ aPoint);
    Result GetCenterInDegrees(Point^ aPoint);
    Result GetBoundsInDegrees(Rect^ aRect);
    Result GetGeometryInDegrees(Geometry^ aGeometry);
    Result GetBounds(Rect^ aRect);
    
    ref class Match
        {
        public:
        String^ m_key;
        String^ m_value;
        int m_start;
        int m_end;
        };
        
    Result GetMatch(Match^ aMatch,String^ aText,StringMatchMethod aMatchMethod,String^ aAttributes,bool aPhrase);
    virtual int ContourCount();
    virtual int PointCount(int aContourIndex);
    virtual void GetPoint(int aContourIndex,int aPointIndex,PathPoint^ aPoint);
        
    internal:
    MapObject(CMapObject* aMapObject);
    
    protected:
    !MapObject();
 
    internal:
    CMapObject* m_map_object;
    };
 
public ref class MapRenderer
    {
    public:
    MapRenderer(Framework^ aFramework,IntPtr aWindowHandle);
    ~MapRenderer();
    void Draw();
    bool Valid();
    bool Enable(bool aEnable);
 
    protected:
    !MapRenderer();
 
    internal:
    Framework^ m_framework;
    CMapRenderer* m_map_renderer = nullptr;
    };
 
public enum class FollowFlag
    {
    Location = 1,
    Heading = 2,
    Zoom = 4
    };
 
public enum class FollowMode
    {
    None = 0,
    Location = (int)FollowFlag::Location,
    LocationHeading = (int)FollowFlag::Location | (int)FollowFlag::Heading,
    LocationZoom = (int)FollowFlag::Location | (int)FollowFlag::Zoom,
    LocationHeadingZoom = (int)FollowFlag::Location | (int)FollowFlag::Heading | (int)FollowFlag::Zoom
    };
 
public enum class ValidityFlag
    {
    Time = 1,
    Position = 2,
    Speed = 4,
    Course = 8,
    Height = 16
    };
 
public enum class NavigationState
    {
    None,
    NoPosition,
    Turn,
    OffRoute,
    ReRouteNeeded,
    ReRouteDone,
    TurnRound,
    Arrival
    };
 
public ref class LocationMatchParam
    {
    public:
    double m_location_accuracy_in_meters = 0;
    double m_heading_accuracy_in_degrees = 0;
    double m_max_road_distance_in_meters = 0;
    };
 
public enum class RouterType
    {
    Default,
    StandardAStar,
    TurnExpandedAStar,
    StandardContractionHierarchy,
    TECH
    };
 
public enum class TurnType
    {
    None, 
    Ahead,
    BearRight,
    Right,
    SharpRight,
    Around,
    SharpLeft,
    Left,
    BearLeft
    };
 
public enum class RoundaboutState
    {
    None,
    Enter,
    Continue,
    Exit
    };
 
public ref class Turn
    {
    public:
    Turn();
    void Clear();
    
    String^ TurnCommand();
    
    TurnType m_turn_type;
    bool m_continue;
    RoundaboutState m_roundabout_state;
    double m_turn_angle;
    int m_exit_number;
    double m_distance;
    double m_time;
    String^ m_from_name;
    String^ m_from_ref;
    String^ m_to_name;
    String^ m_to_ref;
    String^ m_instructions;
    
    internal:
    void Set(const TNavigatorTurn& aTurn);
    };
 
public enum class RouteProfileType
    {
    Car,
    Walk,
    Walking = Walk,
    Cycle,
    Bicycle = Cycle,
    Hike,
    Hiking = Hike
    };
 
public ref class RouteProfile
    {
    public:
    RouteProfile();
    RouteProfile(RouteProfileType aProfileType);
    Result ReadFromXmlFile(String^ aFileName);
    Result ReadFromXmlString(String^ aString);
    Result WriteAsXmlFile(String^ aFileName);
    String^ WriteAsXmlString();
 
    literal int AccessMask = 0x7FF00000;
    literal int WrongWayFlag = 0x00100000;
    literal int BicycleAccessFlag = 0x0020000;
    literal int MotorCycleAccessFlag = 0x0040000;
    literal int CarAccessFlag = 0x0080000;
    literal int HighOccupancyAccessFlag = 0x0100000;
    literal int LightGoodsAccessFlag = 0x02000000;
    literal int HeavyGoodsAccessFlag = 0x04000000;
    literal int BusAccessFlag = 0x08000000;
    literal int TaxiAccessFlag = 0x10000000;
    literal int PedestrianAccessFlag = 0x20000000;
    literal int EmergencyAccessFlag = 0x40000000;
    literal int OtherAccessFlag = 0x80000000;
    literal int BicycleAccessOnly = AccessMask & ~(WrongWayFlag | BicycleAccessFlag);
    literal int AllMotorVehicles = AccessMask & ~(WrongWayFlag | PedestrianAccessFlag | BicycleAccessFlag);
    literal int BicycleAndPedestrianAccessOnly = AllMotorVehicles;
    literal int NoVehicularAccess = AccessMask & ~(WrongWayFlag | PedestrianAccessFlag);
    literal int AllVehicles = NoVehicularAccess;
 
    literal int Motorway = 0;
    literal int MotorwayLink = 1;
    literal int TrunkRoad = 2;
    literal int TrunkRoadLink = 3;
    literal int PrimaryRoad = 4;
    literal int PrimaryRoadLink = 5;
    literal int SecondaryRoad = 6;
    literal int SecondaryRoadLink = 7;
    literal int TertiaryRoad = 8;
    literal int UnclassifiedRoad = 9;
    literal int ResidentialRoad = 10;
    literal int Track = 11;
    literal int ServiceRoad = 12;
    literal int PedestrianRoad = 13;
    literal int VehicularFerry = 14;
    literal int PassengerFerry = 15;
    literal int LivingStreet = 16;
    literal int Cycleway = 17;
    literal int Path = 18;
    literal int Footway = 19;
    literal int Bridleway = 20;
    literal int Steps = 21;
    literal int UnknownRoadType = 22;
    literal int UnpavedRoad = 23;
    literal int OtherRoadType0 = 24;
    literal int OtherRoadType1 = 25;
    literal int OtherRoadType2 = 26;
    literal int OtherRoadType3 = 27;
    literal int OtherRoadType4 = 28;
    literal int OtherRoadType5 = 29;
    literal int OtherRoadType6 = 30;
    literal int OtherRoadType7 = 31;
    literal int RoadTypeCount = 32;
 
    literal int GradientUp0 = 0;
    literal int GradientUp1 = 1;
    literal int GradientUp2 = 2;
    literal int GradientUp3 = 3;
    literal int GradientDown0 = 4;
    literal int GradientDown1 = 5;
    literal int GradientDown2 = 6;
    literal int GradientDown3 = 7;
    literal int GradientCount = 8;
 
    String^ m_name;
 
    int m_vehicle_type = CarAccessFlag | WrongWayFlag;
 
    double m_weight;
 
    double m_axle_load;
 
    double m_double_axle_load;
 
    double m_triple_axle_load;
 
    double m_height;
 
    double m_width;
 
    double m_length;
 
    bool m_hazmat = false;
 
    array<double>^ m_speed;
 
    array<double>^ m_bonus;
 
    array<int>^ m_restriction_override;
 
    int m_turn_time;
 
    int m_u_turn_time;
 
    int m_cross_traffic_turn_time;
 
    int m_traffic_light_time;
 
    bool m_shortest;
 
    bool m_shortest_by_time;
 
    double m_toll_penalty;
 
    array<double>^ m_gradient_speed;
 
    array<double>^ m_gradient_bonus;
 
    int m_gradient_flags;
 
    internal:
    void Set(const TRouteProfile& aProfile);
    void Get(TRouteProfile& aProfile);
    };
 
public enum class RoadType: unsigned
    {
    RoutingMask = 0x3E,
 
    RoadTypeMask = 0xFC0,
 
    MajorRoadTypeMask = 0xF00,
 
    RoadLevelMask = 0xF000,
 
    TunnelFlag = 1,
 
    BridgeFlag = 0x10000,
 
    RoadLevelShift = 12,
 
    RampFlag = 64,
 
    LinkFlag = RampFlag,
 
    LowerGradeFlag = 128,
 
    UnknownMajorRoadType = 0,
 
    PrimaryLimitedAccessRoadType = 0x100,
 
    PrimaryUnlimitedAccessRoadType = 0x200,
 
    SecondaryRoadType = 0x300,
 
    MinorRoadType = 0x400,
 
    BywayRoadType = 0x500,
 
    AccessRampRoadType = 0x600,
 
    ServiceRoadType = 0x700,
 
    VehicularFerryRoadType = 0x800,
 
    PassengerFerryRoadType = 0x900,
 
    PathRoadType = 0xA00,
 
    StairwayRoadType = 0xB00,
 
    CyclePathRoadType = 0xC00,
 
    FootPathRoadType = 0xD00,
    
    OtherRoadType0 = 0xE00,
    OtherRoadType1 = 0xE00 | LowerGradeFlag,
    OtherRoadType2 = 0xE00 | LinkFlag,
    OtherRoadType3 = 0xE00 | LowerGradeFlag | LinkFlag,
    OtherRoadType4 = 0xF00,
    OtherRoadType5 = 0xF00 | LowerGradeFlag,
    OtherRoadType6 = 0xF00 | LinkFlag,
    OtherRoadType7 = 0xF00 | LowerGradeFlag | LinkFlag,
 
    TollFlag = 2,
 
    RoundaboutFlag = 4,
 
    RestrictionFlag = 8,
 
    OneWayForwardFlag = 16,
 
    OneWayBackwardFlag = 32,
 
    FirstOverRoadLevel = 0x1000,
 
    FirstUnderRoadLevel = 0xF000,
 
    SecondUnderRoadLevel = 0xE000,
 
    /* <summary>*
    Access rules.
    These flags occupy the bits used for the OSM type in non-road layers,
    so may be used only where an OSM type is not used.
    Each flag forbids access to a certain type of vehicle.
    </summary> */
    RoadAccessMask = 0xFFFE0000,
 
    BicycleRoadAccessFlag = 0x20000,
 
    MotorCycleRoadAccessFlag = 0x40000,
 
    MotorCarRoadAccessFlag = 0x80000,
 
    HighOccupancyRoadAccessFlag = 0x100000,
 
    GoodsRoadAccessFlag = 0x200000,
 
    HeavyGoodsRoadAccessFlag = 0x400000,
 
    BusRoadAccessFlag = 0x800000,
 
    TaxiRoadAccessFlag = 0x1000000,
 
    PedestrianRoadAccessFlag = 0x2000000,
 
    AgriculturalRoadAccessFlag = 0x4000000,
 
    ForestryRoadAccessFlag = 0x8000000,
 
    EmergencyRoadAccessFlag = 0x10000000,
 
    HazardousRoadAccessFlag = 0x20000000,
 
    WheelChairRoadAccessFlag = 0x40000000,
 
    DisabledRoadAccessFlag = 0x80000000,
 
    MotorVehicleRoadAccessMask = 0xFFFE0000 & ~(PedestrianRoadAccessFlag | BicycleRoadAccessFlag | WheelChairRoadAccessFlag),
    PublicServiceVehicleRoadAccessMask = BusRoadAccessFlag | TaxiRoadAccessFlag,
    
    // useful synonyms for road types
    Motorway = PrimaryLimitedAccessRoadType,
    MotorwayLink = PrimaryLimitedAccessRoadType | LinkFlag,
    TrunkRoad = PrimaryUnlimitedAccessRoadType,
    TrunkRoadLink = PrimaryUnlimitedAccessRoadType | LinkFlag,
    PrimaryRoad = PrimaryUnlimitedAccessRoadType | LowerGradeFlag,
    PrimaryRoadLink = PrimaryUnlimitedAccessRoadType | LowerGradeFlag | LinkFlag,
    SecondaryRoad = SecondaryRoadType,
    SecondaryRoadLink = SecondaryRoadType | LinkFlag,
    TertiaryRoad = SecondaryRoadType | LowerGradeFlag,
    TertiaryRoadLink = SecondaryRoadType | LowerGradeFlag | LinkFlag,
    UnclassifiedRoad = MinorRoadType,
    ResidentialRoad = MinorRoadType | LowerGradeFlag,
    Track = BywayRoadType,
    ServiceRoad = ServiceRoadType,
    PedestrianRoad = PathRoadType,
    VehicularFerry = VehicularFerryRoadType,
    PassengerFerry = PassengerFerryRoadType,
    };
 
public ref class NearestSegmentInfo
    {
    public:
    NearestSegmentInfo():
        m_segment_index(-1),
        m_line_index(0),
        m_nearest_point_x(0),
        m_nearest_point_y(0),
        m_distance_to_route(0),
        m_distance_along_route(0),
        m_distance_along_segment(0),
        m_time_along_route(0),
        m_time_along_segment(0),
        m_heading(0)
        {
        }
 
    int m_segment_index;
    int m_line_index;
    double m_nearest_point_x;
    double m_nearest_point_y;
    double m_distance_to_route;
    double m_distance_along_route;
    double m_distance_along_segment;
    double m_time_along_route;
    double m_time_along_segment;
    double m_heading;
 
    internal:
    void Set(const TNearestSegmentInfo& aInfo);
    };
 
public ref class RoutePoint
    {
    public:
    double m_x = 0;
    double m_y = 0;
    double m_heading = 0;
    bool m_heading_known = false;
    LocationMatchParam^ m_location_match_param;
    };
 
public ref class RoutePointList: List<RoutePoint^>
    {
    };
 
public ref class RouteCoordSet
    {
    public:
    CoordType m_coord_type = CoordType::Degree;
    RoutePointList^ m_route_point_list = gcnew RoutePointList();
 
    internal:
    TRouteCoordSet CreateRouteCoordSet();
    };
 
public ref class RouteSegment: public Path
    {
    public:
    RoadType GetRoadType();
    double GetMaxSpeed();
    String^ GetName();
    String^ GetRef();
    double GetDistance();
    double GetTime();
    double GetTurnTime();
    TurnType GetTurnType();
    bool GetContinue();
    RoundaboutState GetRoundaboutState();
    double GetTurnAngle();
    int GetExitNumber();
    int GetChoices();
    int GetSection();
    
    virtual int ContourCount() { return 1; }
    virtual int PointCount(int aContourIndex);
    virtual void GetPoint(int aContourIndex,int aPointIndex,PathPoint^ aPoint);
 
    internal:
    RouteSegment(Route^ aRoute,const CRouteSegment* aSegment);
    
    private:
    Route^ m_route;                    // a reference to the parent route, to keep it in existence
    const CRouteSegment* m_segment;    // the segment: owned by m_route
    };
 
public ref class Route: public Path
    {
    internal:
    Route(CRoute* aRoute);
    ~Route();
    
    public:
    Geometry^ GetGeometry();
    RouteProfile^ GetProfile();
    double GetDistance();
    double GetTime();
    int GetRouteSegmentCount();
    RouteSegment^ GetRouteSegment(int aIndex);
    double GetTollRoadDistance();
    NearestSegmentInfo^ GetNearestSegment(double aX,double aY,int aSection,double aPreviousDistanceAlongRoute);
    NearestSegmentInfo^ GetPointAtDistance(double aDistanceInMeters);
    NearestSegmentInfo^ GetPointAtTime(double aTimeInSeconds);
    virtual int ContourCount();
    virtual int PointCount(int aContourIndex);
    virtual void GetPoint(int aContourIndex,int aPointIndex,PathPoint^ aPoint);
 
    
    internal:
    const CRoute* GetRoute() { return m_route; }
 
    protected:
    !Route();
 
    private:
    CRoute* m_route;
    };
 
public ref class Address
    {
    public:
    String^ ToString(bool aFull);
 
    String^ m_building;
    String^ m_feature;
    String^ m_street;
    String^ m_sub_locality;
    String^ m_locality;
    String^ m_island;
    String^ m_sub_admin_area;
    String^ m_admin_area;
    String^ m_country;
    String^ m_postcode;
    
    internal:
    void Get(CAddress& aAddress);
    void Set(const CAddress& aAddress);
    };
 
public enum class AddressPart
    {
    Building,
    Feature,
    Street,
    SubLocality,
    Locality,
    Island,
    SubAdminArea,
    AdminArea,
    Country,
    PostCode
    };
 
public ref class NearestRoadInfo
    {
    public:
    RoadType m_road_type;
    double m_max_speed;
    String^ m_name;
    String^ m_ref;
    double m_nearest_point_x;
    double m_nearest_point_y;
    double m_distance;
    double m_heading_in_degrees;
    double m_heading_vector_x;
    double m_heading_vector_y;
    
    internal:
    void Set(const TNearestRoadInfo& aInfo);
    };
 
public enum class WritableMapType
    {
    Memory,
    SQLite
    };
 
public enum class FileType
    {
    Png,
    Jpeg,
    Tiff,
    Ctm1,
    Ctms,
    Kml,
    Ctsql,
    CartoTypeRoute,
    Gpx
    };
 
public ref class MapObjectList: List<MapObject^>
    {
    };
 
public ref class TrafficInfo
    {
    public:
    TrafficInfo();
    
    literal double NoSpeedLimit = 255;
    
    int m_vehicle_types = RouteProfile::AllVehicles;
    double m_speed = NoSpeedLimit;
    };
 
public enum class SideOfRoad
    {
    None,
    Right,
    Left,
    Both
    };
 
public enum class RoadOrientation
    {
    None,
    Forwards,
    Backwards,
    Both,
    };
 
public enum class LocationRefType
    {
    Line,
    GeoCoordinate,
    PointAlongLine,
    PointWithAccessPoint,
    Circle,
    Rectangle,
    Polygon,
    ClosedLine
    };
 
public ref class LocationRef
    {
    public:
    LocationRef(LocationRefType aType,CoordType aCoordType);
 
    LocationRefType m_type = LocationRefType::Line;
    String^ m_id = nullptr;
    Geometry^ m_geometry = nullptr;
    double m_radius_in_meters = 0;
    SideOfRoad m_side_of_road = SideOfRoad::None;
    RoadOrientation m_road_orientation = RoadOrientation::None;
    };
 
public enum class NoticePosition
    {
    TopLeft,
    TopRight,
    BottomLeft,
    BottomRight,
    Top,
    Right,
    Left,
    Bottom,
    Center
    };
 
public ref class ExtendedNoticePosition
    {
    public:
    ExtendedNoticePosition(NoticePosition aBasePosition);
    ExtendedNoticePosition(NoticePosition aBasePosition,double aXInset,String^ aXInsetUnit,double aYInset,String^ aYInsetUnit);
    ~ExtendedNoticePosition();
 
    protected:
    !ExtendedNoticePosition();
 
    internal:
    TExtendedNoticePosition* m_position = nullptr;
    };
 
public ref class PositionedBitmap
    {
    public:
    Drawing::Bitmap^ m_bitmap = nullptr;
    int m_x = 0;
    int m_y = 0;
    };
 
public ref class MapObjectGroup
    {
    public:
    String^ m_name = nullptr;
    MapObjectList^ m_map_object_list = nullptr;
    };
 
public ref class MapObjectGroupList: List<MapObjectGroup^>
    {
    };
 
public delegate void FindAsyncDelegate(MapObjectList^);
 
public delegate void FindAsyncGroupDelegate(MapObjectGroupList^);
 
public delegate void RouterAsyncDelegate(Result,Route^);
 
public ref class PerspectiveParam
    {
    public:
    Result ReadFromXml(String^ aText);
    String^ ToXml();
 
    double m_position_in_degrees_x = 0;
    double m_position_in_degrees_y = 0;
    bool m_auto_position = true;
    double m_height_in_meters = 0;
    double m_azimuth_degrees = 0;
    bool m_auto_azimuth = true;
    double m_declination_in_degrees = 30;
    double m_rotation_degrees = 0;
    double m_field_of_view_degrees = 22.5;
    };
 
public ref class ViewState
    {
    public:
    Result ReadFromXml(String^ aText);
    String^ ToXml();
 
    int m_width_in_pixels = 256;
    int m_height_in_pixels = 256;
    double m_view_center_degrees_x;
    double m_view_center_degrees_y;
    double m_scale_denominator = 0;
    double m_rotation_degrees = 0;
    bool m_perspective = false;
    PerspectiveParam^ m_perspective_param = nullptr;
    };
 
public ref class NavigatorParam
    {
    public:
    int m_minimum_fix_distance = 5;
    int m_route_distance_tolerance = 20;
    int m_route_time_tolerance = 30;
    bool m_auto_reroute = true;
    bool m_navigation_enabled = true;
    };
 
public ref class FrameworkParam
    {
    public:
    FrameworkParam();
    
    String^ m_map_filename = nullptr;
    String^ m_style_sheet_filename = nullptr;
    String^ m_font_filename = nullptr;
    int m_view_width = 256;
    int m_view_height = 256;
    array<Byte>^ m_encryption_key = nullptr;
    int m_file_buffer_size_in_bytes = 0;
    int m_max_file_buffer_count = 0;
    int m_text_index_levels = 0;
    bool m_maps_overlap = true;
    };
 
public value class Color
    {
    public:
    Color(int aValue) : m_value(aValue) { }
    Color(int aRed,int aGreen,int aBlue)
        {
        m_value = (0xFF << 24) | ((aBlue & 0xFF) << 16) | ((aGreen & 0xFF) << 8) | (aRed & 0xFF);
        }
    Color(int aRed,int aGreen,int aBlue,int aAlpha)
        {
        m_value = ((aAlpha & 0xFF) << 24) | ((aBlue & 0xFF) << 16) | ((aGreen & 0xFF) << 8) | (aRed & 0xFF);
        }
    Color(String^ aColor);
    int Red() { return (m_value & 0xFF); }
    int Green() { return (m_value & 0xFF00) >> 8; }
    int Blue() { return (m_value & 0xFF0000) >> 16; }
    int Gray() { return ((m_value & 0xFF) + ((m_value & 0xFF00) >> 8) + ((m_value & 0xFF0000) >> 16)) / 3; }
    int Alpha() { return (m_value & 0xFF000000) >> 24; }
    bool IsNull() { return (m_value & 0xFF000000) == 0; }
    void SetAlpha(int aAlpha) { m_value = (aAlpha << 24) | (m_value & 0xFFFFFF); }
 
    static const Color KBlack = Color(0xFF000000);
    static const Color KDarkGray = Color(0xFF555555);
    static const Color KDarkRed = Color(0xFF000080);
    static const Color KDarkGreen = Color(0xFF008000);
    static const Color KDarkYellow = Color(0xFF008080);
    static const Color KDarkBlue = Color(0xFF800000);
    static const Color KDarkMagenta = Color(0xFF800080);
    static const Color KDarkCyan = Color(0xFF808000);
    static const Color KRed = Color(0xFF0000FF);
    static const Color KGreen = Color(0xFF00FF00);
    static const Color KYellow = Color(0xFF00FFFF);
    static const Color KBlue = Color(0xFFFF0000);
    static const Color KMagenta = Color(0xFFFF00FF);
    static const Color KCyan = Color(0xFFFFFF00);
    static const Color KGray = Color(0xFFAAAAAA);
    static const Color KWhite = Color(0xFFFFFFFF);
 
    static const Color KTransparentBlack = Color(0x00000000);
 
    int m_value;
    };
 
public ref class BlendStyle
    {
    public:
    String^ m_styles;
    Color m_main_color = Color(Color::KTransparentBlack);
    Color m_border_color = Color(Color::KTransparentBlack);
    Color m_text_color = Color(Color::KTransparentBlack);
    Color m_text_glow_color = Color(Color::KTransparentBlack);
    Color m_icon_color = Color(Color::KTransparentBlack);
    };
 
public ref class BlendStyleSet: List<BlendStyle^>
    {
    };
 
public ref class TimeAndDistanceMatrix
    {
    public:
    int FromCount();
    int ToCount();
    int Time(int aFromIndex,int aToIndex);
    int Distance(int aFromIndex,int aToIndex);
 
    protected:
    !TimeAndDistanceMatrix();
        
    internal:
    TimeAndDistanceMatrix(CTimeAndDistanceMatrix* aMatrix);
    ~TimeAndDistanceMatrix();
    
    CTimeAndDistanceMatrix* m_matrix = nullptr;
    };
 
public enum class RouteAccess
    {
    Unknown,
    Accessible,
    Isolated,
    NoRoad
    };
 
public ref class Framework
    {
    public:
    Framework(String^ aMapFileName,String^ aStyleSheetFileName,String^ aFontFileName,
              int aViewWidth,int aViewHeight);
    Framework(String^ aMapFileName,String^ aStyleSheetFileName,String^ aFontFileName,
              int aViewWidth,int aViewHeight,array<Byte>^ aEncryptionKey);
    Framework(FrameworkParam^ aParam);
    
    ~Framework();
 
    Result License(String^ aKey);
    Result License(array<Byte>^ aKey);
    String^ Licensee();
    String^ ExpiryDate();
    String^ AppBuildDate();
    String^ Copyright();
    void SetCopyrightNotice();
    void SetCopyrightNotice(String^ aCopyright);
    void SetLegend(Legend^ aLegend,double aWidth,String^ aUnit,NoticePosition aPosition);
    void SetLegend(Legend^ aLegend,double aWidth,String^ aUnit,ExtendedNoticePosition^ aPosition);
    void EnableLegend(bool aEnable);
    void SetScaleBar(bool aMetricUnits,double aWidth,String^ aUnit,NoticePosition aPosition);
    void SetScaleBar(bool aMetricUnits,double aWidth,String^ aUnit,ExtendedNoticePosition^ aPosition);
    void EnableScaleBar(bool aEnable);
    Result SetTurnInstructions(bool aMetricUnits,bool aAbbreviate,double aWidth,String^ aWidthUnit,NoticePosition aPosition,double aTextSize,String^ aTextSizeUnit);
    Result SetTurnInstructions(bool aMetricUnits,bool aAbbreviate,double aWidth,String^ aWidthUnit,ExtendedNoticePosition^ aPosition,double aTextSize,String^ aTextSizeUnit);
    void EnableTurnInstructions(bool aEnable);
    void SetTurnInstructionText(String^ aText);
    String^ TurnInstructionText();
    void DrawNoticesAutomatically(bool aEnable);
    bool HasNotices();
    PositionedBitmap^ GetNoticeBitmap();
    Result Configure(String^ aConfigFileName);
    Result LoadMap(String^ aMapFileName);
    Result LoadMap(String^ aMapFileName,array<Byte>^ aEncryptionKey);
    bool SetMapsOverlap(bool aEnable);
    Result CreateWritableMap(WritableMapType aType);
    Result CreateWritableMap(WritableMapType aType,String^ aFileName);
    Result SaveMap(int aHandle,String^ aFileName,FileType aFileType);
    Result ReadMap(int aHandle,String^ aFileName,FileType aFileType);
    Result SaveMap(int aHandle,array<Byte>^ aData,FindParam^ aFindParam);
    Result ReadMap(int aHandle,array<Byte>^ aData);
    Result WriteMapImage(String^ aFileName,FileType aFileType,bool aCompress);
    bool MapIsEmpty(int aHandle);
    int MapCount();
    int MapHandle(int aIndex);
    bool MapIsWritable(int aIndex);
    MapMetaData^ GetMapMetaData(int aIndex);
    Result UnloadMapByHandle(int aHandle);
    void EnableMapByHandle(int aHandle,bool aEnable);
    void EnableAllMaps();
    int GetLastMapHandle();
    int GetMainMapHandle();
    int GetMemoryMapHandle();
    Result LoadFont(String^ aFontFileName);
    Result LoadFont(array<Byte>^ aData);
    Result SetStyleSheet(String^ aStyleSheetFileName,int aIndex);
    Result SetStyleSheet(array<Byte>^ aData,int aIndex);
    Result ReloadStyleSheet(int aIndex);
    void AppendStyleSheet(String^ aStyleSheetFileName);
    void AppendStyleSheet(array<Byte>^ aData);
    Result DeleteStyleSheet(int aIndex);
    void EnableLayer(String^ aLayerName,bool aEnable);
    bool LayerIsEnabled(String^ aLayerName);
    List<String^>^ LayerNames();
    Result Resize(int aViewWidth,int aViewHeight);
    void SetResolutionDpi(double aDpi);
    double ResolutionDpi();
    Result SetScaleDenominator(double aScale);
    double ScaleDenominator();
    Result SetScaleDenominatorInView(double aScale);
    double GetScaleDenominatorInView();
    double GetDistanceInMeters(double aX1,double aY1,double aX2,double aY2,CoordType aCoordType);
    double ScaleDenominatorFromZoomLevel(double aZoomLevel,int aImageSizeInPixels);
    double ZoomLevelFromScaleDenominator(double aScaleDenominator,int aImageSizeInPixels);
    void SetPerspective(bool aSet);
    void SetPerspective(PerspectiveParam^ aParam);
    bool Perspective();
    PerspectiveParam^ GetPerspectiveParam();
    bool SetDraw3DBuildings(bool aEnable);
    bool Draw3DBuildings();
    Result Zoom(double aZoomFactor);
    bool SetAnimateTransitions(bool aEnable);
    bool AnimateTransitions();
    Result ZoomAt(double aZoomFactor,double aX,double aY,CoordType aCoordType);
    Result Rotate(double aAngle);
    Result RotateAt(double aAngle,double aX,double aY,CoordType aCoordType);
    Result SetRotation(double aAngle);
    Result SetRotationAt(double aAngle,double aX,double aY,CoordType aCoordType);
    Result RotateAndZoom(double aAngle,double aZoomFactor,double aX,double aY,CoordType aCoordType);
    double Rotation();
    void Pan(int aDx,int aDy);
    Result Pan(double aFromX,double aFromY,CoordType aFromCoordType,
               double aToX,double aToY,CoordType aToCoordType);
    Result SetViewCenter(double aX,double aY,CoordType aCoordType);
    Result SetView(double aX1,double aY1,double aX2,double aY2,CoordType aCoordType,int aMarginInPixels,int aMinScaleDenominator);
    void SetView(MapObject^ aMapObject,int aMarginInPixels,int aMinScaleDenominator);
    Result SetView(MapObjectList^ aObjectList,int aMarginInPixels,int aMinScaleDenominator);
    Result SetView(Geometry^ aGeometry,int aMarginInPixels,int aMinScaleDenominator);
    Result SetView(ViewState^ aViewState);
    Result SetViewToRoute(int aRouteIndex,int aMarginInPixels,int aMinScaleDenominator);
    Result SetViewToWholeMap();
    Result SetViewLimits(double aMinScaleDenominator,double aMaxScaleDenominator,Geometry^ aPanArea);
 
    Result GetView(Rect^ aView,CoordType aCoordType);
    Result GetMapExtent(Rect^ aExtent,CoordType aCoordType);
    String^ GetProjectionAsProj4Param();
    ViewState^ GetViewState();
    
    Result InsertMapObject(int aMapHandle,String^ aLayerName,Geometry^ aGeometry,
                           String^ aStringAttributes,int aIntAttribute,Int64% aId,bool aReplace);
    Result InsertPointMapObject(int aMapHandle,String^ aLayerName,double aX,double aY,
                                CoordType aCoordType,String^ aStringAttributes,int aIntAttribute,Int64% aId,bool aReplace);
    Result InsertCircleMapObject(int aMapHandle,String^ aLayerName,
                                 double aCenterX,double aCenterY,CoordType aCenterCoordType,double aRadius,CoordType aRadiusCoordType,
                                 String^ aStringAttributes,int aIntAttribute,Int64% aId,bool aReplace);
    Result InsertEnvelopeMapObject(int aMapHandle,String^ aLayerName,Geometry^ aGeometry,
                                   double aRadius,CoordType aRadiusCoordType,
                                   String^ aStringAttributes,int aIntAttribute,Int64% aId,bool aReplace);
 
    Result InsertPushPin(double aX,double aY,CoordType aCoordType,String^ aStringAttributes,String^ aColor,int aIconCharacter,Int64% aId);
   
    Result InsertCopyOfMapObject(int aMapHandle,String^ aLayerName,MapObject^ aObject,double aEnvelopeRadius,
                                 CoordType aRadiusCoordType,Int64% aId,bool aReplace);
    
    Result DeleteMapObjects(int aMapHandle,Int64 aStartId,Int64 aEndId,Int64% aDeletedCount,String^ aCondition);
    MapObject^ LoadMapObject(int aMapHandle,Int64 aId);
    Result ReadGpx(int aMapHandle,String^ aFileName);
    Geometry^ Range(RouteProfile^ aProfile,double aX,double aY,CoordType aCoordType,double aTimeOrDistance,bool aIsTime);
    TimeAndDistanceMatrix^ GetTimeAndDistanceMatrix(Result% aResult,array<PointValue>^ aFrom,array<PointValue>^ aTo,CoordType aCoordType);
    RouteAccess GetRouteAccess(Result% aResult,double aX,double aY,CoordType aCoordType);
    Result GetAreaAndLength(Geometry^ aGeometry,double% aArea,double% aLength);
    Result GetContourAreaAndLength(Geometry^ aGeometry,int aContourIndex,double% aArea,double% aLength);
    Result ConvertCoords(Geometry^ aGeometry,CoordType aToCoordType);
    Result ConvertPoint(Point^ aPoint,CoordType aFromCoordType,CoordType aToCoordType);
    double PixelsToMeters(double aPixels);
    double MetersToPixels(double aMeters);
    String^ DataSetName();
 
    Result EditSetWritableMap(int aMapHandle);
    Result EditNewLineObject(double aX,double aY);
    Result EditNewPolygonObject(double aX,double aY);
    Result EditMoveCurrentPoint(double aX,double aY);
    Result EditAddCurrentPoint();
    Result EditDeleteCurrentPoint();
    Result EditDeleteCurrentObject();
    Result EditSelectNearestPoint(double aX,double aY,double aRadiusInMillimeters);
    Result EditInsertCurrentObject(String^ aLayer,Int64% aId,bool aReplace);
    Result EditSetCurrentObjectStringAttribute(String^ aKey,String^ aValue);
    Result EditSetCurrentObjectIntAttribute(int aValue);
    Result EditGetCurrentObjectAreaAndLength(double% aArea,double% aLength);
 
    Drawing::Bitmap^ MapBitmap();
    Drawing::Bitmap^ MemoryDataBaseMapBitmap();
    void EnableDrawingMemoryDataBase(bool aEnable);
 
    Drawing::Bitmap^ TileBitmap(int aTileSizeInPixels,int aZoom,int aX,int aY);
 
    bool ClipBackgroundToMapBounds(bool aEnable);
    
    int SetTileOverSizeZoomLevels(int aLevels);
 
    // adding and removing style sheet icons loaded from files  
    Result LoadIcon(String^ aFileName,String^ aId,int aHotSpotX,int aHotSpotY,int aLabelX,int aLabelY);
    void UnloadIcon(String^ aId);
 
    // finding map objects
    Result FindInDisplay(MapObjectList^ aObjectList,int aMaxObjectCount,double aX,double aY,double aRadius);
    Result FindAddress(MapObjectList^ aObjectList,int aMaxObjectCount,Address^ aAddress,bool aFuzzy);
    Result FindAddressAsync(FindAsyncDelegate^ aDelegate,int aMaxObjectCount,Address^ aAddress,bool aFuzzy,bool aOverride);
    Result FindStreetAddresses(MapObjectList^ aObjectList,int aMaxObjectCount,Address^ aAddress,Geometry^ aClip);
    Result FindAddressPart(MapObjectList^ aObjectList,int aMaxObjectCount,String^ aText,AddressPart aAddressPart,bool aFuzzy,bool aIncremental);
    Result FindBuildingsNearStreet(MapObjectList^ aObjectList,MapObject^ aStreet);
    Result FindInLayer(MapObjectList^ aObjectList,int aMaxObjectCount,String^ aLayer,double aMinX,double aMinY,double aMaxX,double aMaxY,CoordType aCoordType);
    Result FindText(MapObjectList^ aObjectList,int aMaxObjectCount,String^ aText,StringMatchMethod aMatchMethod,String^ aLayers,String^ aAttrib);
    Result Find(MapObjectList^ aObjectList,FindParam^ aFindParam);
    Result Find(MapObjectGroupList^ aObjectGroupList,FindParam^ aFindParam);
    Result Find(MapObjectList^ aObjectList,FindNearbyParam^ aFindNearbyParam);
    Result FindAsync(FindAsyncDelegate^ aDelegate,FindParam^ aFindParam,bool aOverride);
    Result FindAsync(FindAsyncGroupDelegate^ aDelegate,FindParam^ aFindParam,bool aOverride);
 
    Result FindPolygonsContainingPath(MapObjectList^ aObjectList,Geometry^ aPath,FindParam^ aFindParam);
    Result FindPointsInPath(MapObjectList^ aObjectList,Geometry^ aPath,FindParam^ aFindParam);
    int GetHeight(double aX,double aY,CoordType aCoordType);
    Result GetHeights(array<double>^ aX,array<double>^ aY,array<int>^ aTerrainHeightArray,CoordType aCoordType);
 
    // style sheet variables
    void SetStyleSheetVariable(String^ aVariableName,String^ aValue);
    void SetStyleSheetVariable(String^ aVariableName,int aValue);
 
    // night mode and color blending
    bool SetNightMode(bool aSet);
    Color SetNightModeColor(Color aColor);
    bool NightMode();
    Color NightModeColor(Color aColor);
    BlendStyleSet^ SetBlendStyle(BlendStyleSet^ aBlendStyleSet);
    BlendStyleSet^ GetBlendStyleSet();
 
    // geocoding
    String^ GetGeoCodeSummary(MapObject^ aMapObject);
    Result GetAddress(Address^ aAddress,MapObject^ aMapObject);
 
    Result GetAddressFast(Address^ aAddress,MapObject^ aMapObject);
 
    String^ GetGeoCodeSummary(double aX,double aY,CoordType aCoordType);
 
    Result GetAddress(Address^ aAddress,double aX,double aY,CoordType aCoordType);
 
    // navigation    
    void SetPreferredRouterType(RouterType aRouterType);
    RouterType PreferredRouterType();
    RouterType ActualRouterType();
    Result StartNavigation(RouteCoordSet^ aCoordSet);
    Result StartNavigation(array<double>^ aX,array<double>^ aY,CoordType aCoordType);
    Result StartNavigation(double aStartX,double aStartY,CoordType aStartCoordType,
                           double aEndX,double aEndY,CoordType aEndCoordType);
    Route^ CreateRoute(Result% aResult,RouteProfile^ aProfile,RouteCoordSet^ aCoordSet);
    Result CreateRouteAsync(RouterAsyncDelegate^ aDelegate,RouteProfile^ aProfile,RouteCoordSet^ aCoordSet,bool aOverride);
    Route^ CreateRoute(Result% aResult,RouteProfile^ aProfile,array<double>^ aX,array<double>^ aY,CoordType aCoordType);    
    Result ReverseRoutes();
    Result DeleteRoutes();
    Route^ CreateBestRoute(Result% aResult,RouteProfile^ aProfile,RouteCoordSet^ aCoordSet,
                           bool aStartFixed,bool aEndFixed,int aIterations);
    Result CreateBestRouteAsync(RouterAsyncDelegate^ aDelegate,RouteProfile^ aProfile,RouteCoordSet^ aCoordSet,
                                bool aStartFixed,bool aEndFixed,int aIterations,bool aOverride);
    Route^ CreateBestRoute(Result% aResult,RouteProfile^ aProfile,array<double>^ aX,array<double>^ aY,CoordType aCoordType,
                           bool aStartFixed,bool aEndFixed,int aIterations);
 
 
    Route^ CreateRouteFromXml(Result% aResult,RouteProfile^ aProfile,String^ aFilenameOrData);
 
    Result UseRoute(Route^ aRoute,bool aReplace);
    String^ GetRouteInstructions(Route^ aRoute);
    void EndNavigation();
    bool EnableNavigation(bool aEnable);
    bool NavigationEnabled();
    Result LoadNavigationData();
    void UseSerializedNavigationData(bool aEnable);
    Result SetMainProfile(RouteProfile^ aProfile);
    RouteProfile^ Profile(int aIndex);
    int BuiltInProfileCount();
    RouteProfile^ BuiltInProfile(int aIndex);
    Result SetBuiltInProfile(int aIndex);
    Result AddProfile(RouteProfile^ aProfile);
    Result ChooseRoute(int aRouteIndex);
    Result DisplayRoute(bool aEnable);
    int GetRouteCount();
    Route^ GetRoute(int aRouteIndex);
    Result ReadRouteFromXml(String^ aFileNameOrData,bool aReplace);
    Result WriteRouteAsXml(Route^ aRoute,String^ aFileName,FileType aFileType);
    String^ WriteRouteAsXmlString(Route^ aRoute,FileType aFileType);
    Result Navigate(int aValidity,double aTime,double aLong,double aLat,double aSpeed,double aBearing,double aHeight);
    void GetFirstTurn(Turn^ aFirstTurn);
    void GetSecondTurn(Turn^ aSecondTurn);
    void GetContinuationTurn(Turn^ aContinuationTurn);
    NavigationState GetNavigationState();
    void SetNavigatorParam(NavigatorParam^ aParam);
    NavigatorParam^ GetNavigatorParam();
    void SetLocationMatchParam(LocationMatchParam^ aParam);
    LocationMatchParam^ GetLocationMatchParam();
    void SetNavigationMinimumFixDistance(int aMeters);
    void SetNavigationTimeOffRouteTolerance(int aSeconds);
    void SetNavigationDistanceOffRouteTolerance(int aMeters);
    void SetNavigationAutoReRoute(bool aAutoReRoute);
    int SetNearbyObjectWarning(int aId,String^ aLayer,String^ aCondition,double aMaxDistance,int aMaxObjectCount);
    int SetVehicleTypeWarning(double aMaxDistance,int aMaxObjectCount);
    bool DeleteNearbyObjectWarning(int aId);
    bool ClearNearbyObjectWarnings();
    MapObjectList^ CopyNearbyObjects();
    double DistanceToDestination();
    double EstimatedTimeToDestination();
    Result FindNearestRoad(NearestRoadInfo^ aInfo,double aX,double aY,CoordType aCoordType,
                           double aHeadingInDegrees,bool aDisplayPosition);
    Result DisplayPositionOnNearestRoad(double aLong,double aLat,double aHeadingInDegrees,NearestRoadInfo^ aInfo);
    void SetVehiclePosOffset(double aXOffset,double aYOffset);
    void SetLocale(String^ aLocale);
    Result SetFollowMode(FollowMode aFollowMode);
    FollowMode GetFollowMode();
    Result GetNavigationPosition(Point^ aPos,CoordType aCoordType);
 
    String^ Locale();
 
    String^ DistanceToString(double aDistanceInMeters,bool aMetricUnits,bool aAbbreviate);
 
    String^ TimeToString(double aTimeInSeconds);
 
    String^ SetCase(String^ aString,LetterCase aCase);
 
    Result AddTrafficInfo(Int64% aId,TrafficInfo^ aTrafficInfo,LocationRef^ aLocationRef);
    
    Result AddPolygonSpeedLimit(Int64% aId,Geometry^ aPolygon,double aSpeed,int aVehicleTypes);
 
    Result AddLineSpeedLimit(Int64% aId,Geometry^ aLine,double aSpeed,int aVehicleTypes);
    
    Result AddClosedLineSpeedLimit(Int64% aId,Geometry^ aLine,double aSpeed,int aVehicleTypes);
 
    Result AddForbiddenArea(Int64% aId,Geometry^ aPolygon);
    
    Result DeleteTrafficInfo(Int64 aId);
 
    void ClearTrafficInfo();
    
    bool EnableTrafficInfo(bool aEnable);
 
    void StartTracking();
 
    void EndTracking();
 
    void DeleteTrack();
 
    bool Tracking();
 
    bool DisplayTrack(bool aEnable);
 
    Geometry^ GetTrack();
 
    double TrackLengthInMeters();
 
    Result WriteTrackAsXml(String^ aFileName);
        
    String^ WriteTrackAsXmlString();
 
    static const int KMaxRoutesDisplayed = 16;
    
    protected:
    !Framework();
    
    internal:
    CFramework* GetFramework() { return m_framework; }
    List<FindAsyncHelper^>^ m_find_async_helper_list = gcnew List<FindAsyncHelper^>();
    List<FindAsyncGroupHelper^>^ m_find_async_group_helper_list = gcnew List<FindAsyncGroupHelper^>();
    List<CreateRouteAsyncHelper^>^ m_create_route_async_helper_list = gcnew List<CreateRouteAsyncHelper^>();
 
    private:
    Result CreateRouteAsync(RouterAsyncDelegate^ aDelegate,bool aBest,RouteProfile^ aProfile,RouteCoordSet^ aCoordSet,
                            bool aStartFixed,bool aEndFixed,int aIterations,bool aOverride);
 
    CFramework* m_framework = nullptr;    
    Drawing::Bitmap^ m_bitmap = nullptr;
    Drawing::Bitmap^ m_memory_database_bitmap = nullptr;
    Drawing::Bitmap^ m_tile_bitmap = nullptr;
    };
 
public enum class Align
    {
    Center,
    Standard,
    Reverse,
    Left,
    Right
    };
 
public ref class Legend
    {
    public:
    Legend(Framework^ aFramework);
    ~Legend();
 
    void Clear();
 
    Drawing::Bitmap^ CreateLegend(double aWidth,String^ aUnit,double aScaleDenominator,double aScaleDenominatorInView,BlendStyleSet^ aBlendStyleSet);
 
    void AddMapObjectLine(MapObjectType aType,String^ aLayer,String^ aOsmType,int aIntAttrib,String^ aStringAttrib,String^ aLabel);
    
    void AddTextLine(String^ aText);
    
    void AddScaleLine(bool aMetricUnits);
 
    void AddTurnLine(bool aMetricUnits,bool aAbbreviate);
 
    void SetExtraStyleSheet(array<Byte>^ aData);
 
    void SetBackgroundColor(Color aColor);
 
    void SetBorder(Color aColor,double aStrokeWidth,double aRadius,String^ aUnit);
 
    void SetMarginWidth(double aMarginWidth,String^ aUnit);
 
    void SetMinLineHeight(double aLineHeight,String^ aUnit);
 
    void SetFontFamily(String^ aFontFamily);
 
    void SetFontSize(double aFontSize,String^ aUnit);
 
    void SetTextColor(Color aTextColor);
 
    void SetAlignment(Align aAlignment);
 
    protected:
    !Legend();
 
    internal:
    CLegend* GetLegend() { return m_legend; }
 
    private:
    CLegend* m_legend = nullptr;
    };
 
public ref class Util abstract sealed
    {
    public:
    static String^ Version();
    static String^ Build();
 
    static double GetSphericalPolygonArea(array<double>^ aX,array<double>^ aY);
    static double GetLength(array<double>^ aX,array<double>^ aY);
    static double GetGreatCircleDistanceInMeters(double aLong1,double aLat1,double aLong2,double aLat2);
    static double GetAzimuthInDegrees(double aLong1,double aLat1,double aLong2,double aLat2);
    static Point^ GetPointAtAzimuth(double aLong,double aLat,double aDir,double aDistanceInMeters);
    static double GetDistanceFromPoint(array<double>^ aX,array<double>^ aY,bool aIsPolygon,double aPointX,double aPointY,Point^ aNearestPoint);
    static String^ SetAttribute(String^ aString,String^ aKey,String^ aValue);
    static int IntAttribute(String^ aThreeLetterCode,int aType);
    static String^ ErrorString(Result aError);
    };
 
}