dali-toolkit/internal/text/visual-model-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-toolkit/internal/text/visual-model-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <memory.h>
  23
  24 namespace Dali
  25 {
  26 namespace Toolkit
  27 {
  28 namespace Text
  29 {
  30 VisualModelPtr VisualModel::New()
  31 {
  32   return VisualModelPtr(new VisualModel());
  33 }
  34
  35 void VisualModel::CreateCharacterToGlyphTable(CharacterIndex startIndex,
  36                                               GlyphIndex     startGlyphIndex,
  37                                               Length         numberOfCharacters)
  38 {
  39   if(0u == numberOfCharacters)
  40   {
  41     // Nothing to do.
  42     return;
  43   }
  44
  45   DALI_ASSERT_DEBUG(mGlyphsPerCharacter.Count() != 0u);
  46
  47   // Get the total number of characters.
  48   const Length totalNumberOfCharacters = (0u == mGlyphsToCharacters.Count()) ? 0u : *(mGlyphsToCharacters.End() - 1u) + *(mCharactersPerGlyph.End() - 1u); // Index to the first character + the number of characters that form the last glyph.
  49
  50   // Whether the current buffer is being updated or is set from scratch.
  51   const bool updateCurrentBuffer = numberOfCharacters < totalNumberOfCharacters;
  52
  53   Vector<GlyphIndex> newCharactersToGlyph;
  54   GlyphIndex*        charactersToGlyphBuffer = NULL;
  55
  56   // 1) Reserve some space for the glyph indices to avoid reallocations.
  57   if(updateCurrentBuffer)
  58   {
  59     newCharactersToGlyph.Resize(numberOfCharacters);
  60     charactersToGlyphBuffer = newCharactersToGlyph.Begin();
  61   }
  62   else
  63   {
  64     mCharactersToGlyph.Resize(numberOfCharacters);
  65     charactersToGlyphBuffer = mCharactersToGlyph.Begin() + startIndex;
  66   }
  67
  68   const Length* const glyphsPerCharacterBuffer = mGlyphsPerCharacter.Begin();
  69
  70   // 2) Traverse the glyphs and set the glyph indices per character.
  71
  72   // Index to the glyph.
  73   GlyphIndex           glyphIndex                = startGlyphIndex;
  74   CharacterIndex       characterIndex            = startIndex;
  75   const CharacterIndex lastCharacterIndexPlusOne = startIndex + numberOfCharacters;
  76   for(Vector<Length>::ConstIterator it    = mCharactersPerGlyph.Begin() + glyphIndex,
  77                                     endIt = mCharactersPerGlyph.End();
  78       (it != endIt) && (characterIndex < lastCharacterIndexPlusOne);
  79       ++it)
  80   {
  81     const Length numberOfCharactersPerGlyph = *it;
  82
  83     Length numberOfGlyphs = 0u;
  84     // Set the glyph indices.
  85     for(Length index = 0u; index < numberOfCharactersPerGlyph; ++index, ++characterIndex)
  86     {
  87       *charactersToGlyphBuffer = glyphIndex;
  88       numberOfGlyphs += *(glyphsPerCharacterBuffer + characterIndex);
  89       ++charactersToGlyphBuffer;
  90     }
  91     glyphIndex += numberOfGlyphs;
  92   }
  93
  94   // If the character to glyph buffer is updated, it needs to be inserted in the model.
  95   if(updateCurrentBuffer)
  96   {
  97     // Update the indices.
  98     const Length numberOfGlyphs = glyphIndex - startGlyphIndex;
  99     for(Vector<Length>::Iterator it    = mCharactersToGlyph.Begin() + startIndex,
 100                                  endIt = mCharactersToGlyph.End();
 101         it != endIt;
 102         ++it)
 103     {
 104       *it += numberOfGlyphs;
 105     }
 106
 107     mCharactersToGlyph.Insert(mCharactersToGlyph.Begin() + startIndex,
 108                               newCharactersToGlyph.Begin(),
 109                               newCharactersToGlyph.End());
 110   }
 111 }
 112
 113 void VisualModel::CreateGlyphsPerCharacterTable(CharacterIndex startIndex,
 114                                                 GlyphIndex     startGlyphIndex,
 115                                                 Length         numberOfCharacters)
 116 {
 117   if(0u == numberOfCharacters)
 118   {
 119     // Nothing to do.
 120     return;
 121   }
 122
 123   // Get the total number of characters.
 124   const Length totalNumberOfCharacters = (0u == mGlyphsToCharacters.Count()) ? 0u : *(mGlyphsToCharacters.End() - 1u) + *(mCharactersPerGlyph.End() - 1u); // Index to the first character + the number of characters that form the last glyph.
 125
 126   // Whether the current buffer is being updated or is set from scratch.
 127   const bool updateCurrentBuffer = numberOfCharacters < totalNumberOfCharacters;
 128
 129   Vector<Length> newGlyphsPerCharacter;
 130   Length*        glyphsPerCharacterBuffer = NULL;
 131
 132   // 1) Reserve some space for the glyphs per character to avoid reallocations.
 133   if(updateCurrentBuffer)
 134   {
 135     newGlyphsPerCharacter.Resize(numberOfCharacters);
 136     glyphsPerCharacterBuffer = newGlyphsPerCharacter.Begin();
 137   }
 138   else
 139   {
 140     mGlyphsPerCharacter.Resize(numberOfCharacters);
 141     glyphsPerCharacterBuffer = mGlyphsPerCharacter.Begin() + startIndex;
 142   }
 143
 144   // 2) Traverse the glyphs and set the number of glyphs per character.
 145
 146   Length traversedCharacters = 0;
 147
 148   // The number of 'characters per glyph' equal to zero.
 149   Length zeroCharactersPerGlyph = 0u;
 150
 151   for(Vector<Length>::ConstIterator it    = mCharactersPerGlyph.Begin() + startGlyphIndex,
 152                                     endIt = mCharactersPerGlyph.End();
 153       (it != endIt) && (traversedCharacters < numberOfCharacters);
 154       ++it)
 155   {
 156     const Length numberOfCharactersPerGlyph = *it;
 157     traversedCharacters += numberOfCharactersPerGlyph;
 158
 159     // Set the glyphs per character.
 160     if(0u == numberOfCharactersPerGlyph)
 161     {
 162       ++zeroCharactersPerGlyph;
 163     }
 164     else
 165     {
 166       const Length numberOfZeroGlyphsPerCharacter = (numberOfCharactersPerGlyph - 1u);
 167       for(Length zeroIndex = 0u; zeroIndex < numberOfZeroGlyphsPerCharacter; ++zeroIndex)
 168       {
 169         *glyphsPerCharacterBuffer = 0u;
 170
 171         // Point to the next position in the buffer.
 172         ++glyphsPerCharacterBuffer;
 173       }
 174
 175       *glyphsPerCharacterBuffer = zeroCharactersPerGlyph + 1u;
 176
 177       zeroCharactersPerGlyph = 0u;
 178
 179       // Point to the next position in the buffer.
 180       ++glyphsPerCharacterBuffer;
 181     }
 182   }
 183
 184   // If the glyphs per character buffer is updated, it needs to be inserted in the model.
 185   if(updateCurrentBuffer)
 186   {
 187     mGlyphsPerCharacter.Insert(mGlyphsPerCharacter.Begin() + startIndex,
 188                                newGlyphsPerCharacter.Begin(),
 189                                newGlyphsPerCharacter.End());
 190   }
 191 }
 192
 193 void VisualModel::GetGlyphs(GlyphInfo* glyphs,
 194                             GlyphIndex glyphIndex,
 195                             Length     numberOfGlyphs) const
 196 {
 197   memcpy(glyphs, mGlyphs.Begin() + glyphIndex, numberOfGlyphs * sizeof(GlyphInfo));
 198 }
 199
 200 void VisualModel::GetGlyphPositions(Vector2*   glyphPositions,
 201                                     GlyphIndex glyphIndex,
 202                                     Length     numberOfGlyphs) const
 203 {
 204   memcpy(glyphPositions, mGlyphPositions.Begin() + glyphIndex, numberOfGlyphs * sizeof(Vector2));
 205 }
 206
 207 void VisualModel::GetNumberOfLines(GlyphIndex glyphIndex,
 208                                    Length     numberOfGlyphs,
 209                                    LineIndex& firstLine,
 210                                    Length&    numberOfLines) const
 211 {
 212   // Initialize the number of lines and the first line.
 213   firstLine           = 0u;
 214   numberOfLines       = 0u;
 215   bool firstLineFound = false;
 216
 217   const GlyphIndex lastGlyphIndex = glyphIndex + numberOfGlyphs;
 218
 219   // Traverse the lines and count those lines within the range of glyphs.
 220   for(Vector<LineRun>::ConstIterator it    = mLines.Begin(),
 221                                      endIt = mLines.End();
 222       it != endIt;
 223       ++it)
 224   {
 225     const LineRun& line = *it;
 226
 227     if((line.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs > glyphIndex) &&
 228        (lastGlyphIndex > line.glyphRun.glyphIndex))
 229     {
 230       firstLineFound = true;
 231       ++numberOfLines;
 232     }
 233     else if((line.glyphRunSecondHalf.glyphIndex + line.glyphRunSecondHalf.numberOfGlyphs > glyphIndex) &&
 234             (lastGlyphIndex > line.glyphRunSecondHalf.glyphIndex))
 235     {
 236       firstLineFound = true;
 237       ++numberOfLines;
 238     }
 239     else if(lastGlyphIndex <= line.glyphRun.glyphIndex)
 240     {
 241       // nothing else to do.
 242       break;
 243     }
 244
 245     if(!firstLineFound)
 246     {
 247       ++firstLine;
 248     }
 249   }
 250 }
 251
 252 void VisualModel::GetLinesOfGlyphRange(LineRun*   lines,
 253                                        GlyphIndex glyphIndex,
 254                                        Length     numberOfGlyphs) const
 255 {
 256   LineIndex firstLine     = 0u;
 257   Length    numberOfLines = 0u;
 258
 259   GetNumberOfLines(glyphIndex,
 260                    numberOfGlyphs,
 261                    firstLine,
 262                    numberOfLines);
 263
 264   memcpy(lines, mLines.Begin() + firstLine, numberOfLines * sizeof(LineRun));
 265 }
 266
 267 LineIndex VisualModel::GetLineOfCharacter(CharacterIndex characterIndex)
 268 {
 269   // 1) Check line is empty or not.
 270   if(mLines.Empty())
 271   {
 272     return 0u;
 273   }
 274
 275   // 2) Check in the cached line.
 276   const LineRun& lineRun = *(mLines.Begin() + mCachedLineIndex);
 277   if((lineRun.characterRun.characterIndex <= characterIndex) &&
 278      (characterIndex < lineRun.characterRun.characterIndex + lineRun.characterRun.numberOfCharacters))
 279   {
 280     return mCachedLineIndex;
 281   }
 282
 283   // 3) Is not in the cached line. Check in the other lines.
 284   LineIndex index = characterIndex < lineRun.characterRun.characterIndex ? 0u : mCachedLineIndex + 1u;
 285
 286   for(Vector<LineRun>::ConstIterator it    = mLines.Begin() + index,
 287                                      endIt = mLines.End();
 288       it != endIt;
 289       ++it, ++index)
 290   {
 291     const LineRun& lineRun = *it;
 292
 293     if(characterIndex < lineRun.characterRun.characterIndex + lineRun.characterRun.numberOfCharacters)
 294     {
 295       mCachedLineIndex = index;
 296       break;
 297     }
 298   }
 299
 300   return index;
 301 }
 302
 303 void VisualModel::GetUnderlineRuns(GlyphRun*         underlineRuns,
 304                                    UnderlineRunIndex index,
 305                                    Length            numberOfRuns) const
 306 {
 307   memcpy(underlineRuns,
 308          mUnderlineRuns.Begin() + index,
 309          numberOfRuns * sizeof(GlyphRun));
 310 }
 311
 312 void VisualModel::SetNaturalSize(const Vector2& size)
 313 {
 314   mNaturalSize = size;
 315 }
 316
 317 const Vector2& VisualModel::GetNaturalSize() const
 318 {
 319   return mNaturalSize;
 320 }
 321
 322 void VisualModel::SetLayoutSize(const Vector2& size)
 323 {
 324   mLayoutSize = size;
 325 }
 326
 327 const Vector2& VisualModel::GetLayoutSize() const
 328 {
 329   return mLayoutSize;
 330 }
 331
 332 void VisualModel::SetTextColor(const Vector4& textColor)
 333 {
 334   mTextColor = textColor;
 335
 336   if(!mUnderlineColorSet)
 337   {
 338     mUnderlineColor = textColor;
 339   }
 340 }
 341
 342 void VisualModel::SetShadowOffset(const Vector2& shadowOffset)
 343 {
 344   mShadowOffset = shadowOffset;
 345 }
 346
 347 void VisualModel::SetShadowColor(const Vector4& shadowColor)
 348 {
 349   mShadowColor = shadowColor;
 350 }
 351
 352 void VisualModel::SetShadowBlurRadius(const float& shadowBlurRadius)
 353 {
 354   mShadowBlurRadius = shadowBlurRadius;
 355 }
 356
 357 void VisualModel::SetUnderlineColor(const Vector4& color)
 358 {
 359   mUnderlineColor    = color;
 360   mUnderlineColorSet = true;
 361 }
 362
 363 void VisualModel::SetOutlineColor(const Vector4& color)
 364 {
 365   mOutlineColor = color;
 366 }
 367
 368 void VisualModel::SetUnderlineEnabled(bool enabled)
 369 {
 370   mUnderlineEnabled = enabled;
 371 }
 372
 373 void VisualModel::SetUnderlineHeight(float height)
 374 {
 375   mUnderlineHeight = height;
 376 }
 377
 378 void VisualModel::SetOutlineWidth(uint16_t width)
 379 {
 380   mOutlineWidth = width;
 381 }
 382
 383 void VisualModel::SetBackgroundColor(const Vector4& color)
 384 {
 385   mBackgroundColor = color;
 386 }
 387
 388 void VisualModel::SetBackgroundEnabled(bool enabled)
 389 {
 390   mBackgroundEnabled = enabled;
 391 }
 392
 393 void VisualModel::SetMarkupProcessorEnabled(bool enabled)
 394 {
 395   mMarkupProcessorEnabled = enabled;
 396 }
 397
 398 void VisualModel::SetTextElideEnabled(bool enabled)
 399 {
 400   mTextElideEnabled = enabled;
 401 }
 402
 403 void VisualModel::SetEllipsisPosition(Toolkit::DevelText::EllipsisPosition::Type ellipsisPosition)
 404 {
 405   mEllipsisPosition = ellipsisPosition;
 406 }
 407
 408 void VisualModel::SetStartIndexOfElidedGlyphs(GlyphIndex startIndexOfElidedGlyphs)
 409 {
 410   mStartIndexOfElidedGlyphs = startIndexOfElidedGlyphs;
 411 }
 412
 413 void VisualModel::SetEndIndexOfElidedGlyphs(GlyphIndex endIndexOfElidedGlyphs)
 414 {
 415   mEndIndexOfElidedGlyphs = endIndexOfElidedGlyphs;
 416 }
 417
 418 void VisualModel::SetFirstMiddleIndexOfElidedGlyphs(GlyphIndex firstMiddleIndexOfElidedGlyphs)
 419 {
 420   mFirstMiddleIndexOfElidedGlyphs = firstMiddleIndexOfElidedGlyphs;
 421 }
 422
 423 void VisualModel::SetSecondMiddleIndexOfElidedGlyphs(GlyphIndex secondMiddleIndexOfElidedGlyphs)
 424 {
 425   mSecondMiddleIndexOfElidedGlyphs = secondMiddleIndexOfElidedGlyphs;
 426 }
 427
 428 const Vector4& VisualModel::GetTextColor() const
 429 {
 430   return mTextColor;
 431 }
 432
 433 const Vector2& VisualModel::GetShadowOffset() const
 434 {
 435   return mShadowOffset;
 436 }
 437
 438 const Vector4& VisualModel::GetShadowColor() const
 439 {
 440   return mShadowColor;
 441 }
 442
 443 const float& VisualModel::GetShadowBlurRadius() const
 444 {
 445   return mShadowBlurRadius;
 446 }
 447
 448 const Vector4& VisualModel::GetUnderlineColor() const
 449 {
 450   return mUnderlineColor;
 451 }
 452
 453 const Vector4& VisualModel::GetOutlineColor() const
 454 {
 455   return mOutlineColor;
 456 }
 457
 458 bool VisualModel::IsUnderlineEnabled() const
 459 {
 460   return mUnderlineEnabled;
 461 }
 462
 463 float VisualModel::GetUnderlineHeight() const
 464 {
 465   return mUnderlineHeight;
 466 }
 467
 468 uint16_t VisualModel::GetOutlineWidth() const
 469 {
 470   return mOutlineWidth;
 471 }
 472
 473 const Vector4& VisualModel::GetBackgroundColor() const
 474 {
 475   return mBackgroundColor;
 476 }
 477
 478 bool VisualModel::IsBackgroundEnabled() const
 479 {
 480   return mBackgroundEnabled;
 481 }
 482
 483 bool VisualModel::IsMarkupProcessorEnabled() const
 484 {
 485   return mMarkupProcessorEnabled;
 486 }
 487
 488 bool VisualModel::IsTextElideEnabled() const
 489 {
 490   return mTextElideEnabled;
 491 }
 492
 493 Toolkit::DevelText::EllipsisPosition::Type VisualModel::GetEllipsisPosition() const
 494 {
 495   return mEllipsisPosition;
 496 }
 497
 498 GlyphIndex VisualModel::GetStartIndexOfElidedGlyphs() const
 499 {
 500   return mStartIndexOfElidedGlyphs;
 501 }
 502
 503 GlyphIndex VisualModel::GetEndIndexOfElidedGlyphs() const
 504 {
 505   return mEndIndexOfElidedGlyphs;
 506 }
 507
 508 GlyphIndex VisualModel::GetFirstMiddleIndexOfElidedGlyphs() const
 509 {
 510   return mFirstMiddleIndexOfElidedGlyphs;
 511 }
 512
 513 GlyphIndex VisualModel::GetSecondMiddleIndexOfElidedGlyphs() const
 514 {
 515   return mSecondMiddleIndexOfElidedGlyphs;
 516 }
 517
 518 Length VisualModel::GetNumberOfUnderlineRuns() const
 519 {
 520   return mUnderlineRuns.Count();
 521 }
 522
 523 void VisualModel::ClearCaches()
 524 {
 525   mCachedLineIndex = 0u;
 526 }
 527
 528 VisualModel::~VisualModel()
 529 {
 530 }
 531
 532 VisualModel::VisualModel()
 533 : mGlyphs(),
 534   mGlyphsToCharacters(),
 535   mCharactersToGlyph(),
 536   mCharactersPerGlyph(),
 537   mGlyphsPerCharacter(),
 538   mGlyphPositions(),
 539   mLines(),
 540   mTextColor(Color::BLACK),
 541   mShadowColor(Color::BLACK),
 542   mUnderlineColor(Color::BLACK),
 543   mOutlineColor(Color::WHITE),
 544   mBackgroundColor(Color::TRANSPARENT),
 545   mControlSize(),
 546   mShadowOffset(),
 547   mUnderlineHeight(0.0f),
 548   mShadowBlurRadius(0.0f),
 549   mOutlineWidth(0u),
 550   mNaturalSize(),
 551   mLayoutSize(),
 552   mCachedLineIndex(0u),
 553   mEllipsisPosition(DevelText::EllipsisPosition::END),
 554   mStartIndexOfElidedGlyphs(0u),
 555   mEndIndexOfElidedGlyphs(0u),
 556   mFirstMiddleIndexOfElidedGlyphs(0u),
 557   mSecondMiddleIndexOfElidedGlyphs(0u),
 558   mTextElideEnabled(false),
 559   mUnderlineEnabled(false),
 560   mUnderlineColorSet(false),
 561   mBackgroundEnabled(false),
 562   mMarkupProcessorEnabled(false)
 563
 564 {
 565 }
 566
 567 } // namespace Text
 568
 569 } // namespace Toolkit
 570
 571 } // namespace Dali