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=6ec6fc996e0e67c910bf5622b63b631ba1a28492;hp=342784ad7ba4ec3905d9f47954188ae450fc58ab;hb=70fdb1a1e8e2660c383079ae49bc94fbe14943d1;hpb=dacbd89dae18b6e32bf97f3d26d379eee2c9013b

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 342784a..6ec6fc9 100644
--- a/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp
+++ b/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp
@@ -23,10 +23,11 @@
 #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/canvas-view/canvas-view.h>
 #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>
@@ -45,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_TYPE_REGISTRATION_END()
 } // anonymous namespace
 
@@ -54,12 +56,21 @@ CanvasView::CanvasView(const Vector2& viewBox)
 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
   mCanvasRenderer(CanvasRenderer::New(viewBox)),
   mTexture(),
-  mChanged(false)
+  mTextureSet(),
+  mSize(viewBox),
+  mCanvasViewRasterizeThread(nullptr)
 {
 }
 
 CanvasView::~CanvasView()
 {
+  if(mCanvasViewRasterizeThread)
+  {
+    mCanvasViewRasterizeThread->RemoveTask(this);
+
+    CanvasViewRasterizeThread::TerminateThread(mCanvasViewRasterizeThread);
+  }
+
   if(Adaptor::IsAvailable())
   {
     Adaptor::Get().UnregisterProcessor(*this);
@@ -88,23 +99,20 @@ void CanvasView::OnInitialize()
 
   DevelControl::SetAccessibilityConstructor(Self(), [](Dali::Actor actor) {
     return std::unique_ptr<Dali::Accessibility::Accessible>(
-      new DevelControl::AccessibleImpl(actor, Dali::Accessibility::Role::IMAGE));
+      new DevelControl::ControlAccessible(actor, Dali::Accessibility::Role::IMAGE));
   });
 
-  Self().SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
-
-  Adaptor::Get().RegisterProcessor(*this);
+  Adaptor::Get().RegisterProcessor(*this, true);
 }
 
 void CanvasView::OnRelayout(const Vector2& size, RelayoutContainer& container)
 {
   if(!mCanvasRenderer ||
-     mCanvasRenderer.GetSize() == size ||
      !mCanvasRenderer.SetSize(size))
   {
     return;
   }
-  mChanged = true;
+  mSize = size;
 }
 
 void CanvasView::OnSizeSet(const Vector3& targetSize)
@@ -112,57 +120,108 @@ void CanvasView::OnSizeSet(const Vector3& targetSize)
   Control::OnSizeSet(targetSize);
 
   if(!mCanvasRenderer ||
-     mCanvasRenderer.GetSize() == Vector2(targetSize) ||
      !mCanvasRenderer.SetSize(Vector2(targetSize)))
   {
     return;
   }
-  mChanged = true;
+  mSize.width  = targetSize.width;
+  mSize.height = targetSize.height;
 }
 
-void CanvasView::Process(bool postProcessor)
+void CanvasView::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
 {
-  if(!mCanvasRenderer)
+  Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
+  if(canvasView)
   {
-    return;
+    CanvasView& canvasViewImpl(GetImpl(canvasView));
+
+    switch(propertyIndex)
+    {
+      case Toolkit::CanvasView::Property::VIEW_BOX:
+      {
+        Vector2 valueVector2;
+        if(value.Get(valueVector2))
+        {
+          canvasViewImpl.SetViewBox(valueVector2);
+        }
+        break;
+      }
+    }
   }
-  Commit();
 }
 
-void CanvasView::Commit()
+Property::Value CanvasView::GetProperty(BaseObject* object, Property::Index propertyIndex)
 {
-  if(mCanvasRenderer && mCanvasRenderer.Commit())
+  Property::Value value;
+
+  Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
+
+  if(canvasView)
   {
-    Devel::PixelBuffer pixbuf = mCanvasRenderer.GetPixelBuffer();
-    auto               width  = pixbuf.GetWidth();
-    auto               height = pixbuf.GetHeight();
+    CanvasView& canvasViewImpl(GetImpl(canvasView));
 
-    Dali::PixelData pixelData = Devel::PixelBuffer::Convert(pixbuf);
-    if(!pixelData)
+    switch(propertyIndex)
     {
-      return;
+      case Toolkit::CanvasView::Property::VIEW_BOX:
+      {
+        value = canvasViewImpl.GetViewBox();
+        break;
+      }
     }
+  }
+  return value;
+}
 
-    if(!mTexture || mChanged)
+void CanvasView::Process(bool postProcessor)
+{
+  if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged() && mSize.width > 0 && mSize.height > 0)
+  {
+    AddRasterizationTask();
+  }
+}
+
+void CanvasView::AddRasterizationTask()
+{
+  CanvasRendererRasterizingTaskPtr newTask = new CanvasRendererRasterizingTask(this, mCanvasRenderer);
+
+  if(!mCanvasViewRasterizeThread)
+  {
+    mCanvasViewRasterizeThread = new CanvasViewRasterizeThread();
+    mCanvasViewRasterizeThread->RasterizationCompletedSignal().Connect(this, &CanvasView::ApplyRasterizedImage);
+    mCanvasViewRasterizeThread->Start();
+  }
+
+  if(mCanvasRenderer.Commit())
+  {
+    mCanvasViewRasterizeThread->AddTask(newTask);
+  }
+}
+
+void CanvasView::ApplyRasterizedImage(Texture rasterizedTexture)
+{
+  if (rasterizedTexture && rasterizedTexture.GetWidth() != 0 && rasterizedTexture.GetHeight() != 0)
+  {
+    if(!mTextureSet)
     {
-      mTexture = Texture::New(TextureType::TEXTURE_2D, Dali::Pixel::RGBA8888, width, height);
-      mTexture.Upload(pixelData);
-      TextureSet textureSet = TextureSet::New();
-      textureSet.SetTexture(0, mTexture);
+      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, SHADER_CANVAS_VIEW_FRAG);
+      Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, fragmentShader);
       Renderer renderer = Renderer::New(geometry, shader);
-      renderer.SetTextures(textureSet);
-      renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
 
+      renderer.SetTextures(mTextureSet);
+      renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
       Self().AddRenderer(renderer);
-      mChanged = false;
-    }
-    else
-    {
-      //Update texture
-      mTexture.Upload(pixelData);
     }
+    mTextureSet.SetTexture(0, rasterizedTexture);
+  }
+
+  //If there are accumulated changes to CanvasRenderer during Rasterize, Rasterize once again.
+  if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged())
+  {
+    AddRasterizationTask();
   }
 }
 
@@ -174,6 +233,42 @@ 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;
+}
 } // namespace Internal
 } // namespace Toolkit
 } // namespace Dali