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

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