dali-toolkit/internal/controls/text-view/text-view-impl.h

   1 #ifndef __DALI_TOOLKIT_INTERNAL_TEXT_VIEW_H__
   2 #define __DALI_TOOLKIT_INTERNAL_TEXT_VIEW_H__
   3
   4 /*
   5  * Copyright (c) 2014 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/public-api/actors/camera-actor.h>
  23 #include <dali/public-api/actors/image-actor.h>
  24 #include <dali/public-api/actors/layer.h>
  25 #include <dali/public-api/images/glyph-image.h>
  26 #include <dali/public-api/render-tasks/render-task.h>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali-toolkit/public-api/controls/control-impl.h>
  30 #include <dali-toolkit/public-api/controls/text-view/text-view.h>
  31 #include <dali-toolkit/internal/controls/text-view/text-actor-cache.h>
  32 #include <dali-toolkit/internal/controls/text-view/text-view-processor-types.h>
  33
  34 namespace Dali
  35 {
  36
  37 namespace Toolkit
  38 {
  39
  40 namespace Internal
  41 {
  42
  43 /**
  44  * TextView is a custom control for text aligning and multiline support
  45  */
  46 class TextView : public Control
  47 {
  48 public:
  49
  50   /**
  51    * Internal exceed policy with the valid combinations.
  52    */
  53   enum ExceedPolicy
  54   {
  55     Original,             ///< Original size (even if it exceeds the witdh or the height).
  56     OriginalFade,         ///< Original size if it exceeds the width but faded if it exceeds the height.
  57     OriginalShrink,       ///< Shrunk if it exceeds the height.
  58     SplitOriginal,        ///< Split if it exceeds the width but no action if it exceeds the height.
  59     SplitFade,            ///< Split if it exceeds the width and faded if it exceeds the height.
  60     SplitShrink,          ///< Split if it exceeds the width and shrunk if it exceeds the height.
  61     SplitEllipsizeEnd,    ///< Split if it exceeds the width and ellipsize if it exceeds the height.
  62     Fade,                 ///< Faded if it exceeds any boundary.
  63     FadeOriginal,         ///< Faded if it exceeds the width but no action if it exceeds the height.
  64     ShrinkOriginal,       ///< Shrunk if it exceeds the width but no action if it exceeds the height.
  65     ShrinkFade,           ///< Shrunk if it exceeds the width and faded if it exceeds the height.
  66     Shrink,               ///< Shrunk if it exceeds any boundary.
  67     EllipsizeEndOriginal, ///< Ellipsized by the end if it exceeds the width but no action if it exceeds the height.
  68     EllipsizeEnd          ///< Ellipsized by the end if it exceeds the width and/or the height.
  69   };
  70
  71   // Between two OnRelayout methods, several calls to InsertTextAt, RemoveTextFrom or SetText can happen.
  72   // TextViewProcessorMetadata stores the type of operation. A vector stores all operations between two OnRelayout calls.
  73
  74   enum TextViewProcessorMetadataType
  75   {
  76     TextSet,             ///< Sets new text.
  77     TextInserted,        ///< Inserts text into current text.
  78     TextReplaced,        ///< Replaces some text from current text.
  79     TextRemoved,         ///< Removes some text from current text.
  80     NewLineHeight,       ///< Sets a new line height offset.
  81     NewStyle             ///< Sets a new style to the whole text.
  82   };
  83
  84   /**
  85    * Stores info about which data structures need to be modified when the OnRelayout() method is called
  86    */
  87   struct TextViewProcessorMetadata
  88   {
  89     TextViewProcessorMetadata();
  90
  91     TextViewProcessorMetadataType    mType;               ///< Stores the type of operation.
  92     std::size_t                      mPosition;           ///< Character position within the text.
  93     std::size_t                      mNumberOfCharacters; ///< Number of characters to be removed/replaced.
  94     MarkupProcessor::StyledTextArray mText;               ///< The new text.
  95     TextStyle::Mask                  mStyleMask;          ///< The style mask.
  96   };
  97
  98   /**
  99    * Defines which operations have to be done in the relayout process.
 100    */
 101   enum RelayoutOperationMask
 102   {
 103     NO_RELAYOUT = 0x0,                         ///< Does nothing.
 104     RELAYOUT_REMOVE_TEXT_ACTORS = 0x1,         ///< Removes current text-actors from the text-view.
 105     RELAYOUT_SIZE_POSITION = 0x2,              ///< Calculates size and position of the text but it doesn't calculate alignment.
 106     RELAYOUT_ALIGNMENT = 0x4,                  ///< Aligns the whole text.
 107     RELAYOUT_VISIBILITY = 0x8,                 ///< Calculates the visibility.
 108     RELAYOUT_INITIALIZE_TEXT_ACTORS = 0x10,    ///< Initialize text-actors (create handles).
 109     RELAYOUT_TEXT_ACTOR_UPDATE = 0x20,         ///< Updates text-actors (set size, position, style, ...)
 110     RELAYOUT_INSERT_TO_TEXT_VIEW = 0x40,       ///< Adds the text-actors to the text-view.
 111     RELAYOUT_ALL = 0xFF                        ///< Does all operations.
 112   };
 113
 114   //////////////////////////////////////////////
 115
 116   /**
 117    * Create a new TextView.
 118    * @return A smart-pointer to the newly allocated TextView.
 119    */
 120   static Toolkit::TextView New();
 121
 122   /**
 123    * @copydoc SetText( const std::string& text )
 124    */
 125   void SetText( const std::string& text );
 126
 127   /**
 128    * @copydoc SetText( const StyledTextArray& text )
 129    */
 130   void SetText( const MarkupProcessor::StyledTextArray& text );
 131
 132   /**
 133    * @copydoc InsertTextAt( std::size_t position, const std::string& text )
 134    */
 135   void InsertTextAt( std::size_t position, const std::string& text );
 136
 137   /**
 138    * @copydoc InsertTextAt( std::size_t position, const std::string& text )
 139    */
 140   void InsertTextAt( std::size_t position, const MarkupProcessor::StyledTextArray& text );
 141
 142   /**
 143    * @copydoc RemoveTextFrom( std::size_t position, std::size_t numberOfCharacters )
 144    */
 145   void RemoveTextFrom( std::size_t position, std::size_t numberOfCharacters );
 146
 147   /**
 148    * @copydoc ReplaceTextFromTo( std::size_t position, std::size_t numberOfCharacters, const std::string& text )
 149    */
 150   void ReplaceTextFromTo( std::size_t position, std::size_t numberOfCharacters, const std::string& text );
 151
 152   /**
 153    * @copydoc ReplaceTextFromTo( std::size_t position, std::size_t numberOfCharacters, const std::string& text )
 154    */
 155   void ReplaceTextFromTo( std::size_t position, std::size_t numberOfCharacters, const MarkupProcessor::StyledTextArray& text );
 156
 157   /**
 158    * @copydoc GetText()
 159    */
 160   std::string GetText() const;
 161
 162   /**
 163    * @copydoc SetLineHeightOffset()
 164    */
 165   void SetLineHeightOffset( PointSize offset );
 166
 167   /**
 168    * @copydoc GetLineHeightOffset()
 169    */
 170   PointSize GetLineHeightOffset() const;
 171
 172   /**
 173    * @copydoc SetStyleToCurrentText()
 174    */
 175   void SetStyleToCurrentText( const TextStyle& style, TextStyle::Mask mask );
 176
 177   /**
 178    * @copydoc SetTextAlignment( Toolkit::Alignment::Type align )
 179    */
 180   void SetTextAlignment( Toolkit::Alignment::Type align );
 181
 182   /**
 183    * @copydoc GetTextAlignment()
 184    */
 185   Toolkit::Alignment::Type GetTextAlignment() const;
 186
 187   /**
 188    * @copydoc SetMultilinePolicy()
 189    */
 190   void SetMultilinePolicy( Toolkit::TextView::MultilinePolicy policy );
 191
 192   /**
 193    * @copydoc GetMultilinePolicy()
 194    */
 195   Toolkit::TextView::MultilinePolicy GetMultilinePolicy() const;
 196
 197   /**
 198    * @copydoc SetWidthExceedPolicy()
 199    */
 200   void SetWidthExceedPolicy( Toolkit::TextView::ExceedPolicy policy );
 201
 202   /**
 203    * @copydoc GetWidthExceedPolicy()
 204    */
 205   Toolkit::TextView::ExceedPolicy GetWidthExceedPolicy() const;
 206
 207   /**
 208    * @copydoc SetHeightExceedPolicy()
 209    */
 210   void SetHeightExceedPolicy( Toolkit::TextView::ExceedPolicy policy );
 211
 212   /**
 213    * @copydoc GetHeightExceedPolicy()
 214    */
 215   Toolkit::TextView::ExceedPolicy GetHeightExceedPolicy() const;
 216
 217   /**
 218    * @copydoc SetLineJustification()
 219    */
 220   void SetLineJustification( Toolkit::TextView::LineJustification justification );
 221
 222   /**
 223    * @copydoc GetLineJustification()
 224    */
 225   Toolkit::TextView::LineJustification GetLineJustification() const;
 226
 227   /**
 228    * @copydoc SetFadeBoundary()
 229    */
 230   void SetFadeBoundary( const Toolkit::TextView::FadeBoundary& fadeBoundary );
 231
 232   /**
 233    * @copydoc GetFadeBoundary()
 234    */
 235   const Toolkit::TextView::FadeBoundary& GetFadeBoundary() const;
 236
 237   /**
 238    * @copydoc SetEllipsizeText()
 239    */
 240   void SetEllipsizeText( const std::string& ellipsizeText );
 241
 242   /**
 243    * @copydoc SetEllipsizeText()
 244    */
 245   void SetEllipsizeText( const MarkupProcessor::StyledTextArray& ellipsizeText );
 246
 247   /**
 248    * @copydoc SetEllipsizeText()
 249    */
 250   void SetEllipsizeText( const Text& ellipsizeText, const Vector<TextStyle*>& ellipsizeStyles );
 251
 252   /**
 253    * @copydoc GetEllipsizeText()
 254    */
 255   std::string GetEllipsizeText() const;
 256
 257   /**
 258    * Checks if relayout the text is needed. If it is, it relais out the text
 259    * by calling DoRelayOut().
 260    */
 261   void GetTextLayoutInfo();
 262
 263   /**
 264    * Calls GetTextLayoutInfo() and fills the given data structure.
 265    *
 266    * @see GetTextLayoutInfo()
 267    */
 268   void GetTextLayoutInfo( Toolkit::TextView::TextLayoutInfo& textLayoutInfo );
 269
 270   /**
 271    * @copydoc SetSortModifier()
 272    */
 273   void SetSortModifier( float depthOffset );
 274
 275   /**
 276    * @copydoc SetSnapshotModeEnabled()
 277    */
 278   void SetSnapshotModeEnabled( bool enable );
 279
 280   /**
 281    * @copydoc IsSnapshotModeEnabled()
 282    */
 283   bool IsSnapshotModeEnabled() const;
 284
 285   /**
 286    * @brief Sets whether markup processing should be carried out.
 287    *
 288    * @param[in] enable whether markup processing is carried out or not.
 289    */
 290   void SetMarkupProcessingEnabled( bool enable );
 291
 292   /**
 293    * @brief Returns whether markup processing is enabled or not
 294    *
 295    * @return true is markup processing is enabled
 296    */
 297   bool IsMarkupProcessingEnabled() const;
 298
 299   /**
 300    * @copydoc SetScrollEnabled()
 301    */
 302   void SetScrollEnabled( bool enable );
 303
 304   /**
 305    * @copydoc IsScrollEnabled()
 306    */
 307   bool IsScrollEnabled() const;
 308
 309   /**
 310    * @copydoc SetScrollPosition()
 311    * @see DoSetScrollPosition()
 312    */
 313   void SetScrollPosition( const Vector2& position );
 314
 315   /**
 316    * @copydoc GetScrollPosition()
 317    */
 318   const Vector2& GetScrollPosition() const;
 319
 320   /**
 321    * @copydoc IsScrollPositionTrimmed()
 322    */
 323   bool IsScrollPositionTrimmed() const;
 324
 325   /**
 326    * @copydoc ScrolledSignal()
 327    */
 328   Toolkit::TextView::ScrolledSignalType& ScrolledSignal();
 329
 330   /**
 331    * Connects a callback function with the object's signals.
 332    * @param[in] object The object providing the signal.
 333    * @param[in] tracker Used to disconnect the signal.
 334    * @param[in] signalName The signal to connect to.
 335    * @param[in] functor A newly allocated FunctorDelegate.
 336    * @return True if the signal was connected.
 337    * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
 338    */
 339   static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
 340
 341   // Properties
 342
 343   /**
 344    * Called when a property of an object of this type is set.
 345    * @param[in] object The object whose property is set.
 346    * @param[in] index The property index.
 347    * @param[in] value The new property value.
 348    */
 349   static void SetProperty( BaseObject* object, Property::Index index, const Property::Value& value );
 350
 351   /**
 352    * Called to retrieve a property of an object of this type.
 353    * @param[in] object The object whose property is to be retrieved.
 354    * @param[in] index The property index.
 355    * @return The current value of the property.
 356    */
 357   static Property::Value GetProperty( BaseObject* object, Property::Index index );
 358
 359
 360 private: // From Control
 361
 362   /**
 363    * @copydoc Toolkit::Control::OnInitialize()
 364    */
 365   virtual void OnInitialize();
 366
 367   /**
 368    * @copydoc Toolkit::Control::OnFontChange( )
 369    */
 370   virtual void OnFontChange( bool defaultFontChange, bool defaultFontSizeChange );
 371
 372   /**
 373    * @copydoc Toolkit::Control::OnControlSizeSet()
 374    */
 375   virtual void OnControlSizeSet( const Vector3& size );
 376
 377   /**
 378    * @copydoc Toolkit::Control::OnRelayout()
 379    */
 380   virtual void OnRelayout( const Vector2& size, RelayoutContainer& container );
 381
 382   /**
 383    * Retrieves the text-view's natural size.
 384    *
 385    * @return The natural size.
 386    */
 387   virtual Vector3 GetNaturalSize();
 388
 389   /**
 390    * Retrieves the text-view's \e height for a given \e width.
 391    *
 392    * @param[in] width The given \e width.
 393    *
 394    * @return The \e height for the given \e width.
 395    */
 396   virtual float GetHeightForWidth( float width );
 397
 398   /**
 399    * Retrieves the text-view's \e width for a given \e height.
 400    *
 401    * @param[in] height The given \e height.
 402    *
 403    * @return The \e width for the given \e height.
 404    */
 405   virtual float GetWidthForHeight( float height );
 406
 407 protected:
 408
 409   /**
 410    * Construct a new TextView.
 411    */
 412   TextView();
 413
 414   /**
 415    * A reference counted object may only be deleted by calling Unreference()
 416    */
 417   virtual ~TextView();
 418
 419 private:
 420
 421   // Undefined
 422   TextView( const TextView& );
 423
 424   // Undefined
 425   TextView& operator=( const TextView& rhs );
 426
 427   /**
 428    * Executes synchronously relayout operations such as set, insert, remove or replace text, etc.
 429    */
 430   void PerformTextViewProcessorOperations();
 431
 432   /**
 433    * Optimizes some text-view processor operations.
 434    */
 435   void OptimizeTextViewProcessorOperations();
 436
 437   /**
 438    * Synchronously relays-out all text-actors.
 439    *
 440    * Perform text-view-processor operations, sets the new size and position of text-actors and adds them to the text-view.
 441    *
 442    * @param[in] textViewSize The new text-view's size.
 443    * @param[in] relayoutOperationMask Defines which operations need to be done in the relayout process.
 444    */
 445   void DoRelayOut( const Size& textViewSize, RelayoutOperationMask relayoutOperationMask );
 446
 447   /**
 448    * Process Snapshot. It refresh the render-task in order to generate a new snapshot image.
 449    *
 450    * ProcessSnapshot is called from OnRelayout() only if text has been relaid out.
 451    * It creates a new image buffer only if the size of the text has changed.
 452    *
 453    * @param[in] textViewSize The new text-view's size.
 454    */
 455   void ProcessSnapshot( const Size& textViewSize );
 456
 457   /**
 458    * Aligns the offscreen rendering camera actor to cover the whole text and the resulting image actor accordingly with the text view's alignment.
 459    *
 460    * @param[in] textViewSize The text view's size.
 461    * @param[in] offscreenSize The offscreen's frame buffer's size.
 462    */
 463   void AlignOffscreenCameraActor( const Size& textViewSize, const Size& offscreenSize );
 464
 465   /**
 466    * Callback called when the render task has processed.
 467    *
 468    * It makes the root actor invisible.
 469    *
 470    * @param[in] renderTask The processed render task.
 471    */
 472   void RenderTaskFinished( Dali::RenderTask& renderTask );
 473
 474   /**
 475    * Destroys offscreen rendering resources.
 476    *
 477    * It disconects the render task finished signal from the TextView::RenderTaskFinished() method,
 478    * removes the render task from the render task list and resets the offscreen camera actor, root actor,
 479    * image actor and the frame buffer.
 480    */
 481   void DestroyOffscreenRenderingResources();
 482
 483   /**
 484    * Called when text-view is scrolled.
 485    *
 486    * Sets the new scroll position. @see DoSetScrollPosition()
 487    *
 488    * @param[in] actor Handle of the text-view.
 489    * @param[in] gesture Data structure with the parameters of the gesture.
 490    */
 491   void OnTextPan( Actor actor, const PanGesture& gesture );
 492
 493   /**
 494    * Ensures the text-view's boundaries are fully covered of text.
 495    *
 496    * i.e. if the text-view's size is 100x100 and the text's size is 150x100, the scroll position
 497    * can be in the range -50,0 and 50,0.
 498    */
 499   void TrimScrollPosition();
 500
 501   /**
 502    * Called from SetScrollPosition() and OnTextPan()
 503    *
 504    * Updates the stored scroll position ensuring the text-view is always covered with text by calling
 505    * TrimScrollPosition(), calculates the difference with the previous one and emits the Toolkit::TextView::SignalScrolled() signal.
 506    *
 507    * @param[in] position The new scroll position.
 508    */
 509   void DoSetScrollPosition( const Vector2& position );
 510
 511   /**
 512    * Combines width and height exceed policies.
 513    *
 514    * This method is a big switch() which combines two exceed policies into one.
 515    * The aim is avoid this switch inside the relayout code.
 516    *
 517    * i.e.  Width policy = Split. Height policy = Original. Internally the policy is SplitOriginal.
 518    */
 519   void CombineExceedPolicies();
 520
 521   /**
 522    * Retrieves the text-view's root actor which stores all text-actors.
 523    * It could be the text-view itself or an actor used in the snapshot mode.
 524    *
 525    * @return the root actor.
 526    */
 527   Actor GetRootActor() const;
 528
 529   /**
 530    * Creates the ellipsize text layout.
 531    */
 532   void CreateEllipsizeLayout();
 533
 534   /**
 535    * Handle SetProperty for markup processing.
 536    * @param[in] propertyValue The new property value.
 537    */
 538   void OnMarkupEnabledPeopertySet( Property::Value propertyValue );
 539
 540   /**
 541    * Handles SetProperty for multiline policy.
 542    * @param[in] propertyValue The new property value.
 543    */
 544   void OnMultilinePolicyPropertySet( Property::Value propertyValue );
 545
 546   /**
 547    * Handles SetProperty for width exceed policy.
 548    * @param[in] propertyValue The new property value.
 549    */
 550   void OnWidthExceedPolicyPropertySet( Property::Value propertyValue );
 551
 552   /**
 553    * Handles SetProperty for height exceed policy.
 554    * @param[in] propertyValue The new property value.
 555    */
 556   void OnHeightExceedPolicyPropertySet( Property::Value propertyValue );
 557
 558   /**
 559    * Handles SetProperty for line justification.
 560    * @param[in] propertyValue The new property value.
 561    */
 562   void OnLineJustificationPropertySet( Property::Value propertyValue );
 563
 564   /**
 565    * Handles SetProperty for fade boundary.
 566    * @param[in] propertyValue The new property value.
 567    */
 568   void OnFadeBoundaryPropertySet( Property::Value propertyValue );
 569
 570   /**
 571    * Handles SetProperty for alignment property.
 572    * @param[in] propertyIndex The property index.
 573    * @param[in] propertyValue The new property value.
 574    */
 575   void OnAlignmentPropertySet( Property::Index propertyIndex, Property::Value propertyValue );
 576
 577   /**
 578    * Handles GetProperty for horizontal alignment property.
 579    * @return The property value of horizontal alignment.
 580    */
 581   std::string OnHorizontalAlignmentPropertyGet();
 582
 583   /**
 584    * Handles GetProperty for vertical alignment property.
 585    * @return The property value of vertical alignment.
 586    */
 587   std::string OnVerticalAlignmentPropertyGet();
 588
 589 public:
 590
 591   /**
 592    * The parameters which affects the layout of the text.
 593    */
 594   struct LayoutParameters
 595   {
 596     /**
 597      * Default constructor.
 598      */
 599     LayoutParameters();
 600
 601     /**
 602      * Default destructor.
 603      */
 604     ~LayoutParameters();
 605
 606     /**
 607      * Constructor
 608      */
 609     LayoutParameters( Toolkit::TextView::MultilinePolicy     multilinePolicy,
 610                       Toolkit::TextView::ExceedPolicy        widthExceedPolicy,
 611                       Toolkit::TextView::ExceedPolicy        heightExceedPolicy,
 612                       Toolkit::Alignment::Type               alignment,
 613                       Toolkit::TextView::LineJustification   lineJustification,
 614                       float                                  lineHeightOffset,
 615                       bool                                   markUpEnabled );
 616
 617     /**
 618      * Copy constructor
 619      */
 620     LayoutParameters( const LayoutParameters& layoutParameters );
 621
 622     /**
 623      * Assignment operator.
 624      */
 625     LayoutParameters& operator=( const LayoutParameters& layoutParameters );
 626
 627     Toolkit::TextView::MultilinePolicy   mMultilinePolicy;     ///< Stores the multiline policy.
 628     TextView::ExceedPolicy               mExceedPolicy;        ///< Stores a combination of both policies.
 629     Toolkit::TextView::ExceedPolicy      mWidthExceedPolicy;   ///< Stores the text width exceed policy.
 630     Toolkit::TextView::ExceedPolicy      mHeightExceedPolicy;  ///< Stores the text height exceed policy.
 631     Toolkit::Alignment::Type             mHorizontalAlignment; ///< Stores the horizontal alignment for the whole text.
 632     Toolkit::Alignment::Type             mVerticalAlignment;   ///< Stores the vertical alignment for the whole text.
 633     Toolkit::TextView::LineJustification mLineJustification;   ///< Stores the line justification.
 634     float                                mLineHeightOffset;    ///< Line height offset to be addded to the font line height (measured in PointSize).
 635     bool                                 mMarkUpEnabled:1;     ///< Is markup string scanning enabled.
 636   };
 637
 638   /**
 639    * Some parameters which affects the text view visualization.
 640    */
 641   struct VisualParameters
 642   {
 643     /**
 644      * Default constructor.
 645      */
 646     VisualParameters();
 647
 648     /**
 649      * Copy constructor.
 650      */
 651     VisualParameters( const VisualParameters& visualParameters );
 652
 653     /**
 654      * Assignment operator.
 655      */
 656     VisualParameters& operator=( const VisualParameters& visualParameters );
 657
 658     Toolkit::TextView::FadeBoundary mFadeBoundary;            ///< Fade boundary used in fade mode.
 659     float                           mSortModifier;            ///< Stores the sort modifier for all text-actors.
 660     Vector2                         mCameraScrollPosition;    ///< The scroll offset.
 661     bool                            mSnapshotModeEnabled:1;   ///< Whether text-view is rendered offscreen.
 662     bool                            mScrollEnabled:1;         ///< Whether the text scroll is enabled.
 663     bool                            mScrollPositionTrimmed:1; ///< Whether the last scroll position set was trimmed.
 664   };
 665
 666   /**
 667    * The results of the relayout process.
 668    */
 669   struct RelayoutData
 670   {
 671     /**
 672      * Default constructor.
 673      */
 674     RelayoutData();
 675
 676     /**
 677      * Copy constructor
 678      */
 679     RelayoutData( const RelayoutData& relayoutData );
 680
 681     /**
 682      * Assignment operator.
 683      */
 684     RelayoutData& operator=( const RelayoutData& relayoutData );
 685
 686     Size                                            mTextViewSize;                ///< The text-view's size used to relaid-out the text.
 687     float                                           mShrinkFactor;                ///< Shrink factor used when the exceed policy contains ShrinkToFit.
 688     TextViewProcessor::TextLayoutInfo               mTextLayoutInfo;              ///< Stores metrics, layout info (size, direction, type of word) and text-actor info for the whole text.
 689     std::vector<int>                                mCharacterLogicalToVisualMap; ///< Reorder map that stores each character's visual (output) index according to its logical (input) index
 690     std::vector<int>                                mCharacterVisualToLogicalMap; ///< Reorder map that stores each character's logical (input) index according to its visual (output) index
 691     std::vector<RenderableActor>                    mGlyphActors;                 ///< Stores handles of those text-actors which are currently added to the text-view.
 692     std::vector<RenderableActor>                    mEllipsizedGlyphActors;       ///< Stores handles of those text-actors which are used to ellipsize the text.
 693     Toolkit::TextView::CharacterLayoutInfoContainer mCharacterLayoutInfoTable;    ///< Stores layout info per character sorted by the character's visual index.
 694     Toolkit::TextView::LineLayoutInfoContainer      mLines;                       ///< Stores an index to the first character of each line.
 695     Size                                            mTextSizeForRelayoutOption;   ///< Stores the text size after relayout.
 696     TextActorCache                                  mTextActorCache;              ///< Stores previously created text-actors to be reused.
 697   };
 698
 699 private:
 700
 701   MarkupProcessor::StyledTextArray       mCurrentStyledText;           ///< text currently displayed by the view
 702   std::vector<TextViewProcessorMetadata> mTextViewProcessorOperations; ///< Stores all relayout operations which arrive between two consecutive OnRelayout() calls.
 703
 704   LayoutParameters                       mLayoutParameters;            ///< Stores some layout parameters in a struct. To be passed in layout functions.
 705   VisualParameters                       mVisualParameters;            ///< Some parameters which afects text-view visualization.
 706   RelayoutData                           mRelayoutData;                ///< struct with text-view's data structures used to pass all of them in one parameter.
 707   RelayoutOperationMask                  mRelayoutOperations;          ///< Which relayout operations have to be done.
 708
 709   Layer                                  mOffscreenRootActor;          ///< Root actor for offscreen rendering.
 710   ImageActor                             mOffscreenImageActor;         ///< Image actor for offscreen rendering.
 711   CameraActor                            mOffscreenCameraActor;        ///< Camera actor for offscreen rendering.
 712   Size                                   mCurrentOffscreenSize;        ///< Current used ofscreen size.
 713   FrameBufferImage                       mFrameBufferImage;            ///< Frame buffer used for offscreen rendering.
 714   RenderTask                             mRenderTask;                  ///< Used to generate an offscreen rendering.
 715
 716   PanGestureDetector                     mPanGestureDetector;          ///< Pan gesture for text scrolling.
 717
 718   /**
 719    * Helper class used to prevent the modification of some members.
 720    */
 721   struct Lock
 722   {
 723     Lock( bool& lock )
 724     : mLock( lock )
 725     {
 726       mLock = true;
 727     }
 728
 729     ~Lock()
 730     {
 731       mLock = false;
 732     }
 733
 734     bool& mLock;
 735   };
 736
 737   bool                                            mLockPreviousSnapshotMode;      ///< Whether previous stored snapshot mode should be modified.
 738   bool                                            mPreviousSnapshotModeEnabled:1; ///< Stores the previous snapshot mode value.
 739   bool                                            mMarkUpEnabled:1;               ///< enable to scan for mark-up
 740
 741   Toolkit::TextView::ScrolledSignalType             mScrolledSignal;              ///< Signal emitted when text is scrolled.
 742 };
 743
 744 } // namespace Internal
 745
 746 // Helpers for public-api forwarding methods
 747
 748 inline Internal::TextView& GetImpl( TextView& textView )
 749 {
 750   DALI_ASSERT_ALWAYS( textView );
 751
 752   RefObject& handle = textView.GetImplementation();
 753
 754   return static_cast< Internal::TextView& >( handle );
 755 }
 756
 757 inline const Internal::TextView& GetImpl( const TextView& textView )
 758 {
 759   DALI_ASSERT_ALWAYS( textView );
 760
 761   const RefObject& handle = textView.GetImplementation();
 762
 763   return static_cast< const Internal::TextView& >( handle );
 764 }
 765
 766 } // namespace Toolkit
 767
 768 } // namespace Dali
 769
 770 #endif // __DALI_TOOLKIT_INTERNAL_ITEM_VIEW_H__