CartoTypeWrapper.h

/*
CartoTypeWrapper.h
Copyright (C) CartoType Ltd 2011-2026.
See www.cartotype.com for more information.
*/
 
#pragma once
 
#include "CartoTypeResult.h"
#include "CartoTypeGeometry.h"
#include "CartoTypeMetaData.h"
#include "CartoTypeFeatureInfo.h"
#include <memory>
 
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 NoticePosition;
class TimeAndDistanceMatrix;
class LRPoint;
}
 
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;
ref class LoadMapAsyncHelper;
 
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 ref struct ValidityFlag
    {
    public:
    static constexpr uint32_t Time = 1;
    static constexpr uint32_t Position = 2;
    static constexpr uint32_t Speed = 4;
    static constexpr uint32_t Course = 8;
    static constexpr uint32_t Height = 16;
    };
 
public enum class NavigationState
    {
    None,
    NoPosition,
    Turn,
    OffRoute,
    Routing,
    NewRoute,
    TurnRound,
    Arrival,
    Departure
    };
 
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 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 ref class RouteProfile
    {
    public:
    RouteProfile();
    RouteProfile(RouteProfileType aProfileType);
    Result ReadFromXmlFile(String^ aFileName);
    Result ReadFromXmlString(String^ aString);
    Result WriteAsXmlFile(String^ aFileName);
    Result CopyWeights(int aSourceType,int aDestType);
    static int CustomType(int aIndex) { assert(aIndex >= 0 && aIndex < 32); return aIndex + 32; }
    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 uint64_t GradientFlags;
 
    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 OtherRoad = 22;
    literal int UnpavedRoad = 23;
    literal int Railway = 24;
    literal int LightRail = 25;
    literal int Subway = 26;
    literal int AerialWay = 27;
    literal int SkiDownhill = 28;
    literal int SkiNordic = 29;
    literal int Waterway = 30;
    literal int UnknownRoute = 31;
    literal int RouteTypeCount = 64;
 
    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 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> aRouteSegment);
    
    private:
    std::shared_ptr<CartoTypeCore::RouteSegment>* m_route_segment; // use a pointer to a shared pointer because a shared pointer is unmanaged and cannot be stored directly in a managed class
    };
 
public ref class Route: public Path
    {
    internal:
    Route(std::shared_ptr<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:
    std::shared_ptr<CartoTypeCore::Route> GetRoute() { return *m_route; }
 
    protected:
    !Route();
 
    private:
    std::shared_ptr<CartoTypeCore::Route>* m_route; // use a pointer to a shared pointer because a shared pointer is unmanaged and cannot be stored directly in a managed class
    };
 
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 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);
    };
 
public ref class LRGeometry: List<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
    {
    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);
    ~NoticePosition();
 
    protected:
    !NoticePosition();
 
    internal:
    CartoTypeCore::NoticePosition* m_position = nullptr;
    };
 
public ref class PositionedBitmap
    {
    public:
    property Drawing::Bitmap^ Bitmap;
    property int X;
    property int Y;
    };
 
public ref struct FontStyleFlag
    {
    public:
    static constexpr uint32_t Bold = 1;
    static constexpr uint32_t Italic = 2;
    static constexpr uint32_t Serif = 4;
    static constexpr uint32_t Cursive = 8;
    static constexpr uint32_t Fantasy = 16;
    static constexpr uint32_t Monospace = 32;
    };
 
public ref class MapObjectGroup
    {
    public:
    property String^ Name;
    property MapObjectList^ MapObjectList;
    };
 
public ref class MapObjectGroupList: List<MapObjectGroup^>
    {
    };
 
public delegate void FindAsyncDelegate(MapObjectList^ aMapObjectList);
 
public delegate void FindAsyncGroupDelegate(MapObjectGroupList^ aMapObjectGroupList);
 
public delegate void RouterAsyncDelegate(Result aResult,Route^ aRoute);
 
public delegate void LoadMapAsyncDelegate(Result aResult,String^ aFileName,String^ aKey);
 
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 enum class FilePolicy
    {
    Default = 0,
    Cache = 1,
    SharedCache = 2,
    MemoryMap = 3,
    Simple = 4
    };
 
public ref class FrameworkParam
    {
    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 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 TileSet
    {
    public:
    property String^ FileNameTemplate;
    property Rect^ TileRange;
    property int FileZoom;
    property int MinDisplayZoom;
    property int MaxDisplayZoom;
    };
 
public ref class TileParam
    {
    public:
    property List<TileSet^>^ TileSetList;
    };
 
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,String^ aKey);
    Framework(FrameworkParam^ aParam);
    
    ~Framework();
 
    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();  }
    PositionedBitmap^ NoticeBitmap();
    Result Configure(String^ aConfigFileName);
    Result LoadMap(String^ aMapFileName);
    Result LoadMap(String^ aMapFileName,String^ aKey,FilePolicy aPolicy);
    Result LoadMapAsync(LoadMapAsyncDelegate^ aDelegate,String^ aMapFileName,String^ aKey,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 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 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^ 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);
    double Height(double aX,double aY,CoordType aCoordType);
    Result GetHeights(array<double>^ aX,array<double>^ aY,array<double>^ aTerrainHeightArray,CoordType aCoordType);
    array<HeightProfilePoint^>^ HeightProfile(Route^ aRoute,double aIntervalInMeters);
 
    // 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 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(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 ReverseRoute();
    Result DeleteRoute();
    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);
    String^ RouteInstructions(Route^ aRoute);
    void EndNavigation();
    property bool NavigationEnabled { bool get(); void set(bool); }
    Result LoadNavigationData();
    Result SetRouteProfile(CartoType::RouteProfile^ aProfile);
    Result SetRouteProfileType(CartoType::RouteProfileType aProfileType);
    RouteProfile^ RouteProfile();
    property int BuiltInRouteProfileCount { int get(); }
    CartoType::RouteProfile^ BuiltInRouteProfile(int aIndex);
    Result SetBuiltInRouteProfile(int aIndex);
    int BuiltInRouteProfileIndex();
    Result DisplayRoute(bool aEnable);
    Result DisplayRouteChoices(array<CartoType::Route^>^ aRouteArray);
    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(Int64% aId,TrafficEvent^ aTrafficEvent);
    
    Result AddPolygonSpeedLimit(Int64% aId,Geometry^ aPolygon,double aSpeed,int aVehicleTypes);
 
    Result AddLineSpeedLimit(Int64% aId,LRGeometry^ aLine,double aSpeed,int aVehicleTypes);
    
    Result AddClosedLineSpeedLimit(Int64% aId,LRGeometry^ aLine,double aSpeed,int aVehicleTypes);
 
    Result AddForbiddenArea(Int64% aId,Geometry^ aPolygon);
    
    Result DeleteTrafficEvent(Int64 aId);
 
    void ClearTrafficInfo();
    
    property bool TrafficInfoEnabled { bool get(); void set(bool); }
 
    UpdateTrafficResult UpdateTrafficFromDatex2(String^ aXmlText);
 
    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);
 
    property Result LastError { Result get(); }
    
    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^>();
    List<LoadMapAsyncHelper^>^ m_load_map_async_helper_list = gcnew List<LoadMapAsyncHelper^>();
 
    private:
    Result CreateRouteAsync(RouterAsyncDelegate^ aDelegate,bool aBest,CartoType::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;
    uint32_t m_error = 0;
    };
 
public enum class Align
    {
    Center,
    Standard,
    Reverse,
    Left,
    Right
    };
 
public ref struct LegendStyleFlag
    {
    public:
    static constexpr uint32_t Title = 1;
    static constexpr uint32_t ScaleInTitle = 2;
    static constexpr uint32_t MapObjects = 4;
    static constexpr uint32_t ScaleBar = 8;
    static constexpr uint32_t HeightProfile = 16;
    static constexpr uint32_t StandardStyle = 15;
    static constexpr uint32_t TurnStyle = 32;
    static constexpr uint32_t ScaleStyle = 64;
    static constexpr uint32_t EmptyStyle = 0;
    };
 
public ref class Legend
    {
    public:
    Legend(Framework^ aFramework);
    
    Legend(Framework^ aFramework,uint32_t aStyle);
 
    ~Legend();
 
    void Clear();
 
    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();
 
    void AddTurnLine(bool aAbbreviate);
 
    void AddHeightProfileLine();
 
    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 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();
 
    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);
    static String^ UKGridReferenceFromDegrees(PointValue aPointInDegrees,int aDigits);
    static PointValue PointInDegreesFromUKGridReference(String^ aGridReference);
    };
 
}