dali-toolkit/internal/text/controller/text-controller-impl.h

   1 #ifndef DALI_TOOLKIT_TEXT_CONTROLLER_IMPL_H
   2 #define DALI_TOOLKIT_TEXT_CONTROLLER_IMPL_H
   3
   4 /*
   5  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/text-abstraction/font-client.h>
  23 #include <dali/public-api/rendering/shader.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali-toolkit/devel-api/styling/style-manager-devel.h>
  27 #include <dali-toolkit/internal/text/controller/text-controller.h>
  28 #include <dali-toolkit/internal/text/input-style.h>
  29 #include <dali-toolkit/internal/text/multi-language-support.h>
  30 #include <dali-toolkit/internal/text/text-model.h>
  31 #include <dali-toolkit/internal/text/text-view.h>
  32 #include <dali-toolkit/public-api/styling/style-manager.h>
  33
  34 namespace Dali
  35 {
  36 namespace Toolkit
  37 {
  38 namespace Text
  39 {
  40 const float DEFAULT_TEXTFIT_MIN            = 10.f;
  41 const float DEFAULT_TEXTFIT_MAX            = 100.f;
  42 const float DEFAULT_TEXTFIT_STEP           = 1.f;
  43 const float DEFAULT_FONT_SIZE_SCALE        = 1.f;
  44 const float DEFAULT_DISABLED_COLOR_OPACITY = 0.3f;
  45
  46 //Forward declarations
  47 struct CursorInfo;
  48 struct FontDefaults;
  49 struct ControllerImplEventHandler;
  50 struct ControllerImplModelUpdater;
  51 struct SelectionHandleController;
  52
  53 class SelectableControlInterface;
  54 class AnchorControlInterface;
  55
  56 struct Event
  57 {
  58   // Used to queue input events until DoRelayout()
  59   enum Type
  60   {
  61     CURSOR_KEY_EVENT,
  62     TAP_EVENT,
  63     PAN_EVENT,
  64     LONG_PRESS_EVENT,
  65     GRAB_HANDLE_EVENT,
  66     LEFT_SELECTION_HANDLE_EVENT,
  67     RIGHT_SELECTION_HANDLE_EVENT,
  68     SELECT,
  69     SELECT_ALL,
  70     SELECT_NONE,
  71     SELECT_RANGE,
  72   };
  73
  74   union Param
  75   {
  76     int          mInt;
  77     unsigned int mUint;
  78     float        mFloat;
  79     bool         mBool;
  80   };
  81
  82   Event(Type eventType)
  83   : type(eventType)
  84   {
  85     p1.mInt = 0;
  86     p2.mInt = 0;
  87     p3.mInt = 0;
  88   }
  89
  90   Type  type;
  91   Param p1;
  92   Param p2;
  93   Param p3;
  94 };
  95
  96 struct EventData
  97 {
  98   enum State
  99   {
 100     INACTIVE,
 101     INTERRUPTED,
 102     SELECTING,
 103     EDITING,
 104     EDITING_WITH_POPUP,
 105     EDITING_WITH_GRAB_HANDLE,
 106     EDITING_WITH_PASTE_POPUP,
 107     GRAB_HANDLE_PANNING,
 108     SELECTION_HANDLE_PANNING,
 109     TEXT_PANNING
 110   };
 111
 112   EventData(DecoratorPtr decorator, InputMethodContext& inputMethodContext);
 113
 114   ~EventData() = default;
 115
 116   static bool IsEditingState(State stateToCheck)
 117   {
 118     return (stateToCheck == EDITING || stateToCheck == EDITING_WITH_POPUP || stateToCheck == EDITING_WITH_GRAB_HANDLE || stateToCheck == EDITING_WITH_PASTE_POPUP);
 119   }
 120
 121   DecoratorPtr                  mDecorator;               ///< Pointer to the decorator.
 122   InputMethodContext            mInputMethodContext;      ///< The Input Method Framework Manager.
 123   std::unique_ptr<FontDefaults> mPlaceholderFont;         ///< The placeholder default font.
 124   std::string                   mPlaceholderTextActive;   ///< The text to display when the TextField is empty with key-input focus.
 125   std::string                   mPlaceholderTextInactive; ///< The text to display when the TextField is empty and inactive.
 126   Vector4                       mPlaceholderTextColor;    ///< The in/active placeholder text color.
 127
 128   /**
 129    * This is used to delay handling events until after the model has been updated.
 130    * The number of updates to the model is minimized to improve performance.
 131    */
 132   std::vector<Event> mEventQueue; ///< The queue of touch events etc.
 133
 134   Vector<InputStyle::Mask> mInputStyleChangedQueue; ///< Queue of changes in the input style. Used to emit the signal in the iddle callback.
 135
 136   InputStyle mInputStyle; ///< The style to be set to the new inputed text.
 137
 138   State mPreviousState; ///< Stores the current state before it's updated with the new one.
 139   State mState;         ///< Selection mode, edit mode etc.
 140
 141   CharacterIndex mPrimaryCursorPosition;  ///< Index into logical model for primary cursor.
 142   CharacterIndex mLeftSelectionPosition;  ///< Index into logical model for left selection handle.
 143   CharacterIndex mRightSelectionPosition; ///< Index into logical model for right selection handle.
 144
 145   CharacterIndex mPreEditStartPosition; ///< Used to remove the pre-edit text if necessary.
 146   Length         mPreEditLength;        ///< Used to remove the pre-edit text if necessary.
 147
 148   float mCursorHookPositionX; ///< Used to move the cursor with the keys or when scrolling the text vertically with the handles.
 149
 150   Controller::NoTextTap::Action mDoubleTapAction; ///< Action to be done when there is a double tap on top of 'no text'
 151   Controller::NoTextTap::Action mLongPressAction; ///< Action to be done when there is a long press on top of 'no text'
 152
 153   bool mIsShowingPlaceholderText : 1;     ///< True if the place-holder text is being displayed.
 154   bool mPreEditFlag : 1;                  ///< True if the model contains text in pre-edit state.
 155   bool mDecoratorUpdated : 1;             ///< True if the decorator was updated during event processing.
 156   bool mCursorBlinkEnabled : 1;           ///< True if cursor should blink when active.
 157   bool mGrabHandleEnabled : 1;            ///< True if grab handle is enabled.
 158   bool mGrabHandlePopupEnabled : 1;       ///< True if the grab handle popu-up should be shown.
 159   bool mSelectionEnabled : 1;             ///< True if selection handles, highlight etc. are enabled.
 160   bool mUpdateCursorHookPosition : 1;     ///< True if the cursor hook position must be updated. Used to move the cursor with the keys 'up' and 'down'.
 161   bool mUpdateCursorPosition : 1;         ///< True if the visual position of the cursor must be recalculated.
 162   bool mUpdateGrabHandlePosition : 1;     ///< True if the visual position of the grab handle must be recalculated.
 163   bool mUpdateLeftSelectionPosition : 1;  ///< True if the visual position of the left selection handle must be recalculated.
 164   bool mUpdateRightSelectionPosition : 1; ///< True if the visual position of the right selection handle must be recalculated.
 165   bool mIsLeftHandleSelected : 1;         ///< Whether is the left handle the one which is selected.
 166   bool mIsRightHandleSelected : 1;        ///< Whether is the right handle the one which is selected.
 167   bool mUpdateHighlightBox : 1;           ///< True if the text selection high light box must be updated.
 168   bool mScrollAfterUpdatePosition : 1;    ///< Whether to scroll after the cursor position is updated.
 169   bool mScrollAfterDelete : 1;            ///< Whether to scroll after delete characters.
 170   bool mAllTextSelected : 1;              ///< True if the selection handles are selecting all the text.
 171   bool mUpdateInputStyle : 1;             ///< Whether to update the input style after moving the cursor.
 172   bool mPasswordInput : 1;                ///< True if password input is enabled.
 173   bool mCheckScrollAmount : 1;            ///< Whether to check scrolled amount after updating the position
 174   bool mIsPlaceholderPixelSize : 1;       ///< True if the placeholder font size is set as pixel size.
 175   bool mIsPlaceholderElideEnabled : 1;    ///< True if the placeholder text's elide is enabled.
 176   bool mPlaceholderEllipsisFlag : 1;      ///< True if the text controller sets the placeholder ellipsis.
 177   bool mShiftSelectionFlag : 1;           ///< True if the text selection using Shift key is enabled.
 178   bool mUpdateAlignment : 1;              ///< True if the whole text needs to be full aligned..
 179   bool mEditingEnabled : 1;               ///< True if the editing is enabled, false otherwise.
 180 };
 181
 182 struct ModifyEvent
 183 {
 184   enum Type
 185   {
 186     TEXT_REPLACED, ///< The entire text was replaced
 187     TEXT_INSERTED, ///< Insert characters at the current cursor position
 188     TEXT_DELETED   ///< Characters were deleted
 189   };
 190
 191   Type type;
 192 };
 193
 194 struct FontDefaults
 195 {
 196   FontDefaults()
 197   : mFontDescription(),
 198     mDefaultPointSize(0.f),
 199     mFitPointSize(0.f),
 200     mFontId(0u),
 201     familyDefined(false),
 202     weightDefined(false),
 203     widthDefined(false),
 204     slantDefined(false),
 205     sizeDefined(false)
 206   {
 207     // Initially use the default platform font
 208     TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 209     fontClient.GetDefaultPlatformFontDescription(mFontDescription);
 210   }
 211
 212   FontId GetFontId(TextAbstraction::FontClient& fontClient, float fontPointSize)
 213   {
 214     if(!mFontId)
 215     {
 216       const PointSize26Dot6 pointSize = static_cast<PointSize26Dot6>(fontPointSize * 64.f);
 217       mFontId                         = fontClient.GetFontId(mFontDescription, pointSize);
 218     }
 219
 220     return mFontId;
 221   }
 222
 223   TextAbstraction::FontDescription mFontDescription;  ///< The default font's description.
 224   float                            mDefaultPointSize; ///< The default font's point size.
 225   float                            mFitPointSize;     ///< The fit font's point size.
 226   FontId                           mFontId;           ///< The font's id of the default font.
 227   bool                             familyDefined : 1; ///< Whether the default font's family name is defined.
 228   bool                             weightDefined : 1; ///< Whether the default font's weight is defined.
 229   bool                             widthDefined : 1;  ///< Whether the default font's width is defined.
 230   bool                             slantDefined : 1;  ///< Whether the default font's slant is defined.
 231   bool                             sizeDefined : 1;   ///< Whether the default font's point size is defined.
 232 };
 233
 234 /**
 235  * @brief Stores indices used to update the text.
 236  * Stores the character index where the text is updated and the number of characters removed and added.
 237  * Stores as well indices to the first and the last paragraphs to be updated.
 238  */
 239 struct TextUpdateInfo
 240 {
 241   TextUpdateInfo()
 242   : mCharacterIndex(0u),
 243     mNumberOfCharactersToRemove(0u),
 244     mNumberOfCharactersToAdd(0u),
 245     mPreviousNumberOfCharacters(0u),
 246     mParagraphCharacterIndex(0u),
 247     mRequestedNumberOfCharacters(0u),
 248     mStartGlyphIndex(0u),
 249     mStartLineIndex(0u),
 250     mEstimatedNumberOfLines(0u),
 251     mClearAll(true),
 252     mFullRelayoutNeeded(true),
 253     mIsLastCharacterNewParagraph(false)
 254   {
 255   }
 256
 257   ~TextUpdateInfo()
 258   {
 259   }
 260
 261   CharacterIndex mCharacterIndex;             ///< Index to the first character to be updated.
 262   Length         mNumberOfCharactersToRemove; ///< The number of characters to be removed.
 263   Length         mNumberOfCharactersToAdd;    ///< The number of characters to be added.
 264   Length         mPreviousNumberOfCharacters; ///< The number of characters before the text update.
 265
 266   CharacterIndex mParagraphCharacterIndex;     ///< Index of the first character of the first paragraph to be updated.
 267   Length         mRequestedNumberOfCharacters; ///< The requested number of characters.
 268   GlyphIndex     mStartGlyphIndex;
 269   LineIndex      mStartLineIndex;
 270   Length         mEstimatedNumberOfLines; ///< The estimated number of lines. Used to avoid reallocations when layouting.
 271
 272   bool mClearAll : 1;                    ///< Whether the whole text is cleared. i.e. when the text is reset.
 273   bool mFullRelayoutNeeded : 1;          ///< Whether a full re-layout is needed. i.e. when a new size is set to the text control.
 274   bool mIsLastCharacterNewParagraph : 1; ///< Whether the last character is a new paragraph character.
 275
 276   void Clear()
 277   {
 278     // Clear all info except the mPreviousNumberOfCharacters member.
 279     mCharacterIndex              = static_cast<CharacterIndex>(-1);
 280     mNumberOfCharactersToRemove  = 0u;
 281     mNumberOfCharactersToAdd     = 0u;
 282     mParagraphCharacterIndex     = 0u;
 283     mRequestedNumberOfCharacters = 0u;
 284     mStartGlyphIndex             = 0u;
 285     mStartLineIndex              = 0u;
 286     mEstimatedNumberOfLines      = 0u;
 287     mClearAll                    = false;
 288     mFullRelayoutNeeded          = false;
 289     mIsLastCharacterNewParagraph = false;
 290   }
 291 };
 292
 293 struct UnderlineDefaults
 294 {
 295   std::string properties;
 296   // TODO: complete with underline parameters.
 297 };
 298
 299 struct ShadowDefaults
 300 {
 301   std::string properties;
 302   // TODO: complete with shadow parameters.
 303 };
 304
 305 struct EmbossDefaults
 306 {
 307   std::string properties;
 308   // TODO: complete with emboss parameters.
 309 };
 310
 311 struct OutlineDefaults
 312 {
 313   std::string properties;
 314   // TODO: complete with outline parameters.
 315 };
 316
 317 struct Controller::Impl
 318 {
 319   Impl(ControlInterface*           controlInterface,
 320        EditableControlInterface*   editableControlInterface,
 321        SelectableControlInterface* selectableControlInterface,
 322        AnchorControlInterface*     anchorControlInterface)
 323   : mControlInterface(controlInterface),
 324     mEditableControlInterface(editableControlInterface),
 325     mSelectableControlInterface(selectableControlInterface),
 326     mAnchorControlInterface(anchorControlInterface),
 327     mModel(),
 328     mFontDefaults(NULL),
 329     mUnderlineDefaults(NULL),
 330     mShadowDefaults(NULL),
 331     mEmbossDefaults(NULL),
 332     mOutlineDefaults(NULL),
 333     mEventData(NULL),
 334     mFontClient(),
 335     mClipboard(),
 336     mView(),
 337     mMetrics(),
 338     mModifyEvents(),
 339     mTextColor(Color::BLACK),
 340     mAnchorColor(Color::MEDIUM_BLUE),
 341     mAnchorClickedColor(Color::DARK_MAGENTA),
 342     mTextUpdateInfo(),
 343     mOperationsPending(NO_OPERATION),
 344     mMaximumNumberOfCharacters(50u),
 345     mHiddenInput(NULL),
 346     mInputFilter(nullptr),
 347     mTextFitContentSize(),
 348     mTextFitArray(),
 349     mRecalculateNaturalSize(true),
 350     mMarkupProcessorEnabled(false),
 351     mClipboardHideEnabled(true),
 352     mIsAutoScrollEnabled(false),
 353     mIsAutoScrollMaxTextureExceeded(false),
 354     mUpdateTextDirection(true),
 355     mIsTextDirectionRTL(false),
 356     mUnderlineSetByString(false),
 357     mShadowSetByString(false),
 358     mOutlineSetByString(false),
 359     mFontStyleSetByString(false),
 360     mStrikethroughSetByString(false),
 361     mShouldClearFocusOnEscape(true),
 362     mLayoutDirection(LayoutDirection::LEFT_TO_RIGHT),
 363     mCurrentLineSize(0.f),
 364     mTextFitMinSize(DEFAULT_TEXTFIT_MIN),
 365     mTextFitMaxSize(DEFAULT_TEXTFIT_MAX),
 366     mTextFitStepSize(DEFAULT_TEXTFIT_STEP),
 367     mTextFitLineSize(0.f),
 368     mFontSizeScale(DEFAULT_FONT_SIZE_SCALE),
 369     mDisabledColorOpacity(DEFAULT_DISABLED_COLOR_OPACITY),
 370     mFontSizeScaleEnabled(true),
 371     mTextFitEnabled(false),
 372     mTextFitChanged(false),
 373     mTextFitArrayEnabled(false),
 374     mIsLayoutDirectionChanged(false),
 375     mIsUserInteractionEnabled(true)
 376   {
 377     mModel = Model::New();
 378
 379     mFontClient = TextAbstraction::FontClient::Get();
 380     if(mEditableControlInterface != nullptr && Clipboard::IsAvailable())
 381     {
 382       mClipboard = Clipboard::Get();
 383     }
 384
 385     mView.SetVisualModel(mModel->mVisualModel);
 386     mView.SetLogicalModel(mModel->mLogicalModel);
 387
 388     // Use this to access FontClient i.e. to get down-scaled Emoji metrics.
 389     mMetrics = Metrics::New(mFontClient);
 390     mLayoutEngine.SetMetrics(mMetrics);
 391
 392     // Set the text properties to default
 393     mModel->mVisualModel->SetUnderlineEnabled(false);
 394     mModel->mVisualModel->SetUnderlineHeight(0.0f);
 395
 396     Toolkit::StyleManager styleManager = Toolkit::StyleManager::Get();
 397     if(styleManager)
 398     {
 399       const auto clearFocusOnEscapeValue = Toolkit::DevelStyleManager::GetConfigurations(styleManager).Find("clearFocusOnEscape", Property::Type::BOOLEAN);
 400
 401       // Default is true. If config don't have "clearFocusOnEscape" property, make it true.
 402       mShouldClearFocusOnEscape = (!clearFocusOnEscapeValue || clearFocusOnEscapeValue->Get<bool>());
 403     }
 404   }
 405
 406   ~Impl()
 407   {
 408     delete mHiddenInput;
 409     delete mFontDefaults;
 410     delete mUnderlineDefaults;
 411     delete mShadowDefaults;
 412     delete mEmbossDefaults;
 413     delete mOutlineDefaults;
 414     delete mEventData;
 415   }
 416
 417   // Text Controller Implementation.
 418
 419   /**
 420    * @copydoc Text::Controller::RequestRelayout()
 421    */
 422   void RequestRelayout();
 423
 424   /**
 425    * @brief Request a relayout using the ControlInterface.
 426    */
 427   void QueueModifyEvent(ModifyEvent::Type type)
 428   {
 429     if(ModifyEvent::TEXT_REPLACED == type)
 430     {
 431       // Cancel previously queued inserts etc.
 432       mModifyEvents.Clear();
 433     }
 434
 435     ModifyEvent event;
 436     event.type = type;
 437     mModifyEvents.PushBack(event);
 438
 439     // The event will be processed during relayout
 440     RequestRelayout();
 441   }
 442
 443   /**
 444    * @copydoc Text::Controller::ResetFontAndStyleData()
 445    */
 446   void ResetFontAndStyleData()
 447   {
 448     ClearFontData();
 449     ClearStyleData();
 450     RequestRelayout();
 451   }
 452
 453   /**
 454    * @brief Helper to move the cursor, grab handle etc.
 455    */
 456   bool ProcessInputEvents();
 457
 458   /**
 459    * @brief Helper to check whether any place-holder text is available.
 460    */
 461   bool IsPlaceholderAvailable() const
 462   {
 463     return (mEventData &&
 464             (!mEventData->mPlaceholderTextInactive.empty() ||
 465              !mEventData->mPlaceholderTextActive.empty()));
 466   }
 467
 468   bool IsShowingPlaceholderText() const
 469   {
 470     return (mEventData && mEventData->mIsShowingPlaceholderText);
 471   }
 472
 473   /**
 474    * @brief Helper to check whether active place-holder text is available.
 475    */
 476   bool IsFocusedPlaceholderAvailable() const
 477   {
 478     return (mEventData && !mEventData->mPlaceholderTextActive.empty());
 479   }
 480
 481   bool IsShowingRealText() const
 482   {
 483     return (!IsShowingPlaceholderText() &&
 484             0u != mModel->mLogicalModel->mText.Count());
 485   }
 486
 487   /**
 488    * @brief Called when placeholder-text is hidden
 489    */
 490   void PlaceholderCleared()
 491   {
 492     if(mEventData)
 493     {
 494       mEventData->mIsShowingPlaceholderText = false;
 495
 496       // Remove mPlaceholderTextColor
 497       mModel->mVisualModel->SetTextColor(mTextColor);
 498     }
 499   }
 500
 501   void ClearPreEditFlag()
 502   {
 503     if(mEventData)
 504     {
 505       mEventData->mPreEditFlag          = false;
 506       mEventData->mPreEditStartPosition = 0;
 507       mEventData->mPreEditLength        = 0;
 508     }
 509   }
 510
 511   void ResetInputMethodContext()
 512   {
 513     if(mEventData)
 514     {
 515       // Reset incase we are in a pre-edit state.
 516       if(mEventData->mInputMethodContext)
 517       {
 518         mEventData->mInputMethodContext.Reset(); // Will trigger a message ( commit, get surrounding )
 519       }
 520
 521       ClearPreEditFlag();
 522     }
 523   }
 524
 525   float GetFontSizeScale()
 526   {
 527     return mFontSizeScaleEnabled ? mFontSizeScale : 1.0f;
 528   }
 529
 530   /**
 531    * @copydoc Controller::SetAnchorColor()
 532    */
 533   void SetAnchorColor(const Vector4& color);
 534
 535   /**
 536    * @copydoc Controller::GetAnchorColor()
 537    */
 538   const Vector4& GetAnchorColor() const;
 539
 540   /**
 541    * @copydoc Controller::SetAnchorClickedColor()
 542    */
 543   void SetAnchorClickedColor(const Vector4& color);
 544
 545   /**
 546    * @copydoc Controller::GetAnchorClickedColor()
 547    */
 548   const Vector4& GetAnchorClickedColor() const;
 549
 550   /**
 551    * @brief Updates the color of anchors.
 552    */
 553   void UpdateAnchorColor();
 554
 555   /**
 556    * @brief Helper to notify InputMethodContext with surrounding text & cursor changes.
 557    */
 558   void NotifyInputMethodContext();
 559
 560   /**
 561    * @brief Helper to notify InputMethodContext with multi line status.
 562    */
 563   void NotifyInputMethodContextMultiLineStatus();
 564
 565   /**
 566    * @brief Retrieve the current cursor position.
 567    *
 568    * @return The cursor position.
 569    */
 570   CharacterIndex GetLogicalCursorPosition() const;
 571
 572   /**
 573    * @brief Retrieves the number of consecutive white spaces starting from the given @p index.
 574    *
 575    * @param[in] index The character index from where to count the number of consecutive white spaces.
 576    *
 577    * @return The number of consecutive white spaces.
 578    */
 579   Length GetNumberOfWhiteSpaces(CharacterIndex index) const;
 580
 581   /**
 582    * @brief Retrieve any text previously set.
 583    *
 584    * @param[out] text A string of UTF-8 characters.
 585    */
 586   void GetText(std::string& text) const;
 587
 588   /**
 589    * @brief Retrieve any text previously set starting from the given @p index.
 590    *
 591    * @param[in] index The character index from where to retrieve the text.
 592    * @param[out] text A string of UTF-8 characters.
 593    *
 594    * @see Dali::Toolkit::Text::Controller::GetText()
 595    */
 596   void GetText(CharacterIndex index, std::string& text) const;
 597
 598   /**
 599    * @brief Retrieves number of characters previously set.
 600    *
 601    * @return A length of UTF-32 characters.
 602    *
 603    * @see Dali::Toolkit::Text::Controller::GetNumberOfCharacters()
 604    */
 605   Length GetNumberOfCharacters() const;
 606
 607   bool EnsureClipboardCreated()
 608   {
 609     if(!mClipboard)
 610     {
 611       mClipboard = Clipboard::Get();
 612     }
 613
 614     return mClipboard != nullptr ? true : false;
 615   }
 616
 617   bool IsClipboardEmpty()
 618   {
 619     bool result(Clipboard::IsAvailable() && EnsureClipboardCreated() && mClipboard.NumberOfItems());
 620     return !result; // If NumberOfItems greater than 0, return false
 621   }
 622
 623   bool IsClipboardVisible()
 624   {
 625     bool result(Clipboard::IsAvailable() && EnsureClipboardCreated() && mClipboard.IsVisible());
 626     return result;
 627   }
 628
 629   /**
 630    * @copydoc Controller::GetLayoutDirection()
 631    */
 632   Dali::LayoutDirection::Type GetLayoutDirection(Dali::Actor& actor) const;
 633
 634   /**
 635    * @brief Checks text direction.
 636    * @return The text direction.
 637    */
 638   Toolkit::DevelText::TextDirection::Type GetTextDirection();
 639
 640   /**
 641    * @brief Calculates the start character index of the first paragraph to be updated and
 642    * the end character index of the last paragraph to be updated.
 643    *
 644    * @param[out] numberOfCharacters The number of characters to be updated.
 645    */
 646   void CalculateTextUpdateIndices(Length& numberOfCharacters);
 647
 648   /**
 649    * @brief Helper to clear the parts of the model specified by the given @p operations and from @p startIndex to @p endIndex.
 650    *
 651    * @note It never clears the text stored in utf32.
 652    *
 653    * @param[in] startIndex Index to the first character to be cleared.
 654    * @param[in] endIndex Index to the last character to be cleared.
 655    * @param[in] operations The operations required.
 656    */
 657   void ClearModelData(CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations);
 658
 659   /**
 660    * @brief Updates the logical and visual models. Updates the style runs in the visual model when the text's styles changes.
 661    *
 662    * When text or style changes the model is set with some operations pending.
 663    * When i.e. the text's size or a relayout is required this method is called
 664    * with a given @p operationsRequired parameter. The operations required are
 665    * matched with the operations pending to perform the minimum number of operations.
 666    *
 667    * @param[in] operationsRequired The operations required.
 668    *
 669    * @return @e true if the model has been modified.
 670    */
 671   bool UpdateModel(OperationsMask operationsRequired);
 672
 673   /**
 674    * @brief Retreieves the default style.
 675    *
 676    * @param[out] inputStyle The default style.
 677    */
 678   void RetrieveDefaultInputStyle(InputStyle& inputStyle);
 679
 680   /**
 681    * @brief Retrieve the line height of the default font.
 682    */
 683   float GetDefaultFontLineHeight();
 684
 685   /**
 686    * @copydoc Controller::SetDefaultLineSpacing
 687    */
 688   bool SetDefaultLineSpacing(float lineSpacing);
 689
 690   /**
 691    * @copydoc Controller::SetDefaultLineSize
 692    */
 693   bool SetDefaultLineSize(float lineSize);
 694
 695   /**
 696    * @copydoc Controller::SetRelativeLineSize
 697    */
 698   bool SetRelativeLineSize(float relativeLineSize);
 699
 700   /**
 701    * @copydoc Controller::GetRelativeLineSize
 702    */
 703   float GetRelativeLineSize();
 704
 705   /**
 706    * @copydoc Text::Controller::GetPrimaryCursorPosition()
 707    */
 708   CharacterIndex GetPrimaryCursorPosition() const;
 709
 710   /**
 711    * @copydoc Text::Controller::SetPrimaryCursorPosition()
 712    */
 713   bool SetPrimaryCursorPosition(CharacterIndex index, bool focused);
 714
 715   /**
 716    * @copydoc Text::SelectableControlInterface::GetSelectedText()
 717    */
 718   string GetSelectedText();
 719
 720   /**
 721    * @copydoc Text::EditableControlInterface::CopyText()
 722    */
 723   string CopyText();
 724
 725   /**
 726    * @copydoc Text::EditableControlInterface::CutText()
 727    */
 728   string CutText();
 729
 730   /**
 731    * @copydoc Text::SelectableControlInterface::SetTextSelectionRange()
 732    */
 733   void SetTextSelectionRange(const uint32_t* pStart, const uint32_t* pEndf);
 734
 735   /**
 736    * @copydoc Text::SelectableControlInterface::GetTextSelectionRange()
 737    */
 738   Uint32Pair GetTextSelectionRange() const;
 739
 740   /**
 741    * @copydoc Text::EditableControlInterface::IsEditable()
 742    */
 743   bool IsEditable() const;
 744
 745   /**
 746    * @copydoc Text::EditableControlInterface::SetEditable()
 747    */
 748   void SetEditable(bool editable);
 749
 750   /**
 751    * @copydoc Controller::UpdateAfterFontChange
 752    */
 753   void UpdateAfterFontChange(const std::string& newDefaultFont);
 754
 755   /**
 756    * @brief Retrieves the selected text. It removes the text if the @p deleteAfterRetrieval parameter is @e true.
 757    *
 758    * @param[out] selectedText The selected text encoded in utf8.
 759    * @param[in] deleteAfterRetrieval Whether the text should be deleted after retrieval.
 760    */
 761   void RetrieveSelection(std::string& selectedText, bool deleteAfterRetrieval);
 762
 763   void SetSelection(int start, int end);
 764
 765   std::pair<int, int> GetSelectionIndexes() const;
 766
 767   void ShowClipboard();
 768
 769   void HideClipboard();
 770
 771   void SetClipboardHideEnable(bool enable);
 772
 773   bool CopyStringToClipboard(const std::string& source);
 774
 775   void SendSelectionToClipboard(bool deleteAfterSending);
 776
 777   void RepositionSelectionHandles();
 778   void RepositionSelectionHandles(float visualX, float visualY, Controller::NoTextTap::Action action);
 779
 780   void SetPopupButtons();
 781
 782   void ChangeState(EventData::State newState);
 783
 784   /**
 785    * @brief Calculates the cursor's position for a given character index in the logical order.
 786    *
 787    * It retrieves as well the line's height and the cursor's height and
 788    * if there is a valid alternative cursor, its position and height.
 789    *
 790    * @param[in] logical The logical cursor position (in characters). 0 is just before the first character, a value equal to the number of characters is just after the last character.
 791    * @param[out] cursorInfo The line's height, the cursor's height, the cursor's position and whether there is an alternative cursor.
 792    */
 793   void GetCursorPosition(CharacterIndex logical,
 794                          CursorInfo&    cursorInfo);
 795
 796   /**
 797    * @brief Calculates the new cursor index.
 798    *
 799    * It takes into account that in some scripts multiple characters can form a glyph and all of them
 800    * need to be jumped with one key event.
 801    *
 802    * @param[in] index The initial new index.
 803    *
 804    * @return The new cursor index.
 805    */
 806   CharacterIndex CalculateNewCursorIndex(CharacterIndex index) const;
 807
 808   /**
 809    * @brief Updates the cursor position.
 810    *
 811    * Sets the cursor's position into the decorator. It transforms the cursor's position into decorator's coords.
 812    * It sets the position of the secondary cursor if it's a valid one.
 813    * Sets which cursors are active.
 814    *
 815    * @param[in] cursorInfo Contains the selection handle position in Actor's coords.
 816    *
 817    */
 818   void UpdateCursorPosition(const CursorInfo& cursorInfo);
 819
 820   /**
 821    * @brief Updates the position of the given selection handle. It transforms the handle's position into decorator's coords.
 822    *
 823    * @param[in] handleType One of the selection handles.
 824    * @param[in] cursorInfo Contains the selection handle position in Actor's coords.
 825    */
 826   void UpdateSelectionHandle(HandleType        handleType,
 827                              const CursorInfo& cursorInfo);
 828
 829   /**
 830    * @biref Clamps the horizontal scrolling to get the control always filled with text.
 831    *
 832    * @param[in] layoutSize The size of the laid out text.
 833    */
 834   void ClampHorizontalScroll(const Vector2& layoutSize);
 835
 836   /**
 837    * @biref Clamps the vertical scrolling to get the control always filled with text.
 838    *
 839    * @param[in] layoutSize The size of the laid out text.
 840    */
 841   void ClampVerticalScroll(const Vector2& layoutSize);
 842
 843   /**
 844    * @brief Scrolls the text to make a position visible.
 845    *
 846    * @pre mEventData must not be NULL. (there is a text-input or selection capabilities).
 847    *
 848    * @param[in] position A position in text coords.
 849    * @param[in] lineHeight The line height for the given position.
 850    *
 851    * This method is called after inserting text, moving the cursor with the grab handle or the keypad,
 852    * or moving the selection handles.
 853    */
 854   void ScrollToMakePositionVisible(const Vector2& position, float lineHeight);
 855
 856   /**
 857    * @brief Scrolls the text to make the cursor visible.
 858    *
 859    * This method is called after deleting text.
 860    */
 861   void ScrollTextToMatchCursor(const CursorInfo& cursorInfo);
 862
 863   /**
 864    * @brief Scrolls the text to make primary cursor visible.
 865    */
 866   void ScrollTextToMatchCursor();
 867
 868   /**
 869    * @brief Create an actor that renders the text background color
 870    *
 871    * @return the created actor or an empty handle if no background color needs to be rendered.
 872    */
 873   Actor CreateBackgroundActor();
 874
 875   /**
 876    * @brief fill needed relayout parameters whenever a property is changed and a re-layout is needed for the entire text.
 877    */
 878   void RelayoutAllCharacters();
 879
 880   /**
 881    * @copydoc Controller::IsInputStyleChangedSignalsQueueEmpty
 882    */
 883   bool IsInputStyleChangedSignalsQueueEmpty();
 884
 885   /**
 886    * @copydoc Controller::ProcessInputStyleChangedSignals
 887    */
 888   void ProcessInputStyleChangedSignals();
 889
 890   /**
 891    * @copydoc Controller::ScrollBy()
 892    */
 893   void ScrollBy(Vector2 scroll);
 894
 895   /**
 896    * @copydoc Controller::IsScrollable()
 897    */
 898   bool IsScrollable(const Vector2& displacement);
 899
 900   /**
 901    * @copydoc Controller::GetHorizontalScrollPosition()
 902    */
 903   float GetHorizontalScrollPosition();
 904
 905   /**
 906    * @copydoc Controller::GetVerticalScrollPosition()
 907    */
 908   float GetVerticalScrollPosition();
 909
 910   /**
 911    * @copydoc Controller::SetAutoScrollEnabled()
 912    */
 913   void SetAutoScrollEnabled(bool enable);
 914
 915   /**
 916    * @copydoc Controller::SetEnableCursorBlink()
 917    */
 918   void SetEnableCursorBlink(bool enable);
 919
 920   /**
 921    * @copydoc Controller::SetMultiLineEnabled()
 922    */
 923   void SetMultiLineEnabled(bool enable);
 924
 925   /**
 926    * @copydoc Controller::SetHorizontalAlignment()
 927    */
 928   void SetHorizontalAlignment(HorizontalAlignment::Type alignment);
 929
 930   /**
 931    * @copydoc Controller::SetVerticalAlignment()
 932    */
 933   void SetVerticalAlignment(VerticalAlignment::Type alignment);
 934
 935   /**
 936    * @copydoc Controller::SetLineWrapMode()
 937    */
 938   void SetLineWrapMode(Text::LineWrap::Mode textWarpMode);
 939
 940   /**
 941    * @copydoc Controller::SetDefaultColor()
 942    */
 943   void SetDefaultColor(const Vector4& color);
 944
 945   /**
 946    * @copydoc Controller::SetUserInteractionEnabled()
 947    */
 948   void SetUserInteractionEnabled(bool enabled);
 949
 950   /**
 951    * @brief Helper to clear font-specific data (only).
 952    */
 953   void ClearFontData();
 954
 955   /**
 956    * @brief Helper to clear text's style data.
 957    */
 958   void ClearStyleData();
 959
 960   /**
 961    * @brief Used to reset the scroll position after setting a new text.
 962    */
 963   void ResetScrollPosition();
 964
 965   /**
 966    * @brief Resets a provided vector with actors that marks the position of anchors in markup enabled text
 967    *
 968    * @param[out] anchorActors the vector of actor (empty collection if no anchors available).
 969    */
 970   void GetAnchorActors(std::vector<Toolkit::TextAnchor>& anchorActors);
 971
 972   /**
 973    * @brief Return an index of first anchor in the anchor vector whose boundaries includes given character offset
 974    *
 975    * @param[in] characterOffset A position in text coords.
 976    *
 977    * @return the 0-based index in anchor vector (-1 if an anchor not found)
 978    */
 979   int32_t GetAnchorIndex(size_t characterOffset) const;
 980
 981   /**
 982    * @brief Return the geometrical position of an anchor relative to the parent origin point.
 983    *
 984    * @param[in] anchor An anchor.
 985    *
 986    * @return The x, y, z coordinates of an anchor.
 987    */
 988   Vector3 GetAnchorPosition(Anchor anchor) const;
 989
 990   /**
 991    * @brief Return the size of an anchor expresed as a vector containing anchor's width and height.
 992    *
 993    * @param[in] anchor An anchor.
 994    *
 995    * @return The width and height of an anchor.
 996    */
 997   Vector2 GetAnchorSize(Anchor anchor) const;
 998
 999   /**
1000    * @brief Return the actor representing an anchor.
1001    *
1002    * @param[in] anchor An anchor.
1003    *
1004    * @return The actor representing an anchor.
1005    */
1006   Toolkit::TextAnchor CreateAnchorActor(Anchor anchor);
1007
1008 public:
1009   /**
1010    * @brief Gets implementation from the controller handle.
1011    * @param controller The text controller
1012    * @return The implementation of the Controller
1013    */
1014   static Impl& GetImplementation(Text::Controller& controller)
1015   {
1016     return *controller.mImpl;
1017   }
1018
1019 private:
1020   // Declared private and left undefined to avoid copies.
1021   Impl(const Impl&);
1022   // Declared private and left undefined to avoid copies.
1023   Impl& operator=(const Impl&);
1024
1025   /**
1026    * @brief Copy Underlined-Character-Runs from Logical-Model to Underlined-Glyph-Runs in Visual-Model
1027    *
1028    * @param shouldClearPreUnderlineRuns Whether should clear the existing Underlined-Glyph-Runs in Visual-Model
1029    */
1030   void CopyUnderlinedFromLogicalToVisualModels(bool shouldClearPreUnderlineRuns);
1031
1032   /**
1033    * @brief Copy strikethrough-Character-Runs from Logical-Model to strikethrough-Glyph-Runs in Visual-Model
1034    *
1035    */
1036   void CopyStrikethroughFromLogicalToVisualModels();
1037
1038   /**
1039    * @brief Copy CharacterSpacing-Character-Runs from Logical-Model to CharacterSpacing-Glyph-Runs in Visual-Model
1040    *
1041    */
1042   void CopyCharacterSpacingFromLogicalToVisualModels();
1043
1044 public:
1045   ControlInterface*            mControlInterface;           ///< Reference to the text controller.
1046   EditableControlInterface*    mEditableControlInterface;   ///< Reference to the editable text controller.
1047   SelectableControlInterface*  mSelectableControlInterface; ///< Reference to the selectable text controller.
1048   AnchorControlInterface*      mAnchorControlInterface;     ///< Reference to the anchor controller.
1049   ModelPtr                     mModel;                      ///< Pointer to the text's model.
1050   FontDefaults*                mFontDefaults;               ///< Avoid allocating this when the user does not specify a font.
1051   UnderlineDefaults*           mUnderlineDefaults;          ///< Avoid allocating this when the user does not specify underline parameters.
1052   ShadowDefaults*              mShadowDefaults;             ///< Avoid allocating this when the user does not specify shadow parameters.
1053   EmbossDefaults*              mEmbossDefaults;             ///< Avoid allocating this when the user does not specify emboss parameters.
1054   OutlineDefaults*             mOutlineDefaults;            ///< Avoid allocating this when the user does not specify outline parameters.
1055   EventData*                   mEventData;                  ///< Avoid allocating everything for text input until EnableTextInput().
1056   TextAbstraction::FontClient  mFontClient;                 ///< Handle to the font client.
1057   Clipboard                    mClipboard;                  ///< Handle to the system clipboard
1058   View                         mView;                       ///< The view interface to the rendering back-end.
1059   MetricsPtr                   mMetrics;                    ///< A wrapper around FontClient used to get metrics & potentially down-scaled Emoji metrics.
1060   Layout::Engine               mLayoutEngine;               ///< The layout engine.
1061   Vector<ModifyEvent>          mModifyEvents;               ///< Temporary stores the text set until the next relayout.
1062   Vector4                      mTextColor;                  ///< The regular text color
1063   Vector4                      mAnchorColor;                ///< The anchor color
1064   Vector4                      mAnchorClickedColor;         ///< The anchor clicked color
1065   TextUpdateInfo               mTextUpdateInfo;             ///< Info of the characters updated.
1066   OperationsMask               mOperationsPending;          ///< Operations pending to be done to layout the text.
1067   Length                       mMaximumNumberOfCharacters;  ///< Maximum number of characters that can be inserted.
1068   HiddenText*                  mHiddenInput;                ///< Avoid allocating this when the user does not specify hidden input mode.
1069   std::unique_ptr<InputFilter> mInputFilter;                ///< Avoid allocating this when the user does not specify input filter mode.
1070   Vector2                      mTextFitContentSize;         ///< Size of Text fit content
1071
1072   std::vector<Toolkit::DevelTextLabel::FitOption> mTextFitArray; ///< List of FitOption for TextFitArray operation.
1073
1074   bool               mRecalculateNaturalSize : 1;         ///< Whether the natural size needs to be recalculated.
1075   bool               mMarkupProcessorEnabled : 1;         ///< Whether the mark-up procesor is enabled.
1076   bool               mClipboardHideEnabled : 1;           ///< Whether the ClipboardHide function work or not
1077   bool               mIsAutoScrollEnabled : 1;            ///< Whether auto text scrolling is enabled.
1078   bool               mIsAutoScrollMaxTextureExceeded : 1; ///< Whether auto text scrolling is exceed max texture size.
1079   bool               mUpdateTextDirection : 1;            ///< Whether the text direction needs to be updated.
1080   CharacterDirection mIsTextDirectionRTL : 1;             ///< Whether the text direction is right to left or not
1081
1082   bool                  mUnderlineSetByString : 1;     ///< Set when underline is set by string (legacy) instead of map
1083   bool                  mShadowSetByString : 1;        ///< Set when shadow is set by string (legacy) instead of map
1084   bool                  mOutlineSetByString : 1;       ///< Set when outline is set by string (legacy) instead of map
1085   bool                  mFontStyleSetByString : 1;     ///< Set when font style is set by string (legacy) instead of map
1086   bool                  mStrikethroughSetByString : 1; ///< Set when strikethrough is set by string (legacy) instead of map
1087   bool                  mShouldClearFocusOnEscape : 1; ///< Whether text control should clear key input focus
1088   LayoutDirection::Type mLayoutDirection;              ///< Current system language direction
1089
1090   Shader mShaderBackground; ///< The shader for text background.
1091
1092   float mCurrentLineSize;              ///< Used to store the MinLineSize set by user when TextFitArray is enabled.
1093   float mTextFitMinSize;               ///< Minimum Font Size for text fit. Default 10
1094   float mTextFitMaxSize;               ///< Maximum Font Size for text fit. Default 100
1095   float mTextFitStepSize;              ///< Step Size for font intervalse. Default 1
1096   float mTextFitLineSize;              ///< This is the LineSize that is the standard when performing TextFit.
1097   float mFontSizeScale;                ///< Scale value for Font Size. Default 1.0
1098   float mDisabledColorOpacity;         ///< Color opacity when disabled.
1099   bool  mFontSizeScaleEnabled : 1;     ///< Whether the font size scale is enabled.
1100   bool  mTextFitEnabled : 1;           ///< Whether the text's fit is enabled.
1101   bool  mTextFitChanged : 1;           ///< Whether the text fit property has changed.
1102   bool  mTextFitArrayEnabled : 1;      ///< Whether the text's fit array is enabled.
1103   bool  mIsLayoutDirectionChanged : 1; ///< Whether the layout has changed.
1104   bool  mIsUserInteractionEnabled : 1; ///< Whether the user interaction is enabled.
1105
1106 private:
1107   friend ControllerImplEventHandler;
1108   friend ControllerImplModelUpdater;
1109   friend SelectionHandleController;
1110 };
1111
1112 } // namespace Text
1113
1114 } // namespace Toolkit
1115
1116 } // namespace Dali
1117
1118 #endif // DALI_TOOLKIT_TEXT_CONTROLLER_H