dali-toolkit/internal/text/logical-model-impl.cpp

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