X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Fcanvas-view%2Fcanvas-view-impl.cpp;h=282ebb44763bef3d246358ef7aed2ea90d589ab0;hp=0132e3cdd921ce42d2df8e6be2ef0310650826d0;hb=HEAD;hpb=0a079815dfdc1dc941a0741d8c1e390528ac80ef diff --git a/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp b/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp index 0132e3c..282ebb4 100644 --- a/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp +++ b/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2024 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. @@ -19,6 +19,7 @@ #include "canvas-view-impl.h" // EXTERNAL INCLUDES +#include #include #include #include @@ -26,7 +27,6 @@ // INTERNAL INCLUDES #include -#include #include #include #include @@ -45,6 +45,8 @@ BaseHandle Create() } // Setup properties, signals and actions using the type-registry. DALI_TYPE_REGISTRATION_BEGIN(Toolkit::CanvasView, Toolkit::Control, Create); +DALI_PROPERTY_REGISTRATION(Toolkit, CanvasView, "viewBox", VECTOR2, VIEW_BOX) +DALI_PROPERTY_REGISTRATION(Toolkit, CanvasView, "synchronousLoading", BOOLEAN, SYNCHRONOUS_LOADING) DALI_TYPE_REGISTRATION_END() } // anonymous namespace @@ -56,22 +58,17 @@ CanvasView::CanvasView(const Vector2& viewBox) mTexture(), mTextureSet(), mSize(viewBox), - mCanvasViewRasterizeThread(nullptr) + mIsSynchronous(true) { } CanvasView::~CanvasView() { - if(mCanvasViewRasterizeThread) - { - mCanvasViewRasterizeThread->RemoveTask(this); - - CanvasViewRasterizeThread::TerminateThread(mCanvasViewRasterizeThread); - } - if(Adaptor::IsAvailable()) { - Adaptor::Get().UnregisterProcessor(*this); + Dali::AsyncTaskManager::Get().RemoveTask(mRasterizingTask); + mRasterizingTask.Reset(); + Adaptor::Get().UnregisterProcessor(*this, true); } } @@ -95,12 +92,9 @@ void CanvasView::OnInitialize() // CanvasView can relayout in the OnImageReady, alternative to a signal would be to have a upcall from the Control to CanvasView Dali::Toolkit::Control handle(GetOwner()); - DevelControl::SetAccessibilityConstructor(Self(), [](Dali::Actor actor) { - return std::unique_ptr( - new DevelControl::AccessibleImpl(actor, Dali::Accessibility::Role::IMAGE)); - }); + Self().SetProperty(DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::IMAGE); - Adaptor::Get().RegisterProcessor(*this); + Adaptor::Get().RegisterProcessor(*this, true); } void CanvasView::OnRelayout(const Vector2& size, RelayoutContainer& container) @@ -126,6 +120,64 @@ void CanvasView::OnSizeSet(const Vector3& targetSize) mSize.height = targetSize.height; } +void CanvasView::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value) +{ + Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object)); + if(canvasView) + { + CanvasView& canvasViewImpl(GetImpl(canvasView)); + + switch(propertyIndex) + { + case Toolkit::CanvasView::Property::VIEW_BOX: + { + Vector2 valueVector2; + if(value.Get(valueVector2)) + { + canvasViewImpl.SetViewBox(valueVector2); + } + break; + } + case Toolkit::CanvasView::Property::SYNCHRONOUS_LOADING: + { + bool isSynchronous; + if(value.Get(isSynchronous)) + { + canvasViewImpl.SetSynchronous(isSynchronous); + } + break; + } + } + } +} + +Property::Value CanvasView::GetProperty(BaseObject* object, Property::Index propertyIndex) +{ + Property::Value value; + + Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object)); + + if(canvasView) + { + CanvasView& canvasViewImpl(GetImpl(canvasView)); + + switch(propertyIndex) + { + case Toolkit::CanvasView::Property::VIEW_BOX: + { + value = canvasViewImpl.GetViewBox(); + break; + } + case Toolkit::CanvasView::Property::SYNCHRONOUS_LOADING: + { + value = canvasViewImpl.IsSynchronous(); + break; + } + } + } + return value; +} + void CanvasView::Process(bool postProcessor) { if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged() && mSize.width > 0 && mSize.height > 0) @@ -136,62 +188,52 @@ void CanvasView::Process(bool postProcessor) void CanvasView::AddRasterizationTask() { - CanvasRendererRasterizingTaskPtr newTask = new CanvasRendererRasterizingTask(this, mCanvasRenderer); - - if(!mCanvasViewRasterizeThread) - { - mCanvasViewRasterizeThread = new CanvasViewRasterizeThread(); - mCanvasViewRasterizeThread->RasterizationCompletedSignal().Connect(this, &CanvasView::ApplyRasterizedImage); - mCanvasViewRasterizeThread->Start(); - } + mRasterizingTask = new CanvasRendererRasterizingTask(mCanvasRenderer, MakeCallback(this, &CanvasView::ApplyRasterizedImage)); if(mCanvasRenderer.Commit()) { - mCanvasViewRasterizeThread->AddTask(newTask); + if(mIsSynchronous) + { + mRasterizingTask->Process(); + ApplyRasterizedImage(mRasterizingTask); + mRasterizingTask.Reset(); // We don't need it anymore. + } + else + { + AsyncTaskManager::Get().AddTask(mRasterizingTask); + } } } -void CanvasView::ApplyRasterizedImage(PixelData rasterizedPixelData) +void CanvasView::ApplyRasterizedImage(CanvasRendererRasterizingTaskPtr task) { - if(rasterizedPixelData) + if(task->IsRasterized()) { - auto rasterizedPixelDataWidth = rasterizedPixelData.GetWidth(); - auto rasterizedPixelDataHeight = rasterizedPixelData.GetHeight(); - - if(rasterizedPixelDataWidth > 0 && rasterizedPixelDataHeight > 0) + Texture rasterizedTexture = task->GetRasterizedTexture(); + if(rasterizedTexture && rasterizedTexture.GetWidth() != 0 && rasterizedTexture.GetHeight() != 0) { - if(!mTexture || mTexture.GetWidth() != rasterizedPixelDataWidth || mTexture.GetHeight() != rasterizedPixelDataHeight) + if(!mTextureSet) { - mTexture = Texture::New(TextureType::TEXTURE_2D, Dali::Pixel::RGBA8888, rasterizedPixelDataWidth, rasterizedPixelDataHeight); - mTexture.Upload(rasterizedPixelData); + std::string fragmentShader = SHADER_CANVAS_VIEW_FRAG.data(); + DevelTexture::ApplyNativeFragmentShader(rasterizedTexture, fragmentShader); - if(!mTextureSet) - { - mTextureSet = TextureSet::New(); - Geometry geometry = VisualFactoryCache::CreateQuadGeometry(); - Shader shader = Shader::New(SHADER_CANVAS_VIEW_VERT, SHADER_CANVAS_VIEW_FRAG); - Renderer renderer = Renderer::New(geometry, shader); - renderer.SetTextures(mTextureSet); - renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true); - - Actor actor = Self(); - if(actor) - { - actor.AddRenderer(renderer); - } - } - mTextureSet.SetTexture(0, mTexture); - } - else - { - //Update texture - mTexture.Upload(rasterizedPixelData); + mTextureSet = TextureSet::New(); + Geometry geometry = VisualFactoryCache::CreateQuadGeometry(); + Shader shader = Shader::New(SHADER_CANVAS_VIEW_VERT, fragmentShader, Shader::Hint::NONE, "CANVAS_VIEW"); + Renderer renderer = Renderer::New(geometry, shader); + + renderer.SetTextures(mTextureSet); + renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true); + Self().AddRenderer(renderer); } + mTextureSet.SetTexture(0, rasterizedTexture); } } + mRasterizingTask.Reset(); // We don't need it anymore + //If there are accumulated changes to CanvasRenderer during Rasterize, Rasterize once again. - if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged()) + if(!mIsSynchronous && mCanvasRenderer && mCanvasRenderer.IsCanvasChanged()) { AddRasterizationTask(); } @@ -205,6 +247,53 @@ bool CanvasView::AddDrawable(Dali::CanvasRenderer::Drawable& drawable) } return false; } + +bool CanvasView::RemoveDrawable(Dali::CanvasRenderer::Drawable& drawable) +{ + if(mCanvasRenderer && mCanvasRenderer.RemoveDrawable(drawable)) + { + return true; + } + return false; +} + +bool CanvasView::RemoveAllDrawables() +{ + if(mCanvasRenderer && mCanvasRenderer.RemoveAllDrawables()) + { + return true; + } + return false; +} + +bool CanvasView::SetViewBox(const Vector2& viewBox) +{ + if(mCanvasRenderer && mCanvasRenderer.SetViewBox(viewBox)) + { + return true; + } + return false; +} + +const Vector2& CanvasView::GetViewBox() +{ + if(mCanvasRenderer) + { + return mCanvasRenderer.GetViewBox(); + } + return Vector2::ZERO; +} + +void CanvasView::SetSynchronous(const bool isSynchronous) +{ + mIsSynchronous = isSynchronous; +} + +const bool CanvasView::IsSynchronous() +{ + return mIsSynchronous; +} + } // namespace Internal } // namespace Toolkit } // namespace Dali