dali-toolkit/internal/text/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) 2017 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/adaptor-framework/clipboard.h>
  23 #include <dali/devel-api/text-abstraction/font-client.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali-toolkit/internal/text/input-style.h>
  27 #include <dali-toolkit/internal/text/text-controller.h>
  28 #include <dali-toolkit/internal/text/text-model.h>
  29 #include <dali-toolkit/internal/text/text-view.h>
  30
  31 namespace Dali
  32 {
  33
  34 namespace Toolkit
  35 {
  36
  37 namespace Text
  38 {
  39
  40 //Forward declarations
  41 struct CursorInfo;
  42 struct FontDefaults;
  43
  44 struct Event
  45 {
  46   // Used to queue input events until DoRelayout()
  47   enum Type
  48   {
  49     CURSOR_KEY_EVENT,
  50     TAP_EVENT,
  51     PAN_EVENT,
  52     LONG_PRESS_EVENT,
  53     GRAB_HANDLE_EVENT,
  54     LEFT_SELECTION_HANDLE_EVENT,
  55     RIGHT_SELECTION_HANDLE_EVENT,
  56     SELECT,
  57     SELECT_ALL
  58   };
  59
  60   union Param
  61   {
  62     int mInt;
  63     unsigned int mUint;
  64     float mFloat;
  65   };
  66
  67   Event( Type eventType )
  68   : type( eventType )
  69   {
  70     p1.mInt = 0;
  71     p2.mInt = 0;
  72     p3.mInt = 0;
  73   }
  74
  75   Type type;
  76   Param p1;
  77   Param p2;
  78   Param p3;
  79 };
  80
  81 struct EventData
  82 {
  83   enum State
  84   {
  85     INACTIVE,
  86     INTERRUPTED,
  87     SELECTING,
  88     EDITING,
  89     EDITING_WITH_POPUP,
  90     EDITING_WITH_GRAB_HANDLE,
  91     EDITING_WITH_PASTE_POPUP,
  92     GRAB_HANDLE_PANNING,
  93     SELECTION_HANDLE_PANNING,
  94     TEXT_PANNING
  95   };
  96
  97   EventData( DecoratorPtr decorator );
  98
  99   ~EventData();
 100
 101   static bool IsEditingState( State stateToCheck )
 102   {
 103     return ( stateToCheck == EDITING || stateToCheck == EDITING_WITH_POPUP || stateToCheck == EDITING_WITH_GRAB_HANDLE || stateToCheck == EDITING_WITH_PASTE_POPUP );
 104   }
 105
 106   DecoratorPtr       mDecorator;               ///< Pointer to the decorator.
 107   ImfManager         mImfManager;              ///< The Input Method Framework Manager.
 108   FontDefaults*      mPlaceholderFont;         ///< The placeholder default font.
 109   std::string        mPlaceholderTextActive;   ///< The text to display when the TextField is empty with key-input focus.
 110   std::string        mPlaceholderTextInactive; ///< The text to display when the TextField is empty and inactive.
 111   Vector4            mPlaceholderTextColor;    ///< The in/active placeholder text color.
 112
 113   /**
 114    * This is used to delay handling events until after the model has been updated.
 115    * The number of updates to the model is minimized to improve performance.
 116    */
 117   std::vector<Event> mEventQueue;              ///< The queue of touch events etc.
 118
 119   Vector<InputStyle::Mask> mInputStyleChangedQueue; ///< Queue of changes in the input style. Used to emit the signal in the iddle callback.
 120
 121   InputStyle         mInputStyle;              ///< The style to be set to the new inputed text.
 122
 123   State              mPreviousState;           ///< Stores the current state before it's updated with the new one.
 124   State              mState;                   ///< Selection mode, edit mode etc.
 125
 126   CharacterIndex     mPrimaryCursorPosition;   ///< Index into logical model for primary cursor.
 127   CharacterIndex     mLeftSelectionPosition;   ///< Index into logical model for left selection handle.
 128   CharacterIndex     mRightSelectionPosition;  ///< Index into logical model for right selection handle.
 129
 130   CharacterIndex     mPreEditStartPosition;    ///< Used to remove the pre-edit text if necessary.
 131   Length             mPreEditLength;           ///< Used to remove the pre-edit text if necessary.
 132
 133   float              mCursorHookPositionX;     ///< Used to move the cursor with the keys or when scrolling the text vertically with the handles.
 134
 135   Controller::NoTextTap::Action mDoubleTapAction; ///< Action to be done when there is a double tap on top of 'no text'
 136   Controller::NoTextTap::Action mLongPressAction; ///< Action to be done when there is a long press on top of 'no text'
 137
 138   bool mIsShowingPlaceholderText        : 1;   ///< True if the place-holder text is being displayed.
 139   bool mPreEditFlag                     : 1;   ///< True if the model contains text in pre-edit state.
 140   bool mDecoratorUpdated                : 1;   ///< True if the decorator was updated during event processing.
 141   bool mCursorBlinkEnabled              : 1;   ///< True if cursor should blink when active.
 142   bool mGrabHandleEnabled               : 1;   ///< True if grab handle is enabled.
 143   bool mGrabHandlePopupEnabled          : 1;   ///< True if the grab handle popu-up should be shown.
 144   bool mSelectionEnabled                : 1;   ///< True if selection handles, highlight etc. are enabled.
 145   bool mUpdateCursorHookPosition        : 1;   ///< True if the cursor hook position must be updated. Used to move the cursor with the keys 'up' and 'down'.
 146   bool mUpdateCursorPosition            : 1;   ///< True if the visual position of the cursor must be recalculated.
 147   bool mUpdateGrabHandlePosition        : 1;   ///< True if the visual position of the grab handle must be recalculated.
 148   bool mUpdateLeftSelectionPosition     : 1;   ///< True if the visual position of the left selection handle must be recalculated.
 149   bool mUpdateRightSelectionPosition    : 1;   ///< True if the visual position of the right selection handle must be recalculated.
 150   bool mIsLeftHandleSelected            : 1;   ///< Whether is the left handle the one which is selected.
 151   bool mIsRightHandleSelected           : 1;   ///< Whether is the right handle the one which is selected.
 152   bool mUpdateHighlightBox              : 1;   ///< True if the text selection high light box must be updated.
 153   bool mScrollAfterUpdatePosition       : 1;   ///< Whether to scroll after the cursor position is updated.
 154   bool mScrollAfterDelete               : 1;   ///< Whether to scroll after delete characters.
 155   bool mAllTextSelected                 : 1;   ///< True if the selection handles are selecting all the text.
 156   bool mUpdateInputStyle                : 1;   ///< Whether to update the input style after moving the cursor.
 157   bool mPasswordInput                   : 1;   ///< True if password input is enabled.
 158   bool mCheckScrollAmount               : 1;   ///< Whether to check scrolled amount after updating the position
 159   bool mIsPlaceholderPixelSize          : 1;   ///< True if the placeholder font size is set as pixel size.
 160 };
 161
 162 struct ModifyEvent
 163 {
 164   enum Type
 165   {
 166     TEXT_REPLACED,    ///< The entire text was replaced
 167     TEXT_INSERTED,    ///< Insert characters at the current cursor position
 168     TEXT_DELETED      ///< Characters were deleted
 169   };
 170
 171   Type type;
 172 };
 173
 174 struct FontDefaults
 175 {
 176   FontDefaults()
 177   : mFontDescription(),
 178     mDefaultPointSize( 0.f ),
 179     mFontId( 0u ),
 180     familyDefined( false ),
 181     weightDefined( false ),
 182     widthDefined( false ),
 183     slantDefined( false ),
 184     sizeDefined( false )
 185   {
 186     // Initially use the default platform font
 187     TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 188     fontClient.GetDefaultPlatformFontDescription( mFontDescription );
 189   }
 190
 191   FontId GetFontId( TextAbstraction::FontClient& fontClient )
 192   {
 193     if( !mFontId )
 194     {
 195       const PointSize26Dot6 pointSize = static_cast<PointSize26Dot6>( mDefaultPointSize * 64.f );
 196       mFontId = fontClient.GetFontId( mFontDescription, pointSize );
 197     }
 198
 199     return mFontId;
 200   }
 201
 202   TextAbstraction::FontDescription mFontDescription;  ///< The default font's description.
 203   float                            mDefaultPointSize; ///< The default font's point size.
 204   FontId                           mFontId;           ///< The font's id of the default font.
 205   bool familyDefined:1; ///< Whether the default font's family name is defined.
 206   bool weightDefined:1; ///< Whether the default font's weight is defined.
 207   bool  widthDefined:1; ///< Whether the default font's width is defined.
 208   bool  slantDefined:1; ///< Whether the default font's slant is defined.
 209   bool   sizeDefined:1; ///< Whether the default font's point size is defined.
 210 };
 211
 212 /**
 213  * @brief Stores indices used to update the text.
 214  * Stores the character index where the text is updated and the number of characters removed and added.
 215  * Stores as well indices to the first and the last paragraphs to be updated.
 216  */
 217 struct TextUpdateInfo
 218 {
 219   TextUpdateInfo()
 220   : mCharacterIndex( 0u ),
 221     mNumberOfCharactersToRemove( 0u ),
 222     mNumberOfCharactersToAdd( 0u ),
 223     mPreviousNumberOfCharacters( 0u ),
 224     mParagraphCharacterIndex( 0u ),
 225     mRequestedNumberOfCharacters( 0u ),
 226     mStartGlyphIndex( 0u ),
 227     mStartLineIndex( 0u ),
 228     mEstimatedNumberOfLines( 0u ),
 229     mClearAll( true ),
 230     mFullRelayoutNeeded( true ),
 231     mIsLastCharacterNewParagraph( false )
 232   {}
 233
 234   ~TextUpdateInfo()
 235   {}
 236
 237   CharacterIndex    mCharacterIndex;                ///< Index to the first character to be updated.
 238   Length            mNumberOfCharactersToRemove;    ///< The number of characters to be removed.
 239   Length            mNumberOfCharactersToAdd;       ///< The number of characters to be added.
 240   Length            mPreviousNumberOfCharacters;    ///< The number of characters before the text update.
 241
 242   CharacterIndex    mParagraphCharacterIndex;       ///< Index of the first character of the first paragraph to be updated.
 243   Length            mRequestedNumberOfCharacters;   ///< The requested number of characters.
 244   GlyphIndex        mStartGlyphIndex;
 245   LineIndex         mStartLineIndex;
 246   Length            mEstimatedNumberOfLines;         ///< The estimated number of lines. Used to avoid reallocations when layouting.
 247
 248   bool              mClearAll:1;                    ///< Whether the whole text is cleared. i.e. when the text is reset.
 249   bool              mFullRelayoutNeeded:1;          ///< Whether a full re-layout is needed. i.e. when a new size is set to the text control.
 250   bool              mIsLastCharacterNewParagraph:1; ///< Whether the last character is a new paragraph character.
 251
 252   void Clear()
 253   {
 254     // Clear all info except the mPreviousNumberOfCharacters member.
 255     mCharacterIndex = static_cast<CharacterIndex>( -1 );
 256     mNumberOfCharactersToRemove = 0u;
 257     mNumberOfCharactersToAdd = 0u;
 258     mParagraphCharacterIndex = 0u;
 259     mRequestedNumberOfCharacters = 0u;
 260     mStartGlyphIndex = 0u;
 261     mStartLineIndex = 0u;
 262     mEstimatedNumberOfLines = 0u;
 263     mClearAll = false;
 264     mFullRelayoutNeeded = false;
 265     mIsLastCharacterNewParagraph = false;
 266   }
 267 };
 268
 269 struct UnderlineDefaults
 270 {
 271   std::string properties;
 272   // TODO: complete with underline parameters.
 273 };
 274
 275 struct ShadowDefaults
 276 {
 277   std::string properties;
 278   // TODO: complete with shadow parameters.
 279 };
 280
 281 struct EmbossDefaults
 282 {
 283   std::string properties;
 284   // TODO: complete with emboss parameters.
 285 };
 286
 287 struct OutlineDefaults
 288 {
 289   std::string properties;
 290   // TODO: complete with outline parameters.
 291 };
 292
 293 struct Controller::Impl
 294 {
 295   Impl( ControlInterface* controlInterface,
 296         EditableControlInterface* editableControlInterface )
 297   : mControlInterface( controlInterface ),
 298     mEditableControlInterface( editableControlInterface ),
 299     mModel(),
 300     mFontDefaults( NULL ),
 301     mUnderlineDefaults( NULL ),
 302     mShadowDefaults( NULL ),
 303     mEmbossDefaults( NULL ),
 304     mOutlineDefaults( NULL ),
 305     mEventData( NULL ),
 306     mFontClient(),
 307     mClipboard(),
 308     mView(),
 309     mMetrics(),
 310     mModifyEvents(),
 311     mTextColor( Color::BLACK ),
 312     mTextUpdateInfo(),
 313     mOperationsPending( NO_OPERATION ),
 314     mMaximumNumberOfCharacters( 50u ),
 315     mHiddenInput( NULL ),
 316     mRecalculateNaturalSize( true ),
 317     mMarkupProcessorEnabled( false ),
 318     mClipboardHideEnabled( true ),
 319     mIsAutoScrollEnabled( false ),
 320     mAutoScrollDirectionRTL( false ),
 321     mUnderlineSetByString( false ),
 322     mShadowSetByString( false ),
 323     mFontStyleSetByString( false )
 324   {
 325     mModel = Model::New();
 326
 327     mFontClient = TextAbstraction::FontClient::Get();
 328     mClipboard = Clipboard::Get();
 329
 330     mView.SetVisualModel( mModel->mVisualModel );
 331
 332     // Use this to access FontClient i.e. to get down-scaled Emoji metrics.
 333     mMetrics = Metrics::New( mFontClient );
 334     mLayoutEngine.SetMetrics( mMetrics );
 335
 336     // Set the text properties to default
 337     mModel->mVisualModel->SetUnderlineEnabled( false );
 338     mModel->mVisualModel->SetUnderlineHeight( 0.0f );
 339   }
 340
 341   ~Impl()
 342   {
 343     delete mHiddenInput;
 344
 345     delete mFontDefaults;
 346     delete mUnderlineDefaults;
 347     delete mShadowDefaults;
 348     delete mEmbossDefaults;
 349     delete mOutlineDefaults;
 350     delete mEventData;
 351   }
 352
 353   // Text Controller Implementation.
 354
 355   /**
 356    * @copydoc Text::Controller::RequestRelayout()
 357    */
 358   void RequestRelayout();
 359
 360   /**
 361    * @brief Request a relayout using the ControlInterface.
 362    */
 363   void QueueModifyEvent( ModifyEvent::Type type )
 364   {
 365     if( ModifyEvent::TEXT_REPLACED == type)
 366     {
 367       // Cancel previously queued inserts etc.
 368       mModifyEvents.Clear();
 369     }
 370
 371     ModifyEvent event;
 372     event.type = type;
 373     mModifyEvents.PushBack( event );
 374
 375     // The event will be processed during relayout
 376     RequestRelayout();
 377   }
 378
 379   /**
 380    * @brief Helper to move the cursor, grab handle etc.
 381    */
 382   bool ProcessInputEvents();
 383
 384   /**
 385    * @brief Helper to check whether any place-holder text is available.
 386    */
 387   bool IsPlaceholderAvailable() const
 388   {
 389     return ( mEventData &&
 390              ( !mEventData->mPlaceholderTextInactive.empty() ||
 391                !mEventData->mPlaceholderTextActive.empty() )
 392            );
 393   }
 394
 395   bool IsShowingPlaceholderText() const
 396   {
 397     return ( mEventData && mEventData->mIsShowingPlaceholderText );
 398   }
 399
 400   /**
 401    * @brief Helper to check whether active place-holder text is available.
 402    */
 403   bool IsFocusedPlaceholderAvailable() const
 404   {
 405     return ( mEventData && !mEventData->mPlaceholderTextActive.empty() );
 406   }
 407
 408   bool IsShowingRealText() const
 409   {
 410     return ( !IsShowingPlaceholderText() &&
 411              0u != mModel->mLogicalModel->mText.Count() );
 412   }
 413
 414   /**
 415    * @brief Called when placeholder-text is hidden
 416    */
 417   void PlaceholderCleared()
 418   {
 419     if( mEventData )
 420     {
 421       mEventData->mIsShowingPlaceholderText = false;
 422
 423       // Remove mPlaceholderTextColor
 424       mModel->mVisualModel->SetTextColor( mTextColor );
 425     }
 426   }
 427
 428   void ClearPreEditFlag()
 429   {
 430     if( mEventData )
 431     {
 432       mEventData->mPreEditFlag = false;
 433       mEventData->mPreEditStartPosition = 0;
 434       mEventData->mPreEditLength = 0;
 435     }
 436   }
 437
 438   void ResetImfManager()
 439   {
 440     if( mEventData )
 441     {
 442       // Reset incase we are in a pre-edit state.
 443       if( mEventData->mImfManager )
 444       {
 445         mEventData->mImfManager.Reset(); // Will trigger a message ( commit, get surrounding )
 446       }
 447
 448       ClearPreEditFlag();
 449     }
 450   }
 451
 452   /**
 453    * @brief Helper to notify IMF manager with surrounding text & cursor changes.
 454    */
 455   void NotifyImfManager();
 456
 457   /**
 458    * @brief Helper to notify IMF manager with multi line status.
 459    */
 460   void NotifyImfMultiLineStatus();
 461
 462   /**
 463    * @brief Retrieve the current cursor position.
 464    *
 465    * @return The cursor position.
 466    */
 467   CharacterIndex GetLogicalCursorPosition() const;
 468
 469   /**
 470    * @brief Retrieves the number of consecutive white spaces starting from the given @p index.
 471    *
 472    * @param[in] index The character index from where to count the number of consecutive white spaces.
 473    *
 474    * @return The number of consecutive white spaces.
 475    */
 476   Length GetNumberOfWhiteSpaces( CharacterIndex index ) const;
 477
 478   /**
 479    * @brief Retrieve any text previously set starting from the given @p index.
 480    *
 481    * @param[in] index The character index from where to retrieve the text.
 482    * @param[out] text A string of UTF-8 characters.
 483    *
 484    * @see Dali::Toolkit::Text::Controller::GetText()
 485    */
 486   void GetText( CharacterIndex index, std::string& text ) const;
 487
 488   bool IsClipboardEmpty()
 489   {
 490     bool result( mClipboard && mClipboard.NumberOfItems() );
 491     return !result; // If NumberOfItems greater than 0, return false
 492   }
 493
 494   bool IsClipboardVisible()
 495   {
 496     bool result( mClipboard && mClipboard.IsVisible() );
 497     return result;
 498   }
 499
 500   /**
 501    * @brief Calculates the start character index of the first paragraph to be updated and
 502    * the end character index of the last paragraph to be updated.
 503    *
 504    * @param[out] numberOfCharacters The number of characters to be updated.
 505    */
 506   void CalculateTextUpdateIndices( Length& numberOfCharacters );
 507
 508   /**
 509    * @brief Helper to clear completely the parts of the model specified by the given @p operations.
 510    *
 511    * @note It never clears the text stored in utf32.
 512    */
 513   void ClearFullModelData( OperationsMask operations );
 514
 515   /**
 516    * @brief Helper to clear completely the parts of the model related with the characters specified by the given @p operations.
 517    *
 518    * @note It never clears the text stored in utf32.
 519    *
 520    * @param[in] startIndex Index to the first character to be cleared.
 521    * @param[in] endIndex Index to the last character to be cleared.
 522    * @param[in] operations The operations required.
 523    */
 524   void ClearCharacterModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations );
 525
 526   /**
 527    * @brief Helper to clear completely the parts of the model related with the glyphs specified by the given @p operations.
 528    *
 529    * @note It never clears the text stored in utf32.
 530    * @note Character indices are transformed to glyph indices.
 531    *
 532    * @param[in] startIndex Index to the first character to be cleared.
 533    * @param[in] endIndex Index to the last character to be cleared.
 534    * @param[in] operations The operations required.
 535    */
 536   void ClearGlyphModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations );
 537
 538   /**
 539    * @brief Helper to clear the parts of the model specified by the given @p operations and from @p startIndex to @p endIndex.
 540    *
 541    * @note It never clears the text stored in utf32.
 542    *
 543    * @param[in] startIndex Index to the first character to be cleared.
 544    * @param[in] endIndex Index to the last character to be cleared.
 545    * @param[in] operations The operations required.
 546    */
 547   void ClearModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations );
 548
 549   /**
 550    * @brief Updates the logical and visual models. Updates the style runs in the visual model when the text's styles changes.
 551    *
 552    * When text or style changes the model is set with some operations pending.
 553    * When i.e. the text's size or a relayout is required this method is called
 554    * with a given @p operationsRequired parameter. The operations required are
 555    * matched with the operations pending to perform the minimum number of operations.
 556    *
 557    * @param[in] operationsRequired The operations required.
 558    *
 559    * @return @e true if the model has been modified.
 560    */
 561   bool UpdateModel( OperationsMask operationsRequired );
 562
 563   /**
 564    * @brief Retreieves the default style.
 565    *
 566    * @param[out] inputStyle The default style.
 567    */
 568   void RetrieveDefaultInputStyle( InputStyle& inputStyle );
 569
 570   /**
 571    * @brief Retrieve the line height of the default font.
 572    */
 573   float GetDefaultFontLineHeight();
 574
 575   void OnCursorKeyEvent( const Event& event );
 576
 577   void OnTapEvent( const Event& event );
 578
 579   void OnPanEvent( const Event& event );
 580
 581   void OnLongPressEvent( const Event& event );
 582
 583   void OnHandleEvent( const Event& event );
 584
 585   void OnSelectEvent( const Event& event );
 586
 587   void OnSelectAllEvent();
 588
 589   /**
 590    * @brief Retrieves the selected text. It removes the text if the @p deleteAfterRetrieval parameter is @e true.
 591    *
 592    * @param[out] selectedText The selected text encoded in utf8.
 593    * @param[in] deleteAfterRetrieval Whether the text should be deleted after retrieval.
 594    */
 595   void RetrieveSelection( std::string& selectedText, bool deleteAfterRetrieval );
 596
 597   void ShowClipboard();
 598
 599   void HideClipboard();
 600
 601   void SetClipboardHideEnable(bool enable);
 602
 603   bool CopyStringToClipboard( std::string& source );
 604
 605   void SendSelectionToClipboard( bool deleteAfterSending );
 606
 607   void RequestGetTextFromClipboard();
 608
 609   void RepositionSelectionHandles();
 610   void RepositionSelectionHandles( float visualX, float visualY, Controller::NoTextTap::Action action );
 611
 612   void SetPopupButtons();
 613
 614   void ChangeState( EventData::State newState );
 615
 616   /**
 617    * @brief Calculates the cursor's position for a given character index in the logical order.
 618    *
 619    * It retrieves as well the line's height and the cursor's height and
 620    * if there is a valid alternative cursor, its position and height.
 621    *
 622    * @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.
 623    * @param[out] cursorInfo The line's height, the cursor's height, the cursor's position and whether there is an alternative cursor.
 624    */
 625   void GetCursorPosition( CharacterIndex logical,
 626                           CursorInfo& cursorInfo );
 627
 628   /**
 629    * @brief Calculates the new cursor index.
 630    *
 631    * It takes into account that in some scripts multiple characters can form a glyph and all of them
 632    * need to be jumped with one key event.
 633    *
 634    * @param[in] index The initial new index.
 635    *
 636    * @return The new cursor index.
 637    */
 638   CharacterIndex CalculateNewCursorIndex( CharacterIndex index ) const;
 639
 640   /**
 641    * @brief Updates the cursor position.
 642    *
 643    * Sets the cursor's position into the decorator. It transforms the cursor's position into decorator's coords.
 644    * It sets the position of the secondary cursor if it's a valid one.
 645    * Sets which cursors are active.
 646    *
 647    * @param[in] cursorInfo Contains the selection handle position in Actor's coords.
 648    *
 649    */
 650   void UpdateCursorPosition( const CursorInfo& cursorInfo );
 651
 652   /**
 653    * @brief Updates the position of the given selection handle. It transforms the handle's position into decorator's coords.
 654    *
 655    * @param[in] handleType One of the selection handles.
 656    * @param[in] cursorInfo Contains the selection handle position in Actor's coords.
 657    */
 658   void UpdateSelectionHandle( HandleType handleType,
 659                               const CursorInfo& cursorInfo );
 660
 661   /**
 662    * @biref Clamps the horizontal scrolling to get the control always filled with text.
 663    *
 664    * @param[in] layoutSize The size of the laid out text.
 665    */
 666   void ClampHorizontalScroll( const Vector2& layoutSize );
 667
 668   /**
 669    * @biref Clamps the vertical scrolling to get the control always filled with text.
 670    *
 671    * @param[in] layoutSize The size of the laid out text.
 672    */
 673   void ClampVerticalScroll( const Vector2& layoutSize );
 674
 675   /**
 676    * @brief Scrolls the text to make a position visible.
 677    *
 678    * @pre mEventData must not be NULL. (there is a text-input or selection capabilities).
 679    *
 680    * @param[in] position A position in text coords.
 681    * @param[in] lineHeight The line height for the given position.
 682    *
 683    * This method is called after inserting text, moving the cursor with the grab handle or the keypad,
 684    * or moving the selection handles.
 685    */
 686   void ScrollToMakePositionVisible( const Vector2& position, float lineHeight );
 687
 688   /**
 689    * @brief Scrolls the text to make the cursor visible.
 690    *
 691    * This method is called after deleting text.
 692    */
 693   void ScrollTextToMatchCursor( const CursorInfo& cursorInfo );
 694
 695 private:
 696   // Declared private and left undefined to avoid copies.
 697   Impl( const Impl& );
 698   // Declared private and left undefined to avoid copies.
 699   Impl& operator=( const Impl& );
 700
 701 public:
 702
 703   ControlInterface* mControlInterface;     ///< Reference to the text controller.
 704   EditableControlInterface* mEditableControlInterface; ///< Reference to the editable text controller.
 705   ModelPtr mModel;                         ///< Pointer to the text's model.
 706   FontDefaults* mFontDefaults;             ///< Avoid allocating this when the user does not specify a font.
 707   UnderlineDefaults* mUnderlineDefaults;   ///< Avoid allocating this when the user does not specify underline parameters.
 708   ShadowDefaults* mShadowDefaults;         ///< Avoid allocating this when the user does not specify shadow parameters.
 709   EmbossDefaults* mEmbossDefaults;         ///< Avoid allocating this when the user does not specify emboss parameters.
 710   OutlineDefaults* mOutlineDefaults;       ///< Avoid allocating this when the user does not specify outline parameters.
 711   EventData* mEventData;                   ///< Avoid allocating everything for text input until EnableTextInput().
 712   TextAbstraction::FontClient mFontClient; ///< Handle to the font client.
 713   Clipboard mClipboard;                    ///< Handle to the system clipboard
 714   View mView;                              ///< The view interface to the rendering back-end.
 715   MetricsPtr mMetrics;                     ///< A wrapper around FontClient used to get metrics & potentially down-scaled Emoji metrics.
 716   Layout::Engine mLayoutEngine;            ///< The layout engine.
 717   Vector<ModifyEvent> mModifyEvents;       ///< Temporary stores the text set until the next relayout.
 718   Vector4 mTextColor;                      ///< The regular text color
 719   TextUpdateInfo mTextUpdateInfo;          ///< Info of the characters updated.
 720   OperationsMask mOperationsPending;       ///< Operations pending to be done to layout the text.
 721   Length mMaximumNumberOfCharacters;       ///< Maximum number of characters that can be inserted.
 722   HiddenText* mHiddenInput;                ///< Avoid allocating this when the user does not specify hidden input mode.
 723
 724   bool mRecalculateNaturalSize:1;          ///< Whether the natural size needs to be recalculated.
 725   bool mMarkupProcessorEnabled:1;          ///< Whether the mark-up procesor is enabled.
 726   bool mClipboardHideEnabled:1;            ///< Whether the ClipboardHide function work or not
 727   bool mIsAutoScrollEnabled:1;             ///< Whether auto text scrolling is enabled.
 728   CharacterDirection mAutoScrollDirectionRTL:1;  ///< Direction of auto scrolling, true if rtl
 729
 730   bool mUnderlineSetByString:1;            ///< Set when underline is set by string (legacy) instead of map
 731   bool mShadowSetByString:1;               ///< Set when shadow is set by string (legacy) instead of map
 732   bool mFontStyleSetByString:1;            ///< Set when font style is set by string (legacy) instead of map
 733 };
 734
 735 } // namespace Text
 736
 737 } // namespace Toolkit
 738
 739 } // namespace Dali
 740
 741 #endif // DALI_TOOLKIT_TEXT_CONTROLLER_H