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   // This is needed until now for underline tag in mark-up processor
 300   // Process the underlined runs.
 301   Vector<UnderlinedCharacterRun> removedUnderlinedCharacterRuns;
 302   UpdateCharacterRuns<UnderlinedCharacterRun>(index,
 303                                 numberOfCharacters,
 304                                 totalNumberOfCharacters,
 305                                 mUnderlinedCharacterRuns,
 306                                 removedUnderlinedCharacterRuns);
 307
 308   // Process the background color runs.
 309   Vector<ColorRun> removedBackgroundColorRuns;
 310   UpdateCharacterRuns<ColorRun>(index,
 311                                 numberOfCharacters,
 312                                 totalNumberOfCharacters,
 313                                 mBackgroundColorRuns,
 314                                 removedBackgroundColorRuns);
 315
 316   // Process the font description runs.
 317   Vector<FontDescriptionRun> removedFontDescriptionRuns;
 318   UpdateCharacterRuns<FontDescriptionRun>(index,
 319                                           numberOfCharacters,
 320                                           totalNumberOfCharacters,
 321                                           mFontDescriptionRuns,
 322                                           removedFontDescriptionRuns);
 323
 324   // Free memory allocated for the font family name.
 325   FreeFontFamilyNames(removedFontDescriptionRuns);
 326 }
 327
 328 void LogicalModel::RetrieveStyle(CharacterIndex index, InputStyle& style)
 329 {
 330   unsigned int runIndex = 0u;
 331
 332   // Set the text color.
 333   bool                  colorOverriden  = false;
 334   unsigned int          colorIndex      = 0u;
 335   const ColorRun* const colorRunsBuffer = mColorRuns.Begin();
 336   for(Vector<ColorRun>::ConstIterator it    = colorRunsBuffer,
 337                                       endIt = mColorRuns.End();
 338       it != endIt;
 339       ++it, ++runIndex)
 340   {
 341     const ColorRun& colorRun = *it;
 342
 343     if((colorRun.characterRun.characterIndex <= index) &&
 344        (index < colorRun.characterRun.characterIndex + colorRun.characterRun.numberOfCharacters))
 345     {
 346       colorIndex     = runIndex;
 347       colorOverriden = true;
 348     }
 349   }
 350
 351   // Set the text's color if it's overriden.
 352   if(colorOverriden)
 353   {
 354     style.textColor      = (*(colorRunsBuffer + colorIndex)).color;
 355     style.isDefaultColor = false;
 356   }
 357
 358   // Reset the run index.
 359   runIndex = 0u;
 360
 361   // Set the font's parameters.
 362   bool                            nameOverriden             = false;
 363   bool                            weightOverriden           = false;
 364   bool                            widthOverriden            = false;
 365   bool                            slantOverriden            = false;
 366   bool                            sizeOverriden             = false;
 367   unsigned int                    nameIndex                 = 0u;
 368   unsigned int                    weightIndex               = 0u;
 369   unsigned int                    widthIndex                = 0u;
 370   unsigned int                    slantIndex                = 0u;
 371   unsigned int                    sizeIndex                 = 0u;
 372   const FontDescriptionRun* const fontDescriptionRunsBuffer = mFontDescriptionRuns.Begin();
 373   for(Vector<FontDescriptionRun>::ConstIterator it    = fontDescriptionRunsBuffer,
 374                                                 endIt = mFontDescriptionRuns.End();
 375       it != endIt;
 376       ++it, ++runIndex)
 377   {
 378     const FontDescriptionRun& fontDescriptionRun = *it;
 379
 380     if((fontDescriptionRun.characterRun.characterIndex <= index) &&
 381        (index < fontDescriptionRun.characterRun.characterIndex + fontDescriptionRun.characterRun.numberOfCharacters))
 382     {
 383       if(fontDescriptionRun.familyDefined)
 384       {
 385         nameIndex     = runIndex;
 386         nameOverriden = true;
 387       }
 388
 389       if(fontDescriptionRun.weightDefined)
 390       {
 391         weightIndex     = runIndex;
 392         weightOverriden = true;
 393       }
 394
 395       if(fontDescriptionRun.widthDefined)
 396       {
 397         widthIndex     = runIndex;
 398         widthOverriden = true;
 399       }
 400
 401       if(fontDescriptionRun.slantDefined)
 402       {
 403         slantIndex     = runIndex;
 404         slantOverriden = true;
 405       }
 406
 407       if(fontDescriptionRun.sizeDefined)
 408       {
 409         sizeIndex     = runIndex;
 410         sizeOverriden = true;
 411       }
 412     }
 413   }
 414
 415   // Set the font's family name if it's overriden.
 416   if(nameOverriden)
 417   {
 418     const FontDescriptionRun& fontDescriptionRun = *(fontDescriptionRunsBuffer + nameIndex);
 419
 420     style.familyName      = std::string(fontDescriptionRun.familyName, fontDescriptionRun.familyLength);
 421     style.isFamilyDefined = true;
 422   }
 423
 424   // Set the font's weight if it's overriden.
 425   if(weightOverriden)
 426   {
 427     const FontDescriptionRun& fontDescriptionRun = *(fontDescriptionRunsBuffer + weightIndex);
 428
 429     style.weight          = fontDescriptionRun.weight;
 430     style.isWeightDefined = true;
 431   }
 432
 433   // Set the font's width if it's overriden.
 434   if(widthOverriden)
 435   {
 436     const FontDescriptionRun& fontDescriptionRun = *(fontDescriptionRunsBuffer + widthIndex);
 437
 438     style.width          = fontDescriptionRun.width;
 439     style.isWidthDefined = true;
 440   }
 441
 442   // Set the font's slant if it's overriden.
 443   if(slantOverriden)
 444   {
 445     const FontDescriptionRun& fontDescriptionRun = *(fontDescriptionRunsBuffer + slantIndex);
 446
 447     style.slant          = fontDescriptionRun.slant;
 448     style.isSlantDefined = true;
 449   }
 450
 451   // Set the font's size if it's overriden.
 452   if(sizeOverriden)
 453   {
 454     const FontDescriptionRun& fontDescriptionRun = *(fontDescriptionRunsBuffer + sizeIndex);
 455
 456     style.size          = static_cast<float>(fontDescriptionRun.size) / 64.f;
 457     style.isSizeDefined = true;
 458   }
 459 }
 460
 461 void LogicalModel::ClearFontDescriptionRuns()
 462 {
 463   FreeFontFamilyNames(mFontDescriptionRuns);
 464 }
 465
 466 void LogicalModel::CreateParagraphInfo(CharacterIndex startIndex,
 467                                        Length         numberOfCharacters)
 468 {
 469   const Length totalNumberOfCharacters = mLineBreakInfo.Count();
 470
 471   // Count the number of LINE_MUST_BREAK to reserve some space for the vector of paragraph's info.
 472   Vector<CharacterIndex> paragraphs;
 473   paragraphs.Reserve(numberOfCharacters);
 474   const TextAbstraction::LineBreakInfo* lineBreakInfoBuffer       = mLineBreakInfo.Begin();
 475   const CharacterIndex                  lastCharacterIndexPlusOne = startIndex + numberOfCharacters;
 476   for(Length index = startIndex; index < lastCharacterIndexPlusOne; ++index)
 477   {
 478     if(TextAbstraction::LINE_MUST_BREAK == *(lineBreakInfoBuffer + index))
 479     {
 480       paragraphs.PushBack(index);
 481     }
 482   }
 483
 484   // Whether the current paragraphs are updated or set from scratch.
 485   const bool updateCurrentParagraphs = numberOfCharacters < totalNumberOfCharacters;
 486
 487   // Reserve space for current paragraphs plus new ones.
 488   const Length numberOfNewParagraphs   = paragraphs.Count();
 489   const Length totalNumberOfParagraphs = mParagraphInfo.Count() + numberOfNewParagraphs;
 490   mParagraphInfo.Resize(totalNumberOfParagraphs);
 491
 492   ParagraphRun*        paragraphInfoBuffer = NULL;
 493   Vector<ParagraphRun> newParagraphs;
 494
 495   if(updateCurrentParagraphs)
 496   {
 497     newParagraphs.Resize(numberOfNewParagraphs);
 498     paragraphInfoBuffer = newParagraphs.Begin();
 499   }
 500   else
 501   {
 502     paragraphInfoBuffer = mParagraphInfo.Begin();
 503   }
 504
 505   // Find where to insert the new paragraphs.
 506   ParagraphRunIndex paragraphIndex = 0u;
 507   CharacterIndex    firstIndex     = startIndex;
 508
 509   if(updateCurrentParagraphs)
 510   {
 511     for(Vector<ParagraphRun>::ConstIterator it    = mParagraphInfo.Begin(),
 512                                             endIt = mParagraphInfo.Begin() + totalNumberOfParagraphs - numberOfNewParagraphs;
 513         it != endIt;
 514         ++it)
 515     {
 516       const ParagraphRun& paragraph(*it);
 517
 518       if(startIndex < paragraph.characterRun.characterIndex + paragraph.characterRun.numberOfCharacters)
 519       {
 520         firstIndex = paragraph.characterRun.characterIndex;
 521         break;
 522       }
 523
 524       ++paragraphIndex;
 525     }
 526   }
 527
 528   // Create the paragraph info.
 529   ParagraphRunIndex newParagraphIndex = 0u;
 530   for(Vector<CharacterIndex>::ConstIterator it    = paragraphs.Begin(),
 531                                             endIt = paragraphs.End();
 532       it != endIt;
 533       ++it, ++newParagraphIndex)
 534   {
 535     const CharacterIndex index = *it;
 536
 537     ParagraphRun& paragraph                   = *(paragraphInfoBuffer + newParagraphIndex);
 538     paragraph.characterRun.characterIndex     = firstIndex;
 539     paragraph.characterRun.numberOfCharacters = 1u + index - firstIndex;
 540
 541     firstIndex += paragraph.characterRun.numberOfCharacters;
 542   }
 543
 544   // Insert the new paragraphs.
 545   if(updateCurrentParagraphs)
 546   {
 547     mParagraphInfo.Insert(mParagraphInfo.Begin() + paragraphIndex,
 548                           newParagraphs.Begin(),
 549                           newParagraphs.End());
 550
 551     mParagraphInfo.Resize(totalNumberOfParagraphs);
 552
 553     // Update the next paragraph indices.
 554     for(Vector<ParagraphRun>::Iterator it    = mParagraphInfo.Begin() + paragraphIndex + newParagraphs.Count(),
 555                                        endIt = mParagraphInfo.End();
 556         it != endIt;
 557         ++it)
 558     {
 559       ParagraphRun& paragraph(*it);
 560
 561       paragraph.characterRun.characterIndex += numberOfCharacters;
 562     }
 563   }
 564 }
 565
 566 void LogicalModel::FindParagraphs(CharacterIndex             index,
 567                                   Length                     numberOfCharacters,
 568                                   Vector<ParagraphRunIndex>& paragraphs)
 569 {
 570   // Reserve som space for the paragraph indices.
 571   paragraphs.Reserve(mParagraphInfo.Count());
 572
 573   // Traverse the paragraphs to find which ones contain the given characters.
 574   ParagraphRunIndex paragraphIndex = 0u;
 575   for(Vector<ParagraphRun>::ConstIterator it    = mParagraphInfo.Begin(),
 576                                           endIt = mParagraphInfo.End();
 577       it != endIt;
 578       ++it, ++paragraphIndex)
 579   {
 580     const ParagraphRun& paragraph(*it);
 581
 582     if((paragraph.characterRun.characterIndex + paragraph.characterRun.numberOfCharacters > index) &&
 583        (paragraph.characterRun.characterIndex < index + numberOfCharacters))
 584     {
 585       paragraphs.PushBack(paragraphIndex);
 586     }
 587   }
 588 }
 589
 590 void LogicalModel::ClearEmbeddedImages()
 591 {
 592   FreeEmbeddedItems(mEmbeddedItems);
 593 }
 594
 595 void LogicalModel::ClearAnchors()
 596 {
 597   FreeAnchors(mAnchors);
 598 }
 599
 600 LogicalModel::~LogicalModel()
 601 {
 602   ClearFontDescriptionRuns();
 603   ClearEmbeddedImages();
 604 }
 605
 606 LogicalModel::LogicalModel()
 607 : mBidirectionalLineIndex(0u)
 608 {
 609 }
 610
 611 } // namespace Text
 612
 613 } // namespace Toolkit
 614
 615 } // namespace Dali