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

   1 /*
   2  * Copyright (c) 2021 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/text-abstraction/font-client-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #if !(defined(DALI_PROFILE_UBUNTU) || defined(ANDROID) || defined(WIN32) || defined(__APPLE__))
  23 #include <vconf.h>
  24 #endif
  25
  26 // INTERNAL INCLUDES
  27 #include <dali/devel-api/common/singleton-service.h>
  28 #include <dali/internal/text/text-abstraction/plugin/font-client-plugin-impl.h>
  29
  30 #include <dali/devel-api/text-abstraction/glyph-info.h>
  31
  32 namespace Dali
  33 {
  34 namespace TextAbstraction
  35 {
  36 namespace Internal
  37 {
  38 Dali::TextAbstraction::FontClient FontClient::gPreInitializedFontClient(NULL);
  39
  40 FontClient::FontClient()
  41 : mPlugin(nullptr),
  42   mDpiHorizontal(0),
  43   mDpiVertical(0)
  44 {
  45 }
  46
  47 FontClient::~FontClient()
  48 {
  49   delete mPlugin;
  50 }
  51
  52 Dali::TextAbstraction::FontClient FontClient::Get()
  53 {
  54   Dali::TextAbstraction::FontClient fontClientHandle;
  55
  56   Dali::SingletonService service(SingletonService::Get());
  57   if(service)
  58   {
  59     // Check whether the singleton is already created
  60     Dali::BaseHandle handle = service.GetSingleton(typeid(Dali::TextAbstraction::FontClient));
  61     if(handle)
  62     {
  63       // If so, downcast the handle
  64       FontClient* impl = dynamic_cast<Dali::TextAbstraction::Internal::FontClient*>(handle.GetObjectPtr());
  65       fontClientHandle = Dali::TextAbstraction::FontClient(impl);
  66     }
  67     else // create and register the object
  68     {
  69       if(gPreInitializedFontClient)
  70       {
  71         fontClientHandle = gPreInitializedFontClient;
  72         gPreInitializedFontClient.Reset(); // No longer needed
  73       }
  74       else
  75       {
  76         fontClientHandle = Dali::TextAbstraction::FontClient(new FontClient);
  77       }
  78
  79       service.Register(typeid(fontClientHandle), fontClientHandle);
  80     }
  81   }
  82
  83   return fontClientHandle;
  84 }
  85
  86 Dali::TextAbstraction::FontClient FontClient::PreInitialize()
  87 {
  88   gPreInitializedFontClient = Dali::TextAbstraction::FontClient(new FontClient);
  89
  90   // Make DefaultFontDescription cached
  91   Dali::TextAbstraction::FontDescription defaultFontDescription;
  92   gPreInitializedFontClient.GetDefaultPlatformFontDescription(defaultFontDescription);
  93
  94   return gPreInitializedFontClient;
  95 }
  96
  97 void FontClient::ClearCache()
  98 {
  99   if(mPlugin)
 100   {
 101     mPlugin->ClearCache();
 102   }
 103 }
 104
 105 void FontClient::SetDpi(unsigned int horizontalDpi, unsigned int verticalDpi)
 106 {
 107   mDpiHorizontal = horizontalDpi;
 108   mDpiVertical   = verticalDpi;
 109
 110   // Allow DPI to be set without loading plugin
 111   if(mPlugin)
 112   {
 113     mPlugin->SetDpi(horizontalDpi, verticalDpi);
 114   }
 115 }
 116
 117 void FontClient::GetDpi(unsigned int& horizontalDpi, unsigned int& verticalDpi)
 118 {
 119   horizontalDpi = mDpiHorizontal;
 120   verticalDpi   = mDpiVertical;
 121 }
 122
 123 int FontClient::GetDefaultFontSize()
 124 {
 125   int fontSize(-1);
 126
 127 #if !(defined(DALI_PROFILE_UBUNTU) || defined(ANDROID) || defined(WIN32) || defined(__APPLE__))
 128   vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, &fontSize);
 129 #endif
 130
 131   return fontSize;
 132 }
 133
 134 void FontClient::ResetSystemDefaults()
 135 {
 136   CreatePlugin();
 137
 138   mPlugin->ResetSystemDefaults();
 139 }
 140
 141 void FontClient::GetDefaultFonts(FontList& defaultFonts)
 142 {
 143   CreatePlugin();
 144
 145   mPlugin->GetDefaultFonts(defaultFonts);
 146 }
 147
 148 void FontClient::GetDefaultPlatformFontDescription(FontDescription& fontDescription)
 149 {
 150   CreatePlugin();
 151
 152   mPlugin->GetDefaultPlatformFontDescription(fontDescription);
 153 }
 154
 155 void FontClient::GetDescription(FontId id, FontDescription& fontDescription)
 156 {
 157   CreatePlugin();
 158
 159   mPlugin->GetDescription(id, fontDescription);
 160 }
 161
 162 PointSize26Dot6 FontClient::GetPointSize(FontId id)
 163 {
 164   CreatePlugin();
 165
 166   return mPlugin->GetPointSize(id);
 167 }
 168
 169 bool FontClient::IsCharacterSupportedByFont(FontId fontId, Character character)
 170 {
 171   CreatePlugin();
 172
 173   return mPlugin->IsCharacterSupportedByFont(fontId, character);
 174 }
 175
 176 void FontClient::GetSystemFonts(FontList& systemFonts)
 177 {
 178   CreatePlugin();
 179
 180   mPlugin->GetSystemFonts(systemFonts);
 181 }
 182
 183 FontId FontClient::FindDefaultFont(Character       charcode,
 184                                    PointSize26Dot6 requestedPointSize,
 185                                    bool            preferColor)
 186 {
 187   CreatePlugin();
 188
 189   return mPlugin->FindDefaultFont(charcode,
 190                                   requestedPointSize,
 191                                   preferColor);
 192 }
 193
 194 FontId FontClient::FindFallbackFont(Character              charcode,
 195                                     const FontDescription& preferredFontDescription,
 196                                     PointSize26Dot6        requestedPointSize,
 197                                     bool                   preferColor)
 198 {
 199   CreatePlugin();
 200
 201   return mPlugin->FindFallbackFont(charcode,
 202                                    preferredFontDescription,
 203                                    requestedPointSize,
 204                                    preferColor);
 205 }
 206
 207 bool FontClient::IsScalable(const FontPath& path)
 208 {
 209   CreatePlugin();
 210
 211   return mPlugin->IsScalable(path);
 212 }
 213
 214 bool FontClient::IsScalable(const FontDescription& fontDescription)
 215 {
 216   CreatePlugin();
 217
 218   return mPlugin->IsScalable(fontDescription);
 219 }
 220
 221 void FontClient::GetFixedSizes(const FontPath& path, Dali::Vector<PointSize26Dot6>& sizes)
 222 {
 223   CreatePlugin();
 224
 225   mPlugin->GetFixedSizes(path, sizes);
 226 }
 227
 228 void FontClient::GetFixedSizes(const FontDescription&         fontDescription,
 229                                Dali::Vector<PointSize26Dot6>& sizes)
 230 {
 231   CreatePlugin();
 232
 233   mPlugin->GetFixedSizes(fontDescription, sizes);
 234 }
 235
 236 bool FontClient::HasItalicStyle(FontId fontId) const
 237 {
 238   if(!mPlugin)
 239   {
 240     return false;
 241   }
 242   return mPlugin->HasItalicStyle(fontId);
 243 }
 244
 245 FontId FontClient::GetFontId(const FontPath& path, PointSize26Dot6 requestedPointSize, FaceIndex faceIndex)
 246 {
 247   CreatePlugin();
 248
 249   return mPlugin->GetFontId(path,
 250                             requestedPointSize,
 251                             faceIndex,
 252                             true);
 253 }
 254
 255 FontId FontClient::GetFontId(const FontDescription& fontDescription,
 256                              PointSize26Dot6        requestedPointSize,
 257                              FaceIndex              faceIndex)
 258 {
 259   CreatePlugin();
 260
 261   return mPlugin->GetFontId(fontDescription,
 262                             requestedPointSize,
 263                             faceIndex);
 264 }
 265
 266 FontId FontClient::GetFontId(const BitmapFont& bitmapFont)
 267 {
 268   CreatePlugin();
 269
 270   return mPlugin->GetFontId(bitmapFont);
 271 }
 272
 273 void FontClient::GetFontMetrics(FontId fontId, FontMetrics& metrics)
 274 {
 275   CreatePlugin();
 276
 277   mPlugin->GetFontMetrics(fontId, metrics);
 278 }
 279
 280 GlyphIndex FontClient::GetGlyphIndex(FontId fontId, Character charcode)
 281 {
 282   CreatePlugin();
 283
 284   return mPlugin->GetGlyphIndex(fontId, charcode);
 285 }
 286
 287 GlyphIndex FontClient::GetGlyphIndex(FontId fontId, Character charcode, Character variantSelector)
 288 {
 289   CreatePlugin();
 290
 291   return mPlugin->GetGlyphIndex(fontId, charcode, variantSelector);
 292 }
 293
 294 bool FontClient::GetGlyphMetrics(GlyphInfo* array, uint32_t size, GlyphType type, bool horizontal)
 295 {
 296   CreatePlugin();
 297
 298   return mPlugin->GetGlyphMetrics(array, size, type, horizontal);
 299 }
 300
 301 void FontClient::CreateBitmap(FontId fontId, GlyphIndex glyphIndex, bool isItalicRequired, bool isBoldRequired, Dali::TextAbstraction::FontClient::GlyphBufferData& data, int outlineWidth)
 302 {
 303   CreatePlugin();
 304
 305   mPlugin->CreateBitmap(fontId, glyphIndex, isItalicRequired, isBoldRequired, data, outlineWidth);
 306 }
 307
 308 PixelData FontClient::CreateBitmap(FontId fontId, GlyphIndex glyphIndex, int outlineWidth)
 309 {
 310   CreatePlugin();
 311
 312   return mPlugin->CreateBitmap(fontId, glyphIndex, outlineWidth);
 313 }
 314
 315 void FontClient::CreateVectorBlob(FontId fontId, GlyphIndex glyphIndex, VectorBlob*& blob, unsigned int& blobLength, unsigned int& nominalWidth, unsigned int& nominalHeight)
 316 {
 317   CreatePlugin();
 318
 319   mPlugin->CreateVectorBlob(fontId, glyphIndex, blob, blobLength, nominalWidth, nominalHeight);
 320 }
 321
 322 const GlyphInfo& FontClient::GetEllipsisGlyph(PointSize26Dot6 requestedPointSize)
 323 {
 324   CreatePlugin();
 325
 326   return mPlugin->GetEllipsisGlyph(requestedPointSize);
 327 }
 328
 329 bool FontClient::IsColorGlyph(FontId fontId, GlyphIndex glyphIndex)
 330 {
 331   CreatePlugin();
 332
 333   return mPlugin->IsColorGlyph(fontId, glyphIndex);
 334 }
 335
 336 GlyphIndex FontClient::CreateEmbeddedItem(const TextAbstraction::FontClient::EmbeddedItemDescription& description, Pixel::Format& pixelFormat)
 337 {
 338   CreatePlugin();
 339
 340   return mPlugin->CreateEmbeddedItem(description, pixelFormat);
 341 }
 342
 343 void FontClient::EnableAtlasLimitation(bool enabled)
 344 {
 345   CreatePlugin();
 346   return mPlugin->EnableAtlasLimitation(enabled);
 347 }
 348
 349 bool FontClient::IsAtlasLimitationEnabled() const
 350 {
 351   if(mPlugin)
 352   {
 353     return mPlugin->IsAtlasLimitationEnabled();
 354   }
 355   return TextAbstraction::FontClient::DEFAULT_ATLAS_LIMITATION_ENABLED;
 356 }
 357
 358 Size FontClient::GetMaximumTextAtlasSize() const
 359 {
 360   if(mPlugin)
 361   {
 362     return mPlugin->GetMaximumTextAtlasSize();
 363   }
 364   return TextAbstraction::FontClient::MAX_TEXT_ATLAS_SIZE;
 365 }
 366
 367 Size FontClient::GetDefaultTextAtlasSize() const
 368 {
 369   if(mPlugin)
 370   {
 371     return mPlugin->GetDefaultTextAtlasSize();
 372   }
 373   return TextAbstraction::FontClient::DEFAULT_TEXT_ATLAS_SIZE;
 374 }
 375
 376 Size FontClient::GetCurrentMaximumBlockSizeFitInAtlas() const
 377 {
 378   if(mPlugin)
 379   {
 380     return mPlugin->GetCurrentMaximumBlockSizeFitInAtlas();
 381   }
 382   return TextAbstraction::FontClient::DEFAULT_TEXT_ATLAS_SIZE;
 383 }
 384
 385 bool FontClient::SetCurrentMaximumBlockSizeFitInAtlas(const Size& currentMaximumBlockSizeFitInAtlas)
 386 {
 387   CreatePlugin();
 388   return mPlugin->SetCurrentMaximumBlockSizeFitInAtlas(currentMaximumBlockSizeFitInAtlas);
 389 }
 390
 391 uint32_t FontClient::GetNumberOfPointsPerOneUnitOfPointSize() const
 392 {
 393   if(mPlugin)
 394   {
 395     return mPlugin->GetNumberOfPointsPerOneUnitOfPointSize();
 396   }
 397   return TextAbstraction::FontClient::NUMBER_OF_POINTS_PER_ONE_UNIT_OF_POINT_SIZE;
 398   ;
 399 }
 400
 401 FT_FaceRec_* FontClient::GetFreetypeFace(FontId fontId)
 402 {
 403   CreatePlugin();
 404
 405   return mPlugin->GetFreetypeFace(fontId);
 406 }
 407
 408 FontDescription::Type FontClient::GetFontType(FontId fontId)
 409 {
 410   CreatePlugin();
 411
 412   return mPlugin->GetFontType(fontId);
 413 }
 414
 415 bool FontClient::AddCustomFontDirectory(const FontPath& path)
 416 {
 417   CreatePlugin();
 418
 419   return mPlugin->AddCustomFontDirectory(path);
 420 }
 421
 422 void FontClient::CreatePlugin()
 423 {
 424   if(!mPlugin)
 425   {
 426     mPlugin = new Plugin(mDpiHorizontal, mDpiVertical);
 427   }
 428 }
 429
 430 } // namespace Internal
 431
 432 } // namespace TextAbstraction
 433
 434 } // namespace Dali