CartoType C++ API 7.8.2, 2022-03-25
for Windows, Linux, Qt and other platforms supporting C++ development
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
CartoType Namespace Reference

Namespaces

namespace  TCharCategoryFlag
 
namespace  TRoadTypeFlag
 
namespace  TTransformType
 

Classes

class  CAddress
 
class  CBidiEngine
 
class  CBinaryInputFile
 
class  CBitmap
 
class  CBitmapTexture
 
class  CContour
 
class  CContourBase
 
class  CContourFP
 
class  CDashArray
 
class  CFileInputStream
 
class  CFileOutputStream
 
class  CFramework
 
class  CFrameworkEngine
 
class  CFrameworkMapDataSet
 
class  CGeneralGeometry
 
class  CGeoCodeItem
 
class  CGeometry
 
class  CGraphicsContext
 
class  CLegend
 
class  CList
 
class  CListBase
 
class  CLocationRef
 
class  CMapMetaData
 
class  CMapObject
 
class  CMapObjectGroup
 
class  CMapRenderer
 
class  CMemoryOutputStream
 
class  COnCurveContour
 
class  COpenFileOutputStream
 
class  COutline
 
class  CPaintServer
 
class  CPalette
 
class  CPathToJunction
 
class  CPattern
 
class  CPointerList
 
class  CPolygonFP
 
class  CPositionedBitmap
 
class  CRCGenerator
 
class  CRefCountedString
 
class  CRoute
 
class  CRouteSegment
 
class  CSimpleFileInputStream
 
class  CString
 
class  CStyleSheetData
 
class  CTag
 
class  CTexture
 
class  CTimeAndDistanceMatrix
 
class  CTrafficInfo
 
class  MContour
 
class  MDictionary
 
class  MInputStream
 
class  MIter
 
class  MLabelHandler
 
class  MNavigatorObserver
 
class  MOutputStream
 
class  MPath
 
class  MPointerDictionary
 
class  MPointTransformer
 
class  MString
 
class  MUserData
 
class  MWritableContour
 
class  TAbbreviation
 
class  TAbbreviationInfo
 
class  TAbbreviationTableEntry
 
class  TBidiRun
 
class  TBitmap
 
class  TBlendStyle
 
class  TBlendStyleSet
 
class  TCameraParam
 
class  TChar
 
class  TCircularPen
 
class  TClipRegion
 
class  TColor
 
class  TContour
 
class  TContourFP
 
class  TCoordPair
 
class  TCoordSet
 
class  TCoordSetOfTwoPoints
 
class  TDataInputStream
 
class  TDataOutputStream
 
class  TDataStream
 
class  TDataVersion
 
class  TExtendedNoticePosition
 
class  TFileLocation
 
class  TFindNearbyParam
 
class  TFindParam
 
class  TFixedSizeContour
 
class  TFixedSizeContourFP
 
class  TFont
 
class  TFontMetrics
 
class  TFontSpec
 
class  TGraphicsParam
 
class  THachureParam
 
class  TIntersectionType
 
class  TLine
 
class  TLineFP
 
class  TListLink
 
class  TLocationMatchParam
 
class  TMapTableType
 
class  TMemoryInputStream
 
class  TNavigationData
 
class  TNavigatorParam
 
class  TNavigatorTurn
 
class  TNearestRoadInfo
 
class  TNearestSegmentInfo
 
class  TOutlinePoint
 
class  TOutlinePointFP
 
class  TPaint
 
class  TPathIntersectionInfo
 
class  TPathIterator
 
class  TPerspectiveParam
 
class  TPoint
 
class  TPoint2
 
class  TPoint3
 
class  TRect
 
class  TRectFP
 
class  TResult
 
class  TRouteCoordSet
 
class  TRouteCreationData
 
class  TRouteIterator
 
class  TRoutePoint
 
class  TRouteProfile
 
class  TSimpleContourData
 
class  TStringMatchMethod
 
class  TText
 
class  TTextBoxStyle
 
class  TTextBuffer
 
class  TTextMetrics
 
class  TTextParam
 
class  TTileBitmapParam
 
class  TTrackPoint
 
class  TTransform
 
class  TTransform3D
 
class  TTransformComponents
 
class  TTurn
 
class  TTypefaceAttrib
 
class  TTypefaceData
 
class  TTypefaceInstance
 
class  TUtf16ToUtf32
 
class  TUtf32Iter
 
class  TUtf8ToUtf32
 
class  TVehicleType
 
class  TViewState
 
class  TWritableContour
 
class  TWritableCoordSet
 
class  TWritableText
 

Typedefs

using CStreetAddressSearchState = std::unique_ptr< CStreetAddressSearchStateImplementation >
 
using TPointFP = TPoint2< double >
 
using TPoint3FP = TPoint3< double >
 
using CMapObjectArray = std::vector< std::unique_ptr< CMapObject > >
 
using FindHandler = std::function< bool(std::unique_ptr< CMapObject >)>
 
using FindAsyncCallBack = std::function< void(std::unique_ptr< CMapObjectArray > aMapObjectArray)>
 
using FindAsyncGroupCallBack = std::function< void(std::unique_ptr< CMapObjectGroupArray > aMapObjectGroupArray)>
 
using RouterAsyncCallBack = std::function< void(TResult aError, std::unique_ptr< CRoute > aRoute)>
 
using CTrackGeometry = CGeneralGeometry< TTrackPoint >
 
using CMapObjectGroupArray = std::vector< CMapObjectGroup >
 
using CStringDictionary = std::map< CString, CString >
 
using CStringTypeDictionary = std::map< CString, int >
 
using CAbbreviationDictionary = std::map< CString, TAbbreviation >
 
using CStyleSheetDataArray = std::vector< CStyleSheetData >
 

Enumerations

enum class  TAddressPart {
  Building , Feature , Street , SubLocality ,
  Locality , Island , SubAdminArea , AdminArea ,
  Country , PostCode
}
 
enum class  TGeoCodeType {
  None , Position , Address , Building ,
  Farm , Footpath , Cycleway , SkiRoute ,
  WalkingRoute , FerryRoute , Railway , PedestrianRoad ,
  Track , ServiceRoad , ResidentialRoad , UnclassifiedRoad ,
  TertiaryRoad , SecondaryRoad , PrimaryRoad , TrunkRoad ,
  Motorway , HikingRoute , CyclingRoute , LandFeature ,
  WaterFeature , Locality , Hamlet , PostCode ,
  AdminArea10 , AdminArea9 , Neighborhood , Village ,
  Suburb , Island , AdminArea8 , Town ,
  AdminArea7 , City , AdminArea6 , AdminArea5 ,
  AdminArea4 , AdminArea3 , AdminArea2 , Country ,
  AdminArea1 , Continent
}
 
enum class  TIntersectionPlace { None = 0 , Before , On , After }
 
enum class  TCoordType {
  Degree , Display , Screen = Display , Map ,
  MapMeter
}
 
enum class  TPointType { OnCurve , Quadratic , Cubic }
 
enum class  TFileType {
  PNG , JPEG , TIFF , CTM1 ,
  CTMS , KML , CTSQL , CTROUTE ,
  GPX , None = -1
}
 
enum class  TWritableMapType { Memory , SQLite , Count , None = -1 }
 
enum class  TMapObjectType {
  Point , Line , Polygon , Array ,
  Count , None = -1
}
 
enum class  TVectorTileObjectClipType { Standard , Fill , Border , Highlight = 0x10000 }
 
enum class  TNoticePosition {
  TopLeft , TopRight , BottomLeft , BottomRight ,
  Top , Right , Left , Bottom ,
  Center
}
 
enum class  TBidiOverride { Neutral , LeftToRight , RightToLeft }
 
enum class  TBidiParDir { LeftToRightPreferred , RightToLeftPreferred , LeftToRightForced , RightToLeftForced }
 
enum class  TBitmapType {
  KBitsPerPixelMask = 63 , KColored = 64 , KPalette = 128 , A1 = 1 ,
  A8 = 8 , A16 = 16 , RGB16 = KColored | 16 , RGB24 = KColored | 24 ,
  RGBA32 = KColored | 32 , P8 = KPalette | 8
}
 
enum class  TLetterCase { None , Lower , Upper , Title }
 
enum class  TCharCategory {
  Lu = TCharCategoryFlag::Lu , Ll = TCharCategoryFlag::Ll , Lt = TCharCategoryFlag::Lt , Lm = TCharCategoryFlag::Lm ,
  Lo = TCharCategoryFlag::Lo , Mn = TCharCategoryFlag::Mn , Mc = TCharCategoryFlag::Mc , Me = TCharCategoryFlag::Me ,
  Nd = TCharCategoryFlag::Nd , Nl = TCharCategoryFlag::Nl , No = TCharCategoryFlag::No , Pc = TCharCategoryFlag::Pc ,
  Pd = TCharCategoryFlag::Pd , Ps = TCharCategoryFlag::Ps , Pe = TCharCategoryFlag::Pe , Pi = TCharCategoryFlag::Pi ,
  Pf = TCharCategoryFlag::Pf , Po = TCharCategoryFlag::Po , Sm = TCharCategoryFlag::Sm , Sc = TCharCategoryFlag::Sc ,
  Sk = TCharCategoryFlag::Sk , So = TCharCategoryFlag::So , Zs = TCharCategoryFlag::Zs , Zl = TCharCategoryFlag::Zl ,
  Zp = TCharCategoryFlag::Zp , Cc = TCharCategoryFlag::Cc , Cf = TCharCategoryFlag::Cf , Cs = TCharCategoryFlag::Cs ,
  Co = TCharCategoryFlag::Co , Cn = TCharCategoryFlag::Cn
}
 
enum class  TBidiType {
  L = TBidiTypeFlag::L , LRE = TBidiTypeFlag::LRE , LRO = TBidiTypeFlag::LRO , R = TBidiTypeFlag::R ,
  AL = TBidiTypeFlag::AL , RLE = TBidiTypeFlag::RLE , RLO = TBidiTypeFlag::RLO , PDF = TBidiTypeFlag::PDF ,
  EN = TBidiTypeFlag::EN , ES = TBidiTypeFlag::ES , ET = TBidiTypeFlag::ET , AN = TBidiTypeFlag::AN ,
  CS = TBidiTypeFlag::CS , NSM = TBidiTypeFlag::NSM , BN = TBidiTypeFlag::BN , B = TBidiTypeFlag::B ,
  S = TBidiTypeFlag::S , WS = TBidiTypeFlag::WS , ON = TBidiTypeFlag::ON
}
 
enum class  TDrawResult {
  Success , Overlap , MaxTurnExceeded , PathLengthExceeded ,
  GlyphNotFound , TransformFailed
}
 
enum class  TPointOfInterestType {
  None , Airport , Bar , Beach ,
  BusStation , Cafe , Camping , FastFood ,
  Fuel , GolfCourse , Hospital , Hotel ,
  Pharmacy , Police , Restaurant , Shops ,
  SportsCenter , Supermarket , SwimmingPool , Tourism ,
  TrainStation
}
 
enum class  TFollowMode {
  None = 0 , Location = KFollowFlagLocation , LocationHeading = KFollowFlagLocation | KFollowFlagHeading , LocationZoom = KFollowFlagLocation | KFollowFlagZoom ,
  LocationHeadingZoom = KFollowFlagLocation | KFollowFlagHeading | KFollowFlagZoom
}
 
enum class  TLineCap { Butt , Round , Square }
 
enum class  TLineJoin { Round , Bevel , Miter }
 
enum class  TTextBaseline {
  Alphabetic , Ideographic , Hanging , Mathematical ,
  Central , Middle , TextBeforeEdge , TextAfterEdge ,
  CentralCaps
}
 
enum class  TAlign {
  Center , Standard , Reverse , Left ,
  Right
}
 
enum class  TPointFormat { Unknown = 0 , Meter = 2 , ScaledDegree = 7 , Meter32nds = 8 }
 
enum class  TRouterType {
  Default , StandardAStar , TurnExpandedAStar , StandardContractionHierarchy ,
  TECH
}
 
enum class  TTurnType {
  None , Ahead , BearRight , Right ,
  SharpRight , Around , SharpLeft , Left ,
  BearLeft
}
 
enum class  TRoundaboutState { None , Enter , Continue , Exit }
 
enum class  TRouteProfileType {
  Drive , Car = Drive , Walk , Cycle ,
  Bicycle = Cycle , Hike
}
 
enum class  TNavigationState {
  None , NoPosition , Turn , OffRoute ,
  ReRouteNeeded , ReRouteDone , TurnRound , Arrival
}
 
enum class  TSideOfRoad { None , Right , Left , Both }
 
enum class  TRoadOrientation { None , Forwards , Backwards , Both }
 
enum class  TLocationRefType {
  Line , GeoCoordinate , PointAlongLine , PointWithAccessPoint ,
  Circle , Rectangle , Polygon , ClosedLine
}
 
enum class  TRouteAccess { Unknown , Accessible , Isolated , NoRoad }
 
enum class  TClipType { Inside , MayIntersectAndHasNoCurves , MayIntersectAndHasCurves }
 
enum class  TClipOperation { Intersection , Union , Difference , Xor }
 
enum class  TPathIntersectionType {
  Unknown , Separate , Intersects , Contains ,
  Contained
}
 
enum class  TEllipseAngleType { Shortest , Longest , Positive , Negative }
 
enum class  TRoadType {
  UnknownMajor = 0 , PrimaryLimitedAccess = 0x100 , Motorway = PrimaryLimitedAccess , MotorwayLink = PrimaryLimitedAccess | TRoadTypeFlag::LinkFlag ,
  PrimaryUnlimitedAccess = 0x200 , Trunk = PrimaryUnlimitedAccess , TrunkLink = Trunk | TRoadTypeFlag::LinkFlag , Primary = PrimaryUnlimitedAccess | TRoadTypeFlag::LowerGradeFlag ,
  PrimaryLink = Primary | TRoadTypeFlag::LinkFlag , Secondary = 0x300 , SecondaryLink = Secondary | TRoadTypeFlag::LinkFlag , Tertiary = Secondary | TRoadTypeFlag::LowerGradeFlag ,
  TertiaryLink = Tertiary | TRoadTypeFlag::LinkFlag , Minor = 0x400 , Unclassified = Minor , Residential = Minor | TRoadTypeFlag::LowerGradeFlag ,
  Byway = 0x500 , Track = Byway , AccessRamp = 0x600 , Service = 0x700 ,
  VehicularFerry = 0x800 , PassengerFerry = 0x900 , Path = 0xA00 , Pedestrian = Path ,
  Stairway = 0xB00 , CyclePath = 0xC00 , FootPath = 0xD00 , Other0 = 0xE00 ,
  Other1 = 0xE00 | TRoadTypeFlag::LowerGradeFlag , Other2 = 0xE00 | TRoadTypeFlag::LinkFlag , Other3 = 0xE00 | TRoadTypeFlag::LowerGradeFlag | TRoadTypeFlag::LinkFlag , Other4 = 0xF00 ,
  Other5 = 0xF00 | TRoadTypeFlag::LowerGradeFlag , Other6 = 0xF00 | TRoadTypeFlag::LinkFlag , Other7 = 0xF00 | TRoadTypeFlag::LowerGradeFlag | TRoadTypeFlag::LinkFlag
}
 
enum class  TStreamEncoding { Utf16 , Utf8 }
 
enum class  TStreamEndianness { Big , Little }
 
enum class  TAbbreviationType { Any , Start , End }
 
enum class  TStringMatchMethodFlag {
  Exact = 0 , Prefix = 1 , IgnoreSymbols = 2 , FoldAccents = 4 ,
  Fuzzy = 8 , FoldCase = 16 , IgnoreWhitespace = 32
}
 

Functions

int32_t Round (double aValue)
 
double Strtod (const char *aString, size_t aLength=UINT32_MAX, const char **aEndPtr=nullptr) noexcept
 
double Strtod (const uint16_t *aString, size_t aLength=UINT32_MAX, const uint16_t **aEndPtr=nullptr) noexcept
 
double Atan2 (double aY, double aX)
 
const char * Version ()
 
const char * Build ()
 
double GreatCircleDistanceInMeters (double aLong1, double aLat1, double aLong2, double aLat2)
 
template<class T >
void Reverse (T *aStart, size_t aLength)
 
template<class point_t >
double Area (const point_t *aPointArray, size_t aPointCount)
 
template<class contour_t >
double Area (const contour_t &aContour)
 
double SphericalPolygonArea (const TCoordSet &aCoordSet) noexcept
 
double SphericalPolylineLength (const TCoordSet &aCoordSet) noexcept
 
double SphericalPolygonArea (std::function< const TPointFP *()> aNextPoint)
 
double SphericalPolylineLength (std::function< const TPointFP *()> aNextPoint)
 
void GetSphericalAreaAndLength (std::function< const TPointFP *()> aNextPoint, bool aIsPolyline, double *aArea, double *aLength)
 
void GetSphericalAreaAndLength (const TCoordSet &aCoordSet, bool aIsPolyline, double *aArea, double *aLength) noexcept
 
double AzimuthInDegrees (double aLong1, double aLat1, double aLong2, double aLat2) noexcept
 
TPointFP PointAtAzimuth (const TPointFP &aPoint, double aDir, double aDistanceInMetres) noexcept
 
double GreatCircleDistanceInMetersUsingEllipsoid (double aLong1, double aLat1, double aLong2, double aLat2) noexcept
 
uint8_t ReadBigEndian (const uint8_t *aP)
 
void WriteBigEndian (uint8_t *aP, uint8_t aValue)
 
int16_t ReadBigEndian (const int16_t *aP)
 
void WriteBigEndian (int16_t *aP, int16_t aValue)
 
template<class DataType , int32_t UnknownValue = INT32_MIN>
double InterpolatedValue (const DataType *aDataStart, int32_t aWidth, int32_t aHeight, int32_t aStride, int32_t aChannels, double aX, double aY, int aChannel)
 
std::string ErrorString (uint32_t aErrorCode)
 
CString UKGridReferenceFromMapPoint (const TPointFP &aPointInMapMeters, int32_t aDigits)
 
CString UKGridReferenceFromDegrees (const TPointFP &aPointInDegrees, int32_t aDigits)
 
TRectFP MapRectFromUKGridReference (const CString &aGridReference)
 
TPointFP MapPointFromUKGridReference (const CString &aGridReference)
 
TPointFP PointInDegreesFromUKGridReference (const CString &aGridReference)
 
CString ExpandStreetName (const MString &aText)
 
int32_t IntAttribute (const char *aThreeLetterCode, int aType)
 
bool MapObjectUserDataLessThan (const std::unique_ptr< CMapObject > &aP, const std::unique_ptr< CMapObject > &aQ)
 
template<class MTraverser >
void Traverse (MTraverser &aTraverser, const TPoint *aPoint, size_t aPoints, bool aClosed)
 
template<class traverser_t , class point_t >
void Traverse (traverser_t &aTraverser, const point_t *aPoint, size_t aPoints, bool aClosed)
 
double TriangleArea (const TPoint &aA, const TPoint &aB, const TPoint &aC)
 
template<class T >
size_t SimplifyContour (T *aPointArray, size_t aPointCount, bool aClosed, double aResolutionArea)
 
template<class T >
TRect CBox (T *aPointArray, size_t aPointCount)
 
bool RoadTypeIsOneWay (uint32_t aRoadType)
 
int FileSeek (FILE *aFile, int64_t aOffset, int aOrigin)
 
int64_t FileTell (FILE *aFile)
 
const TAbbreviationInfoAbbreviationInfo (const char *aLocale)
 
CString CountryToCode (const MString &aCountry)
 
CString CodeToCountry (const MString &aCode)
 
double ClampTo32Bit (double aX)
 
CMapObjectArray Find (CMapDataBaseArray &aMapDataBaseArray, const TFindParam &aFindParam, const COutline &aClip, const COutline &aLocation)
 
CMapObjectArray Find (CMapDataBaseSet &aMapDataBaseSet, const TFindParam &aFindParam, const COutline &aClip, const COutline &aLocation)
 
void FindInLayers (CMapDataBaseSet &aMapDataBaseSet, const MString &aLayers, const TRect &aRect, FindHandler aFindHandler, const MString *aCondition)
 
void FindHelper (CMapDataBaseSet &aMapDataBaseSet, FindHandler aFindHandler, const TFindParam &aFindParam, const TRect &aClipRect, TTimePoint aTimeOut)
 
void FindNearby (CMapDataBaseSet &aMapDataBaseSet, FindHandler aFindHandler, CMapObjectArray &aMapObjectArray, const TFindParam &aFindParam, const TRect &aClipRect, const COutline &aLocation, TTimePoint aTimeOut)
 
void Find (CMapDataBaseSet &aMapDataBaseSet, const TRect &aRect, FindHandler aFindHandler, const MString *aCondition)
 
void FindText (CMapDataBaseSet &aMapDataBaseSet, const MString &aText, FindHandler aFindHandler, TStringMatchMethod aStringMatchMethod, const MString &aLayers, const std::vector< CString > &aAttribs, const TRect *aClip, TTimePoint aTimeOut)
 
void Sort (CMapObjectArray &aObjectArray, const MString *aText, size_t aStartIndex, const COutline *aLocation, double aMapUnitSize)
 
uint32_t MergeableIntAttribute (const CMapObject &aObject)
 
void Merge (CMapObjectArray &aObjectArray, size_t aStartIndex)
 
template<class point_t >
COutline OutlineInMapCoords (CFramework &aFramework, const CGeneralGeometry< point_t > &aGeometry)
 
void WriteTrackAsXmlHelper (const CTrackGeometry &aTrack, MOutputStream &aOutput)
 
CContour Ellipse (const TPoint &aCenter, double aRX, double aRY, double aEllipseAngle)
 
CContour Circle (const TPoint &aCenter, double aRadius)
 
void AppendEllipticalArc (CContour &aContour, const TPoint &aCenter, double aRX, double aRY, double aEllipseAngle, double aStartAngle, double aEndAngle, TEllipseAngleType aAngleType, bool aAppendStart)
 
void AppendEllipticalArc (CContour &aContour, const TPoint &aStart, double aRX, double aRY, double aEllipseAngle, bool aLargeArc, bool aSweep, const TPoint &aEnd, bool aAppendStart)
 

Variables

constexpr int32_t KMaxLabelLength = 1024
 
constexpr int32_t KEquatorialRadiusInMetres = 6378137
 
constexpr double KWGS84Flattening = 1.0 / 298.257223563
 
constexpr double KRadiansToMetres = KEquatorialRadiusInMetres
 
constexpr double KPiDouble = 3.1415926535897932384626433832795
 
constexpr float KPiFloat = 3.1415926535897932384626433832795f
 
constexpr double KRadiansToDegreesDouble = 180.0 / KPiDouble
 
constexpr double KDegreesToRadiansDouble = KPiDouble / 180.0
 
constexpr double KDegreesToMetres = KRadiansToMetres * KDegreesToRadiansDouble
 
constexpr double KScaledDegreesToMetres = KDegreesToMetres / 2097152.0
 
constexpr int32_t KDefaultTextIndexLevels = 1
 
constexpr double KMinScaleDenominator = 100
 
constexpr double KMaxScaleDenominator = 1000000000
 
const uint32_t KBlack = 0xFF000000
 
const uint32_t KDarkGrey = 0xFF555555
 
const uint32_t KDarkGray = 0xFF555555
 
const uint32_t KDarkRed = 0xFF000080
 
const uint32_t KDarkGreen = 0xFF008000
 
const uint32_t KDarkYellow = 0xFF008080
 
const uint32_t KDarkBlue = 0xFF800000
 
const uint32_t KDarkMagenta = 0xFF800080
 
const uint32_t KDarkCyan = 0xFF808000
 
const uint32_t KRed = 0xFF0000FF
 
const uint32_t KGreen = 0xFF00FF00
 
const uint32_t KYellow = 0xFF00FFFF
 
const uint32_t KBlue = 0xFFFF0000
 
const uint32_t KMagenta = 0xFFFF00FF
 
const uint32_t KCyan = 0xFFFFFF00
 
const uint32_t KGrey = 0xFFAAAAAA
 
const uint32_t KGray = KGrey
 
const uint32_t KWhite = 0xFFFFFFFF
 
const uint32_t KTransparentBlack = 0x00000000
 
constexpr int32_t KEpsgWebMercator = 3857
 
constexpr int32_t KEpsgPlateCarree = 4326
 
constexpr TResult KErrorNone = 0
 
constexpr TResult KErrorGeneral = 1
 
constexpr TResult KErrorNoMemory = 2
 
constexpr TResult KErrorEndOfData = 3
 
constexpr TResult KErrorTextUnmodifiable = 4
 
constexpr TResult KErrorTextTruncated = 5
 
constexpr TResult KErrorNotFound = 6
 
constexpr TResult KErrorUnimplemented = 7
 
constexpr TResult KErrorInvalidOutline = 8
 
constexpr TResult KErrorIo = 9
 
constexpr TResult KErrorCorrupt = 10
 
constexpr TResult KErrorUnknownDataFormat = 11
 
constexpr TResult KErrorNoInverse = 12
 
constexpr TResult KErrorProjectionOverflow = 13
 
constexpr TResult KErrorCancel = 14
 
constexpr TResult KErrorInvalidArgument = 15
 
constexpr TResult KErrorUnknownVersion = 16
 
constexpr TResult KErrorOverflow = 17
 
constexpr TResult KErrorParallelLines = 19
 
constexpr TResult KErrorNoPalette = 22
 
constexpr TResult KErrorDuplicate = 23
 
constexpr TResult KErrorNoProjection = 24
 
constexpr TResult KErrorPaletteFull = 25
 
constexpr TResult KErrorInvalidDashArray = 26
 
constexpr TResult KErrorNoRoute = 28
 
constexpr TResult KErrorZoomLimitReached = 29
 
constexpr TResult KErrorAlreadyProjected = 30
 
constexpr TResult KErrorConditionsTooDeeplyNested = 31
 
constexpr TResult KErrorNullFont = 32
 
constexpr TResult KErrorInternetIo = 33
 
constexpr TResult KErrorDivideByZero = 34
 
constexpr TResult KErrorTransformFailed = 35
 
constexpr TResult KErrorPngRead = 36
 
constexpr TResult KErrorJpgRead = 37
 
constexpr TResult KErrorNoIntersection = 38
 
constexpr TResult KErrorInterrupt = 39
 
constexpr TResult KErrorMapDataBaseFormatMismatch = 40
 
constexpr TResult KErrorEncryptionKeyTooShort = 41
 
constexpr TResult KErrorNoEncryptionKey = 42
 
constexpr TResult KErrorEmergencyMessage = 43
 
constexpr TResult KErrorAlertMessage = 44
 
constexpr TResult KErrorCriticalMessage = 45
 
constexpr TResult KErrorErrorMessage = 46
 
constexpr TResult KErrorWarningMessage = 47
 
constexpr TResult KErrorNoticeMessage = 48
 
constexpr TResult KErrorInfoMessage = 49
 
constexpr TResult KErrorDebugMessage = 50
 
constexpr TResult KErrorNotNavigating = 51
 
constexpr TResult KErrorNoFramework = 52
 
constexpr TResult KErrorFrameworkAlreadyExists = 53
 
constexpr TResult KErrorUntransliterable = 54
 
constexpr TResult KErrorPngWrite = 55
 
constexpr TResult KErrorReadOnlyMapDataBase = 56
 
constexpr TResult KErrorProj4 = 57
 
constexpr TResult KErrorUnlicensed = 58
 
constexpr TResult KErrorNoRoadsNearStartOfRoute = 59
 
constexpr TResult KErrorNoRoadsNearEndOfRoute = 60
 
constexpr TResult KErrorNoRouteConnectivity = 61
 
constexpr TResult KErrorXmlFeatureNotSupported = 62
 
constexpr TResult KErrorMapNotFound = 63
 
constexpr TResult KErrorFontNotFound = 64
 
constexpr TResult KErrorStyleSheetNotFound = 65
 
constexpr int32_t KStandardErrorCodeCount = 66
 
constexpr TResult KErrorXmlRangeStart = 0x10000000
 
constexpr TResult KErrorXmlRangeEnd = 0x2AFFFFFF
 
constexpr uint32_t KErrorSQLite = 0x30000000
 
constexpr uint32_t KFollowFlagLocation = 1
 
constexpr uint32_t KFollowFlagHeading = 2
 
constexpr uint32_t KFollowFlagZoom = 4
 
const uint32_t KLatinScript = 1
 
const uint32_t KGreekScript = 2
 
const uint32_t KCyrillicScript = 4
 
const uint32_t KArmenianScript = 8
 
const uint32_t KHebrewScript = 0x10
 
const uint32_t KArabicScript = 0x20
 
const uint32_t KDevanagariScript = 0x40
 
const uint32_t KBengaliScript = 0x80
 
const uint32_t KGurmukhiScript = 0x100
 
const uint32_t KGujaratiScript = 0x200
 
const uint32_t KOriyaScript = 0x400
 
const uint32_t KTamilScript = 0x800
 
const uint32_t KTeluguScript = 0x1000
 
const uint32_t KKannadaScript = 0x2000
 
const uint32_t KMalayalamScript = 0x4000
 
const uint32_t KSinhalaScript = 0x8000
 
const uint32_t KThaiScript = 0x10000
 
const uint32_t KLaoScript = 0x20000
 
const uint32_t KTibetanScript = 0x40000
 
const uint32_t KMyanmarScript = 0x80000
 
const uint32_t KGeorgianScript = 0x100000
 
const uint32_t KHangulScript = 0x200000
 
const uint32_t KEthiopicScript = 0x400000
 
const uint32_t KKhmerScript = 0x800000
 
const uint32_t KMongolianScript = 0x1000000
 
const uint32_t KHiraganaScript = 0x2000000
 
const uint32_t KKatakanaScript = 0x4000000
 
const uint32_t KBopomofoScript = 0x8000000
 
const uint32_t KHanScript = 0x10000000
 
const uint32_t KReservedScript = 0x20000000
 
const uint32_t KSymbolScript = 0x40000000
 
const uint32_t KOtherScript = 0x80000000
 
const uint32_t KBoldStyle = 1
 
const uint32_t KItalicStyle = 2
 
const uint32_t KSerifStyle = 4
 
const uint32_t KCursiveStyle = 8
 
const uint32_t KFantasyStyle = 16
 
const uint32_t KMonospaceStyle = 32
 
constexpr uint32_t KArcRoadTypeMask = 0x1F
 
constexpr uint32_t KArcGradientMask = 0xE0
 
constexpr uint32_t KArcGradientDirectionFlag = 0x80
 
constexpr uint32_t KArcGradientShift = 5
 
constexpr uint32_t KArcRoadDirectionMask = 0x300
 
constexpr uint32_t KArcDriveOnRightRoadDirection = 0
 
constexpr uint32_t KArcDriveOnLeftRoadDirection = 0x300
 
constexpr uint32_t KArcOneWayForwardRoadDirection = 0x100
 
constexpr uint32_t KArcOneWayBackwardRoadDirection = 0x200
 
constexpr uint32_t KArcRoundaboutFlag = 0x400
 
constexpr uint32_t KArcTollFlag = 0x800
 
constexpr uint32_t KArcSpeedLimitMask = 0xFF000
 
constexpr uint32_t KArcSpeedLimitShift = 12
 
constexpr uint32_t KArcAccessMask = 0x7FF00000
 
constexpr uint32_t KArcWrongWayFlag = 0x00100000
 
constexpr uint32_t KArcBicycleAccessFlag = 0x00200000
 
constexpr uint32_t KArcMotorCycleAccessFlag = 0x00400000
 
constexpr uint32_t KArcCarAccessFlag = 0x00800000
 
constexpr uint32_t KArcHighOccupancyAccessFlag = 0x01000000
 
constexpr uint32_t KArcLightGoodsAccessFlag = 0x02000000
 
constexpr uint32_t KArcHeavyGoodsAccessFlag = 0x04000000
 
constexpr uint32_t KArcBusAccessFlag = 0x08000000
 
constexpr uint32_t KArcTaxiAccessFlag = 0x10000000
 
constexpr uint32_t KArcPedestrianAccessFlag = 0x20000000
 
constexpr uint32_t KArcEmergencyAccessFlag = 0x40000000
 
constexpr uint32_t KArcOtherAccessFlag = 0x80000000
 
constexpr uint32_t KArcBicycleAccessOnly = KArcAccessMask & ~(KArcWrongWayFlag | KArcBicycleAccessFlag)
 
constexpr uint32_t KArcAllMotorVehicles = KArcAccessMask & ~(KArcWrongWayFlag | KArcPedestrianAccessFlag | KArcBicycleAccessFlag)
 
constexpr uint32_t KArcBicycleAndPedestrianAccessOnly = KArcAllMotorVehicles
 
constexpr uint32_t KArcNoVehicularAccess = KArcAccessMask & ~(KArcWrongWayFlag | KArcPedestrianAccessFlag)
 
constexpr uint32_t KArcAllVehicles = KArcNoVehicularAccess
 
constexpr uint32_t KArcMotorway = 0
 
constexpr uint32_t KArcMotorwayLink = 1
 
constexpr uint32_t KArcTrunkRoad = 2
 
constexpr uint32_t KArcTrunkRoadLink = 3
 
constexpr uint32_t KArcPrimaryRoad = 4
 
constexpr uint32_t KArcPrimaryRoadLink = 5
 
constexpr uint32_t KArcSecondaryRoad = 6
 
constexpr uint32_t KArcSecondaryRoadLink = 7
 
constexpr uint32_t KArcTertiaryRoad = 8
 
constexpr uint32_t KArcUnclassifiedRoad = 9
 
constexpr uint32_t KArcResidentialRoad = 10
 
constexpr uint32_t KArcTrack = 11
 
constexpr uint32_t KArcServiceRoad = 12
 
constexpr uint32_t KArcPedestrianRoad = 13
 
constexpr uint32_t KArcVehicularFerry = 14
 
constexpr uint32_t KArcPassengerFerry = 15
 
constexpr uint32_t KArcLivingStreet = 16
 
constexpr uint32_t KArcCycleway = 17
 
constexpr uint32_t KArcPath = 18
 
constexpr uint32_t KArcFootway = 19
 
constexpr uint32_t KArcBridleway = 20
 
constexpr uint32_t KArcSteps = 21
 
constexpr uint32_t KArcUnknownRoadType = 22
 
constexpr uint32_t KArcUnpavedRoad = 23
 
constexpr uint32_t KArcOtherRoadType0 = 24
 
constexpr uint32_t KArcOtherRoadType1 = 25
 
constexpr uint32_t KArcOtherRoadType2 = 26
 
constexpr uint32_t KArcOtherRoadType3 = 27
 
constexpr uint32_t KArcOtherRoadType4 = 28
 
constexpr uint32_t KArcOtherRoadType5 = 29
 
constexpr uint32_t KArcOtherRoadType6 = 30
 
constexpr uint32_t KArcOtherRoadType7 = 31
 
constexpr uint32_t KArcRoadTypeCount = 32
 
constexpr uint32_t KArcGradientUp0Index = 0
 
constexpr uint32_t KArcGradientUp1Index = 1
 
constexpr uint32_t KArcGradientUp2Index = 2
 
constexpr uint32_t KArcGradientUp3Index = 3
 
constexpr uint32_t KArcGradientDown0Index = 4
 
constexpr uint32_t KArcGradientDown1Index = 5
 
constexpr uint32_t KArcGradientDown2Index = 6
 
constexpr uint32_t KArcGradientDown3Index = 7
 
constexpr uint32_t KArcGradientCount = 8
 
const char *const KArcGradientName [KArcGradientCount]
 
constexpr int KStandardTitleCase = 0
 
constexpr int KLowerTitleCase = 1
 
constexpr int KUpperTitleCase = 2
 
const double CT_DBL_MAX = 1.7976931348623158e+308
 

Detailed Description

A namespace for the CartoType library.

Typedef Documentation

◆ CAbbreviationDictionary

A type for a class mapping CString objects to abbreviations.

◆ CMapObjectArray

using CartoType::CMapObjectArray = typedef std::vector<std::unique_ptr<CMapObject> >

A type for arrays of map objects returned by search functions.

◆ CMapObjectGroupArray

using CartoType::CMapObjectGroupArray = typedef std::vector<CMapObjectGroup>

A type for arrays of map object groups returned by search functions.

◆ CStreetAddressSearchState

using CartoType::CStreetAddressSearchState = typedef std::unique_ptr<CStreetAddressSearchStateImplementation>

The state of a street address search. It is used to iterate through all the objects found satisfying the search parameters. Each iteration returns all the streets in a certain combination of country, admin area and locality.

◆ CStringDictionary

using CartoType::CStringDictionary = typedef std::map<CString, CString>

A type for a class mapping CString objects to other CString objects.

◆ CStringTypeDictionary

using CartoType::CStringTypeDictionary = typedef std::map<CString,int>

A type for a class mapping CString objects to integers.

◆ CStyleSheetDataArray

using CartoType::CStyleSheetDataArray = typedef std::vector<CStyleSheetData>

A set of style sheet data that may consist of more than one style sheet.

◆ CTrackGeometry

A type for a sequence of track points.

◆ FindAsyncCallBack

using CartoType::FindAsyncCallBack = typedef std::function<void(std::unique_ptr<CMapObjectArray> aMapObjectArray)>

A type for functions called by the asynchronous Find function.

◆ FindAsyncGroupCallBack

using CartoType::FindAsyncGroupCallBack = typedef std::function<void(std::unique_ptr<CMapObjectGroupArray> aMapObjectGroupArray)>

A type for functions called by the asynchronous Find function for map object group arrays.

◆ FindHandler

using CartoType::FindHandler = typedef std::function<bool(std::unique_ptr<CMapObject>)>

A type for internal functions to handle objects returned by search functions.

◆ RouterAsyncCallBack

using CartoType::RouterAsyncCallBack = typedef std::function<void(TResult aError,std::unique_ptr<CRoute> aRoute)>

A type for functions called by the asynchronous routing function.

◆ TPoint3FP

using CartoType::TPoint3FP = typedef TPoint3<double>

A double-precision floating-point 3D point class.

◆ TPointFP

using CartoType::TPointFP = typedef TPoint2<double>

A double-precision floating-point 2D point class.

Enumeration Type Documentation

◆ TAbbreviationType

enum class CartoType::TAbbreviationType
strong

Types determining where in a phrase an abbreviation can be used.

Enumerator
Any 

The word can be abbreviated at any position in a phrase.

Start 

The word can be abbreviated at the start of a phrase only.

End 

The word can be abbreviated at the end of a phrase only.

◆ TAddressPart

enum class CartoType::TAddressPart
strong

Address part codes used when searching for address parts separately.

Enumerator
Building 

Building names or numbers.

Feature 

Features or points of interest.

Street 

Streets or roads.

SubLocality 

Suburbs and neighborhoods.

Locality 

Cities, towns and villages.

Island 

Islands.

SubAdminArea 

Lower-level administrative areas like counties.

AdminArea 

Higher-level administrative areas like states.

Country 

Countries.

PostCode 

Postal codes.

◆ TAlign

enum class CartoType::TAlign
strong

Alignments used for multi-line text.

Enumerator
Center 

Center the text.

Standard 

Align to the left for left-to-right text, to the right for right-to-left text.

Reverse 

Align to the right for left-to-right text, to the left for right-to-left text.

Left 

Align to the left and leave space on the right.

Right 

Align to the right and leave space on the left.

◆ TBidiOverride

enum class CartoType::TBidiOverride
strong

The override status during bidirectional reordering.

◆ TBidiParDir

enum class CartoType::TBidiParDir
strong

The paragraph direction used during bidirectional reordering.

Enumerator
LeftToRightPreferred 

Set the paragraph direction from the first strongly directional character. If there are none, use left-to-right.

RightToLeftPreferred 

Set the paragraph direction from the first strongly directional character. If there are none, use right-to-left.

LeftToRightForced 

Set the paragraph direction to left-to-right whatever its content.

RightToLeftForced 

Set the paragraph direction to right-to-left whatever its content.

◆ TBidiType

enum class CartoType::TBidiType
strong

The bidirectional type of a character as used in the Unicode Bidirectional Algorithm.

◆ TBitmapType

enum class CartoType::TBitmapType
strong

An enumerated type for supported bitmap types. The number of bits per pixel is held in the low 6 bits.

Enumerator
KBitsPerPixelMask 

A mask for the bits in TBitmapType that represent the number of bits per pixel.

KColored 

The bit in TBitmapType that indicates whether the type is inherently colored, which means that its color data is held in the pixel value.

KPalette 

The bit in TBitmapType indicating whether the bitmap has a palette. If this bit is set, EColored should not also be set.

A1 

One bit per pixel: 1 = foreground color, 0 = background color.

A8 

Eight bits per pixel: 255 = foreground color, 0 = background color.

A16 

16 bits per pixel, monochrome.

RGB16 

16 bits per pixel, accessed as 16-bit words, not as bytes; top 5 bits = red, middle 6 bits = green, low 5 bits = blue.

RGB24 

24 bits per pixel: first byte blue, second byte green, third byte red.

RGBA32 

32 bits per pixel: first byte alpha, second byte blue, second byte green, third byte red. The red, green and blue values are premultiplied by the alpha value.

P8 

Eight bits per pixel with a 256-entry palette.

◆ TCharCategory

enum class CartoType::TCharCategory
strong

The general category of a character as defined in the Unicode Standard (http://www.unicode.org/versions/Unicode5.0.0/ch04.pdf). Each constant is a single bit so that masks can be made by combining them.

Enumerator
Lu 

The Unicode general character property Letter, uppercase.

Ll 

The Unicode general character property Letter, lowercase.

Lt 

The Unicode general character property Letter, titlecase.

Lm 

The Unicode general character property Letter, modifier.

Lo 

The Unicode general character property Letter, other.

Mn 

The Unicode general character property Mark, nonspacing.

Mc 

The Unicode general character property Mark, spacing combining.

Me 

The Unicode general character property Mark, enclosing.

Nd 

The Unicode general character property Number, decimal digit.

Nl 

The Unicode general character property Number, letter.

No 

The Unicode general character property Number, other.

Pc 

The Unicode general character property Punctuation, connector.

Pd 

The Unicode general character property Punctuation, dash.

Ps 

The Unicode general character property Punctuation, open.

Pe 

The Unicode general character property Punctuation, close.

Pi 

The Unicode general character property Punctuation, initial quote (may behave like Ps or Pe depending on usage).

Pf 

The Unicode general character property Punctuation, final quote (may behave like Ps or Pe depending on usage).

Po 

The Unicode general character property Punctuation, other.

Sm 

The Unicode general character property Symbol, math.

Sc 

The Unicode general character property Symbol, currency.

Sk 

The Unicode general character property Symbol, modifier.

So 

The Unicode general character property Symbol, other.

Zs 

The Unicode general character property Separator, space.

Zl 

The Unicode general character property Separator, line.

Zp 

The Unicode general character property Separator, paragraph.

Cc 

The Unicode general character property Other, control.

Cf 

The Unicode general character property Other, format.

Cs 

The Unicode general character property Other, surrogate.

Co 

The Unicode general character property Other, private use.

Cn 

The Unicode general character property Other, not assigned (including noncharacters).

◆ TClipOperation

enum class CartoType::TClipOperation
strong

Types of clipping done by the general clip function COutline MPath::Clip(TClipOperation aClipOperation,const MPath& aClip) const.

Enumerator
Intersection 

Returns the intersection of two paths; commutative.

Union 

Returns the union of two paths; commutative.

Difference 

Returns the difference of two paths; non-commutative.

Xor 

Returns the exclusive-or of the two paths; that is, any regions which are in neither path; commutative.

◆ TClipType

enum class CartoType::TClipType
strong

A type to label different relationships a clip rectangle has with a path, to decide what sort of clipping is needed.

Enumerator
Inside 

The path is completely inside the clip rectangle.

MayIntersectAndHasNoCurves 

The path is not completely inside the clip rectangle, and has no curves.

MayIntersectAndHasCurves 

The path is not completely inside the clip rectangle, and has curves.

◆ TCoordType

enum class CartoType::TCoordType
strong

Coordinate types.

Enumerator
Degree 

Longitude (x) and latitude (y) in degrees.

Display 

Pixels on the display: x increases to the right and y increases downwards.

Screen 

A synonym for Display: pixels on the display: x increases to the right and y increases downwards..

Map 

Map coordinates: projected meters, 32nds of meters or 64ths of meters, depending on the map.

MapMeter 

Map meters: projected meters, not correcting for distortion introduced by the projection.

◆ TDrawResult

enum class CartoType::TDrawResult
strong

Result codes for drawing operations.

◆ TEllipseAngleType

enum class CartoType::TEllipseAngleType
strong

Flags used for appending ellipses to determine the angle between start and end point or start and end angle.

Enumerator
Shortest 

Select the shortest arc between start and end.

Longest 

Select the longest arc between start and end.

Positive 

Select the arc from start to end in positive direction.

Negative 

Select the arc from start to end in negative direction.

◆ TFileType

enum class CartoType::TFileType
strong

File types of interest to CartoType.

Enumerator
PNG 

PNG (Portable Network Graphics) image files.

JPEG 

JPEG (Joint Photographic Expert Group) image files.

TIFF 

TIFF (Tagged Image File Format) image files.

CTM1 

CTM1 (CartoType Map Data Type 1) map data files.

CTMS 

CTMS (CartoType Map Data, Serialized) map data files.

KML 

KML (Keyhole Markup Language) map data files.

CTSQL 

CTSQL (CartoType SQLite format) map data files.

CTROUTE 

CTROUTE (CartoType XML route) files.

GPX 

GPX (GPS Exchange) files.

None 

Unknown or unspecified file type.

◆ TFollowMode

enum class CartoType::TFollowMode
strong

Flags controlling the way the map follows the user location and heading and automatically zooms.

Enumerator
None 

The map does not follow the user's location or heading.

Location 

The map is centred on the user's location.

LocationHeading 

The map is centred on the user's location and rotated to the user's heading.

LocationZoom 

The map is centred on the user's location and zoomed to a suitable level for the user's speed.

LocationHeadingZoom 

The map is centred on the user's location, rotated to the user's heading, and zoomed to a suitable level for the user's speed.

◆ TGeoCodeType

enum class CartoType::TGeoCodeType
strong

A type used in addresses obtained by reverse geocoding. It gives a coarse notion of what an object is. Codes are ordered roughly from small to large.

Enumerator
None 

No geocode type.

Position 

A position not corresponding to something on the map.

Address 

An address.

Building 

A building.

Farm 

A farm.

Footpath 

A footpath.

Cycleway 

A cycleway (cycle path).

SkiRoute 

A ski route (piste or ski trail).

WalkingRoute 

A walking route.

FerryRoute 

A ferry route.

Railway 

A railway track.

PedestrianRoad 

A pedestrian road.

Track 

A track.

ServiceRoad 

A service or access road.

ResidentialRoad 

A residential road.

UnclassifiedRoad 

An unclassified road.

TertiaryRoad 

A tertiary road.

SecondaryRoad 

A secondary road.

PrimaryRoad 

A primary road.

TrunkRoad 

A trunk road.

Motorway 

A motorway (freeway).

HikingRoute 

A hiking route.

CyclingRoute 

A cycling route.

LandFeature 

A land feature: a peak, hill, cliff, quarry, etc.

WaterFeature 

A water feature: a lake, river, stream, spring, etc.

Locality 

A named locality that is not a populated place, or smaller than other populated place categories.

Hamlet 

A hamlet (very small populated place).

PostCode 

The location or area of a postal code.

AdminArea10 

A level 10 administrative area as defined by OpenStreetMap admin_level: e.g., a parish or suburb.

AdminArea9 

A level 9 administrative area as defined by OpenStreetMap admin_level: e.g., a village.

Neighborhood 

A neighborhood: a small distinct part of an urban area.

Village 

A village: an urban area with a population usually of less than a thousand.

Suburb 

A suburb: a large part of an urban area.

Island 

An island.

AdminArea8 

A level 8 administrative area as defined by OpenStreetMap admin_level: e.g., a French commune.

Town 

A town: an urban area with a population less than 100,000, but larger than a village.

AdminArea7 

A level 7 administrative area as defined by OpenStreetMap admin_level: e.g., a U.S. civil township.

City 

A city: an urban area with a population of 100,000 or more.

AdminArea6 

A level 6 administrative area as defined by OpenStreetMap admin_level: e.g., a U.K. or U.S. county.

AdminArea5 

A level 5 administrative area as defined by OpenStreetMap admin_level: e.g., a region of England.

AdminArea4 

A level 4 administrative area as defined by OpenStreetMap admin_level: e.g., a U.K. constituent country or a U.S. state.

AdminArea3 

A level 3 administrative area as defined by OpenStreetMap admin_level: e.g., a federal district of Russia or a Swedish landsdel.

AdminArea2 

A level 2 administrative area as defined by OpenStreetMap admin_level: a country.

Country 

A country, including areas not defined as such by OpenStreetMap.

AdminArea1 

A level 1 administrative area as defined by OpenStreetMap admin_level: e.g., the European Union.

Continent 

A continent.

◆ TIntersectionPlace

enum class CartoType::TIntersectionPlace
strong

The intersection place of a line segment on another.

Enumerator
None 

Lines are parallel or coincident.

Before 

The intersection is before the start of the segment.

On 

The intersection is on the segment.

After 

The intersection is after the segment.

◆ TLetterCase

enum class CartoType::TLetterCase
strong

The case of letters and strings in Latin, Greek, Cyrillic and other alphabetic scripts.

Enumerator
None 

A code used when the letter case is to be left as it is, or is irrelevant.

Lower 

The case of the letters 'a', 'b', c', etc.

Upper 

The case of the letters 'A', 'B', 'C, etc.

Title 

The case of letters like U+01C8 'Lj' and a few others; also indicates that the first letter of each word should be changed to titlecase.

◆ TLineCap

enum class CartoType::TLineCap
strong

Methods of adding caps to the ends of lines created as envelopes of open paths.

Enumerator
Butt 

End a line with a straight line intersecting the end point and normal to the line direction.

Round 

End a line with a half-circle. The center of the circle is the end point of the line.

Square 

End a line with a half-square. The center of the square is the end point of the line.

◆ TLineJoin

enum class CartoType::TLineJoin
strong

Methods of joining segments of lines created as path envelopes.

Enumerator
Round 

Use arcs of circles to join line segments.

Bevel 

Extend line borders till they intersect.

Miter 

The same as Bevel, but if long spikes are produced they are cut off.

◆ TLocationRefType

enum class CartoType::TLocationRefType
strong

The type of a location reference used for traffic information.

Enumerator
Line 

A line in the route network.

GeoCoordinate 

A point on the earth's surface.

PointAlongLine 

A point on a line in the route network.

PointWithAccessPoint 

A point on the route network providing access to a nearby POI: the first point is the point on the line, the second is the POI.

Circle 

A circle defined as a point and a radius.

Rectangle 

A rectangle aligned to the grid of latitude and longitude: it is defined using two points at opposite corners.

Polygon 

A polygon defined using a set of points.

ClosedLine 

A closed line in the route network.

◆ TMapObjectType

enum class CartoType::TMapObjectType
strong

An enumerated type for map objects.

Enumerator
Point 

A point in two-dimensional space.

Line 

A line in two-dimensional space, consisting of one or more open contours.

Polygon 

A polygon in two-dimensional space, consisting of one or more closed contours.

Array 

Information arranged as an array of values, such as an image or height data.

Count 

The total number of map object types. This is not an actual type.

None 

A value to use where a null type is needed.

◆ TNavigationState

enum class CartoType::TNavigationState
strong

States of the navigation system.

Enumerator
None 

No route has been created, or navigation is disabled.

NoPosition 

There is a route, and navigation is enabled, but no position has been supplied.

Turn 

The current position is on the route and turn information is available.

OffRoute 

The current position is off the route.

ReRouteNeeded 

Re-routing is needed. This state is used only when automatic re-routing is turned off, for instance when using a slower routing algorithm.

ReRouteDone 

A new route has been calculated after a period off route.

TurnRound 

The latest position is on the route but a U-turn is needed.

Arrival 

The latest position is on the route and very close to the destination.

◆ TNoticePosition

enum class CartoType::TNoticePosition
strong

Positions for notices like the legend or scale bar. Use TExtendedNoticePosition for greater control.

Enumerator
TopLeft 

The top left corner of the display.

TopRight 

The top right corner of the display.

BottomLeft 

The bottom left corner of the display.

BottomRight 

The bottom right corner of the display.

Top 

The center of the top edge of the display.

Right 

The center of the right side of the display.

Left 

The center of the left side of the display.

Bottom 

The center of the bottom edge of the display.

Center 

The center of the display.

◆ TPathIntersectionType

The ways two paths can intersect.

Enumerator
Unknown 

The intersection type is unknown.

Separate 

The paths do not intersect.

Contains 

The first path contains the second.

Contained 

The second path contains the first.

◆ TPointFormat

enum class CartoType::TPointFormat
strong

The format used for points in CTM1 data. These numbers must fit into 8 bits for the moment because of the way they are stored in the CTM1 file. The values are discontinuous because several obsolete values have been discarded.

Enumerator
Unknown 

An arbitrary or unknown point format.

Meter 

Units are projected map meters.

ScaledDegree 

Units are degrees as 11.21 fixed-point numbers. That is, there are 2^21 (2097152) units to a degree. This format is used only by the makemap tool, for representing unprojected map data.

Meter32nds 

Units are 32nds of projected map meters. This is the default format for CTM1 data.

◆ TPointOfInterestType

Types of place to search for in the 'find nearby' parameters.

Enumerator
None 

No point of interest.

Airport 

An airport.

Bar 

A bar, pub or other drinking establishment.

Beach 

A beach.

BusStation 

A bus station.

Cafe 

A cafe or other place serving snacks and soft drinks.

Camping 

A camp site.

FastFood 

A fast food restaurant, for example a place serving beefburgers.

Fuel 

A fuel station for motor vehicles.

GolfCourse 

A golf course.

Hospital 

A hospital.

Hotel 

A hotel or motel.

Pharmacy 

A pharmacy or chemist's shop.

Police 

A police station.

Restaurant 

A restaurant or other place serving hot meals.

Shops 

An area of retail shops.

SportsCenter 

A public sports center.

Supermarket 

A supermarket or other shop selling groceries.

SwimmingPool 

A public swimming pool.

Tourism 

A tourist attraction.

TrainStation 

A train station.

◆ TPointType

enum class CartoType::TPointType
strong

Types used by TOutlinePoint.

Enumerator
OnCurve 

A point on the curve.

Quadratic 

A control point for a quadratic (conic) Bezier spline curve.

Cubic 

A control point for a cubic Bezier spline curve.

◆ TRoadOrientation

enum class CartoType::TRoadOrientation
strong

The orientation of a path along a road: used in traffic information.

◆ TRoadType

enum class CartoType::TRoadType
strong

Road types. Note that items of type TRoadType are often combined with other TRoadTypeFlag values. Therefore it is often necessary to mask a TRoadType with TRoadTypeFlags::RoadTypeMask to obtain one of the enumerated TRoadType values.

Enumerator
UnknownMajor 

Roads of unknown type.

PrimaryLimitedAccess 

Primary road with limited access (motorway, freeway, etc.).

Motorway 

Primary road with limited access (motorway, freeway, etc.).

MotorwayLink 

Access ramp or link to primary road with limited access (motorway, freeway, etc.).

PrimaryUnlimitedAccess 

Primary road: UK trunk road.

Trunk 

Primary road: UK trunk road.

TrunkLink 

Access ramp or link to trunk road.

Primary 

Primary road: UK 'A' road.

PrimaryLink 

Access ramp or link to primary road.

Secondary 

Secondary road: UK 'B' road.

SecondaryLink 

Access ramp or link to secondary road.

Tertiary 

Tertiary road: one level above minor and residential roads.

TertiaryLink 

Access ramp or link to tertiary road.

Minor 

Local road or town or city street.

Unclassified 

Local road or town or city street.

Residential 

Narrow road or street with residential housing.

Byway 

Byway: road or track open to motor vehicles.

Track 

Byway: road or track open to motor vehicles.

AccessRamp 

Access ramp to limited access road.

Service 

Service road or access road.

VehicularFerry 

Vehicular Ferry route.

PassengerFerry 

Passenger-only Ferry route.

Path 

Path or walkway for pedestrians.

Pedestrian 

Path or walkway for pedestrians.

Stairway 

Stairway or escalator for pedestrians.

CyclePath 

Cycle path.

FootPath 

Footpath.

Other0 

User-defined road type 0.

Other1 

User-defined road type 1.

Other2 

User-defined road type 2.

Other3 

User-defined road type 3.

Other4 

User-defined road type 4.

Other5 

User-defined road type 5.

Other6 

User-defined road type 6.

Other7 

User-defined road type 7.

◆ TRoundaboutState

enum class CartoType::TRoundaboutState
strong

Roundabout states; turns involving roundabouts are marked as such so that exit numbers can be counted

Enumerator
None 

This junction does not involve a roundabout.

Enter 

This junction enters a roundabout.

Continue 

This junction continues around a roundabout.

Exit 

This junction exits a roundabout.

◆ TRouteAccess

enum class CartoType::TRouteAccess
strong

The accessibility of a point for routing purposes. The CFramework::RouteAccess function, if implemented for the current router, returns a value of this type.

A point is defined as accessible if it is connected to at least 1000 other route segments; thus accessibility is not defined correctly for very small maps.

Enumerator
Unknown 

The accessibility of the point is unknown.

Accessible 

The point is accessible for outward routing.

Isolated 

Routes cannot leave the point. The usual cause is an error in the map data like a one-way road that is a dead end.

NoRoad 

There are no routable roads or tracks near the point.

◆ TRouteProfileType

enum class CartoType::TRouteProfileType
strong

Constants used to select frequently-used route profiles.

Enumerator
Drive 

A profile type for driving in a private car (synonym of Car).

Car 

A profile type for driving in a private car (synonym of Drive).

Walk 

A profile type for walking.

Cycle 

A profile type for cycling (synonym of Bicycle).

Bicycle 

A profile type for cycling (synonym of Cycle).

Hike 

A profile type for walking, preferring off-road paths.

◆ TRouterType

enum class CartoType::TRouterType
strong

Types of router; used when selecting a router type.

Enumerator
Default 

This router type causes the default router to be selected: the one for which serialized data is available in the map file, or, failing that, StandardAStar.

StandardAStar 

The A* router, which gives fast performance but takes a lot of memory and cannot create a route going twice through the same junction.

TurnExpandedAStar 

A version of the A* router with road nodes and turn arcs; slower than StandardAStar, and uses more memory, but can generate routes going twice through the same junction, for more flexible routing.

StandardContractionHierarchy 

The contraction hierarchy router is intended where less RAM is available: for example with large maps on mobile devices. It gives the same routes as StandardAStar, but is a little slower and does not support custom route profiles; the route profile is decided at the time of creating the CTM1 file.

TECH 

Turn-expanded contraction hierarchy.

◆ TSideOfRoad

enum class CartoType::TSideOfRoad
strong

The side of the road: used in traffic information.

◆ TStreamEncoding

enum class CartoType::TStreamEncoding
strong

The encoding for reading or writing strings.

◆ TStreamEndianness

enum class CartoType::TStreamEndianness
strong

The endianness for data streams.

◆ TStringMatchMethodFlag

Flags and constants to tell text searching how to match search terms with found strings.

Enumerator
Exact 

The value zero causes exact matching.

Prefix 

A flag to match all strings for which the search term is a perfect match or a prefix.

IgnoreSymbols 

A flag to ignore all characters that are not letters, digits or whitespace when matching.

FoldAccents 

A flag to match accented and unaccented letters.

Fuzzy 

A flag to allow imperfect matches with a small number of omitted, incorrect or extra characters.

FoldCase 

A flag to fold letter case.

IgnoreWhitespace 

A flag to ignore whitespace when matching.

◆ TTextBaseline

enum class CartoType::TTextBaseline
strong

Baselines used for aligning text.

Enumerator
Alphabetic 

The baseline for Latin and similar scripts. It is at or near the bottom of 'A'.

Ideographic 

The bottom edge of Han ideographic characters.

Hanging 

The top edge of characters in hanging Indic scripts like Devanagari.

Mathematical 

The baseline used for mathematical symbols.

Central 

A baseline half way between the leading and trailing edges (top and bottom, for horizontal setting) of the em square.

Middle 

A baseline that is offset from the alphabetic baseline upwards by 1/2 the value of the x-height.

TextBeforeEdge 

The top edge of the em box.

TextAfterEdge 

The bottom edge of the em box.

CentralCaps 

A baseline half way between the ascent line and the alphabetic baseline, suitable for text that is wholly in capital letters.

◆ TTurnType

enum class CartoType::TTurnType
strong

Turn types on a route. Turns at junctions are classified by dividing the full circle into 45-degree segments, except for sharp turns left and right, which encompass everything up to an actual U-turn, and left and right forks, for which there are special rules to avoid classifying them as ahead.

The actual turn angle is also given in the TTurn class.

Enumerator
None 

No turn exists or is needed. This turn type is used at the start of a route.

Ahead 

A turn of less than 15 degrees left or right, unless this is a fork with two choices, in which case the turn will be bear right or bear left.

BearRight 

A turn between 15 degrees and 45 degrees right or a turn through a smaller angle which is the rightmost of a fork with two choices.

Right 

A turn between 45 degrees and 120 degrees right.

SharpRight 

A turn between 120 degrees and 180 degrees right.

Around 

This turn type is use for U-turns: turns back along the same road.

SharpLeft 

A turn between 120 degrees and 180 degrees left.

Left 

A turn between 45 degrees and 120 degrees left.

BearLeft 

A turn between 15 degrees and 45 degrees left. or a turn through a smaller angle which is the leftmost of a fork with two choices.

◆ TVectorTileObjectClipType

Values used in the user-data value of objects in the vector tile drawing system.

Enumerator
Standard 

This object can be drawn normally,

Fill 

This is a polygon that has been clipped and only the interior should be drawn, not the border.

Border 

This is a polyline representing the clipped border of a polygon.

Highlight 

This is a highlight using the first highlight style of a line style. Subsequent highlight styles use the successive values 0x10001, 0x10002, etc.

◆ TWritableMapType

enum class CartoType::TWritableMapType
strong

Types of writable maps.

Enumerator
Memory 

A writable map stored in memory.

SQLite 

A map stored as an SQLite database.

Count 

Not a writable map type but the number of different writable map types.

None 

A value to use where a null type is needed.

Function Documentation

◆ AbbreviationInfo()

const TAbbreviationInfo * CartoType::AbbreviationInfo ( const char *  aLocale)

Returns the abbreviation and letter-case conversion information for a given locale, or null if information for the locale is not found.

◆ AppendEllipticalArc() [1/2]

void CartoType::AppendEllipticalArc ( CContour aContour,
const TPoint aCenter,
double  aRX,
double  aRY,
double  aEllipseAngle,
double  aStartAngle,
double  aEndAngle,
TEllipseAngleType  aAngleType,
bool  aAppendStart 
)

Append an arc of an ellipse using center parameterization. aCenter is in 64ths of pixels. if aAppendStart is true, the start point is also appended to the contour. Implementation notes: The arc is divided into sections of less than pi/2. For each section three points are appended: two control points and the end point.

◆ AppendEllipticalArc() [2/2]

void CartoType::AppendEllipticalArc ( CContour aContour,
const TPoint aStart,
double  aRX,
double  aRY,
double  aEllipseAngle,
bool  aLargeArc,
bool  aSweep,
const TPoint aEnd,
bool  aAppendStart 
)

Append an arc of an ellipse using endpoint parameterization. The input points are in 64ths of pixels. If aAppendStart is true, the start point is also appended to the contour.

◆ Area() [1/2]

template<class contour_t >
double CartoType::Area ( const contour_t &  aContour)
inline

Returns the area of a polygon represented as a vector of points with members iX and iY.

◆ Area() [2/2]

template<class point_t >
double CartoType::Area ( const point_t *  aPointArray,
size_t  aPointCount 
)
inline

Returns the area of a polygon made of points with members iX and iY.

◆ Atan2()

double CartoType::Atan2 ( double  aY,
double  aX 
)
inline

An arctangent function which checks for two zero arguments and returns zero in that case. In the standard library atan2(0,0) is undefined, and on Embarcadero C++ Builder it throws an exception.

◆ AzimuthInDegrees()

double CartoType::AzimuthInDegrees ( double  aLong1,
double  aLat1,
double  aLong2,
double  aLat2 
)
noexcept

Gets the azimuth (direction along a great circle line) from one point to another in degrees, given two lat-long points in degrees.

This function uses the WGS84 ellipsoid.

North is 0 and angles increase clockwise.

◆ Build()

const char * CartoType::Build ( )

Returns the current CartoType build as a string.

◆ CBox()

template<class T >
TRect CartoType::CBox ( T *  aPointArray,
size_t  aPointCount 
)

Returns the axis-aligned bounding box of a sequence of points, treating control points as ordinary points.

◆ Circle()

CContour CartoType::Circle ( const TPoint aCenter,
double  aRadius 
)

Create a contour that is a circle. The center is specified in 64ths and the output is also in 64ths. The radius is in whole units.

◆ ClampTo32Bit()

double CartoType::ClampTo32Bit ( double  aX)
inline

Clamps a floating point number to the range supported by signed 32-bit integers.

◆ CodeToCountry()

CString CartoType::CodeToCountry ( const MString aCode)

Returns the English-language name of a country as a lower-case string, given its two-letter country code (ISO 3166-1 alpha-2). The letter case of aCode is ignored. Returns the code itself, converted to lower case, if aCode is not found.

◆ CountryToCode()

CString CartoType::CountryToCode ( const MString aCountry)

Returns the two-letter country code (ISO 3166-1 alpha-2) as a lower-case string, given the English-language name of the country. The letter case of aCountry is ignored. Returns the empty string if aCountry is not found.

◆ Ellipse()

CContour CartoType::Ellipse ( const TPoint aCenter,
double  aRX,
double  aRY,
double  aEllipseAngle 
)

Create a contour that is an ellipse. The center is specified in 64ths of pixels.

◆ ErrorString()

std::string CartoType::ErrorString ( uint32_t  aErrorCode)

Returns a short description of an error, given its code.

◆ ExpandStreetName()

CString CartoType::ExpandStreetName ( const MString aText)

Expands a street name by replacing abbreviations with their full forms. For example, St is replaced by Street. This function cannot of course know whether St should actually be replaced by Saint. Its purpose is to aid address searching.

◆ FileSeek()

int CartoType::FileSeek ( FILE *  aFile,
int64_t  aOffset,
int  aOrigin 
)
inline

An fseek-compatible function for moving to a position in a file, specifying it using a 64-bit signed integer.

◆ FileTell()

int64_t CartoType::FileTell ( FILE *  aFile)
inline

An ftell-compatible function for getting the current position in a file, returning a 64-bit signed integer.

◆ Find() [1/3]

CMapObjectArray CartoType::Find ( CMapDataBaseArray &  aMapDataBaseArray,
const TFindParam aFindParam,
const COutline aClip,
const COutline aLocation 
)

A low-level general search function, allowing any combination of clip rectangle, choice of layers, choice of attributes, text and string match method, and condition.

aClip contains aFindParam.iClip, converted to map coordinates. aLocation contains aFindParam.iLocation, converted to map coordinates. This low-level function cannot do the conversion itself because it has no access to the current map scale or perspective transform.

◆ Find() [2/3]

CMapObjectArray CartoType::Find ( CMapDataBaseSet &  aMapDataBaseSet,
const TFindParam aFindParam,
const COutline aClip,
const COutline aLocation 
)

A low-level general search function, allowing any combination of clip rectangle, choice of layers, choice of attributes, text and string match method, and condition.

aClip contains aFindParam.iClip, converted to map coordinates. aLocation contains aFindParam.iLocation, converted to map coordinates. This low-level function cannot do the conversion itself because it has no access to the current map scale or perspective transform.

◆ Find() [3/3]

void CartoType::Find ( CMapDataBaseSet &  aMapDataBaseSet,
const TRect aRect,
FindHandler  aFindHandler,
const MString aCondition 
)

Finds objects in aRect, which is in map coordinates. The objects that are returned are unprojected.

The number of objects returned can be limited by setting aMaxObjects to an appropriate value.

if aCondition is non-null it is a style sheet expression (e.g., "Type==2") which must be satisfied by the objects.

◆ FindHelper()

void CartoType::FindHelper ( CMapDataBaseSet &  aMapDataBaseSet,
FindHandler  aFindHandler,
const TFindParam aFindParam,
const TRect aClipRect,
TTimePoint  aTimeOut 
)

An internal function used in the implementation of the general find functions.

◆ FindInLayers()

void CartoType::FindInLayers ( CMapDataBaseSet &  aMapDataBaseSet,
const MString aLayers,
const TRect aRect,
FindHandler  aFindHandler,
const MString aCondition 
)

Finds objects in named layers in aRect, which is in map coordinates. The objects that are returned are unprojected.

aLayers is a space or comma separated list of layers. Each layer may contain the wild cards '*' and '?', in which case all matching layers are searched. If a layer ends in '/' it matches itself without the final '/', and any layers starting with 'layer/'. Layers are searched once only even if they match more than one item in the list of layers. Layers are searched in the order of the list.

if aCondition is non-null it is a style sheet expression (e.g., "Type==2") which must be satisfied by the objects.

◆ FindNearby()

void CartoType::FindNearby ( CMapDataBaseSet &  aMapDataBaseSet,
FindHandler  aFindHandler,
CMapObjectArray aMapObjectArray,
const TFindParam aFindParam,
const TRect aClipRect,
const COutline aLocation,
TTimePoint  aTimeOut 
)

A special function to handle searches where aFindParam.iLocation is set: that is, finding places nearby.

◆ FindText()

void CartoType::FindText ( CMapDataBaseSet &  aMapDataBaseSet,
const MString aText,
FindHandler  aFindHandler,
TStringMatchMethod  aStringMatchMethod,
const MString aLayers,
const std::vector< CString > &  aAttribs,
const TRect aClip,
TTimePoint  aTimeOut 
)

Finds objects with the value aText in selected layers and attributes. If aLayers is empty all layers are searched, otherwise only the named layers are searched. Layer names may contain the wild cards * and ?. If aAttribs is empty all attributes are searched, otherwise only the named attributes are searched. To name the label attribute (the main name of an object) use the empty string.

◆ GetSphericalAreaAndLength() [1/2]

void CartoType::GetSphericalAreaAndLength ( const TCoordSet aCoordSet,
bool  aIsPolyline,
double *  aArea,
double *  aLength 
)
noexcept

Gets the area and length of a polygon, or the length of a polyline, in square metres and metres. The points are defined in degrees of latitude (y) and longitude (x). The polygon or polyline is specified by the points of aCoordSet. The parameter aIsPolyline is true if the points represent a polyline, otherwise the points represent a polygon. The return values aArea and aLength are filled in only if non-null. If aPolyline is true, only aLength is filled in.

◆ GetSphericalAreaAndLength() [2/2]

void CartoType::GetSphericalAreaAndLength ( std::function< const TPointFP *()>  aNextPoint,
bool  aIsPolyline,
double *  aArea,
double *  aLength 
)

Gets the area and length of a polygon, or the length of a polyline, in square metres and metres. The points are defined in degrees of latitude (y) and longitude (x). The function aNextPoint must return all the points in order then return null to indicate that there are no more points. The parameter aIsPolyline is true if the points represent a polyline, otherwise the points represent a polygon. The return values aArea and aLength are filled in only if non-null. If aPolyline is true, only aLength is filled in.

◆ GreatCircleDistanceInMeters()

double CartoType::GreatCircleDistanceInMeters ( double  aLong1,
double  aLat1,
double  aLong2,
double  aLat2 
)
inline

Finds the great-circle distance in metres, assuming a spherical earth, between two lat-long points in degrees.

See also
GreatCircleDistanceInMetersUsingEllipsoid, which is a little slower but uses the WGS84 ellipsoid.

◆ GreatCircleDistanceInMetersUsingEllipsoid()

double CartoType::GreatCircleDistanceInMetersUsingEllipsoid ( double  aLong1,
double  aLat1,
double  aLong2,
double  aLat2 
)
noexcept

Finds the great-circle distance in meters between two lat-long points in degrees, using the WGS84 ellipsoid.

See also
GreatCircleDistanceInMeters, which is faster but assumes a spherical earth.

◆ IntAttribute()

int32_t CartoType::IntAttribute ( const char *  aThreeLetterCode,
int  aType 
)
inline

Constructs an integer attribute from an optional three-letter code, placed in the high 16 bits by encoding each letter in five bits, and a type number placed in the low 16 bits.

The three-letter code is used only if it consists of exactly three lower-case letters in the range a...z.

Three-letter codes are used for mnemonic purposes, as for example "pub" for a public house, and can be tested easily in style sheets.

◆ InterpolatedValue()

template<class DataType , int32_t UnknownValue = INT32_MIN>
double CartoType::InterpolatedValue ( const DataType *  aDataStart,
int32_t  aWidth,
int32_t  aHeight,
int32_t  aStride,
int32_t  aChannels,
double  aX,
double  aY,
int  aChannel 
)

Uses bilinear interpolation to get the value at (aX,aY) from a rectangular table of data. Each data item has aChannels channels, and each channel takes up aWidth * sizeof(DataType) bytes. The UnknownValue is ignored when interpolating.

◆ MapObjectUserDataLessThan()

bool CartoType::MapObjectUserDataLessThan ( const std::unique_ptr< CMapObject > &  aP,
const std::unique_ptr< CMapObject > &  aQ 
)
inline

A comparison function which compares unique pointers to map objects on their user data. Neither pointer can be null. This function can be used in std::sort, etc.

◆ MapPointFromUKGridReference()

TPointFP CartoType::MapPointFromUKGridReference ( const CString aGridReference)

Converts a UK Ordnance Survey national grid reference (two capital letters followed by an even number of digits) into a point in map meters in the Ordnance Survey projection. The rectangle returned is the center of the square defined by the grid reference.

Returns the point (-1,-1) if the grid reference is invalid.

◆ MapRectFromUKGridReference()

TRectFP CartoType::MapRectFromUKGridReference ( const CString aGridReference)

Converts a UK Ordnance Survey national grid reference (two capital letters followed by an even number of digits) into a rectangle in map meters in the Ordnance Survey projection. The rectangle returned is the square defined by the grid reference. Spaces are ignored, and letters are converted to upper case.

Returns the rectangle (-1,-1,-1,-1) if the grid reference is invalid.

◆ Merge()

void CartoType::Merge ( CMapObjectArray aObjectArray,
size_t  aStartIndex 
)

Merges map objects that are parts of the same larger object, like sections of the same road.

◆ MergeableIntAttribute()

uint32_t CartoType::MergeableIntAttribute ( const CMapObject aObject)

Extracts the mergeable part of the integer attribute: the road type, or the whole attribute if the object isn't a road.

◆ OutlineInMapCoords()

template<class point_t >
COutline CartoType::OutlineInMapCoords ( CFramework aFramework,
const CGeneralGeometry< point_t > &  aGeometry 
)

Creates a COutline object in map coordinates from a Geometry object.

◆ PointAtAzimuth()

TPointFP CartoType::PointAtAzimuth ( const TPointFP aPoint,
double  aDir,
double  aDistanceInMetres 
)
noexcept

Finds the point in degrees at a certain distance and azimuth direction from a starting point. This function uses the WGS84 ellipsoid.

◆ PointInDegreesFromUKGridReference()

TPointFP CartoType::PointInDegreesFromUKGridReference ( const CString aGridReference)

Converts a UK Ordnance Survey national grid reference (two capital letters followed by an even number of digits) into a point in degrees latitude and longitude (WGS84). The rectangle returned is the center of the square defined by the grid reference.

Returns the point (0,0) if the grid reference is invalid.

◆ ReadBigEndian() [1/2]

int16_t CartoType::ReadBigEndian ( const int16_t *  aP)
inline

Reads a big-endian 16-bit integer from aP.

◆ ReadBigEndian() [2/2]

uint8_t CartoType::ReadBigEndian ( const uint8_t *  aP)
inline

Reads an 8-bit integer from aP. Used by InterpolatedValue, which requires a function of this name even when endianness is irrelevant.

◆ Reverse()

template<class T >
void CartoType::Reverse ( T *  aStart,
size_t  aLength 
)
inline

Reverses an array of objects of type T.

◆ RoadTypeIsOneWay()

bool CartoType::RoadTypeIsOneWay ( uint32_t  aRoadType)
inline

Returns true if a road type stored in an integer represents a one-way road.

◆ Round()

int32_t CartoType::Round ( double  aValue)
inline

Rounds a floating-point value to the nearest integer. Does not use floor() because it is said to be slow on some platforms.

◆ SimplifyContour()

template<class T >
size_t CartoType::SimplifyContour ( T *  aPointArray,
size_t  aPointCount,
bool  aClosed,
double  aResolutionArea 
)

A templated function to simplify a contour of any type. Returns the new number of points, after simplification.

Simplification consists in removing all points with an area less than aResolutionArea. A point's area is the area of the triangle made by the point and its two neighbours.

The start and end of an open contour are not removed. Closed contours may be reduced to nothing.

◆ Sort()

void CartoType::Sort ( CMapObjectArray aObjectArray,
const MString aText,
size_t  aStartIndex,
const COutline aLocation,
double  aMapUnitSize 
)

Sorts objects according to how good a match they are with aText (if non-empty), their importance, and optionally their distance from a location.

◆ SphericalPolygonArea() [1/2]

double CartoType::SphericalPolygonArea ( const TCoordSet aCoordSet)
noexcept

Gets the area of a polygon in square metres. The polygon is defined in degrees of latitude (y) and longitude (x).

◆ SphericalPolygonArea() [2/2]

double CartoType::SphericalPolygonArea ( std::function< const TPointFP *()>  aNextPoint)

Gets the area of a polygon in square metres. The polygon is defined in degrees of latitude (y) and longitude (x). The function aNextPoint must return all the points of the polygon in order then return null to indicate that there are no more points.

◆ SphericalPolylineLength() [1/2]

double CartoType::SphericalPolylineLength ( const TCoordSet aCoordSet)
noexcept

Gets the length of a line, in meters, defined by points of latitude (y) and longitude (x), using great-circle distances.

◆ SphericalPolylineLength() [2/2]

double CartoType::SphericalPolylineLength ( std::function< const TPointFP *()>  aNextPoint)

Gets the length of a polyline in square metres. The polyline is defined in degrees of latitude (y) and longitude (x). The function aNextPoint must return all the points of the polyline in order then return null to indicate that there are no more points.

◆ Strtod() [1/2]

double CartoType::Strtod ( const char *  aString,
size_t  aLength = UINT32_MAX,
const char **  aEndPtr = nullptr 
)
noexcept

A non-locale-dependent version of the standard library strtod function.

Converts a string to a floating-point number and optionally returns a pointer to the position after the portion of the string converted. The decimal point is always a full stop, unlike the standard library function, which uses that of the current locale (e.g., a comma in the German locale.)

If aLength is UINT32_MAX the string must be null-terminated.

◆ Strtod() [2/2]

double CartoType::Strtod ( const uint16_t *  aString,
size_t  aLength = UINT32_MAX,
const uint16_t **  aEndPtr = nullptr 
)
noexcept

A non-locale-dependent version of the standard library strtod function, but for UTF-16 characters.

Converts a string to a floating-point number and optionally returns a pointer to the position after the portion of the string converted. The decimal point is always a full stop, unlike the standard library function, which uses that of the current locale (e.g., a comma in the German locale.)

If aLength is UINT32_MAX the string must be null-terminated.

◆ Traverse() [1/2]

template<class MTraverser >
void CartoType::Traverse ( MTraverser &  aTraverser,
const TPoint aPoint,
size_t  aPoints,
bool  aClosed 
)

Traverses a sequence of TPoint objects, extracting lines and curves and calling functions to process them.

The functions called are

To start a new contour, move to aPoint without drawing a line and set the current point to aPoint:

void MoveTo(const TPoint& aPoint)

To draw a line from the current point to aPoint and set the current point to aPoint:

void LineTo(const TPoint& aPoint)

◆ Traverse() [2/2]

template<class traverser_t , class point_t >
void CartoType::Traverse ( traverser_t &  aTraverser,
const point_t *  aPoint,
size_t  aPoints,
bool  aClosed 
)

Traverses a sequence of outline point objects, extracting lines and curves and calling functions to process them.

The functions called are

To start a new contour, move to aPoint without drawing a line and set the current point to aPoint:

void MoveTo(const TPoint& aPoint)

To draw a line from the current point to aPoint and set the current point to aPoint:

void LineTo(const TPoint& aPoint)

To draw a quadratic spline from the current point to aPoint2, using aPoint1 as the off-curve control point, and set the current point to aPoint2:

void QuadraticTo(const TPoint& aPoint1,const TPoint& aPoint2)

To draw a cubic spline from the current point to aPoint3, using aPoint1 and aPoint2 as the off-curve control points, and set the current point to aPoint3:

void CubicTo(const TPoint& aPoint1,const TPoint& aPoint2,const TPoint& aPoint3)

◆ TriangleArea()

double CartoType::TriangleArea ( const TPoint aA,
const TPoint aB,
const TPoint aC 
)
inline

Returns the area of a triangle made from the points aA, aB, aC.

◆ UKGridReferenceFromDegrees()

CString CartoType::UKGridReferenceFromDegrees ( const TPointFP aPointInDegrees,
int32_t  aDigits 
)

Converts a point in degrees latitude and longitude (WGS84) into a UK Ordnance Survey national grid reference, using aDigits as the number of digits per coordinate; this value is clamped to the range 0...5. Five-digit references are accurate to a meter.

Returns an empty string if the point is outside the UK national grid bounds.

◆ UKGridReferenceFromMapPoint()

CString CartoType::UKGridReferenceFromMapPoint ( const TPointFP aPointInMapMeters,
int32_t  aDigits 
)

Converts a point in map meters in the Ordnance Survey projection into a UK Ordnance Survey national grid reference, using aDigits as the number of digits per coordinate; this value is clamped to the range 0...5. Five-digit references are accurate to a meter.

Returns an empty string if the point is outside the UK national grid bounds.

◆ Version()

const char * CartoType::Version ( )

Returns the current CartoType version as a string of the form MAJOR.MINOR.

◆ WriteBigEndian() [1/2]

void CartoType::WriteBigEndian ( int16_t *  aP,
int16_t  aValue 
)
inline

Writes a big-endian 16-bit integer to aP.

◆ WriteBigEndian() [2/2]

void CartoType::WriteBigEndian ( uint8_t *  aP,
uint8_t  aValue 
)
inline

Writes an 8-bit integer to aP. Used by InterpolatedValue, which requires a function of this name even when endianness is irrelevant.

◆ WriteTrackAsXmlHelper()

void CartoType::WriteTrackAsXmlHelper ( const CTrackGeometry aTrack,
MOutputStream aOutput 
)

An internal function to write a track in GPX format.

Variable Documentation

◆ CT_DBL_MAX

const double CartoType::CT_DBL_MAX = 1.7976931348623158e+308

This CartoType-specific version of DBL_MAX is supplied to avoid the bug in C++ Builder, which defines DBL_MAX as a very small number. It uses a different name from DBL_MAX in case DBL_MAX is defined as a macro.

◆ KArabicScript

const uint32_t CartoType::KArabicScript = 0x20

A bit flag used in typeface matching: the Arabic script.

◆ KArcAccessMask

constexpr uint32_t CartoType::KArcAccessMask = 0x7FF00000
constexpr

A bit mask used by access restrictions in a route profile, for access restrictions not including the 'other access' flag.

◆ KArcAllMotorVehicles

constexpr uint32_t CartoType::KArcAllMotorVehicles = KArcAccessMask & ~(KArcWrongWayFlag | KArcPedestrianAccessFlag | KArcBicycleAccessFlag)
constexpr

A combination of bit flags used by access restrictions in a route profile: access flags affect all motor vehicles.

◆ KArcAllVehicles

constexpr uint32_t CartoType::KArcAllVehicles = KArcNoVehicularAccess
constexpr

A combination of bit flags used by access restrictions in a route profile: access flags affect all vehicles; synonym of KArcNoVehicularAccess.

◆ KArcBicycleAccessFlag

constexpr uint32_t CartoType::KArcBicycleAccessFlag = 0x00200000
constexpr

A bit flag used by access restrictions in a route profile: no access for bicycles.

◆ KArcBicycleAccessOnly

constexpr uint32_t CartoType::KArcBicycleAccessOnly = KArcAccessMask & ~(KArcWrongWayFlag | KArcBicycleAccessFlag)
constexpr

A combination of bit flags used by access restrictions in a route profile: bicycle access only.

◆ KArcBicycleAndPedestrianAccessOnly

constexpr uint32_t CartoType::KArcBicycleAndPedestrianAccessOnly = KArcAllMotorVehicles
constexpr

A combination of bit flags used by access restrictions in a route profile: bicycle and pedestrian access only; synonym of KArcAllMotorVehicles.

◆ KArcBridleway

constexpr uint32_t CartoType::KArcBridleway = 20
constexpr

The index for bridleways in the speed and bonus arrays in TRouteProfile.

◆ KArcBusAccessFlag

constexpr uint32_t CartoType::KArcBusAccessFlag = 0x08000000
constexpr

A bit flag used by access restrictions in a route profile: no access for buses.

◆ KArcCarAccessFlag

constexpr uint32_t CartoType::KArcCarAccessFlag = 0x00800000
constexpr

A bit flag used by access restrictions in a route profile: no access for cars.

◆ KArcCycleway

constexpr uint32_t CartoType::KArcCycleway = 17
constexpr

The index for cycleways in the speed and bonus arrays in TRouteProfile.

◆ KArcDriveOnLeftRoadDirection

constexpr uint32_t CartoType::KArcDriveOnLeftRoadDirection = 0x300
constexpr

The road direction value for drive-on-left: used by routers.

◆ KArcDriveOnRightRoadDirection

constexpr uint32_t CartoType::KArcDriveOnRightRoadDirection = 0
constexpr

The road direction value for drive-on-right: used by routers.

◆ KArcEmergencyAccessFlag

constexpr uint32_t CartoType::KArcEmergencyAccessFlag = 0x40000000
constexpr

A bit flag used by access restrictions in a route profile: no access for emergency vehicles.

◆ KArcFootway

constexpr uint32_t CartoType::KArcFootway = 19
constexpr

The index for footways in the speed and bonus arrays in TRouteProfile.

◆ KArcGradientCount

constexpr uint32_t CartoType::KArcGradientCount = 8
constexpr

The size of the gradient arrays in TRouteProfile.

◆ KArcGradientDirectionFlag

constexpr uint32_t CartoType::KArcGradientDirectionFlag = 0x80
constexpr

A bit flag for road types: used by routers.

◆ KArcGradientDown0Index

constexpr uint32_t CartoType::KArcGradientDown0Index = 4
constexpr

The index for a very slight downhill gradient, or no gradient, in the gradient arrays in TRouteProfile.

◆ KArcGradientDown1Index

constexpr uint32_t CartoType::KArcGradientDown1Index = 5
constexpr

The index for a gentle downhill gradient in the gradient arrays in TRouteProfile.

◆ KArcGradientDown2Index

constexpr uint32_t CartoType::KArcGradientDown2Index = 6
constexpr

The index for a steep downhill gradient in the gradient arrays in TRouteProfile.

◆ KArcGradientDown3Index

constexpr uint32_t CartoType::KArcGradientDown3Index = 7
constexpr

The index for a very steep downhill gradient in the gradient arrays in TRouteProfile.

◆ KArcGradientMask

constexpr uint32_t CartoType::KArcGradientMask = 0xE0
constexpr

A bit mask for road gradents: used by routers.

◆ KArcGradientName

const char* const CartoType::KArcGradientName[KArcGradientCount]
Initial value:
=
{
"up0", "up1", "up2", "up3", "down0", "down1", "down2", "down3"
}

The names of the different gradient ranges, as used in serialized XML rout profiles.

◆ KArcGradientShift

constexpr uint32_t CartoType::KArcGradientShift = 5
constexpr

The number of bits by which the gradient field is shifted: used by routers.

◆ KArcGradientUp0Index

constexpr uint32_t CartoType::KArcGradientUp0Index = 0
constexpr

The index for a very slight uphill gradient, or no gradient, in the gradient arrays in TRouteProfile.

◆ KArcGradientUp1Index

constexpr uint32_t CartoType::KArcGradientUp1Index = 1
constexpr

The index for a gentle uphill gradient in the gradient arrays in TRouteProfile.

◆ KArcGradientUp2Index

constexpr uint32_t CartoType::KArcGradientUp2Index = 2
constexpr

The index for a steep uphill gradient in the gradient arrays in TRouteProfile.

◆ KArcGradientUp3Index

constexpr uint32_t CartoType::KArcGradientUp3Index = 3
constexpr

The index for a very steep uphill gradient in the gradient arrays in TRouteProfile.

◆ KArcHeavyGoodsAccessFlag

constexpr uint32_t CartoType::KArcHeavyGoodsAccessFlag = 0x04000000
constexpr

A bit flag used by access restrictions in a route profile: no access for heavy goods vehicles.

◆ KArcHighOccupancyAccessFlag

constexpr uint32_t CartoType::KArcHighOccupancyAccessFlag = 0x01000000
constexpr

A bit flag used by access restrictions in a route profile: no access for high occupancy vehicles.

◆ KArcLightGoodsAccessFlag

constexpr uint32_t CartoType::KArcLightGoodsAccessFlag = 0x02000000
constexpr

A bit flag used by access restrictions in a route profile: no access for light goods vehicles.

◆ KArcLivingStreet

constexpr uint32_t CartoType::KArcLivingStreet = 16
constexpr

The index for living streets in the speed and bonus arrays in TRouteProfile.

◆ KArcMotorCycleAccessFlag

constexpr uint32_t CartoType::KArcMotorCycleAccessFlag = 0x00400000
constexpr

A bit flag used by access restrictions in a route profile: no access for motorcycles.

◆ KArcMotorway

constexpr uint32_t CartoType::KArcMotorway = 0
constexpr

The index for motorways in the speed and bonus arrays in TRouteProfile.

◆ KArcMotorwayLink

constexpr uint32_t CartoType::KArcMotorwayLink = 1
constexpr

The index for motorway links (ramps) in the speed and bonus arrays in TRouteProfile.

◆ KArcNoVehicularAccess

constexpr uint32_t CartoType::KArcNoVehicularAccess = KArcAccessMask & ~(KArcWrongWayFlag | KArcPedestrianAccessFlag)
constexpr

A combination of bit flags used by access restrictions in a route profile: no vehicular access.

◆ KArcOneWayBackwardRoadDirection

constexpr uint32_t CartoType::KArcOneWayBackwardRoadDirection = 0x200
constexpr

The road direction value for one-way backward: used by routers.

◆ KArcOneWayForwardRoadDirection

constexpr uint32_t CartoType::KArcOneWayForwardRoadDirection = 0x100
constexpr

The road direction value for one-way forward: used by routers.

◆ KArcOtherAccessFlag

constexpr uint32_t CartoType::KArcOtherAccessFlag = 0x80000000
constexpr

A bit flag used by access restrictions in a route profile: other access restrictions exist such as weight, length, width, height or for vehicles carrying hazardous materials.

◆ KArcOtherRoadType0

constexpr uint32_t CartoType::KArcOtherRoadType0 = 24
constexpr

The index for other road type 0 in the speed and bonus arrays in TRouteProfile.

◆ KArcOtherRoadType1

constexpr uint32_t CartoType::KArcOtherRoadType1 = 25
constexpr

The index for other road type 1 in the speed and bonus arrays in TRouteProfile.

◆ KArcOtherRoadType2

constexpr uint32_t CartoType::KArcOtherRoadType2 = 26
constexpr

The index for other road type 2 in the speed and bonus arrays in TRouteProfile.

◆ KArcOtherRoadType3

constexpr uint32_t CartoType::KArcOtherRoadType3 = 27
constexpr

The index for other road type 3 in the speed and bonus arrays in TRouteProfile.

◆ KArcOtherRoadType4

constexpr uint32_t CartoType::KArcOtherRoadType4 = 28
constexpr

The index for other road type 4 in the speed and bonus arrays in TRouteProfile.

◆ KArcOtherRoadType5

constexpr uint32_t CartoType::KArcOtherRoadType5 = 29
constexpr

The index for other road type 5 in the speed and bonus arrays in TRouteProfile.

◆ KArcOtherRoadType6

constexpr uint32_t CartoType::KArcOtherRoadType6 = 30
constexpr

The index for other road type 6 in the speed and bonus arrays in TRouteProfile.

◆ KArcOtherRoadType7

constexpr uint32_t CartoType::KArcOtherRoadType7 = 31
constexpr

The index for other road type 7 in the speed and bonus arrays in TRouteProfile.

◆ KArcPassengerFerry

constexpr uint32_t CartoType::KArcPassengerFerry = 15
constexpr

The index for passenger ferries in the speed and bonus arrays in TRouteProfile.

◆ KArcPath

constexpr uint32_t CartoType::KArcPath = 18
constexpr

The index for paths in the speed and bonus arrays in TRouteProfile.

◆ KArcPedestrianAccessFlag

constexpr uint32_t CartoType::KArcPedestrianAccessFlag = 0x20000000
constexpr

A bit flag used by access restrictions in a route profile: no access for pedestrians.

◆ KArcPedestrianRoad

constexpr uint32_t CartoType::KArcPedestrianRoad = 13
constexpr

The index for pedestrian roads in the speed and bonus arrays in TRouteProfile.

◆ KArcPrimaryRoad

constexpr uint32_t CartoType::KArcPrimaryRoad = 4
constexpr

The index for primary roads in the speed and bonus arrays in TRouteProfile.

◆ KArcPrimaryRoadLink

constexpr uint32_t CartoType::KArcPrimaryRoadLink = 5
constexpr

The index for primary road links (ramps) in the speed and bonus arrays in TRouteProfile.

◆ KArcResidentialRoad

constexpr uint32_t CartoType::KArcResidentialRoad = 10
constexpr

The index for residential roads in the speed and bonus arrays in TRouteProfile.

◆ KArcRoadDirectionMask

constexpr uint32_t CartoType::KArcRoadDirectionMask = 0x300
constexpr

A bit mask for road directions: used by routers.

◆ KArcRoadTypeCount

constexpr uint32_t CartoType::KArcRoadTypeCount = 32
constexpr

The number of road types and the size of the speed and bonus arrays in TRouteProfile.

◆ KArcRoadTypeMask

constexpr uint32_t CartoType::KArcRoadTypeMask = 0x1F
constexpr

A bit mask for road types: used by routers.

◆ KArcRoundaboutFlag

constexpr uint32_t CartoType::KArcRoundaboutFlag = 0x400
constexpr

A bit flag for roundabouts: used by routers.

◆ KArcSecondaryRoad

constexpr uint32_t CartoType::KArcSecondaryRoad = 6
constexpr

The index for secondary roads in the speed and bonus arrays in TRouteProfile.

◆ KArcSecondaryRoadLink

constexpr uint32_t CartoType::KArcSecondaryRoadLink = 7
constexpr

The index for secondary road links (ramps) in the speed and bonus arrays in TRouteProfile.

◆ KArcServiceRoad

constexpr uint32_t CartoType::KArcServiceRoad = 12
constexpr

The index for service roads and access roads in the speed and bonus arrays in TRouteProfile.

◆ KArcSpeedLimitMask

constexpr uint32_t CartoType::KArcSpeedLimitMask = 0xFF000
constexpr

A bit mask for the speed limit in kph if known (zero means no known speed limit): used by routers.

◆ KArcSpeedLimitShift

constexpr uint32_t CartoType::KArcSpeedLimitShift = 12
constexpr

The number of bits by which the speed limit field is shifted: used by routers.

◆ KArcSteps

constexpr uint32_t CartoType::KArcSteps = 21
constexpr

The index for steps in the speed and bonus arrays in TRouteProfile.

◆ KArcTaxiAccessFlag

constexpr uint32_t CartoType::KArcTaxiAccessFlag = 0x10000000
constexpr

A bit flag used by access restrictions in a route profile: no access for taxis.

◆ KArcTertiaryRoad

constexpr uint32_t CartoType::KArcTertiaryRoad = 8
constexpr

The index for tertiary roads in the speed and bonus arrays in TRouteProfile.

◆ KArcTollFlag

constexpr uint32_t CartoType::KArcTollFlag = 0x800
constexpr

A bit flag for toll roads: used by routers.

◆ KArcTrack

constexpr uint32_t CartoType::KArcTrack = 11
constexpr

The index for tracks in the speed and bonus arrays in TRouteProfile.

◆ KArcTrunkRoad

constexpr uint32_t CartoType::KArcTrunkRoad = 2
constexpr

The index for trunk roads in the speed and bonus arrays in TRouteProfile.

◆ KArcTrunkRoadLink

constexpr uint32_t CartoType::KArcTrunkRoadLink = 3
constexpr

The index for trunk road links (ramps) in the speed and bonus arrays in TRouteProfile.

◆ KArcUnclassifiedRoad

constexpr uint32_t CartoType::KArcUnclassifiedRoad = 9
constexpr

The index for unclassified roads in the speed and bonus arrays in TRouteProfile.

◆ KArcUnknownRoadType

constexpr uint32_t CartoType::KArcUnknownRoadType = 22
constexpr

The index for roads of unknown type in the speed and bonus arrays in TRouteProfile.

◆ KArcUnpavedRoad

constexpr uint32_t CartoType::KArcUnpavedRoad = 23
constexpr

The index for unpaved (unsurfaced) roads in the speed and bonus arrays in TRouteProfile.

◆ KArcVehicularFerry

constexpr uint32_t CartoType::KArcVehicularFerry = 14
constexpr

The index for vehicular ferries in the speed and bonus arrays in TRouteProfile.

◆ KArcWrongWayFlag

constexpr uint32_t CartoType::KArcWrongWayFlag = 0x00100000
constexpr

A bit flag used by access restrictions in a route profile: this arc goes the wrong way along a one-way road but it can be used by pedestrians and emergency vehicles.

◆ KArmenianScript

const uint32_t CartoType::KArmenianScript = 8

A bit flag used in typeface matching: the Armenian script.

◆ KBengaliScript

const uint32_t CartoType::KBengaliScript = 0x80

A bit flag used in typeface matching: the Bengali script.

◆ KBlack

const uint32_t CartoType::KBlack = 0xFF000000

Opaque black.

◆ KBlue

const uint32_t CartoType::KBlue = 0xFFFF0000

Opaque blue.

◆ KBoldStyle

const uint32_t CartoType::KBoldStyle = 1

Constants used to refer to styles in TTypefaceAttrib, etc. These are flags used in a 32-bit word. The bit flag used to select bold face in TTypefaceAttrib::Style, etc.

◆ KBopomofoScript

const uint32_t CartoType::KBopomofoScript = 0x8000000

A bit flag used in typeface matching: the Bopomofo script.

◆ KCursiveStyle

const uint32_t CartoType::KCursiveStyle = 8

The bit flag used to select a cursive font in TTypefaceAttrib::Style, etc.

◆ KCyan

const uint32_t CartoType::KCyan = 0xFFFFFF00

Opaque cyan.

◆ KCyrillicScript

const uint32_t CartoType::KCyrillicScript = 4

A bit flag used in typeface matching: the Cyrillic script.

◆ KDarkBlue

const uint32_t CartoType::KDarkBlue = 0xFF800000

Opaque dark blue.

◆ KDarkCyan

const uint32_t CartoType::KDarkCyan = 0xFF808000

Opaque dark cyan.

◆ KDarkGray

const uint32_t CartoType::KDarkGray = 0xFF555555

Opaque dark gray.

◆ KDarkGreen

const uint32_t CartoType::KDarkGreen = 0xFF008000

Opaque dark green.

◆ KDarkGrey

const uint32_t CartoType::KDarkGrey = 0xFF555555

Opaque dark grey.

◆ KDarkMagenta

const uint32_t CartoType::KDarkMagenta = 0xFF800080

Opaque dark magenta.

◆ KDarkRed

const uint32_t CartoType::KDarkRed = 0xFF000080

Opaque dark red.

◆ KDarkYellow

const uint32_t CartoType::KDarkYellow = 0xFF008080

Opaque dark yellow.

◆ KDefaultTextIndexLevels

constexpr int32_t CartoType::KDefaultTextIndexLevels = 1
constexpr

The standard number of levels of the text index to load into RAM when loading a CTM1 file.

◆ KDegreesToMetres

constexpr double CartoType::KDegreesToMetres = KRadiansToMetres * KDegreesToRadiansDouble
constexpr

A factor to convert degrees to metres, using the semi-major axis (equatorial radius) used by the WGS 84 datum.

◆ KDegreesToRadiansDouble

constexpr double CartoType::KDegreesToRadiansDouble = KPiDouble / 180.0
constexpr

A factor to convert degrees to radians: the number of radians in a degree.

◆ KDevanagariScript

const uint32_t CartoType::KDevanagariScript = 0x40

A bit flag used in typeface matching: the Devanagari script.

◆ KEpsgPlateCarree

constexpr int32_t CartoType::KEpsgPlateCarree = 4326
constexpr

The EPSG code for the Plate Carree projection. Used by TTileParam.

◆ KEpsgWebMercator

constexpr int32_t CartoType::KEpsgWebMercator = 3857
constexpr

The EPSG code for the Web Mercator projection. Used by TTileParam.

◆ KEquatorialRadiusInMetres

constexpr int32_t CartoType::KEquatorialRadiusInMetres = 6378137
constexpr

A factor to convert radians to metres for the Mercator and other projections. It is the semi-major axis (equatorial radius) used by the WGS 84 datum (see http://en.wikipedia.org/wiki/WGS84).

◆ KErrorAlertMessage

constexpr TResult CartoType::KErrorAlertMessage = 44
constexpr

A code for standard alert messages.

◆ KErrorAlreadyProjected

constexpr TResult CartoType::KErrorAlreadyProjected = 30
constexpr

There was an attempt to project a map object that had already been projected.

◆ KErrorCancel

constexpr TResult CartoType::KErrorCancel = 14
constexpr

The code KErrorCancel is returned to cancel an asynchronous operation that uses callbacks. The callback or virtual function returns this code. the caller must terminate further processing on receipt of any error, but this one indicates that there has been no actual error, but the handler has canceled the operation.

◆ KErrorConditionsTooDeeplyNested

constexpr TResult CartoType::KErrorConditionsTooDeeplyNested = 31
constexpr

Conditions are too deeply nested in the style sheet.

◆ KErrorCorrupt

constexpr TResult CartoType::KErrorCorrupt = 10
constexpr

Use KErrorCorrupt when illegal values are found when reading data from a file or other serialized form.

◆ KErrorCriticalMessage

constexpr TResult CartoType::KErrorCriticalMessage = 45
constexpr

A code for standard critical messages.

◆ KErrorDebugMessage

constexpr TResult CartoType::KErrorDebugMessage = 50
constexpr

A code for standard debug messages.

◆ KErrorDivideByZero

constexpr TResult CartoType::KErrorDivideByZero = 34
constexpr

Division by zero in an interpreted expression.

◆ KErrorDuplicate

constexpr TResult CartoType::KErrorDuplicate = 23
constexpr

An attempt was made to insert a duplicate object into a collection class that does not allow duplicates.

◆ KErrorEmergencyMessage

constexpr TResult CartoType::KErrorEmergencyMessage = 43
constexpr

A code for standard emergency messages.

◆ KErrorEncryptionKeyTooShort

constexpr TResult CartoType::KErrorEncryptionKeyTooShort = 41
constexpr

A key supplied for encryption was too short.

◆ KErrorEndOfData

constexpr TResult CartoType::KErrorEndOfData = 3
constexpr

KErrorEndOfData is returned by iterators and streams when no more data is available. It may be treated as an error or not depending on the circumstances.

◆ KErrorErrorMessage

constexpr TResult CartoType::KErrorErrorMessage = 46
constexpr

A code for standard error messages.

◆ KErrorFontNotFound

constexpr TResult CartoType::KErrorFontNotFound = 64
constexpr

A font file was not found.

◆ KErrorFrameworkAlreadyExists

constexpr TResult CartoType::KErrorFrameworkAlreadyExists = 53
constexpr

The global framework object already exists.

◆ KErrorGeneral

constexpr TResult CartoType::KErrorGeneral = 1
constexpr

Use KErrorGeneral where an error has occurred but no other CartoType error is applicable. For example, this error code can be used when FreeType returns an error code for illegal TrueType hinting instructions.

◆ KErrorInfoMessage

constexpr TResult CartoType::KErrorInfoMessage = 49
constexpr

A code for standard information messages.

◆ KErrorInternetIo

constexpr TResult CartoType::KErrorInternetIo = 33
constexpr

An attempt to read data from the internet failed.

◆ KErrorInterrupt

constexpr TResult CartoType::KErrorInterrupt = 39
constexpr

An operation was interrupted, for example by another thread writing to a shared flag.

◆ KErrorInvalidArgument

constexpr TResult CartoType::KErrorInvalidArgument = 15
constexpr

This error is returned when an invalid argument has been given to a function.

◆ KErrorInvalidDashArray

constexpr TResult CartoType::KErrorInvalidDashArray = 26
constexpr

The dash array for drawing strokes is invalid.

◆ KErrorInvalidOutline

constexpr TResult CartoType::KErrorInvalidOutline = 8
constexpr

If the graphics system detects an invalid outline, such as one that starts with a cubic control point, it returns KErrorInvalidOutline.

◆ KErrorIo

constexpr TResult CartoType::KErrorIo = 9
constexpr

The code KErrorIo should be used for unexpected read or write errors on files or other data streams. This is for where you attempt to read data that should be there, but the OS says it's unavailable (e.g., someone has taken the CD out of the drive or the network is down).

◆ KErrorJpgRead

constexpr TResult CartoType::KErrorJpgRead = 37
constexpr

Reading a bitmap from JPG format failed.

◆ KErrorMapDataBaseFormatMismatch

constexpr TResult CartoType::KErrorMapDataBaseFormatMismatch = 40
constexpr

There was an attempt to use map databases of incompatible formats (TMapGrid values containing point format, datum and axis orientations) to draw a map or find objects in a map.

◆ KErrorMapNotFound

constexpr TResult CartoType::KErrorMapNotFound = 63
constexpr

A map file was not found.

◆ KErrorNoEncryptionKey

constexpr TResult CartoType::KErrorNoEncryptionKey = 42
constexpr

No encryption key has been set.

◆ KErrorNoFramework

constexpr TResult CartoType::KErrorNoFramework = 52
constexpr

The global framework object does not exist.

◆ KErrorNoIntersection

constexpr TResult CartoType::KErrorNoIntersection = 38
constexpr

An object did not intersect a specified region.

◆ KErrorNoInverse

constexpr TResult CartoType::KErrorNoInverse = 12
constexpr

This error is returned by transformation inversion if the transformation has no inverse.

◆ KErrorNoMemory

constexpr TResult CartoType::KErrorNoMemory = 2
constexpr

Use KErrorNoMemory when an attempted memory allocation fails.

◆ KErrorNone

constexpr TResult CartoType::KErrorNone = 0
constexpr

No error; a successful result.

◆ KErrorNoPalette

constexpr TResult CartoType::KErrorNoPalette = 22
constexpr

An attempt was made to draw a bitmap needing a color palette but no palette was provided.

◆ KErrorNoProjection

constexpr TResult CartoType::KErrorNoProjection = 24
constexpr

The projection for converting latitude and longitude to map coordinates is unknown or unavailable.

◆ KErrorNoRoadsNearEndOfRoute

constexpr TResult CartoType::KErrorNoRoadsNearEndOfRoute = 60
constexpr

No route could be created because there were no roads near the end point of a route section.

◆ KErrorNoRoadsNearStartOfRoute

constexpr TResult CartoType::KErrorNoRoadsNearStartOfRoute = 59
constexpr

No route could be created because there were no roads near the start point of a route section.

◆ KErrorNoRoute

constexpr TResult CartoType::KErrorNoRoute = 28
constexpr

A route was needed by the navigation system but no route was available.

◆ KErrorNoRouteConnectivity

constexpr TResult CartoType::KErrorNoRouteConnectivity = 61
constexpr

No route could be created because the start and end point were not connected.

◆ KErrorNotFound

constexpr TResult CartoType::KErrorNotFound = 6
constexpr

KErrorNotFound is returned whenever a resource like a file is not found, or a search fails. It may be treated as an error or not depending on the circumstances.

◆ KErrorNoticeMessage

constexpr TResult CartoType::KErrorNoticeMessage = 48
constexpr

A code for standard notice messages.

◆ KErrorNotNavigating

constexpr TResult CartoType::KErrorNotNavigating = 51
constexpr

A function has been called which is available only when navigating.

◆ KErrorNullFont

constexpr TResult CartoType::KErrorNullFont = 32
constexpr

There was an attempt to use a null font for drawing text.

◆ KErrorOverflow

constexpr TResult CartoType::KErrorOverflow = 17
constexpr

This error is returned by the base library when reading data or calculations result in overflow.

◆ KErrorPaletteFull

constexpr TResult CartoType::KErrorPaletteFull = 25
constexpr

A palette is full and no new entries can be added.

◆ KErrorParallelLines

constexpr TResult CartoType::KErrorParallelLines = 19
constexpr

The error code returned by line intersection algorithms when the lines are parallel.

◆ KErrorPngRead

constexpr TResult CartoType::KErrorPngRead = 36
constexpr

Reading a bitmap from PNG format failed.

◆ KErrorPngWrite

constexpr TResult CartoType::KErrorPngWrite = 55
constexpr

Writing a bitmap to PNG format failed.

◆ KErrorProj4

constexpr TResult CartoType::KErrorProj4 = 57
constexpr

There was an error in the PROJ.4 projection library error other than a projection overflow.

◆ KErrorProjectionOverflow

constexpr TResult CartoType::KErrorProjectionOverflow = 13
constexpr

This error is returned by the projection system if the projection causes overflow.

◆ KErrorReadOnlyMapDataBase

constexpr TResult CartoType::KErrorReadOnlyMapDataBase = 56
constexpr

There was an attempt to write to a read-only map database.

◆ KErrorSQLite

constexpr uint32_t CartoType::KErrorSQLite = 0x30000000
constexpr

The base of error codes for returning SQLite errors. The SQLite error code is placed in the lower two bytes.

◆ KErrorStyleSheetNotFound

constexpr TResult CartoType::KErrorStyleSheetNotFound = 65
constexpr

A style sheet was not found.

◆ KErrorTextTruncated

constexpr TResult CartoType::KErrorTextTruncated = 5
constexpr

KErrorTextTruncated is returned when text inserted into a string derived from MString is too long for a fixed-size buffer.

◆ KErrorTextUnmodifiable

constexpr TResult CartoType::KErrorTextUnmodifiable = 4
constexpr

KErrorTextUnmodifiable is returned when an attempt is made to modify an unmodifiable string represented by a class derived from MString.

◆ KErrorTransformFailed

constexpr TResult CartoType::KErrorTransformFailed = 35
constexpr

A transform failed because an argument or result was out of range.

◆ KErrorUnimplemented

constexpr TResult CartoType::KErrorUnimplemented = 7
constexpr

The code KErrorUnimplemented is used for functions that have not yet been implemented, or for circumstances or options within functions that remain unimplemented because they are deemed to be either rarely or never useful.

◆ KErrorUnknownDataFormat

constexpr TResult CartoType::KErrorUnknownDataFormat = 11
constexpr

This error is returned by database accessors, typeface accessors, etc., to indicate that this data format is unknown to a particular accessor. It is not really an error but tells the caller to try the next accessor in the list.

◆ KErrorUnknownVersion

constexpr TResult CartoType::KErrorUnknownVersion = 16
constexpr

This error is returned by a data reader when it cannot deal with the data version.

◆ KErrorUnlicensed

constexpr TResult CartoType::KErrorUnlicensed = 58
constexpr

A function was called from the unlicensed version of CartoType that is available only in the licensed version.

◆ KErrorUntransliterable

constexpr TResult CartoType::KErrorUntransliterable = 54
constexpr

A string was not transliterable.

◆ KErrorWarningMessage

constexpr TResult CartoType::KErrorWarningMessage = 47
constexpr

A code for standard warning messages.

◆ KErrorXmlFeatureNotSupported

constexpr TResult CartoType::KErrorXmlFeatureNotSupported = 62
constexpr

An unsupported feature was requested from the XML parser.

◆ KErrorXmlRangeEnd

constexpr TResult CartoType::KErrorXmlRangeEnd = 0x2AFFFFFF
constexpr

The end of the range of errors in XML parsing or in the style sheet format.

◆ KErrorXmlRangeStart

constexpr TResult CartoType::KErrorXmlRangeStart = 0x10000000
constexpr

The start of the range of errors in XML parsing or in the style sheet format, such as a syntactically incorrect dimension or color. The top byte is 0x10 for style sheet errors, or in the range 0x11 to 0x2A for Expat XML parser error codes.

The low three bytes give the error location: one byte for the column number (clamped to 0...255) two bytes for the line number (clamped to 0...65535).

◆ KErrorZoomLimitReached

constexpr TResult CartoType::KErrorZoomLimitReached = 29
constexpr

There was an attempt to zoom beyond the legal zoom limits for a map.

◆ KEthiopicScript

const uint32_t CartoType::KEthiopicScript = 0x400000

A bit flag used in typeface matching: the Ethiopic script.

◆ KFantasyStyle

const uint32_t CartoType::KFantasyStyle = 16

The bit flag used to select a 'fantasy' font (as defined in http://www.w3.org/TR/REC-CSS2/fonts.html#generic-font-families) in TTypefaceAttrib::Style, etc.

◆ KFollowFlagHeading

constexpr uint32_t CartoType::KFollowFlagHeading = 2
constexpr

A flag to rotate the map to the user's heading.

◆ KFollowFlagLocation

constexpr uint32_t CartoType::KFollowFlagLocation = 1
constexpr

A flag to make the center of the map follow the user's location.

◆ KFollowFlagZoom

constexpr uint32_t CartoType::KFollowFlagZoom = 4
constexpr

A flag to set the map to a suitable zoom level for the user's speed.

◆ KGeorgianScript

const uint32_t CartoType::KGeorgianScript = 0x100000

A bit flag used in typeface matching: the Georgian script.

◆ KGray

const uint32_t CartoType::KGray = KGrey

Opaque gray.

◆ KGreekScript

const uint32_t CartoType::KGreekScript = 2

A bit flag used in typeface matching: the Greek script.

◆ KGreen

const uint32_t CartoType::KGreen = 0xFF00FF00

Opaque green.

◆ KGrey

const uint32_t CartoType::KGrey = 0xFFAAAAAA

Opaque grey.

◆ KGujaratiScript

const uint32_t CartoType::KGujaratiScript = 0x200

A bit flag used in typeface matching: the Gujarati script.

◆ KGurmukhiScript

const uint32_t CartoType::KGurmukhiScript = 0x100

A bit flag used in typeface matching: the Gurmukhi script.

◆ KHangulScript

const uint32_t CartoType::KHangulScript = 0x200000

A bit flag used in typeface matching: the Hangul script.

◆ KHanScript

const uint32_t CartoType::KHanScript = 0x10000000

A bit flag used in typeface matching: the Han script.

◆ KHebrewScript

const uint32_t CartoType::KHebrewScript = 0x10

A bit flag used in typeface matching: the Hebrew script.

◆ KHiraganaScript

const uint32_t CartoType::KHiraganaScript = 0x2000000

A bit flag used in typeface matching: the Japanese Hiragana script.

◆ KItalicStyle

const uint32_t CartoType::KItalicStyle = 2

The bit flag used to select italics in styles in TTypefaceAttrib::Style, etc.

◆ KKannadaScript

const uint32_t CartoType::KKannadaScript = 0x2000

A bit flag used in typeface matching: the Kannada script.

◆ KKatakanaScript

const uint32_t CartoType::KKatakanaScript = 0x4000000

A bit flag used in typeface matching: the Japanese Katakana script.

◆ KKhmerScript

const uint32_t CartoType::KKhmerScript = 0x800000

A bit flag used in typeface matching: the Khmer script.

◆ KLaoScript

const uint32_t CartoType::KLaoScript = 0x20000

A bit flag used in typeface matching: the Lao script.

◆ KLatinScript

const uint32_t CartoType::KLatinScript = 1

A bit flag used in typeface matching: the Latin script.

◆ KLowerTitleCase

constexpr int CartoType::KLowerTitleCase = 1
constexpr

A constant for the title case dictionary passed to MString::SetCase. When setting text to title case, do not capitalize the first letter unless the word is initial. Used for particles like 'on', 'of', etc. and their upper-case variants.

◆ KMagenta

const uint32_t CartoType::KMagenta = 0xFFFF00FF

Opaque magenta.

◆ KMalayalamScript

const uint32_t CartoType::KMalayalamScript = 0x4000

A bit flag used in typeface matching: the Malayalam script.

◆ KMaxLabelLength

constexpr int32_t CartoType::KMaxLabelLength = 1024
constexpr

The maximum length for a map label in characters. The large size allows the use of complex multi-line labels. There has to be a fixed maximum length because of the fixed size of the glyph cache (see CEngine::EGlyphLogEntries).

◆ KMaxScaleDenominator

constexpr double CartoType::KMaxScaleDenominator = 1000000000
constexpr

The maximum legal map scale denominator.

◆ KMinScaleDenominator

constexpr double CartoType::KMinScaleDenominator = 100
constexpr

The minimum legal map scale denominator.

◆ KMongolianScript

const uint32_t CartoType::KMongolianScript = 0x1000000

A bit flag used in typeface matching: the Mongolian script.

◆ KMonospaceStyle

const uint32_t CartoType::KMonospaceStyle = 32

The bit flag used to select a monospace font in TTypefaceAttrib::Style, etc.

◆ KMyanmarScript

const uint32_t CartoType::KMyanmarScript = 0x80000

A bit flag used in typeface matching: the Myanmar script.

◆ KOriyaScript

const uint32_t CartoType::KOriyaScript = 0x400

A bit flag used in typeface matching: the Oriya script.

◆ KOtherScript

const uint32_t CartoType::KOtherScript = 0x80000000

A bit flag used in typeface matching: other scripts.

◆ KPiDouble

constexpr double CartoType::KPiDouble = 3.1415926535897932384626433832795
constexpr

The value of pi as a double-precision floating-point number.

◆ KPiFloat

constexpr float CartoType::KPiFloat = 3.1415926535897932384626433832795f
constexpr

The value of pi as a single-precision floating-point number.

◆ KRadiansToDegreesDouble

constexpr double CartoType::KRadiansToDegreesDouble = 180.0 / KPiDouble
constexpr

A factor to convert radians to degrees: the number of degrees in a radian.

◆ KRadiansToMetres

constexpr double CartoType::KRadiansToMetres = KEquatorialRadiusInMetres
constexpr

A factor to convert radians to metres for the Mercator and other projections. It is the semi-major axis (equatorial radius) used by the WGS 84 datum (see http://en.wikipedia.org/wiki/WGS84). A synonym of KEquatorialRadiusInMetres.

◆ KRed

const uint32_t CartoType::KRed = 0xFF0000FF

Opaque red.

◆ KReservedScript

const uint32_t CartoType::KReservedScript = 0x20000000

A bit flag used in typeface matching: this value is reserved and must not be used.

◆ KScaledDegreesToMetres

constexpr double CartoType::KScaledDegreesToMetres = KDegreesToMetres / 2097152.0
constexpr

A factor to convert scaled degrees, represented in 11.21 fixed-point format, to metres, using the semi-major axis (equatorial radius) used by the WGS 84 datum.

◆ KSerifStyle

const uint32_t CartoType::KSerifStyle = 4

The bit flag used to select a serif font in TTypefaceAttrib::Style, etc.

◆ KSinhalaScript

const uint32_t CartoType::KSinhalaScript = 0x8000

A bit flag used in typeface matching: the Sinhala script.

◆ KStandardErrorCodeCount

constexpr int32_t CartoType::KStandardErrorCodeCount = 66
constexpr

The number of standard error codes.

◆ KStandardTitleCase

constexpr int CartoType::KStandardTitleCase = 0
constexpr

A constant for the title case dictionary passed to MString::SetCase. No special title case treatment. This constant must be zero.

◆ KSymbolScript

const uint32_t CartoType::KSymbolScript = 0x40000000

A bit flag used in typeface matching: Symbols and other non-alphabetic characters.

◆ KTamilScript

const uint32_t CartoType::KTamilScript = 0x800

A bit flag used in typeface matching: the Tamil script.

◆ KTeluguScript

const uint32_t CartoType::KTeluguScript = 0x1000

A bit flag used in typeface matching: the Telugu script.

◆ KThaiScript

const uint32_t CartoType::KThaiScript = 0x10000

A bit flag used in typeface matching: the Thai script.

◆ KTibetanScript

const uint32_t CartoType::KTibetanScript = 0x40000

A bit flag used in typeface matching: the Tibetan script.

◆ KTransparentBlack

const uint32_t CartoType::KTransparentBlack = 0x00000000

The 'null color' transparent black.

◆ KUpperTitleCase

constexpr int CartoType::KUpperTitleCase = 2
constexpr

A constant for the title case dictionary passed to MString::SetCase. When setting text to title case, leave these strings as they are (they are already upper-case). Used for acronyms like US, roman numerals like II, etc.

◆ KWGS84Flattening

constexpr double CartoType::KWGS84Flattening = 1.0 / 298.257223563
constexpr

The flattening constant used by the WGS84 reference ellipsoid.

◆ KWhite

const uint32_t CartoType::KWhite = 0xFFFFFFFF

Opaque white.

◆ KYellow

const uint32_t CartoType::KYellow = 0xFF00FFFF

Opaque yellow.