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