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

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/text-abstraction/font-client-plugin-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/common/dali-vector.h>
  23 #include <dali/public-api/common/vector-wrapper.h>
  24 #include <dali/integration-api/debug.h>
  25
  26 // EXTERNAL INCLUDES
  27 #include <fontconfig/fontconfig.h>
  28
  29 /**
  30  * Conversion from Fractional26.6 to float
  31  */
  32 namespace
  33 {
  34 const float FROM_266 = 1.0f / 64.0f;
  35
  36 const std::string FONT_FORMAT( "TrueType" );
  37 const std::string DEFAULT_FONT_FAMILY_NAME( "Tizen" );
  38 const std::string DEFAULT_FONT_STYLE( "Regular" );
  39
  40 const uint32_t ELLIPSIS_CHARACTER = 0x2026;
  41 }
  42
  43 using Dali::Vector;
  44
  45 namespace Dali
  46 {
  47
  48 namespace TextAbstraction
  49 {
  50
  51 namespace Internal
  52 {
  53
  54 const bool FONT_FIXED_SIZE_BITMAP( true );
  55
  56 FontClient::Plugin::FontDescriptionCacheItem::FontDescriptionCacheItem( const FontFamily& fontFamily,
  57                                                                         const FontStyle& fontStyle,
  58                                                                         FontDescriptionId index )
  59 : fontFamily( fontFamily ),
  60   fontStyle( fontStyle ),
  61   index( index )
  62 {
  63 }
  64
  65 FontClient::Plugin::FontIdCacheItem::FontIdCacheItem( FontDescriptionId validatedFontId,
  66                                                       PointSize26Dot6 pointSize,
  67                                                       FontId fontId )
  68 : validatedFontId( validatedFontId ),
  69   pointSize( pointSize ),
  70   fontId( fontId )
  71 {
  72 }
  73
  74 FontClient::Plugin::CacheItem::CacheItem( FT_Face ftFace,
  75                                           const FontPath& path,
  76                                           PointSize26Dot6 pointSize,
  77                                           FaceIndex face,
  78                                           const FontMetrics& metrics )
  79 : mFreeTypeFace( ftFace ),
  80   mPath( path ),
  81   mPointSize( pointSize ),
  82   mFaceIndex( face ),
  83   mMetrics( metrics ),
  84   mFixedWidthPixels( 0.0f ),
  85   mFixedHeightPixels( 0.0f ),
  86   mIsFixedSizeBitmap( false )
  87 {
  88 }
  89
  90 FontClient::Plugin::CacheItem::CacheItem( FT_Face ftFace,
  91                                           const FontPath& path,
  92                                           PointSize26Dot6 pointSize,
  93                                           FaceIndex face,
  94                                           const FontMetrics& metrics,
  95                                           float fixedWidth,
  96                                           float fixedHeight )
  97 : mFreeTypeFace( ftFace ),
  98   mPath( path ),
  99   mPointSize( pointSize ),
 100   mFaceIndex( face ),
 101   mMetrics( metrics ),
 102   mFixedWidthPixels( fixedWidth ),
 103   mFixedHeightPixels( fixedHeight ),
 104   mIsFixedSizeBitmap( true )
 105 {
 106 }
 107
 108 FontClient::Plugin::Plugin( unsigned int horizontalDpi,
 109                             unsigned int verticalDpi )
 110 : mFreeTypeLibrary( NULL ),
 111   mDpiHorizontal( horizontalDpi ),
 112   mDpiVertical( verticalDpi ),
 113   mSystemFonts(),
 114   mDefaultFonts(),
 115   mFontCache(),
 116   mValidatedFontCache(),
 117   mFontDescriptionCache( 1u ),
 118   mFontIdCache(),
 119   mEllipsisCache()
 120 {
 121   int error = FT_Init_FreeType( &mFreeTypeLibrary );
 122   if( FT_Err_Ok != error )
 123   {
 124     DALI_LOG_ERROR( "FreeType Init error: %d\n", error );
 125   }
 126 }
 127
 128 FontClient::Plugin::~Plugin()
 129 {
 130   FT_Done_FreeType( mFreeTypeLibrary );
 131 }
 132
 133 void FontClient::Plugin::SetDpi( unsigned int horizontalDpi,
 134                                  unsigned int verticalDpi )
 135 {
 136   mDpiHorizontal = horizontalDpi;
 137   mDpiVertical = verticalDpi;
 138 }
 139
 140 void FontClient::Plugin::SetDefaultFontFamily( const FontFamily& fontFamilyName,
 141                                                const FontStyle& fontStyle )
 142 {
 143   mDefaultFonts.clear();
 144
 145   FcPattern* fontFamilyPattern = CreateFontFamilyPattern( fontFamilyName,
 146                                                           fontStyle );
 147
 148   FcResult result = FcResultMatch;
 149
 150   // Match the pattern.
 151   FcFontSet* fontSet = FcFontSort( NULL /* use default configure */,
 152                                    fontFamilyPattern,
 153                                    false /* don't trim */,
 154                                    NULL,
 155                                    &result );
 156
 157   if( NULL != fontSet )
 158   {
 159     // Reserve some space to avoid reallocations.
 160     mDefaultFonts.reserve( fontSet->nfont );
 161
 162     for( int i = 0u; i < fontSet->nfont; ++i )
 163     {
 164       FcPattern* fontPattern = fontSet->fonts[i];
 165
 166       FontPath path;
 167
 168       // Skip fonts with no path
 169       if( GetFcString( fontPattern, FC_FILE, path ) )
 170       {
 171         mDefaultFonts.push_back( FontDescription() );
 172         FontDescription& fontDescription = mDefaultFonts.back();
 173
 174         fontDescription.path = path;
 175
 176         GetFcString( fontPattern, FC_FAMILY, fontDescription.family );
 177         GetFcString( fontPattern, FC_STYLE, fontDescription.style );
 178       }
 179     }
 180
 181     FcFontSetDestroy( fontSet );
 182   }
 183
 184   FcPatternDestroy( fontFamilyPattern );
 185 }
 186
 187 void FontClient::Plugin::GetDefaultFonts( FontList& defaultFonts )
 188 {
 189   if( mDefaultFonts.empty() )
 190   {
 191     SetDefaultFontFamily( DEFAULT_FONT_FAMILY_NAME,
 192                           DEFAULT_FONT_STYLE );
 193   }
 194
 195   defaultFonts = mDefaultFonts;
 196 }
 197
 198 void FontClient::Plugin::GetSystemFonts( FontList& systemFonts )
 199 {
 200   if( mSystemFonts.empty() )
 201   {
 202     InitSystemFonts();
 203   }
 204
 205   systemFonts = mSystemFonts;
 206 }
 207
 208 void FontClient::Plugin::GetDescription( FontId id,
 209                                          FontDescription& fontDescription ) const
 210 {
 211   for( std::vector<FontIdCacheItem>::const_iterator it = mFontIdCache.begin(),
 212          endIt = mFontIdCache.end();
 213        it != endIt;
 214        ++it )
 215   {
 216     const FontIdCacheItem& item = *it;
 217
 218     if( item.fontId == id )
 219     {
 220       fontDescription = *( mFontDescriptionCache.begin() + item.validatedFontId );
 221       return;
 222     }
 223   }
 224
 225   DALI_LOG_ERROR( "FontClient::Plugin::GetDescription. No description found for the font ID %d\n", id );
 226 }
 227
 228 PointSize26Dot6 FontClient::Plugin::GetPointSize( FontId id )
 229 {
 230   const FontId index = id - 1u;
 231
 232   if( id > 0u &&
 233       index < mFontCache.size() )
 234   {
 235     return ( *( mFontCache.begin() + index ) ).mPointSize;
 236   }
 237   else
 238   {
 239     DALI_LOG_ERROR( "FontClient::Plugin::GetPointSize. Invalid font ID %d\n", id );
 240   }
 241
 242   return TextAbstraction::FontClient::DEFAULT_POINT_SIZE;
 243 }
 244
 245 FontId FontClient::Plugin::FindDefaultFont( Character charcode,
 246                                             PointSize26Dot6 requestedSize,
 247                                             bool preferColor )
 248 {
 249   FontId fontId(0);
 250   bool foundColor(false);
 251
 252   // Create the list of default fonts if it has not been created.
 253   if( mDefaultFonts.empty() )
 254   {
 255     SetDefaultFontFamily( DEFAULT_FONT_FAMILY_NAME,
 256                           DEFAULT_FONT_STYLE );
 257   }
 258
 259   // Traverse the list of default fonts.
 260   // Check for each default font if supports the character.
 261
 262   for( FontList::const_iterator it = mDefaultFonts.begin(), endIt = mDefaultFonts.end();
 263        it != endIt;
 264        ++it )
 265   {
 266     const FontDescription& description = *it;
 267
 268     FcPattern* pattern = CreateFontFamilyPattern( description.family,
 269                                                   description.style );
 270
 271     FcResult result = FcResultMatch;
 272     FcPattern* match = FcFontMatch( NULL /* use default configure */, pattern, &result );
 273
 274     FcCharSet* charSet = NULL;
 275     FcPatternGetCharSet( match, FC_CHARSET, 0u, &charSet );
 276
 277     if( FcCharSetHasChar( charSet, charcode ) )
 278     {
 279       Vector< PointSize26Dot6 > fixedSizes;
 280       GetFixedSizes( description.family,
 281                      description.style,
 282                      fixedSizes );
 283
 284       const Vector< PointSize26Dot6 >::SizeType count = fixedSizes.Count();
 285       if( 0 != count )
 286       {
 287         // If the font is not scalable, pick the largest size <= requestedSize
 288         PointSize26Dot6 size = fixedSizes[0];
 289         for( unsigned int i=1; i<count; ++i )
 290         {
 291           if( fixedSizes[i] <= requestedSize &&
 292               fixedSizes[i] > size )
 293           {
 294             size = fixedSizes[i];
 295           }
 296         }
 297         requestedSize = size;
 298       }
 299
 300       fontId = GetFontId( description.family,
 301                           description.style,
 302                           requestedSize,
 303                           0u );
 304
 305       if( preferColor )
 306       {
 307         BufferImage bitmap = CreateBitmap( fontId, GetGlyphIndex(fontId,charcode) );
 308         if( bitmap &&
 309             Pixel::BGRA8888 == bitmap.GetPixelFormat() )
 310         {
 311           foundColor = true;
 312         }
 313       }
 314
 315       // Keep going unless we prefer a different (color) font
 316       if( !preferColor || foundColor )
 317       {
 318         FcPatternDestroy( match );
 319         FcPatternDestroy( pattern );
 320         break;
 321       }
 322     }
 323
 324     FcPatternDestroy( match );
 325     FcPatternDestroy( pattern );
 326   }
 327   return fontId;
 328 }
 329
 330 FontId FontClient::Plugin::GetFontId( const FontPath& path,
 331                                       PointSize26Dot6 pointSize,
 332                                       FaceIndex faceIndex,
 333                                       bool cacheDescription )
 334 {
 335   FontId id( 0 );
 336
 337   if( NULL != mFreeTypeLibrary )
 338   {
 339     FontId foundId(0);
 340     if( FindFont( path, pointSize, faceIndex, foundId ) )
 341     {
 342       id = foundId;
 343     }
 344     else
 345     {
 346       id = CreateFont( path, pointSize, faceIndex, cacheDescription );
 347     }
 348   }
 349
 350   return id;
 351 }
 352
 353 FontId FontClient::Plugin::GetFontId( const FontFamily& fontFamily,
 354                                       const FontStyle& fontStyle,
 355                                       PointSize26Dot6 pointSize,
 356                                       FaceIndex faceIndex )
 357 {
 358   // This method uses three vectors which caches:
 359   // * Pairs of non validated 'fontFamily, fontStyle' and an index to a vector with paths to font file names.
 360   // * The path to font file names.
 361   // * The font ids of pairs 'font point size, index to the vector with paths to font file names'.
 362
 363   // 1) Checks in the cache if the pair 'fontFamily, fontStyle' has been validated before.
 364   //    If it was it gets an index to the vector with paths to font file names. Otherwise,
 365   //    retrieves using font config a path to a font file name which matches with the pair
 366   //    'fontFamily, fontStyle'. The path is stored in the chache.
 367   //
 368   // 2) Checks in the cache if the pair 'font point size, index to the vector with paths to
 369   //    fon file names' exists. If exists, it gets the font id. If it doesn't it calls
 370   //    the GetFontId() method with the path to the font file name and the point size to
 371   //    get the font id.
 372
 373   // The font id to be returned.
 374   FontId fontId = 0u;
 375
 376   // Check first if the pair font family and style have been validated before.
 377   FontDescriptionId validatedFontId = 0u;
 378
 379   if( !FindValidatedFont( fontFamily,
 380                           fontStyle,
 381                           validatedFontId ) )
 382   {
 383     // Use font config to validate the font family name and font style.
 384     ValidateFont( fontFamily, fontStyle, validatedFontId );
 385   }
 386
 387   // Check if exists a pair 'validatedFontId, pointSize' in the cache.
 388   if( !FindFont( validatedFontId, pointSize, fontId ) )
 389   {
 390     // Retrieve the font file name path.
 391     const FontDescription& description = *( mFontDescriptionCache.begin() + validatedFontId );
 392
 393     // Retrieve the font id. Do not cache the description as it has been already cached.
 394     fontId = GetFontId( description.path,
 395                         pointSize,
 396                         faceIndex,
 397                         false );
 398
 399     // Cache the pair 'validatedFontId, pointSize' to improve the following queries.
 400     mFontIdCache.push_back( FontIdCacheItem( validatedFontId,
 401                                              pointSize,
 402                                              fontId ) );
 403   }
 404
 405   return fontId;
 406 }
 407
 408 void FontClient::Plugin::ValidateFont( const FontFamily& fontFamily,
 409                                        const FontStyle& fontStyle,
 410                                        FontDescriptionId& validatedFontId )
 411 {
 412   // Create a font pattern.
 413   FcPattern* fontFamilyPattern = CreateFontFamilyPattern( fontFamily,
 414                                                             fontStyle );
 415
 416   FcResult result = FcResultMatch;
 417
 418   // match the pattern
 419   FcPattern* match = FcFontMatch( NULL /* use default configure */, fontFamilyPattern, &result );
 420
 421   if( match )
 422   {
 423     // Get the path to the font file name.
 424     FontDescription description;
 425     GetFcString( match, FC_FILE, description.path );
 426     GetFcString( match, FC_FAMILY, description.family );
 427     GetFcString( match, FC_STYLE, description.style );
 428
 429     // Set the index to the vector of paths to font file names.
 430     validatedFontId = mFontDescriptionCache.size();
 431
 432     // Add the path to the cache.
 433     mFontDescriptionCache.push_back( description );
 434
 435     // Cache the index and the pair font family name, font style.
 436     FontDescriptionCacheItem item( fontFamily, fontStyle, validatedFontId );
 437     mValidatedFontCache.push_back( item );
 438
 439     // destroyed the matched pattern
 440     FcPatternDestroy( match );
 441   }
 442   else
 443   {
 444     DALI_LOG_ERROR( "FontClient::Plugin::ValidateFont failed for font %s %s\n", fontFamily.c_str(), fontStyle.c_str() );
 445   }
 446
 447   // destroy the pattern
 448   FcPatternDestroy( fontFamilyPattern );
 449 }
 450
 451
 452
 453 void FontClient::Plugin::GetFontMetrics( FontId fontId,
 454                                          FontMetrics& metrics )
 455 {
 456   if( fontId > 0 &&
 457       fontId-1 < mFontCache.size() )
 458   {
 459     metrics = mFontCache[fontId-1].mMetrics;
 460   }
 461   else
 462   {
 463     DALI_LOG_ERROR( "Invalid font ID %d\n", fontId );
 464   }
 465 }
 466
 467 GlyphIndex FontClient::Plugin::GetGlyphIndex( FontId fontId,
 468                                               Character charcode )
 469 {
 470   GlyphIndex index( 0 );
 471
 472   if( fontId > 0 &&
 473       fontId-1 < mFontCache.size() )
 474   {
 475     FT_Face ftFace = mFontCache[fontId-1].mFreeTypeFace;
 476
 477     index = FT_Get_Char_Index( ftFace, charcode );
 478   }
 479
 480   return index;
 481 }
 482
 483 bool FontClient::Plugin::GetGlyphMetrics( GlyphInfo* array,
 484                                           uint32_t size,
 485                                           bool horizontal )
 486 {
 487   bool success( true );
 488
 489   for( unsigned int i=0; i<size; ++i )
 490   {
 491     FontId fontId = array[i].fontId;
 492
 493     if( fontId > 0 &&
 494         fontId-1 < mFontCache.size() )
 495     {
 496       FT_Face ftFace = mFontCache[fontId-1].mFreeTypeFace;
 497
 498 #ifdef FREETYPE_BITMAP_SUPPORT
 499       // Check to see if we should be loading a Fixed Size bitmap?
 500       if ( mFontCache[fontId-1].mIsFixedSizeBitmap )
 501       {
 502         int error = FT_Load_Glyph( ftFace, array[i].index, FT_LOAD_COLOR );
 503         if ( FT_Err_Ok == error )
 504         {
 505           array[i].width = mFontCache[ fontId -1 ].mFixedWidthPixels;
 506           array[i].height = mFontCache[ fontId -1 ].mFixedHeightPixels;
 507           array[i].advance = mFontCache[ fontId -1 ].mFixedWidthPixels;
 508           array[i].xBearing = 0.0f;
 509           array[i].yBearing = mFontCache[ fontId -1 ].mFixedHeightPixels;
 510         }
 511         else
 512         {
 513           DALI_LOG_ERROR( "FreeType Bitmap Load_Glyph error %d\n", error );
 514           success = false;
 515         }
 516       }
 517       else
 518 #endif
 519       {
 520         int error = FT_Load_Glyph( ftFace, array[i].index, FT_LOAD_DEFAULT );
 521
 522         if( FT_Err_Ok == error )
 523         {
 524           array[i].width  = static_cast< float >( ftFace->glyph->metrics.width ) * FROM_266;
 525           array[i].height = static_cast< float >( ftFace->glyph->metrics.height ) * FROM_266 ;
 526           if( horizontal )
 527           {
 528             array[i].xBearing += static_cast< float >( ftFace->glyph->metrics.horiBearingX ) * FROM_266;
 529             array[i].yBearing += static_cast< float >( ftFace->glyph->metrics.horiBearingY ) * FROM_266;
 530           }
 531           else
 532           {
 533             array[i].xBearing += static_cast< float >( ftFace->glyph->metrics.vertBearingX ) * FROM_266;
 534             array[i].yBearing += static_cast< float >( ftFace->glyph->metrics.vertBearingY ) * FROM_266;
 535           }
 536         }
 537         else
 538         {
 539           success = false;
 540         }
 541       }
 542     }
 543     else
 544     {
 545       success = false;
 546     }
 547   }
 548
 549   return success;
 550 }
 551
 552 BufferImage FontClient::Plugin::CreateBitmap( FontId fontId,
 553                                               GlyphIndex glyphIndex )
 554 {
 555   BufferImage bitmap;
 556
 557   if( fontId > 0 &&
 558       fontId-1 < mFontCache.size() )
 559   {
 560     FT_Face ftFace = mFontCache[fontId-1].mFreeTypeFace;
 561
 562     FT_Error error;
 563
 564 #ifdef FREETYPE_BITMAP_SUPPORT
 565     // Check to see if this is fixed size bitmap
 566     if ( mFontCache[fontId-1].mIsFixedSizeBitmap )
 567     {
 568       error = FT_Load_Glyph( ftFace, glyphIndex, FT_LOAD_COLOR );
 569     }
 570     else
 571 #endif
 572     {
 573       error = FT_Load_Glyph( ftFace, glyphIndex, FT_LOAD_DEFAULT );
 574     }
 575     if( FT_Err_Ok == error )
 576     {
 577       FT_Glyph glyph;
 578       error = FT_Get_Glyph( ftFace->glyph, &glyph );
 579
 580       // Convert to bitmap if necessary
 581       if ( FT_Err_Ok == error )
 582       {
 583         if( glyph->format != FT_GLYPH_FORMAT_BITMAP )
 584         {
 585           error = FT_Glyph_To_Bitmap( &glyph, FT_RENDER_MODE_NORMAL, 0, 1 );
 586           if ( FT_Err_Ok == error )
 587           {
 588             FT_BitmapGlyph bitmapGlyph = (FT_BitmapGlyph)glyph;
 589             ConvertBitmap( bitmap, bitmapGlyph->bitmap );
 590           }
 591           else
 592           {
 593             DALI_LOG_ERROR( "FT_Get_Glyph Failed with error: %d\n", error );
 594           }
 595         }
 596         else
 597         {
 598           ConvertBitmap( bitmap, ftFace->glyph->bitmap );
 599         }
 600
 601         // Created FT_Glyph object must be released with FT_Done_Glyph
 602         FT_Done_Glyph( glyph );
 603       }
 604     }
 605     else
 606     {
 607       DALI_LOG_ERROR( "FT_Load_Glyph Failed with error: %d\n", error );
 608     }
 609   }
 610
 611   return bitmap;
 612 }
 613
 614 const GlyphInfo& FontClient::Plugin::GetEllipsisGlyph( PointSize26Dot6 pointSize )
 615 {
 616   // First look into the cache if there is an ellipsis glyph for the requested point size.
 617   for( Vector<EllipsisItem>::ConstIterator it = mEllipsisCache.Begin(),
 618          endIt = mEllipsisCache.End();
 619        it != endIt;
 620        ++it )
 621   {
 622     const EllipsisItem& item = *it;
 623
 624     if( fabsf( item.size - pointSize ) < Math::MACHINE_EPSILON_1000 )
 625     {
 626       // Use the glyph in the cache.
 627       return item.glyph;
 628     }
 629   }
 630
 631   // No glyph has been found. Create one.
 632   mEllipsisCache.PushBack( EllipsisItem() );
 633   EllipsisItem& item = *( mEllipsisCache.End() - 1u );
 634
 635   item.size = pointSize;
 636
 637   // Find a font for the ellipsis glyph.
 638   item.glyph.fontId = FindDefaultFont( ELLIPSIS_CHARACTER,
 639                                        pointSize,
 640                                        false );
 641
 642   // Set the character index to access the glyph inside the font.
 643   item.glyph.index = FT_Get_Char_Index( mFontCache[item.glyph.fontId-1].mFreeTypeFace,
 644                                         ELLIPSIS_CHARACTER );
 645
 646   GetGlyphMetrics( &item.glyph, 1u, true );
 647
 648   return item.glyph;
 649 }
 650
 651 void FontClient::Plugin::InitSystemFonts()
 652 {
 653   FcFontSet* fontSet = GetFcFontSet();
 654
 655   if( fontSet )
 656   {
 657     // Reserve some space to avoid reallocations.
 658     mSystemFonts.reserve( fontSet->nfont );
 659
 660     for( int i = 0u; i < fontSet->nfont; ++i )
 661     {
 662       FcPattern* fontPattern = fontSet->fonts[i];
 663
 664       FontPath path;
 665
 666       // Skip fonts with no path
 667       if( GetFcString( fontPattern, FC_FILE, path ) )
 668       {
 669         mSystemFonts.push_back( FontDescription() );
 670         FontDescription& fontDescription = mSystemFonts.back();
 671
 672         fontDescription.path = path;
 673
 674         GetFcString( fontPattern, FC_FAMILY, fontDescription.family );
 675         GetFcString( fontPattern, FC_STYLE, fontDescription.style );
 676       }
 677     }
 678
 679     FcFontSetDestroy( fontSet );
 680   }
 681 }
 682
 683 FcPattern* FontClient::Plugin::CreateFontFamilyPattern( const FontFamily& fontFamily,
 684                                                         const FontStyle& fontStyle )
 685 {
 686   // create the cached font family lookup pattern
 687   // a pattern holds a set of names, each name refers to a property of the font
 688   FcPattern* fontFamilyPattern = FcPatternCreate();
 689
 690   // add a property to the pattern for the font family
 691   FcPatternAddString( fontFamilyPattern, FC_FAMILY, reinterpret_cast<const FcChar8*>( fontFamily.c_str() ) );
 692
 693   // add a property to the pattern for the font family
 694   FcPatternAddString( fontFamilyPattern, FC_STYLE, reinterpret_cast<const FcChar8*>( fontStyle.c_str() ) );
 695
 696   // Add a property of the pattern, to say we want to match TrueType fonts
 697   FcPatternAddString( fontFamilyPattern , FC_FONTFORMAT, reinterpret_cast<const FcChar8*>( FONT_FORMAT.c_str() ) );
 698
 699   // modify the config, with the mFontFamilyPatterm
 700   FcConfigSubstitute( NULL /* use default configure */, fontFamilyPattern, FcMatchPattern );
 701
 702   // provide default values for unspecified properties in the font pattern
 703   // e.g. patterns without a specified style or weight are set to Medium
 704   FcDefaultSubstitute( fontFamilyPattern );
 705
 706   return fontFamilyPattern;
 707 }
 708
 709 _FcFontSet* FontClient::Plugin::GetFcFontSet() const
 710 {
 711   // create a new pattern.
 712   // a pattern holds a set of names, each name refers to a property of the font
 713   FcPattern* pattern = FcPatternCreate();
 714
 715   // create an object set used to define which properties are to be returned in the patterns from FcFontList.
 716   FcObjectSet* objectSet = FcObjectSetCreate();
 717
 718   // build an object set from a list of property names
 719   FcObjectSetAdd( objectSet, FC_FILE );
 720   FcObjectSetAdd( objectSet, FC_FAMILY );
 721   FcObjectSetAdd( objectSet, FC_STYLE );
 722
 723   // get a list of fonts
 724   // creates patterns from those fonts containing only the objects in objectSet and returns the set of unique such patterns
 725   FcFontSet* fontset = FcFontList( NULL /* the default configuration is checked to be up to date, and used */, pattern, objectSet );
 726
 727   // clear up the object set
 728   if( objectSet )
 729   {
 730     FcObjectSetDestroy( objectSet );
 731   }
 732   // clear up the pattern
 733   if( pattern )
 734   {
 735     FcPatternDestroy( pattern );
 736   }
 737
 738   return fontset;
 739 }
 740
 741 bool FontClient::Plugin::GetFcString( const FcPattern* const pattern,
 742                                       const char* const n,
 743                                       std::string& string )
 744 {
 745   FcChar8* file = NULL;
 746   const FcResult retVal = FcPatternGetString( pattern, n, 0u, &file );
 747
 748   if( FcResultMatch == retVal )
 749   {
 750     // Have to use reinterpret_cast because FcChar8 is unsigned char*, not a const char*.
 751     string.assign( reinterpret_cast<const char*>( file ) );
 752
 753     return true;
 754   }
 755
 756   return false;
 757 }
 758
 759 FontId FontClient::Plugin::CreateFont( const FontPath& path,
 760                                        PointSize26Dot6 pointSize,
 761                                        FaceIndex faceIndex,
 762                                        bool cacheDescription )
 763 {
 764   FontId id( 0 );
 765
 766   // Create & cache new font face
 767   FT_Face ftFace;
 768   int error = FT_New_Face( mFreeTypeLibrary,
 769                            path.c_str(),
 770                            0,
 771                            &ftFace );
 772
 773   if( FT_Err_Ok == error )
 774   {
 775     // Check to see if the font contains fixed sizes?
 776     if ( ftFace->num_fixed_sizes && ftFace->available_sizes )
 777     {
 778       // Ensure this size is available
 779       for ( int i = 0; i < ftFace->num_fixed_sizes; ++i )
 780       {
 781         if ( static_cast<FT_Pos>(pointSize) == ftFace->available_sizes[ i ].size )
 782         {
 783           // Tell Freetype to use this size
 784           error = FT_Select_Size( ftFace, i );
 785           if ( FT_Err_Ok != error )
 786           {
 787             DALI_LOG_ERROR( "FreeType Select_Size error: %d\n", error );
 788           }
 789           else
 790           {
 791             float fixedWidth  = static_cast< float >( ftFace->available_sizes[ i ].width );
 792             float fixedHeight = static_cast< float >( ftFace->available_sizes[ i ].height );
 793
 794             // Indicate that the font is a fixed sized bitmap
 795             FontMetrics metrics( fixedHeight,
 796                                  0.0f,
 797                                  fixedHeight,
 798                                  0.0f,
 799                                  0.0f );
 800
 801             mFontCache.push_back( CacheItem( ftFace, path, pointSize, faceIndex, metrics, fixedWidth, fixedHeight ) );
 802             id = mFontCache.size();
 803
 804             if( cacheDescription )
 805             {
 806               FontDescription description;
 807               description.path = path;
 808               description.family = FontFamily( ftFace->family_name );
 809               description.style = FontStyle( ftFace->style_name );
 810
 811               mFontDescriptionCache.push_back( description );
 812             }
 813             return id;
 814           }
 815         }
 816       }
 817
 818       // Can't find this size
 819       std::stringstream sizes;
 820       for ( int i = 0; i < ftFace->num_fixed_sizes; ++i )
 821       {
 822         if ( i )
 823         {
 824           sizes << ", ";
 825         }
 826         sizes << ftFace->available_sizes[ i ].size;
 827       }
 828       DALI_LOG_ERROR( "FreeType Font: %s, does not contain Bitmaps of size: %d. Available sizes are: %s\n",
 829                        path.c_str(), pointSize, sizes.str().c_str() );
 830     }
 831     else
 832     {
 833       error = FT_Set_Char_Size( ftFace,
 834                               0,
 835                               pointSize,
 836                               mDpiHorizontal,
 837                               mDpiVertical );
 838
 839       if( FT_Err_Ok == error )
 840       {
 841
 842         FT_Size_Metrics& ftMetrics = ftFace->size->metrics;
 843
 844         FontMetrics metrics( static_cast< float >( ftMetrics.ascender  ) * FROM_266,
 845                              static_cast< float >( ftMetrics.descender ) * FROM_266,
 846                              static_cast< float >( ftMetrics.height    ) * FROM_266,
 847                              static_cast< float >( ftFace->underline_position ) * FROM_266,
 848                              static_cast< float >( ftFace->underline_thickness ) * FROM_266 );
 849
 850         mFontCache.push_back( CacheItem( ftFace, path, pointSize, faceIndex, metrics ) );
 851         id = mFontCache.size();
 852
 853         if( cacheDescription )
 854         {
 855           FontDescription description;
 856           description.path = path;
 857           description.family = FontFamily( ftFace->family_name );
 858           description.style = FontStyle( ftFace->style_name );
 859
 860           mFontDescriptionCache.push_back( description );
 861         }
 862       }
 863       else
 864       {
 865         DALI_LOG_ERROR( "FreeType Set_Char_Size error: %d for pointSize %d\n", error, pointSize );
 866       }
 867     }
 868   }
 869   else
 870   {
 871     DALI_LOG_ERROR( "FreeType New_Face error: %d for %s\n", error, path.c_str() );
 872   }
 873
 874   return id;
 875 }
 876
 877 void FontClient::Plugin::ConvertBitmap( BufferImage& destBitmap,
 878                                         FT_Bitmap srcBitmap )
 879 {
 880   if( srcBitmap.width*srcBitmap.rows > 0 )
 881   {
 882     switch( srcBitmap.pixel_mode )
 883     {
 884       case FT_PIXEL_MODE_GRAY:
 885       {
 886         if( srcBitmap.pitch == static_cast< int >( srcBitmap.width ) )
 887         {
 888           destBitmap = BufferImage::New( srcBitmap.width, srcBitmap.rows, Pixel::L8 );
 889
 890           PixelBuffer* destBuffer = destBitmap.GetBuffer();
 891           if( destBuffer )
 892           {
 893             memcpy( destBuffer, srcBitmap.buffer, srcBitmap.width*srcBitmap.rows );
 894           }
 895           else
 896           {
 897             DALI_LOG_ERROR( "GetBuffer returns null\n" );
 898           }
 899         }
 900         break;
 901       }
 902
 903 #ifdef FREETYPE_BITMAP_SUPPORT
 904       case FT_PIXEL_MODE_BGRA:
 905       {
 906         if ( srcBitmap.pitch == static_cast< int >( srcBitmap.width << 2 ) )
 907         {
 908           destBitmap = BufferImage::New( srcBitmap.width, srcBitmap.rows, Pixel::BGRA8888 );
 909
 910           PixelBuffer* destBuffer = destBitmap.GetBuffer();
 911           if( destBuffer )
 912           {
 913             memcpy( destBuffer, srcBitmap.buffer, srcBitmap.width*srcBitmap.rows*4 );
 914           }
 915           else
 916           {
 917             DALI_LOG_ERROR( "GetBuffer returns null\n" );
 918           }
 919         }
 920         break;
 921       }
 922 #endif
 923       default:
 924       {
 925         DALI_LOG_ERROR( "FontClient Unable to create Bitmap of this PixelType\n" );
 926         break;
 927       }
 928     }
 929   }
 930 }
 931
 932 bool FontClient::Plugin::FindFont( const FontPath& path,
 933                                    PointSize26Dot6 pointSize,
 934                                    FaceIndex faceIndex,
 935                                    FontId& fontId ) const
 936 {
 937   fontId = 0u;
 938   for( std::vector<CacheItem>::const_iterator it = mFontCache.begin(),
 939          endIt = mFontCache.end();
 940        it != endIt;
 941        ++it, ++fontId )
 942   {
 943     const CacheItem& cacheItem = *it;
 944
 945     if( cacheItem.mPointSize == pointSize &&
 946         cacheItem.mFaceIndex == faceIndex &&
 947         cacheItem.mPath == path )
 948     {
 949       ++fontId;
 950       return true;
 951     }
 952   }
 953
 954   return false;
 955 }
 956
 957 bool FontClient::Plugin::FindValidatedFont( const FontFamily& fontFamily,
 958                                             const FontStyle& fontStyle,
 959                                             FontDescriptionId& validatedFontId )
 960 {
 961   validatedFontId = 0u;
 962
 963   for( std::vector<FontDescriptionCacheItem>::const_iterator it = mValidatedFontCache.begin(),
 964          endIt = mValidatedFontCache.end();
 965        it != endIt;
 966        ++it )
 967   {
 968     const FontDescriptionCacheItem& item = *it;
 969
 970     if( ( fontFamily == item.fontFamily ) &&
 971         ( fontStyle == item.fontStyle ) )
 972     {
 973       validatedFontId = item.index;
 974
 975       return true;
 976     }
 977   }
 978
 979   return false;
 980 }
 981
 982 bool FontClient::Plugin::FindFont( FontDescriptionId validatedFontId,
 983                                    PointSize26Dot6 pointSize,
 984                                    FontId& fontId )
 985 {
 986   fontId = 0u;
 987
 988   for( std::vector<FontIdCacheItem>::const_iterator it = mFontIdCache.begin(),
 989          endIt = mFontIdCache.end();
 990        it != endIt;
 991        ++it )
 992   {
 993     const FontIdCacheItem& item = *it;
 994
 995     if( ( validatedFontId == item.validatedFontId ) &&
 996         ( pointSize == item.pointSize ) )
 997     {
 998       fontId = item.fontId;
 999       return true;
1000     }
1001   }
1002
1003   return false;
1004 }
1005
1006 bool FontClient::Plugin::IsScalable( const FontPath& path )
1007 {
1008   FT_Face ftFace;
1009   int error = FT_New_Face( mFreeTypeLibrary,
1010                            path.c_str(),
1011                            0,
1012                            &ftFace );
1013   if( FT_Err_Ok != error )
1014   {
1015     DALI_LOG_ERROR( "FreeType Cannot check font: %s\n", path.c_str() );
1016   }
1017   return ( ftFace->num_fixed_sizes == 0 );
1018 }
1019
1020 bool FontClient::Plugin::IsScalable( const FontFamily& fontFamily, const FontStyle& fontStyle )
1021 {
1022   // Create a font pattern.
1023   FcPattern* fontFamilyPattern = CreateFontFamilyPattern( fontFamily,
1024                                                           fontStyle );
1025
1026   FcResult result = FcResultMatch;
1027
1028   // match the pattern
1029   FcPattern* match = FcFontMatch( NULL /* use default configure */, fontFamilyPattern, &result );
1030   bool isScalable = true;
1031
1032   if( match )
1033   {
1034     // Get the path to the font file name.
1035     FontPath path;
1036     GetFcString( match, FC_FILE, path );
1037     isScalable = IsScalable( path );
1038   }
1039   else
1040   {
1041     DALI_LOG_ERROR( "FreeType Cannot check font: %s %s\n", fontFamily.c_str(), fontStyle.c_str() );
1042   }
1043   FcPatternDestroy( fontFamilyPattern );
1044   FcPatternDestroy( match );
1045   return isScalable;
1046 }
1047
1048 void FontClient::Plugin::GetFixedSizes( const FontPath& path, Vector< PointSize26Dot6 >& sizes )
1049 {
1050   // Empty the caller container
1051   sizes.Clear();
1052
1053   FT_Face ftFace;
1054   int error = FT_New_Face( mFreeTypeLibrary,
1055                            path.c_str(),
1056                            0,
1057                            &ftFace );
1058   if( FT_Err_Ok != error )
1059   {
1060     DALI_LOG_ERROR( "FreeType Cannot check font: %s\n", path.c_str() );
1061   }
1062
1063   // Fetch the number of fixed sizes available
1064   if ( ftFace->num_fixed_sizes && ftFace->available_sizes )
1065   {
1066     for ( int i = 0; i < ftFace->num_fixed_sizes; ++i )
1067     {
1068       sizes.PushBack( ftFace->available_sizes[ i ].size );
1069     }
1070   }
1071 }
1072
1073 void FontClient::Plugin::GetFixedSizes( const FontFamily& fontFamily,
1074                                         const FontStyle& fontStyle,
1075                                         Vector< PointSize26Dot6 >& sizes )
1076 {
1077   // Create a font pattern.
1078   FcPattern* fontFamilyPattern = CreateFontFamilyPattern( fontFamily,
1079                                                           fontStyle );
1080
1081   FcResult result = FcResultMatch;
1082
1083   // match the pattern
1084   FcPattern* match = FcFontMatch( NULL /* use default configure */, fontFamilyPattern, &result );
1085
1086   if( match )
1087   {
1088     // Get the path to the font file name.
1089     FontPath path;
1090     GetFcString( match, FC_FILE, path );
1091     GetFixedSizes( path, sizes );
1092   }
1093   else
1094   {
1095     DALI_LOG_ERROR( "FreeType Cannot check font: %s %s\n", fontFamily.c_str(), fontStyle.c_str() );
1096   }
1097   FcPatternDestroy( match );
1098   FcPatternDestroy( fontFamilyPattern );
1099 }
1100
1101 } // namespace Internal
1102
1103 } // namespace TextAbstraction
1104
1105 } // namespace Dali