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    * @return The root actor of for this popup is returned.
 120    */
 121   Actor Self();
 122
 123   /**
 124    * Clears popup options (popup no longer exists)
 125    */
 126   void Clear();
 127
 128   /**
 129    * Create the label
 130    * @param[in] styledCaption The text to be displayed
 131    * @return the newly created label
 132    */
 133   Toolkit::TextView CreateOptionText( const MarkupProcessor::StyledTextArray& styledCaption );
 134
 135   /**
 136    * Create the label
 137    * @param[in] iconImage the image to be used
 138    * @return the newly created Image actor to be used as the icon
 139    */
 140   ImageActor CreateOptionIcon( Image iconImage );
 141
 142   /**
 143    * Creates and sets up the popup background
 144    */
 145   void CreatePopUpBackground();
 146
 147   /**
 148    * Create divider if multiple options
 149    */
 150   void CreateDivider();
 151
 152   /**
 153    * Create a background to be used when button 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 Vector3 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    * Toggle if a popup button should be enabled (shown) or not
 233    * @param[in]  requiredButton Button Id to enable or disable
 234    * @param[in]  enable toggle to enable (true) or disable (false)
 235    */
 236   void TogglePopUpButtonOnOff( TextInputPopup::Buttons requiredButton, bool enable );
 237
 238   /**
 239    * Set the Button Priority Position
 240    * @param[in] button Button id for priority to be set on
 241    * @param[in] priority Priority level, 1 is highest so will appear first.  0 priority will not show the button.
 242    */
 243   void SetButtonPriorityPosition( TextInputPopup::Buttons button, unsigned int priority );
 244
 245   /**
 246    * Get the Button Priority Position
 247    * @param[in] button Button id to get priority of
 248    * @return the button priority, 1 is highest, 0 is not shown.
 249    */
 250   unsigned int GetButtonPriorityPosition( TextInputPopup::Buttons button ) const;
 251
 252   /**
 253    * Adds Popup options which have been enabled.
 254    */
 255   void AddPopupOptions();
 256
 257   /**
 258    * Set Boundary that PopUp should stay within
 259    * @param[in] boundingRectangle coordinates of bounding box from Top Left
 260    */
 261   void SetPopupBoundary( const Rect<float>& boundingRectangle );
 262
 263   /**
 264    * Sets the positon of the PopUp tail relative to TextInput
 265    * @param position Position to set
 266    */
 267   void SetTailPosition( const Vector3& position );
 268
 269 private:
 270
 271   /**
 272    * Creates a Button with the required parameters.
 273    * @param[in] buttonId enum representing the button
 274    * @param[in] orderOfPriority Position in toolbar button should be position, 1 is first from left to right.
 275    * @param[in] name Given name for Button actor
 276    * @param[in] caption Text to display in button
 277    * @param[in] iconImage Icon to display in button
 278    * @param[in] enabled Toggle if button should be used or not, this is decided by the current state/conditions.
 279    */
 280   TextInputPopup::ButtonRequirement CreateRequiredButton( TextInputPopup::Buttons buttonId, std::size_t orderOfPriority,
 281                                                                           const std::string& name, const std::string& caption, Image iconImage, bool enabled );
 282
 283   /**
 284    * Adds Popup to the stage (ideally on a separate top-most layer and as an overlay)
 285    */
 286   void AddToStage();
 287
 288   /**
 289    * Applies constraint to keep Popup in view within the desired area.
 290    */
 291   void ApplyConfinementConstraint();
 292
 293   /**
 294    * Applies constraint to keep the Tail attached to Popup
 295    */
 296   void ApplyTailConstraint();
 297
 298   /**
 299    * Create a layer to hold the stencil
 300    * @param[in] size Size to of layer
 301    */
 302   void CreateLayer(  const Vector2& size );
 303
 304   /**
 305    * Create a stencil to clip the scroll view content
 306    * @param[in] size Size to of stencil
 307    */
 308   void CreateStencil( const Vector2& size );
 309
 310   /**
 311    * Popup has started to scroll
 312    * @param[in] position current scroll view position
 313    */
 314   void OnScrollStarted( const Vector3& position );
 315
 316   /**
 317    * Popup has stopped scrolling
 318    * @param[in] position current scroll view position
 319    */
 320   void OnScrollCompleted( const Vector3& position );
 321
 322   /**
 323    * Create a scroll view to hold the popup buttons and allow scrolling if too many buttons to fit within the visible boundary
 324    * @param[in] scrollViewSize size of content of the scroll view which can exceed its visible size
 325    * @param[in] visibleSize size of the visible scroll view
 326    */
 327   void CreateScrollView( const Vector2& scrollViewSize, const Vector2& visibleSize );
 328
 329   /**
 330    * Removes Popup from the stage.
 331    */
 332   void RemoveFromStage();
 333
 334   /**
 335    * Called when a button is pressed in the Popup
 336    * @param[in] button The button pressed.
 337    */
 338   bool OnButtonPressed( Toolkit::Button button );
 339
 340   /**
 341    * Invoked upon popup Hide animation completing.
 342    * @note Only called for animating hide, not called for instantaneous (animate = false)
 343    * @param[in] source The animation which completed.
 344    */
 345   void OnHideFinished(Animation& source);
 346
 347   /**
 348    * Invoked upon popup Show animation completing.
 349    * @note Only called for animating show, not called for instantaneous (animate = false)
 350    * @param[in] source The animation which completed.
 351    */
 352   void OnShowFinished(Animation& source);
 353
 354 private:
 355
 356   State mState;                                       ///< Popup State.
 357   Actor mRootActor;                                   ///< The actor which all popup content is added to (i.e. panel and buttons)
 358   Property::Index mAlternativeOffsetProperty;         ///< Property [Vector3] how much to offset the popup if it goes out of the screen
 359   ImageActor mBackground;                             ///< The background popup panel
 360   ImageActor mTail;                                   ///< The tail for the popup
 361   ImageActor mTailOutline;                            ///< The border/outline around the tail
 362
 363   float mPopupTailXPosition;                          ///< X position of PopUp tail.
 364
 365   Vector3 mContentSize;                               ///< Size of Content (i.e. Buttons)
 366   ActorContainer mButtonContainer;                    ///< List of buttons added to popup.
 367   ActorContainer mDividerContainer;                   ///< List of dividers added to popup.
 368   Animation mAnimation;                               ///< Popup Hide/Show animation.
 369
 370   Actor mStencil;                                     ///< Stencil to clip scrollview
 371   Toolkit::ScrollView mScrollView;                    ///< Scrollview to house the popup
 372   Layer mLayer;                                       ///< Layer to house the scroll view and stencil
 373
 374   std::vector<ButtonRequirement> mOrderListOfButtons;        // List of buttons in the order to be displayed and a flag to indicate if needed.
 375
 376   Vector4           mCutPasteButtonsColor;  // Color of the cut and paste popup
 377   Vector4           mCutPasteButtonsPressedColor;  // Color of the cut and paste buttons when pressed.
 378   Vector4           mBorderColor; // Color of the border around the Cut and Paste Popup
 379
 380   Rect<float> mBoundingRect; // Boundary that Popup must stay within.
 381
 382   // Priority of Options/Buttons in the Cut and Paste pop-up, higher priority buttons are displayed first, left to right.
 383   std::size_t mSelectOptionPriority;  // Position of Select Button
 384   std::size_t mSelectAllOptionPriority; // Position of Select All button
 385   std::size_t mCutOptionPriority; // Position of Cut button
 386   std::size_t mCopyOptionPriority; // Position of Copy button
 387   std::size_t mPasteOptionPriority;  // Position of Paste button
 388   std::size_t mClipboardOptionPriority;  // Position of Clipboard button
 389
 390   PressedSignalV2 mPressedSignal;              ///< Signal emitted when a button within the popup is pressed.
 391   HideFinishedSignalV2 mHideFinishedSignal;    ///< Signal emitted when popup is completely hidden
 392   ShowFinishedSignalV2 mShowFinishedSignal;    ///< Signal emitted when popup is completely shown
 393
 394 };
 395
 396 } // namespace Internal
 397
 398 } // namespace Toolkit
 399
 400 } // namespace Dali
 401
 402 #endif // __DALI_TOOLKIT_INTERNAL_ITEM_VIEW_H__