Add 'ExclusiveArch: armv7l' limit build to arm architecture
[platform/core/uifw/dali-toolkit.git] / base / dali-toolkit / internal / controls / text-view / text-view-processor.cpp
1 //
2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
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 // INTERNAL INCLUDES
18 #include <dali/integration-api/debug.h>
19 #include "text-view-processor.h"
20 #include "text-view-word-processor.h"
21 #include "text-view-word-group-processor.h"
22 #include "text-view-line-processor.h"
23 #include "text-view-processor-helper-functions.h"
24 #include "text-processor.h"
25 #include "text-view-processor-dbg.h"
26
27 namespace Dali
28 {
29
30 namespace Toolkit
31 {
32
33 namespace Internal
34 {
35
36 namespace TextViewProcessor
37 {
38
39 namespace
40 {
41 /**
42  * Update text layout info.
43  *
44  * Updates the size of the whole text, the maximum width of all words and the number of characters.
45  *
46  * @param[in,out] textLayoutInfo
47  */
48 void UpdateTextLayoutInfo( TextLayoutInfo& textLayoutInfo )
49 {
50   // Initialize members to be updated.
51   textLayoutInfo.mWholeTextSize = Size();
52   textLayoutInfo.mMaxWordWidth = 0.f;
53   textLayoutInfo.mNumberOfCharacters = 0;
54
55   // Traverse all text updating values.
56   for( LineLayoutInfoContainer::const_iterator lineIt = textLayoutInfo.mLinesLayoutInfo.begin(), lineEndIt = textLayoutInfo.mLinesLayoutInfo.end();
57        lineIt != lineEndIt;
58        ++lineIt )
59   {
60     const LineLayoutInfo& line( *lineIt );
61
62     // Updates text size with the size of all lines.
63     UpdateSize( textLayoutInfo.mWholeTextSize, line.mSize, GrowHeight );
64
65     // Updates number of characters.
66     textLayoutInfo.mNumberOfCharacters += line.mNumberOfCharacters;
67
68     // Updates the max word's width.
69     for( WordGroupLayoutInfoContainer::const_iterator groupIt = line.mWordGroupsLayoutInfo.begin(), groupEndIt = line.mWordGroupsLayoutInfo.end();
70          groupIt != groupEndIt;
71          ++groupIt )
72     {
73       const WordGroupLayoutInfo& group( *groupIt );
74       for( WordLayoutInfoContainer::const_iterator wordIt = group.mWordsLayoutInfo.begin(), wordEndIt = group.mWordsLayoutInfo.end();
75            wordIt != wordEndIt;
76            ++wordIt )
77       {
78         const WordLayoutInfo& word( *wordIt );
79
80         textLayoutInfo.mMaxWordWidth = std::max( textLayoutInfo.mMaxWordWidth, word.mSize.width );
81       }
82     }
83   }
84 }
85
86 } // namespace
87
88 // Constructors and assignment operators
89
90 TextInfoIndices::TextInfoIndices()
91 : mLineIndex( 0 ),
92   mGroupIndex( 0 ),
93   mWordIndex( 0 ),
94   mCharacterIndex( 0 )
95 {
96 }
97
98 TextInfoIndices::TextInfoIndices( const std::size_t lineIndex,
99                                   const std::size_t groupIndex,
100                                   const std::size_t wordIndex,
101                                   const std::size_t characterIndex )
102 : mLineIndex( lineIndex ),
103   mGroupIndex( groupIndex ),
104   mWordIndex( wordIndex ),
105   mCharacterIndex( characterIndex )
106 {
107 }
108
109 bool TextInfoIndices::operator==( const TextInfoIndices& indices ) const
110 {
111   return ( ( mLineIndex == indices.mLineIndex ) &&
112            ( mGroupIndex == indices.mGroupIndex ) &&
113            ( mWordIndex == indices.mWordIndex ) &&
114            ( mCharacterIndex == indices.mCharacterIndex ) );
115 }
116
117 /////////////////////
118 // Layout info.
119 /////////////////////
120
121 TextLayoutInfo::TextLayoutInfo()
122 : mWholeTextSize(),
123   mMaxWordWidth( 0.f ),
124   mLinesLayoutInfo(),
125   mNumberOfCharacters( 0 ),
126   mMaxItalicsOffset( 0.f ),
127   mEllipsizeLayoutInfo()
128 {
129 }
130
131 TextLayoutInfo::TextLayoutInfo( const TextLayoutInfo& text )
132 : mWholeTextSize( text.mWholeTextSize ),
133   mMaxWordWidth( text.mMaxWordWidth ),
134   mLinesLayoutInfo( text.mLinesLayoutInfo ),
135   mNumberOfCharacters( text.mNumberOfCharacters ),
136   mMaxItalicsOffset( text.mMaxItalicsOffset ),
137   mEllipsizeLayoutInfo( text.mEllipsizeLayoutInfo )
138 {
139 }
140
141 TextLayoutInfo& TextLayoutInfo::operator=( const TextLayoutInfo& text )
142 {
143   mWholeTextSize = text.mWholeTextSize;
144   mMaxWordWidth = text.mMaxWordWidth;
145   mLinesLayoutInfo = text.mLinesLayoutInfo;
146   mNumberOfCharacters = text.mNumberOfCharacters;
147   mMaxItalicsOffset = text.mMaxItalicsOffset;
148   mEllipsizeLayoutInfo = text.mEllipsizeLayoutInfo;
149
150   return *this;
151 }
152
153 /////////////////////////////////////////////////////////////////////////////////////////////
154
155 void CreateTextInfo( const MarkupProcessor::StyledTextArray& text,
156                      const TextView::LayoutParameters& layoutParameters,
157                      TextView::RelayoutData& relayoutData )
158 {
159   // * Traverse the given text spliting it in lines, each line in groups of words and each group of words in words.
160   // * If possible, it joins characters with same style in one text-actor.
161   // * White spaces and new line characters are alone in one word.
162   // * Bidirectional text is processed in each line.
163   // * A group of words contains text in only one direction (Left to Right or Right to Left but not a mix of both).
164   // * Generates a layout data structure to store layout information (size, position, ascender, text direction, etc) and metrics of all characters.
165   // * Generates a text-actor data structure to store text, style and text-actors.
166   // TODO: finish and test the bidirectional implementation.
167
168   // Collect previously created text-actors.
169   std::vector<TextActor> textActors;
170   CollectTextActorsFromLines( textActors, relayoutData.mTextLayoutInfo, 0, relayoutData.mTextLayoutInfo.mLinesLayoutInfo.size() );
171
172   if( !textActors.empty() )
173   {
174     // Add text-actors to the cache.
175     relayoutData.mTextActorCache.InsertTextActors( textActors );
176     relayoutData.mTextActorCache.ClearTexts();
177   }
178
179   // Store the ellipsize layout info before clearing the previous created info.
180   const WordLayoutInfo ellipsizeInfo = relayoutData.mTextLayoutInfo.mEllipsizeLayoutInfo;
181
182   // clear previous created info.
183   relayoutData.mTextLayoutInfo = TextLayoutInfo();
184   relayoutData.mCharacterLogicalToVisualMap.clear();
185   relayoutData.mCharacterVisualToLogicalMap.clear();
186
187   // Sets the ellipsize layout info.
188   relayoutData.mTextLayoutInfo.mEllipsizeLayoutInfo = ellipsizeInfo;
189
190   // Split the whole text in lines.
191   std::vector<MarkupProcessor::StyledTextArray> lines;
192   TextProcessor::SplitInLines( text,
193                                lines );
194
195   // Traverse all lines
196   for( std::vector<MarkupProcessor::StyledTextArray>::const_iterator lineIt = lines.begin(), lineEndIt = lines.end(); lineIt != lineEndIt; ++lineIt )
197   {
198     const MarkupProcessor::StyledTextArray& line( *lineIt );
199
200     // Data structures for the new line
201     LineLayoutInfo lineLayoutInfo;
202
203     // Fills the line data structures with the layout info.
204     CreateLineInfo( line,
205                     relayoutData,
206                     lineLayoutInfo );
207
208     if( 0 < lineLayoutInfo.mNumberOfCharacters )
209     {
210       // do not add the line offset if the line has no characters.
211       lineLayoutInfo.mSize.height += layoutParameters.mLineHeightOffset;
212       lineLayoutInfo.mLineHeightOffset = layoutParameters.mLineHeightOffset;
213     }
214     else
215     {
216       // line height needs to be added for the last line.
217
218       float lineHeight = 0.f;
219       // Get the last character of the last line.
220       if( !relayoutData.mTextLayoutInfo.mLinesLayoutInfo.empty() )
221       {
222         const LineLayoutInfo& lineInfo( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.end() - 1 ) );
223
224         const CharacterLayoutInfo characterInfo = GetLastCharacterLayoutInfo( lineInfo );
225
226         lineHeight = characterInfo.mSize.height;
227       }
228
229       lineLayoutInfo.mSize.height = lineHeight;
230     }
231
232     // Update layout info for the whole text.
233     UpdateSize( relayoutData.mTextLayoutInfo.mWholeTextSize, lineLayoutInfo.mSize, GrowHeight );
234     relayoutData.mTextLayoutInfo.mNumberOfCharacters += lineLayoutInfo.mNumberOfCharacters;
235
236     // Add the line to the current text.
237     relayoutData.mTextLayoutInfo.mLinesLayoutInfo.push_back( lineLayoutInfo );
238   } // end of lines
239 }
240
241 void UpdateTextInfo( const std::size_t position,
242                      const MarkupProcessor::StyledTextArray& text,
243                      const TextView::LayoutParameters& layoutParameters,
244                      TextView::RelayoutData& relayoutData )
245 {
246   // Update current internal data structure with added text.
247
248   // * Creates layout info for the given text.
249   // * With the given position, find where to add the text.
250   // * If the new text is not added at the end of current text, a line need to be split.
251   // * Merge the last line of the new text to the last part or the split line.
252   // * Add lines between first and last of the new text.
253   // * Merge the first part of the split line with the first line of the new text.
254   // * Update layout info and create new text actors if needed.
255
256   // Early returns:
257
258   if( text.empty() )
259   {
260     // nothing to do if the input text is empty.
261     return;
262   }
263
264   if( 0 == relayoutData.mTextLayoutInfo.mNumberOfCharacters )
265   {
266     // Current text is empty. There is no need to update current data structure,
267     // just create a new one with the new input text.
268     CreateTextInfo( text,
269                     layoutParameters,
270                     relayoutData );
271     return;
272   }
273
274   // initial checks.
275   if( position > relayoutData.mTextLayoutInfo.mNumberOfCharacters )
276   {
277     // Asserts if text is to be added out of bounds.
278     DALI_ASSERT_ALWAYS( !"TextViewProcessor::UpdateTextInfo (insert). Trying to insert text out of bounds." );
279   }
280
281   TextView::RelayoutData relayoutDataForNewText;
282
283   // Creates layout info for the given text.
284   // It doesn't create text-actors as text could be added to an existing one.
285   CreateTextInfo( text,
286                   layoutParameters,
287                   relayoutDataForNewText );
288
289   // Update logical-to-visual and visual-to-logical tables.
290   // TODO: check that for mixed RTL/LTR text.
291   std::size_t index = 0;
292   for( std::size_t i = 0; i < relayoutDataForNewText.mTextLayoutInfo.mNumberOfCharacters; ++i )
293   {
294     relayoutData.mCharacterLogicalToVisualMap.push_back( relayoutData.mTextLayoutInfo.mNumberOfCharacters + index );
295     relayoutData.mCharacterVisualToLogicalMap.push_back( relayoutData.mTextLayoutInfo.mNumberOfCharacters + index );
296     ++index;
297   }
298
299   // If a line is split, it stores the last part of the line.
300   LineLayoutInfo lastLineLayoutInfo;
301
302   // Stores indices to the line, group of words, word and character of the given position.
303   TextInfoIndices textInfoIndices;
304
305   if( position < relayoutData.mTextLayoutInfo.mNumberOfCharacters )
306   {
307     // Get line, group, word and character indices for given position.
308     GetIndicesFromGlobalCharacterIndex( position,
309                                         relayoutData.mTextLayoutInfo,
310                                         textInfoIndices );
311
312     // 1) Split the line
313
314     // Split a line in two is needed, then merge the first part of the split line
315     // with the first line of the new text, add subsequent lines and merge the last line
316     // of the new text with the last part of the split line.
317
318     // Implementation notes!
319     //
320     // These references to the first line are declared in this scope because if new lines are inserted in step 2,
321     // they become invalid, making the algorithm to crash if used again.
322     // In the step 3, references to the first line are needed and declared again.
323
324     // Stores the first part of the split line.
325     LineLayoutInfo& firstLineLayoutInfo( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoIndices.mLineIndex ) );
326
327     SplitLine( textInfoIndices,
328                PointSize( layoutParameters.mLineHeightOffset ),
329                firstLineLayoutInfo,
330                lastLineLayoutInfo );
331   }
332   else
333   {
334     // Position is just after the last character.
335     // Calculates indices for that position.
336     if( !relayoutData.mTextLayoutInfo.mLinesLayoutInfo.empty() )
337     {
338       textInfoIndices.mLineIndex = relayoutData.mTextLayoutInfo.mLinesLayoutInfo.size() - 1;
339       const LineLayoutInfo& lineLayoutInfo( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.end() - 1 ) );
340
341       if( !lineLayoutInfo.mWordGroupsLayoutInfo.empty() )
342       {
343         textInfoIndices.mGroupIndex = lineLayoutInfo.mWordGroupsLayoutInfo.size() - 1;
344         const WordGroupLayoutInfo& groupLayoutInfo( *( lineLayoutInfo.mWordGroupsLayoutInfo.end() - 1 ) );
345
346         if( !groupLayoutInfo.mWordsLayoutInfo.empty() )
347         {
348           textInfoIndices.mWordIndex = groupLayoutInfo.mWordsLayoutInfo.size() - 1;
349
350           const WordLayoutInfo& wordLayoutInfo( *( groupLayoutInfo.mWordsLayoutInfo.end() - 1 ) );
351           textInfoIndices.mCharacterIndex = wordLayoutInfo.mCharactersLayoutInfo.size();
352         }
353       }
354     }
355   }
356
357   // 2) If the new text has more than 1 line, merge the last line of the input text with the last part of the split line.
358   //TODO check this cases ( num lines ==1, >1, >2 ) if it could be simplified.
359   if( relayoutDataForNewText.mTextLayoutInfo.mLinesLayoutInfo.size() > 1 )
360   {
361     LineLayoutInfo& lastInputLineLayoutInfo( *( relayoutDataForNewText.mTextLayoutInfo.mLinesLayoutInfo.end() - 1 ) );
362
363     MergeLine( lastInputLineLayoutInfo,
364                lastLineLayoutInfo );
365
366     if( relayoutDataForNewText.mTextLayoutInfo.mLinesLayoutInfo.size() > 2 )
367     {
368       // Insert all lines except first and last in the text.
369       relayoutData.mTextLayoutInfo.mLinesLayoutInfo.insert( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoIndices.mLineIndex + 1,
370                                                             relayoutDataForNewText.mTextLayoutInfo.mLinesLayoutInfo.begin() + 1,
371                                                             relayoutDataForNewText.mTextLayoutInfo.mLinesLayoutInfo.end() - 1 );
372     }
373
374     // Insert the last line to the text
375     relayoutData.mTextLayoutInfo.mLinesLayoutInfo.insert( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoIndices.mLineIndex + relayoutDataForNewText.mTextLayoutInfo.mLinesLayoutInfo.size() - 1,
376                                                           lastInputLineLayoutInfo );
377   }
378   else
379   {
380     // Merge the new line to the last part of the split line.
381     LineLayoutInfo& inputLineLayoutInfo( *relayoutDataForNewText.mTextLayoutInfo.mLinesLayoutInfo.begin() );
382
383     MergeLine( inputLineLayoutInfo,
384                lastLineLayoutInfo );
385   }
386
387   // 3) Merge the first line of the split text with the first line of the input text.
388   LineLayoutInfo& firstLineLayoutInfo( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoIndices.mLineIndex ) );
389   LineLayoutInfo& firstInputLineLayoutInfo( *relayoutDataForNewText.mTextLayoutInfo.mLinesLayoutInfo.begin() );
390
391   MergeLine( firstLineLayoutInfo,
392              firstInputLineLayoutInfo );
393
394   // 4) Update text info.
395
396   // Updates the whole text size, maximum word size, etc.
397   UpdateTextLayoutInfo( relayoutData.mTextLayoutInfo );
398 }
399
400 void UpdateTextInfo( const std::size_t position,
401                      const std::size_t numberOfCharacters,
402                      const TextView::LayoutParameters& layoutParameters,
403                      TextView::RelayoutData& relayoutData,
404                      const TextOperationOnRemove clearText )
405 {
406   // Removes 'numberOfCharacters' starting from 'position'.
407
408   // * It checks if text to be deleted is in the same line or not:
409   // *   If it is not, check which lines need to be split/merged or deleted.
410   // *   If it is but all characters of the line are going to be deleted, just delete the line (nothing needs to be split/merged)
411   // *   If only some characters of the same line are going to be deleted, proceed similarly: check if text to be deleted is in the same group of words.
412   // *     If it is not, check which groups of words need to be split/merged or deleted. Two groups of words can't be merged if they contain text with different direction (Left to Right / Right to Left)
413   // *     If it is but all characters of the group are going to be deleted, delete the group. TODO: Check if previous and following group need to be merged.
414   // *     If only some characters of the same group of words need to be deleted, proceed similarly: check if text to be deleted is in the same word.
415   // *       If it is not, split/merge words.
416   // *       Check if the whole word needs to be deleted.
417   // *       Check if only some characters of the word need to be deleted.
418   // * Updates layout info.
419
420   // * The algorithm checks if a word separator is deleted (in that case, different words need to be merged) and if a new line separator is deleted (two lines need to be merged).
421
422   // Early return
423
424   if( 0 == numberOfCharacters )
425   {
426     DALI_ASSERT_DEBUG( !"TextViewProcessor::UpdateTextInfo. WARNING: trying to delete 0 characters!" )
427
428     // nothing to do if no characters are deleted.
429     return;
430   }
431
432   // Asserts if trying to delete text out of bounds.
433   DALI_ASSERT_ALWAYS( position + numberOfCharacters <= relayoutData.mTextLayoutInfo.mNumberOfCharacters && "TextViewProcessor::UpdateTextInfo. ERROR: trying to delete characters out of boundary" );
434
435   // Remove characters from character to visual map and vs //TODO: check this for RTL text!!
436   relayoutData.mCharacterLogicalToVisualMap.erase( relayoutData.mCharacterLogicalToVisualMap.end() - numberOfCharacters, relayoutData.mCharacterLogicalToVisualMap.end() );
437   relayoutData.mCharacterVisualToLogicalMap.erase( relayoutData.mCharacterVisualToLogicalMap.end() - numberOfCharacters, relayoutData.mCharacterVisualToLogicalMap.end() );
438
439   // Get line, group of words, word and character indices for the given start position.
440   TextInfoIndices textInfoIndicesBegin;
441   GetIndicesFromGlobalCharacterIndex( position,
442                                       relayoutData.mTextLayoutInfo,
443                                       textInfoIndicesBegin );
444
445   // Get line, group of words, word and character indices for the given end position (start position + number of characters to be deleted).
446   TextInfoIndices textInfoIndicesEnd;
447   GetIndicesFromGlobalCharacterIndex( position + numberOfCharacters - 1,
448                                       relayoutData.mTextLayoutInfo,
449                                       textInfoIndicesEnd );
450
451   // Vectors used to temporary store text-actors removed from text.
452   // Three vectors are needed because text-actors are not removed in order
453   // but insert them in order is required to reuse them later.
454   std::vector<TextActor> removedTextActorsFromBegin;
455   std::vector<TextActor> removedTextActorsFromMid;
456   std::vector<TextActor> removedTextActorsFromEnd;
457
458   // Whether lines, group of words and words need to be merged.
459   bool mergeLines = false;
460   bool mergeGroups = false;
461   bool mergeWords = false;
462
463   // Indices of the lines, group of words and words to be merged.
464   TextInfoIndices textInfoMergeIndicesBegin;
465   TextInfoIndices textInfoMergeIndicesEnd;
466
467   const LineLayoutInfo& lineLayout( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoIndicesBegin.mLineIndex ) ); // used to check the number of characters of the line
468                                                                                                                                     // if all characters to be deleted are in the same line.
469   if( textInfoIndicesBegin.mLineIndex < textInfoIndicesEnd.mLineIndex )
470   {
471     // Deleted text is from different lines. It may need to split two lines, and merge first part of the first one with last part of the last one.
472
473     // whether first or last line need to be split and merged with the last part.
474     bool mergeFirstLine = false;
475     bool mergeLastLine = true;
476
477     textInfoMergeIndicesBegin.mLineIndex = textInfoIndicesBegin.mLineIndex;
478     textInfoMergeIndicesEnd.mLineIndex = textInfoIndicesEnd.mLineIndex;
479
480     if( ( textInfoIndicesBegin.mGroupIndex > 0 ) || ( textInfoIndicesBegin.mWordIndex > 0 ) || ( textInfoIndicesBegin.mCharacterIndex > 0 ) )
481     {
482       // first character to be deleted is not the first one of the current line.
483       ++textInfoIndicesBegin.mLineIndex; // won't delete current line
484
485       // As some characters remain, this line could be merged with the last one.
486       mergeFirstLine = true;
487     }
488
489     // Check if all characters of the last line are going to be deleted.
490     bool wholeLinedeleted = false;
491     const LineLayoutInfo& lastLineLayout( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoIndicesEnd.mLineIndex ) );
492     if( textInfoIndicesEnd.mGroupIndex + 1 == lastLineLayout.mWordGroupsLayoutInfo.size() )
493     {
494       const WordGroupLayoutInfo& lastGroupLayout( *( lastLineLayout.mWordGroupsLayoutInfo.begin() + textInfoIndicesEnd.mGroupIndex ) );
495       if( textInfoIndicesEnd.mWordIndex + 1 == lastGroupLayout.mWordsLayoutInfo.size() )
496       {
497         const WordLayoutInfo& lastWordLayout( *( lastGroupLayout.mWordsLayoutInfo.begin() + textInfoIndicesEnd.mWordIndex ) );
498         if( textInfoIndicesEnd.mCharacterIndex + 1 == lastWordLayout.mCharactersLayoutInfo.size() )
499         {
500           // All characters of the last line are going to be deleted.
501           ++textInfoIndicesEnd.mLineIndex; // will delete the last line.
502
503           // the whole last line is deleted. Need to check if the next line could be merged.
504           mergeLastLine = false;
505           wholeLinedeleted = true;
506         }
507       }
508     }
509
510     if( wholeLinedeleted )
511     {
512       // It means the whole last line is deleted completely.
513       // It's needed to check if there is another line after that could be merged.
514       if( textInfoIndicesEnd.mLineIndex < relayoutData.mTextLayoutInfo.mLinesLayoutInfo.size() )
515       {
516           mergeLastLine = true;
517
518           // Point the first characters of the next line.
519           textInfoIndicesEnd.mGroupIndex = 0;
520           textInfoIndicesEnd.mWordIndex = 0;
521           textInfoIndicesEnd.mCharacterIndex = 0;
522           textInfoMergeIndicesEnd.mLineIndex = textInfoIndicesEnd.mLineIndex;
523       }
524     }
525
526     // If some characters remain in the first and last line, they need to be merged.
527     mergeLines = mergeFirstLine && mergeLastLine;
528
529     if( mergeLines )
530     {
531       // last line is going to be merged with the first one, so is not needed.
532       ++textInfoIndicesEnd.mLineIndex; // will delete the last line.
533     }
534
535     if( mergeFirstLine )
536     {
537       // Remove characters from the first line.
538
539       // Vectors used to temporary store text-actors removed from the line.
540       // Three vectors are needed because text-actors are not removed in order
541       // but insert them in order is required to reuse them later.
542       std::vector<TextActor> removedTextActorsFromFirstWord;
543       std::vector<TextActor> removedTextActorsFromFirstGroup;
544       std::vector<TextActor> removedTextActorsFromGroups;
545
546       // As lineIndexBegin has been increased just to not to remove the line, decrease now is needed to access it.
547       LineLayoutInfo& lineLayout( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoIndicesBegin.mLineIndex - 1 ) );
548
549       if( textInfoIndicesBegin.mGroupIndex + 1 < lineLayout.mWordGroupsLayoutInfo.size() )
550       {
551         // Store text-actors before removing them.
552         CollectTextActorsFromGroups( removedTextActorsFromGroups, lineLayout, textInfoIndicesBegin.mGroupIndex + 1, lineLayout.mWordGroupsLayoutInfo.size() );
553
554         // Remove extra groups. If a line has left to right and right to left text, groups after current one could be removed.
555         RemoveWordGroupsFromLine( textInfoIndicesBegin.mGroupIndex + 1,
556                                   lineLayout.mWordGroupsLayoutInfo.size() - ( textInfoIndicesBegin.mGroupIndex + 1 ),
557                                   PointSize( layoutParameters.mLineHeightOffset ),
558                                   lineLayout );
559       }
560
561       WordGroupLayoutInfo& groupLayout( *( lineLayout.mWordGroupsLayoutInfo.begin() + textInfoIndicesBegin.mGroupIndex ) );
562
563       if( ( textInfoIndicesBegin.mWordIndex + 1 < groupLayout.mWordsLayoutInfo.size() ) || ( 0 == textInfoIndicesBegin.mCharacterIndex ) )
564       {
565         // Remove extra words within current group of words. (and current word if whole characters are removed)
566         // 0 == characterIndexBegin means the whole word is deleted.
567         const std::size_t wordIndex = ( ( 0 == textInfoIndicesBegin.mCharacterIndex ) ? textInfoIndicesBegin.mWordIndex : textInfoIndicesBegin.mWordIndex + 1 );
568
569         // Store text-actors before removing them.
570         CollectTextActorsFromWords( removedTextActorsFromFirstGroup, groupLayout, wordIndex, groupLayout.mWordsLayoutInfo.size() );
571
572         const std::size_t groupNumberCharacters = groupLayout.mNumberOfCharacters;
573         RemoveWordsFromWordGroup( wordIndex,
574                                   groupLayout.mWordsLayoutInfo.size() - wordIndex,
575                                   groupLayout );
576
577         // discount the removed number of characters.
578         lineLayout.mNumberOfCharacters -= ( groupNumberCharacters - groupLayout.mNumberOfCharacters );
579       }
580
581       if( ( textInfoIndicesBegin.mWordIndex < groupLayout.mWordsLayoutInfo.size() ) && ( textInfoIndicesBegin.mCharacterIndex > 0 ) )
582       {
583         // Only some characters of the word need to be removed.
584         WordLayoutInfo& wordLayout( *( groupLayout.mWordsLayoutInfo.begin() + textInfoIndicesBegin.mWordIndex ) );
585
586         // Store text-actors before removing them.
587         CollectTextActors( removedTextActorsFromFirstWord, wordLayout, textInfoIndicesBegin.mCharacterIndex, wordLayout.mCharactersLayoutInfo.size() );
588
589         const std::size_t wordNumberCharacters = wordLayout.mCharactersLayoutInfo.size();
590         RemoveCharactersFromWord( textInfoIndicesBegin.mCharacterIndex,
591                                   wordLayout.mCharactersLayoutInfo.size() - textInfoIndicesBegin.mCharacterIndex,
592                                   wordLayout );
593
594         // discount the removed number of characters.
595         const std::size_t removedNumberOfCharacters = ( wordNumberCharacters - wordLayout.mCharactersLayoutInfo.size() );
596         groupLayout.mNumberOfCharacters -= removedNumberOfCharacters;
597         lineLayout.mNumberOfCharacters -= removedNumberOfCharacters;
598       }
599       UpdateLineLayoutInfo( lineLayout, layoutParameters.mLineHeightOffset );
600
601       // Insert the text-actors in order.
602       removedTextActorsFromBegin.insert( removedTextActorsFromBegin.end(), removedTextActorsFromFirstWord.begin(), removedTextActorsFromFirstWord.end() );
603       removedTextActorsFromBegin.insert( removedTextActorsFromBegin.end(), removedTextActorsFromFirstGroup.begin(), removedTextActorsFromFirstGroup.end() );
604       removedTextActorsFromBegin.insert( removedTextActorsFromBegin.end(), removedTextActorsFromGroups.begin(), removedTextActorsFromGroups.end() );
605     }
606
607     if( mergeLastLine && !wholeLinedeleted )
608     {
609       // Some characters from the last line need to be removed.
610
611       // Vectors used to temporary store text-actors removed from the group.
612       // Three vectors are needed because text-actors are not removed in order
613       // but insert them in order is required to reuse them later.
614       std::vector<TextActor> removedTextActorsFromFirstWord;
615       std::vector<TextActor> removedTextActorsFromFirstGroup;
616       std::vector<TextActor> removedTextActorsFromGroups;
617
618       // lineIndexEnd was increased to delete the last line if lines need to be merged.
619       // To access now the last line we need to decrease the index.
620       const std::size_t lineIndex = ( mergeLines ? textInfoIndicesEnd.mLineIndex - 1 : textInfoIndicesEnd.mLineIndex );
621
622       // Get the last line.
623       LineLayoutInfo& lineLayout( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + lineIndex ) );
624
625       if( textInfoIndicesEnd.mGroupIndex > 0 )
626       {
627         // Store text-actors before removing them.
628         CollectTextActorsFromGroups( removedTextActorsFromGroups, lineLayout, 0, textInfoIndicesEnd.mGroupIndex );
629
630         // Remove extra groups from the beginning of the line to the current group of words.
631         RemoveWordGroupsFromLine( 0,
632                                   textInfoIndicesEnd.mGroupIndex,
633                                   PointSize( layoutParameters.mLineHeightOffset ),
634                                   lineLayout );
635       }
636
637       // The group of characters which contains the characters to be removed is now the first one.
638       WordGroupLayoutInfo& groupLayout( *lineLayout.mWordGroupsLayoutInfo.begin() );
639
640       // Check if is needed remove the whole word. (If the character index is pointing just after the end of the word)
641       const WordLayoutInfo& wordLayout( *( groupLayout.mWordsLayoutInfo.begin() + textInfoIndicesEnd.mWordIndex ) );
642       bool removeWholeWord = wordLayout.mCharactersLayoutInfo.size() == textInfoIndicesEnd.mCharacterIndex + 1;
643
644       if( ( textInfoIndicesEnd.mWordIndex > 0 ) || ( removeWholeWord ) )
645       {
646         // Store text-actors before removing them.
647         CollectTextActorsFromWords( removedTextActorsFromFirstGroup, groupLayout, 0, ( removeWholeWord ) ? textInfoIndicesEnd.mWordIndex + 1 : textInfoIndicesEnd.mWordIndex );
648
649         // Remove extra words. (and current word if whole characters are removed)
650         const std::size_t groupNumberCharacters = groupLayout.mNumberOfCharacters;
651         RemoveWordsFromWordGroup( 0,
652                                   ( removeWholeWord ) ? textInfoIndicesEnd.mWordIndex + 1 : textInfoIndicesEnd.mWordIndex,
653                                   groupLayout );
654
655         // discount the removed number of characters.
656         lineLayout.mNumberOfCharacters -= ( groupNumberCharacters - groupLayout.mNumberOfCharacters );
657       }
658
659       if( !removeWholeWord )
660       {
661         // Only some characters of the word need to be deleted.
662
663         // After removing all extra words. The word with the characters to be removed is the first one.
664         WordLayoutInfo& wordLayout( *groupLayout.mWordsLayoutInfo.begin() );
665
666         // Store text-actors before removing them.
667         CollectTextActors( removedTextActorsFromFirstWord, wordLayout, 0, textInfoIndicesEnd.mCharacterIndex + 1 );
668
669         const std::size_t wordNumberCharacters = wordLayout.mCharactersLayoutInfo.size();
670         RemoveCharactersFromWord( 0,
671                                   textInfoIndicesEnd.mCharacterIndex + 1,
672                                   wordLayout );
673
674         // discount the removed number of characters.
675         const std::size_t removedNumberOfCharacters = ( wordNumberCharacters - wordLayout.mCharactersLayoutInfo.size() );
676         groupLayout.mNumberOfCharacters -= removedNumberOfCharacters;
677         lineLayout.mNumberOfCharacters -= removedNumberOfCharacters;
678         UpdateGroupLayoutInfo( groupLayout );
679       }
680       UpdateLineLayoutInfo( lineLayout, layoutParameters.mLineHeightOffset );
681
682       // Insert the text-actors in order.
683       removedTextActorsFromEnd.insert( removedTextActorsFromEnd.end(), removedTextActorsFromFirstWord.begin(), removedTextActorsFromFirstWord.end() );
684       removedTextActorsFromEnd.insert( removedTextActorsFromEnd.end(), removedTextActorsFromFirstGroup.begin(), removedTextActorsFromFirstGroup.end() );
685       removedTextActorsFromEnd.insert( removedTextActorsFromEnd.end(), removedTextActorsFromGroups.begin(), removedTextActorsFromGroups.end() );
686     }
687   } // end delete text from different lines
688   else if( ( textInfoIndicesBegin.mLineIndex == textInfoIndicesEnd.mLineIndex ) && ( lineLayout.mNumberOfCharacters == numberOfCharacters ) )
689   {
690     // the whole line needs to be deleted.
691     ++textInfoIndicesEnd.mLineIndex; // will delete current line.
692   }
693   else
694   {
695     // deleted text is within the same line. (merge lines could be needed if the line separator character is deleted)
696
697     // Line which contains the characters to be deleted.
698     LineLayoutInfo& lineLayout( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoIndicesBegin.mLineIndex ) );
699
700     const WordGroupLayoutInfo& groupLayout( *( lineLayout.mWordGroupsLayoutInfo.begin() + textInfoIndicesBegin.mGroupIndex ) ); // used to check the number of characters of the group of words
701                                                                                                                                 // if all characters to be deleted are in the same group of words.
702     if( textInfoIndicesBegin.mGroupIndex < textInfoIndicesEnd.mGroupIndex )
703     {
704       // Deleted text is from different group of words. The two different group of words may be merged if they have text with same direction.
705
706       // whether first or last group of words need to be split and merged with the last part.
707       bool splitFirstGroup = false;
708       bool splitLastGroup = true;
709
710       textInfoMergeIndicesBegin.mGroupIndex = textInfoIndicesBegin.mGroupIndex;
711       textInfoMergeIndicesEnd.mGroupIndex = textInfoIndicesEnd.mGroupIndex;
712
713       if( ( textInfoIndicesBegin.mWordIndex > 0 ) || ( textInfoIndicesBegin.mCharacterIndex > 0 ) )
714       {
715         // first character to be deleted is not the first one of the current group.
716         ++textInfoIndicesBegin.mGroupIndex; // won't delete current group
717
718         // As some characters remain, this group needs to be split and could be merged with the last one.
719         splitFirstGroup = true;
720       }
721
722       // Check if all characters of the last group are going to be deleted.
723       const WordGroupLayoutInfo& lastGroupLayout( *( lineLayout.mWordGroupsLayoutInfo.begin() + textInfoIndicesEnd.mGroupIndex ) );
724       if( textInfoIndicesEnd.mWordIndex + 1 == lastGroupLayout.mWordsLayoutInfo.size() )
725       {
726         const WordLayoutInfo& lastWordLayout( *( lastGroupLayout.mWordsLayoutInfo.begin() + textInfoIndicesEnd.mWordIndex ) );
727         if( textInfoIndicesEnd.mCharacterIndex + 1 == lastWordLayout.mCharactersLayoutInfo.size() )
728         {
729           // All characters of the last group are going to be deleted.
730           ++textInfoIndicesEnd.mGroupIndex; // will delete the last group.
731
732           // The whole last group is deleted. No need to merge groups.
733           splitLastGroup = false;
734         }
735       }
736
737       // Only merge two groups if they are not deleted completely and they have same direction.
738       mergeGroups = ( splitFirstGroup && splitLastGroup ) && ( groupLayout.mDirection == lastGroupLayout.mDirection );
739
740       if( mergeGroups )
741       {
742         // last group is going to be merged.
743         ++textInfoIndicesEnd.mGroupIndex; // will delete the last group.
744       }
745
746       if( splitFirstGroup )
747       {
748         // Remove characters from the first group.
749
750         // As wordGroupIndexBegin has been increased just to not to remove the group of words, decrease now is needed to access it.
751         WordGroupLayoutInfo& groupLayout( *( lineLayout.mWordGroupsLayoutInfo.begin() + textInfoIndicesBegin.mGroupIndex - 1 ) );
752
753         if( ( textInfoIndicesBegin.mWordIndex + 1 < groupLayout.mWordsLayoutInfo.size() ) || ( 0 == textInfoIndicesBegin.mCharacterIndex ) )
754         {
755           // Remove extra words within current group of words. (and current word if whole characters are removed)
756           // 0 == characterIndexBegin means the whole word is deleted.
757           const std::size_t wordIndex = ( ( 0 == textInfoIndicesBegin.mCharacterIndex ) ? textInfoIndicesBegin.mWordIndex : textInfoIndicesBegin.mWordIndex + 1 );
758
759           // Store text-actors before removing them.
760           CollectTextActorsFromWords( removedTextActorsFromBegin, groupLayout, wordIndex, groupLayout.mWordsLayoutInfo.size() );
761
762           RemoveWordsFromWordGroup( wordIndex,
763                                     groupLayout.mWordsLayoutInfo.size() - wordIndex,
764                                     groupLayout );
765         }
766
767         if( ( textInfoIndicesBegin.mWordIndex < groupLayout.mWordsLayoutInfo.size() ) && ( textInfoIndicesBegin.mCharacterIndex > 0 ) )
768         {
769           // Only some characters of the word need to be removed.
770           WordLayoutInfo& wordLayout( *( groupLayout.mWordsLayoutInfo.begin() + textInfoIndicesBegin.mWordIndex ) );
771
772           // Store text-actors before removing them.
773           CollectTextActors( removedTextActorsFromBegin, wordLayout, textInfoIndicesBegin.mCharacterIndex, wordLayout.mCharactersLayoutInfo.size() );
774
775           RemoveCharactersFromWord( textInfoIndicesBegin.mCharacterIndex,
776                                     wordLayout.mCharactersLayoutInfo.size() - textInfoIndicesBegin.mCharacterIndex,
777                                     wordLayout );
778         }
779       }
780
781       if( splitLastGroup )
782       {
783         // Some characters from the last group of words need to be removed.
784
785         // textInfoIndicesEnd.mGroupIndex was increased to delete the last group of words if groups need to be merged.
786         // To access now the last group of words we need to decrease the index.
787         std::size_t index = mergeGroups ? textInfoIndicesEnd.mGroupIndex - 1 : textInfoIndicesEnd.mGroupIndex;
788
789         // Get the last group of words.
790         WordGroupLayoutInfo& groupLayout( *( lineLayout.mWordGroupsLayoutInfo.begin() + index ) );
791
792         // Check if is needed remove the whole word. (If the character index is pointing just after the end of the word)
793         const WordLayoutInfo& wordLayout( *( groupLayout.mWordsLayoutInfo.begin() + textInfoIndicesEnd.mWordIndex ) );
794         bool removeWholeWord = wordLayout.mCharactersLayoutInfo.size() == textInfoIndicesEnd.mCharacterIndex + 1;
795
796         if( ( textInfoIndicesEnd.mWordIndex > 0 ) || ( removeWholeWord ) )
797         {
798           // Store text-actors before removing them.
799           CollectTextActorsFromWords( removedTextActorsFromBegin, groupLayout, 0, ( removeWholeWord ) ? textInfoIndicesEnd.mWordIndex + 1 : textInfoIndicesEnd.mWordIndex );
800
801           // Remove extra words. (and current word if whole characters are removed)
802           RemoveWordsFromWordGroup( 0,
803                                     ( removeWholeWord ) ? textInfoIndicesEnd.mWordIndex + 1 : textInfoIndicesEnd.mWordIndex,
804                                     groupLayout );
805         }
806
807         if( !removeWholeWord )
808         {
809           // Only some characters of the word need to be deleted.
810
811           // After removing all extra words. The word with the characters to be removed is the first one.
812           WordLayoutInfo& wordLayout( *groupLayout.mWordsLayoutInfo.begin() );
813
814           // Store text-actors before removing them.
815           CollectTextActors( removedTextActorsFromBegin, wordLayout, 0, textInfoIndicesEnd.mCharacterIndex + 1 );
816
817           RemoveCharactersFromWord( 0,
818                                     textInfoIndicesEnd.mCharacterIndex + 1,
819                                     wordLayout );
820         }
821       }
822     } // end of remove from different groups
823     else if( ( textInfoIndicesBegin.mGroupIndex == textInfoIndicesEnd.mGroupIndex ) && ( groupLayout.mNumberOfCharacters == numberOfCharacters ) )
824     {
825       // The whole group is deleted.
826       ++textInfoIndicesEnd.mGroupIndex; // will delete current group.
827       // TODO group before and group after need to be merged!!!
828     }
829     else
830     {
831       // characters to be deleted are on the same group of words. (words may need to be merged)
832
833       // Group of words which contains the characters to be deleted.
834       WordGroupLayoutInfo& groupLayout( *( lineLayout.mWordGroupsLayoutInfo.begin() + textInfoIndicesBegin.mGroupIndex ) );
835
836       RemoveCharactersFromWordGroupInfo( relayoutData,
837                                          numberOfCharacters,
838                                          mergeWords,
839                                          mergeLines,
840                                          textInfoIndicesBegin,
841                                          textInfoIndicesEnd,
842                                          textInfoMergeIndicesBegin,
843                                          textInfoMergeIndicesEnd,
844                                          groupLayout,
845                                          removedTextActorsFromBegin,
846                                          removedTextActorsFromEnd );
847
848       if( mergeWords )
849       {
850         // Merges words pointed by textInfoMergeIndicesBegin.mWordIndex and textInfoMergeIndicesEnd.mWordIndex calculated previously.
851         DALI_ASSERT_DEBUG( ( textInfoMergeIndicesBegin.mWordIndex < groupLayout.mWordsLayoutInfo.size() ) && "TextViewProcessor::UpdateTextInfo (delete). Word index (begin) out of bounds." );
852         DALI_ASSERT_DEBUG( ( textInfoMergeIndicesEnd.mWordIndex < groupLayout.mWordsLayoutInfo.size() ) && "TextViewProcessor::UpdateTextInfo (delete). Word index (end) out of bounds." );
853
854         WordLayoutInfo& firstWordLayout( *( groupLayout.mWordsLayoutInfo.begin() + textInfoMergeIndicesBegin.mWordIndex ) );
855         WordLayoutInfo& lastWordLayout( *( groupLayout.mWordsLayoutInfo.begin() + textInfoMergeIndicesEnd.mWordIndex ) );
856
857         MergeWord( firstWordLayout,
858                    lastWordLayout );
859       }
860
861       // Store text-actors before removing them.
862       const std::size_t endIndex = ( mergeWords && ( textInfoIndicesEnd.mWordIndex > 0 ) ) ? textInfoIndicesEnd.mWordIndex - 1 : textInfoIndicesEnd.mWordIndex; // text-actors from the last word may have been added in the merge above.
863       CollectTextActorsFromWords( removedTextActorsFromMid, groupLayout, textInfoIndicesBegin.mWordIndex, endIndex );
864
865       // Remove unwanted words using previously calculated indices. (including the last part of the merged word)
866       groupLayout.mWordsLayoutInfo.erase( groupLayout.mWordsLayoutInfo.begin() + textInfoIndicesBegin.mWordIndex, groupLayout.mWordsLayoutInfo.begin() + textInfoIndicesEnd.mWordIndex );
867
868       // Update group of words info
869       groupLayout.mNumberOfCharacters -= numberOfCharacters;
870       groupLayout.mSize = Size();
871       groupLayout.mAscender = 0;
872       for( WordLayoutInfoContainer::const_iterator it = groupLayout.mWordsLayoutInfo.begin(), endIt = groupLayout.mWordsLayoutInfo.end();
873            it != endIt;
874            ++it )
875       {
876         const WordLayoutInfo& layoutInfo( *it );
877         UpdateSize( groupLayout.mSize, layoutInfo.mSize );
878         groupLayout.mAscender = std::max( groupLayout.mAscender, layoutInfo.mAscender );
879       }
880     } // end of remove from same group
881
882     if( mergeGroups )
883     {
884       // Merges group of words pointed by textInfoMergeIndicesBegin.mGroupIndex and textInfoMergeIndicesEnd.mGroupIndex calculated previously.
885
886       WordGroupLayoutInfo& firstGroupLayout( *( lineLayout.mWordGroupsLayoutInfo.begin() + textInfoMergeIndicesBegin.mGroupIndex ) );
887
888       const WordGroupLayoutInfo& lastGroupLayout( *( lineLayout.mWordGroupsLayoutInfo.begin() + textInfoMergeIndicesEnd.mGroupIndex ) );
889
890       MergeWordGroup( firstGroupLayout,
891                       lastGroupLayout );
892     }
893
894     // Remove unwanted groups of words using previously calculated indices. (including the last part of the merged group of words)
895     lineLayout.mWordGroupsLayoutInfo.erase( lineLayout.mWordGroupsLayoutInfo.begin() + textInfoIndicesBegin.mGroupIndex, lineLayout.mWordGroupsLayoutInfo.begin() + textInfoIndicesEnd.mGroupIndex );
896
897     // Update line info.
898     lineLayout.mNumberOfCharacters -= numberOfCharacters;
899     lineLayout.mSize = Size();
900     lineLayout.mAscender = 0;
901     for( WordGroupLayoutInfoContainer::const_iterator it = lineLayout.mWordGroupsLayoutInfo.begin(), endIt = lineLayout.mWordGroupsLayoutInfo.end();
902          it != endIt;
903          ++it )
904     {
905       const WordGroupLayoutInfo& layoutInfo( *it );
906       UpdateSize( lineLayout.mSize, layoutInfo.mSize );
907       lineLayout.mAscender = std::max( lineLayout.mAscender, layoutInfo.mAscender );
908     }
909     lineLayout.mSize.height += layoutParameters.mLineHeightOffset;
910     lineLayout.mLineHeightOffset = layoutParameters.mLineHeightOffset;
911   }// end delete text from same line.
912
913   if( mergeLines )
914   {
915     // Merges lines pointed by textInfoMergeIndicesBegin.mLineIndex and textInfoMergeIndicesEnd.mLineIndex calculated previously.
916
917     LineLayoutInfo& firstLineLayout( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoMergeIndicesBegin.mLineIndex ) );
918
919     const LineLayoutInfo& lastLineLayout( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoMergeIndicesEnd.mLineIndex ) );
920
921     MergeLine( firstLineLayout,
922                lastLineLayout );
923   }
924
925   // Store text-actors before removing them.
926   const std::size_t endIndex = ( mergeLines && ( textInfoIndicesEnd.mLineIndex > 0 ) ) ? textInfoIndicesEnd.mLineIndex - 1 : textInfoIndicesEnd.mLineIndex; // text-actors from the last line may have been added in the merge above.
927   CollectTextActorsFromLines( removedTextActorsFromMid,
928                               relayoutData.mTextLayoutInfo,
929                               textInfoIndicesBegin.mLineIndex,
930                               endIndex );
931
932   // Remove unwanted lines using previously calculated indices. (including the last part of the merged line)
933   relayoutData.mTextLayoutInfo.mLinesLayoutInfo.erase( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoIndicesBegin.mLineIndex,
934                                                        relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin() + textInfoIndicesEnd.mLineIndex );
935
936   // Update text info.
937   UpdateTextLayoutInfo( relayoutData.mTextLayoutInfo );
938
939   // If the last character of the last line is a new line character, an empty line need to be added.
940   if( !relayoutData.mTextLayoutInfo.mLinesLayoutInfo.empty() )
941   {
942     const WordLayoutInfo lastWordLayout = GetLastWordLayoutInfo( *( relayoutData.mTextLayoutInfo.mLinesLayoutInfo.end() - 1 ) );
943
944     if( LineSeparator == lastWordLayout.mType )
945     {
946       LineLayoutInfo lastLineLayout;
947
948       const CharacterLayoutInfo layoutInfo = GetLastCharacterLayoutInfo( lastWordLayout );
949       lastLineLayout.mSize.height = layoutInfo.mSize.height;
950
951       relayoutData.mTextLayoutInfo.mLinesLayoutInfo.push_back( lastLineLayout );
952
953       relayoutData.mTextLayoutInfo.mWholeTextSize.height += layoutInfo.mSize.height;
954     }
955   }
956
957   // Clear the text from the text-actors if required.
958   if( CLEAR_TEXT == clearText )
959   {
960     ClearText( removedTextActorsFromEnd );
961     ClearText( removedTextActorsFromMid );
962     ClearText( removedTextActorsFromBegin );
963   }
964
965   // Insert text-actors into the cache.
966   // Text-actors are inserted in reverse order to use first the first removed.
967   relayoutData.mTextActorCache.InsertTextActors( removedTextActorsFromEnd );
968   relayoutData.mTextActorCache.InsertTextActors( removedTextActorsFromMid );
969   relayoutData.mTextActorCache.InsertTextActors( removedTextActorsFromBegin );
970 }
971
972 void UpdateTextInfo( const std::size_t position,
973                      const std::size_t numberOfCharacters,
974                      const MarkupProcessor::StyledTextArray& text,
975                      const TextView::LayoutParameters& layoutParameters,
976                      TextView::RelayoutData& relayoutData )
977 {
978   // Replaces 'numberOfCharacters' of text starting from 'position' with the given text.
979
980   // TODO: Temporary implementation with remove and insert.
981
982   // Remove.
983   UpdateTextInfo( position,
984                   numberOfCharacters,
985                   layoutParameters,
986                   relayoutData,
987                   KEEP_TEXT ); // Do not clear the text from the text-actors.
988
989   // Insert.
990   UpdateTextInfo( position,
991                   text,
992                   layoutParameters,
993                   relayoutData );
994 }
995
996 void UpdateTextInfo( const float lineHeightOffset,
997                      TextLayoutInfo& textLayoutInfo )
998 {
999   // Updates the space between lines with the new offset value.
1000
1001   float newTextHeight = 0.f;
1002
1003   for( LineLayoutInfoContainer::iterator lineIt = textLayoutInfo.mLinesLayoutInfo.begin(), lineEndIt = textLayoutInfo.mLinesLayoutInfo.end();
1004        lineIt != lineEndIt;
1005        ++lineIt )
1006   {
1007     LineLayoutInfo& lineLayoutInfo( *lineIt );
1008
1009     lineLayoutInfo.mSize.height += ( lineHeightOffset - lineLayoutInfo.mLineHeightOffset );
1010     newTextHeight += lineLayoutInfo.mSize.height;
1011
1012     lineLayoutInfo.mLineHeightOffset = lineHeightOffset;
1013   }
1014
1015   textLayoutInfo.mWholeTextSize.height = newTextHeight;
1016 }
1017
1018 void UpdateTextInfo( const TextStyle& style,
1019                      const TextStyle::Mask mask,
1020                      TextView::RelayoutData& relayoutData )
1021 {
1022   // Change text style for all text-actors.
1023
1024   for( LineLayoutInfoContainer::iterator lineIt = relayoutData.mTextLayoutInfo.mLinesLayoutInfo.begin(), lineEndIt = relayoutData.mTextLayoutInfo.mLinesLayoutInfo.end();
1025        lineIt != lineEndIt;
1026        ++lineIt )
1027   {
1028     LineLayoutInfo& line( *lineIt );
1029
1030     for( WordGroupLayoutInfoContainer::iterator groupIt = line.mWordGroupsLayoutInfo.begin(), groupEndIt = line.mWordGroupsLayoutInfo.end();
1031          groupIt != groupEndIt;
1032          ++groupIt )
1033     {
1034       WordGroupLayoutInfo& group( *groupIt );
1035
1036       for( WordLayoutInfoContainer::iterator wordIt = group.mWordsLayoutInfo.begin(), wordEndIt = group.mWordsLayoutInfo.end();
1037            wordIt != wordEndIt;
1038            ++wordIt )
1039       {
1040         WordLayoutInfo& word( *wordIt );
1041
1042         for( CharacterLayoutInfoContainer::iterator characterIt = word.mCharactersLayoutInfo.begin(), characterEndIt = word.mCharactersLayoutInfo.end();
1043              characterIt != characterEndIt;
1044              ++characterIt )
1045         {
1046           CharacterLayoutInfo& characterLayout( *characterIt );
1047
1048           characterLayout.mStyledText.mStyle.Copy( style, mask );
1049
1050           // Checks if the font family supports all glyphs. If not, chooses a most suitable one.
1051           ChooseFontFamilyName( characterLayout.mStyledText );
1052
1053           // Mark the character to be set the new style into the text-actor.
1054           characterLayout.mSetStyle = true;
1055         } // end characters
1056       } // end words
1057     } // end group of words
1058   } // end lines
1059 }
1060
1061 void InitializeTextActorInfo( TextView::RelayoutData& relayoutData )
1062 {
1063   TextLayoutInfo& textLayoutInfo = relayoutData.mTextLayoutInfo;
1064   if( textLayoutInfo.mLinesLayoutInfo.empty() )
1065   {
1066     // nothing to do if there is no lines.
1067     return;
1068   }
1069
1070   std::size_t characterGlobalIndex = 0;  // Index to the global character (within the whole text).
1071   std::size_t lineLayoutInfoIndex = 0;   // Index to the laid out line info.
1072   const std::size_t lineLayoutInfoSize = relayoutData.mLines.size(); // Number or laid out lines.
1073   bool lineLayoutEnd = false;            // Whether lineLayoutInfoIndex points at the last laid out line.
1074   bool glyphActorCreatedForLine = false; // Whether a renderable actor has been created for this line.
1075
1076   RenderableActor currentGlyphActor;      // text-actor used when the edit mode is disabled.
1077   TextStyle currentStyle;                // style for the current text-actor.
1078   Vector4 currentGradientColor;          // gradient color for the current text-actor.
1079   Vector2 currentStartPoint;             // start point for the current text-actor.
1080   Vector2 currentEndPoint;               // end point for the current text-actor.
1081   bool currentIsColorGlyph = false;      // Whether current glyph is an emoticon.
1082
1083   std::vector<TextActor> textActorsToRemove; // Keep a vector of text-actors to be included into the cache.
1084
1085   for( LineLayoutInfoContainer::iterator lineIt = textLayoutInfo.mLinesLayoutInfo.begin(), lineEndIt = textLayoutInfo.mLinesLayoutInfo.end();
1086        lineIt != lineEndIt;
1087        ++lineIt )
1088   {
1089     LineLayoutInfo& line( *lineIt );
1090
1091     for( WordGroupLayoutInfoContainer::iterator groupIt = line.mWordGroupsLayoutInfo.begin(), groupEndIt = line.mWordGroupsLayoutInfo.end();
1092          groupIt != groupEndIt;
1093          ++groupIt )
1094     {
1095       WordGroupLayoutInfo& group( *groupIt );
1096
1097       for( WordLayoutInfoContainer::iterator wordIt = group.mWordsLayoutInfo.begin(), wordEndIt = group.mWordsLayoutInfo.end();
1098            wordIt != wordEndIt;
1099            ++wordIt )
1100       {
1101         WordLayoutInfo& word( *wordIt );
1102
1103         for( CharacterLayoutInfoContainer::iterator characterIt = word.mCharactersLayoutInfo.begin(), characterEndIt = word.mCharactersLayoutInfo.end();
1104              characterIt != characterEndIt;
1105              ++characterIt )
1106         {
1107           CharacterLayoutInfo& characterLayout( *characterIt );
1108
1109           // Check if there is a new line.
1110           const bool newLine = !lineLayoutEnd && ( characterGlobalIndex == relayoutData.mLines[lineLayoutInfoIndex].mCharacterGlobalIndex );
1111
1112           if( newLine )
1113           {
1114             // Point to the next line.
1115             ++lineLayoutInfoIndex;
1116             if( lineLayoutInfoIndex >= lineLayoutInfoSize )
1117             {
1118               // Arrived at last line.
1119               lineLayoutEnd = true; // Avoids access out of bounds in the relayoutData.mLines vector.
1120             }
1121             glyphActorCreatedForLine = false;
1122           }
1123
1124           if( !characterLayout.mStyledText.mText.IsEmpty() )
1125           {
1126             // Do not create a glyph-actor if there is no text.
1127             const Character character = characterLayout.mStyledText.mText[0]; // there are only one character per character layout.
1128
1129             if( characterLayout.mIsColorGlyph ||
1130                 !character.IsWhiteSpace() || // A new line character is also a white space.
1131                 ( character.IsWhiteSpace() && characterLayout.mStyledText.mStyle.GetUnderline() ) )
1132             {
1133               // Do not create a glyph-actor if it's a white space (without underline) or a new line character.
1134
1135               // Creates one glyph-actor per each counsecutive group of characters, with the same style, per line, or if it's an emoticon.
1136
1137               if( !glyphActorCreatedForLine ||
1138                   characterLayout.mIsColorGlyph ||
1139                   ( characterLayout.mStyledText.mStyle != currentStyle ) ||
1140                   ( characterLayout.mGradientColor != currentGradientColor ) ||
1141                   ( characterLayout.mStartPoint != currentStartPoint ) ||
1142                   ( characterLayout.mEndPoint != currentEndPoint ) ||
1143                   ( characterLayout.mIsColorGlyph != currentIsColorGlyph ) )
1144               {
1145                 characterLayout.mSetText = false;
1146                 characterLayout.mSetStyle = false;
1147
1148                 // There is a new style or a new line.
1149                 glyphActorCreatedForLine = true;
1150
1151                 if( characterLayout.mIsColorGlyph )
1152                 {
1153                   ImageActor imageActor = ImageActor::DownCast( characterLayout.mGlyphActor );
1154                   if( !imageActor )
1155                   {
1156                     characterLayout.mGlyphActor = ImageActor::New();
1157                     characterLayout.mSetText = true;
1158                   }
1159                 }
1160                 else
1161                 {
1162                   TextActor textActor = TextActor::DownCast( characterLayout.mGlyphActor );
1163
1164                   if( textActor )
1165                   {
1166                     // Try to reuse first the text-actor of this character.
1167                     textActor.SetTextStyle( characterLayout.mStyledText.mStyle );
1168                     currentGlyphActor = textActor;
1169                   }
1170                   else
1171                   {
1172                     // If there is no text-actor, try to retrieve one from the cache.
1173                     textActor = relayoutData.mTextActorCache.RetrieveTextActor();
1174
1175                     // If still there is no text-actor, create one.
1176                     if( !textActor )
1177                     {
1178                       textActor = TextActor::New( Text(), characterLayout.mStyledText.mStyle, false, true );
1179                     }
1180                     else
1181                     {
1182                       textActor.SetTextStyle( characterLayout.mStyledText.mStyle );
1183                     }
1184
1185                     currentGlyphActor = textActor;
1186                   }
1187                   characterLayout.mGlyphActor = currentGlyphActor;
1188                 }
1189
1190                 // Update style to be checked with next characters.
1191                 currentStyle = characterLayout.mStyledText.mStyle;
1192                 currentGradientColor = characterLayout.mGradientColor;
1193                 currentStartPoint = characterLayout.mStartPoint;
1194                 currentEndPoint = characterLayout.mEndPoint;
1195                 currentIsColorGlyph = characterLayout.mIsColorGlyph;
1196
1197                 characterLayout.mGlyphActor.SetParentOrigin( ParentOrigin::TOP_LEFT );
1198                 characterLayout.mGlyphActor.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
1199               }
1200               else
1201               {
1202                 DALI_ASSERT_DEBUG( !characterLayout.mIsColorGlyph && "TextViewProcessor::InitializeTextActorInfo. An image-actor doesn't store more than one emoticon." );
1203
1204                 // Same style than previous one.
1205                 TextActor textActor = TextActor::DownCast( characterLayout.mGlyphActor );
1206                 if( textActor )
1207                 {
1208                   // There is a previously created text-actor for this character.
1209                   // If this character has another one put it into the cache.
1210                   textActor.SetText( "" );
1211                   textActorsToRemove.push_back( textActor );
1212                 }
1213
1214                 if( characterLayout.mGlyphActor )
1215                 {
1216                   characterLayout.mGlyphActor.Reset();
1217                 }
1218               }
1219             } // no white space / new line char
1220           } // text not empty
1221
1222           ++characterGlobalIndex;
1223         } // characters
1224       } // words
1225     } // groups
1226   } // lines
1227
1228   // Insert the spare text-actors into the cache.
1229   relayoutData.mTextActorCache.InsertTextActors( textActorsToRemove );
1230 }
1231
1232 } // namespace TextViewProcessor
1233
1234 } // namespace Internal
1235
1236 } // namespace Toolkit
1237
1238 } // namespace Dali