CartoType C++ API 7.8.2, 2022-03-25
for Windows, Linux, Qt and other platforms supporting C++ development
|
Namespaces | |
namespace | TCharCategoryFlag |
namespace | TRoadTypeFlag |
namespace | TTransformType |
Typedefs | |
using | CStreetAddressSearchState = std::unique_ptr< CStreetAddressSearchStateImplementation > |
using | TPointFP = TPoint2< double > |
using | TPoint3FP = TPoint3< double > |
using | CMapObjectArray = std::vector< std::unique_ptr< CMapObject > > |
using | FindHandler = std::function< bool(std::unique_ptr< CMapObject >)> |
using | FindAsyncCallBack = std::function< void(std::unique_ptr< CMapObjectArray > aMapObjectArray)> |
using | FindAsyncGroupCallBack = std::function< void(std::unique_ptr< CMapObjectGroupArray > aMapObjectGroupArray)> |
using | RouterAsyncCallBack = std::function< void(TResult aError, std::unique_ptr< CRoute > aRoute)> |
using | CTrackGeometry = CGeneralGeometry< TTrackPoint > |
using | CMapObjectGroupArray = std::vector< CMapObjectGroup > |
using | CStringDictionary = std::map< CString, CString > |
using | CStringTypeDictionary = std::map< CString, int > |
using | CAbbreviationDictionary = std::map< CString, TAbbreviation > |
using | CStyleSheetDataArray = std::vector< CStyleSheetData > |
Enumerations | |
enum class | TAddressPart { Building , Feature , Street , SubLocality , Locality , Island , SubAdminArea , AdminArea , Country , PostCode } |
enum class | TGeoCodeType { None , Position , Address , Building , Farm , Footpath , Cycleway , SkiRoute , WalkingRoute , FerryRoute , Railway , PedestrianRoad , Track , ServiceRoad , ResidentialRoad , UnclassifiedRoad , TertiaryRoad , SecondaryRoad , PrimaryRoad , TrunkRoad , Motorway , HikingRoute , CyclingRoute , LandFeature , WaterFeature , Locality , Hamlet , PostCode , AdminArea10 , AdminArea9 , Neighborhood , Village , Suburb , Island , AdminArea8 , Town , AdminArea7 , City , AdminArea6 , AdminArea5 , AdminArea4 , AdminArea3 , AdminArea2 , Country , AdminArea1 , Continent } |
enum class | TIntersectionPlace { None = 0 , Before , On , After } |
enum class | TCoordType { Degree , Display , Screen = Display , Map , MapMeter } |
enum class | TPointType { OnCurve , Quadratic , Cubic } |
enum class | TFileType { PNG , JPEG , TIFF , CTM1 , CTMS , KML , CTSQL , CTROUTE , GPX , None = -1 } |
enum class | TWritableMapType { Memory , SQLite , Count , None = -1 } |
enum class | TMapObjectType { Point , Line , Polygon , Array , Count , None = -1 } |
enum class | TVectorTileObjectClipType { Standard , Fill , Border , Highlight = 0x10000 } |
enum class | TNoticePosition { TopLeft , TopRight , BottomLeft , BottomRight , Top , Right , Left , Bottom , Center } |
enum class | TBidiOverride { Neutral , LeftToRight , RightToLeft } |
enum class | TBidiParDir { LeftToRightPreferred , RightToLeftPreferred , LeftToRightForced , RightToLeftForced } |
enum class | TBitmapType { KBitsPerPixelMask = 63 , KColored = 64 , KPalette = 128 , A1 = 1 , A8 = 8 , A16 = 16 , RGB16 = KColored | 16 , RGB24 = KColored | 24 , RGBA32 = KColored | 32 , P8 = KPalette | 8 } |
enum class | TLetterCase { None , Lower , Upper , Title } |
enum class | TCharCategory { Lu = TCharCategoryFlag::Lu , Ll = TCharCategoryFlag::Ll , Lt = TCharCategoryFlag::Lt , Lm = TCharCategoryFlag::Lm , Lo = TCharCategoryFlag::Lo , Mn = TCharCategoryFlag::Mn , Mc = TCharCategoryFlag::Mc , Me = TCharCategoryFlag::Me , Nd = TCharCategoryFlag::Nd , Nl = TCharCategoryFlag::Nl , No = TCharCategoryFlag::No , Pc = TCharCategoryFlag::Pc , Pd = TCharCategoryFlag::Pd , Ps = TCharCategoryFlag::Ps , Pe = TCharCategoryFlag::Pe , Pi = TCharCategoryFlag::Pi , Pf = TCharCategoryFlag::Pf , Po = TCharCategoryFlag::Po , Sm = TCharCategoryFlag::Sm , Sc = TCharCategoryFlag::Sc , Sk = TCharCategoryFlag::Sk , So = TCharCategoryFlag::So , Zs = TCharCategoryFlag::Zs , Zl = TCharCategoryFlag::Zl , Zp = TCharCategoryFlag::Zp , Cc = TCharCategoryFlag::Cc , Cf = TCharCategoryFlag::Cf , Cs = TCharCategoryFlag::Cs , Co = TCharCategoryFlag::Co , Cn = TCharCategoryFlag::Cn } |
enum class | TBidiType { L = TBidiTypeFlag::L , LRE = TBidiTypeFlag::LRE , LRO = TBidiTypeFlag::LRO , R = TBidiTypeFlag::R , AL = TBidiTypeFlag::AL , RLE = TBidiTypeFlag::RLE , RLO = TBidiTypeFlag::RLO , PDF = TBidiTypeFlag::PDF , EN = TBidiTypeFlag::EN , ES = TBidiTypeFlag::ES , ET = TBidiTypeFlag::ET , AN = TBidiTypeFlag::AN , CS = TBidiTypeFlag::CS , NSM = TBidiTypeFlag::NSM , BN = TBidiTypeFlag::BN , B = TBidiTypeFlag::B , S = TBidiTypeFlag::S , WS = TBidiTypeFlag::WS , ON = TBidiTypeFlag::ON } |
enum class | TDrawResult { Success , Overlap , MaxTurnExceeded , PathLengthExceeded , GlyphNotFound , TransformFailed } |
enum class | TPointOfInterestType { None , Airport , Bar , Beach , BusStation , Cafe , Camping , FastFood , Fuel , GolfCourse , Hospital , Hotel , Pharmacy , Police , Restaurant , Shops , SportsCenter , Supermarket , SwimmingPool , Tourism , TrainStation } |
enum class | TFollowMode { None = 0 , Location = KFollowFlagLocation , LocationHeading = KFollowFlagLocation | KFollowFlagHeading , LocationZoom = KFollowFlagLocation | KFollowFlagZoom , LocationHeadingZoom = KFollowFlagLocation | KFollowFlagHeading | KFollowFlagZoom } |
enum class | TLineCap { Butt , Round , Square } |
enum class | TLineJoin { Round , Bevel , Miter } |
enum class | TTextBaseline { Alphabetic , Ideographic , Hanging , Mathematical , Central , Middle , TextBeforeEdge , TextAfterEdge , CentralCaps } |
enum class | TAlign { Center , Standard , Reverse , Left , Right } |
enum class | TPointFormat { Unknown = 0 , Meter = 2 , ScaledDegree = 7 , Meter32nds = 8 } |
enum class | TRouterType { Default , StandardAStar , TurnExpandedAStar , StandardContractionHierarchy , TECH } |
enum class | TTurnType { None , Ahead , BearRight , Right , SharpRight , Around , SharpLeft , Left , BearLeft } |
enum class | TRoundaboutState { None , Enter , Continue , Exit } |
enum class | TRouteProfileType { Drive , Car = Drive , Walk , Cycle , Bicycle = Cycle , Hike } |
enum class | TNavigationState { None , NoPosition , Turn , OffRoute , ReRouteNeeded , ReRouteDone , TurnRound , Arrival } |
enum class | TSideOfRoad { None , Right , Left , Both } |
enum class | TRoadOrientation { None , Forwards , Backwards , Both } |
enum class | TLocationRefType { Line , GeoCoordinate , PointAlongLine , PointWithAccessPoint , Circle , Rectangle , Polygon , ClosedLine } |
enum class | TRouteAccess { Unknown , Accessible , Isolated , NoRoad } |
enum class | TClipType { Inside , MayIntersectAndHasNoCurves , MayIntersectAndHasCurves } |
enum class | TClipOperation { Intersection , Union , Difference , Xor } |
enum class | TPathIntersectionType { Unknown , Separate , Intersects , Contains , Contained } |
enum class | TEllipseAngleType { Shortest , Longest , Positive , Negative } |
enum class | TRoadType { UnknownMajor = 0 , PrimaryLimitedAccess = 0x100 , Motorway = PrimaryLimitedAccess , MotorwayLink = PrimaryLimitedAccess | TRoadTypeFlag::LinkFlag , PrimaryUnlimitedAccess = 0x200 , Trunk = PrimaryUnlimitedAccess , TrunkLink = Trunk | TRoadTypeFlag::LinkFlag , Primary = PrimaryUnlimitedAccess | TRoadTypeFlag::LowerGradeFlag , PrimaryLink = Primary | TRoadTypeFlag::LinkFlag , Secondary = 0x300 , SecondaryLink = Secondary | TRoadTypeFlag::LinkFlag , Tertiary = Secondary | TRoadTypeFlag::LowerGradeFlag , TertiaryLink = Tertiary | TRoadTypeFlag::LinkFlag , Minor = 0x400 , Unclassified = Minor , Residential = Minor | TRoadTypeFlag::LowerGradeFlag , Byway = 0x500 , Track = Byway , AccessRamp = 0x600 , Service = 0x700 , VehicularFerry = 0x800 , PassengerFerry = 0x900 , Path = 0xA00 , Pedestrian = Path , Stairway = 0xB00 , CyclePath = 0xC00 , FootPath = 0xD00 , Other0 = 0xE00 , Other1 = 0xE00 | TRoadTypeFlag::LowerGradeFlag , Other2 = 0xE00 | TRoadTypeFlag::LinkFlag , Other3 = 0xE00 | TRoadTypeFlag::LowerGradeFlag | TRoadTypeFlag::LinkFlag , Other4 = 0xF00 , Other5 = 0xF00 | TRoadTypeFlag::LowerGradeFlag , Other6 = 0xF00 | TRoadTypeFlag::LinkFlag , Other7 = 0xF00 | TRoadTypeFlag::LowerGradeFlag | TRoadTypeFlag::LinkFlag } |
enum class | TStreamEncoding { Utf16 , Utf8 } |
enum class | TStreamEndianness { Big , Little } |
enum class | TAbbreviationType { Any , Start , End } |
enum class | TStringMatchMethodFlag { Exact = 0 , Prefix = 1 , IgnoreSymbols = 2 , FoldAccents = 4 , Fuzzy = 8 , FoldCase = 16 , IgnoreWhitespace = 32 } |
Functions | |
int32_t | Round (double aValue) |
double | Strtod (const char *aString, size_t aLength=UINT32_MAX, const char **aEndPtr=nullptr) noexcept |
double | Strtod (const uint16_t *aString, size_t aLength=UINT32_MAX, const uint16_t **aEndPtr=nullptr) noexcept |
double | Atan2 (double aY, double aX) |
const char * | Version () |
const char * | Build () |
double | GreatCircleDistanceInMeters (double aLong1, double aLat1, double aLong2, double aLat2) |
template<class T > | |
void | Reverse (T *aStart, size_t aLength) |
template<class point_t > | |
double | Area (const point_t *aPointArray, size_t aPointCount) |
template<class contour_t > | |
double | Area (const contour_t &aContour) |
double | SphericalPolygonArea (const TCoordSet &aCoordSet) noexcept |
double | SphericalPolylineLength (const TCoordSet &aCoordSet) noexcept |
double | SphericalPolygonArea (std::function< const TPointFP *()> aNextPoint) |
double | SphericalPolylineLength (std::function< const TPointFP *()> aNextPoint) |
void | GetSphericalAreaAndLength (std::function< const TPointFP *()> aNextPoint, bool aIsPolyline, double *aArea, double *aLength) |
void | GetSphericalAreaAndLength (const TCoordSet &aCoordSet, bool aIsPolyline, double *aArea, double *aLength) noexcept |
double | AzimuthInDegrees (double aLong1, double aLat1, double aLong2, double aLat2) noexcept |
TPointFP | PointAtAzimuth (const TPointFP &aPoint, double aDir, double aDistanceInMetres) noexcept |
double | GreatCircleDistanceInMetersUsingEllipsoid (double aLong1, double aLat1, double aLong2, double aLat2) noexcept |
uint8_t | ReadBigEndian (const uint8_t *aP) |
void | WriteBigEndian (uint8_t *aP, uint8_t aValue) |
int16_t | ReadBigEndian (const int16_t *aP) |
void | WriteBigEndian (int16_t *aP, int16_t aValue) |
template<class DataType , int32_t UnknownValue = INT32_MIN> | |
double | InterpolatedValue (const DataType *aDataStart, int32_t aWidth, int32_t aHeight, int32_t aStride, int32_t aChannels, double aX, double aY, int aChannel) |
std::string | ErrorString (uint32_t aErrorCode) |
CString | UKGridReferenceFromMapPoint (const TPointFP &aPointInMapMeters, int32_t aDigits) |
CString | UKGridReferenceFromDegrees (const TPointFP &aPointInDegrees, int32_t aDigits) |
TRectFP | MapRectFromUKGridReference (const CString &aGridReference) |
TPointFP | MapPointFromUKGridReference (const CString &aGridReference) |
TPointFP | PointInDegreesFromUKGridReference (const CString &aGridReference) |
CString | ExpandStreetName (const MString &aText) |
int32_t | IntAttribute (const char *aThreeLetterCode, int aType) |
bool | MapObjectUserDataLessThan (const std::unique_ptr< CMapObject > &aP, const std::unique_ptr< CMapObject > &aQ) |
template<class MTraverser > | |
void | Traverse (MTraverser &aTraverser, const TPoint *aPoint, size_t aPoints, bool aClosed) |
template<class traverser_t , class point_t > | |
void | Traverse (traverser_t &aTraverser, const point_t *aPoint, size_t aPoints, bool aClosed) |
double | TriangleArea (const TPoint &aA, const TPoint &aB, const TPoint &aC) |
template<class T > | |
size_t | SimplifyContour (T *aPointArray, size_t aPointCount, bool aClosed, double aResolutionArea) |
template<class T > | |
TRect | CBox (T *aPointArray, size_t aPointCount) |
bool | RoadTypeIsOneWay (uint32_t aRoadType) |
int | FileSeek (FILE *aFile, int64_t aOffset, int aOrigin) |
int64_t | FileTell (FILE *aFile) |
const TAbbreviationInfo * | AbbreviationInfo (const char *aLocale) |
CString | CountryToCode (const MString &aCountry) |
CString | CodeToCountry (const MString &aCode) |
double | ClampTo32Bit (double aX) |
CMapObjectArray | Find (CMapDataBaseArray &aMapDataBaseArray, const TFindParam &aFindParam, const COutline &aClip, const COutline &aLocation) |
CMapObjectArray | Find (CMapDataBaseSet &aMapDataBaseSet, const TFindParam &aFindParam, const COutline &aClip, const COutline &aLocation) |
void | FindInLayers (CMapDataBaseSet &aMapDataBaseSet, const MString &aLayers, const TRect &aRect, FindHandler aFindHandler, const MString *aCondition) |
void | FindHelper (CMapDataBaseSet &aMapDataBaseSet, FindHandler aFindHandler, const TFindParam &aFindParam, const TRect &aClipRect, TTimePoint aTimeOut) |
void | FindNearby (CMapDataBaseSet &aMapDataBaseSet, FindHandler aFindHandler, CMapObjectArray &aMapObjectArray, const TFindParam &aFindParam, const TRect &aClipRect, const COutline &aLocation, TTimePoint aTimeOut) |
void | Find (CMapDataBaseSet &aMapDataBaseSet, const TRect &aRect, FindHandler aFindHandler, const MString *aCondition) |
void | FindText (CMapDataBaseSet &aMapDataBaseSet, const MString &aText, FindHandler aFindHandler, TStringMatchMethod aStringMatchMethod, const MString &aLayers, const std::vector< CString > &aAttribs, const TRect *aClip, TTimePoint aTimeOut) |
void | Sort (CMapObjectArray &aObjectArray, const MString *aText, size_t aStartIndex, const COutline *aLocation, double aMapUnitSize) |
uint32_t | MergeableIntAttribute (const CMapObject &aObject) |
void | Merge (CMapObjectArray &aObjectArray, size_t aStartIndex) |
template<class point_t > | |
COutline | OutlineInMapCoords (CFramework &aFramework, const CGeneralGeometry< point_t > &aGeometry) |
void | WriteTrackAsXmlHelper (const CTrackGeometry &aTrack, MOutputStream &aOutput) |
CContour | Ellipse (const TPoint &aCenter, double aRX, double aRY, double aEllipseAngle) |
CContour | Circle (const TPoint &aCenter, double aRadius) |
void | AppendEllipticalArc (CContour &aContour, const TPoint &aCenter, double aRX, double aRY, double aEllipseAngle, double aStartAngle, double aEndAngle, TEllipseAngleType aAngleType, bool aAppendStart) |
void | AppendEllipticalArc (CContour &aContour, const TPoint &aStart, double aRX, double aRY, double aEllipseAngle, bool aLargeArc, bool aSweep, const TPoint &aEnd, bool aAppendStart) |
Variables | |
constexpr int32_t | KMaxLabelLength = 1024 |
constexpr int32_t | KEquatorialRadiusInMetres = 6378137 |
constexpr double | KWGS84Flattening = 1.0 / 298.257223563 |
constexpr double | KRadiansToMetres = KEquatorialRadiusInMetres |
constexpr double | KPiDouble = 3.1415926535897932384626433832795 |
constexpr float | KPiFloat = 3.1415926535897932384626433832795f |
constexpr double | KRadiansToDegreesDouble = 180.0 / KPiDouble |
constexpr double | KDegreesToRadiansDouble = KPiDouble / 180.0 |
constexpr double | KDegreesToMetres = KRadiansToMetres * KDegreesToRadiansDouble |
constexpr double | KScaledDegreesToMetres = KDegreesToMetres / 2097152.0 |
constexpr int32_t | KDefaultTextIndexLevels = 1 |
constexpr double | KMinScaleDenominator = 100 |
constexpr double | KMaxScaleDenominator = 1000000000 |
const uint32_t | KBlack = 0xFF000000 |
const uint32_t | KDarkGrey = 0xFF555555 |
const uint32_t | KDarkGray = 0xFF555555 |
const uint32_t | KDarkRed = 0xFF000080 |
const uint32_t | KDarkGreen = 0xFF008000 |
const uint32_t | KDarkYellow = 0xFF008080 |
const uint32_t | KDarkBlue = 0xFF800000 |
const uint32_t | KDarkMagenta = 0xFF800080 |
const uint32_t | KDarkCyan = 0xFF808000 |
const uint32_t | KRed = 0xFF0000FF |
const uint32_t | KGreen = 0xFF00FF00 |
const uint32_t | KYellow = 0xFF00FFFF |
const uint32_t | KBlue = 0xFFFF0000 |
const uint32_t | KMagenta = 0xFFFF00FF |
const uint32_t | KCyan = 0xFFFFFF00 |
const uint32_t | KGrey = 0xFFAAAAAA |
const uint32_t | KGray = KGrey |
const uint32_t | KWhite = 0xFFFFFFFF |
const uint32_t | KTransparentBlack = 0x00000000 |
constexpr int32_t | KEpsgWebMercator = 3857 |
constexpr int32_t | KEpsgPlateCarree = 4326 |
constexpr TResult | KErrorNone = 0 |
constexpr TResult | KErrorGeneral = 1 |
constexpr TResult | KErrorNoMemory = 2 |
constexpr TResult | KErrorEndOfData = 3 |
constexpr TResult | KErrorTextUnmodifiable = 4 |
constexpr TResult | KErrorTextTruncated = 5 |
constexpr TResult | KErrorNotFound = 6 |
constexpr TResult | KErrorUnimplemented = 7 |
constexpr TResult | KErrorInvalidOutline = 8 |
constexpr TResult | KErrorIo = 9 |
constexpr TResult | KErrorCorrupt = 10 |
constexpr TResult | KErrorUnknownDataFormat = 11 |
constexpr TResult | KErrorNoInverse = 12 |
constexpr TResult | KErrorProjectionOverflow = 13 |
constexpr TResult | KErrorCancel = 14 |
constexpr TResult | KErrorInvalidArgument = 15 |
constexpr TResult | KErrorUnknownVersion = 16 |
constexpr TResult | KErrorOverflow = 17 |
constexpr TResult | KErrorParallelLines = 19 |
constexpr TResult | KErrorNoPalette = 22 |
constexpr TResult | KErrorDuplicate = 23 |
constexpr TResult | KErrorNoProjection = 24 |
constexpr TResult | KErrorPaletteFull = 25 |
constexpr TResult | KErrorInvalidDashArray = 26 |
constexpr TResult | KErrorNoRoute = 28 |
constexpr TResult | KErrorZoomLimitReached = 29 |
constexpr TResult | KErrorAlreadyProjected = 30 |
constexpr TResult | KErrorConditionsTooDeeplyNested = 31 |
constexpr TResult | KErrorNullFont = 32 |
constexpr TResult | KErrorInternetIo = 33 |
constexpr TResult | KErrorDivideByZero = 34 |
constexpr TResult | KErrorTransformFailed = 35 |
constexpr TResult | KErrorPngRead = 36 |
constexpr TResult | KErrorJpgRead = 37 |
constexpr TResult | KErrorNoIntersection = 38 |
constexpr TResult | KErrorInterrupt = 39 |
constexpr TResult | KErrorMapDataBaseFormatMismatch = 40 |
constexpr TResult | KErrorEncryptionKeyTooShort = 41 |
constexpr TResult | KErrorNoEncryptionKey = 42 |
constexpr TResult | KErrorEmergencyMessage = 43 |
constexpr TResult | KErrorAlertMessage = 44 |
constexpr TResult | KErrorCriticalMessage = 45 |
constexpr TResult | KErrorErrorMessage = 46 |
constexpr TResult | KErrorWarningMessage = 47 |
constexpr TResult | KErrorNoticeMessage = 48 |
constexpr TResult | KErrorInfoMessage = 49 |
constexpr TResult | KErrorDebugMessage = 50 |
constexpr TResult | KErrorNotNavigating = 51 |
constexpr TResult | KErrorNoFramework = 52 |
constexpr TResult | KErrorFrameworkAlreadyExists = 53 |
constexpr TResult | KErrorUntransliterable = 54 |
constexpr TResult | KErrorPngWrite = 55 |
constexpr TResult | KErrorReadOnlyMapDataBase = 56 |
constexpr TResult | KErrorProj4 = 57 |
constexpr TResult | KErrorUnlicensed = 58 |
constexpr TResult | KErrorNoRoadsNearStartOfRoute = 59 |
constexpr TResult | KErrorNoRoadsNearEndOfRoute = 60 |
constexpr TResult | KErrorNoRouteConnectivity = 61 |
constexpr TResult | KErrorXmlFeatureNotSupported = 62 |
constexpr TResult | KErrorMapNotFound = 63 |
constexpr TResult | KErrorFontNotFound = 64 |
constexpr TResult | KErrorStyleSheetNotFound = 65 |
constexpr int32_t | KStandardErrorCodeCount = 66 |
constexpr TResult | KErrorXmlRangeStart = 0x10000000 |
constexpr TResult | KErrorXmlRangeEnd = 0x2AFFFFFF |
constexpr uint32_t | KErrorSQLite = 0x30000000 |
constexpr uint32_t | KFollowFlagLocation = 1 |
constexpr uint32_t | KFollowFlagHeading = 2 |
constexpr uint32_t | KFollowFlagZoom = 4 |
const uint32_t | KLatinScript = 1 |
const uint32_t | KGreekScript = 2 |
const uint32_t | KCyrillicScript = 4 |
const uint32_t | KArmenianScript = 8 |
const uint32_t | KHebrewScript = 0x10 |
const uint32_t | KArabicScript = 0x20 |
const uint32_t | KDevanagariScript = 0x40 |
const uint32_t | KBengaliScript = 0x80 |
const uint32_t | KGurmukhiScript = 0x100 |
const uint32_t | KGujaratiScript = 0x200 |
const uint32_t | KOriyaScript = 0x400 |
const uint32_t | KTamilScript = 0x800 |
const uint32_t | KTeluguScript = 0x1000 |
const uint32_t | KKannadaScript = 0x2000 |
const uint32_t | KMalayalamScript = 0x4000 |
const uint32_t | KSinhalaScript = 0x8000 |
const uint32_t | KThaiScript = 0x10000 |
const uint32_t | KLaoScript = 0x20000 |
const uint32_t | KTibetanScript = 0x40000 |
const uint32_t | KMyanmarScript = 0x80000 |
const uint32_t | KGeorgianScript = 0x100000 |
const uint32_t | KHangulScript = 0x200000 |
const uint32_t | KEthiopicScript = 0x400000 |
const uint32_t | KKhmerScript = 0x800000 |
const uint32_t | KMongolianScript = 0x1000000 |
const uint32_t | KHiraganaScript = 0x2000000 |
const uint32_t | KKatakanaScript = 0x4000000 |
const uint32_t | KBopomofoScript = 0x8000000 |
const uint32_t | KHanScript = 0x10000000 |
const uint32_t | KReservedScript = 0x20000000 |
const uint32_t | KSymbolScript = 0x40000000 |
const uint32_t | KOtherScript = 0x80000000 |
const uint32_t | KBoldStyle = 1 |
const uint32_t | KItalicStyle = 2 |
const uint32_t | KSerifStyle = 4 |
const uint32_t | KCursiveStyle = 8 |
const uint32_t | KFantasyStyle = 16 |
const uint32_t | KMonospaceStyle = 32 |
constexpr uint32_t | KArcRoadTypeMask = 0x1F |
constexpr uint32_t | KArcGradientMask = 0xE0 |
constexpr uint32_t | KArcGradientDirectionFlag = 0x80 |
constexpr uint32_t | KArcGradientShift = 5 |
constexpr uint32_t | KArcRoadDirectionMask = 0x300 |
constexpr uint32_t | KArcDriveOnRightRoadDirection = 0 |
constexpr uint32_t | KArcDriveOnLeftRoadDirection = 0x300 |
constexpr uint32_t | KArcOneWayForwardRoadDirection = 0x100 |
constexpr uint32_t | KArcOneWayBackwardRoadDirection = 0x200 |
constexpr uint32_t | KArcRoundaboutFlag = 0x400 |
constexpr uint32_t | KArcTollFlag = 0x800 |
constexpr uint32_t | KArcSpeedLimitMask = 0xFF000 |
constexpr uint32_t | KArcSpeedLimitShift = 12 |
constexpr uint32_t | KArcAccessMask = 0x7FF00000 |
constexpr uint32_t | KArcWrongWayFlag = 0x00100000 |
constexpr uint32_t | KArcBicycleAccessFlag = 0x00200000 |
constexpr uint32_t | KArcMotorCycleAccessFlag = 0x00400000 |
constexpr uint32_t | KArcCarAccessFlag = 0x00800000 |
constexpr uint32_t | KArcHighOccupancyAccessFlag = 0x01000000 |
constexpr uint32_t | KArcLightGoodsAccessFlag = 0x02000000 |
constexpr uint32_t | KArcHeavyGoodsAccessFlag = 0x04000000 |
constexpr uint32_t | KArcBusAccessFlag = 0x08000000 |
constexpr uint32_t | KArcTaxiAccessFlag = 0x10000000 |
constexpr uint32_t | KArcPedestrianAccessFlag = 0x20000000 |
constexpr uint32_t | KArcEmergencyAccessFlag = 0x40000000 |
constexpr uint32_t | KArcOtherAccessFlag = 0x80000000 |
constexpr uint32_t | KArcBicycleAccessOnly = KArcAccessMask & ~(KArcWrongWayFlag | KArcBicycleAccessFlag) |
constexpr uint32_t | KArcAllMotorVehicles = KArcAccessMask & ~(KArcWrongWayFlag | KArcPedestrianAccessFlag | KArcBicycleAccessFlag) |
constexpr uint32_t | KArcBicycleAndPedestrianAccessOnly = KArcAllMotorVehicles |
constexpr uint32_t | KArcNoVehicularAccess = KArcAccessMask & ~(KArcWrongWayFlag | KArcPedestrianAccessFlag) |
constexpr uint32_t | KArcAllVehicles = KArcNoVehicularAccess |
constexpr uint32_t | KArcMotorway = 0 |
constexpr uint32_t | KArcMotorwayLink = 1 |
constexpr uint32_t | KArcTrunkRoad = 2 |
constexpr uint32_t | KArcTrunkRoadLink = 3 |
constexpr uint32_t | KArcPrimaryRoad = 4 |
constexpr uint32_t | KArcPrimaryRoadLink = 5 |
constexpr uint32_t | KArcSecondaryRoad = 6 |
constexpr uint32_t | KArcSecondaryRoadLink = 7 |
constexpr uint32_t | KArcTertiaryRoad = 8 |
constexpr uint32_t | KArcUnclassifiedRoad = 9 |
constexpr uint32_t | KArcResidentialRoad = 10 |
constexpr uint32_t | KArcTrack = 11 |
constexpr uint32_t | KArcServiceRoad = 12 |
constexpr uint32_t | KArcPedestrianRoad = 13 |
constexpr uint32_t | KArcVehicularFerry = 14 |
constexpr uint32_t | KArcPassengerFerry = 15 |
constexpr uint32_t | KArcLivingStreet = 16 |
constexpr uint32_t | KArcCycleway = 17 |
constexpr uint32_t | KArcPath = 18 |
constexpr uint32_t | KArcFootway = 19 |
constexpr uint32_t | KArcBridleway = 20 |
constexpr uint32_t | KArcSteps = 21 |
constexpr uint32_t | KArcUnknownRoadType = 22 |
constexpr uint32_t | KArcUnpavedRoad = 23 |
constexpr uint32_t | KArcOtherRoadType0 = 24 |
constexpr uint32_t | KArcOtherRoadType1 = 25 |
constexpr uint32_t | KArcOtherRoadType2 = 26 |
constexpr uint32_t | KArcOtherRoadType3 = 27 |
constexpr uint32_t | KArcOtherRoadType4 = 28 |
constexpr uint32_t | KArcOtherRoadType5 = 29 |
constexpr uint32_t | KArcOtherRoadType6 = 30 |
constexpr uint32_t | KArcOtherRoadType7 = 31 |
constexpr uint32_t | KArcRoadTypeCount = 32 |
constexpr uint32_t | KArcGradientUp0Index = 0 |
constexpr uint32_t | KArcGradientUp1Index = 1 |
constexpr uint32_t | KArcGradientUp2Index = 2 |
constexpr uint32_t | KArcGradientUp3Index = 3 |
constexpr uint32_t | KArcGradientDown0Index = 4 |
constexpr uint32_t | KArcGradientDown1Index = 5 |
constexpr uint32_t | KArcGradientDown2Index = 6 |
constexpr uint32_t | KArcGradientDown3Index = 7 |
constexpr uint32_t | KArcGradientCount = 8 |
const char *const | KArcGradientName [KArcGradientCount] |
constexpr int | KStandardTitleCase = 0 |
constexpr int | KLowerTitleCase = 1 |
constexpr int | KUpperTitleCase = 2 |
const double | CT_DBL_MAX = 1.7976931348623158e+308 |
A namespace for the CartoType library.
using CartoType::CAbbreviationDictionary = typedef std::map<CString, TAbbreviation> |
A type for a class mapping CString objects to abbreviations.
using CartoType::CMapObjectArray = typedef std::vector<std::unique_ptr<CMapObject> > |
A type for arrays of map objects returned by search functions.
using CartoType::CMapObjectGroupArray = typedef std::vector<CMapObjectGroup> |
A type for arrays of map object groups returned by search functions.
using CartoType::CStreetAddressSearchState = typedef std::unique_ptr<CStreetAddressSearchStateImplementation> |
The state of a street address search. It is used to iterate through all the objects found satisfying the search parameters. Each iteration returns all the streets in a certain combination of country, admin area and locality.
using CartoType::CStringDictionary = typedef std::map<CString, CString> |
using CartoType::CStringTypeDictionary = typedef std::map<CString,int> |
A type for a class mapping CString objects to integers.
using CartoType::CStyleSheetDataArray = typedef std::vector<CStyleSheetData> |
A set of style sheet data that may consist of more than one style sheet.
using CartoType::CTrackGeometry = typedef CGeneralGeometry<TTrackPoint> |
A type for a sequence of track points.
using CartoType::FindAsyncCallBack = typedef std::function<void(std::unique_ptr<CMapObjectArray> aMapObjectArray)> |
A type for functions called by the asynchronous Find function.
using CartoType::FindAsyncGroupCallBack = typedef std::function<void(std::unique_ptr<CMapObjectGroupArray> aMapObjectGroupArray)> |
A type for functions called by the asynchronous Find function for map object group arrays.
using CartoType::FindHandler = typedef std::function<bool(std::unique_ptr<CMapObject>)> |
A type for internal functions to handle objects returned by search functions.
using CartoType::RouterAsyncCallBack = typedef std::function<void(TResult aError,std::unique_ptr<CRoute> aRoute)> |
A type for functions called by the asynchronous routing function.
using CartoType::TPoint3FP = typedef TPoint3<double> |
A double-precision floating-point 3D point class.
using CartoType::TPointFP = typedef TPoint2<double> |
A double-precision floating-point 2D point class.
|
strong |
|
strong |
Address part codes used when searching for address parts separately.
|
strong |
Alignments used for multi-line text.
|
strong |
The override status during bidirectional reordering.
|
strong |
The paragraph direction used during bidirectional reordering.
|
strong |
The bidirectional type of a character as used in the Unicode Bidirectional Algorithm.
|
strong |
An enumerated type for supported bitmap types. The number of bits per pixel is held in the low 6 bits.
|
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.
|
strong |
Types of clipping done by the general clip function COutline MPath::Clip(TClipOperation aClipOperation,const MPath& aClip) const.
|
strong |
A type to label different relationships a clip rectangle has with a path, to decide what sort of clipping is needed.
|
strong |
Coordinate types.
|
strong |
Result codes for drawing operations.
|
strong |
Flags used for appending ellipses to determine the angle between start and end point or start and end angle.
|
strong |
File types of interest to CartoType.
Enumerator | |
---|---|
PNG | PNG (Portable Network Graphics) image files. |
JPEG | JPEG (Joint Photographic Expert Group) image files. |
TIFF | TIFF (Tagged Image File Format) image files. |
CTM1 | CTM1 (CartoType Map Data Type 1) map data files. |
CTMS | CTMS (CartoType Map Data, Serialized) map data files. |
KML | KML (Keyhole Markup Language) map data files. |
CTSQL | CTSQL (CartoType SQLite format) map data files. |
CTROUTE | CTROUTE (CartoType XML route) files. |
GPX | GPX (GPS Exchange) files. |
None | Unknown or unspecified file type. |
|
strong |
Flags controlling the way the map follows the user location and heading and automatically zooms.
|
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.
|
strong |
|
strong |
The case of letters and strings in Latin, Greek, Cyrillic and other alphabetic scripts.
|
strong |
Methods of adding caps to the ends of lines created as envelopes of open paths.
|
strong |
|
strong |
The type of a location reference used for traffic information.
|
strong |
An enumerated type for map objects.
|
strong |
States of the navigation system.
|
strong |
Positions for notices like the legend or scale bar. Use TExtendedNoticePosition for greater control.
|
strong |
|
strong |
The format used for points in CTM1 data. These numbers must fit into 8 bits for the moment because of the way they are stored in the CTM1 file. The values are discontinuous because several obsolete values have been discarded.
|
strong |
Types of place to search for in the 'find nearby' parameters.
|
strong |
Types used by TOutlinePoint.
Enumerator | |
---|---|
OnCurve | A point on the curve. |
Quadratic | A control point for a quadratic (conic) Bezier spline curve. |
Cubic | A control point for a cubic Bezier spline curve. |
|
strong |
The orientation of a path along a road: used in traffic information.
|
strong |
Road types. Note that items of type TRoadType are often combined with other TRoadTypeFlag values. Therefore it is often necessary to mask a TRoadType with TRoadTypeFlags::RoadTypeMask to obtain one of the enumerated TRoadType values.
|
strong |
|
strong |
The accessibility of a point for routing purposes. The CFramework::RouteAccess function, if implemented for the current router, returns a value of this type.
A point is defined as accessible if it is connected to at least 1000 other route segments; thus accessibility is not defined correctly for very small maps.
|
strong |
Constants used to select frequently-used route profiles.
|
strong |
Types of router; used when selecting a router type.
|
strong |
The side of the road: used in traffic information.
|
strong |
The encoding for reading or writing strings.
|
strong |
The endianness for data streams.
|
strong |
Flags and constants to tell text searching how to match search terms with found strings.
|
strong |
Baselines used for aligning text.
|
strong |
Turn types on a route. Turns at junctions are classified by dividing the full circle into 45-degree segments, except for sharp turns left and right, which encompass everything up to an actual U-turn, and left and right forks, for which there are special rules to avoid classifying them as ahead.
The actual turn angle is also given in the TTurn class.
|
strong |
Values used in the user-data value of objects in the vector tile drawing system.
|
strong |
const TAbbreviationInfo * CartoType::AbbreviationInfo | ( | const char * | aLocale | ) |
Returns the abbreviation and letter-case conversion information for a given locale, or null if information for the locale is not found.
void CartoType::AppendEllipticalArc | ( | CContour & | aContour, |
const TPoint & | aCenter, | ||
double | aRX, | ||
double | aRY, | ||
double | aEllipseAngle, | ||
double | aStartAngle, | ||
double | aEndAngle, | ||
TEllipseAngleType | aAngleType, | ||
bool | aAppendStart | ||
) |
Append an arc of an ellipse using center parameterization. aCenter is in 64ths of pixels. if aAppendStart is true, the start point is also appended to the contour. Implementation notes: The arc is divided into sections of less than pi/2. For each section three points are appended: two control points and the end point.
void CartoType::AppendEllipticalArc | ( | CContour & | aContour, |
const TPoint & | aStart, | ||
double | aRX, | ||
double | aRY, | ||
double | aEllipseAngle, | ||
bool | aLargeArc, | ||
bool | aSweep, | ||
const TPoint & | aEnd, | ||
bool | aAppendStart | ||
) |
Append an arc of an ellipse using endpoint parameterization. The input points are in 64ths of pixels. If aAppendStart is true, the start point is also appended to the contour.
|
inline |
Returns the area of a polygon represented as a vector of points with members iX and iY.
|
inline |
Returns the area of a polygon made of points with members iX and iY.
|
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.
|
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.
const char * CartoType::Build | ( | ) |
Returns the current CartoType build as a string.
TRect CartoType::CBox | ( | T * | aPointArray, |
size_t | aPointCount | ||
) |
Returns the axis-aligned bounding box of a sequence of points, treating control points as ordinary points.
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.
|
inline |
Clamps a floating point number to the range supported by signed 32-bit integers.
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.
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.
CContour CartoType::Ellipse | ( | const TPoint & | aCenter, |
double | aRX, | ||
double | aRY, | ||
double | aEllipseAngle | ||
) |
Create a contour that is an ellipse. The center is specified in 64ths of pixels.
std::string CartoType::ErrorString | ( | uint32_t | aErrorCode | ) |
Returns a short description of an error, given its code.
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.
|
inline |
An fseek-compatible function for moving to a position in a file, specifying it using a 64-bit signed integer.
|
inline |
An ftell-compatible function for getting the current position in a file, returning a 64-bit signed integer.
CMapObjectArray CartoType::Find | ( | CMapDataBaseArray & | aMapDataBaseArray, |
const TFindParam & | aFindParam, | ||
const COutline & | aClip, | ||
const COutline & | aLocation | ||
) |
A low-level general search function, allowing any combination of clip rectangle, choice of layers, choice of attributes, text and string match method, and condition.
aClip contains aFindParam.iClip, converted to map coordinates. aLocation contains aFindParam.iLocation, converted to map coordinates. This low-level function cannot do the conversion itself because it has no access to the current map scale or perspective transform.
CMapObjectArray CartoType::Find | ( | CMapDataBaseSet & | aMapDataBaseSet, |
const TFindParam & | aFindParam, | ||
const COutline & | aClip, | ||
const COutline & | aLocation | ||
) |
A low-level general search function, allowing any combination of clip rectangle, choice of layers, choice of attributes, text and string match method, and condition.
aClip contains aFindParam.iClip, converted to map coordinates. aLocation contains aFindParam.iLocation, converted to map coordinates. This low-level function cannot do the conversion itself because it has no access to the current map scale or perspective transform.
void CartoType::Find | ( | CMapDataBaseSet & | aMapDataBaseSet, |
const TRect & | aRect, | ||
FindHandler | aFindHandler, | ||
const MString * | aCondition | ||
) |
Finds objects in aRect, which is in map coordinates. The objects that are returned are unprojected.
The number of objects returned can be limited by setting aMaxObjects to an appropriate value.
if aCondition is non-null it is a style sheet expression (e.g., "Type==2") which must be satisfied by the objects.
void CartoType::FindHelper | ( | CMapDataBaseSet & | aMapDataBaseSet, |
FindHandler | aFindHandler, | ||
const TFindParam & | aFindParam, | ||
const TRect & | aClipRect, | ||
TTimePoint | aTimeOut | ||
) |
An internal function used in the implementation of the general find functions.
void CartoType::FindInLayers | ( | CMapDataBaseSet & | aMapDataBaseSet, |
const MString & | aLayers, | ||
const TRect & | aRect, | ||
FindHandler | aFindHandler, | ||
const MString * | aCondition | ||
) |
Finds objects in named layers in aRect, which is in map coordinates. The objects that are returned are unprojected.
aLayers is a space or comma separated list of layers. Each layer may contain the wild cards '*' and '?', in which case all matching layers are searched. If a layer ends in '/' it matches itself without the final '/', and any layers starting with 'layer/'. Layers are searched once only even if they match more than one item in the list of layers. Layers are searched in the order of the list.
if aCondition is non-null it is a style sheet expression (e.g., "Type==2") which must be satisfied by the objects.
void CartoType::FindNearby | ( | CMapDataBaseSet & | aMapDataBaseSet, |
FindHandler | aFindHandler, | ||
CMapObjectArray & | aMapObjectArray, | ||
const TFindParam & | aFindParam, | ||
const TRect & | aClipRect, | ||
const COutline & | aLocation, | ||
TTimePoint | aTimeOut | ||
) |
A special function to handle searches where aFindParam.iLocation is set: that is, finding places nearby.
void CartoType::FindText | ( | CMapDataBaseSet & | aMapDataBaseSet, |
const MString & | aText, | ||
FindHandler | aFindHandler, | ||
TStringMatchMethod | aStringMatchMethod, | ||
const MString & | aLayers, | ||
const std::vector< CString > & | aAttribs, | ||
const TRect * | aClip, | ||
TTimePoint | aTimeOut | ||
) |
Finds objects with the value aText in selected layers and attributes. If aLayers is empty all layers are searched, otherwise only the named layers are searched. Layer names may contain the wild cards * and ?. If aAttribs is empty all attributes are searched, otherwise only the named attributes are searched. To name the label attribute (the main name of an object) use the empty string.
|
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.
void CartoType::GetSphericalAreaAndLength | ( | std::function< const TPointFP *()> | aNextPoint, |
bool | aIsPolyline, | ||
double * | aArea, | ||
double * | aLength | ||
) |
Gets the area and length of a polygon, or the length of a polyline, in square metres and metres. The points are defined in degrees of latitude (y) and longitude (x). The function aNextPoint must return all the points in order then return null to indicate that there are no more points. The parameter aIsPolyline is true if the points represent a polyline, otherwise the points represent a polygon. The return values aArea and aLength are filled in only if non-null. If aPolyline is true, only aLength is filled in.
|
inline |
Finds the great-circle distance in metres, assuming a spherical earth, between two lat-long points in degrees.
|
noexcept |
Finds the great-circle distance in meters between two lat-long points in degrees, using the WGS84 ellipsoid.
|
inline |
Constructs an integer attribute from an optional three-letter code, placed in the high 16 bits by encoding each letter in five bits, and a type number placed in the low 16 bits.
The three-letter code is used only if it consists of exactly three lower-case letters in the range a...z.
Three-letter codes are used for mnemonic purposes, as for example "pub" for a public house, and can be tested easily in style sheets.
double CartoType::InterpolatedValue | ( | const DataType * | aDataStart, |
int32_t | aWidth, | ||
int32_t | aHeight, | ||
int32_t | aStride, | ||
int32_t | aChannels, | ||
double | aX, | ||
double | aY, | ||
int | aChannel | ||
) |
Uses bilinear interpolation to get the value at (aX,aY) from a rectangular table of data. Each data item has aChannels channels, and each channel takes up aWidth * sizeof(DataType) bytes. The UnknownValue is ignored when interpolating.
|
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.
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.
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.
void CartoType::Merge | ( | CMapObjectArray & | aObjectArray, |
size_t | aStartIndex | ||
) |
Merges map objects that are parts of the same larger object, like sections of the same road.
uint32_t CartoType::MergeableIntAttribute | ( | const CMapObject & | aObject | ) |
Extracts the mergeable part of the integer attribute: the road type, or the whole attribute if the object isn't a road.
COutline CartoType::OutlineInMapCoords | ( | CFramework & | aFramework, |
const CGeneralGeometry< point_t > & | aGeometry | ||
) |
Creates a COutline object in map coordinates from a Geometry object.
|
noexcept |
Finds the point in degrees at a certain distance and azimuth direction from a starting point. This function uses the WGS84 ellipsoid.
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.
|
inline |
Reads a big-endian 16-bit integer from aP.
|
inline |
Reads an 8-bit integer from aP. Used by InterpolatedValue, which requires a function of this name even when endianness is irrelevant.
|
inline |
Reverses an array of objects of type T.
|
inline |
Returns true if a road type stored in an integer represents a one-way road.
|
inline |
Rounds a floating-point value to the nearest integer. Does not use floor() because it is said to be slow on some platforms.
size_t CartoType::SimplifyContour | ( | T * | aPointArray, |
size_t | aPointCount, | ||
bool | aClosed, | ||
double | aResolutionArea | ||
) |
A templated function to simplify a contour of any type. Returns the new number of points, after simplification.
Simplification consists in removing all points with an area less than aResolutionArea. A point's area is the area of the triangle made by the point and its two neighbours.
The start and end of an open contour are not removed. Closed contours may be reduced to nothing.
void CartoType::Sort | ( | CMapObjectArray & | aObjectArray, |
const MString * | aText, | ||
size_t | aStartIndex, | ||
const COutline * | aLocation, | ||
double | aMapUnitSize | ||
) |
Sorts objects according to how good a match they are with aText (if non-empty), their importance, and optionally their distance from a location.
|
noexcept |
Gets the area of a polygon in square metres. The polygon is defined in degrees of latitude (y) and longitude (x).
double CartoType::SphericalPolygonArea | ( | std::function< const TPointFP *()> | aNextPoint | ) |
Gets the area of a polygon in square metres. The polygon is defined in degrees of latitude (y) and longitude (x). The function aNextPoint must return all the points of the polygon in order then return null to indicate that there are no more points.
|
noexcept |
Gets the length of a line, in meters, defined by points of latitude (y) and longitude (x), using great-circle distances.
double CartoType::SphericalPolylineLength | ( | std::function< const TPointFP *()> | aNextPoint | ) |
Gets the length of a polyline in square metres. The polyline is defined in degrees of latitude (y) and longitude (x). The function aNextPoint must return all the points of the polyline in order then return null to indicate that there are no more points.
|
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.
|
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.
void CartoType::Traverse | ( | MTraverser & | aTraverser, |
const TPoint * | aPoint, | ||
size_t | aPoints, | ||
bool | aClosed | ||
) |
Traverses a sequence of TPoint objects, extracting lines and curves and calling functions to process them.
The functions called are
To start a new contour, move to aPoint without drawing a line and set the current point to aPoint:
void MoveTo(const TPoint& aPoint)
To draw a line from the current point to aPoint and set the current point to aPoint:
void LineTo(const TPoint& aPoint)
void CartoType::Traverse | ( | traverser_t & | aTraverser, |
const point_t * | aPoint, | ||
size_t | aPoints, | ||
bool | aClosed | ||
) |
Traverses a sequence of outline point objects, extracting lines and curves and calling functions to process them.
The functions called are
To start a new contour, move to aPoint without drawing a line and set the current point to aPoint:
void MoveTo(const TPoint& aPoint)
To draw a line from the current point to aPoint and set the current point to aPoint:
void LineTo(const TPoint& aPoint)
To draw a quadratic spline from the current point to aPoint2, using aPoint1 as the off-curve control point, and set the current point to aPoint2:
void QuadraticTo(const TPoint& aPoint1,const TPoint& aPoint2)
To draw a cubic spline from the current point to aPoint3, using aPoint1 and aPoint2 as the off-curve control points, and set the current point to aPoint3:
void CubicTo(const TPoint& aPoint1,const TPoint& aPoint2,const TPoint& aPoint3)
Returns the area of a triangle made from the points aA, aB, aC.
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.
CString CartoType::UKGridReferenceFromMapPoint | ( | const TPointFP & | aPointInMapMeters, |
int32_t | aDigits | ||
) |
Converts a point in map meters in the Ordnance Survey projection into a UK Ordnance Survey national grid reference, using aDigits as the number of digits per coordinate; this value is clamped to the range 0...5. Five-digit references are accurate to a meter.
Returns an empty string if the point is outside the UK national grid bounds.
const char * CartoType::Version | ( | ) |
Returns the current CartoType version as a string of the form MAJOR.MINOR.
|
inline |
Writes a big-endian 16-bit integer to aP.
|
inline |
Writes an 8-bit integer to aP. Used by InterpolatedValue, which requires a function of this name even when endianness is irrelevant.
void CartoType::WriteTrackAsXmlHelper | ( | const CTrackGeometry & | aTrack, |
MOutputStream & | aOutput | ||
) |
An internal function to write a track in GPX format.
const double CartoType::CT_DBL_MAX = 1.7976931348623158e+308 |
This CartoType-specific version of DBL_MAX is supplied to avoid the bug in C++ Builder, which defines DBL_MAX as a very small number. It uses a different name from DBL_MAX in case DBL_MAX is defined as a macro.
const uint32_t CartoType::KArabicScript = 0x20 |
A bit flag used in typeface matching: the Arabic script.
|
constexpr |
A bit mask used by access restrictions in a route profile, for access restrictions not including the 'other access' flag.
|
constexpr |
A combination of bit flags used by access restrictions in a route profile: access flags affect all motor vehicles.
|
constexpr |
A combination of bit flags used by access restrictions in a route profile: access flags affect all vehicles; synonym of KArcNoVehicularAccess.
|
constexpr |
A bit flag used by access restrictions in a route profile: no access for bicycles.
|
constexpr |
A combination of bit flags used by access restrictions in a route profile: bicycle access only.
|
constexpr |
A combination of bit flags used by access restrictions in a route profile: bicycle and pedestrian access only; synonym of KArcAllMotorVehicles.
|
constexpr |
The index for bridleways in the speed and bonus arrays in TRouteProfile.
|
constexpr |
A bit flag used by access restrictions in a route profile: no access for buses.
|
constexpr |
A bit flag used by access restrictions in a route profile: no access for cars.
|
constexpr |
The index for cycleways in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The road direction value for drive-on-left: used by routers.
|
constexpr |
The road direction value for drive-on-right: used by routers.
|
constexpr |
A bit flag used by access restrictions in a route profile: no access for emergency vehicles.
|
constexpr |
The index for footways in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The size of the gradient arrays in TRouteProfile.
|
constexpr |
A bit flag for road types: used by routers.
|
constexpr |
The index for a very slight downhill gradient, or no gradient, in the gradient arrays in TRouteProfile.
|
constexpr |
The index for a gentle downhill gradient in the gradient arrays in TRouteProfile.
|
constexpr |
The index for a steep downhill gradient in the gradient arrays in TRouteProfile.
|
constexpr |
The index for a very steep downhill gradient in the gradient arrays in TRouteProfile.
|
constexpr |
A bit mask for road gradents: used by routers.
const char* const CartoType::KArcGradientName[KArcGradientCount] |
The names of the different gradient ranges, as used in serialized XML rout profiles.
|
constexpr |
The number of bits by which the gradient field is shifted: used by routers.
|
constexpr |
The index for a very slight uphill gradient, or no gradient, in the gradient arrays in TRouteProfile.
|
constexpr |
The index for a gentle uphill gradient in the gradient arrays in TRouteProfile.
|
constexpr |
The index for a steep uphill gradient in the gradient arrays in TRouteProfile.
|
constexpr |
The index for a very steep uphill gradient in the gradient arrays in TRouteProfile.
|
constexpr |
A bit flag used by access restrictions in a route profile: no access for heavy goods vehicles.
|
constexpr |
A bit flag used by access restrictions in a route profile: no access for high occupancy vehicles.
|
constexpr |
A bit flag used by access restrictions in a route profile: no access for light goods vehicles.
|
constexpr |
The index for living streets in the speed and bonus arrays in TRouteProfile.
|
constexpr |
A bit flag used by access restrictions in a route profile: no access for motorcycles.
|
constexpr |
The index for motorways in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for motorway links (ramps) in the speed and bonus arrays in TRouteProfile.
|
constexpr |
A combination of bit flags used by access restrictions in a route profile: no vehicular access.
|
constexpr |
The road direction value for one-way backward: used by routers.
|
constexpr |
The road direction value for one-way forward: used by routers.
|
constexpr |
A bit flag used by access restrictions in a route profile: other access restrictions exist such as weight, length, width, height or for vehicles carrying hazardous materials.
|
constexpr |
The index for other road type 0 in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for other road type 1 in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for other road type 2 in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for other road type 3 in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for other road type 4 in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for other road type 5 in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for other road type 6 in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for other road type 7 in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for passenger ferries in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for paths in the speed and bonus arrays in TRouteProfile.
|
constexpr |
A bit flag used by access restrictions in a route profile: no access for pedestrians.
|
constexpr |
The index for pedestrian roads in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for primary roads in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for primary road links (ramps) in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for residential roads in the speed and bonus arrays in TRouteProfile.
|
constexpr |
A bit mask for road directions: used by routers.
|
constexpr |
The number of road types and the size of the speed and bonus arrays in TRouteProfile.
|
constexpr |
A bit mask for road types: used by routers.
|
constexpr |
A bit flag for roundabouts: used by routers.
|
constexpr |
The index for secondary roads in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for secondary road links (ramps) in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for service roads and access roads in the speed and bonus arrays in TRouteProfile.
|
constexpr |
A bit mask for the speed limit in kph if known (zero means no known speed limit): used by routers.
|
constexpr |
The number of bits by which the speed limit field is shifted: used by routers.
|
constexpr |
The index for steps in the speed and bonus arrays in TRouteProfile.
|
constexpr |
A bit flag used by access restrictions in a route profile: no access for taxis.
|
constexpr |
The index for tertiary roads in the speed and bonus arrays in TRouteProfile.
|
constexpr |
A bit flag for toll roads: used by routers.
|
constexpr |
The index for tracks in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for trunk roads in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for trunk road links (ramps) in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for unclassified roads in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for roads of unknown type in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for unpaved (unsurfaced) roads in the speed and bonus arrays in TRouteProfile.
|
constexpr |
The index for vehicular ferries in the speed and bonus arrays in TRouteProfile.
|
constexpr |
A bit flag used by access restrictions in a route profile: this arc goes the wrong way along a one-way road but it can be used by pedestrians and emergency vehicles.
const uint32_t CartoType::KArmenianScript = 8 |
A bit flag used in typeface matching: the Armenian script.
const uint32_t CartoType::KBengaliScript = 0x80 |
A bit flag used in typeface matching: the Bengali script.
const uint32_t CartoType::KBlack = 0xFF000000 |
Opaque black.
const uint32_t CartoType::KBlue = 0xFFFF0000 |
Opaque blue.
const uint32_t CartoType::KBoldStyle = 1 |
Constants used to refer to styles in TTypefaceAttrib, etc. These are flags used in a 32-bit word. The bit flag used to select bold face in TTypefaceAttrib::Style, etc.
const uint32_t CartoType::KBopomofoScript = 0x8000000 |
A bit flag used in typeface matching: the Bopomofo script.
const uint32_t CartoType::KCursiveStyle = 8 |
The bit flag used to select a cursive font in TTypefaceAttrib::Style, etc.
const uint32_t CartoType::KCyan = 0xFFFFFF00 |
Opaque cyan.
const uint32_t CartoType::KCyrillicScript = 4 |
A bit flag used in typeface matching: the Cyrillic script.
const uint32_t CartoType::KDarkBlue = 0xFF800000 |
Opaque dark blue.
const uint32_t CartoType::KDarkCyan = 0xFF808000 |
Opaque dark cyan.
const uint32_t CartoType::KDarkGray = 0xFF555555 |
Opaque dark gray.
const uint32_t CartoType::KDarkGreen = 0xFF008000 |
Opaque dark green.
const uint32_t CartoType::KDarkGrey = 0xFF555555 |
Opaque dark grey.
const uint32_t CartoType::KDarkMagenta = 0xFF800080 |
Opaque dark magenta.
const uint32_t CartoType::KDarkRed = 0xFF000080 |
Opaque dark red.
const uint32_t CartoType::KDarkYellow = 0xFF008080 |
Opaque dark yellow.
|
constexpr |
The standard number of levels of the text index to load into RAM when loading a CTM1 file.
|
constexpr |
A factor to convert degrees to metres, using the semi-major axis (equatorial radius) used by the WGS 84 datum.
|
constexpr |
A factor to convert degrees to radians: the number of radians in a degree.
const uint32_t CartoType::KDevanagariScript = 0x40 |
A bit flag used in typeface matching: the Devanagari script.
|
constexpr |
The EPSG code for the Plate Carree projection. Used by TTileParam.
|
constexpr |
The EPSG code for the Web Mercator projection. Used by TTileParam.
|
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).
|
constexpr |
A code for standard alert messages.
|
constexpr |
There was an attempt to project a map object that had already been projected.
|
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.
|
constexpr |
Conditions are too deeply nested in the style sheet.
|
constexpr |
Use KErrorCorrupt when illegal values are found when reading data from a file or other serialized form.
|
constexpr |
A code for standard critical messages.
|
constexpr |
A code for standard debug messages.
|
constexpr |
Division by zero in an interpreted expression.
|
constexpr |
An attempt was made to insert a duplicate object into a collection class that does not allow duplicates.
|
constexpr |
A code for standard emergency messages.
|
constexpr |
A key supplied for encryption was too short.
|
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.
|
constexpr |
A code for standard error messages.
|
constexpr |
A font file was not found.
|
constexpr |
The global framework object already exists.
|
constexpr |
Use KErrorGeneral where an error has occurred but no other CartoType error is applicable. For example, this error code can be used when FreeType returns an error code for illegal TrueType hinting instructions.
|
constexpr |
A code for standard information messages.
|
constexpr |
An attempt to read data from the internet failed.
|
constexpr |
An operation was interrupted, for example by another thread writing to a shared flag.
|
constexpr |
This error is returned when an invalid argument has been given to a function.
|
constexpr |
The dash array for drawing strokes is invalid.
|
constexpr |
If the graphics system detects an invalid outline, such as one that starts with a cubic control point, it returns KErrorInvalidOutline.
|
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).
|
constexpr |
Reading a bitmap from JPG format failed.
|
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.
|
constexpr |
A map file was not found.
|
constexpr |
No encryption key has been set.
|
constexpr |
The global framework object does not exist.
|
constexpr |
An object did not intersect a specified region.
|
constexpr |
This error is returned by transformation inversion if the transformation has no inverse.
|
constexpr |
Use KErrorNoMemory when an attempted memory allocation fails.
|
constexpr |
No error; a successful result.
|
constexpr |
An attempt was made to draw a bitmap needing a color palette but no palette was provided.
|
constexpr |
The projection for converting latitude and longitude to map coordinates is unknown or unavailable.
|
constexpr |
No route could be created because there were no roads near the end point of a route section.
|
constexpr |
No route could be created because there were no roads near the start point of a route section.
|
constexpr |
A route was needed by the navigation system but no route was available.
|
constexpr |
No route could be created because the start and end point were not connected.
|
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.
|
constexpr |
A code for standard notice messages.
|
constexpr |
A function has been called which is available only when navigating.
|
constexpr |
There was an attempt to use a null font for drawing text.
|
constexpr |
This error is returned by the base library when reading data or calculations result in overflow.
|
constexpr |
A palette is full and no new entries can be added.
|
constexpr |
The error code returned by line intersection algorithms when the lines are parallel.
|
constexpr |
Reading a bitmap from PNG format failed.
|
constexpr |
Writing a bitmap to PNG format failed.
|
constexpr |
There was an error in the PROJ.4 projection library error other than a projection overflow.
|
constexpr |
This error is returned by the projection system if the projection causes overflow.
|
constexpr |
There was an attempt to write to a read-only map database.
|
constexpr |
The base of error codes for returning SQLite errors. The SQLite error code is placed in the lower two bytes.
|
constexpr |
A style sheet was not found.
|
constexpr |
KErrorTextTruncated is returned when text inserted into a string derived from MString is too long for a fixed-size buffer.
|
constexpr |
KErrorTextUnmodifiable is returned when an attempt is made to modify an unmodifiable string represented by a class derived from MString.
|
constexpr |
A transform failed because an argument or result was out of range.
|
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.
|
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.
|
constexpr |
This error is returned by a data reader when it cannot deal with the data version.
|
constexpr |
A function was called from the unlicensed version of CartoType that is available only in the licensed version.
|
constexpr |
A string was not transliterable.
|
constexpr |
A code for standard warning messages.
|
constexpr |
An unsupported feature was requested from the XML parser.
|
constexpr |
The end of the range of errors in XML parsing or in the style sheet format.
|
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).
|
constexpr |
There was an attempt to zoom beyond the legal zoom limits for a map.
const uint32_t CartoType::KEthiopicScript = 0x400000 |
A bit flag used in typeface matching: the Ethiopic script.
const uint32_t CartoType::KFantasyStyle = 16 |
The bit flag used to select a 'fantasy' font (as defined in http://www.w3.org/TR/REC-CSS2/fonts.html#generic-font-families) in TTypefaceAttrib::Style, etc.
|
constexpr |
A flag to rotate the map to the user's heading.
|
constexpr |
A flag to make the center of the map follow the user's location.
|
constexpr |
A flag to set the map to a suitable zoom level for the user's speed.
const uint32_t CartoType::KGeorgianScript = 0x100000 |
A bit flag used in typeface matching: the Georgian script.
const uint32_t CartoType::KGray = KGrey |
Opaque gray.
const uint32_t CartoType::KGreekScript = 2 |
A bit flag used in typeface matching: the Greek script.
const uint32_t CartoType::KGreen = 0xFF00FF00 |
Opaque green.
const uint32_t CartoType::KGrey = 0xFFAAAAAA |
Opaque grey.
const uint32_t CartoType::KGujaratiScript = 0x200 |
A bit flag used in typeface matching: the Gujarati script.
const uint32_t CartoType::KGurmukhiScript = 0x100 |
A bit flag used in typeface matching: the Gurmukhi script.
const uint32_t CartoType::KHangulScript = 0x200000 |
A bit flag used in typeface matching: the Hangul script.
const uint32_t CartoType::KHanScript = 0x10000000 |
A bit flag used in typeface matching: the Han script.
const uint32_t CartoType::KHebrewScript = 0x10 |
A bit flag used in typeface matching: the Hebrew script.
const uint32_t CartoType::KHiraganaScript = 0x2000000 |
A bit flag used in typeface matching: the Japanese Hiragana script.
const uint32_t CartoType::KItalicStyle = 2 |
The bit flag used to select italics in styles in TTypefaceAttrib::Style, etc.
const uint32_t CartoType::KKannadaScript = 0x2000 |
A bit flag used in typeface matching: the Kannada script.
const uint32_t CartoType::KKatakanaScript = 0x4000000 |
A bit flag used in typeface matching: the Japanese Katakana script.
const uint32_t CartoType::KKhmerScript = 0x800000 |
A bit flag used in typeface matching: the Khmer script.
const uint32_t CartoType::KLaoScript = 0x20000 |
A bit flag used in typeface matching: the Lao script.
const uint32_t CartoType::KLatinScript = 1 |
A bit flag used in typeface matching: the Latin script.
|
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.
const uint32_t CartoType::KMagenta = 0xFFFF00FF |
Opaque magenta.
const uint32_t CartoType::KMalayalamScript = 0x4000 |
A bit flag used in typeface matching: the Malayalam script.
|
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).
|
constexpr |
The maximum legal map scale denominator.
|
constexpr |
The minimum legal map scale denominator.
const uint32_t CartoType::KMongolianScript = 0x1000000 |
A bit flag used in typeface matching: the Mongolian script.
const uint32_t CartoType::KMonospaceStyle = 32 |
The bit flag used to select a monospace font in TTypefaceAttrib::Style, etc.
const uint32_t CartoType::KMyanmarScript = 0x80000 |
A bit flag used in typeface matching: the Myanmar script.
const uint32_t CartoType::KOriyaScript = 0x400 |
A bit flag used in typeface matching: the Oriya script.
const uint32_t CartoType::KOtherScript = 0x80000000 |
A bit flag used in typeface matching: other scripts.
|
constexpr |
The value of pi as a double-precision floating-point number.
|
constexpr |
The value of pi as a single-precision floating-point number.
|
constexpr |
A factor to convert radians to degrees: the number of degrees in a radian.
|
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.
const uint32_t CartoType::KRed = 0xFF0000FF |
Opaque red.
const uint32_t CartoType::KReservedScript = 0x20000000 |
A bit flag used in typeface matching: this value is reserved and must not be used.
|
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.
const uint32_t CartoType::KSerifStyle = 4 |
The bit flag used to select a serif font in TTypefaceAttrib::Style, etc.
const uint32_t CartoType::KSinhalaScript = 0x8000 |
A bit flag used in typeface matching: the Sinhala script.
|
constexpr |
The number of standard error codes.
|
constexpr |
A constant for the title case dictionary passed to MString::SetCase. No special title case treatment. This constant must be zero.
const uint32_t CartoType::KSymbolScript = 0x40000000 |
A bit flag used in typeface matching: Symbols and other non-alphabetic characters.
const uint32_t CartoType::KTamilScript = 0x800 |
A bit flag used in typeface matching: the Tamil script.
const uint32_t CartoType::KTeluguScript = 0x1000 |
A bit flag used in typeface matching: the Telugu script.
const uint32_t CartoType::KThaiScript = 0x10000 |
A bit flag used in typeface matching: the Thai script.
const uint32_t CartoType::KTibetanScript = 0x40000 |
A bit flag used in typeface matching: the Tibetan script.
const uint32_t CartoType::KTransparentBlack = 0x00000000 |
The 'null color' transparent black.
|
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.
|
constexpr |
The flattening constant used by the WGS84 reference ellipsoid.
const uint32_t CartoType::KWhite = 0xFFFFFFFF |
Opaque white.
const uint32_t CartoType::KYellow = 0xFF00FFFF |
Opaque yellow.