dali-toolkit/internal/text/decorator/text-decorator.h

   1 #ifndef __DALI_TOOLKIT_TEXT_DECORATOR_H__
   2 #define __DALI_TOOLKIT_TEXT_DECORATOR_H__
   3
   4 /*
   5  * Copyright (c) 2015 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/common/intrusive-ptr.h>
  23 #include <dali/public-api/object/ref-object.h>
  24 #include <dali/public-api/math/rect.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup.h>
  28
  29 namespace Dali
  30 {
  31
  32 struct Vector2;
  33 struct Vector4;
  34
  35 namespace Toolkit
  36 {
  37
  38 namespace Text
  39 {
  40
  41 class Decorator;
  42 typedef IntrusivePtr<Decorator> DecoratorPtr;
  43
  44 // Used to set the cursor positions etc.
  45 enum Cursor
  46 {
  47   PRIMARY_CURSOR,   ///< The primary cursor for bidirectional text (or the regular cursor for single-direction text)
  48   SECONDARY_CURSOR, ///< The secondary cursor for bidirectional text
  49   CURSOR_COUNT
  50 };
  51
  52 // Determines which of the cursors are active (if any).
  53 enum ActiveCursor
  54 {
  55   ACTIVE_CURSOR_NONE,    ///< Neither primary nor secondary cursor are active
  56   ACTIVE_CURSOR_PRIMARY, ///< Primary cursor is active (only)
  57   ACTIVE_CURSOR_BOTH     ///< Both primary and secondary cursor are active
  58 };
  59
  60 // The state information for handle events.
  61 enum HandleState
  62 {
  63   HANDLE_TAPPED,
  64   HANDLE_PRESSED,
  65   HANDLE_RELEASED,
  66   HANDLE_SCROLLING,
  67   HANDLE_STOP_SCROLLING
  68 };
  69
  70 // Used to set different handle images
  71 enum HandleImageType
  72 {
  73   HANDLE_IMAGE_PRESSED,
  74   HANDLE_IMAGE_RELEASED,
  75   HANDLE_IMAGE_TYPE_COUNT
  76 };
  77
  78 // Types of handles.
  79 enum HandleType
  80 {
  81   GRAB_HANDLE,
  82   LEFT_SELECTION_HANDLE,
  83   RIGHT_SELECTION_HANDLE,
  84   HANDLE_TYPE_COUNT
  85 };
  86
  87 /**
  88  * @brief A Text Decorator is used to display cursors, handles, selection highlights and pop-ups.
  89  *
  90  * The decorator is responsible for clipping decorations which are positioned outside of the parent area.
  91  *
  92  * The Popup decoration will be positioned either above the Grab handle or above the selection handles but if doing so
  93  * would cause the Popup to exceed the Decoration Bounding Box ( see SetBoundingBox API ) the the Popup will be repositioned below the handle(s).
  94  *
  95  * Selection handles will be flipped around to ensure they do not exceed the Decoration Bounding Box. ( Stay visible ).
  96  *
  97  * Decorator components forward input events to a controller class through an interface.
  98  * The controller is responsible for selecting which components are active.
  99  */
 100 class Decorator : public RefObject
 101 {
 102 public:
 103
 104   class ControllerInterface
 105   {
 106   public:
 107
 108     /**
 109      * @brief Constructor.
 110      */
 111     ControllerInterface() {};
 112
 113     /**
 114      * @brief Virtual destructor.
 115      */
 116     virtual ~ControllerInterface() {};
 117
 118     /**
 119      * @brief Query the target size of the UI control.
 120      *
 121      * @param[out] targetSize The size of the UI control the decorator is adding it's decorations to.
 122      */
 123     virtual void GetTargetSize( Vector2& targetSize ) = 0;
 124
 125     /**
 126      * @brief Add a decoration to the parent UI control.
 127      *
 128      * @param[in] decoration The actor displaying a decoration.
 129      */
 130     virtual void AddDecoration( Actor& actor, bool needsClipping ) = 0;
 131
 132     /**
 133      * @brief An input event from one of the handles.
 134      *
 135      * @param[in] handleType The handle's type.
 136      * @param[in] state The handle's state.
 137      * @param[in] x The x position relative to the top-left of the parent control.
 138      * @param[in] y The y position relative to the top-left of the parent control.
 139      */
 140     virtual void DecorationEvent( HandleType handleType, HandleState state, float x, float y ) = 0;
 141   };
 142
 143   /**
 144    * @brief Create a new instance of a Decorator.
 145    *
 146    * @param[in] controller The controller which receives input events from Decorator components.
 147    * @param[in] callbackInterface The text popup callback interface which receives the button click callbacks.
 148    *
 149    * @return A pointer to a new Decorator.
 150    */
 151   static DecoratorPtr New( ControllerInterface& controller,
 152                            TextSelectionPopupCallbackInterface& callbackInterface );
 153
 154   /**
 155    * @brief Set the bounding box which handles, popup and similar decorations will not exceed.
 156    *
 157    * The default value is the width and height of the stage from the top left origin.
 158    * If a title bar for example is on the top of the screen then the y should be the title's height and
 159    * the boundary height the stage height minus the title's height.
 160    * Restrictions - The boundary box should be set up with a fixed z position for the text-input and the default camera.
 161    *
 162    * ------------------------------------------
 163    * |(x,y)                                   |
 164    * |o---------------------------------------|
 165    * ||                                      ||
 166    * ||            Bounding Box              || boundary height
 167    * ||                                      ||
 168    * |----------------------------------------|
 169    * ------------------------------------------
 170    *               boundary width
 171    *
 172    * @param[in] boundingBox Vector( x coordinate, y coordinate, width, height )
 173    */
 174   void SetBoundingBox( const Rect<int>& boundingBox );
 175
 176   /**
 177    * @brief Retrieve the bounding box origin and dimensions.
 178    *
 179    * default is set once control is added to stage, before this the return vector will be Vector4:ZERO
 180    * @return Rect<int> the bounding box origin, width and height
 181    */
 182   const Rect<int>& GetBoundingBox() const;
 183
 184   /**
 185    * @brief The decorator waits until a relayout before creating actors etc.
 186    *
 187    * @param[in] size The size of the parent control after size-negotiation.
 188    */
 189   void Relayout( const Dali::Vector2& size );
 190
 191   /**
 192    * @brief Updates the decorator's actor positions after scrolling.
 193    *
 194    * @param[in] scrollOffset The scroll offset.
 195    */
 196   void UpdatePositions( const Vector2& scrollOffset );
 197
 198   /**
 199    * @brief Sets which of the cursors are active.
 200    *
 201    * @note Cursor will only be visible if within the parent area.
 202    * @param[in] activeCursor Which of the cursors should be active (if any).
 203    */
 204   void SetActiveCursor( ActiveCursor activeCursor );
 205
 206   /**
 207    * @brief Query which of the cursors are active.
 208    *
 209    * @return  Which of the cursors are active (if any).
 210    */
 211   unsigned int GetActiveCursor() const;
 212
 213   /**
 214    * @brief Sets the position of a cursor.
 215    *
 216    * @param[in] cursor The cursor to set.
 217    * @param[in] x The x position relative to the top-left of the parent control.
 218    * @param[in] y The y position relative to the top-left of the parent control.
 219    * @param[in] cursorHeight The logical height of the cursor.
 220    * @param[in] lineHeight The logical height of the line.
 221    */
 222   void SetPosition( Cursor cursor, float x, float y, float cursorHeight, float lineHeight );
 223
 224   /**
 225    * @brief Retrieves the position, height and lineHeight of a cursor.
 226    *
 227    * @param[in] cursor The cursor to get.
 228    * @param[out] x The x position relative to the top-left of the parent control.
 229    * @param[out] y The y position relative to the top-left of the parent control.
 230    * @param[out] cursorHeight The logical height of the cursor.
 231    * @param[out] lineHeight The logical height of the line.
 232    */
 233   void GetPosition( Cursor cursor, float& x, float& y, float& cursorHeight, float& lineHeight ) const;
 234
 235   /**
 236    * @brief Retrieves the position of a cursor.
 237    *
 238    * @param[in] cursor The cursor to get.
 239    *
 240    * @return The position.
 241    */
 242   const Vector2& GetPosition( Cursor cursor ) const;
 243
 244   /**
 245    * @brief Sets the color for a cursor.
 246    *
 247    * @param[in] cursor Whether this color is for the primary or secondary cursor.
 248    * @param[in] color The color to use.
 249    */
 250   void SetCursorColor( Cursor cursor, const Dali::Vector4& color );
 251
 252   /**
 253    * @brief Retrieves the color for a cursor.
 254    *
 255    * @param[in] cursor Whether this color is for the primary or secondary cursor.
 256    * @return The cursor color.
 257    */
 258   const Dali::Vector4& GetColor( Cursor cursor ) const;
 259
 260   /**
 261    * @brief Start blinking the cursor; see also SetCursorBlinkDuration().
 262    */
 263   void StartCursorBlink();
 264
 265   /**
 266    * @brief Stop blinking the cursor.
 267    */
 268   void StopCursorBlink();
 269
 270   /**
 271    * @brief Set the interval between cursor blinks.
 272    *
 273    * @param[in] seconds The interval in seconds.
 274    */
 275   void SetCursorBlinkInterval( float seconds );
 276
 277   /**
 278    * @brief Retrieves the blink-interval for a cursor.
 279    *
 280    * @return The cursor blink-interval.
 281    */
 282   float GetCursorBlinkInterval() const;
 283
 284   /**
 285    * @brief The cursor will stop blinking after this duration.
 286    *
 287    * @param[in] seconds The duration in seconds.
 288    */
 289   void SetCursorBlinkDuration( float seconds );
 290
 291   /**
 292    * @brief Retrieves the blink-duration for a cursor.
 293    *
 294    * @return The cursor blink-duration.
 295    */
 296   float GetCursorBlinkDuration() const;
 297
 298   /**
 299    * @brief Sets whether a handle is active.
 300    *
 301    * @param[in] handleType One of the handles.
 302    * @param[in] active True if the handle should be active.
 303    */
 304   void SetHandleActive( HandleType handleType,
 305                         bool active );
 306
 307   /**
 308    * @brief Query whether a handle is active.
 309    *
 310    * @param[in] handleType One of the handles.
 311    *
 312    * @return True if the handle is active.
 313    */
 314   bool IsHandleActive( HandleType handleType ) const;
 315
 316   /**
 317    * @brief Sets the image for one of the handles.
 318    *
 319    * @param[in] handleType One of the handles.
 320    * @param[in] handleImageType A different image can be set for the pressed/released states.
 321    * @param[in] image The image to use.
 322    */
 323   void SetHandleImage( HandleType handleType, HandleImageType handleImageType, Dali::Image image );
 324
 325   /**
 326    * @brief Retrieves the image for one of the handles.
 327    *
 328    * @param[in] handleType One of the handles.
 329    * @param[in] handleImageType A different image can be set for the pressed/released states.
 330    *
 331    * @return The grab handle image.
 332    */
 333   Dali::Image GetHandleImage( HandleType handleType, HandleImageType handleImageType ) const;
 334
 335   /**
 336    * @brief Sets the color of the handles
 337    *
 338    * @param[in] color The color to use.
 339    */
 340   void SetHandleColor( const Vector4& color );
 341
 342   /**
 343    * @brief Retrieves the handles color.
 344    *
 345    * @return The color of the handles.
 346    */
 347   const Vector4& GetHandleColor() const;
 348
 349   /**
 350    * @brief Sets the position of a selection handle.
 351    *
 352    * @param[in] handleType The handle to set.
 353    * @param[in] x The x position relative to the top-left of the parent control.
 354    * @param[in] y The y position relative to the top-left of the parent control.
 355    * @param[in] lineHeight The logical line height at this position.
 356    */
 357   void SetPosition( HandleType handleType, float x, float y, float lineHeight );
 358
 359   /**
 360    * @brief Retrieves the position of a selection handle.
 361    *
 362    * @param[in] handleType The handle to get.
 363    * @param[out] x The x position relative to the top-left of the parent control.
 364    * @param[out] y The y position relative to the top-left of the parent control.
 365    * @param[out] lineHeight The logical line height at this position.
 366    */
 367   void GetPosition( HandleType handleType, float& x, float& y, float& lineHeight ) const;
 368
 369   /**
 370    * @brief Retrieves the position of a selection handle.
 371    *
 372    * @param[in] handleType The handle to get.
 373    *
 374    * @return The position of the selection handle relative to the top-left of the parent control.
 375    */
 376   const Vector2& GetPosition( HandleType handleType ) const;
 377
 378   /**
 379    * @brief Swaps the selection handle's images.
 380    *
 381    * This method is called by the text controller to swap the handles
 382    * when the start index is bigger than the end one.
 383    */
 384   void SwapSelectionHandlesEnabled( bool enable );
 385
 386   /**
 387    * @brief Adds a quad to the existing selection highlights.
 388    *
 389    * @param[in] x1 The top-left x position.
 390    * @param[in] y1 The top-left y position.
 391    * @param[in] x2 The bottom-right x position.
 392    * @param[in] y3 The bottom-right y position.
 393    */
 394   void AddHighlight( float x1, float y1, float x2, float y2 );
 395
 396   /**
 397    * @brief Removes all of the previously added highlights.
 398    */
 399   void ClearHighlights();
 400
 401   /**
 402    * @brief Sets the selection highlight color.
 403    *
 404    * @param[in] color The color to use.
 405    */
 406   void SetHighlightColor( const Vector4& color );
 407
 408   /**
 409    * @brief Retrieves the selection highlight color.
 410    *
 411    * @return The color of the highlight
 412    */
 413   const Vector4& GetHighlightColor() const;
 414
 415   /**
 416    * @brief Sets into the decorator the depth used to render the text.
 417    *
 418    * @param[in] depth The text's depth.
 419    */
 420   void SetTextDepth( int textDepth );
 421
 422   /**
 423    * @brief Set the Selection Popup to show or hide via the active flaf
 424    * @param[in] active true to show, false to hide
 425    */
 426   void SetPopupActive( bool active );
 427
 428   /**
 429    * @brief Query whether the Selection Popup is active.
 430    *
 431    * @return True if the Selection Popup should be active.
 432    */
 433   bool IsPopupActive() const;
 434
 435   /**
 436    * @brief Set a bit mask of the buttons to be shown by Popup
 437    * @param[in] enabledButtonsBitMask from TextSelectionPopup::Buttons enum
 438    */
 439   void SetEnabledPopupButtons( TextSelectionPopup::Buttons& enabledButtonsBitMask );
 440
 441   /**
 442    * @brief Get the current bit mask of buttons to be shown by Popup
 443    * @return bitmask of TextSelectionPopup::Buttons
 444    */
 445   TextSelectionPopup::Buttons& GetEnabledPopupButtons();
 446
 447   /**
 448    * @brief Sets the scroll threshold.
 449    *
 450    * It defines a square area inside the control, close to the edge.
 451    * When the cursor enters this area, the decorator starts to send scroll events.
 452    *
 453    * @param[in] threshold The scroll threshold.
 454    */
 455   void SetScrollThreshold( float threshold );
 456
 457   /**
 458    * @brief Retrieves the scroll threshold.
 459    *
 460    * @retunr The scroll threshold.
 461    */
 462   float GetScrollThreshold() const;
 463
 464   /**
 465    * @brief Sets the scroll speed.
 466    *
 467    * Is the distance the text is going to be scrolled during a scroll interval.
 468    *
 469    * @param[in] speed The scroll speed.
 470    */
 471   void SetScrollSpeed( float speed );
 472
 473   /**
 474    * @brief Retrieves the scroll speed.
 475    *
 476    * @return The scroll speed.
 477    */
 478   float GetScrollSpeed() const;
 479
 480   /**
 481    * @brief Notifies the decorator the whole text has been scrolled.
 482    */
 483   void NotifyEndOfScroll();
 484
 485 protected:
 486
 487   /**
 488    * @brief A reference counted object may only be deleted by calling Unreference().
 489    */
 490   virtual ~Decorator();
 491
 492 private:
 493
 494   /**
 495    * @brief Private constructor.
 496    * @param[in] controller The controller which receives input events from Decorator components.
 497    * @param[in] callbackInterface The text popup callback interface which receives the button click callbacks.
 498    */
 499   Decorator( ControllerInterface& controller,
 500              TextSelectionPopupCallbackInterface& callbackInterface );
 501
 502   // Undefined
 503   Decorator( const Decorator& handle );
 504
 505   // Undefined
 506   Decorator& operator=( const Decorator& handle );
 507
 508 private:
 509
 510   struct Impl;
 511   Impl* mImpl;
 512 };
 513 } // namespace Text
 514
 515 } // namespace Toolkit
 516
 517 } // namespace Dali
 518
 519 #endif // __DALI_TOOLKIT_TEXT_DECORATOR_H__