X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Fbuttons%2Fbutton-impl.cpp;h=acf3a5a70363da7a878fa737794b0efc4fbe43cc;hb=c32e712ddb572650fe0766d7f10a9707db5b5c6b;hp=9c1c3404840a9f32fb0764adced4ac26afa100b9;hpb=3fbada5f2ec43d9b0ea3e63eb54223cf7b3056f4;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/controls/buttons/button-impl.cpp b/dali-toolkit/internal/controls/buttons/button-impl.cpp index 9c1c340..acf3a5a 100644 --- a/dali-toolkit/internal/controls/buttons/button-impl.cpp +++ b/dali-toolkit/internal/controls/buttons/button-impl.cpp @@ -1,27 +1,32 @@ -// -// Copyright (c) 2014 Samsung Electronics Co., Ltd. -// -// Licensed under the Flora License, Version 1.0 (the License); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://floralicense.org/license/ -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an AS IS BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// +/* + * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ // CLASS HEADER - #include "button-impl.h" -namespace -{ -const char* const PROPERTY_DIMMED = "dimmed"; -} // unnamed namespace +// EXTERNAL INCLUDES +#include +#include +#include +#include +#include + +// INTERNAL INCLUDES +#include namespace Dali { @@ -29,8 +34,6 @@ namespace Dali namespace Toolkit { -const Property::Index Button::PROPERTY_DIMMED( Internal::Button::BUTTON_PROPERTY_START_INDEX ); - namespace Internal { @@ -43,66 +46,407 @@ BaseHandle Create() return BaseHandle(); } -TypeRegistration typeRegistration( typeid(Toolkit::Button), typeid(Toolkit::Control), 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_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 ) -SignalConnectorType signalConnector1( typeRegistration, Toolkit::Button::SIGNAL_CLICKED, &Button::DoConnectSignal ); +DALI_ACTION_REGISTRATION( Button, "button-click", ACTION_BUTTON_CLICK ) -PropertyRegistration property1( typeRegistration, "dimmed", Toolkit::Button::PROPERTY_DIMMED, Property::BOOLEAN, &Button::SetProperty, &Button::GetProperty ); +DALI_TYPE_REGISTRATION_END() + +const unsigned int INITIAL_AUTOREPEATING_DELAY( 0.15f ); +const unsigned int NEXT_AUTOREPEATING_DELAY( 0.05f ); } // unnamed namespace Button::Button() -: ControlImpl( true ), - mState( ButtonUp ), - mDimmed( false ), - mPainter( NULL ) +: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS | REQUIRES_STYLE_CHANGE_SIGNALS ) ), + 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::SetDimmed( bool dimmed ) +void Button::SetDisabled( bool disabled ) { - mDimmed = dimmed; + if( disabled != mDisabled ) + { + mDisabled = disabled; + + OnDisabled( mDisabled ); + } +} - // Notifies the painter. - Toolkit::Button handle( GetOwner() ); - if( mPainter ) +bool Button::IsDisabled() const +{ + return mDisabled; +} + +void Button::SetAutoRepeating( bool autoRepeating ) +{ + mAutoRepeating = autoRepeating; + + // An autorepeating button can't be a togglable button. + if( autoRepeating ) { - mPainter->SetDimmed( handle, mDimmed ); + mTogglableButton = false; + + if( mSelected ) + { + // Emit a signal is not wanted, only change the appearance. + OnSelected( false ); + + mSelected = false; + + RelayoutRequest(); + } } } -bool Button::IsDimmed() const +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 mDimmed; + 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::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 ); +} + +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 ); + } + } } -void Button::OnAnimationTimeSet( float animationTime ) +void Button::OnTouchPointLeave() { - // nothing to do. + 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 ); + } + } +} + +void Button::OnTouchPointInterrupted() +{ + OnTouchPointLeave(); +} + +Toolkit::Button::ButtonSignalType& Button::PressedSignal() +{ + return mPressedSignal; } -float Button::OnAnimationTimeRequested() const +Toolkit::Button::ButtonSignalType& Button::ReleasedSignal() { - return 0.f; + return mReleasedSignal; } -Toolkit::Button::ClickedSignalV2& Button::ClickedSignal() +Toolkit::Button::ButtonSignalType& Button::ClickedSignal() { - return mClickedSignalV2; + return mClickedSignal; +} + +Toolkit::Button::ButtonSignalType& Button::StateChangedSignal() +{ + return mStateChangedSignal; } bool Button::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor ) @@ -110,12 +454,24 @@ 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( 0 == strcmp( signalName.c_str(), SIGNAL_STATE_CHANGED ) ) + { + button.StateChangedSignal().Connect( tracker, functor ); + } else { // signalName does not match any signal @@ -127,9 +483,9 @@ bool Button::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tr bool Button::OnTouchEvent(const TouchEvent& event) { - // Only events are processed when the button is not dimmed and the touch event has only + // Only events are processed when the button is not disabled and the touch event has only // one touch point. - if( ( !mDimmed ) && ( 1 == event.GetPointCount() ) ) + if( ( !mDisabled ) && ( 1 == event.GetPointCount() ) ) { switch( event.GetPoint(0).state ) { @@ -191,13 +547,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(); @@ -209,49 +558,210 @@ 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, TapGesture tap) +void Button::OnTap(Actor actor, const TapGesture& tap) { // Do nothing. } -void Button::OnStageDisconnection() +void Button::SetUpTimer( float delay ) { - if( ButtonUp != mState ) + 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 ) { - OnTouchPointLeave(); // Notification for derived classes. - mState = ButtonUp; - } + // 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_DIMMED ) ) + if ( button ) { - GetImplementation( button ).SetDimmed( 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_DIMMED ) ) + if ( button ) { - return Property::Value( GetImplementation( button ).mDimmed ); + 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