Merge "Support YUV decoding for JPEG" into devel/master
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / text / text-controller.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.h>
20
21 // EXTERNAL INCLUDES
22 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
23 #include <dali/devel-api/adaptor-framework/window-devel.h>
24 #include <dali/integration-api/debug.h>
25 #include <memory.h>
26 #include <cmath>
27 #include <limits>
28
29 // INTERNAL INCLUDES
30 #include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
31 #include <dali-toolkit/internal/text/text-controller-background-actor.h>
32 #include <dali-toolkit/internal/text/text-controller-event-handler.h>
33 #include <dali-toolkit/internal/text/text-controller-impl.h>
34 #include <dali-toolkit/internal/text/text-controller-input-font-handler.h>
35 #include <dali-toolkit/internal/text/text-controller-input-properties.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-controller-text-updater.h>
39 #include <dali-toolkit/internal/text/text-editable-control-interface.h>
40 #include <dali-toolkit/internal/text/text-geometry.h>
41
42 namespace
43 {
44 #if defined(DEBUG_ENABLED)
45 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
46 #endif
47
48 const std::string EMPTY_STRING("");
49
50 template<typename Type>
51 void EnsureCreated(Type*& object)
52 {
53   if(!object)
54   {
55     object = new Type();
56   }
57 }
58
59 template<typename Type>
60 void EnsureCreated(std::unique_ptr<Type>& object)
61 {
62   if(!object)
63   {
64     object = std::unique_ptr<Type>(new Type());
65   }
66 }
67
68 template<typename Type, typename Arg1>
69 void EnsureCreated(Type*& object, Arg1 arg1)
70 {
71   if(!object)
72   {
73     object = new Type(arg1);
74   }
75 }
76
77 template<typename Type, typename Arg1, typename Arg2>
78 void EnsureCreated(Type*& object, Arg1 arg1, Arg2 arg2)
79 {
80   if(!object)
81   {
82     object = new Type(arg1, arg2);
83   }
84 }
85
86 float GetDpi()
87 {
88   unsigned int                      horizontalDpi = 0u;
89   unsigned int                      verticalDpi   = 0u;
90   Dali::TextAbstraction::FontClient fontClient    = Dali::TextAbstraction::FontClient::Get();
91   fontClient.GetDpi(horizontalDpi, verticalDpi);
92   return static_cast<float>(horizontalDpi);
93 }
94
95 float ConvertPixelToPoint(float pixel)
96 {
97   return pixel * 72.0f / GetDpi();
98 }
99
100 float ConvertPointToPixel(float point)
101 {
102   // Pixel size = Point size * DPI / 72.f
103   return point * GetDpi() / 72.0f;
104 }
105
106 void UpdateCursorPosition(Dali::Toolkit::Text::EventData* eventData)
107 {
108   if(eventData && Dali::Toolkit::Text::EventData::IsEditingState(eventData->mState))
109   {
110     // Update the cursor position if it's in editing mode
111     eventData->mDecoratorUpdated     = true;
112     eventData->mUpdateCursorPosition = true; // Cursor position should be updated when the font size is updated.
113   }
114 }
115
116 } // namespace
117
118 namespace Dali::Toolkit::Text
119 {
120 void Controller::EnableTextInput(DecoratorPtr decorator, InputMethodContext& inputMethodContext)
121 {
122   if(!decorator)
123   {
124     delete mImpl->mEventData;
125     mImpl->mEventData = NULL;
126
127     // Nothing else to do.
128     return;
129   }
130
131   EnsureCreated(mImpl->mEventData, decorator, inputMethodContext);
132 }
133
134 void Controller::SetGlyphType(TextAbstraction::GlyphType glyphType)
135 {
136   // Metrics for bitmap & vector based glyphs are different
137   mImpl->mMetrics->SetGlyphType(glyphType);
138
139   // Clear the font-specific data
140   mImpl->ClearFontData();
141
142   mImpl->RequestRelayout();
143 }
144
145 void Controller::SetMarkupProcessorEnabled(bool enable)
146 {
147   if(enable != mImpl->mMarkupProcessorEnabled)
148   {
149     //If Text was already set, call the SetText again for enabling or disabling markup
150     mImpl->mMarkupProcessorEnabled = enable;
151     std::string text;
152     GetText(text);
153     SetText(text);
154   }
155
156   mImpl->mModel->mVisualModel->SetMarkupProcessorEnabled(enable);
157 }
158
159 bool Controller::IsMarkupProcessorEnabled() const
160 {
161   return mImpl->mMarkupProcessorEnabled;
162 }
163
164 bool Controller::HasAnchors() const
165 {
166   return (mImpl->mMarkupProcessorEnabled && mImpl->mModel->mLogicalModel->mAnchors.Count() && mImpl->IsShowingRealText());
167 }
168
169 void Controller::SetAutoScrollEnabled(bool enable)
170 {
171   DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled[%s] SingleBox[%s]-> [%p]\n", (enable) ? "true" : "false", (mImpl->mLayoutEngine.GetLayout() == Layout::Engine::SINGLE_LINE_BOX) ? "true" : "false", this);
172   mImpl->SetAutoScrollEnabled(enable);
173 }
174
175 void Controller::SetAutoScrollMaxTextureExceeded(bool exceed)
176 {
177   mImpl->mIsAutoScrollMaxTextureExceeded = exceed;
178 }
179
180 bool Controller::IsAutoScrollEnabled() const
181 {
182   DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::IsAutoScrollEnabled[%s]\n", mImpl->mIsAutoScrollEnabled ? "true" : "false");
183   return mImpl->mIsAutoScrollEnabled;
184 }
185
186 CharacterDirection Controller::GetAutoScrollDirection() const
187 {
188   return mImpl->mIsTextDirectionRTL;
189 }
190
191 float Controller::GetAutoScrollLineAlignment() const
192 {
193   float offset = 0.f;
194   if(mImpl->mModel->mVisualModel && (0u != mImpl->mModel->mVisualModel->mLines.Count()))
195   {
196     offset = (*mImpl->mModel->mVisualModel->mLines.Begin()).alignmentOffset;
197   }
198   return offset;
199 }
200
201 void Controller::SetHorizontalScrollEnabled(bool enable)
202 {
203   if(mImpl->mEventData && mImpl->mEventData->mDecorator)
204   {
205     mImpl->mEventData->mDecorator->SetHorizontalScrollEnabled(enable);
206   }
207 }
208
209 bool Controller::IsHorizontalScrollEnabled() const
210 {
211   return mImpl->mEventData && mImpl->mEventData->mDecorator && mImpl->mEventData->mDecorator->IsHorizontalScrollEnabled();
212 }
213
214 void Controller::SetVerticalScrollEnabled(bool enable)
215 {
216   if(mImpl->mEventData && mImpl->mEventData->mDecorator)
217   {
218     mImpl->mEventData->mDecorator->SetVerticalScrollEnabled(enable);
219   }
220 }
221
222 bool Controller::IsVerticalScrollEnabled() const
223 {
224   return mImpl->mEventData && mImpl->mEventData->mDecorator && mImpl->mEventData->mDecorator->IsVerticalScrollEnabled();
225 }
226
227 void Controller::SetSmoothHandlePanEnabled(bool enable)
228 {
229   if(mImpl->mEventData && mImpl->mEventData->mDecorator)
230   {
231     mImpl->mEventData->mDecorator->SetSmoothHandlePanEnabled(enable);
232   }
233 }
234
235 bool Controller::IsSmoothHandlePanEnabled() const
236 {
237   return mImpl->mEventData && mImpl->mEventData->mDecorator && mImpl->mEventData->mDecorator->IsSmoothHandlePanEnabled();
238 }
239
240 void Controller::SetMaximumNumberOfCharacters(Length maxCharacters)
241 {
242   mImpl->mMaximumNumberOfCharacters = maxCharacters;
243 }
244
245 int Controller::GetMaximumNumberOfCharacters()
246 {
247   return mImpl->mMaximumNumberOfCharacters;
248 }
249
250 void Controller::SetEnableCursorBlink(bool enable)
251 {
252   mImpl->SetEnableCursorBlink(enable);
253 }
254
255 bool Controller::GetEnableCursorBlink() const
256 {
257   return mImpl->mEventData && mImpl->mEventData->mCursorBlinkEnabled;
258 }
259
260 void Controller::SetMultiLineEnabled(bool enable)
261 {
262   mImpl->SetMultiLineEnabled(enable);
263 }
264
265 bool Controller::IsMultiLineEnabled() const
266 {
267   return Layout::Engine::MULTI_LINE_BOX == mImpl->mLayoutEngine.GetLayout();
268 }
269
270 void Controller::SetHorizontalAlignment(Text::HorizontalAlignment::Type alignment)
271 {
272   mImpl->SetHorizontalAlignment(alignment);
273 }
274
275 Text::HorizontalAlignment::Type Controller::GetHorizontalAlignment() const
276 {
277   return mImpl->mModel->mHorizontalAlignment;
278 }
279
280 void Controller::SetVerticalAlignment(VerticalAlignment::Type alignment)
281 {
282   mImpl->SetVerticalAlignment(alignment);
283 }
284
285 VerticalAlignment::Type Controller::GetVerticalAlignment() const
286 {
287   return mImpl->mModel->mVerticalAlignment;
288 }
289
290 bool Controller::IsIgnoreSpacesAfterText() const
291 {
292   return mImpl->mModel->mIgnoreSpacesAfterText;
293 }
294
295 void Controller::SetIgnoreSpacesAfterText(bool ignore)
296 {
297   mImpl->mModel->mIgnoreSpacesAfterText = ignore;
298 }
299
300 void Controller::ChangedLayoutDirection()
301 {
302   mImpl->mIsLayoutDirectionChanged = true;
303 }
304
305 void Controller::SetMatchLayoutDirection(DevelText::MatchLayoutDirection type)
306 {
307   mImpl->mModel->mMatchLayoutDirection = type;
308 }
309
310 DevelText::MatchLayoutDirection Controller::GetMatchLayoutDirection() const
311 {
312   return mImpl->mModel->mMatchLayoutDirection;
313 }
314
315 void Controller::SetLayoutDirection(Dali::LayoutDirection::Type layoutDirection)
316 {
317   mImpl->mLayoutDirection = layoutDirection;
318 }
319
320 Dali::LayoutDirection::Type Controller::GetLayoutDirection(Dali::Actor& actor) const
321 {
322   return mImpl->GetLayoutDirection(actor);
323 }
324
325 bool Controller::IsShowingRealText() const
326 {
327   return mImpl->IsShowingRealText();
328 }
329
330 void Controller::SetLineWrapMode(Text::LineWrap::Mode lineWrapMode)
331 {
332   mImpl->SetLineWrapMode(lineWrapMode);
333 }
334
335 Text::LineWrap::Mode Controller::GetLineWrapMode() const
336 {
337   return mImpl->mModel->mLineWrapMode;
338 }
339
340 void Controller::SetTextElideEnabled(bool enabled)
341 {
342   mImpl->mModel->mElideEnabled = enabled;
343   mImpl->mModel->mVisualModel->SetTextElideEnabled(enabled);
344 }
345
346 bool Controller::IsTextElideEnabled() const
347 {
348   return mImpl->mModel->mElideEnabled;
349 }
350
351 void Controller::SetTextFitEnabled(bool enabled)
352 {
353   mImpl->mTextFitEnabled = enabled;
354 }
355
356 bool Controller::IsTextFitEnabled() const
357 {
358   return mImpl->mTextFitEnabled;
359 }
360
361 void Controller::SetTextFitChanged(bool changed)
362 {
363   mImpl->mTextFitChanged = changed;
364 }
365
366 bool Controller::IsTextFitChanged() const
367 {
368   return mImpl->mTextFitChanged;
369 }
370
371 void Controller::SetTextFitMinSize(float minSize, FontSizeType type)
372 {
373   mImpl->mTextFitMinSize = (type == POINT_SIZE) ? minSize : ConvertPixelToPoint(minSize);
374 }
375
376 float Controller::GetTextFitMinSize() const
377 {
378   return mImpl->mTextFitMinSize;
379 }
380
381 void Controller::SetTextFitMaxSize(float maxSize, FontSizeType type)
382 {
383   mImpl->mTextFitMaxSize = (type == POINT_SIZE) ? maxSize : ConvertPixelToPoint(maxSize);
384 }
385
386 float Controller::GetTextFitMaxSize() const
387 {
388   return mImpl->mTextFitMaxSize;
389 }
390
391 void Controller::SetTextFitStepSize(float step, FontSizeType type)
392 {
393   mImpl->mTextFitStepSize = (type == POINT_SIZE) ? step : ConvertPixelToPoint(step);
394 }
395
396 float Controller::GetTextFitStepSize() const
397 {
398   return mImpl->mTextFitStepSize;
399 }
400
401 void Controller::SetTextFitContentSize(Vector2 size)
402 {
403   mImpl->mTextFitContentSize = size;
404 }
405
406 Vector2 Controller::GetTextFitContentSize() const
407 {
408   return mImpl->mTextFitContentSize;
409 }
410
411 float Controller::GetTextFitPointSize() const
412 {
413   return mImpl->mFontDefaults ? mImpl->mFontDefaults->mFitPointSize : 0.0f;
414 }
415
416 void Controller::SetPlaceholderTextElideEnabled(bool enabled)
417 {
418   PlaceholderHandler::SetPlaceholderTextElideEnabled(*this, enabled);
419 }
420
421 bool Controller::IsPlaceholderTextElideEnabled() const
422 {
423   return PlaceholderHandler::IsPlaceholderTextElideEnabled(*this);
424 }
425
426 void Controller::SetSelectionEnabled(bool enabled)
427 {
428   mImpl->mEventData->mSelectionEnabled = enabled;
429 }
430
431 bool Controller::IsSelectionEnabled() const
432 {
433   return mImpl->mEventData->mSelectionEnabled;
434 }
435
436 void Controller::SetShiftSelectionEnabled(bool enabled)
437 {
438   mImpl->mEventData->mShiftSelectionFlag = enabled;
439 }
440
441 bool Controller::IsShiftSelectionEnabled() const
442 {
443   return mImpl->mEventData->mShiftSelectionFlag;
444 }
445
446 void Controller::SetGrabHandleEnabled(bool enabled)
447 {
448   mImpl->mEventData->mGrabHandleEnabled = enabled;
449 }
450
451 bool Controller::IsGrabHandleEnabled() const
452 {
453   return mImpl->mEventData->mGrabHandleEnabled;
454 }
455
456 void Controller::SetGrabHandlePopupEnabled(bool enabled)
457 {
458   mImpl->mEventData->mGrabHandlePopupEnabled = enabled;
459 }
460
461 bool Controller::IsGrabHandlePopupEnabled() const
462 {
463   return mImpl->mEventData->mGrabHandlePopupEnabled;
464 }
465
466 void Controller::SetText(const std::string& text)
467 {
468   TextUpdater::SetText(*this, text);
469 }
470
471 void Controller::GetText(std::string& text) const
472 {
473   mImpl->GetText(text);
474 }
475
476 void Controller::SetPlaceholderText(PlaceholderType type, const std::string& text)
477 {
478   PlaceholderHandler::SetPlaceholderText(*this, type, text);
479 }
480
481 void Controller::GetPlaceholderText(PlaceholderType type, std::string& text) const
482 {
483   PlaceholderHandler::GetPlaceholderText(*this, type, text);
484 }
485
486 void Controller::UpdateAfterFontChange(const std::string& newDefaultFont)
487 {
488   mImpl->UpdateAfterFontChange(newDefaultFont);
489 }
490
491 void Controller::RetrieveSelection(std::string& selectedText) const
492 {
493   mImpl->RetrieveSelection(selectedText, false);
494 }
495
496 void Controller::SetSelection(int start, int end)
497 {
498   mImpl->SetSelection(start, end);
499 }
500
501 std::pair<int, int> Controller::GetSelectionIndexes() const
502 {
503   return mImpl->GetSelectionIndexes();
504 }
505
506 void Controller::CopyStringToClipboard(const std::string& source)
507 {
508   mImpl->CopyStringToClipboard(source);
509 }
510
511 void Controller::SendSelectionToClipboard(bool deleteAfterSending)
512 {
513   mImpl->SendSelectionToClipboard(deleteAfterSending);
514 }
515
516 void Controller::SetDefaultFontFamily(const std::string& defaultFontFamily)
517 {
518   EnsureCreated(mImpl->mFontDefaults);
519
520   mImpl->mFontDefaults->mFontDescription.family = defaultFontFamily;
521   DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetDefaultFontFamily %s\n", defaultFontFamily.c_str());
522   mImpl->mFontDefaults->familyDefined = !defaultFontFamily.empty();
523
524   // Update the cursor position if it's in editing mode
525   UpdateCursorPosition(mImpl->mEventData);
526
527   // Clear the font-specific data
528   mImpl->ClearFontData();
529
530   mImpl->RequestRelayout();
531 }
532
533 const std::string& Controller::GetDefaultFontFamily() const
534 {
535   return mImpl->mFontDefaults ? mImpl->mFontDefaults->mFontDescription.family : EMPTY_STRING;
536 }
537
538 void Controller::SetPlaceholderFontFamily(const std::string& placeholderTextFontFamily)
539 {
540   PlaceholderHandler::SetPlaceholderFontFamily(*this, placeholderTextFontFamily);
541 }
542
543 const std::string& Controller::GetPlaceholderFontFamily() const
544 {
545   return PlaceholderHandler::GetPlaceholderFontFamily(*this);
546 }
547
548 void Controller::SetDefaultFontWeight(FontWeight weight)
549 {
550   EnsureCreated(mImpl->mFontDefaults);
551
552   mImpl->mFontDefaults->mFontDescription.weight = weight;
553   mImpl->mFontDefaults->weightDefined           = true;
554
555   // Update the cursor position if it's in editing mode
556   UpdateCursorPosition(mImpl->mEventData);
557
558   // Clear the font-specific data
559   mImpl->ClearFontData();
560
561   mImpl->RequestRelayout();
562 }
563
564 bool Controller::IsDefaultFontWeightDefined() const
565 {
566   return mImpl->mFontDefaults && mImpl->mFontDefaults->weightDefined;
567 }
568
569 FontWeight Controller::GetDefaultFontWeight() const
570 {
571   return mImpl->mFontDefaults ? mImpl->mFontDefaults->mFontDescription.weight : TextAbstraction::FontWeight::NORMAL;
572 }
573
574 void Controller::SetPlaceholderTextFontWeight(FontWeight weight)
575 {
576   PlaceholderHandler::SetPlaceholderTextFontWeight(*this, weight);
577 }
578
579 bool Controller::IsPlaceholderTextFontWeightDefined() const
580 {
581   return PlaceholderHandler::IsPlaceholderTextFontWeightDefined(*this);
582 }
583
584 FontWeight Controller::GetPlaceholderTextFontWeight() const
585 {
586   return PlaceholderHandler::GetPlaceholderTextFontWeight(*this);
587 }
588
589 void Controller::SetDefaultFontWidth(FontWidth width)
590 {
591   EnsureCreated(mImpl->mFontDefaults);
592
593   mImpl->mFontDefaults->mFontDescription.width = width;
594   mImpl->mFontDefaults->widthDefined           = true;
595
596   // Update the cursor position if it's in editing mode
597   UpdateCursorPosition(mImpl->mEventData);
598
599   // Clear the font-specific data
600   mImpl->ClearFontData();
601
602   mImpl->RequestRelayout();
603 }
604
605 bool Controller::IsDefaultFontWidthDefined() const
606 {
607   return mImpl->mFontDefaults && mImpl->mFontDefaults->widthDefined;
608 }
609
610 FontWidth Controller::GetDefaultFontWidth() const
611 {
612   return mImpl->mFontDefaults ? mImpl->mFontDefaults->mFontDescription.width : TextAbstraction::FontWidth::NORMAL;
613 }
614
615 void Controller::SetPlaceholderTextFontWidth(FontWidth width)
616 {
617   PlaceholderHandler::SetPlaceholderTextFontWidth(*this, width);
618 }
619
620 bool Controller::IsPlaceholderTextFontWidthDefined() const
621 {
622   return PlaceholderHandler::IsPlaceholderTextFontWidthDefined(*this);
623 }
624
625 FontWidth Controller::GetPlaceholderTextFontWidth() const
626 {
627   return PlaceholderHandler::GetPlaceholderTextFontWidth(*this);
628 }
629
630 void Controller::SetDefaultFontSlant(FontSlant slant)
631 {
632   EnsureCreated(mImpl->mFontDefaults);
633
634   mImpl->mFontDefaults->mFontDescription.slant = slant;
635   mImpl->mFontDefaults->slantDefined           = true;
636
637   // Update the cursor position if it's in editing mode
638   UpdateCursorPosition(mImpl->mEventData);
639
640   // Clear the font-specific data
641   mImpl->ClearFontData();
642
643   mImpl->RequestRelayout();
644 }
645
646 bool Controller::IsDefaultFontSlantDefined() const
647 {
648   return mImpl->mFontDefaults && mImpl->mFontDefaults->slantDefined;
649 }
650
651 FontSlant Controller::GetDefaultFontSlant() const
652 {
653   return mImpl->mFontDefaults ? mImpl->mFontDefaults->mFontDescription.slant : TextAbstraction::FontSlant::NORMAL;
654 }
655
656 void Controller::SetPlaceholderTextFontSlant(FontSlant slant)
657 {
658   PlaceholderHandler::SetPlaceholderTextFontSlant(*this, slant);
659 }
660
661 bool Controller::IsPlaceholderTextFontSlantDefined() const
662 {
663   return PlaceholderHandler::IsPlaceholderTextFontSlantDefined(*this);
664 }
665
666 FontSlant Controller::GetPlaceholderTextFontSlant() const
667 {
668   return PlaceholderHandler::GetPlaceholderTextFontSlant(*this);
669 }
670
671 void Controller::SetFontSizeScale(float scale)
672 {
673   mImpl->mFontSizeScale = scale;
674
675   // No relayout is required
676   if(!mImpl->mFontSizeScaleEnabled) return;
677
678   // Update the cursor position if it's in editing mode
679   UpdateCursorPosition(mImpl->mEventData);
680
681   // Clear the font-specific data
682   mImpl->ClearFontData();
683
684   mImpl->RequestRelayout();
685 }
686
687 float Controller::GetFontSizeScale() const
688 {
689   return mImpl->mFontDefaults ? mImpl->mFontSizeScale : 1.0f;
690 }
691
692 void Controller::SetFontSizeScaleEnabled(bool enabled)
693 {
694   mImpl->mFontSizeScaleEnabled = enabled;
695
696   // Update the cursor position if it's in editing mode
697   UpdateCursorPosition(mImpl->mEventData);
698
699   // Clear the font-specific data
700   mImpl->ClearFontData();
701
702   mImpl->RequestRelayout();
703 }
704
705 bool Controller::IsFontSizeScaleEnabled() const
706 {
707   return mImpl->mFontSizeScaleEnabled;
708 }
709
710 void Controller::SetDefaultFontSize(float fontSize, FontSizeType type)
711 {
712   EnsureCreated(mImpl->mFontDefaults);
713
714   mImpl->mFontDefaults->mDefaultPointSize = (type == POINT_SIZE) ? fontSize : ConvertPixelToPoint(fontSize);
715   mImpl->mFontDefaults->sizeDefined       = true;
716
717   // Update the cursor position if it's in editing mode
718   UpdateCursorPosition(mImpl->mEventData);
719
720   // Clear the font-specific data
721   mImpl->ClearFontData();
722
723   mImpl->RequestRelayout();
724 }
725
726 float Controller::GetDefaultFontSize(FontSizeType type) const
727 {
728   if(mImpl->mFontDefaults)
729   {
730     return (type == POINT_SIZE) ? mImpl->mFontDefaults->mDefaultPointSize : ConvertPointToPixel(mImpl->mFontDefaults->mDefaultPointSize);
731   }
732   return 0.0f;
733 }
734
735 void Controller::SetPlaceholderTextFontSize(float fontSize, FontSizeType type)
736 {
737   PlaceholderHandler::SetPlaceholderTextFontSize(*this, fontSize, type);
738 }
739
740 float Controller::GetPlaceholderTextFontSize(FontSizeType type) const
741 {
742   return PlaceholderHandler::GetPlaceholderTextFontSize(*this, type);
743 }
744
745 void Controller::SetDefaultColor(const Vector4& color)
746 {
747   mImpl->SetDefaultColor(color);
748 }
749
750 const Vector4& Controller::GetDefaultColor() const
751 {
752   return mImpl->mTextColor;
753 }
754
755 void Controller::SetDisabledColorOpacity(float opacity)
756 {
757   mImpl->mDisabledColorOpacity = opacity;
758 }
759
760 float Controller::GetDisabledColorOpacity() const
761 {
762   return mImpl->mDisabledColorOpacity;
763 }
764
765 void Controller::SetUserInteractionEnabled(bool enabled)
766 {
767   mImpl->SetUserInteractionEnabled(enabled);
768 }
769
770 bool Controller::IsUserInteractionEnabled() const
771 {
772   return mImpl->mIsUserInteractionEnabled;
773 }
774
775 void Controller::SetPlaceholderTextColor(const Vector4& textColor)
776 {
777   PlaceholderHandler::SetPlaceholderTextColor(*this, textColor);
778 }
779
780 const Vector4& Controller::GetPlaceholderTextColor() const
781 {
782   return PlaceholderHandler::GetPlaceholderTextColor(*this);
783 }
784
785 void Controller::SetShadowOffset(const Vector2& shadowOffset)
786 {
787   mImpl->mModel->mVisualModel->SetShadowOffset(shadowOffset);
788   mImpl->RequestRelayout();
789 }
790
791 const Vector2& Controller::GetShadowOffset() const
792 {
793   return mImpl->mModel->mVisualModel->GetShadowOffset();
794 }
795
796 void Controller::SetShadowColor(const Vector4& shadowColor)
797 {
798   mImpl->mModel->mVisualModel->SetShadowColor(shadowColor);
799   mImpl->RequestRelayout();
800 }
801
802 const Vector4& Controller::GetShadowColor() const
803 {
804   return mImpl->mModel->mVisualModel->GetShadowColor();
805 }
806
807 void Controller::SetShadowBlurRadius(const float& shadowBlurRadius)
808 {
809   if(fabsf(GetShadowBlurRadius() - shadowBlurRadius) > Math::MACHINE_EPSILON_1)
810   {
811     mImpl->mModel->mVisualModel->SetShadowBlurRadius(shadowBlurRadius);
812     mImpl->RequestRelayout();
813   }
814 }
815
816 const float& Controller::GetShadowBlurRadius() const
817 {
818   return mImpl->mModel->mVisualModel->GetShadowBlurRadius();
819 }
820
821 void Controller::SetUnderlineColor(const Vector4& color)
822 {
823   mImpl->mModel->mVisualModel->SetUnderlineColor(color);
824   mImpl->RequestRelayout();
825 }
826
827 const Vector4& Controller::GetUnderlineColor() const
828 {
829   return mImpl->mModel->mVisualModel->GetUnderlineColor();
830 }
831
832 void Controller::SetUnderlineEnabled(bool enabled)
833 {
834   mImpl->mModel->mVisualModel->SetUnderlineEnabled(enabled);
835   mImpl->RequestRelayout();
836 }
837
838 bool Controller::IsUnderlineEnabled() const
839 {
840   return mImpl->mModel->mVisualModel->IsUnderlineEnabled();
841 }
842
843 void Controller::SetUnderlineHeight(float height)
844 {
845   mImpl->mModel->mVisualModel->SetUnderlineHeight(height);
846   mImpl->RequestRelayout();
847 }
848
849 float Controller::GetUnderlineHeight() const
850 {
851   return mImpl->mModel->mVisualModel->GetUnderlineHeight();
852 }
853
854 void Controller::SetUnderlineType(Text::Underline::Type type)
855 {
856   mImpl->mModel->mVisualModel->SetUnderlineType(type);
857
858   mImpl->RequestRelayout();
859 }
860
861 Text::Underline::Type Controller::GetUnderlineType() const
862 {
863   return mImpl->mModel->mVisualModel->GetUnderlineType();
864 }
865
866 void Controller::SetDashedUnderlineWidth(float width)
867 {
868   mImpl->mModel->mVisualModel->SetDashedUnderlineWidth(width);
869
870   mImpl->RequestRelayout();
871 }
872
873 float Controller::GetDashedUnderlineWidth() const
874 {
875   return mImpl->mModel->mVisualModel->GetDashedUnderlineWidth();
876 }
877
878 void Controller::SetDashedUnderlineGap(float gap)
879 {
880   mImpl->mModel->mVisualModel->SetDashedUnderlineGap(gap);
881
882   mImpl->RequestRelayout();
883 }
884
885 float Controller::GetDashedUnderlineGap() const
886 {
887   return mImpl->mModel->mVisualModel->GetDashedUnderlineGap();
888 }
889
890 void Controller::SetOutlineColor(const Vector4& color)
891 {
892   mImpl->mModel->mVisualModel->SetOutlineColor(color);
893   mImpl->RequestRelayout();
894 }
895
896 const Vector4& Controller::GetOutlineColor() const
897 {
898   return mImpl->mModel->mVisualModel->GetOutlineColor();
899 }
900
901 void Controller::SetOutlineWidth(uint16_t width)
902 {
903   mImpl->mModel->mVisualModel->SetOutlineWidth(width);
904   mImpl->RequestRelayout();
905 }
906
907 uint16_t Controller::GetOutlineWidth() const
908 {
909   return mImpl->mModel->mVisualModel->GetOutlineWidth();
910 }
911
912 void Controller::SetBackgroundColor(const Vector4& color)
913 {
914   mImpl->mModel->mVisualModel->SetBackgroundColor(color);
915   mImpl->RequestRelayout();
916 }
917
918 const Vector4& Controller::GetBackgroundColor() const
919 {
920   return mImpl->mModel->mVisualModel->GetBackgroundColor();
921 }
922
923 void Controller::SetBackgroundEnabled(bool enabled)
924 {
925   mImpl->mModel->mVisualModel->SetBackgroundEnabled(enabled);
926   mImpl->RequestRelayout();
927 }
928
929 bool Controller::IsBackgroundEnabled() const
930 {
931   return mImpl->mModel->mVisualModel->IsBackgroundEnabled();
932 }
933
934 void Controller::SetDefaultEmbossProperties(const std::string& embossProperties)
935 {
936   EnsureCreated(mImpl->mEmbossDefaults);
937   mImpl->mEmbossDefaults->properties = embossProperties;
938 }
939
940 const std::string& Controller::GetDefaultEmbossProperties() const
941 {
942   return mImpl->mEmbossDefaults ? mImpl->mEmbossDefaults->properties : EMPTY_STRING;
943 }
944
945 void Controller::SetDefaultOutlineProperties(const std::string& outlineProperties)
946 {
947   EnsureCreated(mImpl->mOutlineDefaults);
948   mImpl->mOutlineDefaults->properties = outlineProperties;
949 }
950
951 const std::string& Controller::GetDefaultOutlineProperties() const
952 {
953   return mImpl->mOutlineDefaults ? mImpl->mOutlineDefaults->properties : EMPTY_STRING;
954 }
955
956 bool Controller::SetDefaultLineSpacing(float lineSpacing)
957 {
958   return mImpl->SetDefaultLineSpacing(lineSpacing);
959 }
960
961 float Controller::GetDefaultLineSpacing() const
962 {
963   return mImpl->mLayoutEngine.GetDefaultLineSpacing();
964 }
965
966 bool Controller::SetDefaultLineSize(float lineSize)
967 {
968   return mImpl->SetDefaultLineSize(lineSize);
969 }
970
971 float Controller::GetDefaultLineSize() const
972 {
973   return mImpl->mLayoutEngine.GetDefaultLineSize();
974 }
975
976 bool Controller::SetRelativeLineSize(float relativeLineSize)
977 {
978   return mImpl->SetRelativeLineSize(relativeLineSize);
979 }
980
981 float Controller::GetRelativeLineSize() const
982 {
983   return mImpl->GetRelativeLineSize();
984 }
985
986 void Controller::SetInputColor(const Vector4& color)
987 {
988   InputProperties::SetInputColor(*this, color);
989 }
990
991 const Vector4& Controller::GetInputColor() const
992 {
993   return InputProperties::GetInputColor(*this);
994 }
995
996 void Controller::SetInputFontFamily(const std::string& fontFamily)
997 {
998   InputFontHandler::SetInputFontFamily(*this, fontFamily);
999 }
1000
1001 const std::string& Controller::GetInputFontFamily() const
1002 {
1003   return InputFontHandler::GetInputFontFamily(*this);
1004 }
1005
1006 void Controller::SetInputFontWeight(FontWeight weight)
1007 {
1008   InputFontHandler::SetInputFontWeight(*this, weight);
1009 }
1010
1011 bool Controller::IsInputFontWeightDefined() const
1012 {
1013   return InputFontHandler::IsInputFontWeightDefined(*this);
1014 }
1015
1016 FontWeight Controller::GetInputFontWeight() const
1017 {
1018   return InputFontHandler::GetInputFontWeight(*this);
1019 }
1020
1021 void Controller::SetInputFontWidth(FontWidth width)
1022 {
1023   InputFontHandler::SetInputFontWidth(*this, width);
1024 }
1025
1026 bool Controller::IsInputFontWidthDefined() const
1027 {
1028   return InputFontHandler::IsInputFontWidthDefined(*this);
1029 }
1030
1031 FontWidth Controller::GetInputFontWidth() const
1032 {
1033   return InputFontHandler::GetInputFontWidth(*this);
1034 }
1035
1036 void Controller::SetInputFontSlant(FontSlant slant)
1037 {
1038   InputFontHandler::SetInputFontSlant(*this, slant);
1039 }
1040
1041 bool Controller::IsInputFontSlantDefined() const
1042 {
1043   return InputFontHandler::IsInputFontSlantDefined(*this);
1044 }
1045
1046 FontSlant Controller::GetInputFontSlant() const
1047 {
1048   return InputFontHandler::GetInputFontSlant(*this);
1049 }
1050
1051 void Controller::SetInputFontPointSize(float size)
1052 {
1053   InputFontHandler::SetInputFontPointSize(*this, size);
1054 }
1055
1056 float Controller::GetInputFontPointSize() const
1057 {
1058   return InputFontHandler::GetInputFontPointSize(*this);
1059 }
1060
1061 void Controller::SetInputLineSpacing(float lineSpacing)
1062 {
1063   InputProperties::SetInputLineSpacing(*this, lineSpacing);
1064 }
1065
1066 float Controller::GetInputLineSpacing() const
1067 {
1068   return InputProperties::GetInputLineSpacing(*this);
1069 }
1070
1071 void Controller::SetInputShadowProperties(const std::string& shadowProperties)
1072 {
1073   InputProperties::SetInputShadowProperties(*this, shadowProperties);
1074 }
1075
1076 const std::string& Controller::GetInputShadowProperties() const
1077 {
1078   return InputProperties::GetInputShadowProperties(*this);
1079 }
1080
1081 void Controller::SetInputUnderlineProperties(const std::string& underlineProperties)
1082 {
1083   InputProperties::SetInputUnderlineProperties(*this, underlineProperties);
1084 }
1085
1086 const std::string& Controller::GetInputUnderlineProperties() const
1087 {
1088   return InputProperties::GetInputUnderlineProperties(*this);
1089 }
1090
1091 void Controller::SetInputEmbossProperties(const std::string& embossProperties)
1092 {
1093   InputProperties::SetInputEmbossProperties(*this, embossProperties);
1094 }
1095
1096 const std::string& Controller::GetInputEmbossProperties() const
1097 {
1098   return InputProperties::GetInputEmbossProperties(*this);
1099 }
1100
1101 void Controller::SetInputOutlineProperties(const std::string& outlineProperties)
1102 {
1103   InputProperties::SetInputOutlineProperties(*this, outlineProperties);
1104 }
1105
1106 const std::string& Controller::GetInputOutlineProperties() const
1107 {
1108   return InputProperties::GetInputOutlineProperties(*this);
1109 }
1110
1111 void Controller::SetInputModePassword(bool passwordInput)
1112 {
1113   InputProperties::SetInputModePassword(*this, passwordInput);
1114 }
1115
1116 bool Controller::IsInputModePassword()
1117 {
1118   return InputProperties::IsInputModePassword(*this);
1119 }
1120
1121 void Controller::SetNoTextDoubleTapAction(NoTextTap::Action action)
1122 {
1123   if(mImpl->mEventData)
1124   {
1125     mImpl->mEventData->mDoubleTapAction = action;
1126   }
1127 }
1128
1129 Controller::NoTextTap::Action Controller::GetNoTextDoubleTapAction() const
1130 {
1131   return mImpl->mEventData ? mImpl->mEventData->mDoubleTapAction : NoTextTap::NO_ACTION;
1132 }
1133
1134 void Controller::SetNoTextLongPressAction(NoTextTap::Action action)
1135 {
1136   if(mImpl->mEventData)
1137   {
1138     mImpl->mEventData->mLongPressAction = action;
1139   }
1140 }
1141
1142 Controller::NoTextTap::Action Controller::GetNoTextLongPressAction() const
1143 {
1144   return mImpl->mEventData ? mImpl->mEventData->mLongPressAction : NoTextTap::NO_ACTION;
1145 }
1146
1147 bool Controller::IsUnderlineSetByString()
1148 {
1149   return mImpl->mUnderlineSetByString;
1150 }
1151
1152 void Controller::UnderlineSetByString(bool setByString)
1153 {
1154   mImpl->mUnderlineSetByString = setByString;
1155 }
1156
1157 bool Controller::IsShadowSetByString()
1158 {
1159   return mImpl->mShadowSetByString;
1160 }
1161
1162 void Controller::ShadowSetByString(bool setByString)
1163 {
1164   mImpl->mShadowSetByString = setByString;
1165 }
1166
1167 bool Controller::IsOutlineSetByString()
1168 {
1169   return mImpl->mOutlineSetByString;
1170 }
1171
1172 void Controller::OutlineSetByString(bool setByString)
1173 {
1174   mImpl->mOutlineSetByString = setByString;
1175 }
1176
1177 bool Controller::IsFontStyleSetByString()
1178 {
1179   return mImpl->mFontStyleSetByString;
1180 }
1181
1182 void Controller::FontStyleSetByString(bool setByString)
1183 {
1184   mImpl->mFontStyleSetByString = setByString;
1185 }
1186
1187 void Controller::SetStrikethroughHeight(float height)
1188 {
1189   mImpl->mModel->mVisualModel->SetStrikethroughHeight(height);
1190
1191   mImpl->RequestRelayout();
1192 }
1193
1194 float Controller::GetStrikethroughHeight() const
1195 {
1196   return mImpl->mModel->mVisualModel->GetStrikethroughHeight();
1197 }
1198
1199 void Controller::SetStrikethroughColor(const Vector4& color)
1200 {
1201   mImpl->mModel->mVisualModel->SetStrikethroughColor(color);
1202
1203   mImpl->RequestRelayout();
1204 }
1205
1206 const Vector4& Controller::GetStrikethroughColor() const
1207 {
1208   return mImpl->mModel->mVisualModel->GetStrikethroughColor();
1209 }
1210
1211 void Controller::SetStrikethroughEnabled(bool enabled)
1212 {
1213   mImpl->mModel->mVisualModel->SetStrikethroughEnabled(enabled);
1214
1215   mImpl->RequestRelayout();
1216 }
1217
1218 bool Controller::IsStrikethroughEnabled() const
1219 {
1220   return mImpl->mModel->mVisualModel->IsStrikethroughEnabled();
1221 }
1222
1223 void Controller::SetInputStrikethroughProperties(const std::string& strikethroughProperties)
1224 {
1225   if(NULL != mImpl->mEventData)
1226   {
1227     mImpl->mEventData->mInputStyle.strikethroughProperties = strikethroughProperties;
1228   }
1229 }
1230
1231 const std::string& Controller::GetInputStrikethroughProperties() const
1232 {
1233   return (NULL != mImpl->mEventData) ? mImpl->mEventData->mInputStyle.strikethroughProperties : EMPTY_STRING;
1234 }
1235
1236 bool Controller::IsStrikethroughSetByString()
1237 {
1238   return mImpl->mStrikethroughSetByString;
1239 }
1240
1241 void Controller::StrikethroughSetByString(bool setByString)
1242 {
1243   mImpl->mStrikethroughSetByString = setByString;
1244 }
1245
1246 Layout::Engine& Controller::GetLayoutEngine()
1247 {
1248   return mImpl->mLayoutEngine;
1249 }
1250
1251 View& Controller::GetView()
1252 {
1253   return mImpl->mView;
1254 }
1255
1256 Vector3 Controller::GetNaturalSize()
1257 {
1258   return Relayouter::GetNaturalSize(*this);
1259 }
1260
1261 bool Controller::CheckForTextFit(float pointSize, Size& layoutSize)
1262 {
1263   return Relayouter::CheckForTextFit(*this, pointSize, layoutSize);
1264 }
1265
1266 void Controller::FitPointSizeforLayout(Size layoutSize)
1267 {
1268   Relayouter::FitPointSizeforLayout(*this, layoutSize);
1269 }
1270
1271 float Controller::GetHeightForWidth(float width)
1272 {
1273   return Relayouter::GetHeightForWidth(*this, width);
1274 }
1275
1276 int Controller::GetLineCount(float width)
1277 {
1278   GetHeightForWidth(width);
1279   return mImpl->mModel->GetNumberOfLines();
1280 }
1281
1282 const ModelInterface* const Controller::GetTextModel() const
1283 {
1284   return mImpl->mModel.Get();
1285 }
1286
1287 float Controller::GetScrollAmountByUserInput()
1288 {
1289   float scrollAmount = 0.0f;
1290
1291   if(NULL != mImpl->mEventData && mImpl->mEventData->mCheckScrollAmount)
1292   {
1293     scrollAmount                          = mImpl->mModel->mScrollPosition.y - mImpl->mModel->mScrollPositionLast.y;
1294     mImpl->mEventData->mCheckScrollAmount = false;
1295   }
1296   return scrollAmount;
1297 }
1298
1299 bool Controller::GetTextScrollInfo(float& scrollPosition, float& controlHeight, float& layoutHeight)
1300 {
1301   const Vector2& layout = mImpl->mModel->mVisualModel->GetLayoutSize();
1302   bool           isScrolled;
1303
1304   controlHeight  = mImpl->mModel->mVisualModel->mControlSize.height;
1305   layoutHeight   = layout.height;
1306   scrollPosition = mImpl->mModel->mScrollPosition.y;
1307   isScrolled     = !Equals(mImpl->mModel->mScrollPosition.y, mImpl->mModel->mScrollPositionLast.y, Math::MACHINE_EPSILON_1);
1308   return isScrolled;
1309 }
1310
1311 void Controller::SetHiddenInputOption(const Property::Map& options)
1312 {
1313   EnsureCreated<HiddenText, Controller*>(mImpl->mHiddenInput, this);
1314   mImpl->mHiddenInput->SetProperties(options);
1315 }
1316
1317 void Controller::GetHiddenInputOption(Property::Map& options)
1318 {
1319   if(mImpl->mHiddenInput)
1320   {
1321     mImpl->mHiddenInput->GetProperties(options);
1322   }
1323 }
1324
1325 void Controller::SetInputFilterOption(const Property::Map& options)
1326 {
1327   EnsureCreated(mImpl->mInputFilter);
1328   mImpl->mInputFilter->SetProperties(options);
1329 }
1330
1331 void Controller::GetInputFilterOption(Property::Map& options)
1332 {
1333   if(mImpl->mInputFilter)
1334   {
1335     mImpl->mInputFilter->GetProperties(options);
1336   }
1337 }
1338
1339 void Controller::SetPlaceholderProperty(const Property::Map& map)
1340 {
1341   PlaceholderHandler::SetPlaceholderProperty(*this, map);
1342 }
1343
1344 void Controller::GetPlaceholderProperty(Property::Map& map)
1345 {
1346   PlaceholderHandler::GetPlaceholderProperty(*this, map);
1347 }
1348
1349 Toolkit::DevelText::TextDirection::Type Controller::GetTextDirection()
1350 {
1351   // Make sure the model is up-to-date before layouting
1352   EventHandler::ProcessModifyEvents(*this);
1353
1354   return mImpl->GetTextDirection();
1355 }
1356
1357 Toolkit::DevelText::VerticalLineAlignment::Type Controller::GetVerticalLineAlignment() const
1358 {
1359   return mImpl->mModel->GetVerticalLineAlignment();
1360 }
1361
1362 void Controller::SetVerticalLineAlignment(Toolkit::DevelText::VerticalLineAlignment::Type alignment)
1363 {
1364   mImpl->mModel->mVerticalLineAlignment = alignment;
1365 }
1366
1367 Toolkit::DevelText::EllipsisPosition::Type Controller::GetEllipsisPosition() const
1368 {
1369   return mImpl->mModel->GetEllipsisPosition();
1370 }
1371
1372 void Controller::SetEllipsisPosition(Toolkit::DevelText::EllipsisPosition::Type ellipsisPosition)
1373 {
1374   mImpl->mModel->mEllipsisPosition = ellipsisPosition;
1375   mImpl->mModel->mVisualModel->SetEllipsisPosition(ellipsisPosition);
1376 }
1377
1378 void Controller::SetCharacterSpacing(float characterSpacing)
1379 {
1380   mImpl->mModel->mVisualModel->SetCharacterSpacing(characterSpacing);
1381
1382   mImpl->RelayoutAllCharacters();
1383   mImpl->RequestRelayout();
1384 }
1385
1386 const float Controller::GetCharacterSpacing() const
1387 {
1388   return mImpl->mModel->mVisualModel->GetCharacterSpacing();
1389 }
1390
1391 Controller::UpdateTextType Controller::Relayout(const Size& size, Dali::LayoutDirection::Type layoutDirection)
1392 {
1393   return Relayouter::Relayout(*this, size, layoutDirection);
1394 }
1395
1396 void Controller::RequestRelayout()
1397 {
1398   mImpl->RequestRelayout();
1399 }
1400
1401 Vector<Vector2> Controller::GetTextSize(CharacterIndex startIndex, CharacterIndex endIndex)
1402 {
1403   Vector<Vector2> sizesList;
1404   Vector<Vector2> positionsList;
1405
1406   GetTextGeometry(mImpl->mModel, startIndex, endIndex, sizesList, positionsList);
1407   return sizesList;
1408 }
1409
1410 Vector<Vector2> Controller::GetTextPosition(CharacterIndex startIndex, CharacterIndex endIndex)
1411 {
1412   Vector<Vector2> sizesList;
1413   Vector<Vector2> positionsList;
1414
1415   GetTextGeometry(mImpl->mModel, startIndex, endIndex, sizesList, positionsList);
1416   return positionsList;
1417 }
1418
1419 Rect<> Controller::GetTextBoundingRectangle(CharacterIndex startIndex, CharacterIndex endIndex)
1420 {
1421   Vector<Vector2> sizeList;
1422   Vector<Vector2> positionList;
1423
1424   GetTextGeometry(mImpl->mModel, startIndex, endIndex, sizeList, positionList);
1425
1426   if(sizeList.Empty() || sizeList.Size() != positionList.Size())
1427   {
1428     return {0, 0, 0, 0};
1429   }
1430
1431   auto minX      = positionList[0].x;
1432   auto minY      = positionList[0].y;
1433   auto maxRight  = positionList[0].x + sizeList[0].x;
1434   auto maxBottom = positionList[0].y + sizeList[0].y;
1435
1436   for(unsigned int i = 1; i < sizeList.Size(); i++)
1437   {
1438     minX      = std::min(minX, positionList[i].x);
1439     minY      = std::min(minY, positionList[i].y);
1440     maxRight  = std::max(maxRight, positionList[i].x + sizeList[i].x);
1441     maxBottom = std::max(maxBottom, positionList[i].y + sizeList[i].y);
1442   }
1443
1444   return {minX, minY, maxRight - minX, maxBottom - minY};
1445 }
1446
1447 bool Controller::IsInputStyleChangedSignalsQueueEmpty()
1448 {
1449   return mImpl->IsInputStyleChangedSignalsQueueEmpty();
1450 }
1451
1452 void Controller::ProcessInputStyleChangedSignals()
1453 {
1454   mImpl->ProcessInputStyleChangedSignals();
1455 }
1456
1457 void Controller::KeyboardFocusGainEvent()
1458 {
1459   EventHandler::KeyboardFocusGainEvent(*this);
1460 }
1461
1462 void Controller::KeyboardFocusLostEvent()
1463 {
1464   EventHandler::KeyboardFocusLostEvent(*this);
1465 }
1466
1467 bool Controller::KeyEvent(const Dali::KeyEvent& keyEvent)
1468 {
1469   return EventHandler::KeyEvent(*this, keyEvent);
1470 }
1471
1472 void Controller::AnchorEvent(float x, float y)
1473 {
1474   EventHandler::AnchorEvent(*this, x, y);
1475 }
1476
1477 void Controller::TapEvent(unsigned int tapCount, float x, float y)
1478 {
1479   EventHandler::TapEvent(*this, tapCount, x, y);
1480 }
1481
1482 void Controller::PanEvent(GestureState state, const Vector2& displacement)
1483 {
1484   EventHandler::PanEvent(*this, state, displacement);
1485 }
1486
1487 void Controller::LongPressEvent(GestureState state, float x, float y)
1488 {
1489   EventHandler::LongPressEvent(*this, state, x, y);
1490 }
1491
1492 void Controller::SelectEvent(float x, float y, SelectionType selectType)
1493 {
1494   EventHandler::SelectEvent(*this, x, y, selectType);
1495 }
1496
1497 void Controller::SetTextSelectionRange(const uint32_t* start, const uint32_t* end)
1498 {
1499   if(mImpl->mEventData)
1500   {
1501     mImpl->mEventData->mCheckScrollAmount     = true;
1502     mImpl->mEventData->mIsLeftHandleSelected  = true;
1503     mImpl->mEventData->mIsRightHandleSelected = true;
1504     mImpl->SetTextSelectionRange(start, end);
1505     mImpl->RequestRelayout();
1506     EventHandler::KeyboardFocusGainEvent(*this);
1507   }
1508 }
1509
1510 Uint32Pair Controller::GetTextSelectionRange() const
1511 {
1512   return mImpl->GetTextSelectionRange();
1513 }
1514
1515 CharacterIndex Controller::GetPrimaryCursorPosition() const
1516 {
1517   return mImpl->GetPrimaryCursorPosition();
1518 }
1519
1520 bool Controller::SetPrimaryCursorPosition(CharacterIndex index, bool focused)
1521 {
1522   if(mImpl->mEventData)
1523   {
1524     mImpl->mEventData->mCheckScrollAmount     = true;
1525     mImpl->mEventData->mIsLeftHandleSelected  = true;
1526     mImpl->mEventData->mIsRightHandleSelected = true;
1527     mImpl->mEventData->mCheckScrollAmount     = true;
1528     if(mImpl->SetPrimaryCursorPosition(index, focused) && focused)
1529     {
1530       EventHandler::KeyboardFocusGainEvent(*this);
1531       return true;
1532     }
1533   }
1534   return false;
1535 }
1536
1537 void Controller::SelectWholeText()
1538 {
1539   EventHandler::SelectEvent(*this, 0.f, 0.f, SelectionType::ALL);
1540 }
1541
1542 void Controller::SelectNone()
1543 {
1544   EventHandler::SelectEvent(*this, 0.f, 0.f, SelectionType::NONE);
1545 }
1546
1547 void Controller::SelectText(const uint32_t start, const uint32_t end)
1548 {
1549   EventHandler::SelectEvent(*this, start, end, SelectionType::RANGE);
1550 }
1551
1552 string Controller::GetSelectedText() const
1553 {
1554   return mImpl->GetSelectedText();
1555 }
1556
1557 string Controller::CopyText()
1558 {
1559   return mImpl->CopyText();
1560 }
1561
1562 string Controller::CutText()
1563 {
1564   return mImpl->CutText();
1565 }
1566
1567 void Controller::PasteText()
1568 {
1569   mImpl->RequestGetTextFromClipboard(); // Request clipboard service to retrieve an item
1570 }
1571
1572 InputMethodContext::CallbackData Controller::OnInputMethodContextEvent(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
1573 {
1574   return EventHandler::OnInputMethodContextEvent(*this, inputMethodContext, inputMethodContextEvent);
1575 }
1576
1577 void Controller::PasteClipboardItemEvent()
1578 {
1579   EventHandler::PasteClipboardItemEvent(*this);
1580 }
1581
1582 void Controller::GetTargetSize(Vector2& targetSize)
1583 {
1584   targetSize = mImpl->mModel->mVisualModel->mControlSize;
1585 }
1586
1587 void Controller::AddDecoration(Actor& actor, DecorationType type, bool needsClipping)
1588 {
1589   if(mImpl->mEditableControlInterface)
1590   {
1591     mImpl->mEditableControlInterface->AddDecoration(actor, type, needsClipping);
1592   }
1593 }
1594
1595 bool Controller::IsEditable() const
1596 {
1597   return mImpl->IsEditable();
1598 }
1599
1600 void Controller::SetEditable(bool editable)
1601 {
1602   mImpl->SetEditable(editable);
1603 }
1604
1605 void Controller::ScrollBy(Vector2 scroll)
1606 {
1607   mImpl->ScrollBy(scroll);
1608 }
1609
1610 bool Controller::IsScrollable(const Vector2& displacement)
1611 {
1612   return mImpl->IsScrollable(displacement);
1613 }
1614
1615 float Controller::GetHorizontalScrollPosition()
1616 {
1617   return mImpl->GetHorizontalScrollPosition();
1618 }
1619
1620 float Controller::GetVerticalScrollPosition()
1621 {
1622   return mImpl->GetVerticalScrollPosition();
1623 }
1624
1625 void Controller::DecorationEvent(HandleType handleType, HandleState state, float x, float y)
1626 {
1627   EventHandler::DecorationEvent(*this, handleType, state, x, y);
1628 }
1629
1630 void Controller::TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::Buttons button)
1631 {
1632   EventHandler::TextPopupButtonTouched(*this, button);
1633 }
1634
1635 void Controller::DisplayTimeExpired()
1636 {
1637   mImpl->mEventData->mUpdateCursorPosition = true;
1638   // Apply modifications to the model
1639   mImpl->mOperationsPending = ALL_OPERATIONS;
1640
1641   mImpl->RequestRelayout();
1642 }
1643
1644 void Controller::ResetCursorPosition(CharacterIndex cursorIndex)
1645 {
1646   // Reset the cursor position
1647   if(NULL != mImpl->mEventData)
1648   {
1649     mImpl->mEventData->mPrimaryCursorPosition = cursorIndex;
1650
1651     // Update the cursor if it's in editing mode.
1652     if(EventData::IsEditingState(mImpl->mEventData->mState))
1653     {
1654       mImpl->mEventData->mUpdateCursorPosition = true;
1655     }
1656   }
1657 }
1658
1659 CharacterIndex Controller::GetCursorPosition()
1660 {
1661   return mImpl->mEventData ? mImpl->mEventData->mPrimaryCursorPosition : 0;
1662 }
1663
1664 void Controller::SetControlInterface(ControlInterface* controlInterface)
1665 {
1666   mImpl->mControlInterface = controlInterface;
1667 }
1668
1669 void Controller::SetAnchorControlInterface(AnchorControlInterface* anchorControlInterface)
1670 {
1671   mImpl->mAnchorControlInterface = anchorControlInterface;
1672 }
1673
1674 bool Controller::ShouldClearFocusOnEscape() const
1675 {
1676   return mImpl->mShouldClearFocusOnEscape;
1677 }
1678
1679 Actor Controller::CreateBackgroundActor()
1680 {
1681   return CreateControllerBackgroundActor(mImpl->mView, mImpl->mModel->mVisualModel, mImpl->mModel->mLogicalModel, mImpl->mShaderBackground);
1682 }
1683
1684 void Controller::GetAnchorActors(std::vector<Toolkit::TextAnchor>& anchorActors)
1685 {
1686   mImpl->GetAnchorActors(anchorActors);
1687 }
1688
1689 int Controller::GetAnchorIndex(size_t characterOffset)
1690 {
1691   return mImpl->GetAnchorIndex(characterOffset);
1692 }
1693
1694 Controller::Controller(ControlInterface*           controlInterface,
1695                        EditableControlInterface*   editableControlInterface,
1696                        SelectableControlInterface* selectableControlInterface,
1697                        AnchorControlInterface*     anchorControlInterface)
1698 : mImpl(new Controller::Impl(controlInterface, editableControlInterface, selectableControlInterface, anchorControlInterface))
1699 {
1700 }
1701
1702 Controller::~Controller()
1703 {
1704   delete mImpl;
1705 }
1706
1707 } // namespace Dali::Toolkit::Text