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