The canvas view defaults to SYNCHRONOUS_LOADING.

A crash occurs when multiple CanvasViews are operated async.
So, we change it to operate synchronously by default.

The problem of async operation when using a multi-canvas view should be resolved later.

Change-Id: I9bb4c8165b69ebdd93753211214fcadf06a3f456

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-CanvasView.cpp b/automated-tests/src/dali-toolkit/utc-Dali-CanvasView.cpp
index 1a9c1db..6d29bf5 100644 (file)
--- a/automated-tests/src/dali-toolkit/utc-Dali-CanvasView.cpp
+++ b/automated-tests/src/dali-toolkit/utc-Dali-CanvasView.cpp
@@ -402,6 +402,33 @@ int UtcDaliCanvasViewSetSizeAndAddDrawable(void)
   application.SendNotification();
   application.Render();
 
+  END_TEST;
+}
+
+int UtcDaliCanvasViewSetSizeAndAddDrawableAsync(void)
+{
+  ToolkitTestApplication application;
+
+  CanvasView canvasView = CanvasView::New(Vector2(100, 100));
+  DALI_TEST_CHECK(canvasView);
+
+  application.GetScene().Add(canvasView);
+
+  canvasView.SetProperty(Toolkit::CanvasView::Property::SYNCHRONOUS_LOADING, false);
+  canvasView.SetProperty(Actor::Property::SIZE, Vector2(300, 300));
+
+  application.SendNotification();
+  application.Render();
+
+  Dali::CanvasRenderer::Shape shape = Dali::CanvasRenderer::Shape::New();
+
+  shape.AddRect(Rect<float>(10, 10, 10, 10), Vector2(0, 0));
+
+  canvasView.AddDrawable(shape);
+
+  application.SendNotification();
+  application.Render();
+
   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
 
   application.SendNotification();
@@ -448,3 +475,31 @@ int UtcDaliCanvasViewViewBoxN(void)
 
   END_TEST;
 }
+
+int UtcDaliCanvasViewSychronousLoading(void)
+{
+  ToolkitTestApplication application;
+
+  CanvasView canvasView = CanvasView::New(Vector2(300, 300));
+  DALI_TEST_CHECK(canvasView);
+
+  application.GetScene().Add(canvasView);
+
+  canvasView.SetProperty(Actor::Property::SIZE, Vector2(300, 300));
+
+  application.SendNotification();
+  application.Render();
+
+  bool isSynchronous = canvasView.GetProperty(Toolkit::CanvasView::Property::SYNCHRONOUS_LOADING).Get<bool>();
+  DALI_TEST_EQUALS(isSynchronous, true, TEST_LOCATION);
+
+  canvasView.SetProperty(Toolkit::CanvasView::Property::SYNCHRONOUS_LOADING, false);
+
+  application.SendNotification();
+  application.Render();
+
+  isSynchronous = canvasView.GetProperty(Toolkit::CanvasView::Property::SYNCHRONOUS_LOADING).Get<bool>();
+  DALI_TEST_EQUALS(isSynchronous, false, TEST_LOCATION);
+
+  END_TEST;
+}

diff --git a/dali-toolkit/devel-api/controls/canvas-view/canvas-view.h b/dali-toolkit/devel-api/controls/canvas-view/canvas-view.h
index 390cabd..026d3fa 100644 (file)
--- a/dali-toolkit/devel-api/controls/canvas-view/canvas-view.h
+++ b/dali-toolkit/devel-api/controls/canvas-view/canvas-view.h
@@ -83,6 +83,12 @@ public:
        * @details Name "viewBox", type Property::VECTOR2.
        */
       VIEW_BOX = PROPERTY_START_INDEX,
+
+      /**
+       * @brief Whether to load the canvas synchronously.
+       * @details Name "synchronousLoading", type Property::BOOLEAN.
+       */
+      SYNCHRONOUS_LOADING,
     };
   };
 public:

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 bc31ae5..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
@@ -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
 
@@ -56,7 +57,8 @@ CanvasView::CanvasView(const Vector2& viewBox)
   mCanvasRenderer(CanvasRenderer::New(viewBox)),
   mTexture(),
   mTextureSet(),
-  mSize(viewBox)
+  mSize(viewBox),
+  mIsSynchronous(true)
 {
 }
 
@@ -136,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;
+      }
     }
   }
 }
@@ -157,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;
@@ -176,7 +192,16 @@ void CanvasView::AddRasterizationTask()
 
   if(mCanvasRenderer.Commit())
   {
-    AsyncTaskManager::Get().AddTask(mRasterizingTask);
+    if(mIsSynchronous)
+    {
+      mRasterizingTask->Process();
+      ApplyRasterizedImage(mRasterizingTask);
+      mRasterizingTask.Reset(); // We don't need it anymore.
+    }
+    else
+    {
+      AsyncTaskManager::Get().AddTask(mRasterizingTask);
+    }
   }
 }
 
@@ -208,7 +233,7 @@ void CanvasView::ApplyRasterizedImage(CanvasRendererRasterizingTaskPtr task)
   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();
   }
@@ -258,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

diff --git a/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.h b/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.h
index 52ea231..6f0fa11 100644 (file)
--- a/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.h
+++ b/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.h
@@ -120,6 +120,20 @@ private: // From Control
   const Vector2& GetViewBox();
 
   /**
+   * @brief Set to load the canvas synchronously.
+   *
+   * @param isSynchronous The synchronous
+   */
+  void SetSynchronous(const bool isSynchronous);
+
+  /**
+   * @brief Whether to load the canvas synchronously.
+   *
+   * @return Returns true if synchronously.
+   */
+  const bool IsSynchronous();
+
+  /**
    * @bried Rasterize the canvas, and add it to the view.
    *
    * @param[in] size The target size of the canvas view rasterization.
@@ -158,6 +172,7 @@ private:
   TextureSet                       mTextureSet;
   Vector2                          mSize;
   CanvasRendererRasterizingTaskPtr mRasterizingTask;
+  bool                             mIsSynchronous;
 };
 
 } // namespace Internal