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

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