dali/internal/text/text-abstraction/font-client-plugin-impl.h

   1 #ifndef DALI_INTERNAL_TEXT_ABSTRACTION_FONT_CLIENT_PLUGIN_IMPL_H
   2 #define DALI_INTERNAL_TEXT_ABSTRACTION_FONT_CLIENT_PLUGIN_IMPL_H
   3
   4 /*
   5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
  23 #include <dali/devel-api/text-abstraction/bitmap-font.h>
  24 #include <dali/devel-api/text-abstraction/font-metrics.h>
  25 #include <dali/devel-api/text-abstraction/glyph-info.h>
  26 #include <dali/internal/text/text-abstraction/font-client-impl.h>
  27
  28 #ifdef ENABLE_VECTOR_BASED_TEXT_RENDERING
  29 #include <third-party/glyphy/vector-font-cache.h>
  30 #else
  31 class VectorFontCache;
  32 #endif
  33
  34 // EXTERNAL INCLUDES
  35 #include <ft2build.h>
  36 #include FT_FREETYPE_H
  37 #include FT_GLYPH_H
  38 #include FT_OUTLINE_H
  39 #include FT_STROKER_H
  40 #include FT_SYNTHESIS_H
  41
  42 // forward declarations of font config types.
  43 struct _FcCharSet;
  44 struct _FcFontSet;
  45 struct _FcPattern;
  46
  47 namespace Dali
  48 {
  49 namespace TextAbstraction
  50 {
  51 namespace Internal
  52 {
  53 /**
  54  * @brief Type used for indices addressing the vector with front descriptions of validated fonts.
  55  */
  56 typedef uint32_t FontDescriptionId;
  57
  58 /**
  59  * @brief Type used for indices addressing the vector with pixel buffers.
  60  */
  61 typedef uint32_t PixelBufferId;
  62
  63 /**
  64  * @brief Vector of character sets.
  65  */
  66 typedef Vector<_FcCharSet*> CharacterSetList;
  67
  68 /**
  69  * @brief FontClient implementation.
  70  */
  71 struct FontClient::Plugin
  72 {
  73   struct FontIdCacheItem
  74   {
  75     FontDescription::Type type; ///< The type of font.
  76     FontId                id;   ///< Index to the cache of fonts for the specified type.
  77   };
  78
  79   /**
  80    * @brief Caches an list of fallback fonts for a given font-description
  81    */
  82   struct FallbackCacheItem
  83   {
  84     FallbackCacheItem(FontDescription&& fontDescription, FontList* fallbackFonts, CharacterSetList* characterSets);
  85
  86     FontDescription   fontDescription; ///< The font description.
  87     FontList*         fallbackFonts;   ///< The list of fallback fonts for the given font-description.
  88     CharacterSetList* characterSets;   ///< The list of character sets for the given font-description.
  89   };
  90
  91   /**
  92    * @brief Caches an index to the vector of font descriptions for a given font.
  93    */
  94   struct FontDescriptionCacheItem
  95   {
  96     FontDescriptionCacheItem(const FontDescription& fontDescription,
  97                              FontDescriptionId      index);
  98     FontDescriptionCacheItem(FontDescription&& fontDescription,
  99                              FontDescriptionId index);
 100
 101     FontDescription   fontDescription; ///< The font description.
 102     FontDescriptionId index;           ///< Index to the vector of font descriptions.
 103   };
 104
 105   /**
 106    * @brief Caches the font id of the pair font point size and the index to the vector of font descriptions of validated fonts.
 107    */
 108   struct FontDescriptionSizeCacheItem
 109   {
 110     FontDescriptionSizeCacheItem(FontDescriptionId validatedFontId,
 111                                  PointSize26Dot6   requestedPointSize,
 112                                  FontId            fontId);
 113
 114     FontDescriptionId validatedFontId;    ///< Index to the vector with font descriptions.
 115     PointSize26Dot6   requestedPointSize; ///< The font point size.
 116     FontId            fontId;             ///< The font identifier.
 117   };
 118
 119   /**
 120    * @brief Caches the FreeType face and font metrics of the triplet 'path to the font file name, font point size and face index'.
 121    */
 122   struct FontFaceCacheItem
 123   {
 124     FontFaceCacheItem(FT_Face            ftFace,
 125                       const FontPath&    path,
 126                       PointSize26Dot6    requestedPointSize,
 127                       FaceIndex          face,
 128                       const FontMetrics& metrics);
 129
 130     FontFaceCacheItem(FT_Face            ftFace,
 131                       const FontPath&    path,
 132                       PointSize26Dot6    requestedPointSize,
 133                       FaceIndex          face,
 134                       const FontMetrics& metrics,
 135                       int                fixedSizeIndex,
 136                       float              fixedWidth,
 137                       float              fixedHeight,
 138                       bool               hasColorTables);
 139
 140     FT_Face         mFreeTypeFace;          ///< The FreeType face.
 141     FontPath        mPath;                  ///< The path to the font file name.
 142     PointSize26Dot6 mRequestedPointSize;    ///< The font point size.
 143     FaceIndex       mFaceIndex;             ///< The face index.
 144     FontMetrics     mMetrics;               ///< The font metrics.
 145     _FcCharSet*     mCharacterSet;          ///< Pointer with the range of characters.
 146     int             mFixedSizeIndex;        ///< Index to the fixed size table for the requested size.
 147     float           mFixedWidthPixels;      ///< The height in pixels (fixed size bitmaps only)
 148     float           mFixedHeightPixels;     ///< The height in pixels (fixed size bitmaps only)
 149     unsigned int    mVectorFontId;          ///< The ID of the equivalent vector-based font
 150     FontId          mFontId;                ///< Index to the vector with the cache of font's ids.
 151     bool            mIsFixedSizeBitmap : 1; ///< Whether the font has fixed size bitmaps.
 152     bool            mHasColorTables : 1;    ///< Whether the font has color tables.
 153   };
 154
 155   struct EllipsisItem
 156   {
 157     PointSize26Dot6 requestedPointSize;
 158     GlyphInfo       glyph;
 159   };
 160
 161   /**
 162    * @brief Caches pixel buffers.
 163    */
 164   struct PixelBufferCacheItem
 165   {
 166     Devel::PixelBuffer pixelBuffer; ///< The pixel buffer loaded from the url.
 167     std::string        url;         ///< The url.
 168   };
 169
 170   /**
 171    * @brief Caches embedded items.
 172    */
 173   struct EmbeddedItem
 174   {
 175     PixelBufferId pixelBufferId; ///< Index to the vector of pixel buffers
 176     unsigned int  width;         ///< The desired width.
 177     unsigned int  height;        ///< The desired height.
 178   };
 179
 180   /**
 181    * @brief Stores a bitmap font and its pixel buffers per glyph.
 182    */
 183   struct BitmapFontCacheItem
 184   {
 185     BitmapFont                      font;         ///< The bitmap font.
 186     std::vector<Devel::PixelBuffer> pixelBuffers; ///< The pixel buffers of the glyphs.
 187     FontId                          id;           ///< Index to the vector with the cache of font's ids.
 188   };
 189
 190   /**
 191    * Constructor.
 192    *
 193    * Initializes the FreeType library.
 194    * Initializes the dpi values.
 195    *
 196    * @param[in] horizontalDpi The horizontal dpi.
 197    * @param[in] verticalDpi The vertical dpi.
 198    */
 199   Plugin(unsigned int horizontalDpi, unsigned int verticalDpi);
 200
 201   /**
 202    * Default destructor.
 203    *
 204    * Frees any allocated resource.
 205    */
 206   ~Plugin();
 207
 208   /**
 209    * @copydoc Dali::TextAbstraction::FontClient::ClearCache()
 210    */
 211   void ClearCache();
 212
 213   /**
 214    * @copydoc Dali::TextAbstraction::FontClient::SetDpi()
 215    */
 216   void SetDpi(unsigned int horizontalDpi, unsigned int verticalDpi);
 217
 218   /**
 219    * @copydoc Dali::TextAbstraction::FontClient::ResetSystemDefaults()
 220    */
 221   void ResetSystemDefaults();
 222
 223   /**
 224    * @copydoc Dali::TextAbstraction::FontClient::SetDefaultFont()
 225    */
 226   void SetDefaultFont(const FontDescription& preferredFontDescription);
 227
 228   /**
 229    * @copydoc Dali::TextAbstraction::FontClient::GetDefaultPlatformFontDescription()
 230    */
 231   void GetDefaultPlatformFontDescription(FontDescription& fontDescription);
 232
 233   /**
 234    * @copydoc Dali::TextAbstraction::FontClient::GetDefaultFonts()
 235    */
 236   void GetDefaultFonts(FontList& defaultFonts);
 237
 238   /**
 239    * @copydoc Dali::TextAbstraction::FontClient::GetSystemFonts()
 240    */
 241   void GetSystemFonts(FontList& systemFonts);
 242
 243   /**
 244    * @copydoc Dali::TextAbstraction::FontClient::GetDescription()
 245    */
 246   void GetDescription(FontId id, FontDescription& fontDescription) const;
 247
 248   /**
 249    * @copydoc Dali::TextAbstraction::FontClient::GetPointSize()
 250    */
 251   PointSize26Dot6 GetPointSize(FontId id);
 252
 253   /**
 254    * @copydoc Dali::TextAbstraction::FontClient::IsCharacterSupportedByFont()
 255    */
 256   bool IsCharacterSupportedByFont(FontId fontId, Character character);
 257
 258   /**
 259    * @brief Finds within the @p fontList a font which support the @p carcode.
 260    *
 261    * @param[in] fontList A list of font paths, family, width, weight and slant.
 262    * @param[in] characterSetList A list that contains a character set for each description of the font list.
 263    * @param[in] charcode The character for which a font is needed.
 264    * @param[in] requestedPointSize The point size in 26.6 fractional points.
 265    * @param[in] preferColor @e true if a color font is preferred.
 266    *
 267    * @return A valid font identifier, or zero if no font is found.
 268    */
 269   FontId FindFontForCharacter(const FontList&         fontList,
 270                               const CharacterSetList& characterSetList,
 271                               Character               charcode,
 272                               PointSize26Dot6         requestedPointSize,
 273                               bool                    preferColor);
 274
 275   /**
 276    * @copydoc Dali::TextAbstraction::FontClient::FindDefaultFont()
 277    */
 278   FontId FindDefaultFont(Character       charcode,
 279                          PointSize26Dot6 requestedPointSize,
 280                          bool            preferColor);
 281
 282   /**
 283    * @copydoc Dali::TextAbstraction::FontClient::FindFallbackFont()
 284    */
 285   FontId FindFallbackFont(Character              charcode,
 286                           const FontDescription& preferredFontDescription,
 287                           PointSize26Dot6        requestedPointSize,
 288                           bool                   preferColor);
 289
 290   /**
 291    * @see Dali::TextAbstraction::FontClient::GetFontId( const FontPath& path, PointSize26Dot6 requestedPointSize, FaceIndex faceIndex )
 292    *
 293    * @param[in] cacheDescription Whether to cache the font description.
 294    */
 295   FontId GetFontId(const FontPath& path,
 296                    PointSize26Dot6 requestedPointSize,
 297                    FaceIndex       faceIndex,
 298                    bool            cacheDescription);
 299
 300   /**
 301    * @copydoc Dali::TextAbstraction::FontClient::GetFontId( const FontDescription& preferredFontDescription, PointSize26Dot6 requestedPointSize, FaceIndex faceIndex )
 302    */
 303   FontId GetFontId(const FontDescription& fontDescription,
 304                    PointSize26Dot6        requestedPointSize,
 305                    FaceIndex              faceIndex);
 306
 307   /**
 308    * @copydoc Dali::TextAbstraction::FontClient::GetFontId( const BitmapFont& bitmapFont )
 309    */
 310   FontId GetFontId(const BitmapFont& bitmapFont);
 311
 312   /**
 313    * @copydoc Dali::TextAbstraction::FontClient::IsScalable( const FontPath& path )
 314    */
 315   bool IsScalable(const FontPath& path);
 316
 317   /**
 318    * @copydoc Dali::TextAbstraction::FontClient::IsScalable( const FontDescription& fontDescription )
 319    */
 320   bool IsScalable(const FontDescription& fontDescription);
 321
 322   /**
 323    * @copydoc Dali::TextAbstraction::FontClient::GetFixedSizes()
 324    */
 325   void GetFixedSizes(const FontPath& path, Dali::Vector<PointSize26Dot6>& sizes);
 326
 327   /**
 328    * @copydoc Dali::TextAbstraction::FontClient::GetFixedSizes()
 329    */
 330   void GetFixedSizes(const FontDescription&         fontDescription,
 331                      Dali::Vector<PointSize26Dot6>& sizes);
 332
 333   /**
 334    * @copydoc Dali::TextAbstraction::FontClient::HasItalicStyle()
 335    */
 336   bool HasItalicStyle(FontId fontId) const;
 337
 338   /**
 339    * @copydoc Dali::TextAbstraction::FontClient::GetFontMetrics()
 340    */
 341   void GetFontMetrics(FontId fontId, FontMetrics& metrics);
 342
 343   /**
 344    * @copydoc Dali::TextAbstraction::FontClient::GetGlyphIndex()
 345    */
 346   GlyphIndex GetGlyphIndex(FontId fontId, Character charcode);
 347
 348   /**
 349    * @copydoc Dali::TextAbstraction::FontClient::GetGlyphMetrics()
 350    */
 351   bool GetGlyphMetrics(GlyphInfo* array, uint32_t size, GlyphType type, bool horizontal);
 352
 353   /**
 354    * Helper for GetGlyphMetrics when using bitmaps
 355    */
 356   bool GetBitmapMetrics(GlyphInfo* array, uint32_t size, bool horizontal);
 357
 358   /**
 359    * Helper for GetGlyphMetrics when using vectors
 360    */
 361   bool GetVectorMetrics(GlyphInfo* array, uint32_t size, bool horizontal);
 362
 363   /**
 364    * @copydoc Dali::TextAbstraction::FontClient::CreateBitmap( FontId fontId, GlyphIndex glyphIndex, bool isItalicRequired, bool isBoldRequired, Dali::TextAbstraction::FontClient::GlyphBufferData& data, int outlineWidth )
 365    */
 366   void CreateBitmap(FontId fontId, GlyphIndex glyphIndex, bool isItalicRequired, bool isBoldRequired, Dali::TextAbstraction::FontClient::GlyphBufferData& data, int outlineWidth);
 367
 368   /**
 369    * @copydoc Dali::TextAbstraction::FontClient::CreateBitmap( FontId fontId, GlyphIndex glyphIndex, int outlineWidth )
 370    */
 371   PixelData CreateBitmap(FontId fontId, GlyphIndex glyphIndex, int outlineWidth);
 372
 373   /**
 374    * @copydoc Dali::TextAbstraction::FontClient::CreateVectorBlob()
 375    */
 376   void CreateVectorBlob(FontId fontId, GlyphIndex glyphIndex, VectorBlob*& blob, unsigned int& blobLength, unsigned int& nominalWidth, unsigned int& nominalHeight);
 377
 378   /**
 379    * @copydoc Dali::TextAbstraction::FontClient::GetEllipsisGlyph()
 380    */
 381   const GlyphInfo& GetEllipsisGlyph(PointSize26Dot6 requestedPointSize);
 382
 383   /**
 384    * @copydoc Dali::TextAbstraction::FontClient::IsColorGlyph()
 385    */
 386   bool IsColorGlyph(FontId fontId, GlyphIndex glyphIndex);
 387
 388   /**
 389    * @copydoc Dali::TextAbstraction::FontClient::CreateEmbeddedItem()
 390    */
 391   GlyphIndex CreateEmbeddedItem(const TextAbstraction::FontClient::EmbeddedItemDescription& description, Pixel::Format& pixelFormat);
 392
 393   /**
 394    * @copydoc Dali::TextAbstraction::Internal::FontClient::GetFreetypeFace()
 395    */
 396   FT_FaceRec_* GetFreetypeFace(FontId fontId);
 397
 398   /**
 399    * @copydoc Dali::TextAbstraction::Internal::FontClient::GetFontType()
 400    */
 401   FontDescription::Type GetFontType(FontId fontId);
 402
 403   /**
 404    * @copydoc Dali::TextAbstraction::FontClient::AddCustomFontDirectory()
 405    */
 406   bool AddCustomFontDirectory(const FontPath& path);
 407
 408 private:
 409   /**
 410    * @brief Caches the fonts present in the platform.
 411    *
 412    * Calls GetFcFontSet() to retrieve the fonts.
 413    */
 414   void InitSystemFonts();
 415
 416   /**
 417    * @brief Gets the FontDescription which matches the given pattern.
 418    *
 419    * @note The reference counter of the @p characterSet has been increased. Call FcCharSetDestroy to decrease it.
 420    *
 421    * @param[in] pattern pattern to match against.
 422    * @param[out] fontDescription the resultant fontDescription that matched.
 423    * @param[out] characterSet The character set for that pattern.
 424    * @return true if match found.
 425    */
 426   bool MatchFontDescriptionToPattern(_FcPattern* pattern, Dali::TextAbstraction::FontDescription& fontDescription, _FcCharSet** characterSet);
 427
 428   /**
 429    * @brief Creates a font family pattern used to match fonts.
 430    *
 431    * @note Need to call FcPatternDestroy to free the resources.
 432    *
 433    * @param[in] fontDescription The font to cache.
 434    *
 435    * @return The pattern.
 436    */
 437   _FcPattern* CreateFontFamilyPattern(const FontDescription& fontDescription) const;
 438
 439   /**
 440    * @brief Retrieves the fonts present in the platform.
 441    *
 442    * @note Need to call FcFontSetDestroy to free the allocated resources.
 443    *
 444    * @return A font fonfig data structure with the platform's fonts.
 445    */
 446   _FcFontSet* GetFcFontSet() const;
 447
 448   /**
 449    * @brief Retrieves a font config object's value from a pattern.
 450    *
 451    * @param[in] pattern The font config pattern.
 452    * @param[in] n The object.
 453    * @param[out] string The object's value.
 454    *
 455    * @return @e true if the operation is successful.
 456    */
 457   bool GetFcString(const _FcPattern* const pattern, const char* const n, std::string& string);
 458
 459   /**
 460    * @brief Retrieves a font config object's value from a pattern.
 461    *
 462    * @param[in] pattern The font config pattern.
 463    * @param[in] n The object.
 464    * @param[out] intVal The object's value.
 465    *
 466    * @return @e true if the operation is successful.
 467    */
 468   bool GetFcInt(const _FcPattern* const pattern, const char* const n, int& intVal);
 469
 470   /**
 471    * @brief Creates a font.
 472    *
 473    * @param[in] path The path to the font file name.
 474    * @param[in] requestedPointSize The requested point size.
 475    * @param[in] faceIndex A face index.
 476    * @param[in] cacheDescription Whether to cache the font description.
 477    *
 478    * @return The font identifier.
 479    */
 480   FontId CreateFont(const FontPath& path,
 481                     PointSize26Dot6 requestedPointSize,
 482                     FaceIndex       faceIndex,
 483                     bool            cacheDescription);
 484
 485   /**
 486    * @brief Copy the color bitmap given in @p srcBuffer to @p data.
 487    *
 488    * @param[out] data The bitmap data.
 489    * @param[in] srcWidth The width of the bitmap.
 490    * @param[in] srcHeight The height of the bitmap.
 491    * @param[in] srcBuffer The buffer of the bitmap.
 492    */
 493   void ConvertBitmap(TextAbstraction::FontClient::GlyphBufferData& data, unsigned int srcWidth, unsigned int srcHeight, const unsigned char* const srcBuffer);
 494
 495   /**
 496    * @brief Copy the FreeType bitmap to the given buffer.
 497    *
 498    * @param[out] data The bitmap data.
 499    * @param[in] srcBitmap The FreeType bitmap.
 500    * @param[in] isShearRequired Whether the bitmap needs a shear transform (for software italics).
 501    */
 502   void ConvertBitmap(TextAbstraction::FontClient::GlyphBufferData& data, FT_Bitmap srcBitmap, bool isShearRequired);
 503
 504   /**
 505    * @brief Finds in the cache if there is a triplet with the path to the font file name, the font point size and the face index.
 506    * If there is one , if writes the font identifier in the param @p fontId.
 507    *
 508    * @param[in] path Path to the font file name.
 509    * @param[in] requestedPointSize The font point size.
 510    * @param[in] faceIndex The face index.
 511    * @param[out] fontId The font identifier.
 512    *
 513    * @return @e true if there triplet is found.
 514    */
 515   bool FindFont(const FontPath& path, PointSize26Dot6 requestedPointSize, FaceIndex faceIndex, FontId& fontId) const;
 516
 517   /**
 518    * @brief Finds in the cache a cluster 'font family, font width, font weight, font slant'
 519    * If there is one, it writes the index to the vector with font descriptions in the param @p validatedFontId.
 520    *
 521    * @param[in] fontDescription The font to validate.
 522    * @param[out] validatedFontId The index to the vector with font descriptions.
 523    *
 524    * @return @e true if the pair is found.
 525    */
 526   bool FindValidatedFont(const FontDescription& fontDescription,
 527                          FontDescriptionId&     validatedFontId);
 528
 529   /**
 530    * @brief Finds a fallback font list from the cache for a given font-description
 531    *
 532    * @param[in] fontDescription The font to validate.
 533    * @param[out] A valid pointer to a font list, or @e nullptr if not found.
 534    * @param[out] characterSetList A valid pointer to a character set list, or @e nullptr if not found.
 535    */
 536   bool FindFallbackFontList(const FontDescription& fontDescription,
 537                             FontList*&             fontList,
 538                             CharacterSetList*&     characterSetList);
 539
 540   /**
 541    * @brief Finds in the cache a pair 'validated font identifier and font point size'.
 542    * If there is one it writes the font identifier in the param @p fontId.
 543    *
 544    * @param[in] validatedFontId Index to the vector with font descriptions.
 545    * @param[in] requestedPointSize The font point size.
 546    * @param[out] fontId The font identifier.
 547    *
 548    * @return @e true if the pair is found.
 549    */
 550   bool FindFont(FontDescriptionId validatedFontId,
 551                 PointSize26Dot6   requestedPointSize,
 552                 FontId&           fontId);
 553
 554   /**
 555    * @brief Finds in the cache a bitmap font with the @p bitmapFont family name.
 556    *
 557    * @param[in] bitmapFont The font's family name.
 558    * @param[out] fontId The id of the font.
 559    *
 560    * @return Whether the font has been found.
 561    */
 562   bool FindBitmapFont(const FontFamily& bitmapFont, FontId& fontId) const;
 563
 564   /**
 565    * @brief Validate a font description.
 566    *
 567    * @param[in] fontDescription The font to validate.
 568    * @param[out] validatedFontId Result of validation
 569    */
 570   void ValidateFont(const FontDescription& fontDescription,
 571                     FontDescriptionId&     validatedFontId);
 572
 573   /**
 574    * @brief Helper for GetDefaultFonts etc.
 575    *
 576    * @note CharacterSetList is a vector of FcCharSet that are reference counted. It's needed to call FcCharSetDestroy to decrease the reference counter.
 577    *
 578    * @param[in] fontDescription A font description.
 579    * @param[out] fontList A list of the fonts which are a close match for fontDescription.
 580    * @param[out] characterSetList A list of character sets which are a close match for fontDescription.
 581    */
 582   void SetFontList(const FontDescription& fontDescription, FontList& fontList, CharacterSetList& characterSetList);
 583
 584   /**
 585    * Caches a font path.
 586    *
 587    * @param[in] ftFace The FreeType face.
 588    * @param[in] id The font identifier.
 589    * @param[in] requestedPointSize The font point size.
 590    * @param[in] path Path to the font file name.
 591    */
 592   void CacheFontPath(FT_Face ftFace, FontId id, PointSize26Dot6 requestedPointSize, const FontPath& path);
 593
 594   /**
 595    * @brief Creates a character set from a given font's @p description.
 596    *
 597    * @note Need to call FcCharSetDestroy to free the resources.
 598    *
 599    * @param[in] description The font's description.
 600    *
 601    * @return A character set.
 602    */
 603   _FcCharSet* CreateCharacterSetFromDescription(const FontDescription& description);
 604
 605   /**
 606    * @brief Free the resources allocated in the fallback cache.
 607    *
 608    * @param[in] fallbackCache The fallback cache.
 609    */
 610   void ClearFallbackCache(std::vector<FallbackCacheItem>& fallbackCache);
 611
 612   /**
 613    * @brief Free the resources allocated by the FcCharSet objects.
 614    */
 615   void ClearCharacterSetFromFontFaceCache();
 616
 617 private:
 618   // Declared private and left undefined to avoid copies.
 619   Plugin(const Plugin&);
 620   // Declared private and left undefined to avoid copies.
 621   Plugin& operator=(const Plugin&);
 622
 623 private:
 624   FT_Library mFreeTypeLibrary; ///< A handle to a FreeType library instance.
 625
 626   unsigned int mDpiHorizontal; ///< Horizontal dpi.
 627   unsigned int mDpiVertical;   ///< Vertical dpi.
 628
 629   FontDescription mDefaultFontDescription; ///< The cached default font from the system
 630
 631   FontList         mSystemFonts;  ///< Cached system fonts.
 632   FontList         mDefaultFonts; ///< Cached default fonts.
 633   CharacterSetList mDefaultFontCharacterSets;
 634
 635   std::vector<FallbackCacheItem> mFallbackCache; ///< Cached fallback font lists.
 636
 637   Vector<FontIdCacheItem>                   mFontIdCache;
 638   std::vector<FontFaceCacheItem>            mFontFaceCache;            ///< Caches the FreeType face and font metrics of the triplet 'path to the font file name, font point size and face index'.
 639   std::vector<FontDescriptionCacheItem>     mValidatedFontCache;       ///< Caches indices to the vector of font descriptions for a given font.
 640   FontList                                  mFontDescriptionCache;     ///< Caches font descriptions for the validated font.
 641   CharacterSetList                          mCharacterSetCache;        ///< Caches character set lists for the validated font.
 642   std::vector<FontDescriptionSizeCacheItem> mFontDescriptionSizeCache; ///< Caches font identifiers for the pairs of font point size and the index to the vector with font descriptions of the validated fonts.
 643
 644   VectorFontCache* mVectorFontCache; ///< Separate cache for vector data blobs etc.
 645
 646   Vector<EllipsisItem>              mEllipsisCache;     ///< Caches ellipsis glyphs for a particular point size.
 647   std::vector<PixelBufferCacheItem> mPixelBufferCache;  ///< Caches the pixel buffer of a url.
 648   Vector<EmbeddedItem>              mEmbeddedItemCache; ///< Cache embedded items.
 649   std::vector<BitmapFontCacheItem>  mBitmapFontCache;   ///< Stores bitmap fonts.
 650
 651   bool mDefaultFontDescriptionCached : 1; ///< Whether the default font is cached or not
 652 };
 653
 654 } // namespace Internal
 655
 656 } // namespace TextAbstraction
 657
 658 } // namespace Dali
 659
 660 #endif // DALI_INTERNAL_TEXT_ABSTRACTION_FONT_CLIENT_PLUGIN_IMPL_H