318c19609a93b11b13283e02db8041c71ce78b22
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / text / text-controller-impl.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-controller-impl.h>
20
21 // EXTERNAL INCLUDES
22 #include <dali/devel-api/adaptor-framework/window-devel.h>
23 #include <dali/integration-api/debug.h>
24 #include <dali/public-api/actors/layer.h>
25 #include <dali/public-api/rendering/renderer.h>
26 #include <cmath>
27
28 // INTERNAL INCLUDES
29 #include <dali-toolkit/internal/text/character-set-conversion.h>
30 #include <dali-toolkit/internal/text/cursor-helper-functions.h>
31 #include <dali-toolkit/internal/text/glyph-metrics-helper.h>
32 #include <dali-toolkit/internal/text/text-control-interface.h>
33 #include <dali-toolkit/internal/text/text-controller-impl-data-clearer.h>
34 #include <dali-toolkit/internal/text/text-controller-impl-event-handler.h>
35 #include <dali-toolkit/internal/text/text-controller-impl-model-updater.h>
36 #include <dali-toolkit/internal/text/text-controller-placeholder-handler.h>
37 #include <dali-toolkit/internal/text/text-controller-relayouter.h>
38 #include <dali-toolkit/internal/text/text-editable-control-interface.h>
39 #include <dali-toolkit/internal/text/text-enumerations-impl.h>
40 #include <dali-toolkit/internal/text/text-run-container.h>
41 #include <dali-toolkit/internal/text/text-selection-handle-controller.h>
42 #include <dali-toolkit/internal/text/underlined-glyph-run.h>
43
44 using namespace Dali;
45
46 namespace
47 {
48 #if defined(DEBUG_ENABLED)
49 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
50 #endif
51
52 constexpr float MAX_FLOAT = std::numeric_limits<float>::max();
53
54 const std::string EMPTY_STRING("");
55
56 } // namespace
57
58 namespace Dali::Toolkit::Text
59 {
60 namespace
61 {
62 void SetDefaultInputStyle(InputStyle& inputStyle, const FontDefaults* const fontDefaults, const Vector4& textColor)
63 {
64   // Sets the default text's color.
65   inputStyle.textColor      = textColor;
66   inputStyle.isDefaultColor = true;
67
68   inputStyle.familyName.clear();
69   inputStyle.weight = TextAbstraction::FontWeight::NORMAL;
70   inputStyle.width  = TextAbstraction::FontWidth::NORMAL;
71   inputStyle.slant  = TextAbstraction::FontSlant::NORMAL;
72   inputStyle.size   = 0.f;
73
74   inputStyle.lineSpacing = 0.f;
75
76   inputStyle.underlineProperties.clear();
77   inputStyle.shadowProperties.clear();
78   inputStyle.embossProperties.clear();
79   inputStyle.outlineProperties.clear();
80
81   inputStyle.isFamilyDefined = false;
82   inputStyle.isWeightDefined = false;
83   inputStyle.isWidthDefined  = false;
84   inputStyle.isSlantDefined  = false;
85   inputStyle.isSizeDefined   = false;
86
87   inputStyle.isLineSpacingDefined = false;
88
89   inputStyle.isUnderlineDefined = false;
90   inputStyle.isShadowDefined    = false;
91   inputStyle.isEmbossDefined    = false;
92   inputStyle.isOutlineDefined   = false;
93
94   // Sets the default font's family name, weight, width, slant and size.
95   if(fontDefaults)
96   {
97     if(fontDefaults->familyDefined)
98     {
99       inputStyle.familyName      = fontDefaults->mFontDescription.family;
100       inputStyle.isFamilyDefined = true;
101     }
102
103     if(fontDefaults->weightDefined)
104     {
105       inputStyle.weight          = fontDefaults->mFontDescription.weight;
106       inputStyle.isWeightDefined = true;
107     }
108
109     if(fontDefaults->widthDefined)
110     {
111       inputStyle.width          = fontDefaults->mFontDescription.width;
112       inputStyle.isWidthDefined = true;
113     }
114
115     if(fontDefaults->slantDefined)
116     {
117       inputStyle.slant          = fontDefaults->mFontDescription.slant;
118       inputStyle.isSlantDefined = true;
119     }
120
121     if(fontDefaults->sizeDefined)
122     {
123       inputStyle.size          = fontDefaults->mDefaultPointSize;
124       inputStyle.isSizeDefined = true;
125     }
126   }
127 }
128
129 void ChangeTextControllerState(Controller::Impl& impl, EventData::State newState)
130 {
131   EventData* eventData = impl.mEventData;
132
133   if(nullptr == eventData)
134   {
135     // Nothing to do if there is no text input.
136     return;
137   }
138
139   DecoratorPtr& decorator = eventData->mDecorator;
140   if(!decorator)
141   {
142     // Nothing to do if there is no decorator.
143     return;
144   }
145
146   DALI_LOG_INFO(gLogFilter, Debug::General, "ChangeState state:%d  newstate:%d\n", eventData->mState, newState);
147
148   if(eventData->mState != newState)
149   {
150     eventData->mPreviousState = eventData->mState;
151     eventData->mState         = newState;
152
153     switch(eventData->mState)
154     {
155       case EventData::INACTIVE:
156       {
157         decorator->SetActiveCursor(ACTIVE_CURSOR_NONE);
158         decorator->StopCursorBlink();
159         decorator->SetHandleActive(GRAB_HANDLE, false);
160         decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
161         decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
162         decorator->SetHighlightActive(false);
163         decorator->SetPopupActive(false);
164         eventData->mDecoratorUpdated = true;
165         break;
166       }
167
168       case EventData::INTERRUPTED:
169       {
170         decorator->SetHandleActive(GRAB_HANDLE, false);
171         decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
172         decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
173         decorator->SetHighlightActive(false);
174         decorator->SetPopupActive(false);
175         eventData->mDecoratorUpdated = true;
176         break;
177       }
178
179       case EventData::SELECTING:
180       {
181         decorator->SetActiveCursor(ACTIVE_CURSOR_NONE);
182         decorator->StopCursorBlink();
183         decorator->SetHandleActive(GRAB_HANDLE, false);
184         if(eventData->mGrabHandleEnabled)
185         {
186           decorator->SetHandleActive(LEFT_SELECTION_HANDLE, true);
187           decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, true);
188         }
189         decorator->SetHighlightActive(true);
190         if(eventData->mGrabHandlePopupEnabled)
191         {
192           impl.SetPopupButtons();
193           decorator->SetPopupActive(true);
194         }
195         eventData->mDecoratorUpdated = true;
196         break;
197       }
198
199       case EventData::EDITING:
200       {
201         decorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
202         if(eventData->mCursorBlinkEnabled)
203         {
204           decorator->StartCursorBlink();
205         }
206         // Grab handle is not shown until a tap is received whilst EDITING
207         decorator->SetHandleActive(GRAB_HANDLE, false);
208         decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
209         decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
210         decorator->SetHighlightActive(false);
211         if(eventData->mGrabHandlePopupEnabled)
212         {
213           decorator->SetPopupActive(false);
214         }
215         eventData->mDecoratorUpdated = true;
216         break;
217       }
218       case EventData::EDITING_WITH_POPUP:
219       {
220         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "EDITING_WITH_POPUP \n", newState);
221
222         decorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
223         if(eventData->mCursorBlinkEnabled)
224         {
225           decorator->StartCursorBlink();
226         }
227         if(eventData->mSelectionEnabled)
228         {
229           decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
230           decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
231           decorator->SetHighlightActive(false);
232         }
233         else if(eventData->mGrabHandleEnabled)
234         {
235           decorator->SetHandleActive(GRAB_HANDLE, true);
236         }
237         if(eventData->mGrabHandlePopupEnabled)
238         {
239           impl.SetPopupButtons();
240           decorator->SetPopupActive(true);
241         }
242         eventData->mDecoratorUpdated = true;
243         break;
244       }
245       case EventData::EDITING_WITH_GRAB_HANDLE:
246       {
247         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "EDITING_WITH_GRAB_HANDLE \n", newState);
248
249         decorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
250         if(eventData->mCursorBlinkEnabled)
251         {
252           decorator->StartCursorBlink();
253         }
254         // Grab handle is not shown until a tap is received whilst EDITING
255         if(eventData->mGrabHandleEnabled)
256         {
257           decorator->SetHandleActive(GRAB_HANDLE, true);
258         }
259         decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
260         decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
261         decorator->SetHighlightActive(false);
262         if(eventData->mGrabHandlePopupEnabled)
263         {
264           decorator->SetPopupActive(false);
265         }
266         eventData->mDecoratorUpdated = true;
267         break;
268       }
269
270       case EventData::SELECTION_HANDLE_PANNING:
271       {
272         decorator->SetActiveCursor(ACTIVE_CURSOR_NONE);
273         decorator->StopCursorBlink();
274         decorator->SetHandleActive(GRAB_HANDLE, false);
275         if(eventData->mGrabHandleEnabled)
276         {
277           decorator->SetHandleActive(LEFT_SELECTION_HANDLE, true);
278           decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, true);
279         }
280         decorator->SetHighlightActive(true);
281         if(eventData->mGrabHandlePopupEnabled)
282         {
283           decorator->SetPopupActive(false);
284         }
285         eventData->mDecoratorUpdated = true;
286         break;
287       }
288
289       case EventData::GRAB_HANDLE_PANNING:
290       {
291         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "GRAB_HANDLE_PANNING \n", newState);
292
293         decorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
294         if(eventData->mCursorBlinkEnabled)
295         {
296           decorator->StartCursorBlink();
297         }
298         if(eventData->mGrabHandleEnabled)
299         {
300           decorator->SetHandleActive(GRAB_HANDLE, true);
301         }
302         decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
303         decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
304         decorator->SetHighlightActive(false);
305         if(eventData->mGrabHandlePopupEnabled)
306         {
307           decorator->SetPopupActive(false);
308         }
309         eventData->mDecoratorUpdated = true;
310         break;
311       }
312
313       case EventData::EDITING_WITH_PASTE_POPUP:
314       {
315         DALI_LOG_INFO(gLogFilter, Debug::Verbose, "EDITING_WITH_PASTE_POPUP \n", newState);
316
317         decorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
318         if(eventData->mCursorBlinkEnabled)
319         {
320           decorator->StartCursorBlink();
321         }
322
323         if(eventData->mGrabHandleEnabled)
324         {
325           decorator->SetHandleActive(GRAB_HANDLE, true);
326         }
327         decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
328         decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
329         decorator->SetHighlightActive(false);
330
331         if(eventData->mGrabHandlePopupEnabled)
332         {
333           impl.SetPopupButtons();
334           decorator->SetPopupActive(true);
335         }
336         eventData->mDecoratorUpdated = true;
337         break;
338       }
339
340       case EventData::TEXT_PANNING:
341       {
342         decorator->SetActiveCursor(ACTIVE_CURSOR_NONE);
343         decorator->StopCursorBlink();
344         decorator->SetHandleActive(GRAB_HANDLE, false);
345         if(eventData->mDecorator->IsHandleActive(LEFT_SELECTION_HANDLE) ||
346            decorator->IsHandleActive(RIGHT_SELECTION_HANDLE))
347         {
348           decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
349           decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
350           decorator->SetHighlightActive(true);
351         }
352
353         if(eventData->mGrabHandlePopupEnabled)
354         {
355           decorator->SetPopupActive(false);
356         }
357
358         eventData->mDecoratorUpdated = true;
359         break;
360       }
361     }
362   }
363 }
364
365 } // unnamed Namespace
366
367 EventData::EventData(DecoratorPtr decorator, InputMethodContext& inputMethodContext)
368 : mDecorator(decorator),
369   mInputMethodContext(inputMethodContext),
370   mPlaceholderFont(nullptr),
371   mPlaceholderTextActive(),
372   mPlaceholderTextInactive(),
373   mPlaceholderTextColor(0.8f, 0.8f, 0.8f, 0.8f), // This color has been published in the Public API (placeholder-properties.h).
374   mEventQueue(),
375   mInputStyleChangedQueue(),
376   mPreviousState(INACTIVE),
377   mState(INACTIVE),
378   mPrimaryCursorPosition(0u),
379   mLeftSelectionPosition(0u),
380   mRightSelectionPosition(0u),
381   mPreEditStartPosition(0u),
382   mPreEditLength(0u),
383   mCursorHookPositionX(0.f),
384   mDoubleTapAction(Controller::NoTextTap::NO_ACTION),
385   mLongPressAction(Controller::NoTextTap::SHOW_SELECTION_POPUP),
386   mIsShowingPlaceholderText(false),
387   mPreEditFlag(false),
388   mDecoratorUpdated(false),
389   mCursorBlinkEnabled(true),
390   mGrabHandleEnabled(true),
391   mGrabHandlePopupEnabled(true),
392   mSelectionEnabled(true),
393   mUpdateCursorHookPosition(false),
394   mUpdateCursorPosition(false),
395   mUpdateGrabHandlePosition(false),
396   mUpdateLeftSelectionPosition(false),
397   mUpdateRightSelectionPosition(false),
398   mIsLeftHandleSelected(false),
399   mIsRightHandleSelected(false),
400   mUpdateHighlightBox(false),
401   mScrollAfterUpdatePosition(false),
402   mScrollAfterDelete(false),
403   mAllTextSelected(false),
404   mUpdateInputStyle(false),
405   mPasswordInput(false),
406   mCheckScrollAmount(false),
407   mIsPlaceholderPixelSize(false),
408   mIsPlaceholderElideEnabled(false),
409   mPlaceholderEllipsisFlag(false),
410   mShiftSelectionFlag(true),
411   mUpdateAlignment(false),
412   mEditingEnabled(true)
413 {
414 }
415
416 bool Controller::Impl::ProcessInputEvents()
417 {
418   return ControllerImplEventHandler::ProcessInputEvents(*this);
419 }
420
421 void Controller::Impl::NotifyInputMethodContext()
422 {
423   if(mEventData && mEventData->mInputMethodContext)
424   {
425     CharacterIndex cursorPosition = GetLogicalCursorPosition();
426
427     const Length numberOfWhiteSpaces = GetNumberOfWhiteSpaces(0u);
428
429     // Update the cursor position by removing the initial white spaces.
430     if(cursorPosition < numberOfWhiteSpaces)
431     {
432       cursorPosition = 0u;
433     }
434     else
435     {
436       cursorPosition -= numberOfWhiteSpaces;
437     }
438
439     mEventData->mInputMethodContext.SetCursorPosition(cursorPosition);
440     mEventData->mInputMethodContext.NotifyCursorPosition();
441   }
442 }
443
444 void Controller::Impl::NotifyInputMethodContextMultiLineStatus()
445 {
446   if(mEventData && mEventData->mInputMethodContext)
447   {
448     Text::Layout::Engine::Type layout = mLayoutEngine.GetLayout();
449     mEventData->mInputMethodContext.NotifyTextInputMultiLine(layout == Text::Layout::Engine::MULTI_LINE_BOX);
450   }
451 }
452
453 CharacterIndex Controller::Impl::GetLogicalCursorPosition() const
454 {
455   CharacterIndex cursorPosition = 0u;
456
457   if(mEventData)
458   {
459     if((EventData::SELECTING == mEventData->mState) ||
460        (EventData::SELECTION_HANDLE_PANNING == mEventData->mState))
461     {
462       cursorPosition = std::min(mEventData->mRightSelectionPosition, mEventData->mLeftSelectionPosition);
463     }
464     else
465     {
466       cursorPosition = mEventData->mPrimaryCursorPosition;
467     }
468   }
469
470   return cursorPosition;
471 }
472
473 Length Controller::Impl::GetNumberOfWhiteSpaces(CharacterIndex index) const
474 {
475   Length numberOfWhiteSpaces = 0u;
476
477   // Get the buffer to the text.
478   Character* utf32CharacterBuffer = mModel->mLogicalModel->mText.Begin();
479
480   const Length totalNumberOfCharacters = mModel->mLogicalModel->mText.Count();
481   for(; index < totalNumberOfCharacters; ++index, ++numberOfWhiteSpaces)
482   {
483     if(!TextAbstraction::IsWhiteSpace(*(utf32CharacterBuffer + index)))
484     {
485       break;
486     }
487   }
488
489   return numberOfWhiteSpaces;
490 }
491
492 void Controller::Impl::GetText(std::string& text) const
493 {
494   if(!IsShowingPlaceholderText())
495   {
496     // Retrieves the text string.
497     GetText(0u, text);
498   }
499   else
500   {
501     DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::GetText %p empty (but showing placeholder)\n", this);
502   }
503 }
504
505 void Controller::Impl::GetText(CharacterIndex index, std::string& text) const
506 {
507   // Get the total number of characters.
508   Length numberOfCharacters = mModel->mLogicalModel->mText.Count();
509
510   // Retrieve the text.
511   if(0u != numberOfCharacters)
512   {
513     Utf32ToUtf8(mModel->mLogicalModel->mText.Begin() + index, numberOfCharacters - index, text);
514   }
515 }
516
517 Dali::LayoutDirection::Type Controller::Impl::GetLayoutDirection(Dali::Actor& actor) const
518 {
519   if(mModel->mMatchLayoutDirection == DevelText::MatchLayoutDirection::LOCALE ||
520      (mModel->mMatchLayoutDirection == DevelText::MatchLayoutDirection::INHERIT && !mIsLayoutDirectionChanged))
521   {
522     return static_cast<Dali::LayoutDirection::Type>(DevelWindow::Get(actor).GetRootLayer().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
523   }
524   else
525   {
526     return static_cast<Dali::LayoutDirection::Type>(actor.GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
527   }
528 }
529
530 Toolkit::DevelText::TextDirection::Type Controller::Impl::GetTextDirection()
531 {
532   if(mUpdateTextDirection)
533   {
534     // Operations that can be done only once until the text changes.
535     const OperationsMask onlyOnceOperations = static_cast<OperationsMask>(CONVERT_TO_UTF32 |
536                                                                           GET_SCRIPTS |
537                                                                           VALIDATE_FONTS |
538                                                                           GET_LINE_BREAKS |
539                                                                           BIDI_INFO |
540                                                                           SHAPE_TEXT |
541                                                                           GET_GLYPH_METRICS);
542
543     // Set the update info to relayout the whole text.
544     mTextUpdateInfo.mParagraphCharacterIndex     = 0u;
545     mTextUpdateInfo.mRequestedNumberOfCharacters = mModel->mLogicalModel->mText.Count();
546
547     // Make sure the model is up-to-date before layouting
548     UpdateModel(onlyOnceOperations);
549
550     Vector3 naturalSize;
551     Relayouter::DoRelayout(*this,
552                            Size(MAX_FLOAT, MAX_FLOAT),
553                            static_cast<OperationsMask>(onlyOnceOperations |
554                                                        LAYOUT | REORDER | UPDATE_DIRECTION),
555                            naturalSize.GetVectorXY());
556
557     // Do not do again the only once operations.
558     mOperationsPending = static_cast<OperationsMask>(mOperationsPending & ~onlyOnceOperations);
559
560     // Clear the update info. This info will be set the next time the text is updated.
561     mTextUpdateInfo.Clear();
562
563     // FullRelayoutNeeded should be true because DoRelayout is MAX_FLOAT, MAX_FLOAT.
564     mTextUpdateInfo.mFullRelayoutNeeded = true;
565
566     mUpdateTextDirection = false;
567   }
568
569   return mIsTextDirectionRTL ? Toolkit::DevelText::TextDirection::RIGHT_TO_LEFT : Toolkit::DevelText::TextDirection::LEFT_TO_RIGHT;
570 }
571
572 void Controller::Impl::CalculateTextUpdateIndices(Length& numberOfCharacters)
573 {
574   mTextUpdateInfo.mParagraphCharacterIndex = 0u;
575   mTextUpdateInfo.mStartGlyphIndex         = 0u;
576   mTextUpdateInfo.mStartLineIndex          = 0u;
577   numberOfCharacters                       = 0u;
578
579   const Length numberOfParagraphs = mModel->mLogicalModel->mParagraphInfo.Count();
580   if(0u == numberOfParagraphs)
581   {
582     mTextUpdateInfo.mParagraphCharacterIndex = 0u;
583     numberOfCharacters                       = 0u;
584
585     mTextUpdateInfo.mRequestedNumberOfCharacters = mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove;
586
587     // Nothing else to do if there are no paragraphs.
588     return;
589   }
590
591   // Find the paragraphs to be updated.
592   Vector<ParagraphRunIndex> paragraphsToBeUpdated;
593   if(mTextUpdateInfo.mCharacterIndex >= mTextUpdateInfo.mPreviousNumberOfCharacters)
594   {
595     // Text is being added at the end of the current text.
596     if(mTextUpdateInfo.mIsLastCharacterNewParagraph)
597     {
598       // Text is being added in a new paragraph after the last character of the text.
599       mTextUpdateInfo.mParagraphCharacterIndex     = mTextUpdateInfo.mPreviousNumberOfCharacters;
600       numberOfCharacters                           = 0u;
601       mTextUpdateInfo.mRequestedNumberOfCharacters = mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove;
602
603       mTextUpdateInfo.mStartGlyphIndex = mModel->mVisualModel->mGlyphs.Count();
604       mTextUpdateInfo.mStartLineIndex  = mModel->mVisualModel->mLines.Count() - 1u;
605
606       // Nothing else to do;
607       return;
608     }
609
610     paragraphsToBeUpdated.PushBack(numberOfParagraphs - 1u);
611   }
612   else
613   {
614     Length numberOfCharactersToUpdate = 0u;
615     if(mTextUpdateInfo.mFullRelayoutNeeded)
616     {
617       numberOfCharactersToUpdate = mTextUpdateInfo.mPreviousNumberOfCharacters;
618     }
619     else
620     {
621       numberOfCharactersToUpdate = (mTextUpdateInfo.mNumberOfCharactersToRemove > 0u) ? mTextUpdateInfo.mNumberOfCharactersToRemove : 1u;
622     }
623     mModel->mLogicalModel->FindParagraphs(mTextUpdateInfo.mCharacterIndex,
624                                           numberOfCharactersToUpdate,
625                                           paragraphsToBeUpdated);
626   }
627
628   if(0u != paragraphsToBeUpdated.Count())
629   {
630     const ParagraphRunIndex firstParagraphIndex = *(paragraphsToBeUpdated.Begin());
631     const ParagraphRun&     firstParagraph      = *(mModel->mLogicalModel->mParagraphInfo.Begin() + firstParagraphIndex);
632     mTextUpdateInfo.mParagraphCharacterIndex    = firstParagraph.characterRun.characterIndex;
633
634     ParagraphRunIndex   lastParagraphIndex = *(paragraphsToBeUpdated.End() - 1u);
635     const ParagraphRun& lastParagraph      = *(mModel->mLogicalModel->mParagraphInfo.Begin() + lastParagraphIndex);
636
637     if((mTextUpdateInfo.mNumberOfCharactersToRemove > 0u) &&                                           // Some character are removed.
638        (lastParagraphIndex < numberOfParagraphs - 1u) &&                                               // There is a next paragraph.
639        ((lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters) == // The last removed character is the new paragraph character.
640         (mTextUpdateInfo.mCharacterIndex + mTextUpdateInfo.mNumberOfCharactersToRemove)))
641     {
642       // The new paragraph character of the last updated paragraph has been removed so is going to be merged with the next one.
643       const ParagraphRun& lastParagraph = *(mModel->mLogicalModel->mParagraphInfo.Begin() + lastParagraphIndex + 1u);
644
645       numberOfCharacters = lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters - mTextUpdateInfo.mParagraphCharacterIndex;
646     }
647     else
648     {
649       numberOfCharacters = lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters - mTextUpdateInfo.mParagraphCharacterIndex;
650     }
651   }
652
653   mTextUpdateInfo.mRequestedNumberOfCharacters = numberOfCharacters + mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove;
654   mTextUpdateInfo.mStartGlyphIndex             = *(mModel->mVisualModel->mCharactersToGlyph.Begin() + mTextUpdateInfo.mParagraphCharacterIndex);
655 }
656
657 void Controller::Impl::ClearModelData(CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations)
658 {
659   ControllerImplDataClearer::ClearModelData(*this, startIndex, endIndex, operations);
660 }
661
662 bool Controller::Impl::UpdateModel(OperationsMask operationsRequired)
663 {
664   return ControllerImplModelUpdater::Update(*this, operationsRequired);
665 }
666
667 void Controller::Impl::RetrieveDefaultInputStyle(InputStyle& inputStyle)
668 {
669   SetDefaultInputStyle(inputStyle, mFontDefaults, mTextColor);
670 }
671
672 float Controller::Impl::GetDefaultFontLineHeight()
673 {
674   FontId defaultFontId = 0u;
675   if(nullptr == mFontDefaults)
676   {
677     TextAbstraction::FontDescription fontDescription;
678     defaultFontId = mFontClient.GetFontId(fontDescription, TextAbstraction::FontClient::DEFAULT_POINT_SIZE * GetFontSizeScale());
679   }
680   else
681   {
682     defaultFontId = mFontDefaults->GetFontId(mFontClient, mFontDefaults->mDefaultPointSize * GetFontSizeScale());
683   }
684
685   Text::FontMetrics fontMetrics;
686   mMetrics->GetFontMetrics(defaultFontId, fontMetrics);
687
688   return (fontMetrics.ascender - fontMetrics.descender);
689 }
690
691 bool Controller::Impl::SetDefaultLineSpacing(float lineSpacing)
692 {
693   if(std::fabs(lineSpacing - mLayoutEngine.GetDefaultLineSpacing()) > Math::MACHINE_EPSILON_1000)
694   {
695     mLayoutEngine.SetDefaultLineSpacing(lineSpacing);
696
697     RelayoutAllCharacters();
698     return true;
699   }
700   return false;
701 }
702
703 bool Controller::Impl::SetDefaultLineSize(float lineSize)
704 {
705   if(std::fabs(lineSize - mLayoutEngine.GetDefaultLineSize()) > Math::MACHINE_EPSILON_1000)
706   {
707     mLayoutEngine.SetDefaultLineSize(lineSize);
708
709     RelayoutAllCharacters();
710     return true;
711   }
712   return false;
713 }
714
715 bool Controller::Impl::SetRelativeLineSize(float relativeLineSize)
716 {
717   if(std::fabs(relativeLineSize - GetRelativeLineSize()) > Math::MACHINE_EPSILON_1000)
718   {
719     mLayoutEngine.SetRelativeLineSize(relativeLineSize);
720
721     RelayoutAllCharacters();
722     return true;
723   }
724   return false;
725 }
726
727 float Controller::Impl::GetRelativeLineSize()
728 {
729   return mLayoutEngine.GetRelativeLineSize();
730 }
731
732 string Controller::Impl::GetSelectedText()
733 {
734   string text;
735   if(EventData::SELECTING == mEventData->mState)
736   {
737     RetrieveSelection(text, false);
738   }
739   return text;
740 }
741
742 string Controller::Impl::CopyText()
743 {
744   string text;
745   RetrieveSelection(text, false);
746   SendSelectionToClipboard(false); // Text not modified
747
748   mEventData->mUpdateCursorPosition = true;
749
750   RequestRelayout(); // Cursor, Handles, Selection Highlight, Popup
751
752   return text;
753 }
754
755 string Controller::Impl::CutText()
756 {
757   string text;
758   RetrieveSelection(text, false);
759
760   if(!IsEditable())
761   {
762     return EMPTY_STRING;
763   }
764
765   SendSelectionToClipboard(true); // Synchronous call to modify text
766   mOperationsPending = ALL_OPERATIONS;
767
768   if((0u != mModel->mLogicalModel->mText.Count()) ||
769      !IsPlaceholderAvailable())
770   {
771     QueueModifyEvent(ModifyEvent::TEXT_DELETED);
772   }
773   else
774   {
775     PlaceholderHandler::ShowPlaceholderText(*this);
776   }
777
778   mEventData->mUpdateCursorPosition = true;
779   mEventData->mScrollAfterDelete    = true;
780
781   RequestRelayout();
782
783   if(nullptr != mEditableControlInterface)
784   {
785     mEditableControlInterface->TextChanged(true);
786   }
787   return text;
788 }
789
790 void Controller::Impl::SetTextSelectionRange(const uint32_t* pStart, const uint32_t* pEnd)
791 {
792   if(nullptr == mEventData)
793   {
794     // Nothing to do if there is no text.
795     return;
796   }
797
798   if(mEventData->mSelectionEnabled && (pStart || pEnd))
799   {
800     uint32_t length   = static_cast<uint32_t>(mModel->mLogicalModel->mText.Count());
801     uint32_t oldStart = mEventData->mLeftSelectionPosition;
802     uint32_t oldEnd   = mEventData->mRightSelectionPosition;
803
804     if(pStart)
805     {
806       mEventData->mLeftSelectionPosition = std::min(*pStart, length);
807     }
808     if(pEnd)
809     {
810       mEventData->mRightSelectionPosition = std::min(*pEnd, length);
811     }
812
813     if(mEventData->mLeftSelectionPosition == mEventData->mRightSelectionPosition)
814     {
815       ChangeState(EventData::EDITING);
816       mEventData->mPrimaryCursorPosition = mEventData->mLeftSelectionPosition = mEventData->mRightSelectionPosition;
817       mEventData->mUpdateCursorPosition                                       = true;
818     }
819     else
820     {
821       ChangeState(EventData::SELECTING);
822       mEventData->mUpdateHighlightBox           = true;
823       mEventData->mUpdateLeftSelectionPosition  = true;
824       mEventData->mUpdateRightSelectionPosition = true;
825     }
826
827     if(mSelectableControlInterface != nullptr)
828     {
829       mSelectableControlInterface->SelectionChanged(oldStart, oldEnd, mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition);
830     }
831   }
832 }
833
834 CharacterIndex Controller::Impl::GetPrimaryCursorPosition() const
835 {
836   if(nullptr == mEventData)
837   {
838     return 0;
839   }
840   return mEventData->mPrimaryCursorPosition;
841 }
842
843 bool Controller::Impl::SetPrimaryCursorPosition(CharacterIndex index, bool focused)
844 {
845   if(nullptr == mEventData)
846   {
847     // Nothing to do if there is no text.
848     return false;
849   }
850
851   if(mEventData->mPrimaryCursorPosition == index && mEventData->mState != EventData::SELECTING)
852   {
853     // Nothing for same cursor position.
854     return false;
855   }
856
857   uint32_t length                    = static_cast<uint32_t>(mModel->mLogicalModel->mText.Count());
858   uint32_t oldCursorPos              = mEventData->mPrimaryCursorPosition;
859   mEventData->mPrimaryCursorPosition = std::min(index, length);
860   // If there is no focus, only the value is updated.
861   if(focused)
862   {
863     bool     wasInSelectingState = mEventData->mState == EventData::SELECTING;
864     uint32_t oldStart            = mEventData->mLeftSelectionPosition;
865     uint32_t oldEnd              = mEventData->mRightSelectionPosition;
866     ChangeState(EventData::EDITING);
867     mEventData->mLeftSelectionPosition = mEventData->mRightSelectionPosition = mEventData->mPrimaryCursorPosition;
868     mEventData->mUpdateCursorPosition                                        = true;
869
870     if(mSelectableControlInterface != nullptr && wasInSelectingState)
871     {
872       mSelectableControlInterface->SelectionChanged(oldStart, oldEnd, mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition);
873     }
874
875     ScrollTextToMatchCursor();
876   }
877
878   if(nullptr != mEditableControlInterface)
879   {
880     mEditableControlInterface->CursorPositionChanged(oldCursorPos, mEventData->mPrimaryCursorPosition);
881   }
882
883   return true;
884 }
885
886 Uint32Pair Controller::Impl::GetTextSelectionRange() const
887 {
888   Uint32Pair range;
889
890   if(mEventData)
891   {
892     range.first  = mEventData->mLeftSelectionPosition;
893     range.second = mEventData->mRightSelectionPosition;
894   }
895
896   return range;
897 }
898
899 bool Controller::Impl::IsEditable() const
900 {
901   return mEventData && mEventData->mEditingEnabled;
902 }
903
904 void Controller::Impl::SetEditable(bool editable)
905 {
906   if(mEventData)
907   {
908     mEventData->mEditingEnabled = editable;
909
910     if(mEventData->mDecorator)
911     {
912       mEventData->mDecorator->SetEditable(editable);
913     }
914   }
915 }
916
917 void Controller::Impl::UpdateAfterFontChange(const std::string& newDefaultFont)
918 {
919   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::UpdateAfterFontChange\n");
920
921   if(!mFontDefaults->familyDefined) // If user defined font then should not update when system font changes
922   {
923     DALI_LOG_INFO(gLogFilter, Debug::Concise, "Controller::UpdateAfterFontChange newDefaultFont(%s)\n", newDefaultFont.c_str());
924     mFontDefaults->mFontDescription.family = newDefaultFont;
925
926     ClearFontData();
927
928     RequestRelayout();
929   }
930 }
931
932 void Controller::Impl::RetrieveSelection(std::string& selectedText, bool deleteAfterRetrieval)
933 {
934   if(mEventData->mLeftSelectionPosition == mEventData->mRightSelectionPosition)
935   {
936     // Nothing to select if handles are in the same place.
937     selectedText.clear();
938     return;
939   }
940
941   const bool handlesCrossed = mEventData->mLeftSelectionPosition > mEventData->mRightSelectionPosition;
942
943   //Get start and end position of selection
944   const CharacterIndex startOfSelectedText  = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition;
945   const Length         lengthOfSelectedText = (handlesCrossed ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition) - startOfSelectedText;
946
947   Vector<Character>& utf32Characters    = mModel->mLogicalModel->mText;
948   const Length       numberOfCharacters = utf32Characters.Count();
949
950   // Validate the start and end selection points
951   if((startOfSelectedText + lengthOfSelectedText) <= numberOfCharacters)
952   {
953     //Get text as a UTF8 string
954     Utf32ToUtf8(&utf32Characters[startOfSelectedText], lengthOfSelectedText, selectedText);
955
956     if(deleteAfterRetrieval) // Only delete text if copied successfully
957     {
958       // Keep a copy of the current input style.
959       InputStyle currentInputStyle;
960       currentInputStyle.Copy(mEventData->mInputStyle);
961
962       // Set as input style the style of the first deleted character.
963       mModel->mLogicalModel->RetrieveStyle(startOfSelectedText, mEventData->mInputStyle);
964
965       // Compare if the input style has changed.
966       const bool hasInputStyleChanged = !currentInputStyle.Equal(mEventData->mInputStyle);
967
968       if(hasInputStyleChanged)
969       {
970         const InputStyle::Mask styleChangedMask = currentInputStyle.GetInputStyleChangeMask(mEventData->mInputStyle);
971         // Queue the input style changed signal.
972         mEventData->mInputStyleChangedQueue.PushBack(styleChangedMask);
973       }
974
975       mModel->mLogicalModel->UpdateTextStyleRuns(startOfSelectedText, -static_cast<int>(lengthOfSelectedText));
976
977       // Mark the paragraphs to be updated.
978       if(Layout::Engine::SINGLE_LINE_BOX == mLayoutEngine.GetLayout())
979       {
980         mTextUpdateInfo.mCharacterIndex             = 0;
981         mTextUpdateInfo.mNumberOfCharactersToRemove = mTextUpdateInfo.mPreviousNumberOfCharacters;
982         mTextUpdateInfo.mNumberOfCharactersToAdd    = mTextUpdateInfo.mPreviousNumberOfCharacters - lengthOfSelectedText;
983         mTextUpdateInfo.mClearAll                   = true;
984       }
985       else
986       {
987         mTextUpdateInfo.mCharacterIndex             = startOfSelectedText;
988         mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
989       }
990
991       // Delete text between handles
992       Vector<Character>::Iterator first = utf32Characters.Begin() + startOfSelectedText;
993       Vector<Character>::Iterator last  = first + lengthOfSelectedText;
994       utf32Characters.Erase(first, last);
995
996       // Will show the cursor at the first character of the selection.
997       mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition;
998     }
999     else
1000     {
1001       // Will show the cursor at the last character of the selection.
1002       mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition;
1003     }
1004
1005     mEventData->mDecoratorUpdated = true;
1006   }
1007 }
1008
1009 void Controller::Impl::SetSelection(int start, int end)
1010 {
1011   uint32_t oldStart = mEventData->mLeftSelectionPosition;
1012   uint32_t oldEnd   = mEventData->mRightSelectionPosition;
1013
1014   mEventData->mLeftSelectionPosition  = start;
1015   mEventData->mRightSelectionPosition = end;
1016   mEventData->mUpdateCursorPosition   = true;
1017
1018   if(mSelectableControlInterface != nullptr)
1019   {
1020     mSelectableControlInterface->SelectionChanged(oldStart, oldEnd, start, end);
1021   }
1022 }
1023
1024 std::pair<int, int> Controller::Impl::GetSelectionIndexes() const
1025 {
1026   return {mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition};
1027 }
1028
1029 void Controller::Impl::ShowClipboard()
1030 {
1031   if(mClipboard)
1032   {
1033     mClipboard.ShowClipboard();
1034   }
1035 }
1036
1037 void Controller::Impl::HideClipboard()
1038 {
1039   if(mClipboard && mClipboardHideEnabled)
1040   {
1041     mClipboard.HideClipboard();
1042   }
1043 }
1044
1045 void Controller::Impl::SetClipboardHideEnable(bool enable)
1046 {
1047   mClipboardHideEnabled = enable;
1048 }
1049
1050 bool Controller::Impl::CopyStringToClipboard(const std::string& source)
1051 {
1052   //Send string to clipboard
1053   return (mClipboard && mClipboard.SetItem(source));
1054 }
1055
1056 void Controller::Impl::SendSelectionToClipboard(bool deleteAfterSending)
1057 {
1058   std::string selectedText;
1059   RetrieveSelection(selectedText, deleteAfterSending);
1060   CopyStringToClipboard(selectedText);
1061   ChangeState(EventData::EDITING);
1062 }
1063
1064 void Controller::Impl::RequestGetTextFromClipboard()
1065 {
1066   if(mClipboard)
1067   {
1068     mClipboard.RequestItem();
1069   }
1070 }
1071
1072 void Controller::Impl::RepositionSelectionHandles()
1073 {
1074   SelectionHandleController::Reposition(*this);
1075 }
1076 void Controller::Impl::RepositionSelectionHandles(float visualX, float visualY, Controller::NoTextTap::Action action)
1077 {
1078   SelectionHandleController::Reposition(*this, visualX, visualY, action);
1079 }
1080
1081 void Controller::Impl::SetPopupButtons()
1082 {
1083   /**
1084    *  Sets the Popup buttons to be shown depending on State.
1085    *
1086    *  If SELECTING :  CUT & COPY + ( PASTE & CLIPBOARD if content available to paste )
1087    *
1088    *  If EDITING_WITH_POPUP : SELECT & SELECT_ALL
1089    */
1090
1091   bool                        isEditable    = IsEditable();
1092   TextSelectionPopup::Buttons buttonsToShow = TextSelectionPopup::NONE;
1093
1094   if(EventData::SELECTING == mEventData->mState)
1095   {
1096     buttonsToShow = TextSelectionPopup::Buttons(TextSelectionPopup::COPY);
1097     if(isEditable)
1098     {
1099       buttonsToShow = TextSelectionPopup::Buttons(buttonsToShow | TextSelectionPopup::CUT);
1100     }
1101
1102     if(!IsClipboardEmpty())
1103     {
1104       if(isEditable)
1105       {
1106         buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::PASTE));
1107       }
1108       buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::CLIPBOARD));
1109     }
1110
1111     if(!mEventData->mAllTextSelected)
1112     {
1113       buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::SELECT_ALL));
1114     }
1115   }
1116   else if(EventData::EDITING_WITH_POPUP == mEventData->mState)
1117   {
1118     if(mModel->mLogicalModel->mText.Count() && !IsShowingPlaceholderText())
1119     {
1120       buttonsToShow = TextSelectionPopup::Buttons(TextSelectionPopup::SELECT | TextSelectionPopup::SELECT_ALL);
1121     }
1122
1123     if(!IsClipboardEmpty())
1124     {
1125       if(isEditable)
1126       {
1127         buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::PASTE));
1128       }
1129       buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::CLIPBOARD));
1130     }
1131   }
1132   else if(EventData::EDITING_WITH_PASTE_POPUP == mEventData->mState)
1133   {
1134     if(!IsClipboardEmpty())
1135     {
1136       if(isEditable)
1137       {
1138         buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::PASTE));
1139       }
1140       buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::CLIPBOARD));
1141     }
1142   }
1143
1144   mEventData->mDecorator->SetEnabledPopupButtons(buttonsToShow);
1145 }
1146
1147 void Controller::Impl::ChangeState(EventData::State newState)
1148 {
1149   ChangeTextControllerState(*this, newState);
1150 }
1151
1152 void Controller::Impl::GetCursorPosition(CharacterIndex logical,
1153                                          CursorInfo&    cursorInfo)
1154 {
1155   if(!IsShowingRealText())
1156   {
1157     // Do not want to use the place-holder text to set the cursor position.
1158
1159     // Use the line's height of the font's family set to set the cursor's size.
1160     // If there is no font's family set, use the default font.
1161     // Use the current alignment to place the cursor at the beginning, center or end of the box.
1162
1163     cursorInfo.lineOffset          = 0.f;
1164     cursorInfo.lineHeight          = GetDefaultFontLineHeight();
1165     cursorInfo.primaryCursorHeight = cursorInfo.lineHeight;
1166
1167     bool isRTL = false;
1168     if(mModel->mMatchLayoutDirection != DevelText::MatchLayoutDirection::CONTENTS)
1169     {
1170       isRTL = mLayoutDirection == LayoutDirection::RIGHT_TO_LEFT;
1171     }
1172
1173     switch(mModel->mHorizontalAlignment)
1174     {
1175       case Text::HorizontalAlignment::BEGIN:
1176       {
1177         if(isRTL)
1178         {
1179           cursorInfo.primaryPosition.x = mModel->mVisualModel->mControlSize.width - mEventData->mDecorator->GetCursorWidth();
1180         }
1181         else
1182         {
1183           cursorInfo.primaryPosition.x = 0.f;
1184         }
1185         break;
1186       }
1187       case Text::HorizontalAlignment::CENTER:
1188       {
1189         cursorInfo.primaryPosition.x = floorf(0.5f * mModel->mVisualModel->mControlSize.width);
1190         break;
1191       }
1192       case Text::HorizontalAlignment::END:
1193       {
1194         if(isRTL)
1195         {
1196           cursorInfo.primaryPosition.x = 0.f;
1197         }
1198         else
1199         {
1200           cursorInfo.primaryPosition.x = mModel->mVisualModel->mControlSize.width - mEventData->mDecorator->GetCursorWidth();
1201         }
1202         break;
1203       }
1204     }
1205
1206     // Nothing else to do.
1207     return;
1208   }
1209
1210   const bool                  isMultiLine = (Layout::Engine::MULTI_LINE_BOX == mLayoutEngine.GetLayout());
1211   GetCursorPositionParameters parameters;
1212   parameters.visualModel  = mModel->mVisualModel;
1213   parameters.logicalModel = mModel->mLogicalModel;
1214   parameters.metrics      = mMetrics;
1215   parameters.logical      = logical;
1216   parameters.isMultiline  = isMultiLine;
1217
1218   float defaultFontLineHeight = GetDefaultFontLineHeight();
1219
1220   Text::GetCursorPosition(parameters,
1221                           defaultFontLineHeight,
1222                           cursorInfo);
1223
1224   // Adds Outline offset.
1225   const float outlineWidth = static_cast<float>(mModel->GetOutlineWidth());
1226   cursorInfo.primaryPosition.x += outlineWidth;
1227   cursorInfo.primaryPosition.y += outlineWidth;
1228   cursorInfo.secondaryPosition.x += outlineWidth;
1229   cursorInfo.secondaryPosition.y += outlineWidth;
1230
1231   if(isMultiLine)
1232   {
1233     // If the text is editable and multi-line, the cursor position after a white space shouldn't exceed the boundaries of the text control.
1234
1235     // Note the white spaces laid-out at the end of the line might exceed the boundaries of the control.
1236     // The reason is a wrapped line must not start with a white space so they are laid-out at the end of the line.
1237
1238     if(0.f > cursorInfo.primaryPosition.x)
1239     {
1240       cursorInfo.primaryPosition.x = 0.f;
1241     }
1242
1243     const float edgeWidth = mModel->mVisualModel->mControlSize.width - static_cast<float>(mEventData->mDecorator->GetCursorWidth());
1244     if(cursorInfo.primaryPosition.x > edgeWidth)
1245     {
1246       cursorInfo.primaryPosition.x = edgeWidth;
1247     }
1248   }
1249 }
1250
1251 CharacterIndex Controller::Impl::CalculateNewCursorIndex(CharacterIndex index) const
1252 {
1253   if(nullptr == mEventData)
1254   {
1255     // Nothing to do if there is no text input.
1256     return 0u;
1257   }
1258
1259   CharacterIndex cursorIndex = mEventData->mPrimaryCursorPosition;
1260
1261   const GlyphIndex* const charactersToGlyphBuffer  = mModel->mVisualModel->mCharactersToGlyph.Begin();
1262   const Length* const     charactersPerGlyphBuffer = mModel->mVisualModel->mCharactersPerGlyph.Begin();
1263
1264   GlyphIndex glyphIndex         = *(charactersToGlyphBuffer + index);
1265   Length     numberOfCharacters = *(charactersPerGlyphBuffer + glyphIndex);
1266
1267   if(numberOfCharacters > 1u)
1268   {
1269     const Script script = mModel->mLogicalModel->GetScript(index);
1270     if(HasLigatureMustBreak(script))
1271     {
1272       // Prevents to jump the whole Latin ligatures like fi, ff, or Arabic ﻻ, ...
1273       numberOfCharacters = 1u;
1274     }
1275   }
1276   else
1277   {
1278     while(0u == numberOfCharacters)
1279     {
1280       ++glyphIndex;
1281       numberOfCharacters = *(charactersPerGlyphBuffer + glyphIndex);
1282     }
1283   }
1284
1285   if(index < mEventData->mPrimaryCursorPosition)
1286   {
1287     cursorIndex -= numberOfCharacters;
1288   }
1289   else
1290   {
1291     cursorIndex += numberOfCharacters;
1292   }
1293
1294   // Will update the cursor hook position.
1295   mEventData->mUpdateCursorHookPosition = true;
1296
1297   return cursorIndex;
1298 }
1299
1300 void Controller::Impl::UpdateCursorPosition(const CursorInfo& cursorInfo)
1301 {
1302   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "-->Controller::UpdateCursorPosition %p\n", this);
1303   if(nullptr == mEventData)
1304   {
1305     // Nothing to do if there is no text input.
1306     DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::UpdateCursorPosition no event data\n");
1307     return;
1308   }
1309
1310   const Vector2 cursorPosition = cursorInfo.primaryPosition + mModel->mScrollPosition;
1311
1312   mEventData->mDecorator->SetGlyphOffset(PRIMARY_CURSOR, cursorInfo.glyphOffset);
1313
1314   // Sets the cursor position.
1315   mEventData->mDecorator->SetPosition(PRIMARY_CURSOR,
1316                                       cursorPosition.x,
1317                                       cursorPosition.y,
1318                                       cursorInfo.primaryCursorHeight,
1319                                       cursorInfo.lineHeight);
1320   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Primary cursor position: %f,%f\n", cursorPosition.x, cursorPosition.y);
1321
1322   if(mEventData->mUpdateGrabHandlePosition)
1323   {
1324     // Sets the grab handle position.
1325     mEventData->mDecorator->SetPosition(GRAB_HANDLE,
1326                                         cursorPosition.x,
1327                                         cursorInfo.lineOffset + mModel->mScrollPosition.y,
1328                                         cursorInfo.lineHeight);
1329   }
1330
1331   if(cursorInfo.isSecondaryCursor)
1332   {
1333     mEventData->mDecorator->SetPosition(SECONDARY_CURSOR,
1334                                         cursorInfo.secondaryPosition.x + mModel->mScrollPosition.x,
1335                                         cursorInfo.secondaryPosition.y + mModel->mScrollPosition.y,
1336                                         cursorInfo.secondaryCursorHeight,
1337                                         cursorInfo.lineHeight);
1338     DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Secondary cursor position: %f,%f\n", cursorInfo.secondaryPosition.x + mModel->mScrollPosition.x, cursorInfo.secondaryPosition.y + mModel->mScrollPosition.y);
1339   }
1340
1341   // Set which cursors are active according the state.
1342   if(EventData::IsEditingState(mEventData->mState) || (EventData::GRAB_HANDLE_PANNING == mEventData->mState))
1343   {
1344     if(cursorInfo.isSecondaryCursor)
1345     {
1346       mEventData->mDecorator->SetActiveCursor(ACTIVE_CURSOR_BOTH);
1347     }
1348     else
1349     {
1350       mEventData->mDecorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
1351     }
1352   }
1353   else
1354   {
1355     mEventData->mDecorator->SetActiveCursor(ACTIVE_CURSOR_NONE);
1356   }
1357
1358   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::UpdateCursorPosition\n");
1359 }
1360
1361 void Controller::Impl::UpdateSelectionHandle(HandleType        handleType,
1362                                              const CursorInfo& cursorInfo)
1363 {
1364   SelectionHandleController::Update(*this, handleType, cursorInfo);
1365 }
1366
1367 void Controller::Impl::ClampHorizontalScroll(const Vector2& layoutSize)
1368 {
1369   // Clamp between -space & -alignment offset.
1370
1371   if(layoutSize.width > mModel->mVisualModel->mControlSize.width)
1372   {
1373     const float space         = (layoutSize.width - mModel->mVisualModel->mControlSize.width) + mModel->mAlignmentOffset;
1374     mModel->mScrollPosition.x = (mModel->mScrollPosition.x < -space) ? -space : mModel->mScrollPosition.x;
1375     mModel->mScrollPosition.x = (mModel->mScrollPosition.x > -mModel->mAlignmentOffset) ? -mModel->mAlignmentOffset : mModel->mScrollPosition.x;
1376
1377     mEventData->mDecoratorUpdated = true;
1378   }
1379   else
1380   {
1381     mModel->mScrollPosition.x = 0.f;
1382   }
1383 }
1384
1385 void Controller::Impl::ClampVerticalScroll(const Vector2& layoutSize)
1386 {
1387   if(Layout::Engine::SINGLE_LINE_BOX == mLayoutEngine.GetLayout())
1388   {
1389     // Nothing to do if the text is single line.
1390     return;
1391   }
1392
1393   // Clamp between -space & 0.
1394   if(layoutSize.height > mModel->mVisualModel->mControlSize.height)
1395   {
1396     const float space         = (layoutSize.height - mModel->mVisualModel->mControlSize.height);
1397     mModel->mScrollPosition.y = (mModel->mScrollPosition.y < -space) ? -space : mModel->mScrollPosition.y;
1398     mModel->mScrollPosition.y = (mModel->mScrollPosition.y > 0.f) ? 0.f : mModel->mScrollPosition.y;
1399
1400     mEventData->mDecoratorUpdated = true;
1401   }
1402   else
1403   {
1404     mModel->mScrollPosition.y = 0.f;
1405   }
1406 }
1407
1408 void Controller::Impl::ScrollToMakePositionVisible(const Vector2& position, float lineHeight)
1409 {
1410   const float cursorWidth = mEventData->mDecorator ? static_cast<float>(mEventData->mDecorator->GetCursorWidth()) : 0.f;
1411
1412   // position is in actor's coords.
1413   const float positionEndX = position.x + cursorWidth;
1414   const float positionEndY = position.y + lineHeight;
1415
1416   // Transform the position to decorator coords.
1417   const float decoratorPositionBeginX = position.x + mModel->mScrollPosition.x;
1418   const float decoratorPositionEndX   = positionEndX + mModel->mScrollPosition.x;
1419
1420   const float decoratorPositionBeginY = position.y + mModel->mScrollPosition.y;
1421   const float decoratorPositionEndY   = positionEndY + mModel->mScrollPosition.y;
1422
1423   if(decoratorPositionBeginX < 0.f)
1424   {
1425     mModel->mScrollPosition.x = -position.x;
1426   }
1427   else if(decoratorPositionEndX > mModel->mVisualModel->mControlSize.width)
1428   {
1429     mModel->mScrollPosition.x = mModel->mVisualModel->mControlSize.width - positionEndX;
1430   }
1431
1432   if(Layout::Engine::MULTI_LINE_BOX == mLayoutEngine.GetLayout())
1433   {
1434     if(decoratorPositionBeginY < 0.f)
1435     {
1436       mModel->mScrollPosition.y = -position.y;
1437     }
1438     else if(decoratorPositionEndY > mModel->mVisualModel->mControlSize.height)
1439     {
1440       mModel->mScrollPosition.y = mModel->mVisualModel->mControlSize.height - positionEndY;
1441     }
1442   }
1443 }
1444
1445 void Controller::Impl::ScrollTextToMatchCursor(const CursorInfo& cursorInfo)
1446 {
1447   // Get the current cursor position in decorator coords.
1448   const Vector2& currentCursorPosition = mEventData->mDecorator->GetPosition(PRIMARY_CURSOR);
1449
1450   const LineIndex lineIndex = mModel->mVisualModel->GetLineOfCharacter(mEventData->mPrimaryCursorPosition);
1451
1452   // Calculate the offset to match the cursor position before the character was deleted.
1453   mModel->mScrollPosition.x = currentCursorPosition.x - cursorInfo.primaryPosition.x;
1454
1455   //If text control has more than two lines and current line index is not last, calculate scrollpositionY
1456   if(mModel->mVisualModel->mLines.Count() > 1u && lineIndex != mModel->mVisualModel->mLines.Count() - 1u)
1457   {
1458     const float currentCursorGlyphOffset = mEventData->mDecorator->GetGlyphOffset(PRIMARY_CURSOR);
1459     mModel->mScrollPosition.y            = currentCursorPosition.y - cursorInfo.lineOffset - currentCursorGlyphOffset;
1460   }
1461
1462   ClampHorizontalScroll(mModel->mVisualModel->GetLayoutSize());
1463   ClampVerticalScroll(mModel->mVisualModel->GetLayoutSize());
1464
1465   // Makes the new cursor position visible if needed.
1466   ScrollToMakePositionVisible(cursorInfo.primaryPosition, cursorInfo.lineHeight);
1467 }
1468
1469 void Controller::Impl::ScrollTextToMatchCursor()
1470 {
1471   CursorInfo cursorInfo;
1472   GetCursorPosition(mEventData->mPrimaryCursorPosition, cursorInfo);
1473   ScrollTextToMatchCursor(cursorInfo);
1474 }
1475
1476 void Controller::Impl::RequestRelayout()
1477 {
1478   if(nullptr != mControlInterface)
1479   {
1480     mControlInterface->RequestTextRelayout();
1481   }
1482 }
1483
1484 void Controller::Impl::RelayoutAllCharacters()
1485 {
1486   // relayout all characters
1487   mTextUpdateInfo.mCharacterIndex             = 0;
1488   mTextUpdateInfo.mNumberOfCharactersToRemove = mTextUpdateInfo.mPreviousNumberOfCharacters;
1489   mTextUpdateInfo.mNumberOfCharactersToAdd    = mModel->mLogicalModel->mText.Count();
1490   mOperationsPending                          = static_cast<OperationsMask>(mOperationsPending | LAYOUT);
1491
1492   mTextUpdateInfo.mFullRelayoutNeeded = true;
1493
1494   // Need to recalculate natural size
1495   mRecalculateNaturalSize = true;
1496
1497   //remove selection
1498   if((mEventData != nullptr) && (mEventData->mState == EventData::SELECTING))
1499   {
1500     ChangeState(EventData::EDITING);
1501   }
1502
1503   RequestRelayout();
1504 }
1505
1506 bool Controller::Impl::IsInputStyleChangedSignalsQueueEmpty()
1507 {
1508   return (NULL == mEventData) || (0u == mEventData->mInputStyleChangedQueue.Count());
1509 }
1510
1511 void Controller::Impl::ProcessInputStyleChangedSignals()
1512 {
1513   if(mEventData)
1514   {
1515     if(mEditableControlInterface)
1516     {
1517       // Emit the input style changed signal for each mask
1518       std::for_each(mEventData->mInputStyleChangedQueue.begin(),
1519                     mEventData->mInputStyleChangedQueue.end(),
1520                     [&](const auto mask) { mEditableControlInterface->InputStyleChanged(mask); });
1521     }
1522
1523     mEventData->mInputStyleChangedQueue.Clear();
1524   }
1525 }
1526
1527 void Controller::Impl::ScrollBy(Vector2 scroll)
1528 {
1529   if(mEventData && (fabs(scroll.x) > Math::MACHINE_EPSILON_0 || fabs(scroll.y) > Math::MACHINE_EPSILON_0))
1530   {
1531     const Vector2& layoutSize    = mModel->mVisualModel->GetLayoutSize();
1532     const Vector2  currentScroll = mModel->mScrollPosition;
1533
1534     scroll.x = -scroll.x;
1535     scroll.y = -scroll.y;
1536
1537     if(fabs(scroll.x) > Math::MACHINE_EPSILON_0)
1538     {
1539       mModel->mScrollPosition.x += scroll.x;
1540       ClampHorizontalScroll(layoutSize);
1541     }
1542
1543     if(fabs(scroll.y) > Math::MACHINE_EPSILON_0)
1544     {
1545       mModel->mScrollPosition.y += scroll.y;
1546       ClampVerticalScroll(layoutSize);
1547     }
1548
1549     if(mModel->mScrollPosition != currentScroll)
1550     {
1551       mEventData->mDecorator->UpdatePositions(mModel->mScrollPosition - currentScroll);
1552       RequestRelayout();
1553     }
1554   }
1555 }
1556
1557 float Controller::Impl::GetHorizontalScrollPosition()
1558 {
1559   // Scroll values are negative internally so we convert them to positive numbers
1560   return mEventData ? -mModel->mScrollPosition.x : 0.0f;
1561 }
1562
1563 float Controller::Impl::GetVerticalScrollPosition()
1564 {
1565   // Scroll values are negative internally so we convert them to positive numbers
1566   return mEventData ? -mModel->mScrollPosition.y : 0.0f;
1567 }
1568
1569 Vector3 Controller::Impl::GetAnchorPosition(Anchor anchor) const
1570 {
1571   //TODO
1572   return Vector3(10.f, 10.f, 10.f);
1573 }
1574
1575 Vector2 Controller::Impl::GetAnchorSize(Anchor anchor) const
1576 {
1577   //TODO
1578   return Vector2(10.f, 10.f);
1579 }
1580
1581 Toolkit::TextAnchor Controller::Impl::CreateAnchorActor(Anchor anchor)
1582 {
1583   auto actor = Toolkit::TextAnchor::New();
1584   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1585   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1586   const Vector3 anchorPosition = GetAnchorPosition(anchor);
1587   actor.SetProperty(Actor::Property::POSITION, anchorPosition);
1588   const Vector2 anchorSize = GetAnchorSize(anchor);
1589   actor.SetProperty(Actor::Property::SIZE, anchorSize);
1590   std::string anchorText(mModel->mLogicalModel->mText.Begin() + anchor.startIndex, mModel->mLogicalModel->mText.Begin() + anchor.endIndex);
1591   actor.SetProperty(Actor::Property::NAME, anchorText);
1592   actor.SetProperty(Toolkit::TextAnchor::Property::URI, std::string(anchor.href));
1593   actor.SetProperty(Toolkit::TextAnchor::Property::START_CHARACTER_INDEX, static_cast<int>(anchor.startIndex));
1594   actor.SetProperty(Toolkit::TextAnchor::Property::END_CHARACTER_INDEX, static_cast<int>(anchor.endIndex));
1595   return actor;
1596 }
1597
1598 void Controller::Impl::GetAnchorActors(std::vector<Toolkit::TextAnchor>& anchorActors)
1599 {
1600   /* TODO: Now actors are created/destroyed in every "RenderText" function call. Even when we add just 1 character,
1601            we need to create and destroy potentially many actors. Some optimization can be considered here.
1602            Maybe a "dirty" flag in mLogicalModel? */
1603   anchorActors.clear();
1604   for(auto& anchor : mModel->mLogicalModel->mAnchors)
1605   {
1606     auto actor = CreateAnchorActor(anchor);
1607     anchorActors.push_back(actor);
1608   }
1609 }
1610
1611 int32_t Controller::Impl::GetAnchorIndex(size_t characterOffset) const
1612 {
1613   Vector<Anchor>::Iterator it = mModel->mLogicalModel->mAnchors.Begin();
1614
1615   while(it != mModel->mLogicalModel->mAnchors.End() && (it->startIndex > characterOffset || it->endIndex <= characterOffset))
1616   {
1617     it++;
1618   }
1619
1620   return it == mModel->mLogicalModel->mAnchors.End() ? -1 : it - mModel->mLogicalModel->mAnchors.Begin();
1621 }
1622
1623 void Controller::Impl::CopyUnderlinedFromLogicalToVisualModels(bool shouldClearPreUnderlineRuns)
1624 {
1625   //Underlined character runs for markup-processor
1626   const Vector<UnderlinedCharacterRun>& underlinedCharacterRuns = mModel->mLogicalModel->mUnderlinedCharacterRuns;
1627   const Vector<GlyphIndex>&             charactersToGlyph       = mModel->mVisualModel->mCharactersToGlyph;
1628   const Vector<Length>&                 glyphsPerCharacter      = mModel->mVisualModel->mGlyphsPerCharacter;
1629
1630   if(shouldClearPreUnderlineRuns)
1631   {
1632     mModel->mVisualModel->mUnderlineRuns.Clear();
1633   }
1634
1635   for(Vector<UnderlinedCharacterRun>::ConstIterator it = underlinedCharacterRuns.Begin(), endIt = underlinedCharacterRuns.End(); it != endIt; ++it)
1636   {
1637     CharacterIndex characterIndex     = it->characterRun.characterIndex;
1638     Length         numberOfCharacters = it->characterRun.numberOfCharacters;
1639
1640     if(numberOfCharacters == 0)
1641     {
1642       continue;
1643     }
1644
1645     // Create one run for all glyphs of all run's characters that has same properties
1646     // This enhance performance and reduce the needed memory to store glyphs-runs
1647     UnderlinedGlyphRun underlineGlyphRun;
1648     underlineGlyphRun.glyphRun.glyphIndex     = charactersToGlyph[characterIndex];
1649     underlineGlyphRun.glyphRun.numberOfGlyphs = glyphsPerCharacter[characterIndex];
1650     //Copy properties (attributes)
1651     underlineGlyphRun.properties = it->properties;
1652
1653     for(Length index = 1u; index < numberOfCharacters; index++)
1654     {
1655       underlineGlyphRun.glyphRun.numberOfGlyphs += glyphsPerCharacter[characterIndex + index];
1656     }
1657
1658     mModel->mVisualModel->mUnderlineRuns.PushBack(underlineGlyphRun);
1659   }
1660 }
1661
1662 void Controller::Impl::CopyStrikethroughFromLogicalToVisualModels()
1663 {
1664   //Strikethrough character runs from markup-processor
1665   const Vector<StrikethroughCharacterRun>& strikethroughCharacterRuns = mModel->mLogicalModel->mStrikethroughCharacterRuns;
1666   const Vector<GlyphIndex>&                charactersToGlyph          = mModel->mVisualModel->mCharactersToGlyph;
1667   const Vector<Length>&                    glyphsPerCharacter         = mModel->mVisualModel->mGlyphsPerCharacter;
1668
1669   mModel->mVisualModel->mStrikethroughRuns.Clear();
1670
1671   for(Vector<StrikethroughCharacterRun>::ConstIterator it = strikethroughCharacterRuns.Begin(), endIt = strikethroughCharacterRuns.End(); it != endIt; ++it)
1672   {
1673     CharacterIndex characterIndex     = it->characterRun.characterIndex;
1674     Length         numberOfCharacters = it->characterRun.numberOfCharacters;
1675
1676     if(numberOfCharacters == 0)
1677     {
1678       continue;
1679     }
1680
1681     StrikethroughGlyphRun strikethroughGlyphRun;
1682     strikethroughGlyphRun.properties              = it->properties;
1683     strikethroughGlyphRun.glyphRun.glyphIndex     = charactersToGlyph[characterIndex];
1684     strikethroughGlyphRun.glyphRun.numberOfGlyphs = glyphsPerCharacter[characterIndex];
1685
1686     for(Length index = 1u; index < numberOfCharacters; index++)
1687     {
1688       strikethroughGlyphRun.glyphRun.numberOfGlyphs += glyphsPerCharacter[characterIndex + index];
1689     }
1690
1691     mModel->mVisualModel->mStrikethroughRuns.PushBack(strikethroughGlyphRun);
1692   }
1693 }
1694
1695 void Controller::Impl::CopyCharacterSpacingFromLogicalToVisualModels()
1696 {
1697   //CharacterSpacing character runs from markup-processor
1698   const Vector<CharacterSpacingCharacterRun>& characterSpacingCharacterRuns = mModel->mLogicalModel->mCharacterSpacingCharacterRuns;
1699   const Vector<GlyphIndex>&                   charactersToGlyph             = mModel->mVisualModel->mCharactersToGlyph;
1700   const Vector<Length>&                       glyphsPerCharacter            = mModel->mVisualModel->mGlyphsPerCharacter;
1701
1702   mModel->mVisualModel->mCharacterSpacingRuns.Clear();
1703
1704   for(Vector<CharacterSpacingCharacterRun>::ConstIterator it = characterSpacingCharacterRuns.Begin(), endIt = characterSpacingCharacterRuns.End(); it != endIt; ++it)
1705   {
1706     const CharacterIndex& characterIndex     = it->characterRun.characterIndex;
1707     const Length&         numberOfCharacters = it->characterRun.numberOfCharacters;
1708
1709     if(numberOfCharacters == 0)
1710     {
1711       continue;
1712     }
1713
1714     CharacterSpacingGlyphRun characterSpacingGlyphRun;
1715     characterSpacingGlyphRun.value                   = it->value;
1716     characterSpacingGlyphRun.glyphRun.glyphIndex     = charactersToGlyph[characterIndex];
1717     characterSpacingGlyphRun.glyphRun.numberOfGlyphs = glyphsPerCharacter[characterIndex];
1718
1719     for(Length index = 1u; index < numberOfCharacters; index++)
1720     {
1721       characterSpacingGlyphRun.glyphRun.numberOfGlyphs += glyphsPerCharacter[characterIndex + index];
1722     }
1723
1724     mModel->mVisualModel->mCharacterSpacingRuns.PushBack(characterSpacingGlyphRun);
1725   }
1726 }
1727
1728 void Controller::Impl::SetAutoScrollEnabled(bool enable)
1729 {
1730   if(mLayoutEngine.GetLayout() == Layout::Engine::SINGLE_LINE_BOX)
1731   {
1732     mOperationsPending = static_cast<OperationsMask>(mOperationsPending |
1733                                                      LAYOUT |
1734                                                      ALIGN |
1735                                                      UPDATE_LAYOUT_SIZE |
1736                                                      REORDER);
1737
1738     if(enable)
1739     {
1740       DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled for SINGLE_LINE_BOX\n");
1741       mOperationsPending = static_cast<OperationsMask>(mOperationsPending | UPDATE_DIRECTION);
1742     }
1743     else
1744     {
1745       DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled Disabling autoscroll\n");
1746     }
1747
1748     mIsAutoScrollEnabled = enable;
1749     RequestRelayout();
1750   }
1751   else
1752   {
1753     DALI_LOG_WARNING("Attempted AutoScrolling on a non SINGLE_LINE_BOX, request ignored\n");
1754     mIsAutoScrollEnabled = false;
1755   }
1756 }
1757
1758 void Controller::Impl::SetEnableCursorBlink(bool enable)
1759 {
1760   DALI_ASSERT_DEBUG(NULL != mEventData && "TextInput disabled");
1761
1762   if(mEventData)
1763   {
1764     mEventData->mCursorBlinkEnabled = enable;
1765
1766     if(!enable && mEventData->mDecorator)
1767     {
1768       mEventData->mDecorator->StopCursorBlink();
1769     }
1770   }
1771 }
1772
1773 void Controller::Impl::SetMultiLineEnabled(bool enable)
1774 {
1775   const Layout::Engine::Type layout = enable ? Layout::Engine::MULTI_LINE_BOX : Layout::Engine::SINGLE_LINE_BOX;
1776
1777   if(layout != mLayoutEngine.GetLayout())
1778   {
1779     // Set the layout type.
1780     mLayoutEngine.SetLayout(layout);
1781
1782     // Set the flags to redo the layout operations
1783     const OperationsMask layoutOperations = static_cast<OperationsMask>(LAYOUT |
1784                                                                         UPDATE_LAYOUT_SIZE |
1785                                                                         ALIGN |
1786                                                                         REORDER);
1787
1788     mTextUpdateInfo.mFullRelayoutNeeded = true;
1789     mOperationsPending                  = static_cast<OperationsMask>(mOperationsPending | layoutOperations);
1790
1791     // Need to recalculate natural size
1792     mRecalculateNaturalSize = true;
1793
1794     RequestRelayout();
1795   }
1796 }
1797
1798 void Controller::Impl::SetHorizontalAlignment(Text::HorizontalAlignment::Type alignment)
1799 {
1800   if(alignment != mModel->mHorizontalAlignment)
1801   {
1802     // Set the alignment.
1803     mModel->mHorizontalAlignment = alignment;
1804
1805     // Set the flag to redo the alignment operation.
1806     mOperationsPending = static_cast<OperationsMask>(mOperationsPending | ALIGN);
1807
1808     if(mEventData)
1809     {
1810       mEventData->mUpdateAlignment = true;
1811
1812       // Update the cursor if it's in editing mode
1813       if(EventData::IsEditingState(mEventData->mState))
1814       {
1815         ChangeState(EventData::EDITING);
1816         mEventData->mUpdateCursorPosition = true;
1817       }
1818     }
1819
1820     RequestRelayout();
1821   }
1822 }
1823
1824 void Controller::Impl::SetVerticalAlignment(VerticalAlignment::Type alignment)
1825 {
1826   if(alignment != mModel->mVerticalAlignment)
1827   {
1828     // Set the alignment.
1829     mModel->mVerticalAlignment = alignment;
1830     mOperationsPending         = static_cast<OperationsMask>(mOperationsPending | ALIGN);
1831     RequestRelayout();
1832   }
1833 }
1834
1835 void Controller::Impl::SetLineWrapMode(Text::LineWrap::Mode lineWrapMode)
1836 {
1837   if(lineWrapMode != mModel->mLineWrapMode)
1838   {
1839     // Update Text layout for applying wrap mode
1840     mOperationsPending = static_cast<OperationsMask>(mOperationsPending |
1841                                                      ALIGN |
1842                                                      LAYOUT |
1843                                                      UPDATE_LAYOUT_SIZE |
1844                                                      REORDER);
1845
1846     if((mModel->mLineWrapMode == (Text::LineWrap::Mode)DevelText::LineWrap::HYPHENATION) || (lineWrapMode == (Text::LineWrap::Mode)DevelText::LineWrap::HYPHENATION) ||
1847        (mModel->mLineWrapMode == (Text::LineWrap::Mode)DevelText::LineWrap::MIXED) || (lineWrapMode == (Text::LineWrap::Mode)DevelText::LineWrap::MIXED)) // hyphen is treated as line break
1848     {
1849       mOperationsPending = static_cast<OperationsMask>(mOperationsPending | GET_LINE_BREAKS);
1850     }
1851
1852     // Set the text wrap mode.
1853     mModel->mLineWrapMode = lineWrapMode;
1854
1855     mTextUpdateInfo.mCharacterIndex             = 0u;
1856     mTextUpdateInfo.mNumberOfCharactersToRemove = mTextUpdateInfo.mPreviousNumberOfCharacters;
1857     mTextUpdateInfo.mNumberOfCharactersToAdd    = mModel->mLogicalModel->mText.Count();
1858
1859     // Request relayout
1860     RequestRelayout();
1861   }
1862 }
1863
1864 void Controller::Impl::SetDefaultColor(const Vector4& color)
1865 {
1866   mTextColor = color;
1867
1868   if(!IsShowingPlaceholderText())
1869   {
1870     mModel->mVisualModel->SetTextColor(color);
1871     mModel->mLogicalModel->mColorRuns.Clear();
1872     mOperationsPending = static_cast<OperationsMask>(mOperationsPending | COLOR);
1873     RequestRelayout();
1874   }
1875 }
1876
1877 void Controller::Impl::ClearFontData()
1878 {
1879   if(mFontDefaults)
1880   {
1881     mFontDefaults->mFontId = 0u; // Remove old font ID
1882   }
1883
1884   // Set flags to update the model.
1885   mTextUpdateInfo.mCharacterIndex             = 0u;
1886   mTextUpdateInfo.mNumberOfCharactersToRemove = mTextUpdateInfo.mPreviousNumberOfCharacters;
1887   mTextUpdateInfo.mNumberOfCharactersToAdd    = mModel->mLogicalModel->mText.Count();
1888
1889   mTextUpdateInfo.mClearAll           = true;
1890   mTextUpdateInfo.mFullRelayoutNeeded = true;
1891   mRecalculateNaturalSize             = true;
1892
1893   mOperationsPending = static_cast<OperationsMask>(mOperationsPending |
1894                                                    VALIDATE_FONTS |
1895                                                    SHAPE_TEXT |
1896                                                    BIDI_INFO |
1897                                                    GET_GLYPH_METRICS |
1898                                                    LAYOUT |
1899                                                    UPDATE_LAYOUT_SIZE |
1900                                                    REORDER |
1901                                                    ALIGN);
1902 }
1903
1904 void Controller::Impl::ClearStyleData()
1905 {
1906   mModel->mLogicalModel->mColorRuns.Clear();
1907   mModel->mLogicalModel->ClearFontDescriptionRuns();
1908   mModel->mLogicalModel->ClearStrikethroughRuns();
1909 }
1910
1911 void Controller::Impl::ResetScrollPosition()
1912 {
1913   if(mEventData)
1914   {
1915     // Reset the scroll position.
1916     mModel->mScrollPosition                = Vector2::ZERO;
1917     mEventData->mScrollAfterUpdatePosition = true;
1918   }
1919 }
1920
1921 } // namespace Dali::Toolkit::Text