X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Fbuttons%2Fbutton-impl.cpp;h=b84792559d7411190fecbc9e61097732cac1e9cc;hp=2cb3d72378fc3d6bfcab7b7b81877bccc07e694a;hb=928136dbb9e23970f3894eabc7c8b224003b77be;hpb=57869973578f6a0b0f836d396c7232ddb8302c6b diff --git a/dali-toolkit/internal/controls/buttons/button-impl.cpp b/dali-toolkit/internal/controls/buttons/button-impl.cpp index 2cb3d72..b847925 100644 --- a/dali-toolkit/internal/controls/buttons/button-impl.cpp +++ b/dali-toolkit/internal/controls/buttons/button-impl.cpp @@ -21,6 +21,10 @@ // EXTERNAL INCLUDES #include #include +#include +#include + +// INTERNAL INCLUDES namespace Dali { @@ -33,7 +37,7 @@ const Property::Index Button::PROPERTY_AUTO_REPEATING = Internal:: const Property::Index Button::PROPERTY_INITIAL_AUTO_REPEATING_DELAY = Internal::Button::BUTTON_PROPERTY_START_INDEX + 2; const Property::Index Button::PROPERTY_NEXT_AUTO_REPEATING_DELAY = Internal::Button::BUTTON_PROPERTY_START_INDEX + 3; const Property::Index Button::PROPERTY_TOGGLABLE = Internal::Button::BUTTON_PROPERTY_START_INDEX + 4; -const Property::Index Button::PROPERTY_TOGGLED = Internal::Button::BUTTON_PROPERTY_START_INDEX + 5; +const Property::Index Button::PROPERTY_SELECTED = Internal::Button::BUTTON_PROPERTY_START_INDEX + 5; const Property::Index Button::PROPERTY_NORMAL_STATE_ACTOR = Internal::Button::BUTTON_PROPERTY_START_INDEX + 6; const Property::Index Button::PROPERTY_SELECTED_STATE_ACTOR = Internal::Button::BUTTON_PROPERTY_START_INDEX + 7; const Property::Index Button::PROPERTY_DISABLED_STATE_ACTOR = Internal::Button::BUTTON_PROPERTY_START_INDEX + 8; @@ -45,23 +49,41 @@ namespace Internal namespace { +const unsigned int INITIAL_AUTOREPEATING_DELAY( 0.15f ); +const unsigned int NEXT_AUTOREPEATING_DELAY( 0.05f ); + +// Signals + +const char* const SIGNAL_PRESSED = "pressed"; +const char* const SIGNAL_RELEASED = "released"; +const char* const SIGNAL_CLICKED = "clicked"; +const char* const SIGNAL_STATE_CHANGED = "state-changed"; + +// Actions + +const char* const ACTION_BUTTON_CLICK = "button-click"; + BaseHandle Create() { // empty handle as we cannot create button (but type registered for clicked signal) return BaseHandle(); } -TypeRegistration typeRegistration( typeid(Toolkit::Button), typeid(Toolkit::Control), Create ); +TypeRegistration typeRegistration( typeid( Toolkit::Button ), typeid( Toolkit::Control ), Create ); + +SignalConnectorType signalConnector1( typeRegistration, SIGNAL_PRESSED , &Button::DoConnectSignal ); +SignalConnectorType signalConnector2( typeRegistration, SIGNAL_RELEASED, &Button::DoConnectSignal ); +SignalConnectorType signalConnector3( typeRegistration, SIGNAL_CLICKED, &Button::DoConnectSignal ); +SignalConnectorType signalConnector4( typeRegistration, SIGNAL_STATE_CHANGED, &Button::DoConnectSignal ); -SignalConnectorType signalConnector1( typeRegistration, Toolkit::Button::SIGNAL_CLICKED, &Button::DoConnectSignal ); -SignalConnectorType signalConnector2( typeRegistration, Toolkit::Button::SIGNAL_STATE_CHANGED, &Button::DoConnectSignal ); +TypeAction action1( typeRegistration, ACTION_BUTTON_CLICK, &Button::DoAction ); PropertyRegistration property1( typeRegistration, "disabled", Toolkit::Button::PROPERTY_DISABLED, Property::BOOLEAN, &Button::SetProperty, &Button::GetProperty ); PropertyRegistration property2( typeRegistration, "auto-repeating", Toolkit::Button::PROPERTY_AUTO_REPEATING, Property::BOOLEAN, &Button::SetProperty, &Button::GetProperty ); PropertyRegistration property3( typeRegistration, "initial-auto-repeating-delay", Toolkit::Button::PROPERTY_INITIAL_AUTO_REPEATING_DELAY, Property::FLOAT, &Button::SetProperty, &Button::GetProperty ); PropertyRegistration property4( typeRegistration, "next-auto-repeating-delay", Toolkit::Button::PROPERTY_NEXT_AUTO_REPEATING_DELAY, Property::FLOAT, &Button::SetProperty, &Button::GetProperty ); PropertyRegistration property5( typeRegistration, "togglable", Toolkit::Button::PROPERTY_TOGGLABLE, Property::BOOLEAN, &Button::SetProperty, &Button::GetProperty ); -PropertyRegistration property6( typeRegistration, "toggled", Toolkit::Button::PROPERTY_TOGGLED, Property::BOOLEAN, &Button::SetProperty, &Button::GetProperty ); +PropertyRegistration property6( typeRegistration, "selected", Toolkit::Button::PROPERTY_SELECTED, Property::BOOLEAN, &Button::SetProperty, &Button::GetProperty ); PropertyRegistration property7( typeRegistration, "normal-state-actor", Toolkit::Button::PROPERTY_NORMAL_STATE_ACTOR, Property::MAP, &Button::SetProperty, &Button::GetProperty ); PropertyRegistration property8( typeRegistration, "selected-state-actor", Toolkit::Button::PROPERTY_SELECTED_STATE_ACTOR, Property::MAP, &Button::SetProperty, &Button::GetProperty ); PropertyRegistration property9( typeRegistration, "disabled-state-actor", Toolkit::Button::PROPERTY_DISABLED_STATE_ACTOR, Property::MAP, &Button::SetProperty, &Button::GetProperty ); @@ -71,25 +93,34 @@ PropertyRegistration property10( typeRegistration, "label-actor", Button::Button() : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ), - mPainter( NULL ), - mState( ButtonUp ), - mDisabled( false ) + mAutoRepeatingTimer(), + mDisabled( false ), + mAutoRepeating( false ), + mTogglableButton( false ), + mSelected( false ), + mInitialAutoRepeatingDelay( INITIAL_AUTOREPEATING_DELAY ), + mNextAutoRepeatingDelay( NEXT_AUTOREPEATING_DELAY ), + mAnimationTime( 0.0f ), + mClickActionPerforming( false ), + mState( ButtonUp ) { } Button::~Button() { + if( mAutoRepeatingTimer ) + { + mAutoRepeatingTimer.Reset(); + } } void Button::SetDisabled( bool disabled ) { - mDisabled = disabled; - - // Notifies the painter. - Toolkit::Button handle( GetOwner() ); - if( mPainter ) + if( disabled != mDisabled ) { - mPainter->SetDisabled( handle, mDisabled ); + mDisabled = disabled; + + OnDisabled( mDisabled ); } } @@ -98,42 +129,336 @@ bool Button::IsDisabled() const return mDisabled; } +void Button::SetAutoRepeating( bool autoRepeating ) +{ + mAutoRepeating = autoRepeating; + + // An autorepeating button can't be a togglable button. + if( autoRepeating ) + { + mTogglableButton = false; + + if( mSelected ) + { + // Emit a signal is not wanted, only change the appearance. + OnSelected( false ); + + mSelected = false; + + RelayoutRequest(); + } + } +} + +bool Button::IsAutoRepeating() const +{ + return mAutoRepeating; +} + +void Button::SetInitialAutoRepeatingDelay( float initialAutoRepeatingDelay ) +{ + DALI_ASSERT_ALWAYS( initialAutoRepeatingDelay > 0.f ); + mInitialAutoRepeatingDelay = initialAutoRepeatingDelay; +} + +float Button::GetInitialAutoRepeatingDelay() const +{ + return mInitialAutoRepeatingDelay; +} + +void Button::SetNextAutoRepeatingDelay( float nextAutoRepeatingDelay ) +{ + DALI_ASSERT_ALWAYS( nextAutoRepeatingDelay > 0.f ); + mNextAutoRepeatingDelay = nextAutoRepeatingDelay; +} + +float Button::GetNextAutoRepeatingDelay() const +{ + return mNextAutoRepeatingDelay; +} + +void Button::SetTogglableButton( bool togglable ) +{ + mTogglableButton = togglable; + + // A togglable button can't be an autorepeating button. + if( togglable ) + { + mAutoRepeating = false; + } +} + +bool Button::IsTogglableButton() const +{ + return mTogglableButton; +} + +void Button::SetSelected( bool selected ) +{ + if( !mDisabled && mTogglableButton && ( selected != mSelected ) ) + { + // Notifies the derived class the button has been selected. + OnSelected( selected ); + + mSelected = selected; + + Toolkit::Button handle( GetOwner() ); + + // Emit signal. + mStateChangedSignal.Emit( handle ); + + RelayoutRequest(); + } +} + +bool Button::IsSelected() const +{ + return mTogglableButton && mSelected; +} + void Button::SetAnimationTime( float animationTime ) { - OnAnimationTimeSet( animationTime ); + mAnimationTime = animationTime; } float Button::GetAnimationTime() const { - return OnAnimationTimeRequested(); + return mAnimationTime; } -void Button::OnAnimationTimeSet( float animationTime ) +void Button::SetLabel( const std::string& label ) { - // nothing to do. +} + +void Button::SetLabel( Actor label ) +{ + if( mLabel != label ) + { + if( mLabel && mLabel.GetParent() ) + { + mLabel.GetParent().Remove( mLabel ); + } + + mLabel = label; + + OnLabelSet(); + + RelayoutRequest(); + } +} + +Actor Button::GetLabel() const +{ + return mLabel; +} + +Actor& Button::GetLabel() +{ + return mLabel; +} + +Actor Button::GetButtonImage() const +{ + return mButtonContent; +} + +Actor& Button::GetButtonImage() +{ + return mButtonContent; +} + +Actor Button::GetSelectedImage() const +{ + return mSelectedContent; +} + +Actor& Button::GetSelectedImage() +{ + return mSelectedContent; +} + +Actor Button::GetBackgroundImage() const +{ + return mBackgroundContent; +} + +Actor& Button::GetBackgroundImage() +{ + return mBackgroundContent; +} + +Actor Button::GetDisabledImage() const +{ + return mDisabledContent; +} + +Actor& Button::GetDisabledImage() +{ + return mDisabledContent; +} + +Actor Button::GetDisabledSelectedImage() const +{ + return mDisabledSelectedContent; +} + +Actor& Button::GetDisabledSelectedImage() +{ + return mDisabledSelectedContent; +} + +Actor Button::GetDisabledBackgroundImage() const +{ + return mDisabledBackgroundContent; +} + +Actor& Button::GetDisabledBackgroundImage() +{ + return mDisabledBackgroundContent; +} + +bool Button::DoAction( BaseObject* object, const std::string& actionName, const PropertyValueContainer& attributes ) +{ + bool ret = false; + + Dali::BaseHandle handle( object ); + + Toolkit::Button button = Toolkit::Button::DownCast( handle ); + + DALI_ASSERT_ALWAYS( button ); + + if( 0 == strcmp( actionName.c_str(), ACTION_BUTTON_CLICK ) ) + { + GetImplementation( button ).DoClickAction( attributes ); + ret = true; + } + + return ret; +} + +void Button::DoClickAction( const PropertyValueContainer& attributes ) +{ + // Prevents the button signals from doing a recursive loop by sending an action + // and re-emitting the signals. + if( !mClickActionPerforming ) + { + mClickActionPerforming = true; + OnButtonDown(); + mState = ButtonDown; + OnButtonUp(); + mClickActionPerforming = false; + } +} + +void Button::OnButtonStageDisconnection() +{ + if( ButtonDown == mState ) + { + if( !mTogglableButton ) + { + Toolkit::Button handle( GetOwner() ); + + // Notifies the derived class the button has been released. + OnReleased(); + + if( mAutoRepeating ) + { + mAutoRepeatingTimer.Reset(); + } + } + } } void Button::OnButtonDown() { + if( !mTogglableButton ) + { + Toolkit::Button handle( GetOwner() ); + + // Notifies the derived class the button has been pressed. + OnPressed(); + if( mAutoRepeating ) + { + SetUpTimer( mInitialAutoRepeatingDelay ); + } + + //Emit signal. + mPressedSignal.Emit( handle ); + } } void Button::OnButtonUp() { + if( ButtonDown == mState ) + { + if( mTogglableButton ) + { + SetSelected( !mSelected ); + } + else + { + // Notifies the derived class the button has been clicked. + OnReleased(); + OnClicked(); + + if( mAutoRepeating ) + { + mAutoRepeatingTimer.Reset(); + } + + Toolkit::Button handle( GetOwner() ); + //Emit signal. + mReleasedSignal.Emit( handle ); + mClickedSignal.Emit( handle ); + } + } } -float Button::OnAnimationTimeRequested() const +void Button::OnTouchPointLeave() { - return 0.f; + if( ButtonDown == mState ) + { + if( !mTogglableButton ) + { + Toolkit::Button handle( GetOwner() ); + + // Notifies the derived class the button has been released. + OnReleased(); + + if( mAutoRepeating ) + { + mAutoRepeatingTimer.Reset(); + } + + //Emit signal. + mReleasedSignal.Emit( handle ); + } + } } -Toolkit::Button::ClickedSignalType& Button::ClickedSignal() +void Button::OnTouchPointInterrupted() +{ + OnTouchPointLeave(); +} + +Toolkit::Button::ButtonSignalType& Button::PressedSignal() +{ + return mPressedSignal; +} + +Toolkit::Button::ButtonSignalType& Button::ReleasedSignal() +{ + return mReleasedSignal; +} + +Toolkit::Button::ButtonSignalType& Button::ClickedSignal() { return mClickedSignal; } -Toolkit::Button::StateChangedSignalType& Button::StateChangedSignal() +Toolkit::Button::ButtonSignalType& Button::StateChangedSignal() { return mStateChangedSignal; } @@ -143,13 +468,21 @@ bool Button::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tr Dali::BaseHandle handle( object ); bool connected( true ); - Toolkit::Button button = Toolkit::Button::DownCast(handle); + Toolkit::Button button = Toolkit::Button::DownCast( handle ); - if( Dali::Toolkit::Button::SIGNAL_CLICKED == signalName ) + if( 0 == strcmp( signalName.c_str(), SIGNAL_PRESSED ) ) + { + button.PressedSignal().Connect( tracker, functor ); + } + else if( 0 == strcmp( signalName.c_str(), SIGNAL_RELEASED ) ) + { + button.ReleasedSignal().Connect( tracker, functor ); + } + else if( 0 == strcmp( signalName.c_str(), SIGNAL_CLICKED ) ) { button.ClickedSignal().Connect( tracker, functor ); } - else if( Dali::Toolkit::Button::SIGNAL_STATE_CHANGED == signalName ) + else if( 0 == strcmp( signalName.c_str(), SIGNAL_STATE_CHANGED ) ) { button.StateChangedSignal().Connect( tracker, functor ); } @@ -228,13 +561,6 @@ bool Button::OnTouchEvent(const TouchEvent& event) void Button::OnInitialize() { - // Initialize the painter and notifies subclasses. - Toolkit::Button handle( GetOwner() ); - if( mPainter ) - { - mPainter->Initialize( handle ); - } - Actor self = Self(); mTapDetector = TapGestureDetector::New(); @@ -246,13 +572,11 @@ void Button::OnInitialize() self.SetKeyboardFocusable( true ); } -void Button::OnControlSizeSet(const Vector3& targetSize) +void Button::OnActivated() { - Toolkit::Button handle( GetOwner() ); - if( mPainter ) - { - mPainter->SetSize( handle, targetSize ); - } + // When the button is activated, it performs the click action + PropertyValueContainer attributes; + DoClickAction( attributes ); } void Button::OnTap(Actor actor, const TapGesture& tap) @@ -260,32 +584,198 @@ void Button::OnTap(Actor actor, const TapGesture& tap) // Do nothing. } +void Button::SetUpTimer( float delay ) +{ + mAutoRepeatingTimer = Dali::Timer::New( static_cast( 1000.f * delay ) ); + mAutoRepeatingTimer.TickSignal().Connect( this, &Button::AutoRepeatingSlot ); + mAutoRepeatingTimer.Start(); +} + +bool Button::AutoRepeatingSlot() +{ + bool consumed = false; + if( !mDisabled ) + { + // Restart the autorepeat timer. + SetUpTimer( mNextAutoRepeatingDelay ); + + Toolkit::Button handle( GetOwner() ); + + // Notifies the derived class the button has been pressed. + OnPressed(); + + //Emit signal. + consumed = mReleasedSignal.Emit( handle ); + consumed |= mClickedSignal.Emit( handle ); + consumed |= mPressedSignal.Emit( handle ); + } + + return consumed; +} + void Button::OnControlStageDisconnection() { OnButtonStageDisconnection(); // Notification for derived classes. mState = ButtonUp; } +Button::ButtonState Button::GetState() +{ + return mState; +} + void Button::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value ) { Toolkit::Button button = Toolkit::Button::DownCast( Dali::BaseHandle( object ) ); - if ( button && ( index == Toolkit::Button::PROPERTY_DISABLED ) ) + if ( button ) { - GetImplementation( button ).SetDisabled( value.Get() ); + switch ( index ) + { + case Toolkit::Button::PROPERTY_DISABLED: + { + GetImplementation( button ).SetDisabled( value.Get() ); + break; + } + + case Toolkit::Button::PROPERTY_AUTO_REPEATING: + { + GetImplementation( button ).SetAutoRepeating( value.Get< bool >() ); + break; + } + + case Toolkit::Button::PROPERTY_INITIAL_AUTO_REPEATING_DELAY: + { + GetImplementation( button ).SetInitialAutoRepeatingDelay( value.Get< float >() ); + break; + } + + case Toolkit::Button::PROPERTY_NEXT_AUTO_REPEATING_DELAY: + { + GetImplementation( button ).SetNextAutoRepeatingDelay( value.Get< float >() ); + break; + } + + case Toolkit::Button::PROPERTY_TOGGLABLE: + { + GetImplementation( button ).SetTogglableButton( value.Get< bool >() ); + break; + } + + case Toolkit::Button::PROPERTY_SELECTED: + { + GetImplementation( button ).SetSelected( value.Get< bool >() ); + break; + } + + case Toolkit::Button::PROPERTY_NORMAL_STATE_ACTOR: + { + GetImplementation( button ).SetButtonImage( Scripting::NewActor( value.Get< Property::Map >() ) ); + break; + } + + case Toolkit::Button::PROPERTY_SELECTED_STATE_ACTOR: + { + GetImplementation( button ).SetSelectedImage( Scripting::NewActor( value.Get< Property::Map >() ) ); + break; + } + + case Toolkit::Button::PROPERTY_DISABLED_STATE_ACTOR: + { + GetImplementation( button ).SetDisabledImage( Scripting::NewActor( value.Get< Property::Map >() ) ); + break; + } + + case Toolkit::Button::PROPERTY_LABEL_ACTOR: + { + GetImplementation( button ).SetLabel( Scripting::NewActor( value.Get< Property::Map >() ) ); + break; + } + } } } Property::Value Button::GetProperty( BaseObject* object, Property::Index propertyIndex ) { + Property::Value value; + Toolkit::Button button = Toolkit::Button::DownCast( Dali::BaseHandle( object ) ); - if ( button && ( propertyIndex == Toolkit::Button::PROPERTY_DISABLED ) ) + if ( button ) { - return Property::Value( GetImplementation( button ).mDisabled ); + switch ( propertyIndex ) + { + case Toolkit::Button::PROPERTY_DISABLED: + { + value = GetImplementation( button ).mDisabled; + break; + } + + case Toolkit::Button::PROPERTY_AUTO_REPEATING: + { + value = GetImplementation( button ).mAutoRepeating; + break; + } + + case Toolkit::Button::PROPERTY_INITIAL_AUTO_REPEATING_DELAY: + { + value = GetImplementation( button ).mInitialAutoRepeatingDelay; + break; + } + + case Toolkit::Button::PROPERTY_NEXT_AUTO_REPEATING_DELAY: + { + value = GetImplementation( button ).mNextAutoRepeatingDelay; + break; + } + + case Toolkit::Button::PROPERTY_TOGGLABLE: + { + value = GetImplementation( button ).mTogglableButton; + break; + } + + case Toolkit::Button::PROPERTY_SELECTED: + { + value = GetImplementation( button ).mSelected; + break; + } + + case Toolkit::Button::PROPERTY_NORMAL_STATE_ACTOR: + { + Property::Map map; + Scripting::CreatePropertyMap( GetImplementation( button ).mButtonContent, map ); + value = map; + break; + } + + case Toolkit::Button::PROPERTY_SELECTED_STATE_ACTOR: + { + Property::Map map; + Scripting::CreatePropertyMap( GetImplementation( button ).mSelectedContent, map ); + value = map; + break; + } + + case Toolkit::Button::PROPERTY_DISABLED_STATE_ACTOR: + { + Property::Map map; + Scripting::CreatePropertyMap( GetImplementation( button ).mDisabledContent, map ); + value = map; + break; + } + + case Toolkit::Button::PROPERTY_LABEL_ACTOR: + { + Property::Map map; + Scripting::CreatePropertyMap( GetImplementation( button ).mLabel, map ); + value = map; + break; + } + } } - return Property::Value(); + return value; } } // namespace Internal