[dali_2.3.21] Merge branch 'devel/master'

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / canvas-view / canvas-view-impl.cpp

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 a87c040..282ebb4 100644 (file)
--- 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 <dali/devel-api/rendering/texture-devel.h>
 #include <dali/devel-api/scripting/scripting.h>
 #include <dali/integration-api/adaptor-framework/adaptor.h>
 #include <dali/public-api/object/type-registry-helper.h>
@@ -26,7 +27,6 @@
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/controls/control-devel.h>
-#include <dali-toolkit/internal/controls/canvas-view/canvas-view-rasterize-thread.h>
 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
 #include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
@@ -46,6 +46,7 @@ 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
 
@@ -57,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);
   }
 }
 
@@ -96,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<Dali::Accessibility::Accessible>(
-      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)
@@ -145,6 +138,15 @@ void CanvasView::SetProperty(BaseObject* object, Property::Index propertyIndex,
         }
         break;
       }
+      case Toolkit::CanvasView::Property::SYNCHRONOUS_LOADING:
+      {
+        bool isSynchronous;
+        if(value.Get(isSynchronous))
+        {
+          canvasViewImpl.SetSynchronous(isSynchronous);
+        }
+        break;
+      }
     }
   }
 }
@@ -166,6 +168,11 @@ Property::Value CanvasView::GetProperty(BaseObject* object, Property::Index prop
         value = canvasViewImpl.GetViewBox();
         break;
       }
+      case Toolkit::CanvasView::Property::SYNCHRONOUS_LOADING:
+      {
+        value = canvasViewImpl.IsSynchronous();
+        break;
+      }
     }
   }
   return value;
@@ -181,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();
   }
@@ -251,6 +248,24 @@ 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))
@@ -268,6 +283,17 @@ const Vector2& CanvasView::GetViewBox()
   }
   return Vector2::ZERO;
 }
+
+void CanvasView::SetSynchronous(const bool isSynchronous)
+{
+  mIsSynchronous = isSynchronous;
+}
+
+const bool CanvasView::IsSynchronous()
+{
+  return mIsSynchronous;
+}
+
 } // namespace Internal
 } // namespace Toolkit
 } // namespace Dali