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/adaptor-framework/timer.h>
23 #include <dali/public-api/object/property-array.h>
24 #include <dali/public-api/object/property-map.h>
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>
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;
124 * Set the track region
126 * @param[in] region The track region
128 void SetTrackRegion( const Vector2& region );
131 * Get the track region
133 * @return The track region
135 const Vector2& GetTrackRegion() const;
138 * @brief Set the disabled color.
140 * @param[in] color The disabled color.
142 void SetDisabledColor( const Vector4& color );
145 * @brief Get disabled color
147 * @return The disabled color
149 Vector4 GetDisabledColor() const;
152 * Set the value precision to be used for numbers in the slider
154 * @param[in] precision The number of decimal places to use for printing numbers
156 void SetValuePrecision( int precision );
159 * Get value precision
161 * @return The value precision
163 int GetValuePrecision() const;
168 * @param[in] showPopup The show popup flag
170 void SetShowPopup( bool showPopup );
173 * Get show value in popup
175 * @return The show value flag
177 bool GetShowPopup() const;
180 * Set show value on handle
182 * @param[in] showValue The show value flag
184 void SetShowValue( bool showValue );
187 * Get show value on handle
189 * @return The show value flag
191 bool GetShowValue() const;
196 * param[in] enabled Set the enabled flag
198 void SetEnabled( bool enabled );
201 * Return if enabled or not
205 bool IsEnabled() const;
208 * @brief Set the mark tolerance
210 * The tolerance is the percentage of the slider width for which snapping to
213 * @param[in] tolerance The percentage of width for which to snap
215 void SetMarkTolerance( float tolerance );
218 * Return the mark tolerance
220 * @return The tolerance set for snapping to marks
222 float GetMarkTolerance() const;
228 * @copydoc Toolkit::Slider::ValueChangedSignal()
230 Toolkit::Slider::ValueChangedSignalType& ValueChangedSignal();
233 * copydoc Toolkit::Slider::SlidingFinishedSignal()
235 Toolkit::Slider::ValueChangedSignalType& SlidingFinishedSignal();
238 * @copydoc Toolkit::Slider::MarkReachedSignal()
240 Toolkit::Slider::MarkReachedSignalType& MarkReachedSignal();
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.
251 static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName,
252 FunctorDelegate* functor );
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.
262 static void SetProperty( BaseObject* object, Property::Index index, const Property::Value& value );
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.
270 static Property::Value GetProperty( BaseObject* object, Property::Index propertyIndex );
275 * Construct a new Slider.
280 * A reference counted object may only be deleted by calling Unreference()
285 * @copydoc CustomActorImpl::OnSizeSet( const Vector3& size )
287 virtual void OnSizeSet( const Vector3& size );
292 * Domain is a from/to pair
302 Domain( Vector2 fromVal, Vector2 toVal )
303 : from( fromVal ), to( toVal )
322 * @copydoc Toolkit::Control::OnInitialize()
324 virtual void OnInitialize();
329 * @param[in] actor The actor the event is raised for
330 * @param[in] touch The touch info
331 * @return If touch is handled or not
333 bool OnTouch( Actor actor, const TouchData& touch );
338 * @param[in] actor The actor the event is raised for
339 * @param[in] gesture The pan event info
341 void OnPan( Actor actor, const PanGesture& gesture );
344 * Map a position onto a domain and return the result as a percentage
346 * @param[in] point The point to map onto the domain
347 * @return The result as a percentage [0..1]
349 float MapPercentage( const Vector2& point );
352 * Map a value in the range to a percentage
354 * @param[in] point The value in range [lowerBound..upperBound]
355 * @return The result as a percentage [0..1]
357 float MapValuePercentage( float value );
360 * Convert a point in local hit space into domain space
362 * @param[in] x The x position to convert
363 * @return The x position in domain space
365 float HitSpaceToDomain( float x );
368 * Map a percentage onto the slider's bounds
370 * @param[in] percent The current value of slider in percent
371 * @param[in] lowerBound The lower bound to map onto
372 * @param[in] upperBound The upper bound to map onto
373 * @return The value of percent mapped from lowerBound to upperBound
375 float MapBounds( float percent, float lowerBound, float upperBound );
378 * Get the range of the valid values the slider handle can move between
380 * @param[in] currentSize The current size of the slider
381 * @return The range as a domain pair
383 Domain CalcDomain( const Vector2& currentSize );
386 * Create the hit region
388 * @return The hit region actor
390 Actor CreateHitRegion();
393 * Create the track for the slider
395 * @return The track actor
397 Toolkit::ImageView CreateTrack();
400 * Create the progress track for the slider
402 * @return The track actor
404 Toolkit::ImageView CreateProgress();
407 * Create the handle for the slider
409 * @return The created image handle
411 Toolkit::ImageView CreateHandle();
414 * Create the popup arrow
416 * @return The created image handle
418 Toolkit::ImageView CreatePopupArrow();
423 * @return The created image handle
425 Toolkit::ImageView CreatePopup();
428 * Create the textview for the popup
430 * @return The textview created for the popup
432 Toolkit::TextLabel CreatePopupText();
435 * Create the value display for the slider
437 * @return The created root actor of the display
439 Actor CreateValueDisplay();
442 * Set the skin based on the current state
447 * Create all the children
449 void CreateChildren();
462 * Display the popup for a set duration with the given value
464 * @param[in] value The value to display in the popup
466 void DisplayPopup( float value );
469 * If there are marks present, filter the incoming percent based on snapping to any nearby marks
471 * @param[in] value The incoming value on the slider to filter
472 * @return The filtered percentage snapped to any nearby marks
474 float MarkFilter( float value );
477 * If there are marks present, snap the incoming percent to the nearest mark
479 * @param[in] value The incoming value on the slider to snap
480 * @return The filtered percentage snapped to the nearest mark
482 float SnapToMark( float value );
485 * Search for if a mark has been reached
487 * @param[in] value The value to search against
488 * @param[out] outIndex The index of the mark if found
489 * @return If a mark has been found to match percent
491 bool MarkReached( float value, int& outIndex );
494 * Handler for when the value view needs to be hidden
496 * @return If handled or not
498 bool HideValueView();
501 * Set value choosing whether to fire signals or not
503 * @paramp[in] value The value to set
504 * @param[in] raiseSignals Configure signals to be raised or not.
506 void DisplayValue( float value, bool raiseSignals );
509 * Create the image for the track
511 * @param[in] filename The track image
513 void SetTrackVisual( const std::string& filename );
516 * @brief Set the track visual from an Dali::Property::Map
518 * @param[in] map The Dali::Property::Map to use for to display
520 void SetTrackVisual( Dali::Property::Map map );
523 * @brief Return the track image.
525 * @return The track image.
527 std::string GetTrackVisual();
530 * Create the image for the progress bar
532 * @param[in] filename The progress bar image
534 void SetProgressVisual( const std::string& filename );
537 * @brief Set the progress visual from an Dali::Property::Map
539 * @param[in] map The Dali::Property::Map to use for to display
541 void SetProgressVisual( Dali::Property::Map map );
544 * @brief Return the progress bar image.
546 * @return The progress bar image if it exists.
548 std::string GetProgressVisual();
551 * @brief Create the image for the popup
553 * @param[in] filename The popup image
555 void CreatePopupImage( const std::string& filename );
558 * @brief Set the popup image
560 * @param[in] filename The popup image to set
562 void SetPopupVisual( const std::string& filename );
565 * @brief Set the popup from an Dali::Property::Map
567 * @param[in] map The Dali::Property::Map to use for to display
569 void SetPopupVisual( Dali::Property::Map map );
572 * @brief Return the popup image.
574 * @return The popup image if it exists.
576 std::string GetPopupVisual();
579 * @brief Set the popup arrow image
581 * @param[in] filename The popup arrow image to set
583 void SetPopupArrowVisual( const std::string& filename );
586 * @brief Set the popup arrow from an Dali::Property::Map
588 * @param[in] map The Dali::Property::Map to use for to display
590 void SetPopupArrowVisual( Dali::Property::Map map );
593 * @brief Return the popup arrow image.
595 * @return The popup arrow image if it exists.
597 std::string GetPopupArrowVisual();
600 * Create the image for the popup arrow
602 * @param[in] filename The popup arrow image to load and set
604 void CreatePopupArrowImage( const std::string& filename );
607 * Set the size of the progress bar region
609 * @param[in] region The size of the region to set
611 void ResizeProgressRegion( const Vector2& region );
614 * Create the image for the handle
616 * @param[in] filename The handle image
618 void SetHandleVisual( const std::string& filename );
621 * @brief Set the handle visual from an Dali::Property::Map
623 * @param[in] map The Dali::Property::Map to use for to display
625 void SetHandleVisual( Property::Map map );
628 * @brief Return the handle image.
630 * @return The handle image if it exists.
632 std::string GetHandleVisual();
635 * Reset the size of the handle
637 * @param[in] size The size of the handle to set
639 void ResizeHandleSize( const Vector2& size );
642 * Create and display the value on the handle
644 void CreateHandleValueDisplay();
647 * Remove and destroy the handle value display
649 void DestroyHandleValueDisplay();
652 * Set the size of the handle
654 * @param[in] size The handle size
656 void SetHandleSize( const Vector2& size );
659 * Get the size of the handle
661 * @return The handle size
663 const Vector2& GetHandleSize() const;
666 * Set the lower bound of the slider's value
668 * @param[in] bound The value to set for the lower bound
670 void SetLowerBound( float bound );
673 * Get the lower bound of the slider's value
675 * @return The lower bound value
677 float GetLowerBound() const;
680 * Set the upper bound of the slider's value
682 * @param[in] bound The value to set for the upper bound
684 void SetUpperBound( float bound );
687 * Get the upper bound of the slider's value
689 * @return The upper bound value
691 float GetUpperBound() const;
696 Slider( const Slider& );
699 Slider& operator=( const Slider& rhs );
703 Domain mDomain; ///< Current domain of the handle
705 Actor mHitArea; ///< The input handler
706 Actor mValueDisplay; ///< Display of the value
707 Toolkit::ImageView mTrack; ///< Track image
708 Toolkit::ImageView mHandle; ///< Slider handle
709 Toolkit::ImageView mProgress; ///< Progress bar
710 Toolkit::ImageView mPopup; ///< Popup backing
711 Toolkit::ImageView mPopupArrow; ///< Popup arrow backing
713 Toolkit::TextLabel mValueTextLabel; //< The text value in popup
714 Toolkit::TextLabel mHandleValueTextLabel; ///< The text value on handle
715 Vector2 mHandleLastTouchPoint; ///< The last touch point for the handle
716 Timer mValueTimer; ///< Timer used to hide value view
718 Toolkit::Slider::ValueChangedSignalType mValueChangedSignal; ///< Signal emitted when the value is changed
719 Toolkit::Slider::ValueChangedSignalType mSlidingFinishedSignal; ///< Signal emitted when a sliding is finished
720 Toolkit::Slider::MarkReachedSignalType mMarkReachedSignal; ///< Signal emitted when a mark is reached
722 SliderState mState; ///< The state of the slider
724 PanGestureDetector mPanDetector; ///< Hit region pan detector
726 MarkList mMarks; ///< List of discreet marks
728 std::string mPopupVisual; ///< Image for popup image
729 std::string mPopupArrowVisual; ///< Image for popup arrow image
730 std::string mTrackVisual; ///< Image for track image
731 std::string mHandleVisual; ///< Image for handle image
732 std::string mProgressVisual; ///< Image for progress bar image
734 Property::Map mPopupMap; ///< the Property::Map if the image came from a Property::Map, empty otherwise
735 Property::Map mTrackMap; ///< the Property::Map if the image came from a Property::Map, empty otherwise
736 Property::Map mHandleMap; ///< the Property::Map if the image came from a Property::Map, empty otherwise
737 Property::Map mProgressMap; ///< the Property::Map if the image came from a Property::Map, empty otherwise
738 Property::Map mPopupArrowMap; ///< the Property::Map if the image came from a Property::Map, empty otherwise
740 Vector4 mDisabledColor; ///< The color to tint the slider when disabled
742 Vector2 mHitRegion; ///< Size of hit region
743 Vector2 mTrackRegion; ///< Size of track region
744 Vector2 mHandleSize; ///< Size of the handle
746 float mLowerBound; ///< Lower bound on value
747 float mUpperBound; ///< Upper bound on value
748 float mValue; ///< Current value of slider
750 float mMarkTolerance; ///< Tolerance in percentage of slider width for which to snap to marks
752 int mValuePrecision; ///< The precision to use for outputting the value
754 bool mShowPopup : 1, ///< Show the popup or not
755 mShowValue : 1, ///< Whether to display the value number or not on the handle
756 mSnapToMarks : 1; ///< Turn on or off snapping to marks
759 } // namespace Internal
761 // Helpers for public-api forwarding methods
763 inline Toolkit::Internal::Slider& GetImpl( Toolkit::Slider& pub )
765 DALI_ASSERT_ALWAYS( pub );
767 Dali::RefObject& handle = pub.GetImplementation();
769 return static_cast< Toolkit::Internal::Slider& >( handle );
772 inline const Toolkit::Internal::Slider& GetImpl( const Toolkit::Slider& pub )
774 DALI_ASSERT_ALWAYS( pub );
776 const Dali::RefObject& handle = pub.GetImplementation();
778 return static_cast< const Toolkit::Internal::Slider& >( handle );
781 } // namespace Toolkit
785 #endif // __DALI_TOOLKIT_INTERNAL_SLIDER_H__