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=4072f4320dd1473eacc5d66ba7ba060d3b1be196;hp=acf3a5a70363da7a878fa737794b0efc4fbe43cc;hb=efc136204e9a4460a7a2421e673c873e23974a80;hpb=2ec164cd618f93ccafe17b1d0b8ff16401ed4aef diff --git a/dali-toolkit/internal/controls/buttons/button-impl.cpp b/dali-toolkit/internal/controls/buttons/button-impl.cpp index acf3a5a..4072f43 100644 --- a/dali-toolkit/internal/controls/buttons/button-impl.cpp +++ b/dali-toolkit/internal/controls/buttons/button-impl.cpp @@ -19,14 +19,39 @@ #include "button-impl.h" // EXTERNAL INCLUDES +#include // for strcmp #include #include -#include +#include #include -#include +#include // INTERNAL INCLUDES -#include +#include + +/** + * Button states and contents + * (3) mSelectedContent + * (2) mUnselectedContent (2) mSelectedBackgroundContent + * (1) mBackgroundContent (1) mBackgroundContent + * < unselected > ----------------------- < selected > + * | OnSelect() | + * | OnDisabled() | OnDisabled() + * | | + * < disabled > < disabled-selected > + * (2) mDisabledContent (2) mDisabledSelectedContent + * (1) mDisabledBackgroundContent (1) mDisabledBackgroundContent + * + * The drawing order of child actors is as follows. + * + * Top mLabel + * | mUnselectedContent / mSelectedContent / mDisabledContent / mDisabledSelectedContent + * | mSelectedBackgroundContent + * Bottom mBackgroundContent / mDisabledBackgroundContent + * + * Some of contents may be missed. + * And 2 images - fade-in image and fade-out image - in the same layer can be shown during the transition animation. Fade-in image should be above fade-out image. + */ namespace Dali { @@ -49,23 +74,23 @@ BaseHandle Create() // Setup properties, signals and actions using the type-registry. DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Button, Toolkit::Control, Create ); -DALI_PROPERTY_REGISTRATION( Button, "disabled", BOOLEAN, DISABLED ) -DALI_PROPERTY_REGISTRATION( Button, "auto-repeating", BOOLEAN, AUTO_REPEATING ) -DALI_PROPERTY_REGISTRATION( Button, "initial-auto-repeating-delay", FLOAT, INITIAL_AUTO_REPEATING_DELAY ) -DALI_PROPERTY_REGISTRATION( Button, "next-auto-repeating-delay", FLOAT, NEXT_AUTO_REPEATING_DELAY ) -DALI_PROPERTY_REGISTRATION( Button, "togglable", BOOLEAN, TOGGLABLE ) -DALI_PROPERTY_REGISTRATION( Button, "selected", BOOLEAN, SELECTED ) -DALI_PROPERTY_REGISTRATION( Button, "normal-state-actor", MAP, NORMAL_STATE_ACTOR ) -DALI_PROPERTY_REGISTRATION( Button, "selected-state-actor", MAP, SELECTED_STATE_ACTOR ) -DALI_PROPERTY_REGISTRATION( Button, "disabled-state-actor", MAP, DISABLED_STATE_ACTOR ) -DALI_PROPERTY_REGISTRATION( Button, "label-actor", MAP, LABEL_ACTOR ) +DALI_PROPERTY_REGISTRATION( Toolkit, Button, "disabled", BOOLEAN, DISABLED ) +DALI_PROPERTY_REGISTRATION( Toolkit, Button, "auto-repeating", BOOLEAN, AUTO_REPEATING ) +DALI_PROPERTY_REGISTRATION( Toolkit, Button, "initial-auto-repeating-delay", FLOAT, INITIAL_AUTO_REPEATING_DELAY ) +DALI_PROPERTY_REGISTRATION( Toolkit, Button, "next-auto-repeating-delay", FLOAT, NEXT_AUTO_REPEATING_DELAY ) +DALI_PROPERTY_REGISTRATION( Toolkit, Button, "togglable", BOOLEAN, TOGGLABLE ) +DALI_PROPERTY_REGISTRATION( Toolkit, Button, "selected", BOOLEAN, SELECTED ) +DALI_PROPERTY_REGISTRATION( Toolkit, Button, "normal-state-actor", MAP, NORMAL_STATE_ACTOR ) +DALI_PROPERTY_REGISTRATION( Toolkit, Button, "selected-state-actor", MAP, SELECTED_STATE_ACTOR ) +DALI_PROPERTY_REGISTRATION( Toolkit, Button, "disabled-state-actor", MAP, DISABLED_STATE_ACTOR ) +DALI_PROPERTY_REGISTRATION( Toolkit, Button, "label-actor", MAP, LABEL_ACTOR ) -DALI_SIGNAL_REGISTRATION( Button, "pressed", SIGNAL_PRESSED ) -DALI_SIGNAL_REGISTRATION( Button, "released", SIGNAL_RELEASED ) -DALI_SIGNAL_REGISTRATION( Button, "clicked", SIGNAL_CLICKED ) -DALI_SIGNAL_REGISTRATION( Button, "state-changed", SIGNAL_STATE_CHANGED ) +DALI_SIGNAL_REGISTRATION( Toolkit, Button, "pressed", SIGNAL_PRESSED ) +DALI_SIGNAL_REGISTRATION( Toolkit, Button, "released", SIGNAL_RELEASED ) +DALI_SIGNAL_REGISTRATION( Toolkit, Button, "clicked", SIGNAL_CLICKED ) +DALI_SIGNAL_REGISTRATION( Toolkit, Button, "state-changed", SIGNAL_STATE_CHANGED ) -DALI_ACTION_REGISTRATION( Button, "button-click", ACTION_BUTTON_CLICK ) +DALI_ACTION_REGISTRATION( Toolkit, Button, "button-click", ACTION_BUTTON_CLICK ) DALI_TYPE_REGISTRATION_END() @@ -85,26 +110,116 @@ Button::Button() mNextAutoRepeatingDelay( NEXT_AUTOREPEATING_DELAY ), mAnimationTime( 0.0f ), mClickActionPerforming( false ), - mState( ButtonUp ) + mState( ButtonUp ), + mPaintState( UnselectedState ) { } Button::~Button() { - if( mAutoRepeatingTimer ) - { - mAutoRepeatingTimer.Reset(); - } } void Button::SetDisabled( bool disabled ) { - if( disabled != mDisabled ) + if( disabled == mDisabled ) { - mDisabled = disabled; + return; + } + + StopTransitionAnimation(); + + mDisabled = disabled; - OnDisabled( mDisabled ); + // Notifies the derived class the button has been disabled. + OnDisabled(); + + switch( mPaintState ) + { + case UnselectedState: + { + //Layer Order + //(3) mDisabledContent (Inserted) + //(4) mUnselectedContent + //(2) mDisabledBackgroundContent (Inserted) + //(1) mBackgroundContent + + TransitionInBetween( mUnselectedContent, mLabel, mDisabledContent ); + TransitionInAbove( mBackgroundContent, mDisabledBackgroundContent ); + + TransitionOut( mUnselectedContent ); + TransitionOut( mSelectedContent ); + TransitionOut( mBackgroundContent ); + TransitionOut( mSelectedBackgroundContent ); + TransitionOut( mDisabledSelectedContent ); + + mPaintState = DisabledUnselectedState; + break; + } + case SelectedState: + { + //Layer Order + //(5) mDisabledSelectedContent (Inserted) + //(4) mSelectedContent + //(3) mDisabledBackgroundContent (Inserted) + //(2) mSelectedBackgroundContent + //(1) mBackgroundContent + + TransitionInBetween( mSelectedContent, mLabel, mDisabledSelectedContent ); + TransitionInAbove( mSelectedBackgroundContent, mDisabledBackgroundContent ); + + TransitionOut( mUnselectedContent ); + TransitionOut( mSelectedContent ); + TransitionOut( mBackgroundContent ); + TransitionOut( mSelectedBackgroundContent ); + TransitionOut( mDisabledContent ); + + mPaintState = DisabledSelectedState; + break; + } + case DisabledUnselectedState: + { + //Layer Order + //(3) mUnselectedContent (Inserted) + //(4) mDisabledContent + //(2) mBackgroundContent (Inserted) + //(1) mDisabledBackgroundContent + + TransitionInBetween( mDisabledContent, mLabel, mUnselectedContent ); + TransitionInAbove( mDisabledBackgroundContent, mBackgroundContent ); + + TransitionOut( mSelectedContent ); + TransitionOut( mSelectedBackgroundContent ); + TransitionOut( mDisabledContent ); + TransitionOut( mDisabledSelectedContent ); + TransitionOut( mDisabledBackgroundContent ); + + mPaintState = UnselectedState; + break; + } + case DisabledSelectedState: + { + //Layer Order + //(4) mSelectedContent (Inserted) + //(5) mDisabledSelectedContent + //(3) mSelectedBackgroundContent (Inserted) + //(2) mBackgroundContent (Inserted) + //(1) mDisabledBackgroundContent + + TransitionInBetween( mDisabledSelectedContent, mLabel, mSelectedContent ); + TransitionInAbove( mDisabledBackgroundContent, mSelectedBackgroundContent ); + TransitionInAbove( mDisabledBackgroundContent, mBackgroundContent ); + + TransitionOut( mUnselectedContent ); + TransitionOut( mDisabledContent ); + TransitionOut( mDisabledSelectedContent ); + TransitionOut( mDisabledBackgroundContent ); + + mPaintState = SelectedState; + break; + } } + + StartTransitionAnimation(); } bool Button::IsDisabled() const @@ -124,11 +239,7 @@ void Button::SetAutoRepeating( bool autoRepeating ) if( mSelected ) { // Emit a signal is not wanted, only change the appearance. - OnSelected( false ); - - mSelected = false; - - RelayoutRequest(); + SetSelected( false, false ); } } } @@ -180,18 +291,79 @@ void Button::SetSelected( bool selected ) { if( !mDisabled && mTogglableButton && ( selected != mSelected ) ) { - // Notifies the derived class the button has been selected. - OnSelected( selected ); + SetSelected( selected, true ); + } +} + +void Button::SetSelected( bool selected, bool emitSignal ) +{ + StopTransitionAnimation(); + + mSelected = selected; + + // Notifies the derived class the button has been selected. + OnSelected(); + + switch( mPaintState ) + { + case UnselectedState: + { + //Layer Order + //(3) mSelectedContent (Inserted) + //(4) mUnselectedContent + //(2) mSelectedBackgroundContent (Inserted) + //(1) mBackgroundContent + + TransitionInBetween( mUnselectedContent, mLabel, mSelectedContent ); + TransitionInAbove( mBackgroundContent, mSelectedBackgroundContent ); + TransitionInAtIndex( 0, mBackgroundContent ); + + TransitionOut( mUnselectedContent ); + TransitionOut( mDisabledContent ); + TransitionOut( mDisabledSelectedContent ); + TransitionOut( mDisabledBackgroundContent ); + + mPaintState = SelectedState; + break; + } + case SelectedState: + { + //Layer Order + //(3) mUnselectedContent (Inserted) + //(2) mSelectedContent + //(1) mBackgroundContent + + TransitionInBetween( mSelectedContent, mLabel, mUnselectedContent ); + TransitionInAtIndex( 0, mBackgroundContent ); + + TransitionOut( mSelectedContent ); + TransitionOut( mSelectedBackgroundContent ); + TransitionOut( mDisabledContent ); + TransitionOut( mDisabledSelectedContent ); + TransitionOut( mDisabledBackgroundContent ); + + mPaintState = UnselectedState; + break; + } + case DisabledUnselectedState: + case DisabledSelectedState: + { + DALI_ASSERT_DEBUG( 0 && "Shouldn't be able to change paint state if the button is disabled." ); + break; + } + } - mSelected = selected; + StartTransitionAnimation(); + if( emitSignal ) + { Toolkit::Button handle( GetOwner() ); // Emit signal. mStateChangedSignal.Emit( handle ); - - RelayoutRequest(); } + + RelayoutRequest(); } bool Button::IsSelected() const @@ -211,9 +383,8 @@ float Button::GetAnimationTime() const void Button::SetLabel( const std::string& label ) { - Toolkit::TextView textView = Toolkit::TextView::New( label ); - textView.SetWidthExceedPolicy( Toolkit::TextView::ShrinkToFit ); // Make sure our text always fits inside the button - SetLabel( textView ); + Toolkit::TextLabel textLabel = Toolkit::TextLabel::New( label ); + SetLabel( textLabel ); } void Button::SetLabel( Actor label ) @@ -226,6 +397,10 @@ void Button::SetLabel( Actor label ) } mLabel = label; + mLabel.SetPosition( 0.f, 0.f ); + + // label should be the top of the button + Self().Add( mLabel ); OnLabelSet(); @@ -243,14 +418,58 @@ Actor& Button::GetLabel() return mLabel; } +void Button::SetButtonImage( Actor image ) +{ + StopTransitionAnimation(); + + if( mUnselectedContent && mUnselectedContent.GetParent() ) + { + Self().Remove( mUnselectedContent ); + } + + mUnselectedContent = image; + if( mUnselectedContent ) + { + mUnselectedContent.SetAnchorPoint( AnchorPoint::TOP_LEFT ); + mUnselectedContent.SetParentOrigin( ParentOrigin::TOP_LEFT ); + mUnselectedContent.SetPosition( 0.f, 0.f ); + } + ResetImageLayers(); + OnButtonImageSet(); + + RelayoutRequest(); +} + Actor Button::GetButtonImage() const { - return mButtonContent; + return mUnselectedContent; } Actor& Button::GetButtonImage() { - return mButtonContent; + return mUnselectedContent; +} + +void Button::SetSelectedImage( Actor image ) +{ + StopTransitionAnimation(); + + if( mSelectedContent && mSelectedContent.GetParent() ) + { + Self().Remove( mSelectedContent ); + } + + mSelectedContent = image; + if( mSelectedContent ) + { + mSelectedContent.SetAnchorPoint( AnchorPoint::TOP_LEFT ); + mSelectedContent.SetParentOrigin( ParentOrigin::TOP_LEFT ); + mSelectedContent.SetPosition( 0.f, 0.f ); + } + ResetImageLayers(); + OnSelectedImageSet(); + + RelayoutRequest(); } Actor Button::GetSelectedImage() const @@ -263,6 +482,28 @@ Actor& Button::GetSelectedImage() return mSelectedContent; } +void Button::SetBackgroundImage( Actor image ) +{ + StopTransitionAnimation(); + + if( mBackgroundContent && mBackgroundContent.GetParent() ) + { + Self().Remove( mBackgroundContent ); + } + + mBackgroundContent = image; + if( mBackgroundContent ) + { + mBackgroundContent.SetAnchorPoint( AnchorPoint::TOP_LEFT ); + mBackgroundContent.SetParentOrigin( ParentOrigin::TOP_LEFT ); + mBackgroundContent.SetPosition( 0.f, 0.f ); + } + ResetImageLayers(); + OnBackgroundImageSet(); + + RelayoutRequest(); +} + Actor Button::GetBackgroundImage() const { return mBackgroundContent; @@ -273,6 +514,59 @@ Actor& Button::GetBackgroundImage() return mBackgroundContent; } +void Button::SetSelectedBackgroundImage( Actor image ) +{ + StopTransitionAnimation(); + + if( mSelectedBackgroundContent && mSelectedBackgroundContent.GetParent() ) + { + Self().Remove( mSelectedBackgroundContent ); + } + + mSelectedBackgroundContent = image; + if( mSelectedBackgroundContent ) + { + mSelectedBackgroundContent.SetAnchorPoint( AnchorPoint::TOP_LEFT ); + mSelectedBackgroundContent.SetParentOrigin( ParentOrigin::TOP_LEFT ); + mSelectedBackgroundContent.SetPosition( 0.f, 0.f ); + } + ResetImageLayers(); + OnSelectedBackgroundImageSet(); + + RelayoutRequest(); +} + +Actor Button::GetSelectedBackgroundImage() const +{ + return mSelectedBackgroundContent; +} + +Actor& Button::GetSelectedBackgroundImage() +{ + return mSelectedBackgroundContent; +} + +void Button::SetDisabledImage( Actor image ) +{ + StopTransitionAnimation(); + + if( mDisabledContent && mDisabledContent.GetParent() ) + { + Self().Remove( mDisabledContent ); + } + + mDisabledContent = image; + if( mDisabledContent ) + { + mDisabledContent.SetAnchorPoint( AnchorPoint::TOP_LEFT ); + mDisabledContent.SetParentOrigin( ParentOrigin::TOP_LEFT ); + mDisabledContent.SetPosition( 0.f, 0.f ); + } + + ResetImageLayers(); + OnDisabledImageSet(); +} + Actor Button::GetDisabledImage() const { return mDisabledContent; @@ -283,6 +577,27 @@ Actor& Button::GetDisabledImage() return mDisabledContent; } +void Button::SetDisabledSelectedImage( Actor image ) +{ + StopTransitionAnimation(); + + if( mDisabledSelectedContent && mDisabledSelectedContent.GetParent() ) + { + Self().Remove( mDisabledSelectedContent ); + } + + mDisabledSelectedContent = image; + if( mDisabledSelectedContent ) + { + mDisabledSelectedContent.SetAnchorPoint( AnchorPoint::TOP_LEFT ); + mDisabledSelectedContent.SetParentOrigin( ParentOrigin::TOP_LEFT ); + mDisabledSelectedContent.SetPosition( 0.f, 0.f ); + } + + ResetImageLayers(); + OnDisabledSelectedImageSet(); +} + Actor Button::GetDisabledSelectedImage() const { return mDisabledSelectedContent; @@ -293,6 +608,26 @@ Actor& Button::GetDisabledSelectedImage() return mDisabledSelectedContent; } +void Button::SetDisabledBackgroundImage( Actor image ) +{ + StopTransitionAnimation(); + + if( mDisabledBackgroundContent && mDisabledBackgroundContent.GetParent() ) + { + Self().Remove( mDisabledBackgroundContent ); + } + + mDisabledBackgroundContent = image; + if( mDisabledBackgroundContent ) + { + mDisabledBackgroundContent.SetAnchorPoint( AnchorPoint::TOP_LEFT ); + mDisabledBackgroundContent.SetParentOrigin( ParentOrigin::TOP_LEFT ); + mDisabledBackgroundContent.SetPosition( 0.f, 0.f ); + } + ResetImageLayers(); + OnDisabledBackgroundImageSet(); +} + Actor Button::GetDisabledBackgroundImage() const { return mDisabledBackgroundContent; @@ -303,7 +638,7 @@ Actor& Button::GetDisabledBackgroundImage() return mDisabledBackgroundContent; } -bool Button::DoAction( BaseObject* object, const std::string& actionName, const PropertyValueContainer& attributes ) +bool Button::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& attributes ) { bool ret = false; @@ -315,14 +650,13 @@ bool Button::DoAction( BaseObject* object, const std::string& actionName, const if( 0 == strcmp( actionName.c_str(), ACTION_BUTTON_CLICK ) ) { - GetImplementation( button ).DoClickAction( attributes ); - ret = true; + ret = GetImplementation( button ).DoClickAction( attributes ); } return ret; } -void Button::DoClickAction( const PropertyValueContainer& attributes ) +bool Button::DoClickAction( const Property::Map& attributes ) { // Prevents the button signals from doing a recursive loop by sending an action // and re-emitting the signals. @@ -333,7 +667,11 @@ void Button::DoClickAction( const PropertyValueContainer& attributes ) mState = ButtonDown; OnButtonUp(); mClickActionPerforming = false; + + return true; } + + return false; } void Button::OnButtonStageDisconnection() @@ -342,10 +680,7 @@ void Button::OnButtonStageDisconnection() { if( !mTogglableButton ) { - Toolkit::Button handle( GetOwner() ); - - // Notifies the derived class the button has been released. - OnReleased(); + Released(); if( mAutoRepeating ) { @@ -361,8 +696,7 @@ void Button::OnButtonDown() { Toolkit::Button handle( GetOwner() ); - // Notifies the derived class the button has been pressed. - OnPressed(); + Pressed(); if( mAutoRepeating ) { @@ -384,9 +718,7 @@ void Button::OnButtonUp() } else { - // Notifies the derived class the button has been clicked. - OnReleased(); - OnClicked(); + Released(); if( mAutoRepeating ) { @@ -410,8 +742,7 @@ void Button::OnTouchPointLeave() { Toolkit::Button handle( GetOwner() ); - // Notifies the derived class the button has been released. - OnReleased(); + Released(); if( mAutoRepeating ) { @@ -558,11 +889,24 @@ void Button::OnInitialize() self.SetKeyboardFocusable( true ); } -void Button::OnActivated() +bool Button::OnAccessibilityActivated() +{ + return OnKeyboardEnter(); +} + +bool Button::OnKeyboardEnter() +{ + // When the enter key is pressed, or button is activated, the click action is performed. + Property::Map attributes; + bool ret = DoClickAction( attributes ); + + return ret; +} + +void Button::OnControlStageDisconnection() { - // When the button is activated, it performs the click action - PropertyValueContainer attributes; - DoClickAction( attributes ); + OnButtonStageDisconnection(); // Notification for derived classes. + mState = ButtonUp; } void Button::OnTap(Actor actor, const TapGesture& tap) @@ -585,10 +929,9 @@ bool Button::AutoRepeatingSlot() // Restart the autorepeat timer. SetUpTimer( mNextAutoRepeatingDelay ); - Toolkit::Button handle( GetOwner() ); + Pressed(); - // Notifies the derived class the button has been pressed. - OnPressed(); + Toolkit::Button handle( GetOwner() ); //Emit signal. consumed = mReleasedSignal.Emit( handle ); @@ -599,10 +942,63 @@ bool Button::AutoRepeatingSlot() return consumed; } -void Button::OnControlStageDisconnection() +void Button::Pressed() { - OnButtonStageDisconnection(); // Notification for derived classes. - mState = ButtonUp; + if( mPaintState == UnselectedState ) + { + StopTransitionAnimation(); + + // Notifies the derived class the button has been pressed. + OnPressed(); + + //Layer Order + //(4) mSelectedContent (Inserted) + //(3) mUnselectedContent + //(2) mSelectedBackgroundContent (Inserted) + //(1) mBackgroundContent + + TransitionInBetween( mUnselectedContent, mLabel, mSelectedContent ); + TransitionInAbove( mBackgroundContent, mSelectedBackgroundContent ); + TransitionInAtIndex( 0, mBackgroundContent ); + + TransitionOut( mUnselectedContent ); + TransitionOut( mDisabledContent ); + TransitionOut( mDisabledSelectedContent ); + TransitionOut( mDisabledBackgroundContent ); + + mPaintState = SelectedState; + + StartTransitionAnimation(); + } +} + +void Button::Released() +{ + if( mPaintState == SelectedState ) + { + StopTransitionAnimation(); + + // Notifies the derived class the button has been released. + OnReleased(); + + //Layer Order + //(3) mUnselectedContent (Inserted) + //(2) mSelectedContent + //(1) mBackgroundContent + + TransitionInBetween( mSelectedContent, mLabel, mUnselectedContent ); + TransitionInAtIndex( 0, mBackgroundContent ); + + TransitionOut( mSelectedContent ); + TransitionOut( mSelectedBackgroundContent ); + TransitionOut( mDisabledContent ); + TransitionOut( mDisabledSelectedContent ); + TransitionOut( mDisabledBackgroundContent ); + + mPaintState = UnselectedState; + + StartTransitionAnimation(); + } } Button::ButtonState Button::GetState() @@ -610,6 +1006,237 @@ Button::ButtonState Button::GetState() return mState; } +Button::PaintState Button::GetPaintState() +{ + return mPaintState; +} + +bool Button::InsertButtonImage( unsigned int index, Actor& actor ) +{ + if( actor ) + { + Self().Insert( index, actor ); + PrepareForTranstionOut( actor ); + return true; + } + + return false; +} + +void Button::RemoveButtonImage( Actor& actor ) +{ + if( actor ) + { + if( actor.GetParent() ) + { + Self().Remove( actor ); + } + PrepareForTranstionIn( actor ); + } +} + +unsigned int Button::FindChildIndex( Actor& actor ) +{ + Actor self = Self(); + unsigned int childrenNum = self.GetChildCount(); + + for( unsigned int i = 0; i < childrenNum; i++ ) + { + Actor child = self.GetChildAt( i ); + if( child == actor ) + { + return i; + } + } + + return childrenNum; +} + +void Button::TransitionInBetween( Actor childLower, Actor childUpper, Actor actor ) +{ + unsigned int index = childLower ? FindChildIndex( childLower ) + 1 : FindChildIndex( childUpper ); + TransitionInAtIndex( index, actor ); +} + +void Button::TransitionInAbove( Actor child, Actor actor ) +{ + unsigned int index = child ? FindChildIndex( child ) + 1 : 0; + TransitionInAtIndex( index, actor ); +} + +void Button::TransitionInAtIndex( unsigned int index, Actor actor ) +{ + if( actor ) + { + if( !actor.GetParent() ) + { + Self().Insert( index, actor ); + } + + OnTransitionIn( actor ); + } +} + +void Button::TransitionOut( Actor actor ) +{ + OnTransitionOut( actor ); +} + +void Button::ResetImageLayers() +{ + //ensure that all layers are in the correct order and state according to the paint state + + int index = 0; + switch( mPaintState ) + { + case UnselectedState: + { + //Layer Order + //(2) mUnselectedContent + //(1) mBackgroundContent + + RemoveButtonImage( mSelectedContent ); + RemoveButtonImage( mSelectedBackgroundContent ); + RemoveButtonImage( mDisabledContent ); + RemoveButtonImage( mDisabledSelectedContent ); + RemoveButtonImage( mDisabledBackgroundContent ); + + if( InsertButtonImage( index, mBackgroundContent ) ) + { + ++index; + } + if( InsertButtonImage( index, mUnselectedContent ) ) + { + ++index; + } + break; + } + case SelectedState: + { + //Layer Order + //(3) mSelectedContent + //(2) mSelectedBackgroundContent + //(1) mBackgroundContent + + RemoveButtonImage( mUnselectedContent ); + RemoveButtonImage( mDisabledContent ); + RemoveButtonImage( mDisabledSelectedContent ); + RemoveButtonImage( mDisabledBackgroundContent ); + + if( InsertButtonImage( index, mBackgroundContent ) ) + { + ++index; + } + if( InsertButtonImage( index, mSelectedBackgroundContent ) ) + { + ++index; + } + if( InsertButtonImage( index, mSelectedContent ) ) + { + ++index; + } + break; + } + case DisabledUnselectedState: + { + //Layer Order + //(2) mDisabledContent + //(1) mDisabledBackgroundContent + + RemoveButtonImage( mUnselectedContent ); + RemoveButtonImage( mBackgroundContent ); + RemoveButtonImage( mSelectedContent ); + RemoveButtonImage( mDisabledSelectedContent ); + RemoveButtonImage( mSelectedBackgroundContent ); + + if( InsertButtonImage( index, mDisabledBackgroundContent ? mDisabledBackgroundContent : mBackgroundContent ) ) + { + ++index; + } + if( InsertButtonImage( index, mDisabledContent ? mDisabledContent : mUnselectedContent ) ) + { + ++index; + } + break; + } + case DisabledSelectedState: + { + //Layer Order + // (2) mDisabledSelectedContent + // (1) mDisabledBackgroundContent + + RemoveButtonImage( mUnselectedContent ); + RemoveButtonImage( mSelectedContent ); + RemoveButtonImage( mBackgroundContent ); + RemoveButtonImage( mSelectedBackgroundContent ); + RemoveButtonImage( mDisabledContent ); + + if( mDisabledBackgroundContent ) + { + if( InsertButtonImage( index, mDisabledBackgroundContent) ) + { + ++index; + } + } + else + { + if( InsertButtonImage( index, mBackgroundContent ) ) + { + ++index; + } + if( InsertButtonImage( index, mSelectedBackgroundContent ) ) + { + ++index; + } + } + + if( InsertButtonImage( index, mDisabledSelectedContent ? mDisabledSelectedContent : mSelectedContent) ) + { + ++index; + } + break; + } + } +} + +void Button::StartTransitionAnimation() +{ + if( mTransitionAnimation ) + { + mTransitionAnimation.Play(); + } + else + { + ResetImageLayers(); + } +} + +void Button::StopTransitionAnimation() +{ + if( mTransitionAnimation ) + { + mTransitionAnimation.Clear(); + mTransitionAnimation.Reset(); + } +} + +Dali::Animation Button::GetTransitionAnimation() +{ + if( !mTransitionAnimation ) + { + mTransitionAnimation = Dali::Animation::New( GetAnimationTime() ); + mTransitionAnimation.FinishedSignal().Connect( this, &Button::TransitionAnimationFinished ); + } + + return mTransitionAnimation; +} + +void Button::TransitionAnimationFinished( Dali::Animation& source ) +{ + StopTransitionAnimation(); + ResetImageLayers(); +} + void Button::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value ) { Toolkit::Button button = Toolkit::Button::DownCast( Dali::BaseHandle( object ) ); @@ -620,7 +1247,7 @@ void Button::SetProperty( BaseObject* object, Property::Index index, const Prope { case Toolkit::Button::Property::DISABLED: { - GetImplementation( button ).SetDisabled( value.Get() ); + GetImplementation( button ).SetDisabled( value.Get< bool >() ); break; } @@ -730,7 +1357,7 @@ Property::Value Button::GetProperty( BaseObject* object, Property::Index propert case Toolkit::Button::Property::NORMAL_STATE_ACTOR: { Property::Map map; - Scripting::CreatePropertyMap( GetImplementation( button ).mButtonContent, map ); + Scripting::CreatePropertyMap( GetImplementation( button ).mUnselectedContent, map ); value = map; break; }