From 60dba1bc7922ae1fce890de1efe19b941d23c9b3 Mon Sep 17 00:00:00 2001
From: JunsuChoi <jsuya.choi@samsung.com>
Date: Thu, 5 Aug 2021 17:38:00 +0900
Subject: [PATCH] Add CanvasRenderer::Gradient, LinearGradient, RadialGradient
 binder

Change-Id: I7cdd84f832c9a02f5d33a03a5f05d508dc7bf052
---
 dali-csharp-binder/src/canvas-view-wrap.cpp | 431 ++++++++++++++++++++++++++++
 1 file changed, 431 insertions(+)

diff --git a/dali-csharp-binder/src/canvas-view-wrap.cpp b/dali-csharp-binder/src/canvas-view-wrap.cpp
index 0c57dd4..d85f15c 100644
--- a/dali-csharp-binder/src/canvas-view-wrap.cpp
+++ b/dali-csharp-binder/src/canvas-view-wrap.cpp
@@ -8,6 +8,9 @@
 #include "common.h"
 #include <dali-toolkit/devel-api/controls/canvas-view/canvas-view.h>
 #include <dali/devel-api/adaptor-framework/canvas-renderer-drawable-group.h>
+#include <dali/devel-api/adaptor-framework/canvas-renderer-gradient.h>
+#include <dali/devel-api/adaptor-framework/canvas-renderer-linear-gradient.h>
+#include <dali/devel-api/adaptor-framework/canvas-renderer-radial-gradient.h>
 
 using namespace Dali;
 using namespace Dali::Toolkit;
@@ -972,6 +975,114 @@ SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shape_GetStrokeJoin(char *pShape) {
   return (int)result;
 }
 
+SWIGEXPORT bool SWIGSTDCALL
+CSharp_Dali_Shapep_SetFillGradient(char *pShape, char *pGradient) {
+  Dali::CanvasRenderer::Shape shape;
+  Dali::CanvasRenderer::Gradient gradient;
+  bool result = true;
+
+  if (!pShape) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
+    return false;
+  }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
+  if (!pGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0);
+    return false;
+  }
+  gradient = *(Dali::CanvasRenderer::Gradient *)pGradient;
+  {
+    try {
+      result = shape.SetFillGradient(gradient);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL
+CSharp_Dali_Shapep_GetFillGradient(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
+  Dali::CanvasRenderer::Gradient gradient;
+
+  if (!pShape) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
+    return nullptr;
+  }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
+  {
+    try {
+      gradient = shape.GetFillGradient();
+    }
+    CALL_CATCH_EXCEPTION(nullptr);
+  }
+
+  return new Dali::CanvasRenderer::Gradient((const Dali::CanvasRenderer::Gradient &)gradient);
+}
+
+SWIGEXPORT bool SWIGSTDCALL
+CSharp_Dali_Shapep_SetStrokeGradient(char *pShape, char *pGradient) {
+  Dali::CanvasRenderer::Shape shape;
+  Dali::CanvasRenderer::Gradient gradient;
+  bool result = true;
+
+  if (!pShape) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
+    return false;
+  }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
+  if (!pGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0);
+    return false;
+  }
+  gradient = *(Dali::CanvasRenderer::Gradient *)pGradient;
+  {
+    try {
+      shape.SetStrokeGradient(gradient);
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return result;
+}
+
+SWIGEXPORT void* SWIGSTDCALL
+CSharp_Dali_Shapep_GetStrokeGradient(char *pShape) {
+  Dali::CanvasRenderer::Shape shape;
+  Dali::CanvasRenderer::Gradient gradient;
+
+  if (!pShape) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Shape", 0);
+    return nullptr;
+  }
+  shape = *(Dali::CanvasRenderer::Shape *)pShape;
+
+  {
+    try {
+      gradient = shape.GetStrokeGradient();
+    }
+    CALL_CATCH_EXCEPTION(nullptr);
+  }
+
+  return new Dali::CanvasRenderer::Gradient((const Dali::CanvasRenderer::Gradient &)gradient);
+}
+
 // Dali::CanvasRenderer::DrawableGroup Wrapper
 
 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_DrawableGroup_New() {
@@ -1042,6 +1153,326 @@ CSharp_Dali_DrawableGroup_RemoveAllDrawables(char *pDrawableGroup) {
   return result;
 }
 
+// Dali::CanvasRenderer::Gradient Wrapper
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gradient_SetColorStops(char *pGradient,
+                                                            float *pStops,
+                                                            int stopsLength) {
+  Dali::CanvasRenderer::Gradient gradient;
+
+  if (!pGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0);
+    return;
+  }
+  gradient = *(Dali::CanvasRenderer::Gradient *)pGradient;
+
+  if (!pStops) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException,
+                                           "Stops is null", 0);
+    return;
+  }
+
+  {
+    try {
+      Dali::CanvasRenderer::Gradient::ColorStops stops;
+      for (unsigned int count = 0; count < stopsLength; count++) {
+        Dali::CanvasRenderer::Gradient::ColorStop stop;
+        stop.offset = pStops[count * 5];
+        stop.color = Vector4( pStops[(count * 5) + 1],
+                              pStops[(count * 5) + 2],
+                              pStops[(count * 5) + 3],
+                              pStops[(count * 5) + 4] );
+        stops.PushBack(stop);
+      }
+      gradient.SetColorStops(stops);
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gradient_GetColorStopsCount(char *pGradient) {
+  Dali::CanvasRenderer::Gradient gradient;
+  int result = 0;
+
+  if (!pGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0);
+    return 0;
+  }
+  gradient = *(Dali::CanvasRenderer::Gradient *)pGradient;
+
+  {
+    try {
+      Dali::CanvasRenderer::Gradient::ColorStops colorStops = gradient.GetColorStops();
+      result = colorStops.Size();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return result;
+}
+
+SWIGEXPORT float SWIGSTDCALL
+CSharp_Dali_Gradient_GetColorStopsOffsetIndexOf(char *pGradient, int index) {
+  Dali::CanvasRenderer::Gradient gradient;
+  float result = 0.0f;
+
+  if (!pGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0);
+    return 0.0f;
+  }
+  gradient = *(Dali::CanvasRenderer::Gradient *)pGradient;
+
+  {
+    try {
+      Dali::CanvasRenderer::Gradient::ColorStops colorStops = gradient.GetColorStops();
+      if (index < 0 || index > colorStops.Size()) {
+        throw std::invalid_argument("invalid index");
+      }
+      result = colorStops[index].offset;
+    }
+    CALL_CATCH_EXCEPTION(0.0f);
+  }
+
+  return result;
+}
+
+SWIGEXPORT void *SWIGSTDCALL
+CSharp_Dali_Gradient_GetColorStopsColorIndexOf(char *pGradient, int index) {
+  Dali::CanvasRenderer::Gradient gradient;
+  Dali::Vector4 result;
+
+  if (!pGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0);
+    return nullptr;
+  }
+  gradient = *(Dali::CanvasRenderer::Gradient *)pGradient;
+
+  {
+    try {
+      Dali::CanvasRenderer::Gradient::ColorStops colorStops = gradient.GetColorStops();
+      if (index < 0 || index > colorStops.Size()) {
+        throw std::invalid_argument("invalid index");
+      }
+      result = colorStops[index].color;
+    }
+    CALL_CATCH_EXCEPTION(nullptr);
+  }
+
+  return new Dali::Vector4((const Dali::Vector4 &)result);
+}
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gradient_SetSpread(char *pGradient,
+                                                          int spread) {
+  Dali::CanvasRenderer::Gradient gradient;
+
+  if (!pGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0);
+    return;
+  }
+  gradient = *(Dali::CanvasRenderer::Gradient *)pGradient;
+
+  {
+    try {
+      gradient.SetSpread(
+          static_cast<Dali::CanvasRenderer::Gradient::Spread>(spread));
+    }
+    CALL_CATCH_EXCEPTION();
+  }
+}
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gradient_GetSpread(char *pGradient) {
+  Dali::CanvasRenderer::Gradient gradient;
+  Dali::CanvasRenderer::Gradient::Spread result;
+
+  if (!pGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::Gradient", 0);
+    return 0;
+  }
+  gradient = *(Dali::CanvasRenderer::Gradient *)pGradient;
+
+  {
+    try {
+      result = gradient.GetSpread();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return (int)result;
+}
+
+// Dali::CanvasRenderer::LinearGradient Wrapper
+
+SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_LinearGradient_New() {
+  Dali::CanvasRenderer::LinearGradient linearGradient;
+
+  {
+    try {
+      linearGradient = Dali::CanvasRenderer::LinearGradient::New();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::CanvasRenderer::LinearGradient(
+      (const Dali::CanvasRenderer::LinearGradient &)linearGradient);
+}
+
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LinearGradient_SetBounds(char *pLinearGradient,
+                                                           void* pFirstPoint, void* pSecondPoint) {
+  Dali::CanvasRenderer::LinearGradient linearGradient;
+  bool result = false;
+
+  if (!pLinearGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::LinearGradient", 0);
+    return false;
+  }
+  linearGradient = *(Dali::CanvasRenderer::LinearGradient *)pLinearGradient;
+
+  if (!pFirstPoint) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::Vector2", 0);
+    return false;
+  }
+
+  if (!pSecondPoint) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::Vector2", 0);
+    return false;
+  }
+
+  {
+    try {
+      result = linearGradient.SetBounds(*(Dali::Vector2*)pFirstPoint, *(Dali::Vector2*)pSecondPoint);
+    }
+    CALL_CATCH_EXCEPTION(false);
+  }
+  return result;
+}
+
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LinearGradient_GetBounds(char *pLinearGradient,
+                                                           void* pFirstPoint, void* pSecondPoint) {
+  Dali::CanvasRenderer::LinearGradient linearGradient;
+  bool result = false;
+
+  if (!pLinearGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::LinearGradient", 0);
+    return false;
+  }
+  linearGradient = *(Dali::CanvasRenderer::LinearGradient *)pLinearGradient;
+
+  if (!pFirstPoint) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::Vector2", 0);
+    return false;
+  }
+
+  if (!pSecondPoint) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::Vector2", 0);
+    return false;
+  }
+
+  {
+    try {
+      result = linearGradient.GetBounds(*(Dali::Vector2*)pFirstPoint, *(Dali::Vector2*)pSecondPoint);
+    }
+    CALL_CATCH_EXCEPTION(false);
+  }
+  return result;
+}
+
+// Dali::CanvasRenderer::RadialGradient Wrapper
+
+SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_RadialGradient_New() {
+  Dali::CanvasRenderer::RadialGradient radialGradient;
+
+  {
+    try {
+      radialGradient = Dali::CanvasRenderer::RadialGradient::New();
+    }
+    CALL_CATCH_EXCEPTION(0);
+  }
+
+  return new Dali::CanvasRenderer::RadialGradient(
+      (const Dali::CanvasRenderer::RadialGradient &)radialGradient);
+}
+
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RadialGradient_SetBounds(char *pRadialGradient,
+                                                           void* pCenterPoint, float radius) {
+  Dali::CanvasRenderer::RadialGradient radialGradient;
+  bool result = false;
+
+  if (!pRadialGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::RadialGradient", 0);
+    return false;
+  }
+  radialGradient = *(Dali::CanvasRenderer::RadialGradient *)pRadialGradient;
+
+  if (!pCenterPoint) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::Vector2", 0);
+    return false;
+  }
+
+  {
+    try {
+      result = radialGradient.SetBounds(*(Dali::Vector2*)pCenterPoint, radius);
+    }
+    CALL_CATCH_EXCEPTION(false);
+  }
+  return result;
+}
+
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RadialGradient_GetBounds(char *pRadialGradient,
+                                                           void* pCenterPoint, void* radius) {
+  Dali::CanvasRenderer::RadialGradient radialGradient;
+  bool result = false;
+
+  if (!pRadialGradient) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::CanvasRenderer::RadialGradient", 0);
+    return false;
+  }
+  radialGradient = *(Dali::CanvasRenderer::RadialGradient *)pRadialGradient;
+
+  if (!pCenterPoint) {
+    SWIG_CSharpSetPendingExceptionArgument(
+        SWIG_CSharpArgumentNullException,
+        "Attempt to dereference null Dali::Vector2", 0);
+    return false;
+  }
+
+  {
+    try {
+      result = radialGradient.GetBounds(*(Dali::Vector2*)pCenterPoint, *(float*)radius);
+    }
+    CALL_CATCH_EXCEPTION(false);
+  }
+  return result;
+}
 #ifdef __cplusplus
 } // end extern "C"
 #endif
-- 
2.7.4