dali-toolkit/internal/text/text-geometry.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-toolkit/internal/text/text-geometry.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali-toolkit/internal/text/cursor-helper-functions.h>
  26 #include <dali-toolkit/internal/text/line-run.h>
  27 #include <dali-toolkit/internal/text/visual-model-impl.h>
  28 #include <algorithm>
  29
  30 using namespace Dali;
  31
  32 namespace Dali
  33 {
  34 namespace Toolkit
  35 {
  36 namespace Text
  37 {
  38 bool GetNextLine(GlyphIndex index, LineIndex& lineIndex, LineRun*& lineRun, GlyphIndex& lastGlyphOfLine, Length numberOfLines, bool& isLastLine)
  39 {
  40   if(index == lastGlyphOfLine)
  41   {
  42     ++lineIndex;
  43     if(lineIndex < numberOfLines)
  44     {
  45       isLastLine = (lineIndex + 1 == numberOfLines);
  46       ++lineRun;
  47       return true;
  48     }
  49   }
  50
  51   return false;
  52 }
  53
  54 void UpdateLineInfo(const LineRun* lineRun, float& currentLineOffset, float& currentLineHeight, GlyphIndex& lastGlyphOfLine, bool isLastLine)
  55 {
  56   lastGlyphOfLine   = lineRun->glyphRun.glyphIndex + lineRun->glyphRun.numberOfGlyphs - 1u;
  57   currentLineOffset = currentLineOffset + currentLineHeight;
  58   currentLineHeight = GetLineHeight(*lineRun, isLastLine);
  59 }
  60
  61 void GetTextGeometry(ModelPtr textModel, CharacterIndex startIndex, CharacterIndex endIndex, Vector<Vector2>& sizesList, Vector<Vector2>& positionsList)
  62 {
  63   VisualModelPtr&  visualModel  = textModel->mVisualModel;
  64   LogicalModelPtr& logicalModel = textModel->mLogicalModel;
  65
  66   const GlyphIndex* const         charactersToGlyphBuffer        = visualModel->mCharactersToGlyph.Begin();
  67   const Length* const             glyphsPerCharacterBuffer       = visualModel->mGlyphsPerCharacter.Begin();
  68   const GlyphInfo* const          glyphsBuffer                   = visualModel->mGlyphs.Begin();
  69   const Vector2* const            positionsBuffer                = visualModel->mGlyphPositions.Begin();
  70   const Length* const             charactersPerGlyphBuffer       = visualModel->mCharactersPerGlyph.Begin();
  71   const CharacterIndex* const     glyphToCharacterBuffer         = visualModel->mGlyphsToCharacters.Begin();
  72   const CharacterDirection* const modelCharacterDirectionsBuffer = (0u != logicalModel->mCharacterDirections.Count()) ? logicalModel->mCharacterDirections.Begin() : NULL;
  73
  74   //Clear the lists
  75   sizesList.Clear();
  76   positionsList.Clear();
  77
  78   if(charactersToGlyphBuffer == nullptr || glyphsPerCharacterBuffer  == nullptr || charactersPerGlyphBuffer  == nullptr || glyphToCharacterBuffer == nullptr )
  79   {
  80     return;
  81   }
  82
  83   if(startIndex >= logicalModel->mText.Count() && endIndex >= logicalModel->mText.Count())
  84   {
  85     return;
  86   }
  87
  88   if(startIndex >= logicalModel->mText.Count())
  89   {
  90     startIndex = static_cast<CharacterIndex>(logicalModel->mText.Count() - 1u);
  91   }
  92
  93   if(endIndex >= logicalModel->mText.Count())
  94   {
  95     endIndex = static_cast<CharacterIndex>(logicalModel->mText.Count() - 1u);
  96   }
  97
  98   if(startIndex > endIndex)
  99   {
 100     std::swap(startIndex, endIndex);
 101   }
 102
 103   LineRun*   lineRun    = visualModel->mLines.Begin();
 104   GlyphIndex glyphStart = *(charactersToGlyphBuffer + startIndex);
 105
 106   //if glyph not in the first line (in some ellipsis cases)
 107   if(glyphStart < lineRun->glyphRun.glyphIndex)
 108   {
 109     glyphStart = lineRun->glyphRun.glyphIndex;
 110     startIndex = *(glyphToCharacterBuffer + glyphStart);
 111
 112     if(startIndex > endIndex)
 113     {
 114       std::swap(startIndex, endIndex);
 115     }
 116   }
 117
 118   const Length numberOfGlyphs = *(glyphsPerCharacterBuffer + endIndex);
 119   GlyphIndex   glyphEnd       = *(charactersToGlyphBuffer + endIndex) + ((numberOfGlyphs > 0) ? numberOfGlyphs - 1u : 0u);
 120   LineIndex    lineIndex      = visualModel->GetLineOfCharacter(startIndex);
 121   Length       numberOfLines  = visualModel->GetTotalNumberOfLines();
 122   bool         isLastLine     = lineIndex + 1 == numberOfLines;
 123
 124   LineIndex firstLineIndex = lineIndex;
 125   Size      textInLineSize;
 126   Vector2   textInLinePosition;
 127
 128   lineRun += firstLineIndex;
 129
 130   //get the first line and its vertical offset
 131   float      currentLineOffset = CalculateLineOffset(visualModel->mLines, firstLineIndex);
 132   float      currentLineHeight = GetLineHeight(*lineRun, isLastLine);
 133   GlyphIndex lastGlyphOfLine   = lineRun->glyphRun.glyphIndex + lineRun->glyphRun.numberOfGlyphs - 1;
 134
 135   // Check if the first/last glyph is a ligature that needs be splitted like English fi or Arabic ﻻ.
 136   const Length numberOfCharactersStart = *(charactersPerGlyphBuffer + glyphStart);
 137   const Length numberOfCharactersEnd   = *(charactersPerGlyphBuffer + glyphEnd);
 138
 139   bool splitStartGlyph = (numberOfCharactersStart > 1u) && HasLigatureMustBreak(logicalModel->GetScript(startIndex));
 140   bool splitEndGlyph   = (glyphStart != glyphEnd) && (numberOfCharactersEnd > 1u) && HasLigatureMustBreak(logicalModel->GetScript(endIndex));
 141
 142   Vector2            currentSize;
 143   Vector2            currentPosition;
 144   Vector2            blockSize;
 145   Vector2            blockPos;
 146   CharacterDirection isCurrentRightToLeft;
 147
 148   CharacterDirection                      isPrevoiusRightToLeft           = (nullptr != modelCharacterDirectionsBuffer ? *(modelCharacterDirectionsBuffer + startIndex) : false);
 149   const bool                              isEllipsisEnabled               = textModel->mElideEnabled;
 150   const GlyphIndex                        startIndexOfGlyphs              = textModel->GetStartIndexOfElidedGlyphs();
 151   const GlyphIndex                        endIndexOfGlyphs                = textModel->GetEndIndexOfElidedGlyphs();
 152   const GlyphIndex                        firstMiddleIndexOfElidedGlyphs  = textModel->GetFirstMiddleIndexOfElidedGlyphs();
 153   const GlyphIndex                        secondMiddleIndexOfElidedGlyphs = textModel->GetSecondMiddleIndexOfElidedGlyphs();
 154   const DevelText::EllipsisPosition::Type ellipsisPosition                = textModel->GetEllipsisPosition();
 155
 156   for(GlyphIndex index = glyphStart; index <= glyphEnd; ++index)
 157   {
 158     if(isEllipsisEnabled)
 159     {
 160       if(ellipsisPosition == DevelText::EllipsisPosition::MIDDLE)
 161       {
 162         if(index >= firstMiddleIndexOfElidedGlyphs &&
 163            index < secondMiddleIndexOfElidedGlyphs)
 164         {
 165           if((index - 1 == firstMiddleIndexOfElidedGlyphs) && (firstMiddleIndexOfElidedGlyphs != 0))
 166           {
 167             sizesList.PushBack(blockSize);
 168             positionsList.PushBack(blockPos);
 169           }
 170
 171           if(GetNextLine(index, lineIndex, lineRun, lastGlyphOfLine, numberOfLines, isLastLine))
 172           {
 173             UpdateLineInfo(lineRun, currentLineOffset, currentLineHeight, lastGlyphOfLine, isLastLine);
 174           }
 175           // Ignore any glyph that was removed
 176           continue;
 177         }
 178       }
 179       else
 180       {
 181         if((ellipsisPosition == DevelText::EllipsisPosition::END) && (index > endIndexOfGlyphs))
 182         {
 183           //skip remaining elided glyphs
 184           break;
 185         }
 186         else if((ellipsisPosition == DevelText::EllipsisPosition::START) && (index <= startIndexOfGlyphs))
 187         {
 188           if(GetNextLine(index, lineIndex, lineRun, lastGlyphOfLine, numberOfLines, isLastLine))
 189           {
 190             UpdateLineInfo(lineRun, currentLineOffset, currentLineHeight, lastGlyphOfLine, isLastLine);
 191           }
 192
 193           continue;
 194         }
 195       }
 196     }
 197
 198     const GlyphInfo& glyph    = *(glyphsBuffer + index);
 199     const Vector2&   position = *(positionsBuffer + index);
 200
 201     // If NULL, means all of the characters is left to right.
 202     isCurrentRightToLeft = (nullptr != modelCharacterDirectionsBuffer ? *(modelCharacterDirectionsBuffer + *(glyphToCharacterBuffer + index)) : false);
 203
 204     if(splitStartGlyph && (index == glyphStart))
 205     {
 206       // If the first glyph is a ligature that needs to be splitted, we may need only to add part of the glyph.
 207       const float          glyphAdvance       = glyph.advance / static_cast<float>(numberOfCharactersStart);
 208       const CharacterIndex interGlyphIndex    = startIndex - *(glyphToCharacterBuffer + glyphStart);
 209       const Length         numberOfCharacters = (glyphStart == glyphEnd) ? (endIndex - startIndex) + 1 : (numberOfCharactersStart - interGlyphIndex);
 210
 211       currentPosition.x = lineRun->alignmentOffset + position.x - glyph.xBearing + textModel->mScrollPosition.x + glyphAdvance * static_cast<float>(isCurrentRightToLeft ? (numberOfCharactersStart - interGlyphIndex - numberOfCharacters) : interGlyphIndex);
 212       currentPosition.y = currentLineOffset + textModel->mScrollPosition.y;
 213       currentSize.x     = static_cast<float>(numberOfCharacters) * glyphAdvance;
 214       currentSize.y     = currentLineHeight;
 215       splitStartGlyph   = false;
 216     }
 217     else if(splitEndGlyph && (index == glyphEnd))
 218     {
 219       const float          glyphAdvance       = glyph.advance / static_cast<float>(numberOfCharactersEnd);
 220       const CharacterIndex interGlyphIndex    = endIndex - *(glyphToCharacterBuffer + glyphEnd);
 221       const Length         numberOfCharacters = numberOfCharactersEnd - interGlyphIndex - 1;
 222
 223       currentPosition.x = lineRun->alignmentOffset + position.x - glyph.xBearing + textModel->mScrollPosition.x + (isCurrentRightToLeft ? (glyphAdvance * static_cast<float>(numberOfCharacters)) : 0.f);
 224       currentPosition.y = currentLineOffset + textModel->mScrollPosition.y;
 225       currentSize.x     = static_cast<float>(interGlyphIndex + 1) * glyphAdvance;
 226       currentSize.y     = currentLineHeight;
 227       splitEndGlyph     = false;
 228     }
 229     else
 230     {
 231       currentPosition.x = lineRun->alignmentOffset + position.x - glyph.xBearing + textModel->mScrollPosition.x;
 232       currentPosition.y = currentLineOffset + textModel->mScrollPosition.y;
 233       currentSize.x     = glyph.advance;
 234       currentSize.y     = currentLineHeight;
 235
 236       // if there is next line to retrieve.
 237       if(GetNextLine(index, lineIndex, lineRun, lastGlyphOfLine, numberOfLines, isLastLine))
 238       {
 239         UpdateLineInfo(lineRun, currentLineOffset, currentLineHeight, lastGlyphOfLine, isLastLine);
 240       }
 241     }
 242
 243     if((index == glyphStart) || (isEllipsisEnabled && (((ellipsisPosition == DevelText::EllipsisPosition::MIDDLE) && (index == secondMiddleIndexOfElidedGlyphs)) || ((ellipsisPosition == DevelText::EllipsisPosition::START) && (index - 1 == startIndexOfGlyphs)))))
 244     {
 245       blockPos  = currentPosition;
 246       blockSize = currentSize;
 247     }
 248     else if((isPrevoiusRightToLeft != isCurrentRightToLeft) || (blockPos.y != currentPosition.y)) //new direction or new line
 249     {
 250       sizesList.PushBack(blockSize);
 251       positionsList.PushBack(blockPos);
 252
 253       blockPos  = currentPosition;
 254       blockSize = currentSize;
 255     }
 256     else
 257     {
 258       if(isCurrentRightToLeft)
 259       {
 260         blockPos.x -= currentSize.x;
 261       }
 262
 263       blockSize.x += currentSize.x;
 264     }
 265
 266     isPrevoiusRightToLeft = isCurrentRightToLeft;
 267   }
 268
 269   //add last block
 270   sizesList.PushBack(blockSize);
 271   positionsList.PushBack(blockPos);
 272 }
 273
 274 float GetLineLeft(const LineRun& lineRun)
 275 {
 276   return lineRun.alignmentOffset;
 277 }
 278
 279 float GetLineTop(const Vector<LineRun>& lines, const LineRun& lineRun)
 280 {
 281   float lineTop = 0;
 282   const int numberOfLines = (int)lines.Count();
 283
 284   int currentLineIndex = 0;
 285   Vector<LineRun>::ConstIterator endIt = (&lineRun);
 286   for(Vector<LineRun>::Iterator it = lines.Begin();
 287       it != endIt;
 288       ++it, ++currentLineIndex)
 289     {
 290       LineRun& line = *it;
 291       bool isLastLine  = (currentLineIndex + 1) == numberOfLines;
 292       lineTop         += GetLineHeight(line, isLastLine);
 293     }
 294
 295   return lineTop;
 296 }
 297
 298 float GetLineWidth(const LineRun& lineRun)
 299 {
 300   return lineRun.width;
 301 }
 302
 303 Rect<float> GetLineBoundingRect(ModelPtr textModel, const uint32_t lineIndex)
 304 {
 305
 306   if(textModel->mVisualModel == nullptr)
 307   {
 308     return {0, 0, 0, 0};
 309   }
 310
 311   Length numberOfLines = textModel->mVisualModel->GetTotalNumberOfLines();
 312
 313   if(lineIndex >= numberOfLines)
 314   {
 315     return {0, 0, 0, 0};
 316   }
 317
 318   const Vector<LineRun>& lines   = textModel->mVisualModel->mLines;
 319   const LineRun&         lineRun = lines[lineIndex];
 320   bool  isFirstLine = lineIndex == 0;
 321   bool  isLastLine  = (lineIndex + 1) == numberOfLines;
 322
 323   // Calculate the Left(lineX) = X position.
 324   float lineX = GetLineLeft(lineRun) + textModel->mScrollPosition.x;
 325
 326   // Calculate the Top(lineY) = PreviousHeights.
 327   // If the line is the first line of the text; its top = 0.
 328   float lineY = (isFirstLine ? 0 : GetLineTop(lines, lineRun)) + textModel->mScrollPosition.y;
 329
 330   // The rectangle contains the width and height:
 331   float lineWidth  = GetLineWidth(lineRun);
 332   float lineHeight = GetLineHeight(lineRun, isLastLine);
 333
 334   return {lineX, lineY, lineWidth, lineHeight};
 335 }
 336
 337 float GetCharacterLeft(const GlyphInfo& glyph, const Vector2& characterPosition)
 338 {
 339   return characterPosition.x - glyph.xBearing;
 340 }
 341
 342 float GetCharacterTop(const float& yPosition)
 343 {
 344   return (-1 * yPosition);
 345 }
 346
 347 float GetCharacterHeight(const GlyphInfo& glyph)
 348 {
 349   return glyph.height;
 350 }
 351
 352 float GetCharacterWidth(const GlyphInfo& glyph)
 353 {
 354   return glyph.advance;
 355 }
 356
 357 Rect<> GetCharacterBoundingRect(ModelPtr textModel, const uint32_t charIndex)
 358 {
 359   if(textModel->mVisualModel == nullptr)
 360   {
 361     return {0, 0, 0, 0};
 362   }
 363
 364   VisualModelPtr&  visualModel  = textModel->mVisualModel;
 365   LogicalModelPtr& logicalModel = textModel->mLogicalModel;
 366
 367   if(charIndex >= logicalModel->mText.Count() || visualModel->mLines.Empty())
 368   {
 369     return {0, 0, 0, 0};
 370   }
 371
 372   const Vector<Vector2>&   glyphPositions = visualModel->mGlyphPositions;
 373   const Vector<GlyphInfo>& glyphs         = visualModel->mGlyphs;
 374   const Vector<LineRun>&   lines          = visualModel->mLines;
 375
 376   //For each character, the index of the first glyph.
 377   const GlyphIndex glyphIndex = visualModel->mCharactersToGlyph[charIndex]; //took its glyphs
 378
 379   const Vector2&   characterPosition = glyphPositions[glyphIndex];
 380   const GlyphInfo& glyphInfo    = glyphs[glyphIndex];
 381
 382   // GetLineOfCharacter function returns 0 if the lines are empty
 383   const int      lineIndex = visualModel->GetLineOfCharacter(charIndex);
 384   const LineRun& lineRun   = lines[lineIndex];
 385
 386   //Calculate the left: x position of the glyph + alignmentOffset of the line +  mScrollPosition.x.
 387   float characterX = lineRun.alignmentOffset + GetCharacterLeft(glyphInfo, characterPosition) + textModel->mScrollPosition.x;
 388
 389   //Calculate the Top(characterY): position.Y + previouse lines height + mScrollPosition.y.
 390   bool isFirstLine = lineIndex == 0;
 391
 392   //If the line is the first line of the text; its top = 0.
 393   float lineY = (isFirstLine ? 0 : GetLineTop(lines, lineRun));
 394
 395   float characterY = lineY + GetCharacterTop(characterPosition.y) + textModel->mScrollPosition.y;
 396
 397   //The rectangle contains the width and height:
 398   float characterWidth  = GetCharacterWidth(glyphInfo);
 399   float characterHeight = GetCharacterHeight(glyphInfo);
 400
 401   return {characterX, characterY, characterWidth, characterHeight};
 402 }
 403
 404 int GetCharIndexAtPosition(ModelPtr textModel, float visualX, float visualY)
 405 {
 406   if(textModel == nullptr)
 407   {
 408     return -1;
 409   }
 410
 411   VisualModelPtr& visualModel = textModel->mVisualModel;
 412
 413   const int totalNumberOfGlyphs = visualModel->mGlyphs.Count();
 414   const int totalNumberOfLines  = visualModel->mLines.Count();
 415
 416   if((0 == totalNumberOfGlyphs) ||
 417      (0 == totalNumberOfLines))
 418   {
 419     return -1;
 420   }
 421
 422   //The top point of the view = 0.
 423   if(visualY < 0)
 424   {
 425     return -1;
 426   }
 427
 428   const Vector<LineRun>& lines = visualModel->mLines;
 429
 430   float lineTop   = 0.f;
 431   int   lineIndex = -1;
 432   int   high      = totalNumberOfLines;
 433   int   low       = -1;
 434   int   guess;
 435
 436   // Searching for the correct line.
 437   while(high - low > 1)
 438   {
 439     guess = (high + low) / 2;
 440     Vector<LineRun>::ConstIterator it = lines.Begin() + guess;
 441
 442     lineTop = GetLineTop(lines, *it);
 443
 444     if(lineTop > visualY)
 445     {
 446       high = guess;
 447     }
 448     else
 449     {
 450       low = guess;
 451     }
 452   }
 453
 454   if(low < 0)
 455   {
 456     lineIndex = 0;
 457   }
 458   else
 459   {
 460     lineIndex = low;
 461   }
 462
 463   bool isLastLine = lineIndex + 1 == totalNumberOfLines;
 464
 465   if(isLastLine)
 466   {
 467     const LineRun& line = *(visualModel->mLines.Begin() + lineIndex);
 468     float lineHeight = GetLineHeight(line, isLastLine);
 469
 470     // If the visualY is placed after the last line.
 471     if(visualY > lineTop + lineHeight)
 472     {
 473       return -1;
 474     }
 475   }
 476
 477   // Check if a line is not found; return -1.
 478   if(lineIndex == -1)
 479   {
 480     return -1;
 481   }
 482
 483  // Start searching for the visualX
 484   const LineRun& line = *(visualModel->mLines.Begin() + lineIndex);
 485
 486   visualX -= line.alignmentOffset;
 487
 488   // Positions of the glyphs
 489   const Vector2* const positionsBuffer = visualModel->mGlyphPositions.Begin();
 490
 491   const CharacterIndex startCharacter = line.characterRun.characterIndex;
 492   const CharacterIndex endCharacter   = line.characterRun.characterIndex + line.characterRun.numberOfCharacters - 1;
 493
 494   CharacterIndex characterIndexAtPosition = -1;
 495   CharacterIndex characterIndex           = startCharacter;
 496   float characterPosition;
 497   float rightMostCharacterPosition;
 498
 499   for(; characterIndex != endCharacter; characterIndex++)
 500   {
 501     characterPosition = positionsBuffer[characterIndex].x;
 502     rightMostCharacterPosition = positionsBuffer[characterIndex+1].x;
 503
 504     if(visualX < rightMostCharacterPosition && visualX >= characterPosition)
 505     {
 506       characterIndexAtPosition = characterIndex;
 507       break;
 508     }
 509   }
 510
 511   if(characterIndex == endCharacter)
 512   {
 513     // If the visualX is within the last character position or it comes after the last character; we return the last character.
 514     rightMostCharacterPosition = positionsBuffer[endCharacter].x + GetCharacterWidth(visualModel->mGlyphs[endCharacter]);
 515
 516     if(visualX >= positionsBuffer[endCharacter].x && visualX < rightMostCharacterPosition)
 517     {
 518       characterIndexAtPosition = endCharacter;
 519     }
 520   }
 521
 522   return characterIndexAtPosition;
 523 }
 524 } // namespace Text
 525
 526 } // namespace Toolkit
 527
 528 } // namespace Dali