CartoTypeWrapper.h

/*
CartoTypeWrapper.h
Copyright (C) CartoType Ltd 2011-2023.
See www.cartotype.com for more information.
*/
 
#pragma once
 
#include "CartoTypeResult.h"
#include "CartoTypeGeometry.h"
#include "CartoTypeMetaData.h"
#include "CartoTypeFeatureInfo.h"
 
using namespace System;
using namespace System::Collections::Generic;
 
#using "System.Drawing.dll"
 
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 ExtendedNoticePosition;
class TimeAndDistanceMatrix;
}
 
namespace CartoType
{
 
// forward declarations
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 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
    {
    public:
    FindNearbyParam() { Type = FeatureType::Invalid; }
 
    property FeatureType Type;
    property String^ Text;
    property Geometry^ Location;
    };
 
public ref class FindParam
    {
    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
    {
    public:
    property bool Found;
    property String^ Key;
    property String^ Value;
    property int Start;
    property int End;
    };
 
public ref class MapObject: public Path
    {
    public:
    ~MapObject();
    
    property String^ Label { String^ get(); };
    property FeatureInfo^ FeatureInfo { CartoType::FeatureInfo^ get(); }
    String^ StringAttribute(String^ aName);
    SortedDictionary<String^,String^>^ StringAttributes();
    property Int64 Id { Int64 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(CartoTypeCore::MapObject* aMapObject);
    
    protected:
    !MapObject();
 
    internal:
    CartoTypeCore::MapObject* 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;
    CartoTypeCore::MapRenderer* 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,
    Routing,
    NewRoute,
    TurnRound,
    Arrival
    };
 
public ref class LocationMatchParam
    {
    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
    {
    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 String^ ToName;
    property String^ ToRef;
    property String^ Instructions;
    
    internal:
    void Set(const CartoTypeCore::NavigatorTurn& aTurn);
    };
 
public enum class RouteProfileType
    {
    Car,
    Walk,
    Walking = Walk,
    Cycle,
    Bicycle = Cycle,
    Hike,
    Hiking = Hike,
    Ski
    };
 
public ref class RouteProfile
    {
    public:
    RouteProfile();
    RouteProfile(RouteProfileType aProfileType);
    Result ReadFromXmlFile(String^ aFileName);
    Result ReadFromXmlString(String^ aString);
    Result WriteAsXmlFile(String^ aFileName);
    property String^ XmlString { String^ get(); }
 
    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;
 
    array<double>^ Speed;
 
    array<double>^ Bonus;
 
    array<int>^ RestrictionOverride;
 
    property int TurnTime;
 
    property int UTurnTime;
 
    property int CrossTrafficTurnTime;
 
    property int TrafficLightTime;
 
    property bool Shortest;
 
    property bool ShortestByTime;
 
    property double TollPenalty;
 
    array<double>^ GradientSpeed;
 
    array<double>^ GradientBonus;
 
    property int GradientFlags;
 
    internal:
    void Set(const CartoTypeCore::RouteProfile& aProfile);
    void Get(CartoTypeCore::RouteProfile& aProfile);
    };
 
public ref class NearestSegmentInfo
    {
    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
    {
    public:
    property double X;
    property double Y;
    property double Heading;
    property bool HeadingKnown;
    property LocationMatchParam^ LocationMatchParam;
    };
 
public ref class RoutePointList: List<RoutePoint^>
    {
    };
 
public ref class RouteCoordSet
    {
    public:
    RouteCoordSet()
        {
        CoordType = CartoType::CoordType::Degree;
        }
 
    property CartoType::CoordType CoordType;
    RoutePointList^ RoutePointList = gcnew CartoType::RoutePointList();
 
    internal:
    CartoTypeCore::RouteCoordSet CreateRouteCoordSet();
    };
 
public ref class RouteSegment: public Path
    {
    public:
    property FeatureInfo^ FeatureInfo { CartoType::FeatureInfo^ get(); }
    property String^ Name { String^ get(); };
    property String^ Ref { 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(); };
    
    virtual int ContourCount() { return 1; }
    virtual int PointCount(int aContourIndex);
    virtual PathPoint^ Point(int aContourIndex,int aPointIndex);
 
    internal:
    RouteSegment(Route^ aRoute,const CartoTypeCore::RouteSegment* aSegment);
    
    private:
    Route^ m_route;                    // a reference to the parent route, to keep it in existence
    const CartoTypeCore::RouteSegment* m_segment;    // the segment: owned by m_route
    };
 
public ref class Route: public Path
    {
    internal:
    Route(CartoTypeCore::Route* aRoute);
    ~Route();
    
    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:
    const CartoTypeCore::Route* GetRoute() { return m_route; }
 
    protected:
    !Route();
 
    private:
    CartoTypeCore::Route* m_route;
    };
 
public ref class Address
    {
    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
    {
    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 MapObjectList: List<MapObject^>
    {
    };
 
public ref class TrafficInfo
    {
    public:
    TrafficInfo();
    
    literal double NoSpeedLimit = 255;
    
    property int VehicleTypes;
    property double Speed;
    };
 
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);
 
    property LocationRefType Type;
    property String^ Id;
    property Geometry^ Geometry;
    property double RadiusInMeters;
    property SideOfRoad SideOfRoad;
    property RoadOrientation RoadOrientation;
    };
 
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:
    CartoTypeCore::ExtendedNoticePosition* m_position = nullptr;
    };
 
public ref class PositionedBitmap
    {
    public:
    property Drawing::Bitmap^ Bitmap;
    property int X;
    property int Y;
    };
 
public ref class MapObjectGroup
    {
    public:
    property String^ Name;
    property MapObjectList^ MapObjectList;
    };
 
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:
    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
    {
    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
    {
    public:
    NavigatorParam()
        {
        MinimumFixDistance = 5;
        RouteDistanceTolerance = 20;
        RouteTimeTolerance = 30;
        NavigationEnabled = true;
        }
   
    property int MinimumFixDistance;
    property int RouteDistanceTolerance;
    property int RouteTimeTolerance;
    property bool NavigationEnabled;
    };
 
public ref class FrameworkParam
    {
    public:
    FrameworkParam()
        {
        ViewWidth = 256;
        ViewHeight = 256;
        }
    
    property String^ MapFileName;
    property String^ StyleSheetFileName;
    property String^ StyleSheetText;
    property String^ FontFileName;
    property int ViewWidth;
    property int ViewHeight;
    property String^ EncryptionKey;
    property int FileBufferSizeinBytes;
    property int MaxFileBufferCount;
    property int TextIndexLevels;
    };
 
public value class Color
    {
    public:
    Color(int aValue) { Value = aValue; }
    Color(int aRed,int aGreen,int aBlue)
        {
        Value = (0xFF << 24) | ((aBlue & 0xFF) << 16) | ((aGreen & 0xFF) << 8) | (aRed & 0xFF);
        }
    Color(int aRed,int aGreen,int aBlue,int aAlpha)
        {
        Value = ((aAlpha & 0xFF) << 24) | ((aBlue & 0xFF) << 16) | ((aGreen & 0xFF) << 8) | (aRed & 0xFF);
        }
    Color(String^ aColor);
    property int Red { int get() { return (Value & 0xFF); } }
    property int Green { int get() { return (Value & 0xFF00) >> 8; } }
    property int Blue { int get() { return (Value & 0xFF0000) >> 16; } }
    property int Gray { int get() { return ((Value & 0xFF) + ((Value & 0xFF00) >> 8) + ((Value & 0xFF0000) >> 16)) / 3; } }
    property int Alpha { int get() { return (Value & 0xFF000000) >> 24; } void set(int aAlpha) { Value = (aAlpha << 24) | (Value & 0xFFFFFF); } }
    property bool IsNull { bool get() { return (Value & 0xFF000000) == 0; } }
 
    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);
 
    property int Value;
    };
 
public ref class BlendStyle
    {
    public:
    property String^ Styles;
    property Color MainColor;
    property Color BorderColor;
    property Color TextColor;
    property Color TextGlowColor;
    property Color IconColor;
    };
 
public ref class BlendStyleSet: List<BlendStyle^>
    {
    };
 
public ref class TimeAndDistanceMatrix
    {
    public:
    property int FromCount { int get(); };
    property int ToCount { int get(); };
    int Time(int aFromIndex,int aToIndex);
    int Distance(int aFromIndex,int aToIndex);
 
    protected:
    !TimeAndDistanceMatrix();
        
    internal:
    TimeAndDistanceMatrix(CartoTypeCore::TimeAndDistanceMatrix* aMatrix);
    ~TimeAndDistanceMatrix();
    
    CartoTypeCore::TimeAndDistanceMatrix* m_matrix = nullptr;
    };
 
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);
    property String^ Licensee { String^ get(); };
    property String^ ExpiryDate { String^ get(); };
    property String^ AppBuildDate { String^ get(); };
    property String^ Copyright { String^ get(); };
    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);
    property bool LegendEnabled { bool get(); void set(bool); }
    void SetScaleBar(bool aMetricUnits,double aWidth,String^ aUnit,NoticePosition aPosition);
    void SetScaleBar(bool aMetricUnits,double aWidth,String^ aUnit,ExtendedNoticePosition^ aPosition);
    property bool ScaleBarEnabled { bool get(); void set(bool); }
    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);
    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();  }
    PositionedBitmap^ NoticeBitmap();
    Result Configure(String^ aConfigFileName);
    Result LoadMap(String^ aMapFileName);
    Result LoadMap(String^ aMapFileName,array<Byte>^ aEncryptionKey);
    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);
    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 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);
    property List<String^>^ LayerNames { List<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);
    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 SetView(MapObjectList^ aObjectList,int aMarginInPixels,int aMinScaleDenominator);
    Result SetView(Geometry^ aGeometry,int aMarginInPixels,int aMinScaleDenominator);
    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);
    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,Int64% aId,bool aReplace);
    Result InsertPointMapObject(int aMapHandle,String^ aLayerName,double aX,double aY,
                                CoordType aCoordType,String^ aStringAttributes,FeatureInfo^ aFeatureInfo,Int64% aId,bool aReplace);
    Result InsertCircleMapObject(int aMapHandle,String^ aLayerName,
                                 double aCenterX,double aCenterY,CoordType aCenterCoordType,double aRadius,CoordType aRadiusCoordType,
                                 String^ aStringAttributes,FeatureInfo^ aFeatureInfo,Int64% 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,Int64% aId,bool aReplace);
    Result InsertEnvelopeMapObject(int aMapHandle,String^ aLayerName,Geometry^ aGeometry,
                                   double aRadius,CoordType aRadiusCoordType,
                                   String^ aStringAttributes,FeatureInfo^ aFeatureInfo,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^ TimeAndDistanceMatrix(Result% aResult,array<PointValue>^ aFrom,array<PointValue>^ aTo,CoordType aCoordType);
    bool MutuallyAccessible(Result% aResult,array<PointValue>^ aPointArray,CoordType aCoordType,array<int>^ aGroupArray);
    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);
    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,Int64% aId,bool aReplace);
    Result EditSetCurrentObjectStringAttribute(String^ aKey,String^ aValue);
    Result EditSetCurrentObjectFeatureInfo(FeatureInfo^ aFeatureInfo);
    Result EditGetCurrentObjectAreaAndLength(double% aArea,double% aLength);
 
    Drawing::Bitmap^ MapBitmap();
    Drawing::Bitmap^ MemoryDataBaseMapBitmap();
    void DrawMemoryDataBase(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 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 Height(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
    property bool NightMode { 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(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^ RouteInstructions(Route^ aRoute);
    void EndNavigation();
    property bool NavigationEnabled { bool get(); void set(bool); }
    Result LoadNavigationData();
    Result SetMainProfile(RouteProfile^ aProfile);
    RouteProfile^ Profile(int aIndex);
    property int BuiltInProfileCount { int get(); }
    RouteProfile^ BuiltInProfile(int aIndex);
    Result SetBuiltInProfile(int aIndex);
    Result AddProfile(RouteProfile^ aProfile);
    Result ChooseRoute(int aRouteIndex);
    Result DisplayRoute(bool aEnable);
    property int RouteCount { int get(); }
    Route^ Route(int aRouteIndex);
    Result ReadRouteFromXml(String^ aFileNameOrData,bool aReplace);
    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 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 GetNavigationPosition(Point^ aPos,CoordType aCoordType);
 
    property String^ Locale { String^ get(); void set(String^); }
 
    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();
    
    property bool TrafficInfoEnabled { bool get(); void set(bool); }
 
    void StartTracking();
 
    void EndTracking();
 
    void DeleteTrack();
 
    property bool Tracking { bool get(); }
 
    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(); }
 
    static const int KMaxRoutesDisplayed = 16;
 
    // server
 
    array<Byte>^ HandleQuery(String^ aQuery,array<Byte>^ aData);
    
    protected:
    !Framework();
    
    internal:
    auto 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);
 
    CartoTypeCore::Framework* 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,FeatureInfo^ aFeatureInfo,String^ aStringAttrib,String^ aLabel);
    
    void AddMapObjectLine(MapObjectType aType,String^ aLayer,FeatureType aFeatureType,String^ aStringAttrib,String^ aLabel);
 
    void AddTextLine(String^ aText);
    
    void AddScaleLine(bool aMetricUnits);
 
    void AddTurnLine(bool aMetricUnits,bool aAbbreviate);
 
    void SetMainStyleSheet(array<Byte>^ aData);
 
    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 SetLabelWrapWidth(double aWrapWidth,String^ aUnit);
 
    void SetFontFamily(String^ aFontFamily);
 
    void SetFontSize(double aFontSize,String^ aUnit);
 
    void SetTextColor(Color aTextColor);
 
    void SetDiagramColor(Color aDiagramColor);
 
    void SetAlignment(Align aAlignment);
 
    void SetPolygonRotation(double aDegrees);
 
    bool HasTurnInstruction();
 
    void SetTurnInstruction(String^ aText);
 
    String^ TurnInstruction();
 
    protected:
    !Legend();
 
    internal:
    CartoTypeCore::Legend* GetLegend() { return m_legend; }
 
    private:
    CartoTypeCore::Legend* m_legend = nullptr;
    };
 
public ref class Util abstract sealed
    {
    public:
    static String^ Description();
    static String^ Version();
    static String^ Build();
 
    static double SphericalPolygonArea(array<double>^ aX,array<double>^ aY);
    static double Length(array<double>^ aX,array<double>^ aY);
    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 double DistanceFromPoint(array<double>^ aX,array<double>^ aY,bool aIsPolygon,double aPointX,double aPointY,Point^ aNearestPoint);
    static String^ SetAttribute(String^ aString,String^ aKey,String^ aValue);
    static String^ ErrorString(Result aError);
    };
 
}