dali-toolkit/internal/text/controller/text-controller.cpp

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