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=6ec6fc996e0e67c910bf5622b63b631ba1a28492;hb=HEAD;hpb=74e9803017d7ca8f0b57046c5da107b9a7a49205

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 6ec6fc9..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,15 +19,14 @@
 #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>
 #include <dali/public-api/object/type-registry.h>
-#include <dali/devel-api/rendering/texture-devel.h>
 
 // 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>
@@ -47,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
 
@@ -58,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);
   }
 }
 
@@ -97,10 +92,7 @@ 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::ControlAccessible(actor, Dali::Accessibility::Role::IMAGE));
-  });
+  Self().SetProperty(DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::IMAGE);
 
   Adaptor::Get().RegisterProcessor(*this, true);
 }
@@ -146,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;
+      }
     }
   }
 }
@@ -167,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;
@@ -182,44 +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(Texture rasterizedTexture)
+void CanvasView::ApplyRasterizedImage(CanvasRendererRasterizingTaskPtr task)
 {
-  if (rasterizedTexture && rasterizedTexture.GetWidth() != 0 && rasterizedTexture.GetHeight() != 0)
+  if(task->IsRasterized())
   {
-    if(!mTextureSet)
+    Texture rasterizedTexture = task->GetRasterizedTexture();
+    if(rasterizedTexture && rasterizedTexture.GetWidth() != 0 && rasterizedTexture.GetHeight() != 0)
     {
-      std::string fragmentShader = SHADER_CANVAS_VIEW_FRAG.data();
-      DevelTexture::ApplyNativeFragmentShader(rasterizedTexture, fragmentShader);
+      if(!mTextureSet)
+      {
+        std::string fragmentShader = SHADER_CANVAS_VIEW_FRAG.data();
+        DevelTexture::ApplyNativeFragmentShader(rasterizedTexture, fragmentShader);
 
-      mTextureSet       = TextureSet::New();
-      Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
-      Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, fragmentShader);
-      Renderer renderer = Renderer::New(geometry, shader);
+        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);
+        renderer.SetTextures(mTextureSet);
+        renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
+        Self().AddRenderer(renderer);
+      }
+      mTextureSet.SetTexture(0, rasterizedTexture);
     }
-    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();
   }
@@ -269,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