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