CartoType C++ API 8.2-50-g007fde5ee
for Windows, Linux, Qt and other platforms supporting C++ development
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
CartoTypeCore Namespace Reference

Namespaces

namespace  CharCategoryFlag
 
namespace  TransformType
 

Classes

class  Abbreviation
 
class  AbbreviationDictionary
 
class  AbbreviationInfo
 
class  AbbreviationTableEntry
 
class  Address
 
class  AffineTransform
 
class  BidiEngine
 
class  BidiRun
 
class  BinaryInputFile
 
class  Bitmap
 
class  BitmapTexture
 
class  BitmapView
 
class  BlendStyle
 
class  BlendStyleSet
 
class  CameraParam
 
class  Char
 
class  CircularPen
 
class  ClipRegion
 
class  Color
 
class  Contour
 
class  ContourBase
 
class  ContourFP
 
class  ContourView
 
class  ContourViewFP
 
class  CoordPair
 
class  CoordSet
 
class  CoordSetOfTwoPoints
 
class  CRCGenerator
 
class  DashArray
 
class  DataInputStream
 
class  DataOutputStream
 
class  DataStream
 
class  DataVersion
 
class  ExtendedNoticePosition
 
class  FeatureInfo
 
class  FileInputStream
 
class  FileLocation
 
class  FileOutputStream
 
class  FindNearbyParam
 
class  FindParam
 
class  FixedSizeContour
 
class  FixedSizeContourFP
 
class  FoldingIterator
 
class  Font
 
class  FontMetrics
 
class  FontSpec
 
class  Framework
 
class  FrameworkEngine
 
class  FrameworkMapDataSet
 
class  GeneralGeometry
 
class  GeoCodeItem
 
class  Geometry
 
class  GraphicsContext
 
class  GraphicsParam
 
class  HachureParam
 
class  IntersectionType
 
class  Legend
 
class  Line
 
class  LineFP
 
class  List
 
class  ListBase
 
class  ListLink
 
class  LocationMatchParam
 
class  LocationRef
 
class  MapMetaData
 
class  MapObject
 
class  MapObjectGroup
 
class  MapObjectMatch
 
class  MapRenderer
 
class  MapTableType
 
class  MContour
 
class  MDictionary
 
class  MemoryInputStream
 
class  MemoryOutputStream
 
class  MInputStream
 
class  MIter
 
class  MLabelHandler
 
class  MNavigatorObserver
 
class  MOutputStream
 
class  MPath
 
class  MPointerDictionary
 
class  MPointTransformer
 
class  MString
 
class  MUserData
 
class  MWritableContour
 
class  NavigationData
 
class  NavigatorParam
 
class  NavigatorTurn
 
class  NearestRoadInfo
 
class  NearestSegmentInfo
 
class  OnCurveContour
 
class  OpenFileOutputStream
 
class  Outline
 
class  OutlinePoint
 
class  OutlinePointFP
 
class  Paint
 
class  PaintServer
 
class  Palette
 
class  PathIntersectionInfo
 
class  PathIterator
 
class  PathToJunction
 
class  Pattern
 
class  PerspectiveParam
 
class  Point
 
class  Point2
 
class  Point3
 
class  PointerList
 
class  PolygonFP
 
class  PositionedBitmap
 
class  Rect
 
class  RectFP
 
class  RefCountedString
 
class  Result
 
class  Route
 
class  RouteCoordSet
 
class  RouteCreationData
 
class  RouteIterator
 
class  RoutePoint
 
class  RouteProfile
 
class  RouteSegment
 
class  SimpleContourData
 
class  SimpleFileInputStream
 
class  String
 
class  StringMatchMethod
 
class  StyleSheetData
 
class  Tag
 
class  Text
 
class  TextBoxStyle
 
class  TextBuffer
 
class  TextMetrics
 
class  TextParam
 
class  Texture
 
class  TileBitmapParam
 
class  TimeAndDistanceMatrix
 
class  TrackPoint
 
class  TrafficInfo
 
class  Transform3D
 
class  TransformComponents
 
class  Turn
 
class  TypefaceAttrib
 
class  TypefaceData
 
class  TypefaceInstance
 
union  UserData
 
class  Utf16ToUtf32
 
class  Utf32Iter
 
class  Utf8ToUtf32
 
class  VehicleType
 
class  ViewState
 
class  WritableContourView
 
class  WritableCoordSet
 
class  WritableTextView
 

Typedefs

using StreetAddressSearchState = std::unique_ptr< StreetAddressSearchStateImplementation >
 
using PointFP = Point2< double >
 
using Point3FP = Point3< double >
 
using MapObjectArray = std::vector< std::unique_ptr< MapObject > >
 
using FindHandler = std::function< bool(std::unique_ptr< MapObject >)>
 
using FindAsyncCallBack = std::function< void(std::unique_ptr< MapObjectArray > aMapObjectArray)>
 
using FindAsyncGroupCallBack = std::function< void(std::unique_ptr< MapObjectGroupArray > aMapObjectGroupArray)>
 
using RouterAsyncCallBack = std::function< void(Result aError, std::unique_ptr< Route > aRoute)>
 
using TrackGeometry = GeneralGeometry< TrackPoint >
 
using MapObjectGroupArray = std::vector< MapObjectGroup >
 
using StringDictionary = std::map< String, String >
 
using StringTypeDictionary = std::map< String, int >
 
using StyleSheetDataArray = std::vector< StyleSheetData >
 

Enumerations

enum class  AddressPart {
  Building , Feature , Street , SubLocality ,
  Locality , Island , SubAdminArea , AdminArea ,
  Country , PostCode
}
 
enum class  GeoCodeType {
  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  IntersectionPlace { None = 0 , Before , On , After }
 
enum class  CoordType {
  Degree , Display , Screen = Display , Map ,
  MapMeter
}
 
enum class  PointType { OnCurve , Quadratic , Cubic }
 
enum class  FileType {
  PNG , JPEG , TIFF , CTM1 ,
  CTMS , KML , CTSQL , CTROUTE ,
  GPX , None = -1
}
 
enum class  WritableMapType { Memory , SQLite , Count , None = -1 }
 
enum class  MapObjectType {
  Point , Line , Polygon , Array ,
  Count , None = -1
}
 
enum class  VectorTileObjectClipType { Standard , Fill , Border , Highlight = 0x10000 }
 
enum class  NoticePosition {
  TopLeft , TopRight , BottomLeft , BottomRight ,
  Top , Right , Left , Bottom ,
  Center
}
 
enum class  BidiOverride { Neutral , LeftToRight , RightToLeft }
 
enum class  BidiParDir { LeftToRightPreferred , RightToLeftPreferred , LeftToRightForced , RightToLeftForced }
 
enum class  BitmapType {
  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  LetterCase { None , Lower , Upper , Title }
 
enum class  CharCategory {
  Lu = CharCategoryFlag::Lu , Ll = CharCategoryFlag::Ll , Lt = CharCategoryFlag::Lt , Lm = CharCategoryFlag::Lm ,
  Lo = CharCategoryFlag::Lo , Mn = CharCategoryFlag::Mn , Mc = CharCategoryFlag::Mc , Me = CharCategoryFlag::Me ,
  Nd = CharCategoryFlag::Nd , Nl = CharCategoryFlag::Nl , No = CharCategoryFlag::No , Pc = CharCategoryFlag::Pc ,
  Pd = CharCategoryFlag::Pd , Ps = CharCategoryFlag::Ps , Pe = CharCategoryFlag::Pe , Pi = CharCategoryFlag::Pi ,
  Pf = CharCategoryFlag::Pf , Po = CharCategoryFlag::Po , Sm = CharCategoryFlag::Sm , Sc = CharCategoryFlag::Sc ,
  Sk = CharCategoryFlag::Sk , So = CharCategoryFlag::So , Zs = CharCategoryFlag::Zs , Zl = CharCategoryFlag::Zl ,
  Zp = CharCategoryFlag::Zp , Cc = CharCategoryFlag::Cc , Cf = CharCategoryFlag::Cf , Cs = CharCategoryFlag::Cs ,
  Co = CharCategoryFlag::Co , Cn = CharCategoryFlag::Cn
}
 
enum class  BidiType {
  L = BidiTypeFlag::L , LRE = BidiTypeFlag::LRE , LRO = BidiTypeFlag::LRO , R = BidiTypeFlag::R ,
  AL = BidiTypeFlag::AL , RLE = BidiTypeFlag::RLE , RLO = BidiTypeFlag::RLO , PDF = BidiTypeFlag::PDF ,
  EN = BidiTypeFlag::EN , ES = BidiTypeFlag::ES , ET = BidiTypeFlag::ET , AN = BidiTypeFlag::AN ,
  CS = BidiTypeFlag::CS , NSM = BidiTypeFlag::NSM , BN = BidiTypeFlag::BN , B = BidiTypeFlag::B ,
  S = BidiTypeFlag::S , WS = BidiTypeFlag::WS , ON = BidiTypeFlag::ON
}
 
enum class  DrawResult {
  Success , OverlapText , OverlapEdge , MaxTurnExceeded ,
  PathLengthExceeded , GlyphNotFound , TransformFailed
}
 
enum class  FeatureType : uint16_t {
  Motorway = 0 , MotorwayLink = 1 , TrunkRoad = 2 , TrunkLink = 3 ,
  PrimaryRoad = 4 , PrimaryLink = 5 , SecondaryRoad = 6 , SecondaryLink = 7 ,
  TertiaryRoad = 8 , UnclassifiedRoad = 9 , ResidentialRoad = 10 , Track = 11 ,
  ServiceRoad = 12 , PedestrianRoad = 13 , VehicularFerry = 14 , PassengerFerry = 15 ,
  LivingStreet = 16 , Cycleway = 17 , Path = 18 , Footway = 19 ,
  Bridleway = 20 , Steps = 21 , OtherRoad = 22 , UnpavedRoad = 23 ,
  Railway = 24 , LightRail = 25 , Subway = 26 , AerialWay = 27 ,
  SkiDownhill = 28 , SkiNordic = 29 , Waterway = 30 , UnknownRoute = 31 ,
  UnknownNonRoute = 32 , AdminArea1 = FeatureTypeCode('a','a','a') , AdminArea2 = FeatureTypeCode('a','a','b') , AdminArea3 = FeatureTypeCode('a','a','c') ,
  AdminArea4 = FeatureTypeCode('a','a','d') , AdminArea5 = FeatureTypeCode('a','a','e') , AdminArea6 = FeatureTypeCode('a','a','f') , AdminArea7 = FeatureTypeCode('a','a','g') ,
  AdminArea8 = FeatureTypeCode('a','a','h') , AdminArea9 = FeatureTypeCode('a','a','i') , AdminArea10 = FeatureTypeCode('a','a','j') , Address = FeatureTypeCode('a','d','d') ,
  Aerodrome = FeatureTypeCode('a','e','r') , Airport = FeatureTypeCode('a','i','r') , AirportGate = FeatureTypeCode('a','g','t') , AirportHoldingPosition = FeatureTypeCode('a','h','p') ,
  Allotments = FeatureTypeCode('a','l','l') , AlpineHut = FeatureTypeCode('a','l','p') , AmbulanceStation = FeatureTypeCode('a','m','b') , Apron = FeatureTypeCode('a','p','r') ,
  AerialWayPylon = FeatureTypeCode('a','p','y') , Artwork = FeatureTypeCode('a','r','t') , AerialWayStation = FeatureTypeCode('a','s','t') , AirTerminal = FeatureTypeCode('a','t','e') ,
  Atm = FeatureTypeCode('a','t','m') , Attraction = FeatureTypeCode('a','t','t') , Bar = FeatureTypeCode('b','a','r') , Basin = FeatureTypeCode('b','a','s') ,
  Bay = FeatureTypeCode('b','a','y') , Beach = FeatureTypeCode('b','e','a') , Beacon = FeatureTypeCode('b','e','c') , BedAndBreakfast = FeatureTypeCode('b','e','d') ,
  Bench = FeatureTypeCode('b','e','n') , Bank = FeatureTypeCode('b','n','k') , Boatyard = FeatureTypeCode('b','o','a') , Borough = FeatureTypeCode('b','o','r') ,
  Boundary = FeatureTypeCode('b','o','u') , BicycleParking = FeatureTypeCode('b','p','k') , BicycleRental = FeatureTypeCode('b','r','e') , BareRock = FeatureTypeCode('b','r','c') ,
  Barracks = FeatureTypeCode('b','r','k') , BrownField = FeatureTypeCode('b','r','o') , BusStop = FeatureTypeCode('b','s','p') , BusStation = FeatureTypeCode('b','s','t') ,
  BufferStop = FeatureTypeCode('b','u','f') , Building = FeatureTypeCode('b','u','i') , Bunker = FeatureTypeCode('b','u','n') , Cabin = FeatureTypeCode('c','a','b') ,
  Cafe = FeatureTypeCode('c','a','f') , CampSite = FeatureTypeCode('c','a','m') , Canal = FeatureTypeCode('c','a','n') , CaveEntrance = FeatureTypeCode('c','a','v') ,
  CableCar = FeatureTypeCode('c','c','r') , CableDistributionCabinet = FeatureTypeCode('c','d','c') , Cemetery = FeatureTypeCode('c','e','m') , ChairLift = FeatureTypeCode('c','h','a') ,
  CheckPoint = FeatureTypeCode('c','h','e') , Chalet = FeatureTypeCode('c','h','l') , CivilBoundary = FeatureTypeCode('c','i','b') , Cinema = FeatureTypeCode('c','i','n') ,
  City = FeatureTypeCode('c','i','t') , Cliff = FeatureTypeCode('c','l','f') , Clinic = FeatureTypeCode('c','l','i') , Commercial = FeatureTypeCode('c','m','r') ,
  Coastline = FeatureTypeCode('c','o','a') , College = FeatureTypeCode('c','o','l') , Common = FeatureTypeCode('c','o','m') , Construction = FeatureTypeCode('c','n','s') ,
  Conservation = FeatureTypeCode('c','n','v') , Continent = FeatureTypeCode('c','o','n') , County = FeatureTypeCode('c','o','u') , CarPark = FeatureTypeCode('c','p','k') ,
  CarRental = FeatureTypeCode('c','r','e') , Crossing = FeatureTypeCode('c','r','o') , Country = FeatureTypeCode('c','r','y') , CarSharing = FeatureTypeCode('c','s','h') ,
  CutLine = FeatureTypeCode('c','u','t') , CarWash = FeatureTypeCode('c','w','a') , CaravanSite = FeatureTypeCode('c','v','n') , CyclingRoute = FeatureTypeCode('c','y','r') ,
  Dam = FeatureTypeCode('d','a','m') , DangerArea = FeatureTypeCode('d','a','n') , Dentist = FeatureTypeCode('d','e','n') , Disused = FeatureTypeCode('d','i','s') ,
  Ditch = FeatureTypeCode('d','i','t') , Dock = FeatureTypeCode('d','o','c') , DogPark = FeatureTypeCode('d','o','g') , Drain = FeatureTypeCode('d','r','a') ,
  DragLift = FeatureTypeCode('d','r','g') , Doctors = FeatureTypeCode('d','r','s') , District = FeatureTypeCode('d','s','t') , ElectricVehicleCharging = FeatureTypeCode('e','v','c') ,
  Farm = FeatureTypeCode('f','a','r') , FarmYard = FeatureTypeCode('f','a','y') , Fell = FeatureTypeCode('f','e','l') , FerryTerminal = FeatureTypeCode('f','e','t') ,
  FastFood = FeatureTypeCode('f','f','d') , FireExtinguisher = FeatureTypeCode('f','i','e') , FireFlapper = FeatureTypeCode('f','i','f') , FireHose = FeatureTypeCode('f','i','h') ,
  FireStation = FeatureTypeCode('f','i','s') , FitnessStation = FeatureTypeCode('f','i','t') , FireHydrant = FeatureTypeCode('f','i','y') , Forestry = FeatureTypeCode('f','o','r') ,
  Fishing = FeatureTypeCode('f','s','h') , Fuel = FeatureTypeCode('f','u','e') , Funicular = FeatureTypeCode('f','u','n') , Garages = FeatureTypeCode('g','a','r') ,
  Gate = FeatureTypeCode('g','a','t') , Garden = FeatureTypeCode('g','d','n') , Generator = FeatureTypeCode('g','e','n') , GreenHouse = FeatureTypeCode('g','h','o') ,
  Glacier = FeatureTypeCode('g','l','a') , GolfCourse = FeatureTypeCode('g','o','l') , Gondola = FeatureTypeCode('g','o','n') , GoodsAerialWay = FeatureTypeCode('g','o','o') ,
  Grass = FeatureTypeCode('g','r','a') , GreenField = FeatureTypeCode('g','r','e') , GritBin = FeatureTypeCode('g','r','b') , GraveYard = FeatureTypeCode('g','r','y') ,
  GuestHouse = FeatureTypeCode('g','u','e') , Halt = FeatureTypeCode('h','a','l') , Hamlet = FeatureTypeCode('h','a','m') , Hangar = FeatureTypeCode('h','a','n') ,
  Heath = FeatureTypeCode('h','e','a') , Helipad = FeatureTypeCode('h','e','l') , RailwayHalt = FeatureTypeCode('h','l','t') , HikingRoute = FeatureTypeCode('h','i','k') ,
  HorseRiding = FeatureTypeCode('h','o','r') , Hospital = FeatureTypeCode('h','o','s') , Hotel = FeatureTypeCode('h','o','t') , HorseRidingRoute = FeatureTypeCode('h','r','r') ,
  Hostel = FeatureTypeCode('h','s','t') , IceRink = FeatureTypeCode('i','c','e') , Industrial = FeatureTypeCode('i','n','d') , Information = FeatureTypeCode('i','n','f') ,
  Island = FeatureTypeCode('i','s','l') , IsolatedDwelling = FeatureTypeCode('i','s','o') , Junction = FeatureTypeCode('j','c','t') , Kindergarten = FeatureTypeCode('k','i','n') ,
  LandFill = FeatureTypeCode('l','a','n') , Land = FeatureTypeCode('l','n','d') , LevelCrossing = FeatureTypeCode('l','e','v') , Library = FeatureTypeCode('l','i','b') ,
  Locality = FeatureTypeCode('l','o','c') , LockGate = FeatureTypeCode('l','o','k') , MaritimeBoundary = FeatureTypeCode('m','a','b') , Mall = FeatureTypeCode('m','a','l') ,
  Marsh = FeatureTypeCode('m','a','r') , Meadow = FeatureTypeCode('m','e','a') , Military = FeatureTypeCode('m','i','l') , Marina = FeatureTypeCode('m','n','a') ,
  Motel = FeatureTypeCode('m','o','t') , MinorPowerLine = FeatureTypeCode('m','p','l') , MiniatureGolf = FeatureTypeCode('m','r','g') , MiniatureRailway = FeatureTypeCode('m','r','y') ,
  Mud = FeatureTypeCode('m','u','d') , Municipality = FeatureTypeCode('m','u','n') , Museum = FeatureTypeCode('m','u','s') , NatureReserve = FeatureTypeCode('n','a','t') ,
  NationalPark = FeatureTypeCode('n','a','p') , NavalBase = FeatureTypeCode('n','a','v') , Neighborhood = FeatureTypeCode('n','e','i') , NursingHome = FeatureTypeCode('n','u','r') ,
  Orchard = FeatureTypeCode('o','r','c') , PrecisionApproachPathIndicator = FeatureTypeCode('p','a','p') , Park = FeatureTypeCode('p','a','r') , PublicBuilding = FeatureTypeCode('p','b','u') ,
  PostBox = FeatureTypeCode('p','b','x') , PostCode = FeatureTypeCode('p','c','o') , PicnicTable = FeatureTypeCode('p','c','t') , Peak = FeatureTypeCode('p','e','a') ,
  Pharmacy = FeatureTypeCode('p','h','a') , Phone = FeatureTypeCode('p','h','o') , PicnicSite = FeatureTypeCode('p','i','c') , Pier = FeatureTypeCode('p','i','e') ,
  Pipeline = FeatureTypeCode('p','i','p') , ParkingEntrance = FeatureTypeCode('p','k','e') , Parking = FeatureTypeCode('p','k','g') , ParkingSpace = FeatureTypeCode('p','k','s') ,
  PlantNursery = FeatureTypeCode('p','l','a') , Platform = FeatureTypeCode('p','l','f') , PlaceOfWorship = FeatureTypeCode('p','l','w') , Playground = FeatureTypeCode('p','l','y') ,
  PostOffice = FeatureTypeCode('p','o','f') , Police = FeatureTypeCode('p','o','l') , Position = FeatureTypeCode('p','o','s') , ProtectedArea = FeatureTypeCode('p','r','a') ,
  PowerSubStation = FeatureTypeCode('p','s','s') , Pub = FeatureTypeCode('p','u','b') , PowerLine = FeatureTypeCode('p','w','l') , PowerStation = FeatureTypeCode('p','w','s') ,
  Quarry = FeatureTypeCode('q','a','r') , Quarter = FeatureTypeCode('q','r','t') , Range = FeatureTypeCode('r','a','n') , Rapids = FeatureTypeCode('r','a','p') ,
  Recycling = FeatureTypeCode('r','c','y') , RecreationGround = FeatureTypeCode('r','e','c') , Reef = FeatureTypeCode('r','e','e') , Region = FeatureTypeCode('r','e','g') ,
  Retail = FeatureTypeCode('r','e','t') , Ridge = FeatureTypeCode('r','i','j') , River = FeatureTypeCode('r','i','v') , Rock = FeatureTypeCode('r','o','c') ,
  RoundHouse = FeatureTypeCode('r','o','u') , ResidentialArea = FeatureTypeCode('r','s','d') , Restaurant = FeatureTypeCode('r','s','t') , Reservoir = FeatureTypeCode('r','s','v') ,
  Runway = FeatureTypeCode('r','u','n') , Route = FeatureTypeCode('r','u','t') , RiverBank = FeatureTypeCode('r','v','b') , SaltPond = FeatureTypeCode('s','a','l') ,
  Sand = FeatureTypeCode('s','a','n') , Sauna = FeatureTypeCode('s','a','u') , School = FeatureTypeCode('s','c','h') , Scree = FeatureTypeCode('s','c','r') ,
  Scrub = FeatureTypeCode('s','c','b') , Sea = FeatureTypeCode('s','e','a') , StateEmergencyServiceStation = FeatureTypeCode('s','e','s') , Shop = FeatureTypeCode('s','h','o') ,
  SkiRoute = FeatureTypeCode('s','k','r') , Slipway = FeatureTypeCode('s','l','i') , SportsCenter = FeatureTypeCode('s','p','o') , SportsPitch = FeatureTypeCode('s','p','p') ,
  Spring = FeatureTypeCode('s','p','r') , SportsTrack = FeatureTypeCode('s','p','t') , State = FeatureTypeCode('s','t','a') , Stadium = FeatureTypeCode('s','t','m') ,
  RailwayStation = FeatureTypeCode('s','t','n') , Station = FeatureTypeCode('s','t','n') , Stone = FeatureTypeCode('s','t','o') , StopPosition = FeatureTypeCode('s','t','p') ,
  Stream = FeatureTypeCode('s','t','r') , Strait = FeatureTypeCode('s','t','t') , Suburb = FeatureTypeCode('s','u','b') , Supermarket = FeatureTypeCode('s','u','p') ,
  SurveyPoint = FeatureTypeCode('s','u','r') , SubwayEntrance = FeatureTypeCode('s','w','e') , SwimmingPool = FeatureTypeCode('s','w','i') , Tank = FeatureTypeCode('t','a','n') ,
  Taxi = FeatureTypeCode('t','a','x') , Theatre = FeatureTypeCode('t','h','e') , ThemePark = FeatureTypeCode('t','h','p') , Toilet = FeatureTypeCode('t','o','i') ,
  Town = FeatureTypeCode('t','o','w') , TurningCircle = FeatureTypeCode('t','c','i') , TurningPoint = FeatureTypeCode('t','p','t') , Tram = FeatureTypeCode('t','r','a') ,
  Tree = FeatureTypeCode('t','r','e') , TrafficSignals = FeatureTypeCode('t','r','f') , TrackPoint = FeatureTypeCode('t','r','p') , TreeRow = FeatureTypeCode('t','r','r') ,
  TramStop = FeatureTypeCode('t','r','s') , TurnTable = FeatureTypeCode('t','u','r') , Tower = FeatureTypeCode('t','w','r') , Taxiway = FeatureTypeCode('t','w','y') ,
  University = FeatureTypeCode('u','n','i') , VisualApproachSlopeIndicator = FeatureTypeCode('v','a','s') , VillageGreen = FeatureTypeCode('v','i','g') , Village = FeatureTypeCode('v','i','l') ,
  Vineyard = FeatureTypeCode('v','i','n') , ViewPoint = FeatureTypeCode('v','i','w') , Volcano = FeatureTypeCode('v','o','l') , Waterfall = FeatureTypeCode('w','a','f') ,
  WaterPark = FeatureTypeCode('w','a','p') , Water = FeatureTypeCode('w','a','t') , Weir = FeatureTypeCode('w','e','r') , Wetland = FeatureTypeCode('w','e','t') ,
  Windsock = FeatureTypeCode('w','i','s') , WalkingRoute = FeatureTypeCode('w','l','k') , Wood = FeatureTypeCode('w','o','o') , Works = FeatureTypeCode('w','o','r') ,
  Waypoint = FeatureTypeCode('w','p','t') , WaterTower = FeatureTypeCode('w','t','t') , WaterWell = FeatureTypeCode('w','t','w') , Zoo = FeatureTypeCode('z','o','o') ,
  LegacyBridleway = FeatureTypeCode('b','r','i') , LegacyCycleway = FeatureTypeCode('c','y','c') , LegacyFootway = FeatureTypeCode('f','o','o') , LegacyLightRail = FeatureTypeCode('l','i','r') ,
  LegacyMonorail = FeatureTypeCode('m','o','n') , LegacyNarrowGauge = FeatureTypeCode('n','a','r') , LegacyPreservedRailway = FeatureTypeCode('p','r','y') , LegacyRailway = FeatureTypeCode('r','l','y') ,
  LegacySteps = FeatureTypeCode('s','t','e') , LegacySubway = FeatureTypeCode('s','w','y') , LegacyTram = FeatureTypeCode('t','r','a') , Invalid = INT16_MAX
}
 
enum class  FeatureDiscriminator { NonRoute = 0 , BridgeRoute = 1 , TunnelRoute = 2 , Route = 3 }
 
enum class  FollowMode {
  None = 0 , Location = KFollowFlagLocation , LocationHeading = KFollowFlagLocation | KFollowFlagHeading , LocationZoom = KFollowFlagLocation | KFollowFlagZoom ,
  LocationHeadingZoom = KFollowFlagLocation | KFollowFlagHeading | KFollowFlagZoom
}
 
enum class  LineCap { Butt , Round , Square }
 
enum class  LineJoin { Round , Bevel , Miter }
 
enum class  TextBaseline {
  Alphabetic , Ideographic , Hanging , Mathematical ,
  Central , Middle , TextBeforeEdge , TextAfterEdge ,
  CentralCaps
}
 
enum class  Align {
  Center , Standard , Reverse , Left ,
  Right
}
 
enum class  PointFormat { Unknown = 0 , Meter = 2 , ScaledDegree = 7 , Meter32nds = 8 }
 
enum class  RouterType {
  Default , StandardAStar , TurnExpandedAStar , StandardContractionHierarchy ,
  TECH
}
 
enum class  TurnType {
  None , Ahead , BearRight , Right ,
  SharpRight , Around , SharpLeft , Left ,
  BearLeft
}
 
enum class  RoundaboutState { None , Enter , Continue , Exit }
 
enum class  RouteProfileType {
  Drive , Car = Drive , Walk , Cycle ,
  Bicycle = Cycle , Hike , Ski
}
 
enum class  NavigationState {
  None , NoPosition , Turn , OffRoute ,
  ReRouteNeeded , ReRouteDone , TurnRound , Arrival
}
 
enum class  SideOfRoad { None , Right , Left , Both }
 
enum class  RoadOrientation { None , Forwards , Backwards , Both }
 
enum class  LocationRefType {
  Line , GeoCoordinate , PointAlongLine , PointWithAccessPoint ,
  Circle , Rectangle , Polygon , ClosedLine
}
 
enum class  ClipType { Inside , MayIntersectAndHasNoCurves , MayIntersectAndHasCurves }
 
enum class  ClipOperation { Intersection , Union , Difference , Xor }
 
enum class  PathIntersectionType {
  Unknown , Separate , Intersects , Contains ,
  Contained
}
 
enum class  PolygonOrientation { None , Clockwise , Anticlockwise }
 
enum class  EllipseAngleType { Shortest , Longest , Positive , Negative }
 
enum class  StreamEncoding { Utf16 , Utf8 }
 
enum class  StreamEndianness { Big , Little }
 
enum class  AbbreviationType { Any , Start , End , Suffix }
 
enum class  StringMatchMethodFlag {
  Exact = 0 , Prefix = 1 , IgnoreSymbols = 2 , FoldAccents = 4 ,
  Fuzzy = 8 , FoldCase = 16 , IgnoreWhitespace = 32
}
 
enum class  StringMatchType {
  None , Substring , Fuzzy , Phrase ,
  Full
}
 

Functions

int32_t Round (double aValue)
 
double Round (double aValue, int aFractionDigits)
 
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 * Description ()
 
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 CoordSet &aCoordSet) noexcept
 
double SphericalPolylineLength (const CoordSet &aCoordSet) noexcept
 
double SphericalPolygonArea (std::function< const PointFP *()> aNextPoint)
 
double SphericalPolylineLength (std::function< const PointFP *()> aNextPoint)
 
void GetSphericalAreaAndLength (std::function< const PointFP *()> aNextPoint, bool aIsPolyline, double *aArea, double *aLength)
 
void GetSphericalAreaAndLength (const CoordSet &aCoordSet, bool aIsPolyline, double *aArea, double *aLength) noexcept
 
double AzimuthInDegrees (double aLong1, double aLat1, double aLong2, double aLat2) noexcept
 
PointFP PointAtAzimuth (const PointFP &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 >
double InterpolatedValue (const DataType *aDataStart, int32_t aWidth, int32_t aHeight, int32_t aStride, int32_t aChannels, double aX, double aY, int aChannel, int32_t aUnknownValue)
 
std::string ErrorString (uint32_t aErrorCode)
 
uint32_t constexpr FeatureTypeCode (int A, int B, int C)
 
std::string FeatureTypeName (FeatureType aType)
 
FeatureType FeatureTypeFromName (const MString &aName)
 
bool FeatureTypeIsRoad (FeatureType aType)
 
bool FeatureTypeIsCity (FeatureType aType)
 
bool FeatureTypeIsPOI (FeatureType aType)
 
bool FeatureTypeIsPath (FeatureType aType)
 
bool FeatureTypeIsLink (FeatureType aType)
 
FeatureType MajorRouteType (FeatureType aType)
 
const char * GradientName (int aGradient)
 
uint32_t GradientCode (int16_t aStartHeight, int16_t aEndHeight, int32_t aDistance)
 
uint32_t RoadTypeMask (const MString &aLayer)
 
double OsmSpeedLimit (const MString &aValue)
 
String UKGridReferenceFromMapPoint (const PointFP &aPointInMapMeters, int32_t aDigits)
 
String UKGridReferenceFromDegrees (const PointFP &aPointInDegrees, int32_t aDigits)
 
RectFP MapRectFromUKGridReference (const String &aGridReference)
 
PointFP MapPointFromUKGridReference (const String &aGridReference)
 
PointFP PointInDegreesFromUKGridReference (const String &aGridReference)
 
String ExpandStreetName (const MString &aText)
 
bool MapObjectUserDataLessThan (const std::unique_ptr< MapObject > &aP, const std::unique_ptr< MapObject > &aQ)
 
template<class MTraverser >
void Traverse (MTraverser &aTraverser, const Point *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 Point &aA, const Point &aB, const Point &aC)
 
template<class T >
size_t SimplifyContour (T *aPointArray, size_t aPointCount, bool aClosed, double aResolutionArea)
 
template<class T >
Rect CBox (T *aPointArray, size_t aPointCount)
 
int FileSeek (FILE *aFile, int64_t aOffset, int aOrigin)
 
int64_t FileTell (FILE *aFile)
 
const AbbreviationInfoAbbreviationInfoForLocale (const char *aLocale)
 
String CountryToCode (const MString &aCountry)
 
String CodeToCountry (const MString &aCode)
 
String IdToString (uint64_t aId)
 
uint64_t StringToId (const MString &aIdString)
 
size_t Utf32ToUtf8 (uint8_t *aDest, MIter< int32_t > &aIter)
 
double ClampTo32Bit (double aX)
 
MapObjectArray Find (CMapDataBaseArray &aMapDataBaseArray, const FindParam &aFindParam, const ClipRegion &aClip, const ClipRegion &aLocation)
 
MapObjectArray Find (CMapDataBaseSet &aMapDataBaseSet, const FindParam &aFindParam, const ClipRegion &aClip, const ClipRegion &aLocation)
 
void GetPlaceBounds (CMapDataBaseSet *aMapDataBaseSet, const MapObject &aPlace, Outline &aOutline, Rect &aBounds, double &aRadiusSquared)
 
bool StreetIsInPlace (const Outline &aPlaceOutline, const Rect &aPlaceBounds, double aPlaceRadiusSquared, const MapObject &aStreet, const Rect &aStreetBounds)
 
MapObjectArray FindCities (CMapDataBaseSet &aMapDataBaseSet, StringMatchMethod aStringMatchMethod, const MString &aCityName, const ClipRegion &aClip)
 
MapObjectArray FindPostCodes (CMapDataBaseSet &aMapDataBaseSet, const MString &aPostCode, const ClipRegion &aClip)
 
MapObjectArray FindStreetsNearPlace (CMapDataBaseSet &aMapDataBaseSet, const MapObject &aPlace, StringMatchMethod aStringMatchMethod, const MString &aStreetName, const ClipRegion &aClip)
 
MapObjectArray FindStreets (CMapDataBaseArray &aMapDataBaseArray, const MString &aStreet, const MString &aCity, const MString &aPostCode, StringMatchMethod aStringMatchMethod, const ClipRegion &aClip, const AbbreviationDictionary &aAbbreviationDictionary)
 
void FindInLayers (CMapDataBaseSet &aMapDataBaseSet, const MString &aLayers, const ClipRegion &aClip, FindHandler aFindHandler, const MString *aCondition)
 
void FindHelper (CMapDataBaseSet &aMapDataBaseSet, FindHandler aFindHandler, const FindParam &aFindParam, const ClipRegion &aClip, TTimePoint aTimeOut)
 
void FindNearby (CMapDataBaseSet &aMapDataBaseSet, FindHandler aFindHandler, MapObjectArray &aMapObjectArray, const FindParam &aFindParam, const ClipRegion &aClip, const ClipRegion &aLocation, TTimePoint aTimeOut)
 
void Find (CMapDataBaseSet &aMapDataBaseSet, const ClipRegion &aClip, FindHandler aFindHandler, const MString *aCondition)
 
void FindText (CMapDataBaseSet &aMapDataBaseSet, const MString &aText, FindHandler aFindHandler, StringMatchMethod aStringMatchMethod, const MString &aLayers, const std::vector< String > &aAttribs, const ClipRegion &aClip, TTimePoint aTimeOut)
 
void Sort (MapObjectArray &aObjectArray, const MString *aText, size_t aStartIndex, const Outline *aLocation, const AbbreviationDictionary *aAbbreviationDictionary)
 
void Merge (MapObjectArray &aObjectArray, size_t aStartIndex)
 
void ConvertTo32nds (MapObject &aMapObject)
 
template<class point_t >
Outline OutlineInMapCoords (Framework &aFramework, const GeneralGeometry< point_t > &aGeometry)
 
void WriteTrackAsXmlHelper (const TrackGeometry &aTrack, MOutputStream &aOutput)
 
Contour Ellipse (const Point &aCenter, double aRX, double aRY, double aEllipseAngle)
 
Contour Circle (const Point &aCenter, double aRadius)
 
void AppendEllipticalArc (Contour &aContour, const Point &aCenter, double aRX, double aRY, double aEllipseAngle, double aStartAngle, double aEndAngle, EllipseAngleType aAngleType, bool aAppendStart)
 
void AppendEllipticalArc (Contour &aContour, const Point &aStart, double aRX, double aRY, double aEllipseAngle, bool aLargeArc, bool aSweep, const Point &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 KMapUnitsPerMeter = 32
 
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 Result KErrorNone = 0
 
constexpr Result KErrorGeneral = 1
 
constexpr Result KErrorNoMemory = 2
 
constexpr Result KErrorEndOfData = 3
 
constexpr Result KErrorTextUnmodifiable = 4
 
constexpr Result KErrorTextTruncated = 5
 
constexpr Result KErrorNotFound = 6
 
constexpr Result KErrorUnimplemented = 7
 
constexpr Result KErrorInvalidOutline = 8
 
constexpr Result KErrorIo = 9
 
constexpr Result KErrorCorrupt = 10
 
constexpr Result KErrorUnknownDataFormat = 11
 
constexpr Result KErrorNoInverse = 12
 
constexpr Result KErrorProjectionOverflow = 13
 
constexpr Result KErrorCancel = 14
 
constexpr Result KErrorInvalidArgument = 15
 
constexpr Result KErrorUnknownVersion = 16
 
constexpr Result KErrorOverflow = 17
 
constexpr Result KErrorParallelLines = 19
 
constexpr Result KErrorNoPalette = 22
 
constexpr Result KErrorDuplicate = 23
 
constexpr Result KErrorNoProjection = 24
 
constexpr Result KErrorPaletteFull = 25
 
constexpr Result KErrorInvalidDashArray = 26
 
constexpr Result KErrorNoRoute = 28
 
constexpr Result KErrorZoomLimitReached = 29
 
constexpr Result KErrorAlreadyProjected = 30
 
constexpr Result KErrorConditionsTooDeeplyNested = 31
 
constexpr Result KErrorNullFont = 32
 
constexpr Result KErrorInternetIo = 33
 
constexpr Result KErrorDivideByZero = 34
 
constexpr Result KErrorTransformFailed = 35
 
constexpr Result KErrorPngRead = 36
 
constexpr Result KErrorJpgRead = 37
 
constexpr Result KErrorNoIntersection = 38
 
constexpr Result KErrorInterrupt = 39
 
constexpr Result KErrorMapDataBaseFormatMismatch = 40
 
constexpr Result KErrorEncryptionKeyTooShort = 41
 
constexpr Result KErrorNoEncryptionKey = 42
 
constexpr Result KErrorEmergencyMessage = 43
 
constexpr Result KErrorAlertMessage = 44
 
constexpr Result KErrorCriticalMessage = 45
 
constexpr Result KErrorErrorMessage = 46
 
constexpr Result KErrorWarningMessage = 47
 
constexpr Result KErrorNoticeMessage = 48
 
constexpr Result KErrorInfoMessage = 49
 
constexpr Result KErrorDebugMessage = 50
 
constexpr Result KErrorNotNavigating = 51
 
constexpr Result KErrorNoFramework = 52
 
constexpr Result KErrorFrameworkAlreadyExists = 53
 
constexpr Result KErrorUntransliterable = 54
 
constexpr Result KErrorPngWrite = 55
 
constexpr Result KErrorReadOnlyMapDataBase = 56
 
constexpr Result KErrorProj4 = 57
 
constexpr Result KErrorUnlicensed = 58
 
constexpr Result KErrorNoRoadsNearStartOfRoute = 59
 
constexpr Result KErrorNoRoadsNearEndOfRoute = 60
 
constexpr Result KErrorNoRouteConnectivity = 61
 
constexpr Result KErrorXmlFeatureNotSupported = 62
 
constexpr Result KErrorMapNotFound = 63
 
constexpr Result KErrorFontNotFound = 64
 
constexpr Result KErrorStyleSheetNotFound = 65
 
constexpr Result KErrorFeatureInfoIsNotRoute = 66
 
constexpr Result KErrorFeatureInfoIsRoute = 67
 
constexpr int32_t KStandardErrorCodeCount = 68
 
constexpr Result KErrorXmlRangeStart = 0x10000000
 
constexpr Result 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 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 CartoTypeCore library.

Typedef Documentation

◆ FindAsyncCallBack

using CartoTypeCore::FindAsyncCallBack = typedef std::function<void(std::unique_ptr<MapObjectArray> aMapObjectArray)>

A type for functions called by the asynchronous Find function.

◆ FindAsyncGroupCallBack

using CartoTypeCore::FindAsyncGroupCallBack = typedef std::function<void(std::unique_ptr<MapObjectGroupArray> aMapObjectGroupArray)>

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

◆ FindHandler

using CartoTypeCore::FindHandler = typedef std::function<bool(std::unique_ptr<MapObject>)>

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

◆ MapObjectArray

using CartoTypeCore::MapObjectArray = typedef std::vector<std::unique_ptr<MapObject> >

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

◆ MapObjectGroupArray

using CartoTypeCore::MapObjectGroupArray = typedef std::vector<MapObjectGroup>

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

◆ Point3FP

using CartoTypeCore::Point3FP = typedef Point3<double>

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

◆ PointFP

using CartoTypeCore::PointFP = typedef Point2<double>

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

◆ RouterAsyncCallBack

using CartoTypeCore::RouterAsyncCallBack = typedef std::function<void(Result aError,std::unique_ptr<Route> aRoute)>

A type for functions called by the asynchronous routing function.

◆ StreetAddressSearchState

using CartoTypeCore::StreetAddressSearchState = typedef std::unique_ptr<StreetAddressSearchStateImplementation>

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.

◆ StringDictionary

using CartoTypeCore::StringDictionary = typedef std::map<String, String>

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

◆ StringTypeDictionary

using CartoTypeCore::StringTypeDictionary = typedef std::map<String,int>

A type for a class mapping String objects to integers.

◆ StyleSheetDataArray

using CartoTypeCore::StyleSheetDataArray = typedef std::vector<StyleSheetData>

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

◆ TrackGeometry

A type for a sequence of track points.

Enumeration Type Documentation

◆ AbbreviationType

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.

Suffix 

The word is a suffix.

◆ AddressPart

enum class CartoTypeCore::AddressPart
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.

◆ Align

enum class CartoTypeCore::Align
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.

◆ BidiOverride

enum class CartoTypeCore::BidiOverride
strong

The override status during bidirectional reordering.

◆ BidiParDir

enum class CartoTypeCore::BidiParDir
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.

◆ BidiType

enum class CartoTypeCore::BidiType
strong

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

◆ BitmapType

enum class CartoTypeCore::BitmapType
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 BitmapType that represent the number of bits per pixel.

KColored 

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

KPalette 

The bit in BitmapType 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.

◆ CharCategory

enum class CartoTypeCore::CharCategory
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).

◆ ClipOperation

enum class CartoTypeCore::ClipOperation
strong

Types of clipping done by the general clip function Outline MPath::Clip(ClipOperation 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.

◆ ClipType

enum class CartoTypeCore::ClipType
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.

◆ CoordType

enum class CartoTypeCore::CoordType
strong

Coordinate types.

Enumerator
Degree 

Longitude (X) and latitude (Y) in degrees. X increases to the east and Y increases to the north.

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: 32nds of projected meters. X increases to the east and Y increases to the north.

MapMeter 

Map meters: projected meters. X increases to the east and Y increases to the north.

◆ DrawResult

enum class CartoTypeCore::DrawResult
strong

Result codes for drawing operations.

◆ EllipseAngleType

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.

◆ FeatureDiscriminator

The feature discriminator stored in a FeatureInfo object.

Enumerator
NonRoute 

Not a route.

BridgeRoute 

A route that is a bridge.

TunnelRoute 

A route that is a tunnel.

Route 

A route that is neither a tunnel nor a bridge.

◆ FeatureType

enum class CartoTypeCore::FeatureType : uint16_t
strong

Every map object has a feature type. The first 32 feature types are used for routable objects and their values are indexes into tables of speeds and weights in route profiles. Other feature types are constructed from three-letter codes.

All feature type values must fit into 15 bits, and therefore must be in the range 0...32767.

◆ FileType

enum class CartoTypeCore::FileType
strong

File types of interest to CartoTypeCore.

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 (CartoTypeCore Map Data Type 1) map data files.

CTMS 

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

KML 

KML (Keyhole Markup Language) map data files.

CTSQL 

CTSQL (CartoTypeCore SQLite format) map data files.

CTROUTE 

CTROUTE (CartoTypeCore XML route) files.

GPX 

GPX (GPS Exchange) files.

None 

Unknown or unspecified file type.

◆ FollowMode

enum class CartoTypeCore::FollowMode
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.

◆ GeoCodeType

enum class CartoTypeCore::GeoCodeType
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.

◆ IntersectionPlace

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.

◆ LetterCase

enum class CartoTypeCore::LetterCase
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.

◆ LineCap

enum class CartoTypeCore::LineCap
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.

◆ LineJoin

enum class CartoTypeCore::LineJoin
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.

◆ LocationRefType

enum class CartoTypeCore::LocationRefType
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.

◆ MapObjectType

enum class CartoTypeCore::MapObjectType
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.

◆ NavigationState

enum class CartoTypeCore::NavigationState
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.

◆ NoticePosition

enum class CartoTypeCore::NoticePosition
strong

Positions for notices like the legend or scale bar. Use ExtendedNoticePosition 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.

◆ PathIntersectionType

The ways two paths can intersect.

Enumerator
Unknown 

The intersection type is unknown.

Separate 

The paths do not intersect.

Intersects 

The paths intersect or are identical.

Contains 

The first path contains the second.

Contained 

The second path contains the first.

◆ PointFormat

enum class CartoTypeCore::PointFormat
strong

The format used for points in CTM1 data. These numbers must fit into 8 bits 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.

◆ PointType

enum class CartoTypeCore::PointType
strong

Types used by OutlinePoint.

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.

◆ PolygonOrientation

The direction of a polygon. Points and unclosed polygons have no orientation.

Enumerator
None 

No orientation, or unspecified orientation.

Clockwise 

Clockwise, assuming X goes right and Y goes up.

Anticlockwise 

Anticlockwise, assuming X goes right and Y goes up.

◆ RoadOrientation

enum class CartoTypeCore::RoadOrientation
strong

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

◆ RoundaboutState

enum class CartoTypeCore::RoundaboutState
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.

◆ RouteProfileType

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.

Ski 

A profile type for downhill skiing.

◆ RouterType

enum class CartoTypeCore::RouterType
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.

◆ SideOfRoad

enum class CartoTypeCore::SideOfRoad
strong

The side of the road: used in traffic information.

◆ StreamEncoding

enum class CartoTypeCore::StreamEncoding
strong

The encoding for reading or writing strings.

◆ StreamEndianness

The endianness for data streams.

◆ StringMatchMethodFlag

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.

◆ StringMatchType

enum class CartoTypeCore::StringMatchType
strong

Different qualities of string match used when comparing map object attributes.

Enumerator
None 

No match.

Substring 

A substring of the text matches, but the substring is not aligned to token boundaries.

Fuzzy 

A fuzzy match: a small number of extra characters, missing characters, or transpositions.

Phrase 

A phrase match: a substring match aligned to token boundaries.

Full 

A full match, ignoring letter case, accents and non-alphanumeric characters.

◆ TextBaseline

enum class CartoTypeCore::TextBaseline
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.

◆ TurnType

enum class CartoTypeCore::TurnType
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 Turn 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.

◆ VectorTileObjectClipType

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.

◆ WritableMapType

enum class CartoTypeCore::WritableMapType
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

◆ AbbreviationInfoForLocale()

const AbbreviationInfo * CartoTypeCore::AbbreviationInfoForLocale ( 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 CartoTypeCore::AppendEllipticalArc ( Contour aContour,
const Point aCenter,
double  aRX,
double  aRY,
double  aEllipseAngle,
double  aStartAngle,
double  aEndAngle,
EllipseAngleType  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 CartoTypeCore::AppendEllipticalArc ( Contour aContour,
const Point aStart,
double  aRX,
double  aRY,
double  aEllipseAngle,
bool  aLargeArc,
bool  aSweep,
const Point 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 CartoTypeCore::Area ( const contour_t &  aContour)
inline

Returns the area of a polygon represented as a vector of points with members X and Y.

◆ Area() [2/2]

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

Returns the area of a polygon made of points with members X and Y.

◆ Atan2()

double CartoTypeCore::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 CartoTypeCore::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 * CartoTypeCore::Build ( )

Returns the current CartoType build as a string.

◆ CBox()

template<class T >
Rect CartoTypeCore::CBox ( T *  aPointArray,
size_t  aPointCount 
)

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

◆ Circle()

Contour CartoTypeCore::Circle ( const Point 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 CartoTypeCore::ClampTo32Bit ( double  aX)
inline

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

◆ CodeToCountry()

String CartoTypeCore::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.

◆ ConvertTo32nds()

void CartoTypeCore::ConvertTo32nds ( MapObject aMapObject)

Converts the points of a map object from map metres to 32nds of metres.

◆ CountryToCode()

String CartoTypeCore::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.

◆ Description()

const char * CartoTypeCore::Description ( )

Returns a Git description of the current CartoType version as a string of the form MAJOR.MINOR-BUILD-COMMIT, created by the command 'git describe –tags –long'. The major version is the most recent tag, the minor version is the number of commits since that tag, and the commit is the Git commit name, which is a unambiguous abbreviation of a cryptographic hash of that state of the repository.

◆ Ellipse()

Contour CartoTypeCore::Ellipse ( const Point 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 CartoTypeCore::ErrorString ( uint32_t  aErrorCode)

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

◆ ExpandStreetName()

String CartoTypeCore::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.

◆ FeatureTypeCode()

uint32_t constexpr CartoTypeCore::FeatureTypeCode ( int  A,
int  B,
int  C 
)
inlineconstexpr

Constructs a 15-bit feature type code from 3 lower-case letters.

◆ FeatureTypeFromName()

FeatureType CartoTypeCore::FeatureTypeFromName ( const MString aName)

Given a feature type name, returns a feature type. Three-letter names are taken to be special three-letter codes.

This function is used in makemap import rules and the general expression evaluator for conditions used when searching. It ignores case, spaces and punctuation when comparing names.

◆ FeatureTypeIsCity()

bool CartoTypeCore::FeatureTypeIsCity ( FeatureType  aType)

Returns true if aType is a city, town, etc.

◆ FeatureTypeIsLink()

bool CartoTypeCore::FeatureTypeIsLink ( FeatureType  aType)

Returns true if aType is a link: that is, an on or off ramp to or from a higher-level road.

◆ FeatureTypeIsPath()

bool CartoTypeCore::FeatureTypeIsPath ( FeatureType  aType)

Returns true if aType is a path. Paths include cycleways, steps and ski pistes as well as footpaths and footways.

◆ FeatureTypeIsPOI()

bool CartoTypeCore::FeatureTypeIsPOI ( FeatureType  aType)

Returns true if aType is a point of interest.

◆ FeatureTypeIsRoad()

bool CartoTypeCore::FeatureTypeIsRoad ( FeatureType  aType)

Returns true if aType is a road.

◆ FeatureTypeName()

std::string CartoTypeCore::FeatureTypeName ( FeatureType  aType)

Returns the name corresponding to a feature type.

◆ FileSeek()

int CartoTypeCore::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 CartoTypeCore::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]

MapObjectArray CartoTypeCore::Find ( CMapDataBaseArray &  aMapDataBaseArray,
const FindParam aFindParam,
const ClipRegion aClip,
const ClipRegion 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]

void CartoTypeCore::Find ( CMapDataBaseSet &  aMapDataBaseSet,
const ClipRegion aClip,
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.

◆ Find() [3/3]

MapObjectArray CartoTypeCore::Find ( CMapDataBaseSet &  aMapDataBaseSet,
const FindParam aFindParam,
const ClipRegion aClip,
const ClipRegion 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.

◆ FindCities()

MapObjectArray CartoTypeCore::FindCities ( CMapDataBaseSet &  aMapDataBaseSet,
StringMatchMethod  aStringMatchMethod,
const MString aCityName,
const ClipRegion aClip 
)

Finds cities matching aCityName. If aCityName is empty, finds all cities.

◆ FindHelper()

void CartoTypeCore::FindHelper ( CMapDataBaseSet &  aMapDataBaseSet,
FindHandler  aFindHandler,
const FindParam aFindParam,
const ClipRegion aClip,
TTimePoint  aTimeOut 
)

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

◆ FindInLayers()

void CartoTypeCore::FindInLayers ( CMapDataBaseSet &  aMapDataBaseSet,
const MString aLayers,
const ClipRegion aClip,
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., "sub_type==2") which must be satisfied by the objects.

◆ FindNearby()

void CartoTypeCore::FindNearby ( CMapDataBaseSet &  aMapDataBaseSet,
FindHandler  aFindHandler,
MapObjectArray aMapObjectArray,
const FindParam aFindParam,
const ClipRegion aClip,
const ClipRegion aLocation,
TTimePoint  aTimeOut 
)

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

◆ FindPostCodes()

MapObjectArray CartoTypeCore::FindPostCodes ( CMapDataBaseSet &  aMapDataBaseSet,
const MString aPostCode,
const ClipRegion aClip 
)

Finds postcodes matching aPostCode. If aPostCode is empty, finds all postcodes.

◆ FindStreets()

MapObjectArray CartoTypeCore::FindStreets ( CMapDataBaseArray &  aMapDataBaseArray,
const MString aStreet,
const MString aCity,
const MString aPostCode,
StringMatchMethod  aStringMatchMethod,
const ClipRegion aClip,
const AbbreviationDictionary aAbbreviationDictionary 
)

Finds streets, given a street name, city name and optional postcode.

◆ FindStreetsNearPlace()

MapObjectArray CartoTypeCore::FindStreetsNearPlace ( CMapDataBaseSet &  aMapDataBaseSet,
const MapObject aPlace,
StringMatchMethod  aStringMatchMethod,
const MString aStreetName,
const ClipRegion aClip 
)

Finds named streets near a given place. If aStreetName is empty, finds all named streets near the city.

◆ FindText()

void CartoTypeCore::FindText ( CMapDataBaseSet &  aMapDataBaseSet,
const MString aText,
FindHandler  aFindHandler,
StringMatchMethod  aStringMatchMethod,
const MString aLayers,
const std::vector< String > &  aAttribs,
const ClipRegion 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.

◆ GetPlaceBounds()

void CartoTypeCore::GetPlaceBounds ( CMapDataBaseSet *  aMapDataBaseSet,
const MapObject aPlace,
Outline aOutline,
Rect aBounds,
double &  aRadiusSquared 
)

Gets the outline, bounds and radius of a place. For internal use.

◆ GetSphericalAreaAndLength() [1/2]

void CartoTypeCore::GetSphericalAreaAndLength ( const CoordSet 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 CartoTypeCore::GetSphericalAreaAndLength ( std::function< const PointFP *()>  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.

◆ GradientCode()

uint32_t CartoTypeCore::GradientCode ( int16_t  aStartHeight,
int16_t  aEndHeight,
int32_t  aDistance 
)

Returns the gradient code for an arc, given its start and end heights in metres. GetHeight values of INT16_MIN mean 'unknown'.

Gradients are as follows. The thresholds are designed to be useful for cycling. See http://theclimbingcyclist.com/gradients-and-cycling-an-introduction/.

flat = up to 1 in 100 (1%) gentle = up to 1 in 25 (4%) steep = up to 1 in 12.5 (8%) very steep = over 1 in 12.5 (over 8%)

Gradient codes are 0: flat or slightly uphill 1: gentle uphill 2: steep uphill 3: very steep uphill 4: flat or slightly downhill 5: gentle downhill 6: steep downhill 7: very steep downhill

◆ GradientName()

const char * CartoTypeCore::GradientName ( int  aGradient)

Returns the name of a gradient range, as used in serialized XML route profiles.

◆ GreatCircleDistanceInMeters()

double CartoTypeCore::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 CartoTypeCore::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.

◆ IdToString()

String CartoTypeCore::IdToString ( uint64_t  aId)

Creates a string representing a 64-bit map object ID, encoded as one to four 16-bit characters in big-endian order, from the ID.

◆ InterpolatedValue()

template<class DataType >
double CartoTypeCore::InterpolatedValue ( const DataType *  aDataStart,
int32_t  aWidth,
int32_t  aHeight,
int32_t  aStride,
int32_t  aChannels,
double  aX,
double  aY,
int  aChannel,
int32_t  aUnknownValue 
)

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 value aUnknownValue is ignored when interpolating.

◆ MajorRouteType()

FeatureType CartoTypeCore::MajorRouteType ( FeatureType  aType)

Combines different route types into a major type. Used for determining the difficulty or importance of a turn in routing.

◆ MapObjectUserDataLessThan()

bool CartoTypeCore::MapObjectUserDataLessThan ( const std::unique_ptr< MapObject > &  aP,
const std::unique_ptr< MapObject > &  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()

PointFP CartoTypeCore::MapPointFromUKGridReference ( const String 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()

RectFP CartoTypeCore::MapRectFromUKGridReference ( const String 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 CartoTypeCore::Merge ( MapObjectArray aObjectArray,
size_t  aStartIndex 
)

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

◆ OsmSpeedLimit()

double CartoTypeCore::OsmSpeedLimit ( const MString aValue)

Converts an OpenStreetMap speed limit expressed as a string (the value of the maxspeed tag) to a value in kph.

The speed limit is either a plain number denoting kph, a number followed by 'mph' denoting miles per hour, or a country code followed by a category as defined in http://wiki.openstreetmap.org/wiki/Speed_limits.

◆ OutlineInMapCoords()

template<class point_t >
Outline CartoTypeCore::OutlineInMapCoords ( Framework aFramework,
const GeneralGeometry< point_t > &  aGeometry 
)

Creates an Outline object in map coordinates from a Geometry object.

◆ PointAtAzimuth()

PointFP CartoTypeCore::PointAtAzimuth ( const PointFP 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()

PointFP CartoTypeCore::PointInDegreesFromUKGridReference ( const String 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 CartoTypeCore::ReadBigEndian ( const int16_t *  aP)
inline

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

◆ ReadBigEndian() [2/2]

uint8_t CartoTypeCore::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 CartoTypeCore::Reverse ( T *  aStart,
size_t  aLength 
)
inline

Reverses an array of objects of type T.

◆ RoadTypeMask()

uint32_t CartoTypeCore::RoadTypeMask ( const MString aLayer)

Returns the road type mask for a given layer; for internal use in providing backward compatibility with pre-version-8 CTM1 files.

◆ Round() [1/2]

int32_t CartoTypeCore::Round ( double  aValue)
inline

Rounds a floating-point value to the nearest integer.

◆ Round() [2/2]

double CartoTypeCore::Round ( double  aValue,
int  aFractionDigits 
)
inline

Rounds a number to a certain number of fractional digits.

For example, if aFractionDigits is 0, it rounds to the nearest integer, and if it is 2, to two decimal places. Negative numbers of fractional digits round to powers of 10; e.g., -3 rounds to the nearest 1000. Unlike the single-argument version of Round, it returns a double, and handles numbers outside the integer range.

◆ SimplifyContour()

template<class T >
size_t CartoTypeCore::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 CartoTypeCore::Sort ( MapObjectArray aObjectArray,
const MString aText,
size_t  aStartIndex,
const Outline aLocation,
const AbbreviationDictionary aAbbreviationDictionary 
)

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 CartoTypeCore::SphericalPolygonArea ( const CoordSet 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 CartoTypeCore::SphericalPolygonArea ( std::function< const PointFP *()>  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 CartoTypeCore::SphericalPolylineLength ( const CoordSet 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 CartoTypeCore::SphericalPolylineLength ( std::function< const PointFP *()>  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.

◆ StreetIsInPlace()

bool CartoTypeCore::StreetIsInPlace ( const Outline aPlaceOutline,
const Rect aPlaceBounds,
double  aPlaceRadiusSquared,
const MapObject aStreet,
const Rect aStreetBounds 
)

Returns true if a street is in a place, using bounds returned by GetPlaceBounds. For internal use.

◆ StringToId()

uint64_t CartoTypeCore::StringToId ( const MString aIdString)

Converts a string represnring a 64-bit map object ID, encoded as one to four 16-bit characters in big-endian order, to the ID.

◆ Strtod() [1/2]

double CartoTypeCore::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 CartoTypeCore::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 CartoTypeCore::Traverse ( MTraverser &  aTraverser,
const Point aPoint,
size_t  aPoints,
bool  aClosed 
)

Traverses a sequence of 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 Point& aPoint)

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

void LineTo(const Point& aPoint)

◆ Traverse() [2/2]

template<class traverser_t , class point_t >
void CartoTypeCore::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 Point& aPoint)

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

void LineTo(const Point& 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 Point& aPoint1,const Point& 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 Point& aPoint1,const Point& aPoint2,const Point& aPoint3)

◆ TriangleArea()

double CartoTypeCore::TriangleArea ( const Point aA,
const Point aB,
const Point aC 
)
inline

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

◆ UKGridReferenceFromDegrees()

String CartoTypeCore::UKGridReferenceFromDegrees ( const PointFP 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()

String CartoTypeCore::UKGridReferenceFromMapPoint ( const PointFP 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.

◆ Utf32ToUtf8()

size_t CartoTypeCore::Utf32ToUtf8 ( uint8_t *  aDest,
MIter< int32_t > &  aIter 
)

Converts UTF32 text to Utf8, returning the number of bytes needed. If aDest is null do not write to aDest but still return the number of bytes needed.

◆ Version()

const char * CartoTypeCore::Version ( )

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

◆ WriteBigEndian() [1/2]

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

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

◆ WriteBigEndian() [2/2]

void CartoTypeCore::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 CartoTypeCore::WriteTrackAsXmlHelper ( const TrackGeometry aTrack,
MOutputStream aOutput 
)

An internal function to write a track in GPX format.

Variable Documentation

◆ CT_DBL_MAX

const double CartoTypeCore::CT_DBL_MAX = 1.7976931348623158e+308

This CartoTypeCore-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 CartoTypeCore::KArabicScript = 0x20

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

◆ KArmenianScript

const uint32_t CartoTypeCore::KArmenianScript = 8

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

◆ KBengaliScript

const uint32_t CartoTypeCore::KBengaliScript = 0x80

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

◆ KBlack

const uint32_t CartoTypeCore::KBlack = 0xFF000000

Opaque black.

◆ KBlue

const uint32_t CartoTypeCore::KBlue = 0xFFFF0000

Opaque blue.

◆ KBoldStyle

const uint32_t CartoTypeCore::KBoldStyle = 1

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

◆ KBopomofoScript

const uint32_t CartoTypeCore::KBopomofoScript = 0x8000000

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

◆ KCursiveStyle

const uint32_t CartoTypeCore::KCursiveStyle = 8

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

◆ KCyan

const uint32_t CartoTypeCore::KCyan = 0xFFFFFF00

Opaque cyan.

◆ KCyrillicScript

const uint32_t CartoTypeCore::KCyrillicScript = 4

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

◆ KDarkBlue

const uint32_t CartoTypeCore::KDarkBlue = 0xFF800000

Opaque dark blue.

◆ KDarkCyan

const uint32_t CartoTypeCore::KDarkCyan = 0xFF808000

Opaque dark cyan.

◆ KDarkGray

const uint32_t CartoTypeCore::KDarkGray = 0xFF555555

Opaque dark gray.

◆ KDarkGreen

const uint32_t CartoTypeCore::KDarkGreen = 0xFF008000

Opaque dark green.

◆ KDarkGrey

const uint32_t CartoTypeCore::KDarkGrey = 0xFF555555

Opaque dark grey.

◆ KDarkMagenta

const uint32_t CartoTypeCore::KDarkMagenta = 0xFF800080

Opaque dark magenta.

◆ KDarkRed

const uint32_t CartoTypeCore::KDarkRed = 0xFF000080

Opaque dark red.

◆ KDarkYellow

const uint32_t CartoTypeCore::KDarkYellow = 0xFF008080

Opaque dark yellow.

◆ KDefaultTextIndexLevels

constexpr int32_t CartoTypeCore::KDefaultTextIndexLevels = 1
constexpr

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

◆ KDegreesToMetres

constexpr double CartoTypeCore::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 CartoTypeCore::KDegreesToRadiansDouble = KPiDouble / 180.0
constexpr

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

◆ KDevanagariScript

const uint32_t CartoTypeCore::KDevanagariScript = 0x40

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

◆ KEpsgPlateCarree

constexpr int32_t CartoTypeCore::KEpsgPlateCarree = 4326
constexpr

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

◆ KEpsgWebMercator

constexpr int32_t CartoTypeCore::KEpsgWebMercator = 3857
constexpr

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

◆ KEquatorialRadiusInMetres

constexpr int32_t CartoTypeCore::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 Result CartoTypeCore::KErrorAlertMessage = 44
constexpr

A code for standard alert messages.

◆ KErrorAlreadyProjected

constexpr Result CartoTypeCore::KErrorAlreadyProjected = 30
constexpr

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

◆ KErrorCancel

constexpr Result CartoTypeCore::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 Result CartoTypeCore::KErrorConditionsTooDeeplyNested = 31
constexpr

Conditions are too deeply nested in the style sheet.

◆ KErrorCorrupt

constexpr Result CartoTypeCore::KErrorCorrupt = 10
constexpr

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

◆ KErrorCriticalMessage

constexpr Result CartoTypeCore::KErrorCriticalMessage = 45
constexpr

A code for standard critical messages.

◆ KErrorDebugMessage

constexpr Result CartoTypeCore::KErrorDebugMessage = 50
constexpr

A code for standard debug messages.

◆ KErrorDivideByZero

constexpr Result CartoTypeCore::KErrorDivideByZero = 34
constexpr

Division by zero in an interpreted expression.

◆ KErrorDuplicate

constexpr Result CartoTypeCore::KErrorDuplicate = 23
constexpr

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

◆ KErrorEmergencyMessage

constexpr Result CartoTypeCore::KErrorEmergencyMessage = 43
constexpr

A code for standard emergency messages.

◆ KErrorEncryptionKeyTooShort

constexpr Result CartoTypeCore::KErrorEncryptionKeyTooShort = 41
constexpr

A key supplied for encryption was too short.

◆ KErrorEndOfData

constexpr Result CartoTypeCore::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 Result CartoTypeCore::KErrorErrorMessage = 46
constexpr

A code for standard error messages.

◆ KErrorFeatureInfoIsNotRoute

constexpr Result CartoTypeCore::KErrorFeatureInfoIsNotRoute = 66
constexpr

An attempt was made to set a route attribute on a feature info that is not a route.

◆ KErrorFeatureInfoIsRoute

constexpr Result CartoTypeCore::KErrorFeatureInfoIsRoute = 67
constexpr

An attempt was made to set a non-route attribute on a feature info that is a route.

◆ KErrorFontNotFound

constexpr Result CartoTypeCore::KErrorFontNotFound = 64
constexpr

A font file was not found.

◆ KErrorFrameworkAlreadyExists

constexpr Result CartoTypeCore::KErrorFrameworkAlreadyExists = 53
constexpr

The global framework object already exists.

◆ KErrorGeneral

constexpr Result CartoTypeCore::KErrorGeneral = 1
constexpr

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

◆ KErrorInfoMessage

constexpr Result CartoTypeCore::KErrorInfoMessage = 49
constexpr

A code for standard information messages.

◆ KErrorInternetIo

constexpr Result CartoTypeCore::KErrorInternetIo = 33
constexpr

An attempt to read data from the internet failed.

◆ KErrorInterrupt

constexpr Result CartoTypeCore::KErrorInterrupt = 39
constexpr

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

◆ KErrorInvalidArgument

constexpr Result CartoTypeCore::KErrorInvalidArgument = 15
constexpr

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

◆ KErrorInvalidDashArray

constexpr Result CartoTypeCore::KErrorInvalidDashArray = 26
constexpr

The dash array for drawing strokes is invalid.

◆ KErrorInvalidOutline

constexpr Result CartoTypeCore::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 Result CartoTypeCore::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 Result CartoTypeCore::KErrorJpgRead = 37
constexpr

Reading a bitmap from JPG format failed.

◆ KErrorMapDataBaseFormatMismatch

constexpr Result CartoTypeCore::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 Result CartoTypeCore::KErrorMapNotFound = 63
constexpr

A map file was not found.

◆ KErrorNoEncryptionKey

constexpr Result CartoTypeCore::KErrorNoEncryptionKey = 42
constexpr

No encryption key has been set.

◆ KErrorNoFramework

constexpr Result CartoTypeCore::KErrorNoFramework = 52
constexpr

The global framework object does not exist.

◆ KErrorNoIntersection

constexpr Result CartoTypeCore::KErrorNoIntersection = 38
constexpr

An object did not intersect a specified region.

◆ KErrorNoInverse

constexpr Result CartoTypeCore::KErrorNoInverse = 12
constexpr

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

◆ KErrorNoMemory

constexpr Result CartoTypeCore::KErrorNoMemory = 2
constexpr

Use KErrorNoMemory when an attempted memory allocation fails.

◆ KErrorNone

constexpr Result CartoTypeCore::KErrorNone = 0
constexpr

No error; a successful result.

◆ KErrorNoPalette

constexpr Result CartoTypeCore::KErrorNoPalette = 22
constexpr

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

◆ KErrorNoProjection

constexpr Result CartoTypeCore::KErrorNoProjection = 24
constexpr

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

◆ KErrorNoRoadsNearEndOfRoute

constexpr Result CartoTypeCore::KErrorNoRoadsNearEndOfRoute = 60
constexpr

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

◆ KErrorNoRoadsNearStartOfRoute

constexpr Result CartoTypeCore::KErrorNoRoadsNearStartOfRoute = 59
constexpr

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

◆ KErrorNoRoute

constexpr Result CartoTypeCore::KErrorNoRoute = 28
constexpr

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

◆ KErrorNoRouteConnectivity

constexpr Result CartoTypeCore::KErrorNoRouteConnectivity = 61
constexpr

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

◆ KErrorNotFound

constexpr Result CartoTypeCore::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 Result CartoTypeCore::KErrorNoticeMessage = 48
constexpr

A code for standard notice messages.

◆ KErrorNotNavigating

constexpr Result CartoTypeCore::KErrorNotNavigating = 51
constexpr

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

◆ KErrorNullFont

constexpr Result CartoTypeCore::KErrorNullFont = 32
constexpr

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

◆ KErrorOverflow

constexpr Result CartoTypeCore::KErrorOverflow = 17
constexpr

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

◆ KErrorPaletteFull

constexpr Result CartoTypeCore::KErrorPaletteFull = 25
constexpr

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

◆ KErrorParallelLines

constexpr Result CartoTypeCore::KErrorParallelLines = 19
constexpr

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

◆ KErrorPngRead

constexpr Result CartoTypeCore::KErrorPngRead = 36
constexpr

Reading a bitmap from PNG format failed.

◆ KErrorPngWrite

constexpr Result CartoTypeCore::KErrorPngWrite = 55
constexpr

Writing a bitmap to PNG format failed.

◆ KErrorProj4

constexpr Result CartoTypeCore::KErrorProj4 = 57
constexpr

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

◆ KErrorProjectionOverflow

constexpr Result CartoTypeCore::KErrorProjectionOverflow = 13
constexpr

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

◆ KErrorReadOnlyMapDataBase

constexpr Result CartoTypeCore::KErrorReadOnlyMapDataBase = 56
constexpr

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

◆ KErrorSQLite

constexpr uint32_t CartoTypeCore::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 Result CartoTypeCore::KErrorStyleSheetNotFound = 65
constexpr

A style sheet was not found.

◆ KErrorTextTruncated

constexpr Result CartoTypeCore::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 Result CartoTypeCore::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 Result CartoTypeCore::KErrorTransformFailed = 35
constexpr

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

◆ KErrorUnimplemented

constexpr Result CartoTypeCore::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 Result CartoTypeCore::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 Result CartoTypeCore::KErrorUnknownVersion = 16
constexpr

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

◆ KErrorUnlicensed

constexpr Result CartoTypeCore::KErrorUnlicensed = 58
constexpr

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

◆ KErrorUntransliterable

constexpr Result CartoTypeCore::KErrorUntransliterable = 54
constexpr

A string was not transliterable.

◆ KErrorWarningMessage

constexpr Result CartoTypeCore::KErrorWarningMessage = 47
constexpr

A code for standard warning messages.

◆ KErrorXmlFeatureNotSupported

constexpr Result CartoTypeCore::KErrorXmlFeatureNotSupported = 62
constexpr

An unsupported feature was requested from the XML parser.

◆ KErrorXmlRangeEnd

constexpr Result CartoTypeCore::KErrorXmlRangeEnd = 0x2AFFFFFF
constexpr

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

◆ KErrorXmlRangeStart

constexpr Result CartoTypeCore::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 Result CartoTypeCore::KErrorZoomLimitReached = 29
constexpr

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

◆ KEthiopicScript

const uint32_t CartoTypeCore::KEthiopicScript = 0x400000

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

◆ KFantasyStyle

const uint32_t CartoTypeCore::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 TypefaceAttrib::Style, etc.

◆ KFollowFlagHeading

constexpr uint32_t CartoTypeCore::KFollowFlagHeading = 2
constexpr

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

◆ KFollowFlagLocation

constexpr uint32_t CartoTypeCore::KFollowFlagLocation = 1
constexpr

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

◆ KFollowFlagZoom

constexpr uint32_t CartoTypeCore::KFollowFlagZoom = 4
constexpr

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

◆ KGeorgianScript

const uint32_t CartoTypeCore::KGeorgianScript = 0x100000

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

◆ KGray

const uint32_t CartoTypeCore::KGray = KGrey

Opaque gray.

◆ KGreekScript

const uint32_t CartoTypeCore::KGreekScript = 2

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

◆ KGreen

const uint32_t CartoTypeCore::KGreen = 0xFF00FF00

Opaque green.

◆ KGrey

const uint32_t CartoTypeCore::KGrey = 0xFFAAAAAA

Opaque grey.

◆ KGujaratiScript

const uint32_t CartoTypeCore::KGujaratiScript = 0x200

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

◆ KGurmukhiScript

const uint32_t CartoTypeCore::KGurmukhiScript = 0x100

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

◆ KHangulScript

const uint32_t CartoTypeCore::KHangulScript = 0x200000

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

◆ KHanScript

const uint32_t CartoTypeCore::KHanScript = 0x10000000

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

◆ KHebrewScript

const uint32_t CartoTypeCore::KHebrewScript = 0x10

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

◆ KHiraganaScript

const uint32_t CartoTypeCore::KHiraganaScript = 0x2000000

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

◆ KItalicStyle

const uint32_t CartoTypeCore::KItalicStyle = 2

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

◆ KKannadaScript

const uint32_t CartoTypeCore::KKannadaScript = 0x2000

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

◆ KKatakanaScript

const uint32_t CartoTypeCore::KKatakanaScript = 0x4000000

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

◆ KKhmerScript

const uint32_t CartoTypeCore::KKhmerScript = 0x800000

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

◆ KLaoScript

const uint32_t CartoTypeCore::KLaoScript = 0x20000

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

◆ KLatinScript

const uint32_t CartoTypeCore::KLatinScript = 1

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

◆ KLowerTitleCase

constexpr int CartoTypeCore::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 CartoTypeCore::KMagenta = 0xFFFF00FF

Opaque magenta.

◆ KMalayalamScript

const uint32_t CartoTypeCore::KMalayalamScript = 0x4000

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

◆ KMapUnitsPerMeter

constexpr int32_t CartoTypeCore::KMapUnitsPerMeter = 32
constexpr

Number of map units per projected meter. Map units are used for the coordinates of map objects.

◆ KMaxLabelLength

constexpr int32_t CartoTypeCore::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 CartoTypeCore::KMaxScaleDenominator = 1000000000
constexpr

The maximum legal map scale denominator.

◆ KMinScaleDenominator

constexpr double CartoTypeCore::KMinScaleDenominator = 100
constexpr

The minimum legal map scale denominator.

◆ KMongolianScript

const uint32_t CartoTypeCore::KMongolianScript = 0x1000000

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

◆ KMonospaceStyle

const uint32_t CartoTypeCore::KMonospaceStyle = 32

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

◆ KMyanmarScript

const uint32_t CartoTypeCore::KMyanmarScript = 0x80000

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

◆ KOriyaScript

const uint32_t CartoTypeCore::KOriyaScript = 0x400

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

◆ KOtherScript

const uint32_t CartoTypeCore::KOtherScript = 0x80000000

A bit flag used in typeface matching: other scripts.

◆ KPiDouble

constexpr double CartoTypeCore::KPiDouble = 3.1415926535897932384626433832795
constexpr

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

◆ KPiFloat

constexpr float CartoTypeCore::KPiFloat = 3.1415926535897932384626433832795f
constexpr

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

◆ KRadiansToDegreesDouble

constexpr double CartoTypeCore::KRadiansToDegreesDouble = 180.0 / KPiDouble
constexpr

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

◆ KRadiansToMetres

constexpr double CartoTypeCore::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 CartoTypeCore::KRed = 0xFF0000FF

Opaque red.

◆ KReservedScript

const uint32_t CartoTypeCore::KReservedScript = 0x20000000

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

◆ KScaledDegreesToMetres

constexpr double CartoTypeCore::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 CartoTypeCore::KSerifStyle = 4

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

◆ KSinhalaScript

const uint32_t CartoTypeCore::KSinhalaScript = 0x8000

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

◆ KStandardErrorCodeCount

constexpr int32_t CartoTypeCore::KStandardErrorCodeCount = 68
constexpr

The number of standard error codes.

◆ KStandardTitleCase

constexpr int CartoTypeCore::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 CartoTypeCore::KSymbolScript = 0x40000000

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

◆ KTamilScript

const uint32_t CartoTypeCore::KTamilScript = 0x800

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

◆ KTeluguScript

const uint32_t CartoTypeCore::KTeluguScript = 0x1000

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

◆ KThaiScript

const uint32_t CartoTypeCore::KThaiScript = 0x10000

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

◆ KTibetanScript

const uint32_t CartoTypeCore::KTibetanScript = 0x40000

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

◆ KTransparentBlack

const uint32_t CartoTypeCore::KTransparentBlack = 0x00000000

The 'null color' transparent black.

◆ KUpperTitleCase

constexpr int CartoTypeCore::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 CartoTypeCore::KWGS84Flattening = 1.0 / 298.257223563
constexpr

The flattening constant used by the WGS84 reference ellipsoid.

◆ KWhite

const uint32_t CartoTypeCore::KWhite = 0xFFFFFFFF

Opaque white.

◆ KYellow

const uint32_t CartoTypeCore::KYellow = 0xFF00FFFF

Opaque yellow.