dali-toolkit/internal/controls/slider/slider-impl.h

   1 #ifndef __DALI_TOOLKIT_INTERNAL_SLIDER_H__
   2 #define __DALI_TOOLKIT_INTERNAL_SLIDER_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 // EXTERNAL INCLUDES
  22 #include <dali/public-api/adaptor-framework/timer.h>
  23 #include <dali/public-api/object/property-array.h>
  24 #include <dali/public-api/object/property-map.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/public-api/controls/control-impl.h>
  28 #include <dali-toolkit/public-api/controls/slider/slider.h>
  29 #include <dali-toolkit/public-api/controls/text-controls/text-label.h>
  30 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
  31
  32 namespace Dali
  33 {
  34
  35 namespace Toolkit
  36 {
  37
  38 class Button;
  39
  40 namespace Internal
  41 {
  42
  43 class Slider;
  44
  45 typedef Dali::IntrusivePtr< Slider > SliderPtr;
  46
  47 /**
  48  * @copydoc Toolkit::Slider
  49  */
  50 class Slider : public Control
  51 {
  52 public:
  53
  54   typedef Property::Array MarkList;
  55
  56   /**
  57    * Create a new Slider.
  58    *
  59    * @return A public handle to the newly allocated Slider.
  60    */
  61   static Dali::Toolkit::Slider New();
  62
  63 public:
  64
  65   // Properties
  66
  67   /**
  68    * Set marks from a list
  69    *
  70    * @param[in] marks The list of marks to set
  71    */
  72   void SetMarks( const MarkList& marks );
  73
  74   /**
  75    * Get the list of marks
  76    *
  77    * @return The marks list
  78    */
  79   const MarkList& GetMarks() const;
  80
  81   /**
  82    * Set if should snap to marks or not
  83    *
  84    * @param[in] snap Flag to snap to marks or not
  85    */
  86   void SetSnapToMarks( bool snap );
  87
  88   /**
  89    * Return if snap to marks is set or not
  90    *
  91    * @return If snap to marks is set
  92    */
  93   bool GetSnapToMarks() const;
  94
  95   /**
  96    * Set the value of the slider
  97    *
  98    * @param[in] value The value to set. Will be clamped to [lowerBound .. upperBound]
  99    */
 100   void SetValue( float value );
 101
 102   /**
 103    * Get the value of the slider
 104    *
 105    * @return The current value of the slider
 106    */
 107   float GetValue() const;
 108
 109   /**
 110    * Set hit region
 111    *
 112    * @param[in] region The hit region
 113    */
 114   void SetHitRegion( const Vector2& region );
 115
 116   /**
 117    * Get hit region
 118    *
 119    * @return The hit region
 120    */
 121   const Vector2& GetHitRegion() const;
 122
 123   /**
 124    * Set the track region
 125    *
 126    * @param[in] region The track region
 127    */
 128   void SetTrackRegion( const Vector2& region );
 129
 130   /**
 131    * Get the track region
 132    *
 133    * @return The track region
 134    */
 135   const Vector2& GetTrackRegion() const;
 136
 137   /**
 138    * @brief Set the disabled color.
 139    *
 140    * @param[in] color The disabled color.
 141    */
 142   void SetDisabledColor( const Vector4& color );
 143
 144   /**
 145    * @brief Get disabled color
 146    *
 147    * @return The disabled color
 148    */
 149   Vector4 GetDisabledColor() const;
 150
 151   /**
 152    * Set the value precision to be used for numbers in the slider
 153    *
 154    * @param[in] precision The number of decimal places to use for printing numbers
 155    */
 156   void SetValuePrecision( int precision );
 157
 158   /**
 159    * Get value precision
 160    *
 161    * @return The value precision
 162    */
 163   int GetValuePrecision() const;
 164
 165   /**
 166    * Show the popup
 167    *
 168    * @param[in] showPopup The show popup flag
 169    */
 170   void SetShowPopup( bool showPopup );
 171
 172   /**
 173    * Get show value in popup
 174    *
 175    * @return The show value flag
 176    */
 177   bool GetShowPopup() const;
 178
 179   /**
 180    * Set show value on handle
 181    *
 182    * @param[in] showValue The show value flag
 183    */
 184   void SetShowValue( bool showValue );
 185
 186   /**
 187    * Get show value on handle
 188    *
 189    * @return The show value flag
 190    */
 191   bool GetShowValue() const;
 192
 193   /**
 194    * Set enabled
 195    *
 196    * param[in] enabled Set the enabled flag
 197    */
 198   void SetEnabled( bool enabled );
 199
 200   /**
 201    * Return if enabled or not
 202    *
 203    * @return If enabled
 204    */
 205   bool IsEnabled() const;
 206
 207   /**
 208    * @brief Set the mark tolerance
 209    *
 210    * The tolerance is the percentage of the slider width for which snapping to
 211    * marks occurs
 212    *
 213    * @param[in] tolerance The percentage of width for which to snap
 214    */
 215   void SetMarkTolerance( float tolerance );
 216
 217   /**
 218    * Return the mark tolerance
 219    *
 220    * @return The tolerance set for snapping to marks
 221    */
 222   float GetMarkTolerance() const;
 223
 224 public:
 225   //Signals
 226
 227   /**
 228    * @copydoc Toolkit::Slider::ValueChangedSignal()
 229    */
 230   Toolkit::Slider::ValueChangedSignalType& ValueChangedSignal();
 231
 232   /**
 233    * copydoc Toolkit::Slider::SlidingFinishedSignal()
 234    */
 235   Toolkit::Slider::ValueChangedSignalType& SlidingFinishedSignal();
 236
 237   /**
 238    * @copydoc Toolkit::Slider::MarkReachedSignal()
 239    */
 240   Toolkit::Slider::MarkReachedSignalType& MarkReachedSignal();
 241
 242   /**
 243    * Connects a callback function with the object's signals.
 244    * @param[in] object The object providing the signal.
 245    * @param[in] tracker Used to disconnect the signal.
 246    * @param[in] signalName The signal to connect to.
 247    * @param[in] functor A newly allocated FunctorDelegate.
 248    * @return True if the signal was connected.
 249    * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
 250    */
 251   static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName,
 252                                FunctorDelegate* functor );
 253
 254   // Properties
 255
 256   /**
 257    * Called when a property of an object of this type is set.
 258    * @param[in] object The object whose property is set.
 259    * @param[in] index The property index.
 260    * @param[in] value The new property value.
 261    */
 262   static void SetProperty( BaseObject* object, Property::Index index, const Property::Value& value );
 263
 264   /**
 265    * Called to retrieve a property of an object of this type.
 266    * @param[in] object The object whose property is to be retrieved.
 267    * @param[in] index The property index.
 268    * @return The current value of the property.
 269    */
 270   static Property::Value GetProperty( BaseObject* object, Property::Index propertyIndex );
 271
 272 protected:
 273
 274   /**
 275    * Construct a new Slider.
 276    */
 277   Slider();
 278
 279   /**
 280    * A reference counted object may only be deleted by calling Unreference()
 281    */
 282   virtual ~Slider();
 283
 284   /**
 285    * @copydoc CustomActorImpl::OnRelayout
 286    */
 287   virtual void OnRelayout( const Vector2& size, RelayoutContainer& container );
 288
 289
 290 private:
 291
 292   /**
 293    * Domain is a from/to pair
 294    */
 295   struct Domain
 296   {
 297     Vector2 from;
 298     Vector2 to;
 299
 300     Domain()
 301     {
 302     }
 303     Domain( Vector2 fromVal, Vector2 toVal )
 304         : from( fromVal ), to( toVal )
 305     {
 306     }
 307   };
 308
 309   /**
 310    * Slider states
 311    */
 312   enum SliderState
 313   {
 314     NORMAL,
 315     DISABLED,
 316     PRESSED,
 317     FOCUSED
 318   };
 319
 320 private:
 321
 322   /**
 323    * @copydoc Toolkit::Control::OnInitialize()
 324    */
 325   virtual void OnInitialize();
 326
 327   /**
 328    * Hit region touch
 329    *
 330    * @param[in] actor The actor the event is raised for
 331    * @param[in] touch The touch info
 332    * @return If touch is handled or not
 333    */
 334   bool OnTouch( Actor actor, const TouchData& touch );
 335
 336   /**
 337    * Pan gesture event
 338    *
 339    * @param[in] actor The actor the event is raised for
 340    * @param[in] gesture The pan event info
 341    */
 342   void OnPan( Actor actor, const PanGesture& gesture );
 343
 344   /**
 345    * Map a position onto a domain and return the result as a percentage
 346    *
 347    * @param[in] point The point to map onto the domain
 348    * @return The result as a percentage [0..1]
 349    */
 350   float MapPercentage( const Vector2& point );
 351
 352   /**
 353    * Map a value in the range to a percentage
 354    *
 355    * @param[in] point The value in range [lowerBound..upperBound]
 356    * @return The result as a percentage [0..1]
 357    */
 358   float MapValuePercentage( float value );
 359
 360   /**
 361    * Convert a point in local hit space into domain space
 362    *
 363    * @param[in] x The x position to convert
 364    * @return The x position in domain space
 365    */
 366   float HitSpaceToDomain( float x );
 367
 368   /**
 369    * Map a percentage onto the slider's bounds
 370    *
 371    * @param[in] percent The current value of slider in percent
 372    * @param[in] lowerBound The lower bound to map onto
 373    * @param[in] upperBound The upper bound to map onto
 374    * @return The value of percent mapped from lowerBound to upperBound
 375    */
 376   float MapBounds( float percent, float lowerBound, float upperBound );
 377
 378   /**
 379    * Get the range of the valid values the slider handle can move between
 380    *
 381    * @param[in] currentSize The current size of the slider
 382    * @return The range as a domain pair
 383    */
 384   Domain CalcDomain( const Vector2& currentSize );
 385
 386   /**
 387    * Create the hit region
 388    *
 389    * @return The hit region actor
 390    */
 391   Actor CreateHitRegion();
 392
 393   /**
 394    * Create the track for the slider
 395    *
 396    * @return The track actor
 397    */
 398   Toolkit::ImageView CreateTrack();
 399
 400   /**
 401    * Create the progress track for the slider
 402    *
 403    * @return The track actor
 404    */
 405   Toolkit::ImageView CreateProgress();
 406
 407   /**
 408    * Create the handle for the slider
 409    *
 410    * @return The created image handle
 411    */
 412   Toolkit::ImageView CreateHandle();
 413
 414   /**
 415    * Create the popup arrow
 416    *
 417    * @return The created image handle
 418    */
 419   Toolkit::ImageView CreatePopupArrow();
 420
 421   /**
 422    * Create the popup
 423    *
 424    * @return The created image handle
 425    */
 426   Toolkit::ImageView CreatePopup();
 427
 428   /**
 429    * Create the textview for the popup
 430    *
 431    * @return The textview created for the popup
 432    */
 433   Toolkit::TextLabel CreatePopupText();
 434
 435   /**
 436    * Create the value display for the slider
 437    *
 438    * @return The created root actor of the display
 439    */
 440   Actor CreateValueDisplay();
 441
 442   /**
 443    * Set the skin based on the current state
 444    */
 445   void UpdateSkin();
 446
 447   /**
 448    * Create all the children
 449    */
 450   void CreateChildren();
 451
 452   /**
 453    * Create value popup
 454    */
 455   void AddPopup();
 456
 457   /**
 458    * Remove value popup
 459    */
 460   void RemovePopup();
 461
 462   /**
 463    * Display the popup for a set duration with the given value
 464    *
 465    * @param[in] value The value to display in the popup
 466    */
 467   void DisplayPopup( float value );
 468
 469   /**
 470    * If there are marks present, filter the incoming percent based on snapping to any nearby marks
 471    *
 472    * @param[in] value The incoming value on the slider to filter
 473    * @return The filtered percentage snapped to any nearby marks
 474    */
 475   float MarkFilter( float value );
 476
 477   /**
 478    * If there are marks present, snap the incoming percent to the nearest mark
 479    *
 480    * @param[in] value The incoming value on the slider to snap
 481    * @return The filtered percentage snapped to the nearest mark
 482    */
 483   float SnapToMark( float value );
 484
 485   /**
 486    * Search for if a mark has been reached
 487    *
 488    * @param[in] value The value to search against
 489    * @param[out] outIndex The index of the mark if found
 490    * @return If a mark has been found to match percent
 491    */
 492   bool MarkReached( float value, int& outIndex );
 493
 494   /**
 495    * Handler for when the value view needs to be hidden
 496    *
 497    * @return If handled or not
 498    */
 499   bool HideValueView();
 500
 501   /**
 502    * Set value choosing whether to fire signals or not
 503    *
 504    * @paramp[in] value The value to set
 505    * @param[in] raiseSignals Configure signals to be raised or not.
 506    */
 507   void DisplayValue( float value, bool raiseSignals );
 508
 509   /**
 510    * Create the image for the track
 511    *
 512    * @param[in] filename The track image
 513    */
 514   void SetTrackVisual( const std::string& filename );
 515
 516   /**
 517    * @brief Set the track visual from an Dali::Property::Map
 518    *
 519    * @param[in] map The Dali::Property::Map to use for to display
 520    */
 521   void SetTrackVisual( Dali::Property::Map map );
 522
 523   /**
 524    * @brief Return the track image.
 525    *
 526    * @return The track image.
 527    */
 528   std::string GetTrackVisual();
 529
 530   /**
 531    * Create the image for the progress bar
 532    *
 533    * @param[in] filename The progress bar image
 534    */
 535   void SetProgressVisual( const std::string& filename );
 536
 537   /**
 538    * @brief Set the progress visual from an Dali::Property::Map
 539    *
 540    * @param[in] map The Dali::Property::Map to use for to display
 541    */
 542   void SetProgressVisual( Dali::Property::Map map );
 543
 544   /**
 545    * @brief Return the progress bar image.
 546    *
 547    * @return The progress bar image if it exists.
 548    */
 549   std::string GetProgressVisual();
 550
 551   /**
 552    * @brief Create the image for the popup
 553    *
 554    * @param[in] filename The popup image
 555    */
 556   void CreatePopupImage( const std::string& filename );
 557
 558   /**
 559    * @brief Set the popup image
 560    *
 561    * @param[in] filename The popup image to set
 562    */
 563   void SetPopupVisual( const std::string& filename );
 564
 565   /**
 566    * @brief Set the popup from an Dali::Property::Map
 567    *
 568    * @param[in] map The Dali::Property::Map to use for to display
 569    */
 570   void SetPopupVisual( Dali::Property::Map map );
 571
 572   /**
 573    * @brief Return the popup image.
 574    *
 575    * @return The popup image if it exists.
 576    */
 577   std::string GetPopupVisual();
 578
 579   /**
 580    * @brief Set the popup arrow image
 581    *
 582    * @param[in] filename The popup arrow image to set
 583    */
 584   void SetPopupArrowVisual( const std::string& filename );
 585
 586   /**
 587    * @brief Set the popup arrow from an Dali::Property::Map
 588    *
 589    * @param[in] map The Dali::Property::Map to use for to display
 590    */
 591   void SetPopupArrowVisual( Dali::Property::Map map );
 592
 593   /**
 594    * @brief Return the popup arrow image.
 595    *
 596    * @return The popup arrow image if it exists.
 597    */
 598   std::string GetPopupArrowVisual();
 599
 600   /**
 601    * Create the image for the popup arrow
 602    *
 603    * @param[in] filename The popup arrow image to load and set
 604    */
 605   void CreatePopupArrowImage( const std::string& filename );
 606
 607   /**
 608    * Set the size of the progress bar region
 609    *
 610    * @param[in] region The size of the region to set
 611    */
 612   void ResizeProgressRegion( const Vector2& region );
 613
 614   /**
 615    * Create the image for the handle
 616    *
 617    * @param[in] filename The handle image
 618    */
 619   void SetHandleVisual( const std::string& filename );
 620
 621   /**
 622    * @brief Set the handle visual from an Dali::Property::Map
 623    *
 624    * @param[in] map The Dali::Property::Map to use for to display
 625    */
 626   void SetHandleVisual( Property::Map map );
 627
 628   /**
 629    * @brief Return the handle image.
 630    *
 631    * @return The handle image if it exists.
 632    */
 633   std::string GetHandleVisual();
 634
 635   /**
 636    * Reset the size of the handle
 637    *
 638    * @param[in] size The size of the handle to set
 639    */
 640   void ResizeHandleSize( const Vector2& size );
 641
 642   /**
 643    * Create and display the value on the handle
 644    */
 645   void CreateHandleValueDisplay();
 646
 647   /**
 648    * Remove and destroy the handle value display
 649    */
 650   void DestroyHandleValueDisplay();
 651
 652   /**
 653    * Set the size of the handle
 654    *
 655    * @param[in] size The handle size
 656    */
 657   void SetHandleSize( const Vector2& size );
 658
 659   /**
 660    * Get the size of the handle
 661    *
 662    * @return The handle size
 663    */
 664   const Vector2& GetHandleSize() const;
 665
 666   /**
 667    * Set the lower bound of the slider's value
 668    *
 669    * @param[in] bound The value to set for the lower bound
 670    */
 671   void SetLowerBound( float bound );
 672
 673   /**
 674    * Get the lower bound of the slider's value
 675    *
 676    * @return The lower bound value
 677    */
 678   float GetLowerBound() const;
 679
 680   /**
 681    * Set the upper bound of the slider's value
 682    *
 683    * @param[in] bound The value to set for the upper bound
 684    */
 685   void SetUpperBound( float bound );
 686
 687   /**
 688    * Get the upper bound of the slider's value
 689    *
 690    * @return The upper bound value
 691    */
 692   float GetUpperBound() const;
 693
 694 private:
 695
 696   // Undefined
 697   Slider( const Slider& );
 698
 699   // Undefined
 700   Slider& operator=( const Slider& rhs );
 701
 702 private:
 703
 704   Domain mDomain;                           ///< Current domain of the handle
 705
 706   Actor mHitArea;                           ///< The input handler
 707   Actor mValueDisplay;                      ///< Display of the value
 708   Toolkit::ImageView mTrack;                ///< Track image
 709   Toolkit::ImageView mHandle;               ///< Slider handle
 710   Toolkit::ImageView mProgress;             ///< Progress bar
 711   Toolkit::ImageView mPopup;                ///< Popup backing
 712   Toolkit::ImageView mPopupArrow;           ///< Popup arrow backing
 713
 714   Toolkit::TextLabel mValueTextLabel;       //< The text value in popup
 715   Toolkit::TextLabel mHandleValueTextLabel; ///< The text value on handle
 716   Vector2 mHandleLastTouchPoint;            ///< The last touch point for the handle
 717   Timer mValueTimer;                        ///< Timer used to hide value view
 718
 719   Toolkit::Slider::ValueChangedSignalType mValueChangedSignal;       ///< Signal emitted when the value is changed
 720   Toolkit::Slider::ValueChangedSignalType mSlidingFinishedSignal;    ///< Signal emitted when a sliding is finished
 721   Toolkit::Slider::MarkReachedSignalType mMarkReachedSignal;         ///< Signal emitted when a mark is reached
 722
 723   SliderState mState;                 ///< The state of the slider
 724
 725   PanGestureDetector mPanDetector;    ///< Hit region pan detector
 726
 727   MarkList mMarks;                    ///< List of discreet marks
 728
 729   std::string mPopupVisual;           ///< Image for popup image
 730   std::string mPopupArrowVisual;      ///< Image for popup arrow image
 731   std::string mTrackVisual;           ///< Image for track image
 732   std::string mHandleVisual;          ///< Image for handle image
 733   std::string mProgressVisual;        ///< Image for progress bar image
 734
 735   Property::Map mPopupMap;         ///< the Property::Map if the image came from a Property::Map, empty otherwise
 736   Property::Map mTrackMap;         ///< the Property::Map if the image came from a Property::Map, empty otherwise
 737   Property::Map mHandleMap;        ///< the Property::Map if the image came from a Property::Map, empty otherwise
 738   Property::Map mProgressMap;      ///< the Property::Map if the image came from a Property::Map, empty otherwise
 739   Property::Map mPopupArrowMap;    ///< the Property::Map if the image came from a Property::Map, empty otherwise
 740
 741   Vector4 mDisabledColor;    ///< The color to tint the slider when disabled
 742
 743   Vector2 mHitRegion;     ///< Size of hit region
 744   Vector2 mTrackRegion;   ///< Size of track region
 745   Vector2 mHandleSize;    ///< Size of the handle
 746
 747   float mLowerBound;        ///< Lower bound on value
 748   float mUpperBound;        ///< Upper bound on value
 749   float mValue;             ///< Current value of slider
 750
 751   float mMarkTolerance;     ///< Tolerance in percentage of slider width for which to snap to marks
 752
 753   int mValuePrecision;      ///< The precision to use for outputting the value
 754
 755   bool mShowPopup   : 1,      ///< Show the popup or not
 756        mShowValue   : 1,      ///< Whether to display the value number or not on the handle
 757        mSnapToMarks : 1;      ///< Turn on or off snapping to marks
 758 };
 759
 760 } // namespace Internal
 761
 762 // Helpers for public-api forwarding methods
 763
 764 inline Toolkit::Internal::Slider& GetImpl( Toolkit::Slider& pub )
 765 {
 766   DALI_ASSERT_ALWAYS( pub );
 767
 768   Dali::RefObject& handle = pub.GetImplementation();
 769
 770   return static_cast< Toolkit::Internal::Slider& >( handle );
 771 }
 772
 773 inline const Toolkit::Internal::Slider& GetImpl( const Toolkit::Slider& pub )
 774 {
 775   DALI_ASSERT_ALWAYS( pub );
 776
 777   const Dali::RefObject& handle = pub.GetImplementation();
 778
 779   return static_cast< const Toolkit::Internal::Slider& >( handle );
 780 }
 781
 782 } // namespace Toolkit
 783
 784 } // namespace Dali
 785
 786 #endif // __DALI_TOOLKIT_INTERNAL_SLIDER_H__