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

Change-Id: I813095b4dc7fd2ae05efa5a9fcb21385f71dc090

diff --git a/build/tizen/Makefile.am b/build/tizen/Makefile.am
index 5d8722a..1f61da8 100644 (file)
--- a/build/tizen/Makefile.am
+++ b/build/tizen/Makefile.am
@@ -114,8 +114,8 @@ endif
 
 if MOBILE_PROFILE
 LIBDALI_CSHARP_BINDER_LA_CXXFLAGS += -DTIZEN_BUILD \
-                            $(DALIEXTENSION_CFLAGS)
-LIBDALI_CSHARP_BINDER_LA_LIBADD += $(DALIEXTENSION_LIBS)
+                            $(DALIRIVEVIEW_CFLAGS)
+LIBDALI_CSHARP_BINDER_LA_LIBADD += $(DALIRIVEVIEW_LIBS)
 endif
 
 if WEARABLE_PROFILE
@@ -128,20 +128,20 @@ LIBDALI_CSHARP_BINDER_LA_CXXFLAGS += -DTIZEN_BUILD \
 LIBDALI_CSHARP_BINDER_LA_LIBADD += $(DALIWATCHHOLDERBASE_LIBS)
 
 LIBDALI_CSHARP_BINDER_LA_CXXFLAGS += -DTIZEN_BUILD \
-                            $(DALIEXTENSION_CFLAGS)
-LIBDALI_CSHARP_BINDER_LA_LIBADD += $(DALIEXTENSION_LIBS)
+                            $(DALIRIVEVIEW_CFLAGS)
+LIBDALI_CSHARP_BINDER_LA_LIBADD += $(DALIRIVEVIEW_LIBS)
 endif
 
 if TV_PROFILE
 LIBDALI_CSHARP_BINDER_LA_CXXFLAGS += -DTIZEN_BUILD \
-                            $(DALIEXTENSION_CFLAGS)
-LIBDALI_CSHARP_BINDER_LA_LIBADD += $(DALIEXTENSION_LIBS)
+                            $(DALIRIVEVIEW_CFLAGS)
+LIBDALI_CSHARP_BINDER_LA_LIBADD += $(DALIRIVEVIEW_LIBS)
 endif
 
 if COMMON_PROFILE
 LIBDALI_CSHARP_BINDER_LA_CXXFLAGS += -DTIZEN_BUILD \
-                            $(DALIEXTENSION_CFLAGS)
-LIBDALI_CSHARP_BINDER_LA_LIBADD += $(DALIEXTENSION_LIBS)
+                            $(DALIRIVEVIEW_CFLAGS)
+LIBDALI_CSHARP_BINDER_LA_LIBADD += $(DALIRIVEVIEW_LIBS)
 endif
 
 lib_LTLIBRARIES = libdali2-csharp-binder.la

diff --git a/build/tizen/configure.ac b/build/tizen/configure.ac
index 0ebba0a..40102f0 100644 (file)
--- a/build/tizen/configure.ac
+++ b/build/tizen/configure.ac
@@ -74,7 +74,7 @@ PKG_CHECK_MODULES(DALITOOLKIT, dali2-toolkit)
 
 if test "x$enable_profile" = "xMOBILE" -o "x$enable_profile" = "xWEARABLE" -o "x$enable_profile" = "xTV" -o "x$enable_profile" = "xIVI" -o "x$enable_profile" = "xCOMMON"; then
   PKG_CHECK_MODULES(DALIWIDGET, widget_viewer_dali)
-  PKG_CHECK_MODULES(DALIEXTENSION, dali2-extension)
+  PKG_CHECK_MODULES(DALIRIVEVIEW, dali2-extension-rive-animation-view)
   if test x$enable_ecore_wayland2 = xyes; then
     PKG_CHECK_MODULES(ECORE_WL2, ecore-wl2)
   else

diff --git a/dali-csharp-binder/file.list b/dali-csharp-binder/file.list
index 294aa06..bb36484 100755 (executable)
--- a/dali-csharp-binder/file.list
+++ b/dali-csharp-binder/file.list
@@ -12,6 +12,7 @@ dali_csharp_binder_common_src_files = \
   ${dali_csharp_binder_dir}/src/constraint.cpp \
   ${dali_csharp_binder_dir}/src/keyboard_focus_manager_wrap.cpp \
   ${dali_csharp_binder_dir}/src/devel-property-wrap.cpp \
+  ${dali_csharp_binder_dir}/src/encoded-image-buffer.cpp \
   ${dali_csharp_binder_dir}/src/version-check.cpp \
   ${dali_csharp_binder_dir}/src/processor-controller.cpp \
   ${dali_csharp_binder_dir}/src/fade.cpp \
@@ -41,7 +42,9 @@ dali_csharp_binder_common_src_files = \
   ${dali_csharp_binder_dir}/src/control-devel_wrap.cpp \
   ${dali_csharp_binder_dir}/src/signal_wrap.cpp \
   ${dali_csharp_binder_dir}/src/accessible-impl-nui.cpp \
-  ${dali_csharp_binder_dir}/src/rotation.cpp
+  ${dali_csharp_binder_dir}/src/rotation.cpp \
+  ${dali_csharp_binder_dir}/src/input-options.cpp \
+  ${dali_csharp_binder_dir}/src/native-image-queue.cpp
 
 # added for key grab binding only for tizen
 # module: csharp-binder, backend: mobile,tv,ivi,watch

diff --git a/dali-csharp-binder/src/canvas-view.cpp b/dali-csharp-binder/src/canvas-view.cpp
index 37a7f10..a7fef94 100644 (file)
--- a/dali-csharp-binder/src/canvas-view.cpp
+++ b/dali-csharp-binder/src/canvas-view.cpp
@@ -34,62 +34,68 @@ using namespace Dali::Toolkit;
 extern "C" {
 #endif
 
-SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_CanvasView_New__SWIG_0(char *jarg1) {
-  void *jresult;
-  Dali::ImageDimensions arg1;
-  Dali::ImageDimensions *argp1;
+SWIGEXPORT void *SWIGSTDCALL
+CSharp_Dali_CanvasView_New__SWIG_0(char *pViewBox) {
+  Dali::ImageDimensions viewBox;
   Dali::Toolkit::CanvasView result;
 
-  argp1 = (Dali::ImageDimensions *)jarg1;
-  if (!argp1) {
+  if (!pViewBox) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::ImageDimensions", 0);
     return 0;
   }
-  arg1 = *argp1;
+  viewBox = *(Dali::ImageDimensions *)pViewBox;
   {
-    const Vector2 viewBox(arg1.GetWidth(), arg1.GetHeight());
     try {
-      result = Dali::Toolkit::CanvasView::New(viewBox);
+      result = Dali::Toolkit::CanvasView::New(
+          Vector2(viewBox.GetWidth(), viewBox.GetHeight()));
     }
     CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult =
-      new Dali::Toolkit::CanvasView((const Dali::Toolkit::CanvasView &)result);
+  return new Dali::Toolkit::CanvasView(
+      (const Dali::Toolkit::CanvasView &)result);
+}
+
+SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_CanvasView_New__SWIG_1() {
+  Dali::Toolkit::CanvasView result;
+
+  {
+    try {
+      result = Dali::Toolkit::CanvasView::New();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
 
-  return jresult;
+  return new Dali::Toolkit::CanvasView(
+      (const Dali::Toolkit::CanvasView &)result);
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CanvasView_AddDrawable(char *jarg1,
-                                                               char *jarg2) {
-  Dali::Toolkit::CanvasView arg1;
-  Dali::Toolkit::CanvasView *argp1;
-  Dali::CanvasRenderer::Drawable arg2;
-  Dali::CanvasRenderer::Drawable *argp2;
+SWIGEXPORT bool SWIGSTDCALL
+CSharp_Dali_CanvasView_AddDrawable(char *pCanvasView, char *pDrawable) {
+  Dali::Toolkit::CanvasView canvasView;
+  Dali::CanvasRenderer::Drawable drawable;
   bool result = true;
 
-  argp1 = (Dali::Toolkit::CanvasView *)jarg1;
-  if (!argp1) {
+  if (!pCanvasView) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::Toolkit::CanvasView", 0);
     return false;
   }
-  arg1 = *argp1;
+  canvasView = *(Dali::Toolkit::CanvasView *)pCanvasView;
 
-  argp2 = (Dali::CanvasRenderer::Drawable *)jarg2;
-  if (!argp2) {
+  if (!pDrawable) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
     return false;
   }
-  arg2 = *argp2;
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
   {
     try {
-      arg1.AddDrawable(arg2);
+      canvasView.AddDrawable(drawable);
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -97,13 +103,74 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CanvasView_AddDrawable(char *jarg1,
   return result;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CanvasView(void *jarg1) {
-  Dali::Toolkit::CanvasView *arg1 = (Dali::Toolkit::CanvasView *)0;
+SWIGEXPORT bool SWIGSTDCALL
+CSharp_Dali_CanvasView_RemoveDrawable(char *pCanvasView, char *pDrawable) {
+  Dali::Toolkit::CanvasView canvasView;
+  Dali::CanvasRenderer::Drawable drawable;
+  bool result = true;
 
-  arg1 = (Dali::Toolkit::CanvasView *)jarg1;
+  if (!pCanvasView) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::Toolkit::CanvasView", 0);
+    return false;
+  }
+  canvasView = *(Dali::Toolkit::CanvasView *)pCanvasView;
+
+  if (!pDrawable) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
+    return false;
+  }
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
   {
     try {
-      delete arg1;
+      canvasView.RemoveDrawable(drawable);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return result;
+}
+
+SWIGEXPORT void SWIGSTDCALL
+CSharp_Dali_CanvasView_RemoveAllDrawables(char *pCanvasView) {
+  Dali::Toolkit::CanvasView canvasView;
+  Dali::CanvasRenderer::Drawable drawable;
+  bool result = true;
+
+  if (!pCanvasView) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::Toolkit::CanvasView", 0);
+    return;
+  }
+  canvasView = *(Dali::Toolkit::CanvasView *)pCanvasView;
+
+  {
+    try {
+      canvasView.RemoveAllDrawables();
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CanvasView(void *pCanvasView) {
+  Dali::Toolkit::CanvasView *pTargetCanvasView = nullptr;
+
+  if (!pCanvasView) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::Toolkit::CanvasView", 0);
+  }
+
+  pTargetCanvasView = (Dali::Toolkit::CanvasView *)pCanvasView;
+  {
+    try {
+      if (pTargetCanvasView) {
+        delete pTargetCanvasView;
+      }
     }
     CALL_CATCH_EXCEPTION();
   }
@@ -111,141 +178,137 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CanvasView(void *jarg1) {
 
 // Dali::CanvasRenderer::Drawable Wrapper
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Drawable_SetOpacity(char *jarg1,
-                                                            float jarg2) {
-  Dali::CanvasRenderer::Drawable *argp1;
-  float arg2 = jarg2;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Drawable_SetOpacity(char *pDrawable,
+                                                            float opacity) {
+  Dali::CanvasRenderer::Drawable drawable;
 
-  argp1 = (Dali::CanvasRenderer::Drawable *)jarg1;
-  if (!argp1) {
+  if (!pDrawable) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
     return;
   }
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
+
   {
     try {
-      argp1->SetOpacity(arg2);
+      drawable.SetOpacity(opacity);
     }
     CALL_CATCH_EXCEPTION();
   }
 }
 
-SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Drawable_GetOpacity(char *jarg1) {
-  Dali::CanvasRenderer::Drawable *argp1;
-  float result = 0.0f;
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Drawable_GetOpacity(char *pDrawable) {
+  Dali::CanvasRenderer::Drawable drawable;
+  float opacity = 0.0f;
 
-  argp1 = (Dali::CanvasRenderer::Drawable *)jarg1;
-  if (!argp1) {
+  if (!pDrawable) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
     return 0.0;
   }
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
   {
     try {
-      result = argp1->GetOpacity();
+      opacity = drawable.GetOpacity();
     }
     CALL_CATCH_EXCEPTION(0);
   }
 
-  return result;
+  return opacity;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Translate(char *jarg1,
-                                                           float jarg2,
-                                                           float jarg3) {
-  Dali::CanvasRenderer::Drawable *argp1;
-  float arg2 = jarg2;
-  float arg3 = jarg3;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Translate(char *pDrawable,
+                                                           float x, float y) {
+  Dali::CanvasRenderer::Drawable drawable;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Drawable *)jarg1;
-  if (!argp1) {
+  if (!pDrawable) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
     return false;
   }
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
   {
     try {
-      result = argp1->Translate(Vector2(arg2, arg3));
+      result = drawable.Translate(Vector2(x, y));
     }
     CALL_CATCH_EXCEPTION(false);
   }
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Scale(char *jarg1,
-                                                       float jarg2) {
-  Dali::CanvasRenderer::Drawable *argp1;
-  float arg2 = jarg2;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Scale(char *pDrawable,
+                                                       float scale) {
+  Dali::CanvasRenderer::Drawable drawable;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Drawable *)jarg1;
-  if (!argp1) {
+  if (!pDrawable) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
     return false;
   }
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
+
   {
     try {
-      result = argp1->Scale(arg2);
+      result = drawable.Scale(scale);
     }
     CALL_CATCH_EXCEPTION(false);
   }
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Rotate(char *jarg1,
-                                                        float jarg2) {
-  Dali::CanvasRenderer::Drawable *argp1;
-  float arg2 = jarg2;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Rotate(char *pDrawable,
+                                                        float degree) {
+  Dali::CanvasRenderer::Drawable drawable;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Drawable *)jarg1;
-  if (!argp1) {
+  if (!pDrawable) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
     return false;
   }
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
   {
     try {
-      result = argp1->Rotate(Dali::Degree(arg2));
+      result = drawable.Rotate(Dali::Degree(degree));
     }
     CALL_CATCH_EXCEPTION(false);
   }
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Transform(char *jarg1,
-                                                           float *jarg2) {
-  Dali::CanvasRenderer::Drawable *argp1;
-  float *argp2 = (float *)0;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Transform(char *pDrawable,
+                                                           float *pTransform) {
+  Dali::CanvasRenderer::Drawable drawable;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Drawable *)jarg1;
-  if (!argp1) {
+  if (!pDrawable) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
     return false;
   }
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
 
-  argp2 = jarg2;
-  if (!argp2) {
+  if (!pTransform) {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException,
                                            "Dali::Matrix3 const & type is null",
                                            0);
     return false;
   }
+
   {
     try {
-      result = argp1->Transform(Dali::Matrix3(argp2[0], argp2[1], argp2[2],
-                                              argp2[3], argp2[4], argp2[5],
-                                              argp2[6], argp2[7], argp2[8]));
+      result = drawable.Transform(
+          Dali::Matrix3(pTransform[0], pTransform[1], pTransform[2],
+                        pTransform[3], pTransform[4], pTransform[5],
+                        pTransform[6], pTransform[7], pTransform[8]));
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -253,76 +316,134 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_Transform(char *jarg1,
   return result;
 }
 
-SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Drawable_GetBoundingBox(char *jarg1) {
-  Dali::CanvasRenderer::Drawable *argp1;
+SWIGEXPORT void *SWIGSTDCALL
+CSharp_Dali_Drawable_GetBoundingBox(char *pDrawable) {
+  Dali::CanvasRenderer::Drawable drawable;
   Dali::Rect<float> result;
-  void *jresult = nullptr;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pDrawable) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return 0;
   }
+  drawable = *(Dali::CanvasRenderer::Shape *)pDrawable;
   {
     try {
-      result = argp1->GetBoundingBox();
+      result = drawable.GetBoundingBox();
     }
     CALL_CATCH_EXCEPTION(0);
   }
 
-  //Note: The float type Rectangle class is not ready yet.
+  // Note: The float type Rectangle class is not ready yet.
   //      Therefore, it transmits data in Vector4 class.
   //      This type should later be changed to the appropriate data type.
-  jresult = new Dali::Vector4(result.x, result.y, result.width, result.height);
-  return jresult;
+  return new Dali::Vector4(result.x, result.y, result.width, result.height);
+}
+
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_SetClipPath(char *pDrawable,
+                                                             char *pClip) {
+  Dali::CanvasRenderer::Drawable drawable;
+  Dali::CanvasRenderer::Drawable clip;
+  bool result = false;
+
+  if (!pDrawable) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
+    return false;
+  }
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
+
+  if (!pClip) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
+    return false;
+  }
+  clip = *(Dali::CanvasRenderer::Drawable *)pClip;
+
+  {
+    try {
+      result = drawable.SetClipPath(clip);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return result;
+}
+
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Drawable_SetMask(char *pDrawable,
+                                                         char *pMask,
+                                                         int maskType) {
+  Dali::CanvasRenderer::Drawable drawable;
+  Dali::CanvasRenderer::Drawable mask;
+  bool result = false;
+
+  if (!pDrawable) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
+    return false;
+  }
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
+
+  if (!pMask) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
+    return false;
+  }
+  mask = *(Dali::CanvasRenderer::Drawable *)pMask;
+
+  {
+    try {
+      result = drawable.SetMask(
+          mask,
+          static_cast<Dali::CanvasRenderer::Drawable::MaskType>(maskType));
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return result;
 }
 
 // Dali::CanvasRenderer::Shape Wrapper
 
 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_New() {
-  void *jresult;
-  Dali::CanvasRenderer::Shape result;
+  Dali::CanvasRenderer::Shape shape;
 
   {
     try {
-      result = Dali::CanvasRenderer::Shape::New();
+      shape = Dali::CanvasRenderer::Shape::New();
     }
     CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::CanvasRenderer::Shape(
-      (const Dali::CanvasRenderer::Shape &)result);
-
-  return jresult;
+  return new Dali::CanvasRenderer::Shape(
+      (const Dali::CanvasRenderer::Shape &)shape);
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddRect(char *jarg1, float jarg2,
-                                                      float jarg3, float jarg4,
-                                                      float jarg5, float jarg6,
-                                                      float jarg7) {
-  Dali::CanvasRenderer::Shape *argp1;
-  float arg2 = jarg2;
-  float arg3 = jarg3;
-  float arg4 = jarg4;
-  float arg5 = jarg5;
-  float arg6 = jarg6;
-  float arg7 = jarg7;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddRect(char *pShape, float x,
+                                                      float y, float width,
+                                                      float height,
+                                                      float roundX,
+                                                      float roundY) {
+  Dali::CanvasRenderer::Shape shape;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return false;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
   {
     try {
-      result = argp1->AddRect(Rect<float>(arg2, arg3, arg4, arg5),
-                              Vector2(arg6, arg7));
+      result = shape.AddRect(Rect<float>(x, y, width, height),
+                             Vector2(roundX, roundY));
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -330,25 +451,23 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddRect(char *jarg1, float jarg2,
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddCircle(
-    char *jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
-  Dali::CanvasRenderer::Shape *argp1;
-  float arg2 = jarg2;
-  float arg3 = jarg3;
-  float arg4 = jarg4;
-  float arg5 = jarg5;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddCircle(char *pShape, float x,
+                                                        float y, float radiusX,
+                                                        float radiusY) {
+  Dali::CanvasRenderer::Shape shape;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return false;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
   {
     try {
-      result = argp1->AddCircle(Vector2(arg2, arg3), Vector2(arg4, arg5));
+      result = shape.AddCircle(Vector2(x, y), Vector2(radiusX, radiusY));
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -356,29 +475,24 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddCircle(
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddArc(char *jarg1, float jarg2,
-                                                     float jarg3, float jarg4,
-                                                     float jarg5, float jarg6,
-                                                     bool jarg7) {
-  Dali::CanvasRenderer::Shape *argp1;
-  float arg2 = jarg2;
-  float arg3 = jarg3;
-  float arg4 = jarg4;
-  float arg5 = jarg5;
-  float arg6 = jarg6;
-  bool arg7 = jarg7;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddArc(char *pShape, float x,
+                                                     float y, float radius,
+                                                     float startAngle,
+                                                     float sweep, bool pie) {
+  Dali::CanvasRenderer::Shape shape;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return false;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
   {
     try {
-      result = argp1->AddArc(Vector2(arg2, arg3), arg4, arg5, arg6, arg7);
+      result = shape.AddArc(Vector2(x, y), radius, startAngle, sweep, pie);
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -386,24 +500,22 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddArc(char *jarg1, float jarg2,
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddMoveTo(char *jarg1,
-                                                        float jarg2,
-                                                        float jarg3) {
-  Dali::CanvasRenderer::Shape *argp1;
-  float arg2 = jarg2;
-  float arg3 = jarg3;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddMoveTo(char *pShape, float x,
+                                                        float y) {
+  Dali::CanvasRenderer::Shape shape;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return false;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
   {
     try {
-      result = argp1->AddMoveTo(Vector2(arg2, arg3));
+      result = shape.AddMoveTo(Vector2(x, y));
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -411,24 +523,22 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddMoveTo(char *jarg1,
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddLineTo(char *jarg1,
-                                                        float jarg2,
-                                                        float jarg3) {
-  Dali::CanvasRenderer::Shape *argp1;
-  float arg2 = jarg2;
-  float arg3 = jarg3;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddLineTo(char *pShape, float x,
+                                                        float y) {
+  Dali::CanvasRenderer::Shape shape;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return false;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
   {
     try {
-      result = argp1->AddLineTo(Vector2(arg2, arg3));
+      result = shape.AddLineTo(Vector2(x, y));
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -436,29 +546,26 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddLineTo(char *jarg1,
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL
-CSharp_Dali_Shape_AddCubicTo(char *jarg1, float jarg2, float jarg3, float jarg4,
-                             float jarg5, float jarg6, float jarg7) {
-  Dali::CanvasRenderer::Shape *argp1;
-  float arg2 = jarg2;
-  float arg3 = jarg3;
-  float arg4 = jarg4;
-  float arg5 = jarg5;
-  float arg6 = jarg6;
-  float arg7 = jarg7;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_AddCubicTo(
+    char *pShape, float controlPoint1X, float controlPoint1Y,
+    float controlPoint2X, float controlPoint2Y, float endPointX,
+    float endPointY) {
+  Dali::CanvasRenderer::Shape shape;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return false;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
   {
     try {
-      result = argp1->AddCubicTo(Vector2(arg2, arg3), Vector2(arg4, arg5),
-                                 Vector2(arg6, arg7));
+      result = shape.AddCubicTo(Vector2(controlPoint1X, controlPoint1Y),
+                                Vector2(controlPoint2X, controlPoint2Y),
+                                Vector2(endPointX, endPointY));
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -466,21 +573,21 @@ CSharp_Dali_Shape_AddCubicTo(char *jarg1, float jarg2, float jarg3, float jarg4,
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_Close(char *jarg1) {
-  Dali::CanvasRenderer::Shape *argp1;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_Close(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return false;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
   {
     try {
-      result = argp1->Close();
+      result = shape.Close();
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -488,21 +595,21 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_Close(char *jarg1) {
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_ResetPath(char *jarg1) {
-  Dali::CanvasRenderer::Shape *argp1;
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_ResetPath(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return false;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
   {
     try {
-      result = argp1->ResetPath();
+      result = shape.ResetPath();
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -510,93 +617,93 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Shape_ResetPath(char *jarg1) {
   return result;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetFillColor(char *jarg1,
-                                                           char *jarg2) {
-  Dali::CanvasRenderer::Shape *argp1;
-  Dali::Vector4 *argp2 = 0;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetFillColor(char *pShape,
+                                                           char *pColor) {
+  Dali::CanvasRenderer::Shape shape;
+  Dali::Vector4 color;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
-  argp2 = (Dali::Vector4 *)jarg2;
-  if (!argp2) {
+  if (!pColor) {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException,
                                            "Dali::Vector4 const & type is null",
                                            0);
     return;
   }
+  color = *(Dali::Vector4 *)pColor;
+
   {
     try {
-      argp1->SetFillColor(*argp2);
+      shape.SetFillColor(color);
     }
     CALL_CATCH_EXCEPTION();
   }
 }
 
-SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_GetFillColor(char *jarg1) {
-  Dali::CanvasRenderer::Shape *argp1;
+SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_GetFillColor(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
   Dali::Vector4 result;
-  void *jresult = nullptr;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return 0;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
   {
     try {
-      result = argp1->GetFillColor();
+      result = shape.GetFillColor();
     }
     CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector4((const Dali::Vector4 &)result);
-  return jresult;
+  return new Dali::Vector4((const Dali::Vector4 &)result);
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetFillRule(char *jarg1,
-                                                          int jarg2) {
-  Dali::CanvasRenderer::Shape *argp1;
-  Dali::CanvasRenderer::Shape::FillRule arg2;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetFillRule(char *pShape,
+                                                          int rule) {
+  Dali::CanvasRenderer::Shape shape;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return;
   }
-  arg2 = static_cast<Dali::CanvasRenderer::Shape::FillRule>(jarg2);
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
   {
     try {
-      argp1->SetFillRule(arg2);
+      shape.SetFillRule(
+          static_cast<Dali::CanvasRenderer::Shape::FillRule>(rule));
     }
     CALL_CATCH_EXCEPTION();
   }
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetFillRule(char *jarg1) {
-  Dali::CanvasRenderer::Shape *argp1;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetFillRule(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
   Dali::CanvasRenderer::Shape::FillRule result;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return 0;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
   {
     try {
-      result = argp1->GetFillRule();
+      result = shape.GetFillRule();
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -604,40 +711,41 @@ SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetFillRule(char *jarg1) {
   return (int)result;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeWidth(char *jarg1,
-                                                             float jarg2) {
-  Dali::CanvasRenderer::Shape *argp1;
-  float arg2 = jarg2;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeWidth(char *pShape,
+                                                             float width) {
+  Dali::CanvasRenderer::Shape shape;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
   {
     try {
-      argp1->SetStrokeWidth(arg2);
+      shape.SetStrokeWidth(width);
     }
     CALL_CATCH_EXCEPTION();
   }
 }
 
-SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Shape_GetStrokeWidth(char *jarg1) {
-  Dali::CanvasRenderer::Shape *argp1;
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Shape_GetStrokeWidth(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
   float result;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return 0;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
   {
     try {
-      result = argp1->GetStrokeWidth();
+      result = shape.GetStrokeWidth();
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -645,76 +753,69 @@ SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Shape_GetStrokeWidth(char *jarg1) {
   return result;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeColor(char *jarg1,
-                                                             char *jarg2) {
-  Dali::CanvasRenderer::Shape *argp1;
-  Dali::Vector4 arg2;
-  Dali::Vector4 *argp2 = 0;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeColor(char *pShape,
+                                                             char *pColor) {
+  Dali::CanvasRenderer::Shape shape;
+  Dali::Vector4 color;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
-  argp2 = (Dali::Vector4 *)jarg2;
-  if (!argp2) {
+  if (!pColor) {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException,
                                            "Dali::Vector4 const & type is null",
                                            0);
     return;
   }
-  arg2 = *argp2;
+  color = *(Dali::Vector4 *)pColor;
   {
     try {
-      argp1->SetStrokeColor(arg2);
+      shape.SetStrokeColor(color);
     }
     CALL_CATCH_EXCEPTION();
   }
 }
 
-SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_GetStrokeColor(char *jarg1) {
-  Dali::CanvasRenderer::Shape *argp1;
+SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Shape_GetStrokeColor(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
   Dali::Vector4 result;
-  void *jresult = nullptr;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return 0;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
   {
     try {
-      result = argp1->GetStrokeColor();
+      result = shape.GetStrokeColor();
     }
     CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector4((const Dali::Vector4 &)result);
-  return jresult;
+  return new Dali::Vector4((const Dali::Vector4 &)result);
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeDash(char *jarg1,
-                                                            float *jarg2,
-                                                            int jarg3) {
-  Dali::CanvasRenderer::Shape *argp1;
-  float *argp2 = (float *)0;
-  int arg3 = jarg3;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeDash(char *pShape,
+                                                            float *pDashPattern,
+                                                            int patternLength) {
+  Dali::CanvasRenderer::Shape shape;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
-  argp2 = jarg2;
-  if (!argp2) {
+  if (!pDashPattern) {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException,
                                            "Dash pattern is null", 0);
     return;
@@ -723,31 +824,31 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeDash(char *jarg1,
   {
     try {
       Vector<float> dashPattern;
-      for (unsigned int count = 0; count < arg3; count++) {
-        dashPattern.PushBack(argp2[count]);
+      for (unsigned int count = 0; count < patternLength; count++) {
+        dashPattern.PushBack(pDashPattern[count]);
       }
-      argp1->SetStrokeDash(dashPattern);
+      shape.SetStrokeDash(dashPattern);
     }
     CALL_CATCH_EXCEPTION();
   }
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeDashCount(char *jarg1) {
-  Dali::CanvasRenderer::Shape *argp1;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeDashCount(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
   int result;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return 0;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
   {
     try {
 
-      Dali::Vector<float> dashPattern = argp1->GetStrokeDash();
+      Dali::Vector<float> dashPattern = shape.GetStrokeDash();
       result = dashPattern.Size();
     }
     CALL_CATCH_EXCEPTION(0);
@@ -756,26 +857,26 @@ SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeDashCount(char *jarg1) {
   return result;
 }
 
-SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Shape_GetStrokeDashIndexOf(char *jarg1,
-                                                                    int jarg2) {
-  Dali::CanvasRenderer::Shape *argp1;
+SWIGEXPORT float SWIGSTDCALL
+CSharp_Dali_Shape_GetStrokeDashIndexOf(char *pShape, int index) {
+  Dali::CanvasRenderer::Shape shape;
   float result = 0.0f;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return 0;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
   {
     try {
-      Dali::Vector<float> dashPattern = argp1->GetStrokeDash();
-      if (jarg2 < 0 || jarg2 > dashPattern.Size()) {
+      Dali::Vector<float> dashPattern = shape.GetStrokeDash();
+      if (index < 0 || index > dashPattern.Size()) {
         throw std::invalid_argument("invalid index");
       }
-      result = dashPattern[jarg2];
+      result = dashPattern[index];
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -783,42 +884,42 @@ SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Shape_GetStrokeDashIndexOf(char *jarg1,
   return result;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeCap(char *jarg1,
-                                                           int jarg2) {
-  Dali::CanvasRenderer::Shape *argp1;
-  Dali::CanvasRenderer::Shape::StrokeCap arg2;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeCap(char *pShape,
+                                                           int cap) {
+  Dali::CanvasRenderer::Shape shape;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return;
   }
-  arg2 = static_cast<Dali::CanvasRenderer::Shape::StrokeCap>(jarg2);
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
   {
     try {
-      argp1->SetStrokeCap(arg2);
+      shape.SetStrokeCap(
+          static_cast<Dali::CanvasRenderer::Shape::StrokeCap>(cap));
     }
     CALL_CATCH_EXCEPTION();
   }
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeCap(char *jarg1) {
-  Dali::CanvasRenderer::Shape *argp1;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeCap(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
   Dali::CanvasRenderer::Shape::StrokeCap result;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return 0;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
   {
     try {
-      result = argp1->GetStrokeCap();
+      result = shape.GetStrokeCap();
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -826,42 +927,41 @@ SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeCap(char *jarg1) {
   return (int)result;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeJoin(char *jarg1,
-                                                            int jarg2) {
-  Dali::CanvasRenderer::Shape *argp1;
-  Dali::CanvasRenderer::Shape::StrokeJoin arg2;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Shape_SetStrokeJoin(char *pShape,
+                                                            int join) {
+  Dali::CanvasRenderer::Shape shape;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return;
   }
-  arg2 = static_cast<Dali::CanvasRenderer::Shape::StrokeJoin>(jarg2);
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
 
   {
     try {
-      argp1->SetStrokeJoin(arg2);
+      shape.SetStrokeJoin(
+          static_cast<Dali::CanvasRenderer::Shape::StrokeJoin>(join));
     }
     CALL_CATCH_EXCEPTION();
   }
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeJoin(char *jarg1) {
-  Dali::CanvasRenderer::Shape *argp1;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeJoin(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
   Dali::CanvasRenderer::Shape::StrokeJoin result;
 
-  argp1 = (Dali::CanvasRenderer::Shape *)jarg1;
-  if (!argp1) {
+  if (!pShape) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
     return 0;
   }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
   {
     try {
-      result = argp1->GetStrokeJoin();
+      result = shape.GetStrokeJoin();
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -872,50 +972,43 @@ SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeJoin(char *jarg1) {
 // Dali::CanvasRenderer::DrawableGroup Wrapper
 
 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_DrawableGroup_New() {
-  void *jresult;
-  Dali::CanvasRenderer::DrawableGroup result;
+  Dali::CanvasRenderer::DrawableGroup drawableGroup;
 
   {
     try {
-      result = Dali::CanvasRenderer::DrawableGroup::New();
+      drawableGroup = Dali::CanvasRenderer::DrawableGroup::New();
     }
     CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::CanvasRenderer::DrawableGroup(
-      (const Dali::CanvasRenderer::DrawableGroup &)result);
-
-  return jresult;
+  return new Dali::CanvasRenderer::DrawableGroup(
+      (const Dali::CanvasRenderer::DrawableGroup &)drawableGroup);
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DrawableGroup_AddDrawable(char *jarg1,
-                                                                  char *jarg2) {
-  Dali::CanvasRenderer::DrawableGroup arg1;
-  Dali::CanvasRenderer::DrawableGroup *argp1;
-  Dali::CanvasRenderer::Drawable arg2;
-  Dali::CanvasRenderer::Drawable *argp2;
+SWIGEXPORT bool SWIGSTDCALL
+CSharp_Dali_DrawableGroup_AddDrawable(char *pDrawableGroup, char *pDrawable) {
+  Dali::CanvasRenderer::DrawableGroup drawableGroup;
+  Dali::CanvasRenderer::Drawable drawable;
   bool result = true;
 
-  argp1 = (Dali::CanvasRenderer::DrawableGroup *)jarg1;
-  if (!argp1) {
+  if (!pDrawableGroup) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::DrawableGroup", 0);
     return false;
   }
-  arg1 = *argp1;
+  drawableGroup = *(Dali::CanvasRenderer::DrawableGroup *)pDrawableGroup;
 
-  argp2 = (Dali::CanvasRenderer::Drawable *)jarg2;
-  if (!argp2) {
+  if (!pDrawable) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::Drawable", 0);
     return false;
   }
-  arg2 = *argp2;
+  drawable = *(Dali::CanvasRenderer::Drawable *)pDrawable;
   {
     try {
-      arg1.AddDrawable(arg2);
+      drawableGroup.AddDrawable(drawable);
     }
     CALL_CATCH_EXCEPTION(0);
   }
@@ -923,21 +1016,22 @@ SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DrawableGroup_AddDrawable(char *jarg1,
   return result;
 }
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_DrawableGroup_Clear(char *jarg1) {
-  Dali::CanvasRenderer::DrawableGroup *argp1;
+SWIGEXPORT bool SWIGSTDCALL
+CSharp_Dali_DrawableGroup_Clear(char *pDrawableGroup) {
+  Dali::CanvasRenderer::DrawableGroup drawableGroup;
   bool result = false;
 
-  argp1 = (Dali::CanvasRenderer::DrawableGroup *)jarg1;
-  if (!argp1) {
+  if (!pDrawableGroup) {
     SWIG_CSharpSetPendingExceptionArgument(
         SWIG_CSharpArgumentNullException,
         "Attempt to dereference null Dali::CanvasRenderer::DrawableGroup", 0);
     return false;
   }
+  drawableGroup = *(Dali::CanvasRenderer::DrawableGroup *)pDrawableGroup;
 
   {
     try {
-      result = argp1->Clear();
+      result = drawableGroup.Clear();
     }
     CALL_CATCH_EXCEPTION(0);
   }

diff --git a/dali-csharp-binder/src/encoded-image-buffer.cpp b/dali-csharp-binder/src/encoded-image-buffer.cpp
new file mode 100755 (executable)
index 0000000..82802e6
--- /dev/null
+++ b/dali-csharp-binder/src/encoded-image-buffer.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2021 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "common.h"
+#include <dali-toolkit/public-api/image-loader/image.h>
+#include <dali-toolkit/public-api/image-loader/image-url.h>
+#include <dali/public-api/adaptor-framework/encoded-image-buffer.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define CALL_CATCH_EXCEPTION(ret)                                          \
+  catch (std::out_of_range & e)                                            \
+  {                                                                        \
+    SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));   \
+    return ret;                                                            \
+  }                                                                        \
+  catch (std::exception & e)                                               \
+  {                                                                        \
+    SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what())); \
+    return ret;                                                            \
+  }                                                                        \
+  catch (Dali::DaliException e)                                            \
+  {                                                                        \
+    SWIG_CSharpException(SWIG_UnknownError, e.condition);                  \
+    return ret;                                                            \
+  }                                                                        \
+  catch (...)                                                              \
+  {                                                                        \
+    SWIG_CSharpException(SWIG_UnknownError, "unknown error");              \
+    return ret;                                                            \
+  }
+
+SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_EncodedImageBuffer__SWIG_0()
+{
+  void *jresult;
+  Dali::EncodedImageBuffer *result = 0;
+
+  {
+    try
+    {
+      result = new Dali::EncodedImageBuffer();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  jresult = (void *)result;
+  return jresult;
+}
+
+SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_new_EncodedImageBuffer__SWIG_1(void *nuiEncodedImageBuffer)
+{
+  void *jresult;
+  Dali::EncodedImageBuffer *result = (Dali::EncodedImageBuffer *)0;
+  Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;;
+
+  if (!encodedImageBuffer)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedImageBuffer const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = new Dali::EncodedImageBuffer((Dali::EncodedImageBuffer const &)*encodedImageBuffer);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  jresult = (void *)result;
+  return jresult;
+}
+
+// note: nuiRawBuffer is same as Dali::Vector<unsigned char>, which created by CSharp_Dali_new_VectorUnsignedChar__SWIG_0
+SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_EncodedImageBuffer_New(void *nuiRawBuffer)
+{
+  void *jresult;
+  Dali::EncodedImageBuffer::RawBufferType *buffer = (Dali::EncodedImageBuffer::RawBufferType *)nuiRawBuffer;
+  Dali::EncodedImageBuffer result;
+
+  if (!buffer)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null buffer", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::EncodedImageBuffer::New((const Dali::EncodedImageBuffer::RawBufferType &)*buffer);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  jresult = new Dali::EncodedImageBuffer((const Dali::EncodedImageBuffer &)result);
+  return jresult;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedImageBuffer(void *nuiEncodedImageBuffer)
+{
+  Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;;
+  {
+    try
+    {
+      delete encodedImageBuffer;
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_EncodedImageBuffer_GetRawBuffer(void *nuiEncodedImageBuffer)
+{
+  void *jresult;
+  Dali::EncodedImageBuffer::RawBufferType *result = (Dali::EncodedImageBuffer::RawBufferType *)0;
+  Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;;
+
+  if (!encodedImageBuffer)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedImageBuffer const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = const_cast<Dali::EncodedImageBuffer::RawBufferType *>(&(encodedImageBuffer->GetRawBuffer()));
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  jresult = (void *)result;
+  return jresult;
+}
+
+SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_EncodedImageBuffer_GenerateUrl(void *nuiEncodedImageBuffer)
+{
+  void *jresult;
+  Dali::Toolkit::ImageUrl result;
+  Dali::EncodedImageBuffer *encodedImageBuffer = (Dali::EncodedImageBuffer *)nuiEncodedImageBuffer;;
+
+  if (!encodedImageBuffer)
+  {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedImageBuffer const & type is null", 0);
+    return 0;
+  }
+  {
+    try
+    {
+      result = Dali::Toolkit::Image::GenerateUrl((const Dali::EncodedImageBuffer &)*encodedImageBuffer);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
+  return jresult;
+}
+
+#ifdef __cplusplus
+}
+#endif

diff --git a/dali-csharp-binder/src/input-options.cpp b/dali-csharp-binder/src/input-options.cpp
new file mode 100644 (file)
index 0000000..65960d8
--- /dev/null
+++ b/dali-csharp-binder/src/input-options.cpp
@@ -0,0 +1,264 @@
+#ifndef CSHARP_INPUT_OPTIONS\r
+#define CSHARP_INPUT_OPTIONS\r
+#endif\r
+\r
+/*\r
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+#include <string.h>\r
+#include "common.h"\r
+#include <dali/integration-api/input-options.h>\r
+\r
+#ifdef __cplusplus\r
+extern "C"\r
+{\r
+#endif\r
+\r
+#define CALL_CATCH_EXCEPTION(ret)                                          \\r
+  catch (std::out_of_range & e)                                            \\r
+  {                                                                        \\r
+    SWIG_CSharpException(SWIG_IndexError, const_cast<char *>(e.what()));   \\r
+    return ret;                                                            \\r
+  }                                                                        \\r
+  catch (std::exception & e)                                               \\r
+  {                                                                        \\r
+    SWIG_CSharpException(SWIG_RuntimeError, const_cast<char *>(e.what())); \\r
+    return ret;                                                            \\r
+  }                                                                        \\r
+  catch (Dali::DaliException e)                                            \\r
+  {                                                                        \\r
+    SWIG_CSharpException(SWIG_UnknownError, e.condition);                  \\r
+    return ret;                                                            \\r
+  }                                                                        \\r
+  catch (...)                                                              \\r
+  {                                                                        \\r
+    SWIG_CSharpException(SWIG_UnknownError, "unknown error");              \\r
+    return ret;                                                            \\r
+  }\r
+\r
+using namespace Dali;\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGesturePredictionMode(int mode) {\r
+  {\r
+    try {\r
+      Integration::SetPanGesturePredictionMode(mode);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGesturePredictionAmount(unsigned int amount) {\r
+  {\r
+    try {\r
+      Integration::SetPanGesturePredictionAmount(amount);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMaximumPredictionAmount(unsigned int amount) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureMaximumPredictionAmount(amount);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMinimumPredictionAmount(unsigned int amount) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureMinimumPredictionAmount(amount);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGesturePredictionAmountAdjustment(unsigned int amount) {\r
+  {\r
+    try {\r
+      Integration::SetPanGesturePredictionAmountAdjustment(amount);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureSmoothingMode(int mode) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureSmoothingMode(mode);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureSmoothingAmount(float amount) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureSmoothingAmount(amount);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureUseActualTimes(bool enable) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureUseActualTimes(enable);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureInterpolationTimeRange(int range) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureInterpolationTimeRange(range);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureScalarOnlyPredictionEnabled(bool enable) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureScalarOnlyPredictionEnabled(enable);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointPredictionEnabled(bool enable) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureTwoPointPredictionEnabled(enable);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointInterpolatePastTime(int time) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureTwoPointInterpolatePastTime(time);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointVelocityBias(float velocity) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureTwoPointVelocityBias(velocity);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureTwoPointAccelerationBias(float acceleration) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureTwoPointAccelerationBias(acceleration);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMultitapSmoothingRange(int range) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureMultitapSmoothingRange(range);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMinimumDistance(int distance) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureMinimumDistance(distance);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPanGestureMinimumPanEvents(int number) {\r
+  {\r
+    try {\r
+      Integration::SetPanGestureMinimumPanEvents(number);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPinchGestureMinimumDistance(float distance) {\r
+  {\r
+    try {\r
+      Integration::SetPinchGestureMinimumDistance(distance);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPinchGestureMinimumTouchEvents(unsigned int number) {\r
+  {\r
+    try {\r
+      Integration::SetPinchGestureMinimumTouchEvents(number);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetPinchGestureMinimumTouchEventsAfterStart(unsigned int number) {\r
+  {\r
+    try {\r
+      Integration::SetPinchGestureMinimumTouchEventsAfterStart(number);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetRotationGestureMinimumTouchEvents(unsigned int number) {\r
+  {\r
+    try {\r
+      Integration::SetRotationGestureMinimumTouchEvents(number);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetRotationGestureMinimumTouchEventsAfterStart(unsigned int number) {\r
+  {\r
+    try {\r
+      Integration::SetRotationGestureMinimumTouchEventsAfterStart(number);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureOptions_SetLongPressMinimumHoldingTime(unsigned int time) {\r
+  {\r
+    try {\r
+      Integration::SetLongPressMinimumHoldingTime(time);\r
+    } CALL_CATCH_EXCEPTION();\r
+  }\r
+  return;\r
+}\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r

diff --git a/dali-csharp-binder/src/native-image-queue.cpp b/dali-csharp-binder/src/native-image-queue.cpp
new file mode 100644 (file)
index 0000000..3efe4e6
--- /dev/null
+++ b/dali-csharp-binder/src/native-image-queue.cpp
@@ -0,0 +1,203 @@
+/** Copyright (c) 2021 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.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+*/
+
+#include "common.h"
+#include <dali/devel-api/adaptor-framework/native-image-source-queue.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct NativeImageSourceQueuePtrHandle
+{
+  Dali::NativeImageSourceQueuePtr Ptr;
+};
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_NativeImageQueuePtr(unsigned int width, unsigned int height, int depth)
+{
+  void* jresult;
+  NativeImageSourceQueuePtrHandle* queue = new NativeImageSourceQueuePtrHandle();
+  {
+    try {
+      queue->Ptr = Dali::NativeImageSourceQueue::New(width, height, (Dali::NativeImageSourceQueue::ColorDepth)depth);
+    }
+    catch (std::out_of_range & e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+      };
+    }
+    catch (std::exception & e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+      };
+    }
+    catch (Dali::DaliException e) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
+      };
+    }
+    catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  jresult = (void *)queue;
+  return jresult;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageQueue_GetPtr(void* nuiqueue)
+{
+  void* jresult;
+  NativeImageSourceQueuePtrHandle* queue = (NativeImageSourceQueuePtrHandle*)nuiqueue;
+  jresult = (void*)(queue->Ptr.Get());
+  return jresult;
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImageQueuePtr(void* nuiqueue)
+{
+  NativeImageSourceQueuePtrHandle* queue = (NativeImageSourceQueuePtrHandle*)nuiqueue;
+  {
+    try {
+      delete queue;
+    }
+    catch (std::out_of_range & e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
+      };
+    }
+    catch (std::exception & e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
+      };
+    }
+    catch (Dali::DaliException e) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
+      };
+    }
+    catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
+      };
+    }
+  }
+}
+
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageQueue_CanDequeueBuffer(void* nuiqueue)
+{
+  bool jresult;
+  Dali::NativeImageSourceQueue* queue = (Dali::NativeImageSourceQueue*)nuiqueue;
+  {
+    try {
+      jresult = queue->CanDequeueBuffer();
+    }
+    catch (std::out_of_range & e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+      };
+    }
+    catch (std::exception & e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+      };
+    }
+    catch (Dali::DaliException e) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
+      };
+    }
+    catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  return jresult;
+}
+
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageQueue_DequeueBuffer(void* nuiqueue, int* jwidth, int* jheight, int* jstride)
+{
+  void* jresult;
+  Dali::NativeImageSourceQueue* queue = (Dali::NativeImageSourceQueue*)nuiqueue;
+  uint32_t* width = (uint32_t*)(jwidth);
+  uint32_t* height = (uint32_t*)(jheight);
+  uint32_t* stride = (uint32_t*)(jstride);
+  {
+    try {
+      jresult = (void *)queue->DequeueBuffer( *width, *height, *stride );
+    }
+    catch (std::out_of_range & e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+      };
+    }
+    catch (std::exception & e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+      };
+    }
+    catch (Dali::DaliException e) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
+      };
+    }
+    catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  return jresult;
+}
+
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageQueue_EnqueueBuffer(void* nuiqueue, void* jbuffer)
+{
+  bool jresult;
+  Dali::NativeImageSourceQueue* queue = (Dali::NativeImageSourceQueue*)nuiqueue;
+  uint8_t* buffer = (uint8_t*)jbuffer;
+  {
+    try {
+      jresult = queue->EnqueueBuffer(buffer);
+    }
+    catch (std::out_of_range & e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
+      };
+    }
+    catch (std::exception & e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
+      };
+    }
+    catch (Dali::DaliException e) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
+      };
+    }
+    catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
+      };
+    }
+  }
+  return jresult;
+}
+
+#ifdef __cplusplus
+}
+#endif
+

diff --git a/dali-csharp-binder/src/web-view.cpp b/dali-csharp-binder/src/web-view.cpp
index 1b0e7ab..f821f2c 100755 (executable)
--- a/dali-csharp-binder/src/web-view.cpp
+++ b/dali-csharp-binder/src/web-view.cpp
@@ -1105,6 +1105,18 @@ SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_RegisterContextMenuHiddenCallbac
   }
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GetPlainTextAsynchronously(void * nuiWebView, void * nuiCallback) {
+  Dali::Toolkit::WebView *webview = (Dali::Toolkit::WebView *)nuiWebView;
+  void (*callback)(char*) = (void (*)(char*))nuiCallback;
+  {
+    try {
+      webview->GetPlainTextAsynchronously([callback](const std::string& url) {
+            callback(SWIG_csharp_string_callback(url.c_str()));
+          });
+    } CALL_CATCH_EXCEPTION();
+  }
+}
+
 //----------------------------------WebBackForwardListItem-----------------------------------------------------
 SWIGEXPORT const char * SWIGSTDCALL CSharp_Dali_WebBackForwardListItem_GetUrl(void * jarg1) {
   Dali::WebEngineBackForwardListItem *arg1 = (Dali::WebEngineBackForwardListItem *)0;

diff --git a/packaging/dali-csharp-binder.spec b/packaging/dali-csharp-binder.spec
index 08ee49b..a146e0c 100644 (file)
--- a/packaging/dali-csharp-binder.spec
+++ b/packaging/dali-csharp-binder.spec
@@ -21,7 +21,7 @@
 
 Name: dali2-csharp-binder
 Summary: The DALI Csharp Binder
-Version: 2.0.36
+Version: 2.0.37
 Release: 1
 Group: uifw/graphic
 License: Apache-2.0 and BSD-3-Clause and MIT
@@ -45,7 +45,7 @@ BuildRequires: pkgconfig
 BuildRequires: pkgconfig(dali2-core)
 BuildRequires: pkgconfig(dali2-adaptor)
 BuildRequires: pkgconfig(dali2-toolkit)
-BuildRequires: pkgconfig(dali2-extension)
+BuildRequires: pkgconfig(dali2-extension-rive-animation-view)
 BuildRequires: pkgconfig(widget_viewer_dali)
 BuildRequires: pkgconfig(watch_viewer_dali)
 BuildRequires: pkgconfig(watch-holder-base)