1 /* 2 * Copyright 2006 The Android Open Source Project 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SkTypeface_DEFINED 9 #define SkTypeface_DEFINED 10 11 #include "../private/SkBitmaskEnum.h" 12 #include "../private/SkOnce.h" 13 #include "../private/SkWeakRefCnt.h" 14 #include "SkFontArguments.h" 15 #include "SkFontStyle.h" 16 #include "SkRect.h" 17 #include "SkString.h" 18 19 class SkDescriptor; 20 class SkFontData; 21 class SkFontDescriptor; 22 class SkScalerContext; 23 struct SkScalerContextRec; 24 struct SkScalerContextEffects; 25 class SkStream; 26 class SkStreamAsset; 27 class SkAdvancedTypefaceMetrics; 28 class SkWStream; 29 30 typedef uint32_t SkFontID; 31 /** Machine endian. */ 32 typedef uint32_t SkFontTableTag; 33 34 /** \class SkTypeface 35 36 The SkTypeface class specifies the typeface and intrinsic style of a font. 37 This is used in the paint, along with optionally algorithmic settings like 38 textSize, textSkewX, textScaleX, kFakeBoldText_Mask, to specify 39 how text appears when drawn (and measured). 40 41 Typeface objects are immutable, and so they can be shared between threads. 42 */ 43 class SK_API SkTypeface : public SkWeakRefCnt { 44 public: 45 /** Style specifies the intrinsic style attributes of a given typeface 46 */ 47 enum Style { 48 kNormal = 0, 49 kBold = 0x01, 50 kItalic = 0x02, 51 52 // helpers 53 kBoldItalic = 0x03 54 }; 55 56 /** Returns the typeface's intrinsic style attributes. */ 57 SkFontStyle fontStyle() const { 58 return fStyle; 59 } 60 61 /** Returns the typeface's intrinsic style attributes. 62 * @deprecated use fontStyle() instead. 63 */ 64 Style style() const { 65 return static_cast<Style>( 66 (fStyle.weight() >= SkFontStyle::kSemiBold_Weight ? kBold : kNormal) | 67 (fStyle.slant() != SkFontStyle::kUpright_Slant ? kItalic : kNormal)); 68 } 69 70 /** Returns true if style() has the kBold bit set. */ 71 bool isBold() const { return fStyle.weight() >= SkFontStyle::kSemiBold_Weight; } 72 73 /** Returns true if style() has the kItalic bit set. */ 74 bool isItalic() const { return fStyle.slant() != SkFontStyle::kUpright_Slant; } 75 76 /** Returns true if the typeface claims to be fixed-pitch. 77 * This is a style bit, advance widths may vary even if this returns true. 78 */ 79 bool isFixedPitch() const { return fIsFixedPitch; } 80 81 /** Copy into 'coordinates' (allocated by the caller) the design variation coordinates. 82 * 83 * @param coordinates the buffer into which to write the design variation coordinates. 84 * @param coordinateCount the number of entries available through 'coordinates'. 85 * 86 * @return The number of axes, or -1 if there is an error. 87 * If 'coordinates != nullptr' and 'coordinateCount >= numAxes' then 'coordinates' will be 88 * filled with the variation coordinates describing the position of this typeface in design 89 * variation space. It is possible the number of axes can be retrieved but actual position 90 * cannot. 91 */ 92 int getVariationDesignPosition(SkFontArguments::VariationPosition::Coordinate coordinates[], 93 int coordinateCount) const; 94 95 /** Return a 32bit value for this typeface, unique for the underlying font 96 data. Will never return 0. 97 */ 98 SkFontID uniqueID() const { return fUniqueID; } 99 100 /** Return the uniqueID for the specified typeface. If the face is null, 101 resolve it to the default font and return its uniqueID. Will never 102 return 0. 103 */ 104 static SkFontID UniqueID(const SkTypeface* face); 105 106 /** Returns true if the two typefaces reference the same underlying font, 107 handling either being null (treating null as the default font) 108 */ 109 static bool Equal(const SkTypeface* facea, const SkTypeface* faceb); 110 111 /** Returns the default typeface, which is never nullptr. */ 112 static sk_sp<SkTypeface> MakeDefault(Style style = SkTypeface::kNormal); 113 114 /** Creates a new reference to the typeface that most closely matches the 115 requested familyName and fontStyle. This method allows extended font 116 face specifiers as in the SkFontStyle type. Will never return null. 117 118 @param familyName May be NULL. The name of the font family. 119 @param fontStyle The style of the typeface. 120 @return reference to the closest-matching typeface. Call must call 121 unref() when they are done. 122 */ 123 static sk_sp<SkTypeface> MakeFromName(const char familyName[], SkFontStyle fontStyle); 124 125 /** Return the typeface that most closely matches the requested typeface and style. 126 Use this to pick a new style from the same family of the existing typeface. 127 If family is nullptr, this selects from the default font's family. 128 129 @param family May be NULL. The name of the existing type face. 130 @param s The style (normal, bold, italic) of the type face. 131 @return the closest-matching typeface. 132 */ 133 static sk_sp<SkTypeface> MakeFromTypeface(SkTypeface* family, Style); 134 135 /** Return a new typeface given a file. If the file does not exist, or is 136 not a valid font file, returns nullptr. 137 */ 138 static sk_sp<SkTypeface> MakeFromFile(const char path[], int index = 0); 139 140 /** Return a new typeface given a stream. If the stream is 141 not a valid font file, returns nullptr. Ownership of the stream is 142 transferred, so the caller must not reference it again. 143 */ 144 static sk_sp<SkTypeface> MakeFromStream(SkStreamAsset* stream, int index = 0); 145 146 /** Return a new typeface given font data and configuration. If the data 147 is not valid font data, returns nullptr. 148 */ 149 static sk_sp<SkTypeface> MakeFromFontData(std::unique_ptr<SkFontData>); 150 151 /** Write a unique signature to a stream, sufficient to reconstruct a 152 typeface referencing the same font when Deserialize is called. 153 */ 154 void serialize(SkWStream*) const; 155 156 /** Given the data previously written by serialize(), return a new instance 157 of a typeface referring to the same font. If that font is not available, 158 return nullptr. 159 Does not affect ownership of SkStream. 160 */ 161 static sk_sp<SkTypeface> MakeDeserialize(SkStream*); 162 163 enum Encoding { 164 kUTF8_Encoding, 165 kUTF16_Encoding, 166 kUTF32_Encoding 167 }; 168 169 /** 170 * Given an array of character codes, of the specified encoding, 171 * optionally return their corresponding glyph IDs (if glyphs is not NULL). 172 * 173 * @param chars pointer to the array of character codes 174 * @param encoding how the characters are encoded 175 * @param glyphs (optional) returns the corresponding glyph IDs for each 176 * character code, up to glyphCount values. If a character code is 177 * not found in the typeface, the corresponding glyph ID will be 0. 178 * @param glyphCount number of code points in 'chars' to process. If glyphs 179 * is not NULL, then it must point sufficient memory to write 180 * glyphCount values into it. 181 * @return the number of number of continuous non-zero glyph IDs computed 182 * from the beginning of chars. This value is valid, even if the 183 * glyphs parameter is NULL. 184 */ 185 int charsToGlyphs(const void* chars, Encoding encoding, SkGlyphID glyphs[], 186 int glyphCount) const; 187 188 /** 189 * Return the number of glyphs in the typeface. 190 */ 191 int countGlyphs() const; 192 193 // Table getters -- may fail if the underlying font format is not organized 194 // as 4-byte tables. 195 196 /** Return the number of tables in the font. */ 197 int countTables() const; 198 199 /** Copy into tags[] (allocated by the caller) the list of table tags in 200 * the font, and return the number. This will be the same as CountTables() 201 * or 0 if an error occured. If tags == NULL, this only returns the count 202 * (the same as calling countTables()). 203 */ 204 int getTableTags(SkFontTableTag tags[]) const; 205 206 /** Given a table tag, return the size of its contents, or 0 if not present 207 */ 208 size_t getTableSize(SkFontTableTag) const; 209 210 /** Copy the contents of a table into data (allocated by the caller). Note 211 * that the contents of the table will be in their native endian order 212 * (which for most truetype tables is big endian). If the table tag is 213 * not found, or there is an error copying the data, then 0 is returned. 214 * If this happens, it is possible that some or all of the memory pointed 215 * to by data may have been written to, even though an error has occured. 216 * 217 * @param fontID the font to copy the table from 218 * @param tag The table tag whose contents are to be copied 219 * @param offset The offset in bytes into the table's contents where the 220 * copy should start from. 221 * @param length The number of bytes, starting at offset, of table data 222 * to copy. 223 * @param data storage address where the table contents are copied to 224 * @return the number of bytes actually copied into data. If offset+length 225 * exceeds the table's size, then only the bytes up to the table's 226 * size are actually copied, and this is the value returned. If 227 * offset > the table's size, or tag is not a valid table, 228 * then 0 is returned. 229 */ 230 size_t getTableData(SkFontTableTag tag, size_t offset, size_t length, 231 void* data) const; 232 233 /** 234 * Return the units-per-em value for this typeface, or zero if there is an 235 * error. 236 */ 237 int getUnitsPerEm() const; 238 239 /** 240 * Given a run of glyphs, return the associated horizontal adjustments. 241 * Adjustments are in "design units", which are integers relative to the 242 * typeface's units per em (see getUnitsPerEm). 243 * 244 * Some typefaces are known to never support kerning. Calling this method 245 * with all zeros (e.g. getKerningPairAdustments(NULL, 0, NULL)) returns 246 * a boolean indicating if the typeface might support kerning. If it 247 * returns false, then it will always return false (no kerning) for all 248 * possible glyph runs. If it returns true, then it *may* return true for 249 * somne glyph runs. 250 * 251 * If count is non-zero, then the glyphs parameter must point to at least 252 * [count] valid glyph IDs, and the adjustments parameter must be 253 * sized to at least [count - 1] entries. If the method returns true, then 254 * [count-1] entries in the adjustments array will be set. If the method 255 * returns false, then no kerning should be applied, and the adjustments 256 * array will be in an undefined state (possibly some values may have been 257 * written, but none of them should be interpreted as valid values). 258 */ 259 bool getKerningPairAdjustments(const SkGlyphID glyphs[], int count, 260 int32_t adjustments[]) const; 261 262 struct LocalizedString { 263 SkString fString; 264 SkString fLanguage; 265 }; 266 class LocalizedStrings : ::SkNoncopyable { 267 public: 268 virtual ~LocalizedStrings() { } 269 virtual bool next(LocalizedString* localizedString) = 0; 270 void unref() { delete this; } 271 }; 272 /** 273 * Returns an iterator which will attempt to enumerate all of the 274 * family names specified by the font. 275 * It is the caller's responsibility to unref() the returned pointer. 276 */ 277 LocalizedStrings* createFamilyNameIterator() const; 278 279 /** 280 * Return the family name for this typeface. It will always be returned 281 * encoded as UTF8, but the language of the name is whatever the host 282 * platform chooses. 283 */ 284 void getFamilyName(SkString* name) const; 285 286 /** 287 * Return a stream for the contents of the font data, or NULL on failure. 288 * If ttcIndex is not null, it is set to the TrueTypeCollection index 289 * of this typeface within the stream, or 0 if the stream is not a 290 * collection. 291 * The caller is responsible for deleting the stream. 292 */ 293 SkStreamAsset* openStream(int* ttcIndex) const; 294 295 /** 296 * Return the font data, or nullptr on failure. 297 */ 298 std::unique_ptr<SkFontData> makeFontData() const; 299 300 /** 301 * Return a scalercontext for the given descriptor. If this fails, then 302 * if allowFailure is true, this returns NULL, else it returns a 303 * dummy scalercontext that will not crash, but will draw nothing. 304 */ 305 std::unique_ptr<SkScalerContext> createScalerContext(const SkScalerContextEffects&, 306 const SkDescriptor*, 307 bool allowFailure = false) const; 308 309 /** 310 * Return a rectangle (scaled to 1-pt) that represents the union of the bounds of all 311 * of the glyphs, but each one positioned at (0,). This may be conservatively large, and 312 * will not take into account any hinting or other size-specific adjustments. 313 */ 314 SkRect getBounds() const; 315 316 // PRIVATE / EXPERIMENTAL -- do not call 317 void filterRec(SkScalerContextRec* rec) const { 318 this->onFilterRec(rec); 319 } 320 // PRIVATE / EXPERIMENTAL -- do not call 321 void getFontDescriptor(SkFontDescriptor* desc, bool* isLocal) const { 322 this->onGetFontDescriptor(desc, isLocal); 323 } 324 325 protected: 326 // The type of advance data wanted. 327 enum PerGlyphInfo { 328 kNo_PerGlyphInfo = 0x0, // Don't populate any per glyph info. 329 kGlyphNames_PerGlyphInfo = 0x1, // Populate glyph names (Type 1 only). 330 kToUnicode_PerGlyphInfo = 0x2 // Populate ToUnicode table, ignored 331 // for Type 1 fonts 332 }; 333 334 /** uniqueID must be unique and non-zero 335 */ 336 SkTypeface(const SkFontStyle& style, bool isFixedPitch = false); 337 virtual ~SkTypeface(); 338 339 /** Sets the fixedPitch bit. If used, must be called in the constructor. */ 340 void setIsFixedPitch(bool isFixedPitch) { fIsFixedPitch = isFixedPitch; } 341 /** Sets the font style. If used, must be called in the constructor. */ 342 void setFontStyle(SkFontStyle style) { fStyle = style; } 343 344 friend class SkScalerContext; 345 static SkTypeface* GetDefaultTypeface(Style style = SkTypeface::kNormal); 346 347 virtual SkScalerContext* onCreateScalerContext(const SkScalerContextEffects&, 348 const SkDescriptor*) const = 0; 349 virtual void onFilterRec(SkScalerContextRec*) const = 0; 350 virtual SkAdvancedTypefaceMetrics* onGetAdvancedTypefaceMetrics( 351 PerGlyphInfo, 352 const uint32_t* glyphIDs, 353 uint32_t glyphIDsCount) const = 0; 354 355 virtual SkStreamAsset* onOpenStream(int* ttcIndex) const = 0; 356 // TODO: make pure virtual. 357 virtual std::unique_ptr<SkFontData> onMakeFontData() const; 358 359 virtual int onGetVariationDesignPosition( 360 SkFontArguments::VariationPosition::Coordinate coordinates[], 361 int coordinateCount) const = 0; 362 363 virtual void onGetFontDescriptor(SkFontDescriptor*, bool* isLocal) const = 0; 364 365 virtual int onCharsToGlyphs(const void* chars, Encoding, SkGlyphID glyphs[], 366 int glyphCount) const = 0; 367 virtual int onCountGlyphs() const = 0; 368 369 virtual int onGetUPEM() const = 0; 370 virtual bool onGetKerningPairAdjustments(const SkGlyphID glyphs[], int count, 371 int32_t adjustments[]) const; 372 373 /** Returns the family name of the typeface as known by its font manager. 374 * This name may or may not be produced by the family name iterator. 375 */ 376 virtual void onGetFamilyName(SkString* familyName) const = 0; 377 378 /** Returns an iterator over the family names in the font. */ 379 virtual LocalizedStrings* onCreateFamilyNameIterator() const = 0; 380 381 virtual int onGetTableTags(SkFontTableTag tags[]) const = 0; 382 virtual size_t onGetTableData(SkFontTableTag, size_t offset, 383 size_t length, void* data) const = 0; 384 385 virtual bool onComputeBounds(SkRect*) const; 386 387 private: 388 friend class SkGTypeface; 389 friend class SkRandomTypeface; 390 friend class SkPDFFont; 391 friend class GrPathRendering; 392 friend class GrGLPathRendering; 393 394 /** Retrieve detailed typeface metrics. Used by the PDF backend. 395 @param perGlyphInfo Indicate what glyph specific information (advances, 396 names, etc.) should be populated. 397 @param glyphIDs For per-glyph info, specify subset of the font by 398 giving glyph ids. Each integer represents a glyph 399 id. Passing NULL means all glyphs in the font. 400 @param glyphIDsCount Number of elements in subsetGlyphIds. Ignored if 401 glyphIDs is NULL. 402 @return The returned object has already been referenced. 403 */ 404 SkAdvancedTypefaceMetrics* getAdvancedTypefaceMetrics( 405 PerGlyphInfo, 406 const uint32_t* glyphIDs = NULL, 407 uint32_t glyphIDsCount = 0) const; 408 409 private: 410 SkFontID fUniqueID; 411 SkFontStyle fStyle; 412 mutable SkRect fBounds; 413 mutable SkOnce fBoundsOnce; 414 bool fIsFixedPitch; 415 416 friend class SkPaint; 417 friend class SkGlyphCache; // GetDefaultTypeface 418 419 typedef SkWeakRefCnt INHERITED; 420 }; 421 422 namespace skstd { 423 template <> struct is_bitmask_enum<SkTypeface::PerGlyphInfo> : std::true_type {}; 424 } 425 426 #endif 427
