#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/devel-api/image-loader/texture-manager.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
namespace Dali
{
${toolkit_src_dir}/visuals/animated-image/rolling-image-cache.cpp
${toolkit_src_dir}/visuals/animated-image/rolling-animated-image-cache.cpp
${toolkit_src_dir}/visuals/animated-vector-image/animated-vector-image-visual.cpp
+ ${toolkit_src_dir}/visuals/animated-vector-image/vector-animation-manager.cpp
${toolkit_src_dir}/visuals/animated-vector-image/vector-animation-task.cpp
${toolkit_src_dir}/visuals/animated-vector-image/vector-animation-thread.cpp
${toolkit_src_dir}/visuals/animated-vector-image/vector-rasterize-thread.cpp
#include <dali-toolkit/internal/visuals/visual-url.h>
#include <dali-toolkit/internal/visuals/animated-image/image-cache.h>
#include <dali-toolkit/devel-api/visuals/animated-image-visual-actions-devel.h>
+#include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
namespace Dali
{
#include <dali/devel-api/common/stage.h>
#include <dali/devel-api/rendering/renderer-devel.h>
#include <dali/devel-api/adaptor-framework/window-devel.h>
-#include <dali/integration-api/adaptor-framework/adaptor.h>
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
+#include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
namespace Dali
{
mVisualScale( Vector2::ONE ),
mPlacementActor(),
mPlayState( DevelImageVisual::PlayState::STOPPED ),
- mRendererAdded( false ),
- mRasterizationTriggered( false )
+ mEventCallback( nullptr ),
+ mRendererAdded( false )
{
// the rasterized image is with pre-multiplied alpha format
mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA;
AnimatedVectorImageVisual::~AnimatedVectorImageVisual()
{
- if( mRasterizationTriggered && Adaptor::IsAvailable() )
+ if( mEventCallback )
{
- Adaptor::Get().UnregisterProcessor( *this );
+ mFactoryCache.GetVectorAnimationManager().UnregisterEventCallback( mEventCallback );
}
// Finalize animation task and disconnect the signal in the main thread
TriggerVectorRasterization();
}
-void AnimatedVectorImageVisual::Process()
-{
- SendAnimationData();
-
- mRasterizationTriggered = false;
-
- Adaptor::Get().UnregisterProcessor( *this );
-}
-
void AnimatedVectorImageVisual::OnUploadCompleted()
{
// If weak handle is holding a placement actor, it is the time to add the renderer to actor.
void AnimatedVectorImageVisual::TriggerVectorRasterization()
{
- if( !mRasterizationTriggered )
+ if( !mEventCallback )
{
+ mEventCallback = MakeCallback( this, &AnimatedVectorImageVisual::OnProcessEvents );
+ mFactoryCache.GetVectorAnimationManager().RegisterEventCallback( mEventCallback );
Stage::GetCurrent().KeepRendering( 0.0f ); // Trigger event processing
-
- Adaptor::Get().RegisterProcessor( *this );
- mRasterizationTriggered = true;
}
}
}
}
+void AnimatedVectorImageVisual::OnProcessEvents()
+{
+ SendAnimationData();
+
+ mEventCallback = nullptr; // The callback will be deleted in the VectorAnimationManager
+}
+
} // namespace Internal
} // namespace Toolkit
#include <dali/public-api/object/property-notification.h>
#include <dali/public-api/adaptor-framework/window.h>
#include <dali/devel-api/actors/actor-devel.h>
-#include <dali/integration-api/processor-interface.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/visual-base-impl.h>
* | url | STRING |
*
*/
-class AnimatedVectorImageVisual: public Visual::Base, public ConnectionTracker, public Integration::Processor
+class AnimatedVectorImageVisual: public Visual::Base, public ConnectionTracker
{
public:
*/
void OnDoAction( const Property::Index actionId, const Property::Value& attributes ) override;
-protected: // Implementation of Processor
-
- /**
- * @copydoc Dali::Integration::Processor::Process()
- */
- void Process() override;
-
private:
/**
*/
void OnWindowVisibilityChanged( Window window, bool visible );
+ /**
+ * @brief Callback when the event is processed.
+ */
+ void OnProcessEvents();
+
// Undefined
AnimatedVectorImageVisual( const AnimatedVectorImageVisual& visual ) = delete;
Vector2 mVisualScale;
WeakHandle< Actor > mPlacementActor;
DevelImageVisual::PlayState::Type mPlayState;
+ CallbackBase* mEventCallback; // Not owned
bool mRendererAdded;
- bool mRasterizationTriggered;
};
} // namespace Internal
--- /dev/null
+/*
+ * Copyright (c) 2020 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 <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal
+{
+
+namespace
+{
+
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_VECTOR_ANIMATION" );
+#endif
+
+} // unnamed namespace
+
+VectorAnimationManager::VectorAnimationManager()
+: mEventCallbacks(),
+ mVectorAnimationThread( nullptr ),
+ mProcessorRegistered( false )
+{
+}
+
+VectorAnimationManager::~VectorAnimationManager()
+{
+ for( auto&& iter : mEventCallbacks )
+ {
+ delete iter;
+ }
+ mEventCallbacks.clear();
+
+ if( mProcessorRegistered )
+ {
+ Adaptor::Get().UnregisterProcessor( *this );
+ }
+}
+
+VectorAnimationThread& VectorAnimationManager::GetVectorAnimationThread()
+{
+ if( !mVectorAnimationThread )
+ {
+ mVectorAnimationThread = std::unique_ptr< VectorAnimationThread >( new VectorAnimationThread() );
+ mVectorAnimationThread->Start();
+ }
+ return *mVectorAnimationThread;
+}
+
+void VectorAnimationManager::RegisterEventCallback( CallbackBase* callback )
+{
+ mEventCallbacks.push_back( callback );
+
+ if( !mProcessorRegistered )
+ {
+ Adaptor::Get().RegisterProcessor( *this );
+ mProcessorRegistered = true;
+ }
+}
+
+void VectorAnimationManager::UnregisterEventCallback( CallbackBase* callback )
+{
+ auto iter = std::find( mEventCallbacks.begin(), mEventCallbacks.end(), callback );
+ if( iter != mEventCallbacks.end() )
+ {
+ mEventCallbacks.erase( iter );
+
+ if( mEventCallbacks.empty() )
+ {
+ if( Adaptor::IsAvailable() )
+ {
+ Adaptor::Get().UnregisterProcessor( *this );
+ mProcessorRegistered = false;
+ }
+ }
+ }
+}
+
+void VectorAnimationManager::Process()
+{
+ for( auto&& iter : mEventCallbacks )
+ {
+ CallbackBase::Execute( *iter );
+ delete iter;
+ }
+ mEventCallbacks.clear();
+
+ Adaptor::Get().UnregisterProcessor( *this );
+ mProcessorRegistered = false;
+}
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_TOOLKIT_INTERNAL_VECTOR_ANIMATION_MANAGER_H
+#define DALI_TOOLKIT_INTERNAL_VECTOR_ANIMATION_MANAGER_H
+
+/*
+ * Copyright (c) 2020 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.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/signals/callback.h>
+#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/integration-api/processor-interface.h>
+#include <memory>
+
+// INTERNAL INCLUDES
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal
+{
+
+class VectorAnimationThread;
+
+/**
+ * @brief Vector animation manager
+ */
+class VectorAnimationManager: public Integration::Processor
+{
+public:
+
+ /**
+ * @brief Constructor.
+ */
+ VectorAnimationManager();
+
+ /**
+ * @brief Destructor.
+ */
+ virtual ~VectorAnimationManager();
+
+ /**
+ * Get the vector animation thread.
+ * @return A raw pointer pointing to the vector animation thread.
+ */
+ VectorAnimationThread& GetVectorAnimationThread();
+
+ /**
+ * @brief Register a callback.
+ *
+ * @param callback The callback to register
+ * @note Ownership of the callback is passed onto this class.
+ */
+ void RegisterEventCallback( CallbackBase* callback );
+
+ /**
+ * @brief Unregister a previously registered callback
+ *
+ * @param callback The callback to unregister
+ */
+ void UnregisterEventCallback( CallbackBase* callback );
+
+protected: // Implementation of Processor
+
+ /**
+ * @copydoc Dali::Integration::Processor::Process()
+ */
+ void Process() override;
+
+private:
+
+ // Undefined
+ VectorAnimationManager( const VectorAnimationManager& manager ) = delete;
+
+ // Undefined
+ VectorAnimationManager& operator=( const VectorAnimationManager& manager ) = delete;
+
+private:
+
+ std::vector< CallbackBase* > mEventCallbacks;
+ std::unique_ptr< VectorAnimationThread > mVectorAnimationThread;
+ bool mProcessorRegistered;
+};
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // DALI_TOOLKIT_INTERNAL_VECTOR_ANIMATION_MANAGER_H
// INTERNAL INCLUDES
#include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
#include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.h>
+#include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
namespace Dali
{
: mUrl( url ),
mVectorRenderer(),
mAnimationData(),
- mVectorAnimationThread( factoryCache.GetVectorAnimationThread() ),
+ mVectorAnimationThread( factoryCache.GetVectorAnimationManager().GetVectorAnimationThread() ),
mConditionalWait(),
mAnimationFinishedTrigger(),
mPlayState( PlayState::STOPPED ),
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
#include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
-#include <dali/devel-api/adaptor-framework/file-loader.h>
+#include <dali-toolkit/public-api/visuals/image-visual-properties.h>
// EXTERNAL INCLUDES
#include <dali/devel-api/common/stage.h>
+#include <dali/devel-api/adaptor-framework/file-loader.h>
#include <dali/integration-api/debug.h>
namespace Dali
map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl() );
map.Insert( Toolkit::ImageVisual::Property::ATLASING, mAttemptAtlasing );
}
+ map.Insert( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, IsSynchronousLoadingRequired() );
}
void SvgVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
// which is ok, because they have a different key value range.
map.Insert( Toolkit::Visual::Property::MIX_COLOR, mImpl->mMixColor ); // vec4
map.Insert( Toolkit::Visual::Property::OPACITY, mImpl->mMixColor.a );
- map.Insert( Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, IsSynchronousLoadingRequired() );
auto fittingModeString = Scripting::GetLinearEnumerationName< FittingMode >(
mImpl->mFittingMode, VISUAL_FITTING_MODE_TABLE, VISUAL_FITTING_MODE_TABLE_COUNT );
#include <dali-toolkit/internal/visuals/color/color-visual.h>
#include <dali-toolkit/internal/visuals/svg/svg-visual.h>
#include <dali-toolkit/internal/visuals/image-atlas-manager.h>
+#include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
namespace Dali
{
VisualFactoryCache::VisualFactoryCache( bool preMultiplyOnLoad )
: mSvgRasterizeThread( NULL ),
- mVectorAnimationThread(),
+ mVectorAnimationManager(),
mBrokenImageUrl(""),
mPreMultiplyOnLoad( preMultiplyOnLoad )
{
return mSvgRasterizeThread;
}
-VectorAnimationThread& VisualFactoryCache::GetVectorAnimationThread()
+VectorAnimationManager& VisualFactoryCache::GetVectorAnimationManager()
{
- if( !mVectorAnimationThread )
+ if( !mVectorAnimationManager )
{
- mVectorAnimationThread = std::unique_ptr< VectorAnimationThread >( new VectorAnimationThread() );
- mVectorAnimationThread->Start();
+ mVectorAnimationManager = std::unique_ptr< VectorAnimationManager >( new VectorAnimationManager() );
}
- return *mVectorAnimationThread;
+ return *mVectorAnimationManager;
}
void VisualFactoryCache::ApplyRasterizedSVGToSampler()
#include <dali-toolkit/internal/visuals/npatch-loader.h>
#include <dali-toolkit/internal/visuals/svg/svg-rasterize-thread.h>
#include <dali-toolkit/internal/visuals/texture-manager-impl.h>
-#include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-thread.h>
namespace Dali
{
class ImageAtlasManager;
class NPatchLoader;
class TextureManager;
+class VectorAnimationManager;
typedef IntrusivePtr<ImageAtlasManager> ImageAtlasManagerPtr;
SvgRasterizeThread* GetSVGRasterizationThread();
/**
- * Get the vector animation thread.
- * @return A raw pointer pointing to the vector animation thread.
+ * Get the vector animation manager.
+ * @return A reference to the vector animation manager.
*/
- VectorAnimationThread& GetVectorAnimationThread();
+ VectorAnimationManager& GetVectorAnimationManager();
private: // for svg rasterization thread
Geometry mGeometry[GEOMETRY_TYPE_MAX+1];
Shader mShader[SHADER_TYPE_MAX+1];
- ImageAtlasManagerPtr mAtlasManager;
- TextureManager mTextureManager;
- NPatchLoader mNPatchLoader;
- Texture mBrokenImageTexture;
- SvgRasterizeThread* mSvgRasterizeThread;
- std::unique_ptr< VectorAnimationThread > mVectorAnimationThread;
- std::string mBrokenImageUrl;
- bool mPreMultiplyOnLoad;
+ ImageAtlasManagerPtr mAtlasManager;
+ TextureManager mTextureManager;
+ NPatchLoader mNPatchLoader;
+ Texture mBrokenImageTexture;
+ SvgRasterizeThread* mSvgRasterizeThread;
+ std::unique_ptr< VectorAnimationManager > mVectorAnimationManager;
+ std::string mBrokenImageUrl;
+ bool mPreMultiplyOnLoad;
};
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / commitdiff