CartoTypeWrapper.h

/*
CartoTypeWrapper.h
Copyright (C) CartoType Ltd 2011-2026.
See www.cartotype.com for more information.
*/
 
/*
C++/CX notes.
 
This interface is written in C++/CX. To enable compilation for C++/CX use the /ZW compiler option.
 
SEALED CLASSES: not sealing classes produces error 4585: A WinRT 'public ref class'
must either be sealed or derive from an existing unsealed class.
 
VECTOR TYPES:  Windows::Foundation::Collections::IVector is used in parameters
and return values. Platform::Collections::Vector is used when creating objects
to be returned.
See https://docs.microsoft.com/en-us/cpp/cppcx/platform-collections-vector-class?view=msvc-170:
"If you attempt to use a Vector type in a public return value or parameter,
compiler error C3986 is raised. You can fix the error by changing the parameter
or return value type to Windows::Foundation::Collections::IVector. For more
information, see Collections (C++/CX)."
*/
 
#pragma once
 
#include "CartoTypeResult.h"
#include "CartoTypeGeometry.h"
#include "CartoTypeMetaData.h"
#include "CartoTypeFeatureInfo.h"
 
#include <collection.h>
#include <ppltasks.h>
#include <wrl.h>
#include <robuffer.h>
#include <algorithm>
#include <memory>
 
using namespace Platform;
using namespace Platform::Collections;
using namespace Platform::Metadata; 
using namespace Windows::Foundation::Collections;
using namespace Windows::Graphics::Imaging;
 
namespace CartoTypeCore
{
class Framework;
class MapObject;
class TCoordinateTransform;
class NavigatorTurn;
class MInternetAccessor;
class Route;
class RouteSegment;
class RouteProfile;
class NearestRoadInfo;
class NearestSegmentInfo;
class Address;
class Legend;
class MapRenderer;
class RouteCoordSet;
class NoticePosition;
class TimeAndDistanceMatrix;
class CVectorTileServer;
class LRPoint;
}
 
namespace CartoType
{
 
// forward declarations
ref class Framework;
ref class Route;
ref class Address;
ref class Geometry;
ref class Legend;
 
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 ref class FindNearbyParam sealed
    {
    public:
    FindNearbyParam() { Type = FeatureType::Invalid; }
 
    property FeatureType Type;
    property String^ Text;
    property Geometry^ Location;
    };
 
public ref class FindParam sealed
    {
    public:
    public:
    FindParam() { MaxObjectCount = 0x7FFFFFFF; StringMatchMethod = CartoType::StringMatchMethod::Exact; Merge = true; TimeOut = 0.5; }
    FindParam(FindNearbyParam^ aFindNearbyParam);
 
    property int MaxObjectCount;
    property Geometry^ Clip;
    property Geometry^ Location;
    property String^ Layers;
    property String^ Attributes;
    property String^ Text;
    property StringMatchMethod StringMatchMethod;
    property String^ Condition;
    property bool Merge;
    property double TimeOut;
    };
 
public ref class MapObjectMatch sealed
    {
    public:
    property bool Found;
    property String^ Key;
    property String^ Value;
    property int Start;
    property int End;
    };
 
public ref class MapObject sealed: public Path
    {
    public:
    property String^ Label { String^ get(); };
    property FeatureInfo^ FeatureInfo { CartoType::FeatureInfo^ get(); }
    String^ StringAttribute(String^ aName);
    IVector<String^>^ StringAttributes();
    property int64_t Id { int64_t get(); }
    property MapObjectType Type { MapObjectType get(); };
    property String^ LayerName { String^ get(); }
    property double Area { double get(); };
    property double LengthOrPerimeter { double get(); }
    property Point^ Center { Point^ get(); };
    property Point^ CenterInDegrees { Point^ get(); };
    property Rect^ BoundsInDegrees { Rect^ get(); };
    property Geometry^ GeometryInDegrees { Geometry^ get(); };
    property Rect^ Bounds { Rect^ get(); }
        
    MapObjectMatch^ Match(String^ aText,StringMatchMethod aMatchMethod,String^ aAttributes,bool aPhrase);
    virtual int ContourCount();
    virtual int PointCount(int aContourIndex);
    virtual PathPoint^ Point(int aContourIndex,int aPointIndex);
 
    internal:
    MapObject(std::unique_ptr<CartoTypeCore::MapObject> aMapObject);
    
    internal:
    std::unique_ptr<CartoTypeCore::MapObject> m_map_object;
    };
 
[Flags]
public enum class FollowFlag : unsigned int
    {
    Location = 1,
    Heading = 2,
    Zoom = 4
    };
 
[Flags]
public enum class FollowMode : unsigned int
    {
    None = 0,
    Location = FollowFlag::Location,
    LocationHeading = FollowFlag::Location | FollowFlag::Heading,
    LocationZoom = FollowFlag::Location | FollowFlag::Zoom,
    LocationHeadingZoom = FollowFlag::Location | FollowFlag::Heading | FollowFlag::Zoom
    };
 
[Flags]
public enum class ValidityFlag : unsigned int
    {
    Time = 1,
    Position = 2,
    Speed = 4,
    Course = 8,
    Height = 16
    };
 
public enum class NavigationState
    {
    None,
    NoPosition,
    Turn,
    OffRoute,
    Routing,
    NewRoute,
    TurnRound,
    Arrival,
    Departure
    };
 
public ref class LocationMatchParam sealed
    {
    public:
    property double LocationAccuracyInMeters;
    property double HeadingAccuracyInDegrees;
    property double MaxRoadDistanceInMeters;
    };
 
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 sealed
    {
    public:
    Turn();
    void Clear();
        
    property TurnType Type;
    property bool IsContinue;
    property RoundaboutState RoundaboutState;
    property double TurnAngle;
    property int ExitNumber;
    property double Distance;
    property double Time;
    property String^ FromName;
    property String^ FromRef;
    property FeatureInfo^ FromRouteInfo;
    property String^ ToName;
    property String^ ToRef;
    property FeatureInfo^ ToRouteInfo;
    property String^ Destination;
    property String^ Instructions;
    property int Index;
 
    internal:
    void Set(const CartoTypeCore::NavigatorTurn& aTurn);
    };
 
public enum class RouteProfileType
    {
    Car,
    Walk,
    Walking = Walk,
    Cycle,
    Bicycle = Cycle,
    Hike,
    Hiking = Hike,
    Ski
    };
 
public enum class RouteProfileConstants
    {
    Motorway = 0,
    MotorwayLink = 1,
    TrunkRoad = 2,
    TrunkLink = 3,
    PrimaryRoad = 4,
    PrimaryLink = 5,
    SecondaryRoad = 6,
    SecondaryLink = 7,
    TertiaryRoad = 8,
    UnclassifiedRoad = 9,
    ResidentialRoad = 10,
    Track = 11,
    ServiceRoad = 12,
    PedestrianRoad = 13,
    VehicularFerry = 14,
    PassengerFerry = 15,
    LivingStreet = 16,
    Cycleway = 17,
    Path = 18,
    Footway = 19,
    Bridleway = 20,
    Steps = 21,
    OtherRoad = 22,
    UnpavedRoad = 23,
    Railway = 24,
    LightRail = 25,
    Subway = 26,
    AerialWay = 27,
    SkiDownhill = 28,
    SkiNordic = 29,
    Waterway = 30,
    UnknownRoute = 31,
    RouteTypeCount = 64
    };
 
public ref class RouteProfile sealed
    {
    public:
    RouteProfile();
    RouteProfile(RouteProfileType aProfileType);
    Result ReadFromXmlFile(String^ aFileName);
    Result ReadFromXmlString(String^ aString);
    Result WriteAsXmlFile(String^ aFileName);
    String^ WriteAsXmlString();
    Result CopyWeights(int aSourceType,int aDestType);
    static int CustomType(int aIndex) { assert(aIndex >= 0 && aIndex < 32); return aIndex + 32; }
 
    property String^ Name;
 
    property int VehicleType;
 
    property double Weight;
 
    property double AxleLoad;
 
    property double DoubleAxleLoad;
 
    property double TripleAxleLoad;
 
    property double Height;
 
    property double Width;
 
    property double Length;
 
    property bool HazMat;
 
    property Array<double>^ Speed;
 
    property Array<double>^ Bonus;
 
    property Array<int>^ RestrictionOverride;
 
    property int TurnTime;
 
    property int UTurnTime;
 
    property int CrossTrafficTurnTime;
 
    property int TrafficLightTime;
 
    property bool Shortest;
 
    property bool ShortestByTime;
 
    property double TollPenalty;
 
    property Array<double>^ GradientSpeed;
 
    property Array<double>^ GradientBonus;
 
    property uint64_t GradientFlags;
 
    internal:
    void Set(const CartoTypeCore::RouteProfile& aProfile);
    void Get(CartoTypeCore::RouteProfile& aProfile);
    };
 
public ref class NearestSegmentInfo sealed
    {
    public:
    NearestSegmentInfo() { SegmentIndex = -1; }
 
    property int SegmentIndex;
    property int LineIndex;
    property double NearestPointX;
    property double NearestPointY;
    property double DistanceToRoute;
    property double DistanceAlongRoute;
    property double DistanceAlongSegment;
    property double TimeAlongRoute;
    property double TimeAlongSegment;
    property double Heading;
 
    internal:
    void Set(const CartoTypeCore::NearestSegmentInfo& aInfo);
    };
 
public ref class RoutePoint sealed
    {
    public:
    property double X;
    property double Y;
    property double Heading;
    property bool HeadingKnown;
    property LocationMatchParam^ LocationMatchParam;
    };
 
using RoutePointList = IVector<RoutePoint^>;
 
public ref class RouteCoordSet sealed
    {
    public:
    RouteCoordSet()
        {
        CoordType = CartoType::CoordType::Degree;
        RoutePointList = ref new Vector<RoutePoint^>;
        }
 
    property CartoType::CoordType CoordType;
    property RoutePointList^ RoutePointList;
 
    internal:
    CartoTypeCore::RouteCoordSet CreateRouteCoordSet();
    };
 
public ref class RouteSegment sealed: public Path
    {
    public:
    property FeatureInfo^ FeatureInfo { CartoType::FeatureInfo^ get(); }
    property String^ Name { String^ get(); };
    property String^ Ref { String^ get(); };
    property String^ Destination { String^ get(); };
    property double Distance { double get(); };
    property double Time { double get(); };
    property double TurnTime { double get(); }
    property TurnType TurnType { CartoType::TurnType get(); }
    property bool IsContinue { bool get(); }
    property RoundaboutState RoundaboutState { CartoType::RoundaboutState get(); }
    property double TurnAngle { double get(); }
    property int ExitNumber { int get(); };
    property int Choices { int get(); }
    property int Section { int get(); };
    property String^ Instructions { String^ get(); };
    
    virtual int ContourCount() { return 1; }
    virtual int PointCount(int aContourIndex);
    virtual PathPoint^ Point(int aContourIndex,int aPointIndex);
 
    internal:
    RouteSegment(std::shared_ptr<CartoTypeCore::RouteSegment> aSegment);
    
    private:
    std::shared_ptr<CartoTypeCore::RouteSegment> m_segment;
    };
 
public ref class Route sealed: public Path
    {
    internal:
    Route(std::shared_ptr<CartoTypeCore::Route> aRoute);
    
    public:
    property Geometry^ Geometry { CartoType::Geometry^ get();  };
    property RouteProfile^ Profile { RouteProfile^ get(); }
    property double Distance { double get(); }
    property double Time { double get(); }
    property int RouteSegmentCount { int get(); }
    RouteSegment^ RouteSegment(int aIndex);
    property double TollRoadDistance { double get(); }
    NearestSegmentInfo^ NearestSegment(double aX,double aY,int aSection,double aPreviousDistanceAlongRoute);
    NearestSegmentInfo^ PointAtDistance(double aDistanceInMeters);
    NearestSegmentInfo^ PointAtTime(double aTimeInSeconds);
    virtual int ContourCount();
    virtual int PointCount(int aContourIndex);
    virtual PathPoint^ Point(int aContourIndex,int aPointIndex);
    
    internal:
    std::shared_ptr<CartoTypeCore::Route> GetRoute() { return m_route; }
 
    private:
    std::shared_ptr<CartoTypeCore::Route> m_route;
    };
 
public ref class Address sealed
    {
    public:
    String^ ToString(bool aFull);
 
    property String^ Building;
    property String^ Feature;
    property String^ Street;
    property String^ SubLocalty;
    property String^ Locality;
    property String^ Island;
    property String^ SubAdminArea;
    property String^ AdminArea;
    property String^ Country;
    property String^ PostCode;
    
    internal:
    void Get(CartoTypeCore::Address& aAddress);
    void Set(const CartoTypeCore::Address& aAddress);
    };
 
public enum class SideOfRoad
    {
    None,
    Right,
    Left,
    Both
    };
 
public ref class NearestRoadInfo sealed
    {
    public:
    property FeatureInfo^ FeatureInfo;
    property String^ Name;
    property String^ Ref;
    property double NearestPointX;
    property double NearestPointY;
    property double Distance;
    property double HeadingInDegrees;
    property double HeadingVectorX;
    property double HeadingVectorY;
    property SideOfRoad SideOfRoad;
 
    internal:
    void Set(const CartoTypeCore::NearestRoadInfo& aInfo);
    };
 
public enum class WritableMapType
    {
    Memory,
    SQLite
    };
 
public enum class FileType
    {
    Png,
    Jpeg,
    Tiff,
    Ctm1,
    Ctms,
    Kml,
    Ctsql,
    CartoTypeRoute,
    Gpx
    };
 
public ref class TrafficInfo sealed
    {
    public:
    TrafficInfo()
        {
        VehicleTypes = int(FeatureConstants::KRouteAccessVehicle);
        Speed = 255;
        }
        
    property int VehicleTypes;
    property double Speed;
    };
 
public enum class RoadOrientation
    {
    None,
    Forwards,
    Backwards,
    Both,
    };
 
public enum class LRType
    {
    Line,
    GeoCoordinate,
    PointAlongLine,
    PointWithAccessPoint,
    Circle,
    Rectangle,
    Polygon,
    ClosedLine
    };
 
public value struct UpdateTrafficResult
    {
    Result Error;
    int EventsRead;
    int EventsAdded;
    };
 
public enum class LRFunctionalRoadClass
    {
    Main = 0,
    First = 1,
    Second = 2,
    Third = 3,
    Fourth = 4,
    Fifth = 5,
    Sixth = 6,
    Other = 7,
    Unknown = 255
    };
 
public enum class LRFormOfWay
    {
    Undefined = 0,
    Motorway = 1,
    MultipleCarriageway = 2,
    SingleCarriageway = 3,
    Roundabout = 4,
    TrafficSquare = 5,
    SlipRoad = 6,
    Other = 7,
    Unknown = 255
    };
 
public ref class LRPoint sealed
    {
    public:
    LRPoint();
 
    property double Longitude;
    property double Latitude;
    property LRFunctionalRoadClass FRC;
    property LRFormOfWay FOW;
    property double Bearing;
    property bool BearingKnown;
    property double DistanceToNextPoint;
    property LRFunctionalRoadClass LowestRoadClassToNextPoint;
 
    internal:
    LRPoint(const CartoTypeCore::LRPoint& aPoint);
    };
 
using LRGeometry = Windows::Foundation::Collections::IVector<LRPoint^>;
 
public ref class LocationRef sealed
    {
    public:
    LocationRef();
    LocationRef(LRType aType);
 
    property LRType Type;
    property String^ Id;
    property LRGeometry^ Geometry;
    property double RadiusInMeters;
    property SideOfRoad SideOfRoad;
    property RoadOrientation RoadOrientation;
    };
 
public ref class TrafficEvent sealed
    {
    public:
    TrafficEvent();
    static bool CreateFromDatex2Xml(String^ aSituationRecord,TrafficEvent^ aTrafficEvent);
    
    property TrafficInfo^ TrafficInfo;
    property LocationRef^ LocationRef;
    };
 
public enum class NoticeAnchor
    {
    TopLeft,
    TopRight,
    BottomLeft,
    BottomRight,
    Top,
    Right,
    Left,
    Bottom,
    Center
    };
 
public ref class NoticePosition sealed
    {
    public:
    NoticePosition(NoticeAnchor aAnchor);
    NoticePosition(NoticeAnchor aAnchor,double aWidth,String^ aWidthUnit);
    NoticePosition(NoticeAnchor aAnchor,double aWidth,String^ aWidthUnit,double aXInset,String^ aXInsetUnit,double aYInset,String^ aYInsetUnit);
 
    internal:
    std::unique_ptr<CartoTypeCore::NoticePosition> m_position;
    };
 
[Flags]
public enum class FontStyleFlag : unsigned int
    {
    Bold = 1,
    Italic = 2,
    Serif = 4,
    Cursive = 8,
    Fantasy = 16,
    Monospace = 32
    };
 
public ref class MapObjectGroup sealed
    {
    public:
    property String^ Name;
    property MapObjectList^ MapObjectList;
    };
 
using MapObjectGroupList = IVector<MapObjectGroup^>;
 
public ref class PerspectiveParam sealed
    {
    public:
    PerspectiveParam()
        {
        AutoPosition = true;
        AutoAzimuth = true;
        DeclinationDegrees = 30;
        FieldOfViewDegrees = 22.5;
        }
 
    Result ReadFromXml(String^ aText);
    String^ ToXml();
 
    property double PositionDegreesX;
    property double PositionDegreesY;
    property bool AutoPosition;
    property double HeightMeters;
    property double AzimuthDegrees;
    property bool AutoAzimuth;
    property double DeclinationDegrees;
    property double RotationDegrees;
    property double FieldOfViewDegrees;
    };
 
public ref class ViewState sealed
    {
    public:
    ViewState() { WidthInPixels = 256; HeightInPixels = 256; }
 
    Result ReadFromXml(String^ aText);
    String^ ToXml();
 
    property int WidthInPixels;
    property int HeightInPixels;
    property double ViewCenterDegreesX;
    property double ViewCenterDegreesY;
    property double ScaleDenominator;
    property double RotationDegrees;
    property bool Perspective;
    property PerspectiveParam^ PerspectiveParam;
    };
 
public ref class NavigatorParam sealed
    {
    public:
    NavigatorParam()
        {
        MinimumFixDistance = 5;
        RouteDistanceTolerance = 20;
        RouteTimeTolerance = 30;
        NavigationEnabled = true;
        }
 
    property int MinimumFixDistance;
    property int RouteDistanceTolerance;
    property int RouteTimeTolerance;
    property bool NavigationEnabled;
    };
 
public enum class FilePolicy
    {
    Default = 0,
    Cache = 1,
    SharedCache = 2,
    MemoryMap = 3,
    Simple = 4
    };
 
public ref class FrameworkParam sealed
    {
    public:
    FrameworkParam()
        {
        ViewWidth = 256;
        ViewHeight = 256;
        MapFilePolicy = FilePolicy::Default;
        }
    
    property String^ MapFileName;
    property String^ StyleSheetFileName;
    property String^ StyleSheetText;
    property String^ FontFileName;
    property int ViewWidth;
    property int ViewHeight;
    property String^ Key;
    property FilePolicy MapFilePolicy;
    };
 
public enum class ColorValue
    {
    Black = (int)0xFF000000,
    DarkGray = (int)0xFF555555,
    DarkRed = (int)0xFF000080,
    DarkGreen = (int)0xFF008000,
    DarkYellow = (int)0xFF008080,
    DarkBlue = (int)0xFF800000,
    DarkMagenta = (int)0xFF800080,
    DarkCyan = (int)0xFF808000,
    Red = (int)0xFF0000FF,
    Green = (int)0xFF00FF00,
    Yellow = (int)0xFF00FFFF,
    Blue = (int)0xFFFF0000,
    Magenta = (int)0xFFFF00FF,
    Cyan = (int)0xFFFFFF00,
    Gray = (int)0xFFAAAAAA,
    White = (int)0xFFFFFFFF,
 
    TransparentBlack = 0x00000000
    };
 
public value class Color sealed 
    {
    public:
    int Value;
    };
 
Color CreateColor(int aRed,int aGreen,int aBlue)
    {
    return Color { (0xFF << 24) | ((aBlue & 0xFF) << 16) | ((aGreen & 0xFF) << 8) | (aRed & 0xFF) };
    }
 
Color CreateColor(int aRed,int aGreen,int aBlue,int aAlpha)
    {
    return Color { ((aAlpha & 0xFF) << 24) | ((aBlue & 0xFF) << 16) | ((aGreen & 0xFF) << 8) | (aRed & 0xFF) };
    }
 
public ref class BlendStyle sealed
    {
    public:
    property String^ Styles;
    property Color MainColor;
    property Color BorderColor;
    property Color TextColor;
    property Color TextGlowColor;
    property Color IconColor;
    };
 
using BlendStyleSet = IVector<BlendStyle^>;
 
public ref class TimeAndDistanceMatrix sealed
    {
    public:
    property int FromCount { int get(); };
    property int ToCount { int get(); };
    int Time(int aFromIndex,int aToIndex);
    int Distance(int aFromIndex,int aToIndex);
        
    internal:
    TimeAndDistanceMatrix(CartoTypeCore::TimeAndDistanceMatrix* aMatrix);
    
    std::unique_ptr<CartoTypeCore::TimeAndDistanceMatrix> m_matrix;
    };
 
public ref class MapObjectId sealed
    {
    public:
    property int64_t Id;
    };
 
public ref class TileSet sealed
    {
    public:
    property String^ FileNameTemplate;
    property Rect^ TileRange;
    property int FileZoom;
    property int MinDisplayZoom;
    property int MaxDisplayZoom;
    };
 
public ref class TileParam sealed
    {
    public:
    property IVector<TileSet^>^ TileSetList;
    };
 
public ref class Framework sealed
    {
    public:
    Framework(String^ aMapFileName,String^ aStyleSheetFileName,String^ aFontFileName,
              int aViewWidth,int aViewHeight);
    Framework(String^ aMapFileName,String^ aStyleSheetFileName,String^ aFontFileName,
              int aViewWidth,int aViewHeight,String^ aKey);
    Framework(FrameworkParam^ aParam);
   
    Result License(String^ aKey);
    property String^ Licensee { String^ get(); };
    Result SetProviderParam(String^ aKey,String^ aValue);
    property String^ ExpiryDate { String^ get(); };
    property String^ AppBuildDate { String^ get(); };
    property String^ Copyright { String^ get(); };
    void SetCopyrightNotice();
    void SetCopyrightNotice(String^ aCopyright);
    Result SetLegend(NoticePosition^ aPosition,Legend^ aLegend);
    Result SetLegend(NoticeAnchor aAnchor,double aWidth,String^ aUnit);
    property bool LegendEnabled { bool get(); void set(bool); }
    Result SetScaleBar(NoticePosition^ aPosition,Legend^ aLegend);
    Result SetScaleBar(NoticeAnchor aAnchor,double aWidth,String^ aUnit);
    property bool ScaleBarEnabled { bool get(); void set(bool); }
    Result SetTurnInstructions(NoticePosition^ aPosition,Legend^ aLegend,bool aAbbreviate);
    Result SetTurnInstructions(NoticeAnchor aAnchor,double aWidth,String^ aWidthUnit,double aTextSize,String^ aTextSizeUnit,bool aAbbreviate);
    property bool TurnInstructionsEnabled { bool get(); void set(bool); }
    void SetTurnInstructionText(String^ aText);
    property String^ TurnInstructionText { String^ get(); };
    void DrawNoticesAutomatically(bool aEnable);
    property bool HasNotices { bool get();  }
    Result Configure(String^ aConfigFileName);
    Result LoadMap(String^ aMapFileName);
    Result LoadMap(String^ aMapFileName,String^ aEncryptionKey,FilePolicy aPolicy);
    Result LoadMapsAutomatically(TileParam^ aParam);
    void CancelAutomaticMapLoading();
    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 WriteMapImage(String^ aFileName,FileType aFileType,bool aCompress);
    bool MapIsEmpty(int aHandle);
    property int MapCount { int get(); }
    int MapHandle(int aIndex);
    bool MapIsWritable(int aIndex);
    MapMetaData^ MapMetaData(int aIndex);
    Result UnloadMapByHandle(int aHandle);
    void EnableMapByHandle(int aHandle,bool aEnable);
    void EnableAllMaps();
    property int LastMapHandle { int get(); }
    property int MainMapHandle { int get(); }
    property int MemoryMapHandle { int get(); }
    Result LoadFont(String^ aFontFileName);
    Result SetStyleSheet(String^ aStyleSheetFileName,int aIndex);
    Result SetStyleSheetData(String^ aData,int aIndex);
    Result ReloadStyleSheet(int aIndex);
    void AppendStyleSheet(String^ aStyleSheetFileName);
    void AppendStyleSheetData(String^ aData);
    Result DeleteStyleSheet(int aIndex);
    void EnableLayer(String^ aLayerName,bool aEnable);
    bool LayerIsEnabled(String^ aLayerName);
    property IVector<String^>^ LayerNames { IVector<String^>^ get(); };
    Result Resize(int aViewWidth,int aViewHeight);
    property double ResolutionDpi { double get(); void set(double); };
    property double ScaleDenominator { double get(); void set(double); };
    property double ScaleDenominatorInView { double get(); void set(double); };
    double DistanceInMeters(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);
    property bool Perspective { bool get(); void set(bool); }
    property PerspectiveParam^ PerspectiveParam { CartoType::PerspectiveParam^ get(); void set(CartoType::PerspectiveParam^); }
    property bool Draw3DBuildings { bool get(); void set(bool); }
    Result Zoom(double aZoomFactor);
    property bool AnimateTransitions { bool get(); void set(bool); }
    property double LabelFPS { double get(); void set(double); }
    property bool FixedLabels { bool get(); void set(bool); }
    property double LabelUpAngle { double get(); void set(double); }
    Result ZoomAt(double aZoomFactor,double aX,double aY,CoordType aCoordType);
    Result Rotate(double aAngle);
    Result RotateAt(double aAngle,double aX,double aY,CoordType aCoordType);
    property double Rotation { double get(); void set(double); }
    Result SetRotationAt(double aAngle,double aX,double aY,CoordType aCoordType);
    Result RotateAndZoom(double aAngle,double aZoomFactor,double aX,double aY,CoordType aCoordType);
    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 SetViewToMapObjects(MapObjectList^ aObjectList,int aMarginInPixels,int aMinScaleDenominator);
    Result SetViewToGeometry(Geometry^ aGeometry,int aMarginInPixels,int aMinScaleDenominator);
    Result SetViewToRoute(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);
    property String^ ProjectionAsProj4Param { String^ get(); }
    property ViewState^ ViewState { CartoType::ViewState^ get(); void set(CartoType::ViewState^); }
 
    Result InsertMapObject(int aMapHandle,String^ aLayerName,Geometry^ aGeometry,
                           String^ aStringAttributes,FeatureInfo^ aFeatureInfo,MapObjectId^ aId,bool aReplace);
    Result InsertPointMapObject(int aMapHandle,String^ aLayerName,double aX,double aY,
                                CoordType aCoordType,String^ aStringAttributes,FeatureInfo^ aFeatureInfo,MapObjectId^ aId,bool aReplace);
    Result InsertCircleMapObject(int aMapHandle,String^ aLayerName,
                                 double aCenterX,double aCenterY,CoordType aCenterCoordType,double aRadius,CoordType aRadiusCoordType,
                                 String^ aStringAttributes,FeatureInfo^ aFeatureInfo,MapObjectId^ aId,bool aReplace);
    Result InsertEllipseMapObject(int aMapHandle,String^ aLayerName,double aCenterX,double aCenterY,CoordType aCenterCoordType,
                                  double aRadiusX,double aRadiusY,CoordType aRadiusCoordType,double aRotationDegrees,String^ aStringAttributes,FeatureInfo^ aFeatureInfo,MapObjectId^ aId,bool aReplace);
    Result InsertEnvelopeMapObject(int aMapHandle,String^ aLayerName,Geometry^ aGeometry,
                                   double aRadius,CoordType aRadiusCoordType,
                                   String^ aStringAttributes,FeatureInfo^ aFeatureInfo,MapObjectId^ aId,bool aReplace);
 
    Result InsertPushPin(double aX,double aY,CoordType aCoordType,String^ aStringAttributes,String^ aColor,int aIconCharacter,MapObjectId^ aId);
   
    Result InsertCopyOfMapObject(int aMapHandle,String^ aLayerName,MapObject^ aObject,double aEnvelopeRadius,
                                 CoordType aRadiusCoordType,MapObjectId^ aId,bool aReplace);
    
    Result DeleteMapObjects(int aMapHandle,int64_t aStartId,int64_t aEndId,String^ aCondition);
    MapObject^ LoadMapObject(int aMapHandle,int64_t aId);
    Result ReadGpx(int aMapHandle,String^ aFileName);
    Geometry^ Range(CartoType::RouteProfile^ aProfile,double aX,double aY,CoordType aCoordType,double aTimeOrDistance,bool aIsTime);
    TimeAndDistanceMatrix^ TimeAndDistanceMatrix(IVector<PointValue>^ aFrom,IVector<PointValue>^ aTo,CoordType aCoordType);
    bool MutuallyAccessible(IVector<PointValue>^ aPointArray,CoordType aCoordType,IVector<int>^ aGroupArray);
    double Area(Geometry^ aGeometry);
    double Length(Geometry^ aGeometry);
    double ContourArea(Geometry^ aGeometry,int aContourIndex);
    double ContourLength(Geometry^ aGeometry,int aContourIndex);
    Result ConvertCoords(Geometry^ aGeometry,CoordType aToCoordType);
    Result ConvertPoint(Point^ aPoint,CoordType aFromCoordType,CoordType aToCoordType);
    double PixelsToMeters(double aPixels);
    double MetersToPixels(double aMeters);
    property String^ DataSetName { String^ get(); };
 
    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,MapObjectId^ aId,bool aReplace);
    Result EditSetCurrentObjectStringAttribute(String^ aKey,String^ aValue);
    Result EditSetCurrentObjectFeatureInfo(FeatureInfo^ aFeatureInfo);
    double EditGetCurrentObjectArea();
    double EditGetCurrentObjectLength();
 
    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 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 FindGroups(MapObjectGroupList^ aObjectGroupList,FindParam^ aFindParam);
    Result FindNearby(MapObjectList^ aObjectList,FindNearbyParam^ aFindNearbyParam);
 
    Result FindPolygonsContainingPath(MapObjectList^ aObjectList,Geometry^ aPath,FindParam^ aFindParam);
    Result FindPointsInPath(MapObjectList^ aObjectList,Geometry^ aPath,FindParam^ aFindParam);
    double Height(double aX,double aY,CoordType aCoordType);
    IVector<HeightProfilePoint^>^ HeightProfile(Route^ aRoute,double aIntervalInMeters);
 
    // style sheet variables
    void SetStyleSheetVariableToString(String^ aVariableName,String^ aValue);
    void SetStyleSheetVariableToInt(String^ aVariableName,int aValue);
 
    // night mode and color blending
    property bool NightMode { bool get(); void set(bool); }
    property bool Monochrome { bool get(); void set(bool); }
    property Color NightModeColor { Color get(); void set(Color); }
    property BlendStyleSet^ BlendStyleSet { CartoType::BlendStyleSet^ get(); void set(CartoType::BlendStyleSet^); }
 
    // geocoding
    String^ GeoCodeSummary(MapObject^ aMapObject);
    Result GetAddress(Address^ aAddress,MapObject^ aMapObject);
 
    Result GetAddressFast(Address^ aAddress,MapObject^ aMapObject);
 
    String^ GeoCodeSummary(double aX,double aY,CoordType aCoordType);
 
    Result GetAddress(Address^ aAddress,double aX,double aY,CoordType aCoordType);
 
    // navigation
    property RouterType PreferredRouterType { RouterType get(); void set(RouterType); }
    property RouterType ActualRouterType { RouterType get(); }
    Result StartNavigation(RouteCoordSet^ aCoordSet);
    Result StartNavigationDeferred(RouteCoordSet^ aCoordSet);
    Result StartNavigation(IVector<double>^ aX,IVector<double>^ aY,CoordType aCoordType);
    Result StartNavigation(double aStartX,double aStartY,CoordType aStartCoordType,
                           double aEndX,double aEndY,CoordType aEndCoordType);
    Route^ CreateRoute(RouteProfile^ aProfile,RouteCoordSet^ aCoordSet);
    Route^ CreateRoute(RouteProfile^ aProfile,IVector<double>^ aX,IVector<double>^ aY,CoordType aCoordType);    
    Result ReverseRoute();
    Result DeleteRoute();
    Route^ CreateBestRoute(RouteProfile^ aProfile,RouteCoordSet^ aCoordSet,
                           bool aStartFixed,bool aEndFixed,int aIterations);
    Route^ CreateBestRoute(RouteProfile^ aProfile,IVector<double>^ aX,IVector<double>^ aY,CoordType aCoordType,
                           bool aStartFixed,bool aEndFixed,int aIterations);
 
 
    Route^ CreateRouteFromXml(RouteProfile^ aProfile,String^ aFilenameOrData);
 
    Result UseRoute(CartoType::Route^ aRoute);
    String^ RouteInstructions(CartoType::Route^ aRoute);
    void EndNavigation();
    property bool NavigationEnabled { bool get(); void set(bool); }
    Result LoadNavigationData();
    Result SetRouteProfile(CartoType::RouteProfile^ aProfile);
    Result SetRouteProfileType(CartoType::RouteProfileType aProfileType);
    CartoType::RouteProfile^ RouteProfile();
    property int BuiltInRouteProfileCount { int get(); }
    CartoType::RouteProfile^ BuiltInRouteProfile(int aIndex);
    Result SetBuiltInRouteProfile(int aIndex);
    int BuiltInRouteProfileIndex();
    Result DisplayRoute(bool aEnabled);
    Result DisplayRouteChoices(IVector<CartoType::Route^>^ aRouteArray);
    CartoType::Route^ Route();
    Result ReadRouteFromXml(String^ aFileNameOrData);
    Result WriteRouteAsXml(CartoType::Route^ aRoute,String^ aFileName,FileType aFileType);
    String^ WriteRouteAsXmlString(CartoType::Route^ aRoute,FileType aFileType);
    Result Navigate(int aValidity,double aTime,double aLong,double aLat,double aSpeed,double aBearing,double aHeight);
    property Turn^ FirstTurn { Turn^ get(); }
    property Turn^ SecondTurn { Turn^ get(); }
    property Turn^ ContinuationTurn { Turn^ get(); }
    property NavigationState NavigationState { CartoType::NavigationState get();  }
    property String^ Framework::VoiceInstruction { String^ get(); }
    property NavigatorParam^ NavigatorParam { CartoType::NavigatorParam^ get(); void set(CartoType::NavigatorParam^); }
    property LocationMatchParam^ LocationMatchParam { CartoType::LocationMatchParam^ get(); void set(CartoType::LocationMatchParam^); }
    property int NavigationMinimumFixDistance { int get(); void set(int); }
    property int NavigationTimeOffRouteTolerance { int get(); void set(int); }
    property int NavigationDistanceOffRouteTolerance { int get(); void set(int); }
    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();
    property double DistanceToDestination { double get(); }
    property double EstimatedTimeToDestination { double get(); }
    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);
    property CartoType::FollowMode FollowMode { CartoType::FollowMode get(); void set(CartoType::FollowMode); }
 
    Result SetFollowScale(double aMinScale,double aSlowScale,double aFastScale,double aMaxScale);
 
    Result GetNavigationPosition(Point^ aPos,CoordType aCoordType);
 
    property String^ Locale { String^ get(); void set(String^); }
 
    property bool MetricUnits { bool get(); void set(bool); }
 
    String^ DistanceToString(double aDistanceInMeters,bool aAbbreviate);
 
    String^ TimeToString(double aTimeInSeconds);
 
    String^ SetCase(String^ aString,LetterCase aCase);
 
    Result AddTrafficEvent(MapObjectId^ aId,TrafficEvent^ aTrafficEvent);
    
    Result AddPolygonSpeedLimit(MapObjectId^ aId,Geometry^ aPolygon,double aSpeed,int aVehicleTypes);
 
    Result AddLineSpeedLimit(MapObjectId^ aId,LRGeometry^ aLine,double aSpeed,int aVehicleTypes);
    
    Result AddClosedLineSpeedLimit(MapObjectId^ aId,LRGeometry^ aLine,double aSpeed,int aVehicleTypes);
 
    Result AddForbiddenArea(MapObjectId^ aId,Geometry^ aPolygon);
    
    Result DeleteTrafficEvent(int64_t aId);
 
    void ClearTrafficInfo();
    
    property bool TrafficInfoEnabled { bool get(); void set(bool); }
 
    UpdateTrafficResult UpdateTrafficFromDatex2(String^ aXmlText);
 
    void StartTracking();
 
    void EndTracking();
 
    void DeleteTrack();
 
    bool Tracking();
 
    property bool DisplayTrack { bool get(); void set(bool); }
 
    property Geometry^ Track { Geometry^ get(); }
 
    property double TrackLengthInMeters { double get(); }
 
    Result WriteTrackAsXml(String^ aFileName);
        
    property String^ TrackAsXmlString { String^ get(); }
 
    property Result LastError { Result get(); }
 
    internal:
    CartoTypeCore::Framework* GetFramework() { return m_framework.get(); }
 
    private:
    std::unique_ptr<CartoTypeCore::Framework> m_framework;
    CartoTypeCore::Result m_error;
    };
 
public enum class Align
    {
    Center,
    Standard,
    Reverse,
    Left,
    Right
    };
 
[Flags]
public enum class LegendStyleFlag: unsigned int
    {
    Title = 1,
    ScaleInTitle = 2,
    MapObjects = 4,
    ScaleBar = 8,
    HeightProfile = 16,
    StandardStyle = 15,
    TurnStyle = 32,
    ScaleStyle = 64,
    EmptyStyle = 0
    };
 
public ref class Legend sealed
    {
    public:
    Legend(Framework^ aFramework);
 
    Legend(Framework^ aFramework,uint32_t aStyle);
 
    void Clear();
 
    void AddMapObjectLine(MapObjectType aType,String^ aLayer,FeatureInfo^ aFeatureInfo,String^ aStringAttrib,String^ aLabel);
    
    void AddTextLine(String^ aText);
    
    void AddScaleLine();
 
    void AddTurnLine(bool aAbbreviate);
 
    void AddHeightProfileLine();
 
    void SetMainStyleSheet(String^ aData);
    
    void SetExtraStyleSheet(String^ 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 SetLabelWrapWidth(double aWrapWidth,String^ aUnit);
    
    void SetFontFamily(String^ aFontFamily);
 
    void SetFontStyle(uint32_t aStyle);
 
    void SetFontSize(double aFontSize,String^ aUnit);
 
    void SetTextColor(Color aTextColor);
 
    void SetDiagramColor(Color aDiagramColor);
 
    void SetAlignment(Align aAlignment);
 
    void SetPolygonRotation(double aDegrees);
 
    void SetTurnInstruction(String^ aText);
 
    String^ TurnInstruction();
 
    internal:
    CartoTypeCore::Legend* GetLegend() { return m_legend.get(); }
 
    private:
    std::unique_ptr<CartoTypeCore::Legend> m_legend;
    };
 
public ref class MapRenderer sealed
    {
    public:
    MapRenderer(Framework^ aFramework);
    void Draw();
 
    private:
    std::shared_ptr<class CartoTypeCore::CVectorTileServer> m_vector_tile_server;
    };
 
public ref class Util sealed
    {
    public:
    static String^ Description();
    static String^ Version();
    static String^ Build();
 
    static double GreatCircleDistanceInMeters(double aLong1,double aLat1,double aLong2,double aLat2);
    static double AzimuthInDegrees(double aLong1,double aLat1,double aLong2,double aLat2);
    static Point^ PointAtAzimuth(double aLong,double aLat,double aDir,double aDistanceInMeters);
    static String^ SetAttribute(String^ aString,String^ aKey,String^ aValue);
    static String^ ErrorString(Result aError);
    static String^ UKGridReferenceFromDegrees(PointValue aPointInDegrees,int aDigits);
    static PointValue PointInDegreesFromUKGridReference(String^ aGridReference);
    };
 
}