dali-toolkit/internal/text/logical-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/logical-model-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali-toolkit/internal/text/input-style.h>
  23 #include <dali-toolkit/internal/text/text-run-container.h>
  24
  25 namespace Dali
  26 {
  27 namespace Toolkit
  28 {
  29 namespace Text
  30 {
  31 void FreeFontFamilyNames(Vector<FontDescriptionRun>& fontDescriptionRuns)
  32 {
  33   for(Vector<FontDescriptionRun>::Iterator it    = fontDescriptionRuns.Begin(),
  34                                            endIt = fontDescriptionRuns.End();
  35       it != endIt;
  36       ++it)
  37   {
  38     delete[](*it).familyName;
  39   }
  40
  41   fontDescriptionRuns.Clear();
  42 }
  43
  44 void FreeEmbeddedItems(Vector<EmbeddedItem>& embeddedItem)
  45 {
  46   for(Vector<EmbeddedItem>::Iterator it    = embeddedItem.Begin(),
  47                                      endIt = embeddedItem.End();
  48       it != endIt;
  49       ++it)
  50   {
  51     EmbeddedItem& item = *it;
  52     delete[] item.url;
  53   }
  54
  55   embeddedItem.Clear();
  56 }
  57
  58 void FreeAnchors(Vector<Anchor>& anchors)
  59 {
  60   for(auto&& anchor : anchors)
  61   {
  62     delete[] anchor.href;
  63   }
  64
  65   anchors.Clear();
  66 }
  67
  68 LogicalModelPtr LogicalModel::New()
  69 {
  70   return LogicalModelPtr(new LogicalModel());
  71 }
  72
  73 Script LogicalModel::GetScript(CharacterIndex characterIndex) const
  74 {
  75   // If this operation is too slow, consider a binary search.
  76
  77   const ScriptRun* const scriptRunBuffer = mScriptRuns.Begin();
  78   for(Length index = 0u, length = mScriptRuns.Count(); index < length; ++index)
  79   {
  80     const ScriptRun* const scriptRun = scriptRunBuffer + index;
  81
  82     if((scriptRun->characterRun.characterIndex <= characterIndex) &&
  83        (characterIndex < scriptRun->characterRun.characterIndex + scriptRun->characterRun.numberOfCharacters))
  84     {
  85       return scriptRun->script;
  86     }
  87   }
  88
  89   return TextAbstraction::UNKNOWN;
  90 }
  91
  92 CharacterDirection LogicalModel::GetCharacterDirection(CharacterIndex characterIndex) const
  93 {
  94   if(characterIndex >= mCharacterDirections.Count())
  95   {
  96     // The model has no right to left characters, so the vector of directions is void.
  97     return false;
  98   }
  99
 100   return *(mCharacterDirections.Begin() + characterIndex);
 101 }
 102
 103 CharacterIndex LogicalModel::GetLogicalCursorIndex(CharacterIndex visualCursorIndex)
 104 {
 105   // The character's directions buffer.
 106   const CharacterDirection* const modelCharacterDirections = mCharacterDirections.Begin();
 107
 108   // The bidirectional line info.
 109   const BidirectionalLineInfoRun* const bidirectionalLineInfo = mBidirectionalLineInfo.Begin() + mBidirectionalLineIndex;
 110
 111   // Whether the paragraph starts with a right to left character.
 112   const bool isRightToLeftParagraph = bidirectionalLineInfo->direction;
 113
 114   // The total number of characters of the line.
 115   const Length lastCharacterIndex = bidirectionalLineInfo->characterRun.characterIndex + bidirectionalLineInfo->characterRun.numberOfCharacters;
 116
 117   CharacterIndex logicalCursorIndex = 0u;
 118
 119   if(bidirectionalLineInfo->characterRun.characterIndex == visualCursorIndex)
 120   {
 121     if(isRightToLeftParagraph)
 122     {
 123       logicalCursorIndex = lastCharacterIndex;
 124     }
 125     else // else logical position is the first of the line.
 126     {
 127       logicalCursorIndex = bidirectionalLineInfo->characterRun.characterIndex;
 128     }
 129   }
 130   else if(lastCharacterIndex == visualCursorIndex)
 131   {
 132     if(isRightToLeftParagraph)
 133     {
 134       logicalCursorIndex = bidirectionalLineInfo->characterRun.characterIndex;
 135     }
 136     else // else logical position is the number of characters.
 137     {
 138       logicalCursorIndex = lastCharacterIndex;
 139     }
 140   }
 141   else
 142   {
 143     // Get the character indexed by  index - 1 and index
 144     // and calculate the logical position according the directions of
 145     // both characters and the direction of the paragraph.
 146
 147     const CharacterIndex previousVisualCursorIndex  = visualCursorIndex - 1u;
 148     const CharacterIndex previousLogicalCursorIndex = *(bidirectionalLineInfo->visualToLogicalMap + previousVisualCursorIndex - bidirectionalLineInfo->characterRun.characterIndex) + bidirectionalLineInfo->characterRun.characterIndex;
 149     const CharacterIndex currentLogicalCursorIndex  = *(bidirectionalLineInfo->visualToLogicalMap + visualCursorIndex - bidirectionalLineInfo->characterRun.characterIndex) + bidirectionalLineInfo->characterRun.characterIndex;
 150
 151     const CharacterDirection previousCharacterDirection = *(modelCharacterDirections + previousLogicalCursorIndex);
 152     const CharacterDirection currentCharacterDirection  = *(modelCharacterDirections + currentLogicalCursorIndex);
 153
 154     if(previousCharacterDirection == currentCharacterDirection)
 155     {
 156       // Both glyphs have the same direction.
 157       if(previousCharacterDirection)
 158       {
 159         logicalCursorIndex = previousLogicalCursorIndex;
 160       }
 161       else
 162       {
 163         logicalCursorIndex = currentLogicalCursorIndex;
 164       }
 165     }
 166     else
 167     {
 168       if(isRightToLeftParagraph)
 169       {
 170         if(currentCharacterDirection)
 171         {
 172           logicalCursorIndex = currentLogicalCursorIndex + 1u;
 173         }
 174         else
 175         {
 176           logicalCursorIndex = previousLogicalCursorIndex;
 177         }
 178       }
 179       else
 180       {
 181         if(previousCharacterDirection)
 182         {
 183           logicalCursorIndex = currentLogicalCursorIndex;
 184         }
 185         else
 186         {
 187           logicalCursorIndex = previousLogicalCursorIndex + 1u;
 188         }
 189       }
 190     }
 191   }
 192
 193   return logicalCursorIndex;
 194 }
 195
 196 CharacterIndex LogicalModel::GetLogicalCharacterIndex(CharacterIndex visualCharacterIndex)
 197 {
 198   // The bidirectional line info.
 199   const BidirectionalLineInfoRun* const bidirectionalLineInfo = mBidirectionalLineInfo.Begin() + mBidirectionalLineIndex;
 200
 201   return *(bidirectionalLineInfo->visualToLogicalMap + visualCharacterIndex - bidirectionalLineInfo->characterRun.characterIndex) + bidirectionalLineInfo->characterRun.characterIndex;
 202 }
 203
 204 bool LogicalModel::FetchBidirectionalLineInfo(CharacterIndex characterIndex)
 205 {
 206   // The number of bidirectional lines.
 207   const Length numberOfBidirectionalLines = mBidirectionalLineInfo.Count();
 208
 209   if(0u == numberOfBidirectionalLines)
 210   {
 211     // If there is no bidirectional info.
 212     return false;
 213   }
 214
 215   // Find the bidi line where the character is laid-out.
 216
 217   const BidirectionalLineInfoRun* const bidirectionalLineInfoBuffer = mBidirectionalLineInfo.Begin();
 218
 219   // Check first if the character is in the previously fetched line.
 220
 221   BidirectionalLineRunIndex bidiLineIndex                 = 0u;
 222   CharacterIndex            lastCharacterOfRightToLeftRun = 0u;
 223   if(mBidirectionalLineIndex < numberOfBidirectionalLines)
 224   {
 225     const BidirectionalLineInfoRun& bidiLineRun = *(bidirectionalLineInfoBuffer + mBidirectionalLineIndex);
 226
 227     const CharacterIndex lastCharacterOfRunPlusOne = bidiLineRun.characterRun.characterIndex + bidiLineRun.characterRun.numberOfCharacters;
 228     if((bidiLineRun.characterRun.characterIndex <= characterIndex) &&
 229        (characterIndex < lastCharacterOfRunPlusOne))
 230     {
 231       // The character is in the previously fetched bidi line.
 232       return true;
 233     }
 234     else
 235     {
 236       // The character is not in the previously fetched line.
 237       // Set the bidi line index from where to start the fetch.
 238
 239       if(characterIndex < bidiLineRun.characterRun.characterIndex)
 240       {
 241         // Start the fetch from the beginning.
 242         bidiLineIndex = 0u;
 243       }
 244       else
 245       {
 246         // Start the fetch from the next line.
 247         bidiLineIndex                 = mBidirectionalLineIndex + 1u;
 248         lastCharacterOfRightToLeftRun = lastCharacterOfRunPlusOne - 1u;
 249       }
 250     }
 251   }
 252
 253   // The character has not been found in the previously fetched bidi line.
 254   for(Vector<BidirectionalLineInfoRun>::ConstIterator it    = bidirectionalLineInfoBuffer + bidiLineIndex,
 255                                                       endIt = mBidirectionalLineInfo.End();
 256       it != endIt;
 257       ++it, ++bidiLineIndex)
 258   {
 259     const BidirectionalLineInfoRun& bidiLineRun = *it;
 260
 261     if((lastCharacterOfRightToLeftRun < characterIndex) &&
 262        (characterIndex < bidiLineRun.characterRun.characterIndex))
 263     {
 264       // The character is not inside a bidi line.
 265       return false;
 266     }
 267
 268     const CharacterIndex lastCharacterOfRunPlusOne = bidiLineRun.characterRun.characterIndex + bidiLineRun.characterRun.numberOfCharacters;
 269     lastCharacterOfRightToLeftRun                  = lastCharacterOfRunPlusOne - 1u;
 270     if((bidiLineRun.characterRun.characterIndex <= characterIndex) &&
 271        (characterIndex < lastCharacterOfRunPlusOne))
 272     {
 273       // Bidi line found. Fetch the line.
 274       mBidirectionalLineIndex = bidiLineIndex;
 275       return true;
 276     }
 277   }
 278
 279   return false;
 280 }
 281
 282 BidirectionalLineRunIndex LogicalModel::GetBidirectionalLineInfo() const
 283 {
 284   return mBidirectionalLineIndex;
 285 }
 286
 287 void LogicalModel::UpdateTextStyleRuns(CharacterIndex index, int numberOfCharacters)
 288 {
 289   const Length totalNumberOfCharacters = mText.Count();
 290
 291   // Process the color runs.
 292   Vector<ColorRun> removedColorRuns;
 293   UpdateCharacterRuns<ColorRun>(index,
 294                                 numberOfCharacters,
 295                                 totalNumberOfCharacters,
 296                                 mColorRuns,
 297                                 removedColorRuns);
 298
 299   // Process the background color runs.
 300   Vector<ColorRun> removedBackgroundColorRuns;
 301   UpdateCharacterRuns<ColorRun>(index,
 302                                 numberOfCharacters,
 303                                 totalNumberOfCharacters,
 304                                 mBackgroundColorRuns,
 305                                 removedBackgroundColorRuns);
 306
 307   // Process the font description runs.
 308   Vector<FontDescriptionRun> removedFontDescriptionRuns;
 309   UpdateCharacterRuns<FontDescriptionRun>(index,
 310                                           numberOfCharacters,
 311                                           totalNumberOfCharacters,
 312                                           mFontDescriptionRuns,
 313                                           removedFontDescriptionRuns);
 314
 315   // Free memory allocated for the font family name.
 316   FreeFontFamilyNames(removedFontDescriptionRuns);
 317 }
 318
 319 void LogicalModel::RetrieveStyle(CharacterIndex index, InputStyle& style)
 320 {
 321   unsigned int runIndex = 0u;
 322
 323   // Set the text color.
 324   bool                  colorOverriden  = false;
 325   unsigned int          colorIndex      = 0u;
 326   const ColorRun* const colorRunsBuffer = mColorRuns.Begin();
 327   for(Vector<ColorRun>::ConstIterator it    = colorRunsBuffer,
 328                                       endIt = mColorRuns.End();
 329       it != endIt;
 330       ++it, ++runIndex)
 331   {
 332     const ColorRun& colorRun = *it;
 333
 334     if((colorRun.characterRun.characterIndex <= index) &&
 335        (index < colorRun.characterRun.characterIndex + colorRun.characterRun.numberOfCharacters))
 336     {
 337       colorIndex     = runIndex;
 338       colorOverriden = true;
 339     }
 340   }
 341
 342   // Set the text's color if it's overriden.
 343   if(colorOverriden)
 344   {
 345     style.textColor      = (*(colorRunsBuffer + colorIndex)).color;
 346     style.isDefaultColor = false;
 347   }
 348
 349   // Reset the run index.
 350   runIndex = 0u;
 351
 352   // Set the font's parameters.
 353   bool                            nameOverriden             = false;
 354   bool                            weightOverriden           = false;
 355   bool                            widthOverriden            = false;
 356   bool                            slantOverriden            = false;
 357   bool                            sizeOverriden             = false;
 358   unsigned int                    nameIndex                 = 0u;
 359   unsigned int                    weightIndex               = 0u;
 360   unsigned int                    widthIndex                = 0u;
 361   unsigned int                    slantIndex                = 0u;
 362   unsigned int                    sizeIndex                 = 0u;
 363   const FontDescriptionRun* const fontDescriptionRunsBuffer = mFontDescriptionRuns.Begin();
 364   for(Vector<FontDescriptionRun>::ConstIterator it    = fontDescriptionRunsBuffer,
 365                                                 endIt = mFontDescriptionRuns.End();
 366       it != endIt;
 367       ++it, ++runIndex)
 368   {
 369     const FontDescriptionRun& fontDescriptionRun = *it;
 370
 371     if((fontDescriptionRun.characterRun.characterIndex <= index) &&
 372        (index < fontDescriptionRun.characterRun.characterIndex + fontDescriptionRun.characterRun.numberOfCharacters))
 373     {
 374       if(fontDescriptionRun.familyDefined)
 375       {
 376         nameIndex     = runIndex;
 377         nameOverriden = true;
 378       }
 379
 380       if(fontDescriptionRun.weightDefined)
 381       {
 382         weightIndex     = runIndex;
 383         weightOverriden = true;
 384       }
 385
 386       if(fontDescriptionRun.widthDefined)
 387       {
 388         widthIndex     = runIndex;
 389         widthOverriden = true;
 390       }
 391
 392       if(fontDescriptionRun.slantDefined)
 393       {
 394         slantIndex     = runIndex;
 395         slantOverriden = true;
 396       }
 397
 398       if(fontDescriptionRun.sizeDefined)
 399       {
 400         sizeIndex     = runIndex;
 401         sizeOverriden = true;
 402       }
 403     }
 404   }
 405
 406   // Set the font's family name if it's overriden.
 407   if(nameOverriden)
 408   {
 409     const FontDescriptionRun& fontDescriptionRun = *(fontDescriptionRunsBuffer + nameIndex);
 410
 411     style.familyName      = std::string(fontDescriptionRun.familyName, fontDescriptionRun.familyLength);
 412     style.isFamilyDefined = true;
 413   }
 414
 415   // Set the font's weight if it's overriden.
 416   if(weightOverriden)
 417   {
 418     const FontDescriptionRun& fontDescriptionRun = *(fontDescriptionRunsBuffer + weightIndex);
 419
 420     style.weight          = fontDescriptionRun.weight;
 421     style.isWeightDefined = true;
 422   }
 423
 424   // Set the font's width if it's overriden.
 425   if(widthOverriden)
 426   {
 427     const FontDescriptionRun& fontDescriptionRun = *(fontDescriptionRunsBuffer + widthIndex);
 428
 429     style.width          = fontDescriptionRun.width;
 430     style.isWidthDefined = true;
 431   }
 432
 433   // Set the font's slant if it's overriden.
 434   if(slantOverriden)
 435   {
 436     const FontDescriptionRun& fontDescriptionRun = *(fontDescriptionRunsBuffer + slantIndex);
 437
 438     style.slant          = fontDescriptionRun.slant;
 439     style.isSlantDefined = true;
 440   }
 441
 442   // Set the font's size if it's overriden.
 443   if(sizeOverriden)
 444   {
 445     const FontDescriptionRun& fontDescriptionRun = *(fontDescriptionRunsBuffer + sizeIndex);
 446
 447     style.size          = static_cast<float>(fontDescriptionRun.size) / 64.f;
 448     style.isSizeDefined = true;
 449   }
 450 }
 451
 452 void LogicalModel::ClearFontDescriptionRuns()
 453 {
 454   FreeFontFamilyNames(mFontDescriptionRuns);
 455 }
 456
 457 void LogicalModel::CreateParagraphInfo(CharacterIndex startIndex,
 458                                        Length         numberOfCharacters)
 459 {
 460   const Length totalNumberOfCharacters = mLineBreakInfo.Count();
 461
 462   // Count the number of LINE_MUST_BREAK to reserve some space for the vector of paragraph's info.
 463   Vector<CharacterIndex> paragraphs;
 464   paragraphs.Reserve(numberOfCharacters);
 465   const TextAbstraction::LineBreakInfo* lineBreakInfoBuffer       = mLineBreakInfo.Begin();
 466   const CharacterIndex                  lastCharacterIndexPlusOne = startIndex + numberOfCharacters;
 467   for(Length index = startIndex; index < lastCharacterIndexPlusOne; ++index)
 468   {
 469     if(TextAbstraction::LINE_MUST_BREAK == *(lineBreakInfoBuffer + index))
 470     {
 471       paragraphs.PushBack(index);
 472     }
 473   }
 474
 475   // Whether the current paragraphs are updated or set from scratch.
 476   const bool updateCurrentParagraphs = numberOfCharacters < totalNumberOfCharacters;
 477
 478   // Reserve space for current paragraphs plus new ones.
 479   const Length numberOfNewParagraphs   = paragraphs.Count();
 480   const Length totalNumberOfParagraphs = mParagraphInfo.Count() + numberOfNewParagraphs;
 481   mParagraphInfo.Resize(totalNumberOfParagraphs);
 482
 483   ParagraphRun*        paragraphInfoBuffer = NULL;
 484   Vector<ParagraphRun> newParagraphs;
 485
 486   if(updateCurrentParagraphs)
 487   {
 488     newParagraphs.Resize(numberOfNewParagraphs);
 489     paragraphInfoBuffer = newParagraphs.Begin();
 490   }
 491   else
 492   {
 493     paragraphInfoBuffer = mParagraphInfo.Begin();
 494   }
 495
 496   // Find where to insert the new paragraphs.
 497   ParagraphRunIndex paragraphIndex = 0u;
 498   CharacterIndex    firstIndex     = startIndex;
 499
 500   if(updateCurrentParagraphs)
 501   {
 502     for(Vector<ParagraphRun>::ConstIterator it    = mParagraphInfo.Begin(),
 503                                             endIt = mParagraphInfo.Begin() + totalNumberOfParagraphs - numberOfNewParagraphs;
 504         it != endIt;
 505         ++it)
 506     {
 507       const ParagraphRun& paragraph(*it);
 508
 509       if(startIndex < paragraph.characterRun.characterIndex + paragraph.characterRun.numberOfCharacters)
 510       {
 511         firstIndex = paragraph.characterRun.characterIndex;
 512         break;
 513       }
 514
 515       ++paragraphIndex;
 516     }
 517   }
 518
 519   // Create the paragraph info.
 520   ParagraphRunIndex newParagraphIndex = 0u;
 521   for(Vector<CharacterIndex>::ConstIterator it    = paragraphs.Begin(),
 522                                             endIt = paragraphs.End();
 523       it != endIt;
 524       ++it, ++newParagraphIndex)
 525   {
 526     const CharacterIndex index = *it;
 527
 528     ParagraphRun& paragraph                   = *(paragraphInfoBuffer + newParagraphIndex);
 529     paragraph.characterRun.characterIndex     = firstIndex;
 530     paragraph.characterRun.numberOfCharacters = 1u + index - firstIndex;
 531
 532     firstIndex += paragraph.characterRun.numberOfCharacters;
 533   }
 534
 535   // Insert the new paragraphs.
 536   if(updateCurrentParagraphs)
 537   {
 538     mParagraphInfo.Insert(mParagraphInfo.Begin() + paragraphIndex,
 539                           newParagraphs.Begin(),
 540                           newParagraphs.End());
 541
 542     mParagraphInfo.Resize(totalNumberOfParagraphs);
 543
 544     // Update the next paragraph indices.
 545     for(Vector<ParagraphRun>::Iterator it    = mParagraphInfo.Begin() + paragraphIndex + newParagraphs.Count(),
 546                                        endIt = mParagraphInfo.End();
 547         it != endIt;
 548         ++it)
 549     {
 550       ParagraphRun& paragraph(*it);
 551
 552       paragraph.characterRun.characterIndex += numberOfCharacters;
 553     }
 554   }
 555 }
 556
 557 void LogicalModel::FindParagraphs(CharacterIndex             index,
 558                                   Length                     numberOfCharacters,
 559                                   Vector<ParagraphRunIndex>& paragraphs)
 560 {
 561   // Reserve som space for the paragraph indices.
 562   paragraphs.Reserve(mParagraphInfo.Count());
 563
 564   // Traverse the paragraphs to find which ones contain the given characters.
 565   ParagraphRunIndex paragraphIndex = 0u;
 566   for(Vector<ParagraphRun>::ConstIterator it    = mParagraphInfo.Begin(),
 567                                           endIt = mParagraphInfo.End();
 568       it != endIt;
 569       ++it, ++paragraphIndex)
 570   {
 571     const ParagraphRun& paragraph(*it);
 572
 573     if((paragraph.characterRun.characterIndex + paragraph.characterRun.numberOfCharacters > index) &&
 574        (paragraph.characterRun.characterIndex < index + numberOfCharacters))
 575     {
 576       paragraphs.PushBack(paragraphIndex);
 577     }
 578   }
 579 }
 580
 581 void LogicalModel::ClearEmbeddedImages()
 582 {
 583   FreeEmbeddedItems(mEmbeddedItems);
 584 }
 585
 586 void LogicalModel::ClearAnchors()
 587 {
 588   FreeAnchors(mAnchors);
 589 }
 590
 591 LogicalModel::~LogicalModel()
 592 {
 593   ClearFontDescriptionRuns();
 594   ClearEmbeddedImages();
 595 }
 596
 597 LogicalModel::LogicalModel()
 598 : mBidirectionalLineIndex(0u)
 599 {
 600 }
 601
 602 } // namespace Text
 603
 604 } // namespace Toolkit
 605
 606 } // namespace Dali