dali-toolkit/internal/controls/text-controls/text-selection-popup-impl.h

   1 #ifndef __DALI_TOOLKIT_INTERNAL_TEXT_SELECTION_POPUP_H__
   2 #define __DALI_TOOLKIT_INTERNAL_TEXT_SELECTION_POPUP_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 // INTERNAL INCLUDES
  22 #include <dali-toolkit/public-api/controls/control-impl.h>
  23 #include <dali-toolkit/public-api/controls/buttons/push-button.h>
  24 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
  25 #include <dali-toolkit/public-api/controls/table-view/table-view.h>
  26 #include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup.h>
  27 #include <dali-toolkit/devel-api/controls/text-controls/text-selection-toolbar.h>
  28
  29 // EXTERNAL INCLUDES
  30 #include <dali/public-api/actors/layer.h>
  31 #include <dali/public-api/object/property-map.h>
  32
  33 namespace Dali
  34 {
  35
  36 namespace Toolkit
  37 {
  38
  39 namespace Internal
  40 {
  41
  42 enum PopupCustomisations
  43 {
  44   POPUP_MAXIMUM_SIZE,
  45   OPTION_MAXIMUM_SIZE,
  46   OPTION_MINIMUM_SIZE,
  47   OPTION_DIVIDER_SIZE
  48 };
  49
  50 class TextSelectionPopup : public Control
  51 {
  52 public:
  53
  54   struct ButtonRequirement
  55   {
  56     ButtonRequirement()
  57     : id( Toolkit::TextSelectionPopup::NONE ),
  58       priority( 0u ),
  59       name(),
  60       caption(),
  61       icon(),
  62       enabled( false )
  63     {}
  64
  65     ButtonRequirement( Toolkit::TextSelectionPopup::Buttons buttonId,
  66                        std::size_t buttonPriority,
  67                        const std::string& buttonName,
  68                        const std::string& buttonCaption,
  69                        Dali::Image& buttonIcon,
  70                        bool buttonEnabled )
  71     : id( buttonId ),
  72       priority( buttonPriority ),
  73       name( buttonName ),
  74       caption( buttonCaption ),
  75       icon( buttonIcon ),
  76       enabled( buttonEnabled )
  77     {}
  78
  79     Toolkit::TextSelectionPopup::Buttons id;
  80     std::size_t priority;
  81     std::string name;
  82     std::string caption;
  83     Dali::Image icon;
  84     bool enabled;
  85   };
  86
  87   struct ButtonPriorityCompare
  88   {
  89       bool operator()( const ButtonRequirement& lhs, const ButtonRequirement& rhs ) const {
  90         return lhs.priority < rhs.priority;
  91       }
  92   };
  93
  94   /**
  95    * @brief New constructor with provided buttons to enable.
  96    * @param[in] callbackInterface The text popup callback interface which receives the button click callbacks.
  97    * @return A handle to the TextSelectionPopup control.
  98    */
  99   static Toolkit::TextSelectionPopup New( TextSelectionPopupCallbackInterface* callbackInterface );
 100
 101   // Properties
 102
 103   /**
 104    * @brief Called when a property of an object of this type is set.
 105    * @param[in] object The object whose property is set.
 106    * @param[in] index The property index.
 107    * @param[in] value The new property value.
 108    */
 109   static void SetProperty( BaseObject* object, Property::Index index, const Property::Value& value );
 110
 111   /**
 112    * @brief Called to retrieve a property of an object of this type.
 113    *
 114    * @param[in] object The object whose property is to be retrieved.
 115    * @param[in] index The property index.
 116    * @return The current value of the property.
 117    */
 118   static Property::Value GetProperty( BaseObject* object, Property::Index index );
 119
 120   /**
 121    * @copydoc Toolkit::EnableButtons
 122    */
 123   void EnableButtons( Toolkit::TextSelectionPopup::Buttons buttonsToEnable );
 124
 125   /**
 126    * @copydoc Toolkit::TextSelectionPopup::RaiseAbove()
 127    */
 128   void RaiseAbove( Layer target );
 129
 130   /**
 131    * @copydoc Toolkit::TextSelectionPopup::ShowPopup()
 132    */
 133   void ShowPopup();
 134
 135   /**
 136    * @copydoc Toolkiut::TextSelectionPopup::HidePopup()
 137    */
 138   void HidePopup();
 139
 140 private: // From Control
 141
 142   /**
 143    * @copydoc Control::OnInitialize()
 144    */
 145   virtual void OnInitialize();
 146
 147 private: // Implementation
 148
 149   void HideAnimationFinished( Animation& animation );
 150
 151   /**
 152    * @brief When the cut button is pressed.
 153    * @param[in] button the button pressed
 154    * @return @e true to consume the event.
 155    */
 156   bool OnCutButtonPressed( Toolkit::Button button );
 157
 158   /**
 159    * @brief When the copy button is pressed.
 160    * @param[in] button the button pressed
 161    * @return @e true to consume the event.
 162    */
 163   bool OnCopyButtonPressed( Toolkit::Button button );
 164
 165   /**
 166    * @brief When the paste button is pressed.
 167    * @param[in] button the button pressed
 168    * @return @e true to consume the event.
 169    */
 170   bool OnPasteButtonPressed( Toolkit::Button button );
 171
 172   /**
 173    * @brief When the select button is pressed.
 174    * @param[in] button the button pressed
 175    * @return @e true to consume the event.
 176    */
 177   bool OnSelectButtonPressed( Toolkit::Button button );
 178
 179   /**
 180    * @brief When the select all button is pressed.
 181    * @param[in] button the button pressed
 182    * @return @e true to consume the event.
 183    */
 184   bool OnSelectAllButtonPressed( Toolkit::Button button );
 185
 186   /**
 187    * @brief When the clipboard button is pressed.
 188    * @param[in] button the button pressed
 189    * @return @e true to consume the event.
 190    */
 191   bool OnClipboardButtonPressed( Toolkit::Button button );
 192
 193   /**
 194    * @brief Method to set the dimension or dimension constraint on certain aspects of the Popup.
 195    *
 196    * @param[in] settingToCustomise The setting for the PopupCustomisations enum that can be customised
 197    * @param[in] dimension The size to customise with
 198    */
 199   void SetDimensionToCustomise( const PopupCustomisations& settingToCustomise, const Size& dimension );
 200
 201   /**
 202    * @brief Method to get the dimension or dimension constraint on certain aspects of the Popup that was previously customised
 203    *
 204    * @param[in] setting The setting from the PopupCustomisations enum
 205    */
 206   Size GetDimensionToCustomise( const PopupCustomisations& setting );
 207
 208   /**
 209    * @brief Sets the image for the given button of the Popup.
 210    *
 211    * @param[in] button  The button the image should be used for from the Buttons Enum.
 212    * @param[in] image The image to use.
 213    */
 214  void SetButtonImage( Toolkit::TextSelectionPopup::Buttons button, Dali::Image image );
 215
 216   /**
 217    * @brief Retrieves the image of the given button used by the popup
 218    *
 219    * @param[in] button The button to get the image from
 220    * @return The image used for that button.
 221    */
 222   Dali::Image GetButtonImage( Toolkit::TextSelectionPopup::Buttons button );
 223
 224   /**
 225    * @brief Sets the image for the pressed state of a popup option.
 226    *
 227    * @param[in]  filename The image filename to use.
 228    */
 229   void SetPressedImage( const std::string& filename);
 230
 231   /**
 232    * @brief Gets the image used for the pressed state of a popup option.
 233    *
 234    * @return     The image filename used.
 235    */
 236   std::string GetPressedImage() const;
 237
 238   void CreateOrderedListOfPopupOptions();
 239
 240   void AddOption( const ButtonRequirement& button, bool showDivider, bool showIcons, bool showCaption );
 241
 242   std::size_t GetNumberOfEnabledOptions();
 243
 244   void AddPopupOptionsToToolbar(  bool showIcons, bool showCaptions );
 245
 246   /**
 247    * Creates the background-border image
 248    *
 249    * @param[in] propertyMap The properties describing the background-border
 250    */
 251   void CreateBackgroundBorder( Property::Map& propertyMap );
 252
 253   /**
 254    * Construct a new TextField.
 255    */
 256   TextSelectionPopup( TextSelectionPopupCallbackInterface* callbackInterface );
 257
 258   /**
 259    * A reference counted object may only be deleted by calling Unreference()
 260    */
 261   virtual ~TextSelectionPopup();
 262
 263 private:
 264
 265   // Undefined copy constructor and assignment operators
 266   TextSelectionPopup(const TextSelectionPopup&);
 267   TextSelectionPopup& operator=(const TextSelectionPopup& rhs);
 268
 269 private: // Data
 270
 271
 272   Dali::Toolkit::TextSelectionToolbar mToolbar;
 273
 274   Dali::Toolkit::TableView mTableOfButtons;           // Actor which holds all the buttons, sensitivity can be set on buttons via this actor
 275
 276   // Images to be used by the Popup buttons
 277   Image mCutIconImage;
 278   Image mCopyIconImage;
 279   Image mPasteIconImage;
 280   Image mClipboardIconImage;
 281   Image mSelectIconImage;
 282   Image mSelectAllIconImage;
 283
 284   Size mPopupMaxSize;                   // Maximum size of the Popup
 285   Size mOptionMaxSize;                  // Maximum size of an Option button
 286   Size mOptionMinSize;                  // Minimum size of an Option button
 287   Size mOptionDividerSize;              // Size of divider line
 288
 289   std::vector<ButtonRequirement> mOrderListOfButtons; // List of buttons in the order to be displayed and a flag to indicate if needed.
 290
 291   Toolkit::TextSelectionPopup::Buttons mEnabledButtons; // stores enabled buttons
 292   Toolkit::TextSelectionPopupCallbackInterface* mCallbackInterface;
 293
 294   std::string mPressedImage;            // Image used for the popup option when pressed.
 295   Vector4 mPressedColor;                // Color of the popup option when pressed.
 296   Vector4 mDividerColor;                // Color of the divider between buttons
 297   Vector4 mIconColor;                   // Color of the popup icon.
 298
 299   // Priority of Options/Buttons in the Cut and Paste pop-up, higher priority buttons are displayed first, left to right.
 300   std::size_t mSelectOptionPriority;    // Position of Select Button
 301   std::size_t mSelectAllOptionPriority; // Position of Select All button
 302   std::size_t mCutOptionPriority;       // Position of Cut button
 303   std::size_t mCopyOptionPriority;      // Position of Copy button
 304   std::size_t mPasteOptionPriority;     // Position of Paste button
 305   std::size_t mClipboardOptionPriority; // Position of Clipboard button
 306   float mFadeInDuration;                // Duration of the animation to fade in the Popup
 307   float mFadeOutDuration;               // Duration of the animation to fade out the Popup
 308
 309   bool mShowIcons:1; // Flag to show icons
 310   bool mShowCaptions:1; // Flag to show text captions
 311   bool mPopupShowing:1; // Flag to indicate Popup showing
 312   bool mButtonsChanged:1; // Flag to indicate the Popup Buttons have changed
 313
 314 };
 315
 316 } // namespace Internal
 317
 318 // Helpers for public-api forwarding methods
 319
 320 inline Toolkit::Internal::TextSelectionPopup& GetImpl( Toolkit::TextSelectionPopup& textSelectionPopup )
 321 {
 322   DALI_ASSERT_ALWAYS( textSelectionPopup );
 323
 324   Dali::RefObject& handle = textSelectionPopup.GetImplementation();
 325
 326   return static_cast<Toolkit::Internal::TextSelectionPopup&>(handle);
 327 }
 328
 329 inline const Toolkit::Internal::TextSelectionPopup& GetImpl( const Toolkit::TextSelectionPopup& textSelectionPopup )
 330 {
 331   DALI_ASSERT_ALWAYS( textSelectionPopup );
 332
 333   const Dali::RefObject& handle = textSelectionPopup.GetImplementation();
 334
 335   return static_cast<const Toolkit::Internal::TextSelectionPopup&>(handle);
 336 }
 337
 338 } // namespace Toolkit
 339
 340 } // namespace Dali
 341
 342 #endif // __DALI_TOOLKIT_INTERNAL_TEXT_SELECTION_POPUP_H__
 343