dali-csharp-binder/dali-toolkit/text-spanned-wrap.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // EXTERNAL INCLUDES
  19 #include <dali-toolkit/dali-toolkit.h>
  20 #include <dali-toolkit/devel-api/text/spanned.h>
  21 #include <dali/dali.h>
  22
  23 // INTERNAL INCLUDES
  24 #include <dali-csharp-binder/common/common.h>
  25
  26 /* Callback for returning strings to C# without leaking memory */
  27 typedef char *(SWIGSTDCALL *SWIG_CSharpStringHelperCallback)(const char *);
  28 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  29
  30 #ifdef __cplusplus
  31 extern "C" {
  32 #endif
  33
  34 using namespace Dali::Toolkit::Text;
  35
  36 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Spanned(void *refSpanned) {
  37   Spanned *spannedPtr = (Spanned *)0;
  38   spannedPtr = (Spanned *)refSpanned;
  39
  40   {
  41     try {
  42       delete spannedPtr;
  43     }
  44     CALL_CATCH_EXCEPTION();
  45   }
  46 }
  47
  48 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_Spanned_GetAllSpans(void *refSpanned) {
  49
  50   Spanned *spannedPtr;
  51   void *result = nullptr;
  52
  53   spannedPtr = (Spanned *)refSpanned;
  54   if (!spannedPtr) {
  55     SWIG_CSharpSetPendingExceptionArgument(
  56         SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned",
  57         0);
  58     return 0;
  59   }
  60
  61   {
  62     try {
  63       result = new std::vector<BaseSpan>(
  64           (const std::vector<BaseSpan> &)(spannedPtr->GetAllSpans()));
  65     }
  66     CALL_CATCH_EXCEPTION(0);
  67   }
  68
  69   return result;
  70 }
  71
  72 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Spanned_RetrieveAllSpansAndRanges(
  73     void *refSpanned, void *refVectorSpans, void *refVectorRanges) {
  74
  75   std::vector<BaseSpan> *spanVectorPtr = (std::vector<BaseSpan> *)0;
  76   spanVectorPtr = (std::vector<BaseSpan> *)refVectorSpans;
  77   if (!spanVectorPtr) {
  78     SWIG_CSharpSetPendingExceptionArgument(
  79         SWIG_CSharpArgumentNullException,
  80         "Attempt to dereference null vector<BaseSpan>", 0);
  81     return;
  82   }
  83
  84   std::vector<Range> *rangeVectorPtr = (std::vector<Range> *)0;
  85   rangeVectorPtr = (std::vector<Range> *)refVectorRanges;
  86   if (!rangeVectorPtr) {
  87     SWIG_CSharpSetPendingExceptionArgument(
  88         SWIG_CSharpArgumentNullException,
  89         "Attempt to dereference null vector<Range>", 0);
  90     return;
  91   }
  92
  93   Spanned *spannedPtr;
  94   spannedPtr = (Spanned *)refSpanned;
  95   if (!spannedPtr) {
  96     SWIG_CSharpSetPendingExceptionArgument(
  97         SWIG_CSharpArgumentNullException, "Attempt to dereference null Spanned",
  98         0);
  99     return;
 100   }
 101
 102   {
 103     try {
 104       spannedPtr->RetrieveAllSpansAndRanges(*spanVectorPtr, *rangeVectorPtr);
 105     }
 106     CALL_CATCH_EXCEPTION();
 107   }
 108
 109   return;
 110 }
 111
 112 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_BaseSpan_Create() {
 113   void *nuiResult;
 114   std::vector<BaseSpan> *result = 0;
 115
 116   {
 117     try {
 118       result = (std::vector<BaseSpan> *)new std::vector<BaseSpan>();
 119     }
 120     CALL_CATCH_EXCEPTION(0);
 121   }
 122
 123   nuiResult = (void *)result;
 124   return nuiResult;
 125 }
 126
 127 SWIGEXPORT void SWIGSTDCALL
 128 CSharp_Dali_std_vector_BaseSpan_Release(void *refVector) {
 129   std::vector<BaseSpan> *spanPtr = (std::vector<BaseSpan> *)0;
 130
 131   spanPtr = (std::vector<BaseSpan> *)refVector;
 132   {
 133     try {
 134       delete spanPtr;
 135     }
 136     CALL_CATCH_EXCEPTION();
 137   }
 138 }
 139
 140 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_BaseSpan_ValueOfIndex(
 141     void *refVector, unsigned long argIndex) {
 142   void *nuiResult;
 143   std::vector<BaseSpan> *spanPtr = (std::vector<BaseSpan> *)0;
 144   std::vector<BaseSpan>::size_type itemSize;
 145   std::vector<BaseSpan>::value_type *result = 0;
 146
 147   spanPtr = (std::vector<BaseSpan> *)refVector;
 148   itemSize = (std::vector<BaseSpan>::size_type)argIndex;
 149   {
 150     try {
 151       result =
 152           (std::vector<BaseSpan>::value_type *)&(spanPtr)->operator[](itemSize);
 153     }
 154     CALL_CATCH_EXCEPTION(0);
 155   }
 156
 157   nuiResult = (void *)result;
 158   return nuiResult;
 159 }
 160
 161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_std_vector_BaseSpan_TypeOfIndex(
 162     void *refVector, unsigned long argIndex) {
 163
 164   Dali::Toolkit::Text::SpanType::Value result;
 165   std::vector<BaseSpan> *item = (std::vector<BaseSpan> *)0;
 166   std::vector<BaseSpan>::size_type itemSize;
 167   std::vector<BaseSpan>::value_type *spanPtr = 0;
 168
 169   item = (std::vector<BaseSpan> *)refVector;
 170   itemSize = (std::vector<BaseSpan>::size_type)argIndex;
 171   {
 172     try {
 173       spanPtr =
 174           (std::vector<BaseSpan>::value_type *)&(item)->operator[](itemSize);
 175       result = spanPtr->GetSpanType();
 176     }
 177     CALL_CATCH_EXCEPTION(0);
 178   }
 179
 180   int nuiResult = (int)result;
 181   return nuiResult;
 182 }
 183
 184 SWIGEXPORT int SWIGSTDCALL
 185 CSharp_Dali_std_vector_BaseSpan_Size(void *refVector) {
 186   std::vector<BaseSpan> *spanVectorPtr = (std::vector<BaseSpan> *)0;
 187   int size;
 188
 189   spanVectorPtr = (std::vector<BaseSpan> *)refVector;
 190   {
 191     try {
 192       size = (spanVectorPtr)->size();
 193     }
 194     CALL_CATCH_EXCEPTION(0);
 195   }
 196
 197   return size;
 198 }
 199
 200 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_Range_Create() {
 201   void *nuiResult;
 202   std::vector<Range> *result = 0;
 203
 204   {
 205     try {
 206       result = (std::vector<Range> *)new std::vector<Range>();
 207     }
 208     CALL_CATCH_EXCEPTION(0);
 209   }
 210
 211   nuiResult = (void *)result;
 212   return nuiResult;
 213 }
 214
 215 SWIGEXPORT void SWIGSTDCALL
 216 CSharp_Dali_std_vector_Range_Release(void *refVector) {
 217   std::vector<Range> *rangePtr = (std::vector<Range> *)0;
 218
 219   rangePtr = (std::vector<Range> *)refVector;
 220   {
 221     try {
 222       delete rangePtr;
 223     }
 224     CALL_CATCH_EXCEPTION();
 225   }
 226 }
 227
 228 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_std_vector_Range_ValueOfIndex(
 229     void *refVector, unsigned long argIndex) {
 230   void *nuiResult;
 231   std::vector<Range> *rangePtr = (std::vector<Range> *)0;
 232   std::vector<Range>::size_type itemSize;
 233   std::vector<Range>::value_type *result = 0;
 234
 235   rangePtr = (std::vector<Range> *)refVector;
 236   itemSize = (std::vector<Range>::size_type)argIndex;
 237   {
 238     try {
 239       result =
 240           (std::vector<Range>::value_type *)&(rangePtr)->operator[](itemSize);
 241     }
 242     CALL_CATCH_EXCEPTION(0);
 243   }
 244
 245   nuiResult = (void *)result;
 246   return nuiResult;
 247 }
 248
 249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_std_vector_Range_Size(void *refVector) {
 250   std::vector<Range> *rangePtr = (std::vector<Range> *)0;
 251   int size;
 252
 253   rangePtr = (std::vector<Range> *)refVector;
 254   {
 255     try {
 256       size = (rangePtr)->size();
 257     }
 258     CALL_CATCH_EXCEPTION(0);
 259   }
 260
 261   return size;
 262 }
 263
 264 #ifdef __cplusplus
 265 }
 266 #endif