base/dali-toolkit/internal/controls/text-input/text-input-popup-impl.h

   1 #ifndef __DALI_TOOLKIT_INTERNAL_TEXT_INPUT_POPUP_H__
   2 #define __DALI_TOOLKIT_INTERNAL_TEXT_INPUT_POPUP_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 // INTERNAL INCLUDES
  22 #include <dali/dali.h>
  23
  24 #include <dali-toolkit/public-api/controls/text-view/text-view.h>
  25 #include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view.h>
  26
  27 namespace Dali
  28 {
  29
  30 namespace Toolkit
  31 {
  32
  33 class Button;
  34
  35 namespace Internal
  36 {
  37
  38 class TextInputPopup : public ConnectionTracker
  39 {
  40
  41 public:
  42
  43   enum State
  44   {
  45     StateHidden,
  46     StateHiding,
  47     StateShowing,
  48     StateShown
  49   };
  50
  51   enum Buttons
  52   {
  53     ButtonsCut,
  54     ButtonsCopy,
  55     ButtonsPaste,
  56     ButtonsSelect,
  57     ButtonsSelectAll,
  58     ButtonsClipboard,
  59     ButtonsEnumEnd
  60   };
  61
  62   struct ButtonRequirement
  63   {
  64     TextInputPopup::Buttons buttonId;
  65     std::size_t orderOfPriority;
  66     std::string name;
  67     std::string caption;
  68     Image iconImage;
  69     bool enabled;
  70   };
  71
  72   static const char* const OPTION_SELECT_WORD;
  73   static const char* const OPTION_SELECT_ALL;
  74   static const char* const OPTION_CUT;
  75   static const char* const OPTION_COPY;
  76   static const char* const OPTION_PASTE;
  77   static const char* const OPTION_CLIPBOARD;
  78
  79   // Signal names
  80   static const char* const SIGNAL_PRESSED;
  81   static const char* const SIGNAL_HIDE_FINISHED;
  82   static const char* const SIGNAL_SHOW_FINISHED;
  83
  84   // Popup Button Pressed
  85   typedef SignalV2< bool( Toolkit::Button ) > PressedSignalV2;
  86
  87   // Popup Hide Finished
  88   typedef SignalV2< void( TextInputPopup& ) > HideFinishedSignalV2;
  89
  90   // Popup Show Finished
  91   typedef SignalV2< void( TextInputPopup& ) > ShowFinishedSignalV2;
  92
  93   /**
  94    * Signal emitted when the button is touched.
  95    */
  96   PressedSignalV2& PressedSignal();
  97
  98   /**
  99    * Signal emitted when popup is completely hidden
 100    * @note Only occurs after a Show() call with animation enabled.
 101    */
 102   HideFinishedSignalV2& HideFinishedSignal();
 103
 104   /**
 105    * Signal emitted when popup is completely shown
 106    * @note Only occurs after a Hide() call with animation enabled.
 107    */
 108   ShowFinishedSignalV2& ShowFinishedSignal();
 109
 110 public:
 111
 112   /**
 113    * Default constructor
 114    * Creates an empty popup base actor (no content i.e. invisible)
 115    */
 116   TextInputPopup();
 117
 118   /**
 119    * Clears popup options (popup no longer exists)
 120    */
 121   void Clear();
 122
 123   /**
 124    * Create the label
 125    * @return the newly created Image actor to be used as the icon
 126    */
 127   ImageActor CreateOptionIcon( Image iconImage, const Vector4& color );
 128
 129   /**
 130    * Create the caption
 131    * @param[in] styledCaption The text to be displayed
 132    * @return the newly created label
 133    */
 134   Toolkit::TextView CreateOptionCaption( const std::string& caption, const Vector4& color );
 135
 136   /**
 137    * Creates and sets up the background
 138    */
 139   void CreateBackground();
 140
 141   /**
 142    * Create and set up the tail
 143    */
 144   void CreateTail();
 145
 146   /**
 147    * Create divider if multiple options
 148    * @return Return a divider image actor
 149    */
 150   ImageActor CreateDivider();
 151
 152   /**
 153    * Create a background to be used when option pressed
 154    * @param[in] requiredSize size Image actor should be
 155    * @return Returns an Image Actor to be used a pressed background
 156    */
 157   ImageActor CreatePressedBackground( const Vector2& requiredSize );
 158
 159   /**
 160    * Creates a ordered vector of button options
 161    */
 162   void CreateOrderedListOfOptions();
 163
 164   /**
 165    * Adds a popup option.
 166    * @note Creates popup frame if not already created.
 167    * @param[in] name The unique name for this option.
 168    * @param[in] caption The caption (label) for this option
 169    * @param[in] iconImage Image to displayed with text.
 170    * @param[in] finalOption Flag to indicate that this is the final option.
 171    * (set to true on the last option you add)
 172    */
 173   void AddOption(const std::string& name, const std::string& caption, const Image iconImage, bool finalOption);
 174
 175   /**
 176    * Hides the popup
 177    * @param[in] animate (optional) whether to animate popup to hide state over time (i.e. tween).
 178    */
 179   void Hide(bool animate = true);
 180
 181   /**
 182    * Shows the popup
 183    * @param[in] animate (optional) whether to animate popup to show state over time (i.e. tween).
 184    */
 185   void Show(bool animate = true);
 186
 187   /**
 188    * Sets Alternative offset property.
 189    * The alternative offset property is how much to move in the horizontal and vertical
 190    * axes when the popup goes out of the screen on the left/right sides or top/bottom sides.
 191    * @param[in] offset Vector holding the left/right offset (x) and top/bottom offset (y)
 192    */
 193   void SetAlternativeOffset(Vector2 offset);
 194
 195   /**
 196    * Returns the current state of the popup.
 197    * @return The state of the popup see enum State
 198    */
 199   State GetState(void) const;
 200
 201   /**
 202    * Get the root actor which the buttons are added to.
 203    * @return the root actor
 204    */
 205   Actor GetRootActor() const;
 206
 207   /**
 208    * Set the Cut and Paste buttons color when in normal state
 209    * @param[in] color color to use
 210    */
 211   void SetCutPastePopupColor( const Vector4& color );
 212
 213   /**
 214    * Get the set color of the Copy and Paste Popup buttons
 215    * @return color
 216    */
 217   const Vector4& GetCutPastePopupColor() const;
 218
 219   /**
 220    * Set the Cut and Paste button color when pressed.
 221    * @param[in] color color to use
 222    */
 223   void SetCutPastePopupPressedColor( const Vector4& color );
 224
 225   /**
 226    * Get the Cut and Paste pressed button color.
 227    * @return color
 228    */
 229   const Vector4& GetCutPastePopupPressedColor() const;
 230
 231   /**
 232    * Set the border color of the popup
 233    * @param[in] color required color
 234    */
 235   void SetCutPastePopupBorderColor( const Vector4& color );
 236
 237   /**
 238    * Get the border color
 239    * @return Vector4 the color of the border
 240    */
 241   const Vector4& GetCutPastePopupBorderColor() const;
 242
 243   /**
 244    * Toggle if a popup button should be enabled (shown) or not
 245    * @param[in]  requiredButton Button Id to enable or disable
 246    * @param[in]  enable toggle to enable (true) or disable (false)
 247    */
 248   void TogglePopupButtonOnOff( TextInputPopup::Buttons requiredButton, bool enable );
 249
 250   /**
 251    * Set the Button Priority Position
 252    * @param[in] button Button id for priority to be set on
 253    * @param[in] priority Priority level, 1 is highest so will appear first.  0 priority will not show the button.
 254    */
 255   void SetButtonPriorityPosition( TextInputPopup::Buttons button, unsigned int priority );
 256
 257   /**
 258    * Set the icon color of the popup
 259    * @param[in] color required color
 260    */
 261   void SetCutPastePopupIconColor( const Vector4& color );
 262
 263   /**
 264    * Get the popup icon color
 265    * @return Vector4 the color of the popup icon
 266    */
 267   const Vector4& GetCutPastePopupIconColor() const;
 268
 269   /**
 270    * Set the pressed icon color of the popup
 271    * @param[in] color required color
 272    */
 273   void SetCutPastePopupIconPressedColor( const Vector4& color );
 274
 275   /**
 276    * Get the popup pressed icon color
 277    * @return Vector4 the color of the popup pressed icon
 278    */
 279   const Vector4& GetCutPastePopupIconPressedColor();
 280
 281   /**
 282    * Set the text color of the popup
 283    * @param[in] color required color
 284    */
 285   void SetCutPastePopupTextColor( const Vector4& color );
 286
 287   /**
 288    * Get the popup text color
 289    * @return Vector4 the color of the popup text
 290    */
 291   const Vector4& GetCutPastePopupTextColor();
 292
 293   /**
 294    * Set the pressed text color of the popup
 295    * @param[in] color required color
 296    */
 297   void SetCutPastePopupTextPressedColor( const Vector4& color );
 298
 299   /**
 300    * Get the popup pressed text color
 301    * @return Vector4 the color of the popup pressed text
 302    */
 303   const Vector4& GetCutPastePopupTextPressedColor();
 304
 305   /**
 306    * Get the Button Priority Position
 307    * @param[in] button Button id to get priority of
 308    * @return the button priority, 1 is highest, 0 is not shown.
 309    */
 310   unsigned int GetButtonPriorityPosition( TextInputPopup::Buttons button ) const;
 311
 312   /**
 313    * Adds Popup options which have been enabled.
 314    */
 315   void AddPopupOptions();
 316
 317   /**
 318    * Set Boundary that Popup should stay within
 319    * @param[in] boundingRectangle coordinates of bounding box from Top Left
 320    */
 321   void SetPopupBoundary( const Rect<float>& boundingRectangle );
 322
 323   /**
 324    * Sets the positon of the Popup tail relative to TextInput
 325    * @param position Position to set
 326    */
 327   void SetTailPosition( const Vector3& position );
 328
 329 private:
 330
 331   /**
 332    * Creates a Button with the required parameters.
 333    * @param[in] buttonId enum representing the button
 334    * @param[in] orderOfPriority Position in toolbar button should be position, 1 is first from left to right.
 335    * @param[in] name Given name for Button actor
 336    * @param[in] caption Text to display in button
 337    * @param[in] iconImage Icon to display in button
 338    * @param[in] enabled Toggle if button should be used or not, this is decided by the current state/conditions.
 339    */
 340   TextInputPopup::ButtonRequirement CreateRequiredButton( TextInputPopup::Buttons buttonId, std::size_t orderOfPriority,
 341                                                                           const std::string& name, const std::string& caption, Image iconImage, bool enabled );
 342
 343   /**
 344    * Adds Popup to the stage (ideally on a separate top-most layer and as an overlay)
 345    */
 346   void AddToStage();
 347
 348   /**
 349    * Applies constraint to keep Popup in view within the desired area.
 350    */
 351   void ApplyConfinementConstraint();
 352
 353   /**
 354    * Applies constraint to keep the Tail attached to Popup
 355    */
 356   void ApplyTailConstraint();
 357
 358   /**
 359    * Create a stencil to clip the scroll view content
 360    * @param[in] size of the stencil.
 361    */
 362   void CreateStencil( const Vector2& size );
 363
 364   /**
 365    * Popup has started to scroll
 366    * @param[in] position current scroll view position
 367    */
 368   void OnScrollStarted( const Vector3& position );
 369
 370   /**
 371    * Popup has stopped scrolling
 372    * @param[in] position current scroll view position
 373    */
 374   void OnScrollCompleted( const Vector3& position );
 375
 376   /**
 377    * Create a scroll view to hold the popup buttons and allow scrolling if too many buttons to fit within the visible boundary
 378    */
 379   void CreateScrollView();
 380
 381   /**
 382    * Set the scroll view size and ruler.
 383    * @param[in] visibleSize size of the visible scroll view
 384    */
 385   void UpdateScrollViewProperty( const Vector2& visibleSize );
 386
 387   /**
 388    * Removes Popup from the stage.
 389    */
 390   void RemoveFromStage();
 391
 392   /**
 393    * Called when a button is pressed in the Popup
 394    * @param[in] button The button pressed.
 395    */
 396   bool OnButtonPressed( Toolkit::Button button );
 397
 398   /**
 399    * Invoked upon popup Hide animation completing.
 400    * @note Only called for animating hide, not called for instantaneous (animate = false)
 401    * @param[in] source The animation which completed.
 402    */
 403   void OnHideFinished(Animation& source);
 404
 405   /**
 406    * Invoked upon popup Show animation completing.
 407    * @note Only called for animating show, not called for instantaneous (animate = false)
 408    * @param[in] source The animation which completed.
 409    */
 410   void OnShowFinished(Animation& source);
 411
 412 private:
 413
 414   State mState;                                       ///< Popup State.
 415   Layer mRoot;                                       ///< The actor which all popup content is added to (i.e. panel and buttons)
 416   Property::Index mAlternativeOffsetProperty;         ///< Property [Vector3] how much to offset the popup if it goes out of the screen
 417   Property::Index mRequestionPositionProperty;        ///< Prperty [Vector3] Requested position to place popup
 418   ImageActor mBackground;                             ///< The background popup panel
 419   ImageActor mBackgroundEffect;                       ///< The background effect
 420   ImageActor mBackgroundLine;                         ///< The background line
 421   ImageActor mTail;                                   ///< The tail for the popup
 422   ImageActor mTailEffect;                             ///< the tail effect
 423   ImageActor mTailLine;                               ///< The border/outline around the tail
 424
 425   float mPopupTailXPosition;                          ///< X position of Popup tail.
 426
 427   Vector2 mContentSize;                               ///< Size of Content (i.e. Buttons)
 428   ActorContainer mButtonContainer;                    ///< List of buttons added to popup.
 429   ActorContainer mDividerContainer;                   ///< List of dividers added to popup.
 430   Animation mAnimation;                               ///< Popup Hide/Show animation.
 431
 432   Actor mStencil;                                     ///< Stencil to clip scrollview
 433   Toolkit::ScrollView mScrollView;                    ///< Scrollview to house the popup
 434
 435   std::vector<ButtonRequirement> mOrderListOfButtons;        // List of buttons in the order to be displayed and a flag to indicate if needed.
 436
 437   Vector4 mBackgroundColor;              // Color of the background of the text input popup
 438   Vector4 mBackgroundPressedColor;       // Color of the option background.
 439   Vector4 mLineColor;                    // Color of the line around the text input popup
 440   Vector4 mIconColor;                    // Color of the popup icon.
 441   Vector4 mIconPressedColor;             // Color of the popup icon when pressed.
 442   Vector4 mTextColor;                    // Color of the popup text.
 443   Vector4 mTextPressedColor;             // Color of the popup text when pressed.
 444
 445   Rect<float> mBoundingRect; // Boundary that Popup must stay within.
 446
 447   // Priority of Options/Buttons in the Cut and Paste pop-up, higher priority buttons are displayed first, left to right.
 448   std::size_t mSelectOptionPriority;  // Position of Select Button
 449   std::size_t mSelectAllOptionPriority; // Position of Select All button
 450   std::size_t mCutOptionPriority; // Position of Cut button
 451   std::size_t mCopyOptionPriority; // Position of Copy button
 452   std::size_t mPasteOptionPriority;  // Position of Paste button
 453   std::size_t mClipboardOptionPriority;  // Position of Clipboard button
 454
 455   PressedSignalV2 mPressedSignal;              ///< Signal emitted when a button within the popup is pressed.
 456   HideFinishedSignalV2 mHideFinishedSignal;    ///< Signal emitted when popup is completely hidden
 457   ShowFinishedSignalV2 mShowFinishedSignal;    ///< Signal emitted when popup is completely shown
 458
 459 };
 460
 461 } // namespace Internal
 462
 463 } // namespace Toolkit
 464
 465 } // namespace Dali
 466
 467 #endif // __DALI_TOOLKIT_INTERNAL_ITEM_VIEW_H__