uint32_t verticalDpi,
ResourcePolicy::DataRetention policy,
bool initialize )
-: mCore( NULL ),
+: mRenderSurface( NULL ),
+ mCore( NULL ),
mSurfaceWidth( surfaceWidth ),
mSurfaceHeight( surfaceHeight ),
mFrame( 0u ),
void SceneHolder::Remove( Dali::Actor actor )
{
- mScene.Add( actor );
+ mScene.Remove( actor );
}
Dali::Layer SceneHolder::GetRootLayer() const
class Window : public SceneHolder
{
public:
-
Window( const PositionSize& positionSize );
virtual ~Window() = default;
static Window* New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent);
+ FocusChangeSignalType mFocusChangeSignal;
};
} // namespace Adaptor
return GetImplementation( *this ).GetRenderSurface();
}
+void Window::Add( Actor actor )
+{
+ GetImplementation( *this ).Add( actor );
+}
+
+void Window::Remove( Actor actor )
+{
+ GetImplementation( *this ).Remove( actor );
+}
+
+Dali::Layer Window::GetRootLayer() const
+{
+ return GetImplementation( *this ).GetRootLayer();
+}
+
+void Window::SetBackgroundColor( const Vector4& color )
+{
+ GetImplementation( *this ).SetBackgroundColor( color );
+}
+
+Vector4 Window::GetBackgroundColor() const
+{
+ return GetImplementation( *this ).GetBackgroundColor();
+}
+
+void Window::Raise()
+{
+ GetImplementation( *this ).mFocusChangeSignal.Emit(*this, true);
+}
+
+FocusChangeSignalType& Window::FocusChangeSignal()
+{
+ return GetImplementation( *this ).mFocusChangeSignal;
+}
+
namespace DevelWindow
{
return Dali::Window( windowImpl );
}
+Window DownCast( BaseHandle handle )
+{
+ Internal::Adaptor::Window* windowImpl = nullptr;
+ if ( Dali::Adaptor::IsAvailable() )
+ {
+ windowImpl = dynamic_cast<Dali::Internal::Adaptor::Window*>( handle.GetObjectPtr());
+ }
+ return Dali::Window( windowImpl );
+}
+
EventProcessingFinishedSignalType& EventProcessingFinishedSignal( Window window )
{
return GetImplementation( window ).GetScene().EventProcessingFinishedSignal();
{
return GetImplementation( window ).WheelEventSignal();
}
+
} // namespace DevelWindow
} // Dali
}
}
+class Window;
+typedef Signal< void (Window,bool) > FocusChangeSignalType;
+
class Window : public BaseHandle
{
public:
Integration::Scene GetScene();
Integration::RenderSurface& GetRenderSurface();
+ void Add( Dali::Actor actor );
+ void Remove( Dali::Actor actor );
+ Dali::Layer GetRootLayer() const;
+ void SetBackgroundColor( const Vector4& color );
+ Vector4 GetBackgroundColor() const;
+ void Raise();
+ FocusChangeSignalType& FocusChangeSignal();
public:
explicit Window( Internal::Adaptor::Window* window );
typedef Signal< void (const WheelEvent&) > WheelEventSignalType;
Dali::Window Get( Actor actor );
+Dali::Window DownCast( BaseHandle handle );
EventProcessingFinishedSignalType& EventProcessingFinishedSignal( Window window );
KeyEventSignalType& KeyEventSignal( Dali::Window window );
// Stop
DevelControl::DoAction( actor, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::STOP, attributes );
- // Trigger count is 1 - animation finished
- DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
+ application.SendNotification();
+ application.Render( 16 );
map = actor.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
value = map.Find( DevelImageVisual::Property::CURRENT_FRAME_NUMBER );
END_TEST;
}
+int UtcDaliKeyboardFocusManagerFocusPerWindow(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline( "Ensure Memory focus actors for each window ");
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK( ! manager.GetCurrentFocusActor() );
+
+ Window firstWindow = Window::New(PositionSize(0,0,300,500) ,"", false);
+ DALI_TEST_CHECK( firstWindow );
+ Control first = Control::New();
+ first.SetKeyboardFocusable(true);
+ firstWindow.Add(first);
+
+ Window secondWindow = Window::New(PositionSize(0,0,400,600) ,"", false);
+ DALI_TEST_CHECK( secondWindow );
+ Control second = Control::New();
+ second.SetKeyboardFocusable(true);
+ secondWindow.Add( second );
+
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+ firstWindow.Raise();
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ secondWindow.Remove( second );
+ secondWindow.Raise();
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() != second);
+
+ secondWindow.Reset();
+ END_TEST;
+}
+
mFocusedActorEnterKeySignal(),
mCurrentFocusActor(),
mFocusIndicatorActor(),
- mIsFocusIndicatorShown( -1 ),
- mFocusGroupLoopEnabled( false ),
- mIsWaitingKeyboardFocusChangeCommit( false ),
- mClearFocusOnTouch( true ),
- mEnableFocusIndicator( true ),
- mAlwaysShowIndicator( true ),
mFocusHistory(),
mSlotDelegate( this ),
- mCustomAlgorithmInterface(NULL)
+ mCustomAlgorithmInterface(NULL),
+ mCurrentFocusedWindow(),
+ mIsFocusIndicatorShown( UNKNOWN ),
+ mEnableFocusIndicator( ENABLE ),
+ mAlwaysShowIndicator( ALWAYS_SHOW ),
+ mFocusGroupLoopEnabled( false ),
+ mIsWaitingKeyboardFocusChangeCommit( false ),
+ mClearFocusOnTouch( true )
{
// TODO: Get FocusIndicatorEnable constant from stylesheet to set mIsFocusIndicatorShown.
{
( *iter ).KeyEventSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnKeyEvent );
( *iter ).TouchSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
+ Dali::Window window = DevelWindow::DownCast( *iter );
+ if( window )
+ {
+ window.FocusChangeSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnWindowFocusChanged);
+ }
}
// Get notified when any new scene holder is created afterwards
{
sceneHolder.KeyEventSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnKeyEvent );
sceneHolder.TouchSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnTouch );
+ Dali::Window window = DevelWindow::DownCast( sceneHolder );
+ if( window )
+ {
+ window.FocusChangeSignal().Connect( mSlotDelegate, &KeyboardFocusManager::OnWindowFocusChanged);
+ }
}
KeyboardFocusManager::~KeyboardFocusManager()
if( styleManager )
{
Property::Map config = Toolkit::DevelStyleManager::GetConfigurations( styleManager );
- mAlwaysShowIndicator = config["alwaysShowFocus"].Get<bool>();
- mIsFocusIndicatorShown = static_cast<int>(mAlwaysShowIndicator);
- mClearFocusOnTouch = mIsFocusIndicatorShown ? false : true;
+ mAlwaysShowIndicator = config["alwaysShowFocus"].Get<bool>() ? ALWAYS_SHOW : NONE;
+ mIsFocusIndicatorShown = ( mAlwaysShowIndicator == ALWAYS_SHOW )? SHOW : HIDE;
+ mClearFocusOnTouch = ( mIsFocusIndicatorShown == SHOW ) ? false : true;
}
}
{
DALI_ASSERT_DEBUG( !mIsWaitingKeyboardFocusChangeCommit && "Calling this function in the PreFocusChangeSignal callback?" );
- if( mIsFocusIndicatorShown == -1 )
+ if( mIsFocusIndicatorShown == UNKNOWN )
{
GetConfigurationFromStyleManger();
}
bool KeyboardFocusManager::DoSetCurrentFocusActor( Actor actor )
{
bool success = false;
+ if( actor && actor.IsKeyboardFocusable() && actor.OnStage() )
+ {
+ Integration::SceneHolder currentWindow = Integration::SceneHolder::Get( actor );
+
+ if( currentWindow.GetRootLayer() != mCurrentFocusedWindow.GetHandle())
+ {
+ Layer rootLayer = currentWindow.GetRootLayer();
+ mCurrentFocusedWindow = rootLayer;
+ }
+ }
Actor currentFocusedActor = GetCurrentFocusActor();
// Check whether the actor is in the stage and is keyboard focusable.
if( actor && actor.IsKeyboardFocusable() && actor.OnStage() )
{
- if( mIsFocusIndicatorShown && mEnableFocusIndicator )
+ if( ( mIsFocusIndicatorShown == SHOW ) && ( mEnableFocusIndicator == ENABLE ) )
{
actor.Add( GetFocusIndicatorActor() );
}
// Save the current focused actor
mCurrentFocusActor = actor;
+ bool focusedWindowFound = false;
+ for( unsigned int i = 0; i < mCurrentFocusActors.size(); i++ )
+ {
+ if( mCurrentFocusActors[i].first == mCurrentFocusedWindow )
+ {
+ mCurrentFocusActors[i].second = actor;
+ focusedWindowFound = true;
+ break;
+ }
+ }
+ if( !focusedWindowFound)
+ {
+ // A new window gains the focus, so store the focused actor in that window.
+ mCurrentFocusActors.push_back( std::pair< WeakHandle< Layer>, WeakHandle< Actor > >( mCurrentFocusedWindow , actor ));
+ }
+
Toolkit::Control newlyFocusedControl = Toolkit::Control::DownCast(actor);
if( newlyFocusedControl )
{
Actor KeyboardFocusManager::GetCurrentFocusActor()
{
Actor actor = mCurrentFocusActor.GetHandle();
+
if( actor && ! actor.OnStage() )
{
// If the actor has been removed from the stage, then it should not be focused
-
actor.Reset();
mCurrentFocusActor.Reset();
}
return actor;
}
+Actor KeyboardFocusManager::GetFocusActorFromCurrentWindow()
+{
+ Actor actor;
+ unsigned int index;
+ for( index = 0; index < mCurrentFocusActors.size(); index++ )
+ {
+ if( mCurrentFocusActors[index].first == mCurrentFocusedWindow )
+ {
+ actor = mCurrentFocusActors[index].second.GetHandle();
+ break;
+ }
+ }
+
+ if( actor && ! actor.OnStage() )
+ {
+ // If the actor has been removed from the window, then the window doesn't have any focused actor
+ actor.Reset();
+ mCurrentFocusActors.erase( mCurrentFocusActors.begin() + index );
+ }
+
+ return actor;
+}
+
Actor KeyboardFocusManager::GetCurrentFocusGroup()
{
return GetFocusGroup(GetCurrentFocusActor());
}
mCurrentFocusActor.Reset();
- mIsFocusIndicatorShown = static_cast<int>(mAlwaysShowIndicator);
+ mIsFocusIndicatorShown = ( mAlwaysShowIndicator == ALWAYS_SHOW ) ? SHOW : HIDE;
}
void KeyboardFocusManager::SetFocusGroupLoop(bool enabled)
std::string keyName = event.keyPressedName;
- if( mIsFocusIndicatorShown == -1 )
+ if( mIsFocusIndicatorShown == UNKNOWN )
{
GetConfigurationFromStyleManger();
}
{
if(!isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorShown)
+ if(mIsFocusIndicatorShown == HIDE)
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
{
if(!isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
}
else if (keyName == "Up" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
}
else if (keyName == "Down" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
}
else if (keyName == "Prior" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
}
else if (keyName == "Next" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
}
else if (keyName == "Tab" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
}
else if (keyName == "space" && !isAccessibilityEnabled)
{
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
isFocusStartableKey = true;
else if (keyName == "" && !isAccessibilityEnabled)
{
// Check the fake key event for evas-plugin case
- if(!mIsFocusIndicatorShown)
+ if( mIsFocusIndicatorShown == HIDE )
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
isFocusStartableKey = true;
{
if (keyName == "Return")
{
- if(!mIsFocusIndicatorShown && !isAccessibilityEnabled)
+ if((mIsFocusIndicatorShown == HIDE) && !isAccessibilityEnabled)
{
// Show focus indicator
- mIsFocusIndicatorShown = 1;
+ mIsFocusIndicatorShown = SHOW;
}
else
{
}
}
- if(isFocusStartableKey && mIsFocusIndicatorShown && !isAccessibilityEnabled)
+ if(isFocusStartableKey && ( mIsFocusIndicatorShown == SHOW ) && !isAccessibilityEnabled)
{
Actor actor = GetCurrentFocusActor();
if( actor )
{
- if( mEnableFocusIndicator )
+ if( mEnableFocusIndicator == ENABLE )
{
// Make sure the focused actor is highlighted
actor.Add( GetFocusIndicatorActor() );
void KeyboardFocusManager::OnTouch(const TouchData& touch)
{
- // if mIsFocusIndicatorShown is -1, it means Configuration is not loaded.
+ // if mIsFocusIndicatorShown is UNKNOWN, it means Configuration is not loaded.
// Try to load configuration.
- if( mIsFocusIndicatorShown == -1 )
+ if( mIsFocusIndicatorShown == UNKNOWN )
{
GetConfigurationFromStyleManger();
}
}
}
+void KeyboardFocusManager::OnWindowFocusChanged(Window window, bool focusIn )
+{
+ if( focusIn && mCurrentFocusedWindow.GetHandle() != window.GetRootLayer() )
+ {
+ // Change Current Focused Window
+ Layer rootLayer = window.GetRootLayer();
+ mCurrentFocusedWindow = rootLayer;
+
+ // Get Current Focused Actor from window
+ Actor currentFocusedActor = GetFocusActorFromCurrentWindow();
+ SetCurrentFocusActor( currentFocusedActor );
+
+ if( currentFocusedActor && ( mEnableFocusIndicator == ENABLE ) )
+ {
+ // Make sure the focused actor is highlighted
+ currentFocusedActor.Add( GetFocusIndicatorActor() );
+ mIsFocusIndicatorShown = SHOW;
+ }
+ }
+}
+
Toolkit::KeyboardFocusManager::PreFocusChangeSignalType& KeyboardFocusManager::PreFocusChangeSignal()
{
return mPreFocusChangeSignal;
mFocusIndicatorActor.Unparent();
}
- mEnableFocusIndicator = enable;
+ mEnableFocusIndicator = enable? ENABLE : DISABLE;
+
}
bool KeyboardFocusManager::IsFocusIndicatorEnabled() const
{
- return mEnableFocusIndicator;
+ return ( mEnableFocusIndicator == ENABLE );
}
} // namespace Internal
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
#include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
+#include <dali/devel-api/adaptor-framework/window-devel.h>
namespace Dali
{
typedef Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface CustomAlgorithmInterface;
+ enum FocusIndicatorState
+ {
+ UNKNOWN = -1, ///< Unknown state
+ HIDE = 0, ///< FocusIndicator is hidden
+ SHOW = 1, ///< FocusIndicator is shown
+ };
+
+ enum EnableFocusedIndicatorState
+ {
+ DISABLE = 0, ///< FocusIndicator is disable
+ ENABLE = 1, ///< FocusIndicator is enable
+ };
+
+ enum FocusedIndicatorModeState
+ {
+ NONE = 0, ///< Set nothing
+ ALWAYS_SHOW = 1, ///< FocusIndicator is always shown
+ };
+
/**
* @copydoc Toolkit::KeyboardFocusManager::Get
*/
* Callback for the key event when no actor in the stage has gained the key input focus
* @param[in] event The KeyEvent event.
*/
- void OnKeyEvent(const KeyEvent& event);
+ void OnKeyEvent( const KeyEvent& event );
/**
* Callback for the touch event when the screen is touched and when the touch ends
*/
void OnTouch( const TouchData& touch );
+ /**
+ * Called when the window focus is changed.
+ * @param[in] window The window whose focus is changed
+ * @param[in] focusIn Whether the focus is in/out
+ */
+ void OnWindowFocusChanged( Window window, bool focusIn );
+
+ /**
+ * Get the focus Actor from current window
+ */
+ Actor GetFocusActorFromCurrentWindow();
+
private:
// Undefined
Actor mFocusIndicatorActor; ///< The focus indicator actor shared by all the keyboard focusable actors for highlight
- int mIsFocusIndicatorShown; ///< Whether indicator should be shown / hidden when getting focus. It could be enabled when keyboard focus feature is enabled and navigation keys or 'Tab' key are pressed.
+ FocusStack mFocusHistory; ///< Stack to contain pre-focused actor's BaseObject*
- bool mFocusGroupLoopEnabled:1; ///< Whether the focus movement is looped within the same focus group
+ SlotDelegate< KeyboardFocusManager > mSlotDelegate;
- bool mIsWaitingKeyboardFocusChangeCommit:1; /// A flag to indicate PreFocusChangeSignal emitted but the proposed focus actor is not commited by the application yet.
+ CustomAlgorithmInterface* mCustomAlgorithmInterface; ///< The user's (application / toolkit) implementation of CustomAlgorithmInterface
- bool mClearFocusOnTouch:1; ///< Whether clear focus on touch.
+ typedef std::vector< std::pair< WeakHandle< Layer >, WeakHandle< Actor > > > FocusActorContainer;
- bool mEnableFocusIndicator; ///< Whether use focus indicator
+ FocusActorContainer mCurrentFocusActors; ///< A container of focused actors
- bool mAlwaysShowIndicator; ///< Whether always show indicator. If true, the indicator would be directly shown when focused.
+ WeakHandle< Layer > mCurrentFocusedWindow; ///< A weak handle to the current focused window's root layer
- FocusStack mFocusHistory; ///< Stack to contain pre-focused actor's BaseObject*
+ FocusIndicatorState mIsFocusIndicatorShown; ///< Whether indicator should be shown / hidden when getting focus. It could be enabled when keyboard focus feature is enabled and navigation keys or 'Tab' key are pressed.
- SlotDelegate< KeyboardFocusManager > mSlotDelegate;
+ EnableFocusedIndicatorState mEnableFocusIndicator; ///< Whether use focus indicator
- CustomAlgorithmInterface* mCustomAlgorithmInterface; ///< The user's (application / toolkit) implementation of CustomAlgorithmInterface
+ FocusedIndicatorModeState mAlwaysShowIndicator; ///< Whether always show indicator. If true, the indicator would be directly shown when focused
+ bool mFocusGroupLoopEnabled:1; ///< Whether the focus movement is looped within the same focus group
+
+ bool mIsWaitingKeyboardFocusChangeCommit:1; /// A flag to indicate PreFocusChangeSignal emitted but the proposed focus actor is not commited by the application yet.
+
+ bool mClearFocusOnTouch:1; ///< Whether clear focus on touch.
};
} // namespace Internal
}
case Toolkit::DevelImageVisual::Property::STOP_BEHAVIOR:
{
- int32_t stopBehavior;
- Scripting::GetEnumerationProperty( value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior );
- mStopBehavior = DevelImageVisual::StopBehavior::Type( stopBehavior );
- mResendFlag |= RESEND_STOP_BEHAVIOR;
+ int32_t stopBehavior = mStopBehavior;
+ if( Scripting::GetEnumerationProperty( value, STOP_BEHAVIOR_TABLE, STOP_BEHAVIOR_TABLE_COUNT, stopBehavior ) )
+ {
+ mStopBehavior = DevelImageVisual::StopBehavior::Type( stopBehavior );
+ mResendFlag |= RESEND_STOP_BEHAVIOR;
+ }
break;
}
case Toolkit::DevelImageVisual::Property::LOOPING_MODE:
{
- int32_t loopingMode;
- Scripting::GetEnumerationProperty( value, LOOPING_MODE_TABLE, LOOPING_MODE_TABLE_COUNT, loopingMode );
- mLoopingMode = DevelImageVisual::LoopingMode::Type( loopingMode );
- mResendFlag |= RESEND_LOOPING_MODE;
+ int32_t loopingMode = mLoopingMode;
+ if( Scripting::GetEnumerationProperty( value, LOOPING_MODE_TABLE, LOOPING_MODE_TABLE_COUNT, loopingMode ) )
+ {
+ mLoopingMode = DevelImageVisual::LoopingMode::Type( loopingMode );
+ mResendFlag |= RESEND_LOOPING_MODE;
+ }
break;
}
}
if( mVectorRasterizeThread.GetPlayState() != DevelImageVisual::PlayState::STOPPED )
{
mVectorRasterizeThread.StopAnimation();
+ }
- OnAnimationFinished();
+ if( mImpl->mRenderer )
+ {
+ mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
}
+
mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
break;
}
void AnimatedVectorImageVisual::OnAnimationFinished()
{
- if( mImpl->mEventObserver )
+ DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "AnimatedVectorImageVisual::OnAnimationFinished: action state = %d [%p]\n", mActionStatus, this );
+
+ if( mActionStatus != DevelAnimatedVectorImageVisual::Action::STOP )
{
- mImpl->mEventObserver->NotifyVisualEvent( *this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED );
- }
+ mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
- mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
+ if( mImpl->mEventObserver )
+ {
+ mImpl->mEventObserver->NotifyVisualEvent( *this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED );
+ }
+ }
if( mImpl->mRenderer )
{
Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_VECTOR_ANIMATION" );
#endif
-inline void ResetValue( bool& updated, uint32_t& value, uint32_t newValue, ConditionalWait& conditionalWait )
+template< typename T >
+inline void ResetValue( bool& updated, T& value, T newValue, ConditionalWait& conditionalWait )
{
ConditionalWait::ScopedLock lock( conditionalWait );
if( !updated )
mDestroyThread( false ),
mResourceReady( false ),
mCurrentFrameUpdated( false ),
+ mCurrentLoopUpdated( false ),
mForward( true ),
mUpdateFrameNumber( false ),
+ mNeedAnimationFinishedTrigger( true ),
mLogFactory( Dali::Adaptor::Get().GetLogFactory() )
{
Initialize();
if( mPlayState != PlayState::STOPPED && mPlayState != PlayState::STOPPING )
{
mNeedRender = true;
+ mNeedAnimationFinishedTrigger = false;
mPlayState = PlayState::STOPPING;
mConditionalWait.Notify( lock );
ConditionalWait::ScopedLock lock( mConditionalWait );
mLoopCount = count;
+ mCurrentLoop = 0;
+ mCurrentLoopUpdated = true;
DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::SetLoopCount: [%d] [%p]\n", count, this );
}
void VectorRasterizeThread::Rasterize()
{
- bool stopped = false;
+ bool stopped = false, needAnimationFinishedTrigger;
uint32_t currentFrame, startFrame, endFrame;
- int32_t loopCount;
+ int32_t loopCount, currentLoopCount;
{
ConditionalWait::ScopedLock lock( mConditionalWait );
startFrame = mStartFrame;
endFrame = mEndFrame;
loopCount = mLoopCount;
+ currentLoopCount = mCurrentLoop;
+ needAnimationFinishedTrigger = mNeedAnimationFinishedTrigger;
mResourceReady = true;
mNeedRender = false;
mCurrentFrameUpdated = false;
+ mCurrentLoopUpdated = false;
mUpdateFrameNumber = true;
+ mNeedAnimationFinishedTrigger = true;
}
auto currentFrameStartTime = std::chrono::system_clock::now();
}
else
{
- if( loopCount < 0 || ++mCurrentLoop < loopCount ) // repeat forever or before the last loop
+ if( loopCount < 0 || ++currentLoopCount < loopCount ) // repeat forever or before the last loop
{
ResetValue( mCurrentFrameUpdated, mCurrentFrame, startFrame, mConditionalWait ); // If the current frame is changed in the event thread, don't overwrite it.
mUpdateFrameNumber = false;
{
animationFinished = true; // end of animation
}
+ ResetValue( mCurrentLoopUpdated, mCurrentLoop, currentLoopCount, mConditionalWait );
}
}
else if( currentFrame == startFrame && !mForward ) // first frame
{
- if( loopCount < 0 || ++mCurrentLoop < loopCount ) // repeat forever or before the last loop
+ if( loopCount < 0 || ++currentLoopCount < loopCount ) // repeat forever or before the last loop
{
mForward = true;
}
{
animationFinished = true; // end of animation
}
+ ResetValue( mCurrentLoopUpdated, mCurrentLoop, currentLoopCount, mConditionalWait );
}
if( animationFinished )
mCurrentLoop = 0;
// Animation is finished
- mAnimationFinishedTrigger->Trigger();
+ if( needAnimationFinishedTrigger )
+ {
+ mAnimationFinishedTrigger->Trigger();
+ }
DALI_LOG_INFO( gVectorAnimationLogFilter, Debug::Verbose, "VectorRasterizeThread::Rasterize: Animation is finished [current = %d] [%p]\n", currentFrame, this );
}
bool mDestroyThread; ///< Whether the thread be destroyed
bool mResourceReady;
bool mCurrentFrameUpdated;
+ bool mCurrentLoopUpdated;
bool mForward;
bool mUpdateFrameNumber;
+ bool mNeedAnimationFinishedTrigger;
const Dali::LogFactoryInterface& mLogFactory; ///< The log factory
};
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 4;
-const unsigned int TOOLKIT_MICRO_VERSION = 36;
+const unsigned int TOOLKIT_MICRO_VERSION = 37;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali-toolkit
Summary: Dali 3D engine Toolkit
-Version: 1.4.36
+Version: 1.4.37
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff