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