1 #ifndef __DALI_TOOLKIT_INTERNAL_SLIDER_H__
2 #define __DALI_TOOLKIT_INTERNAL_SLIDER_H__
5 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 #include <dali/public-api/actors/image-actor.h>
23 #include <dali/public-api/adaptor-framework/timer.h>
24 #include <dali/public-api/object/property-array.h>
27 #include <dali-toolkit/public-api/controls/control-impl.h>
28 #include <dali-toolkit/devel-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>
45 typedef Dali::IntrusivePtr< Slider > SliderPtr;
48 * @copydoc Toolkit::Slider
50 class Slider : public Control
54 typedef Property::Array MarkList;
57 * Create a new Slider.
59 * @return A public handle to the newly allocated Slider.
61 static Dali::Toolkit::Slider New();
68 * Set marks from a list
70 * @param[in] marks The list of marks to set
72 void SetMarks( const MarkList& marks );
75 * Get the list of marks
77 * @return The marks list
79 const MarkList& GetMarks() const;
82 * Set if should snap to marks or not
84 * @param[in] snap Flag to snap to marks or not
86 void SetSnapToMarks( bool snap );
89 * Return if snap to marks is set or not
91 * @return If snap to marks is set
93 bool GetSnapToMarks() const;
96 * Set the value of the slider
98 * @param[in] value The value to set. Will be clamped to [lowerBound .. upperBound]
100 void SetValue( float value );
103 * Get the value of the slider
105 * @return The current value of the slider
107 float GetValue() const;
112 * @param[in] region The hit region
114 void SetHitRegion( const Vector2& region );
119 * @return The hit region
121 const Vector2& GetHitRegion() const;
126 * @param[in] region The backing region
128 void SetBackingRegion( const Vector2& region );
133 * @return The backing region
135 const Vector2& GetBackingRegion() const;
138 * @brief Set the disable color.
140 * @param[in] color The disable color.
142 void SetDisableColor( const Vector4& color );
145 * @brief Get disable color
147 * @return The disable color
149 Vector4 GetDisableColor() const;
152 * Get popup text color
154 * @return The popup text color
156 Vector4 GetPopupTextColor() const;
159 * Set the value precision to be used for numbers in the slider
161 * @param[in] precision The number of decimal places to use for printing numbers
163 void SetValuePrecision( int precision );
166 * Get value precision
168 * @return The value precision
170 int GetValuePrecision() const;
175 * @param[in] showPopup The show popup flag
177 void SetShowPopup( bool showPopup );
180 * Get show value in popup
182 * @return The show value flag
184 bool GetShowPopup() const;
187 * Set show value on handle
189 * @param[in] showValue The show value flag
191 void SetShowValue( bool showValue );
194 * Get show value on handle
196 * @return The show value flag
198 bool GetShowValue() const;
203 * param[in] enabled Set the enabled flag
205 void SetEnabled( bool enabled );
208 * Return if enabled or not
212 bool IsEnabled() const;
215 * @brief Set the mark tolerance
217 * The tolerance is the percentage of the slider width for which snapping to
220 * @param[in] tolerance The percentage of width for which to snap
222 void SetMarkTolerance( float tolerance );
225 * Return the mark tolerance
227 * @return The tolerance set for snapping to marks
229 float GetMarkTolerance() const;
235 * @copydoc Toolkit::Slider::ValueChangedSignal()
237 Toolkit::Slider::ValueChangedSignalType& ValueChangedSignal();
240 * copydoc Toolkit::Slider::SlidingFinishedSignal()
242 Toolkit::Slider::ValueChangedSignalType& SlidingFinishedSignal();
245 * @copydoc Toolkit::Slider::MarkSignal()
247 Toolkit::Slider::MarkSignalType& MarkSignal();
250 * Connects a callback function with the object's signals.
251 * @param[in] object The object providing the signal.
252 * @param[in] tracker Used to disconnect the signal.
253 * @param[in] signalName The signal to connect to.
254 * @param[in] functor A newly allocated FunctorDelegate.
255 * @return True if the signal was connected.
256 * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
258 static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName,
259 FunctorDelegate* functor );
264 * Called when a property of an object of this type is set.
265 * @param[in] object The object whose property is set.
266 * @param[in] index The property index.
267 * @param[in] value The new property value.
269 static void SetProperty( BaseObject* object, Property::Index index, const Property::Value& value );
272 * Called to retrieve a property of an object of this type.
273 * @param[in] object The object whose property is to be retrieved.
274 * @param[in] index The property index.
275 * @return The current value of the property.
277 static Property::Value GetProperty( BaseObject* object, Property::Index propertyIndex );
282 * Construct a new Slider.
287 * A reference counted object may only be deleted by calling Unreference()
292 * @copydoc CustomActorImpl::OnSizeSet( const Vector3& size )
294 virtual void OnSizeSet( const Vector3& size );
299 * Domain is a from/to pair
309 Domain( Vector2 fromVal, Vector2 toVal )
310 : from( fromVal ), to( toVal )
329 * @copydoc Toolkit::Control::OnInitialize()
331 virtual void OnInitialize();
334 * Hit region touch event
336 * @param[in] actor The actor the event is raised for
337 * @param[in] event The touch event info
338 * @return If the event is handled or not
340 bool OnTouchEvent( Actor actor, const TouchEvent& event );
345 * @param[in] actor The actor the event is raised for
346 * @param[in] gesture The pan event info
348 void OnPan( Actor actor, const PanGesture& gesture );
351 * Map a position onto a domain and return the result as a percentage
353 * @param[in] point The point to map onto the domain
354 * @return The result as a percentage [0..1]
356 float MapPercentage( const Vector2& point );
359 * Map a value in the range to a percentage
361 * @param[in] point The value in range [lowerBound..upperBound]
362 * @return The result as a percentage [0..1]
364 float MapValuePercentage( float value );
367 * Convert a point in local hit space into domain space
369 * @param[in] x The x position to convert
370 * @return The x position in domain space
372 float HitSpaceToDomain( float x );
375 * Map a percentage onto the slider's bounds
377 * @param[in] percent The current value of slider in percent
378 * @param[in] lowerBound The lower bound to map onto
379 * @param[in] upperBound The upper bound to map onto
380 * @return The value of percent mapped from lowerBound to upperBound
382 float MapBounds( float percent, float lowerBound, float upperBound );
385 * Get the range of the valid values the slider handle can move between
387 * @param[in] currentSize The current size of the slider
388 * @return The range as a domain pair
390 Domain CalcDomain( const Vector2& currentSize );
393 * Create the hit region
395 * @return The hit region actor
397 Actor CreateHitRegion();
400 * Create the backing for the slider
402 * @return The backing actor
404 Toolkit::ImageView CreateBacking();
407 * Create the progress backing for the slider
409 * @return The backing actor
411 Toolkit::ImageView CreateProgress();
414 * Create the handle for the slider
416 * @return The created image handle
418 Toolkit::ImageView CreateHandle();
421 * Create the popup arrow
423 * @return The created image handle
425 Toolkit::ImageView CreatePopupArrow();
430 * @return The created image handle
432 Toolkit::ImageView CreatePopup();
435 * Create the textview for the popup
437 * @return The textview created for the popup
439 Toolkit::TextLabel CreatePopupText();
442 * Create the value display for the slider
444 * @return The created root actor of the display
446 Actor CreateValueDisplay();
449 * Set the skin based on the current state
454 * Create all the children
456 void CreateChildren();
469 * Display the popup for a set duration with the given value
471 * @param[in] value The value to display in the popup
473 void DisplayPopup( float value );
476 * If there are marks present, filter the incoming percent based on snapping to any nearby marks
478 * @param[in] value The incoming value on the slider to filter
479 * @return The filtered percentage snapped to any nearby marks
481 float MarkFilter( float value );
484 * If there are marks present, snap the incoming percent to the nearest mark
486 * @param[in] value The incoming value on the slider to snap
487 * @return The filtered percentage snapped to the nearest mark
489 float SnapToMark( float value );
492 * Search for if a mark has been reached
494 * @param[in] value The value to search against
495 * @param[out] outIndex The index of the mark if found
496 * @return If a mark has been found to match percent
498 bool MarkReached( float value, int& outIndex );
501 * Handler for when the value view needs to be hidden
503 * @return If handled or not
505 bool HideValueView();
508 * Set value choosing whether to fire signals or not
510 * @paramp[in] value The value to set
511 * @param[in] raiseSignals Configure signals to be raised or not.
513 void DisplayValue( float value, bool raiseSignals );
516 * Create the image for the backing
518 * @param[in] imageName The name of the image to load and set
520 void SetBackingImageName( const std::string& imageName );
523 * @brief Return the backing image file name.
525 * @return The backing image file name.
527 std::string GetBackingImageName();
530 * Create the image for the progress bar
532 * @param[in] imageName The name of the image to load and set
534 void SetProgressImageName( const std::string& imageName );
537 * @brief Return the progress image name.
539 * @return The progress image name if it exists.
541 std::string GetProgressImageName();
544 * @brief Create the image for the popup
546 * @param[in] imageName The name of the image to load and set
548 void CreatePopupImage( const std::string& imageName );
551 * @brief Set the popup name
553 * @param[in] imageName The name of the image to set
555 void SetPopupImageName( const std::string& imageName );
558 * @brief Return the popup image name.
560 * @return The name of the popup image if it exists.
562 std::string GetPopupImageName();
565 * @brief Set the popup arrow image name
567 * @param[in] imageName The name of the image to set
569 void SetPopupArrowImageName( const std::string& imageName );
572 * @brief Return the popup arrow image name.
574 * @return The name of the popup image if it exists.
576 std::string GetPopupArrowImageName();
579 * Create the image for the popup arrow
581 * @param[in] imageName The name of the image to load and set
583 void CreatePopupArrowImage( const std::string& imageName );
586 * Set the size of the progress bar region
588 * @param[in] region The size of the region to set
590 void ResizeProgressRegion( const Vector2& region );
593 * Create the image for the handle
595 * @param[in] imageName The name of the image to load and set
597 void SetHandleImageName( const std::string& imageName );
600 * @brief Return the handle image name.
602 * @return The name of the image handle if it exists.
604 std::string GetHandleImageName();
607 * Set the size of the handle region
609 * @param[in] region The size of the region to set
611 void ResizeHandleRegion( const Vector2& region );
614 * Create and display the value on the handle
616 void CreateHandleValueDisplay();
619 * Remove and destroy the handle value display
621 void DestroyHandleValueDisplay();
624 * Update the color of the popup text
626 * @param[in] color The new color
628 void SetPopupTextColor( const Vector4& color );
633 * @param[in] region The handle region
635 void SetHandleRegion( const Vector2& region );
640 * @return The handle region
642 const Vector2& GetHandleRegion() const;
645 * Set the lower bound of the slider's value
647 * @param[in] bound The value to set for the lower bound
649 void SetLowerBound( float bound );
652 * Get the lower bound of the slider's value
654 * @return The lower bound value
656 float GetLowerBound() const;
659 * Set the upper bound of the slider's value
661 * @param[in] bound The value to set for the upper bound
663 void SetUpperBound( float bound );
666 * Get the upper bound of the slider's value
668 * @return The upper bound value
670 float GetUpperBound() const;
675 Slider( const Slider& );
678 Slider& operator=( const Slider& rhs );
682 Domain mDomain; ///< Current domain of the handle
684 Actor mHitArea; ///< The input handler
685 Actor mValueDisplay; ///< Display of the value
686 Toolkit::ImageView mBacking; ///< Backing image
687 Toolkit::ImageView mHandle; ///< Slider handle
688 Toolkit::ImageView mProgress; ///< Progress backing
689 Toolkit::ImageView mPopup; ///< Popup backing
690 Toolkit::ImageView mPopupArrow; ///< Popup arrow backing
692 Toolkit::TextLabel mValueTextLabel; //< The text value in popup
693 Toolkit::TextLabel mHandleValueTextLabel; ///< The text value on handle
694 Vector2 mHandleLastTouchPoint; ///< The last touch point for the handle
695 Timer mValueTimer; ///< Timer used to hide value view
697 Toolkit::Slider::ValueChangedSignalType mValueChangedSignal; ///< Signal emitted when the value is changed
698 Toolkit::Slider::ValueChangedSignalType mSlidingFinishedSignal; ///< Signal emitted when a sliding is finished
699 Toolkit::Slider::MarkSignalType mMarkSignal; ///< Signal emitted when a mark is reached
701 SliderState mState; ///< The state of the slider
703 PanGestureDetector mPanDetector; ///< Hit region pan detector
705 MarkList mMarks; ///< List of discreet marks
707 std::string mPopupImageName; ///< Image name for popup image
708 std::string mPopupArrowImageName; ///< Image name for popup arrow
709 std::string mBackingImageName; ///< Image name for backing image
710 std::string mHandleImageName; ///< Image name for handle image
711 std::string mProgressImageName; ///< Image name for progress image
713 Vector4 mDisableColor; ///< The color to tint the slider when disabled
714 Vector4 mPopupTextColor; ///< The color of the popup text
716 Vector2 mHitRegion; ///< Size of hit region
717 Vector2 mBackingRegion; ///< Size of backing region
718 Vector2 mHandleRegionSize; ///< Size of the handle region
720 float mLowerBound; ///< Lower bound on value
721 float mUpperBound; ///< Upper bound on value
722 float mValue; ///< Current value of slider
724 float mMarkTolerance; ///< Tolerance in percentage of slider width for which to snap to marks
726 int mValuePrecision; ///< The precision to use for outputting the value
728 bool mShowPopup : 1, ///< Show the popup or not
729 mShowValue : 1, ///< Whether to display the value number or not on the handle
730 mSnapToMarks : 1; ///< Turn on or off snapping to marks
733 } // namespace Internal
735 // Helpers for public-api forwarding methods
737 inline Toolkit::Internal::Slider& GetImpl( Toolkit::Slider& pub )
739 DALI_ASSERT_ALWAYS( pub );
741 Dali::RefObject& handle = pub.GetImplementation();
743 return static_cast< Toolkit::Internal::Slider& >( handle );
746 inline const Toolkit::Internal::Slider& GetImpl( const Toolkit::Slider& pub )
748 DALI_ASSERT_ALWAYS( pub );
750 const Dali::RefObject& handle = pub.GetImplementation();
752 return static_cast< const Toolkit::Internal::Slider& >( handle );
755 } // namespace Toolkit
759 #endif // __DALI_TOOLKIT_INTERNAL_SLIDER_H__