dali-csharp-binder/src/layout-item-ptr.cpp

   1 /*
   2  * Copyright (c) 2018 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 #include "common.h"
  19 #include <dali-toolkit/devel-api/layouting/layout-group-impl.h>
  20
  21 #ifdef __cplusplus
  22 extern "C" {
  23 #endif
  24
  25 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  26
  27 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemPtr__SWIG_0() {
  28   void * jresult ;
  29   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *result = 0 ;
  30
  31   {
  32     try {
  33       result = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)new Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem >();
  34     } catch (std::out_of_range& e) {
  35       {
  36         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  37       };
  38     } catch (std::exception& e) {
  39       {
  40         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  41       };
  42     } catch (...) {
  43       {
  44         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  45       };
  46     }
  47   }
  48   jresult = (void *)result;
  49   return jresult;
  50 }
  51
  52
  53 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemPtr__SWIG_1(void * jarg1) {
  54   void * jresult ;
  55   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
  56   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *result = 0 ;
  57
  58   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
  59   {
  60     try {
  61       result = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)new Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem >(arg1);
  62     } catch (std::out_of_range& e) {
  63       {
  64         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  65       };
  66     } catch (std::exception& e) {
  67       {
  68         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  69       };
  70     } catch (...) {
  71       {
  72         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  73       };
  74     }
  75   }
  76   jresult = (void *)result;
  77   return jresult;
  78 }
  79
  80
  81 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemPtr__SWIG_2(void * jarg1) {
  82   void * jresult ;
  83   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = 0 ;
  84   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *result = 0 ;
  85
  86   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
  87   if (!arg1) {
  88     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const & type is null", 0);
  89     return 0;
  90   }
  91   {
  92     try {
  93       result = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)new Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem >((Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const &)*arg1);
  94     } catch (std::out_of_range& e) {
  95       {
  96         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  97       };
  98     } catch (std::exception& e) {
  99       {
 100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 101       };
 102     } catch (...) {
 103       {
 104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 105       };
 106     }
 107   }
 108   jresult = (void *)result;
 109   return jresult;
 110 }
 111
 112
 113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LayoutItemPtr(void * jarg1) {
 114   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 115
 116   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 117   {
 118     try {
 119       delete arg1;
 120     } catch (std::out_of_range& e) {
 121       {
 122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 123       };
 124     } catch (std::exception& e) {
 125       {
 126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 127       };
 128     } catch (...) {
 129       {
 130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 131       };
 132     }
 133   }
 134 }
 135
 136
 137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Get(void * jarg1) {
 138   void * jresult ;
 139   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 140   Dali::Toolkit::Internal::LayoutItem *result = 0 ;
 141
 142   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 143   {
 144     try {
 145       result = (Dali::Toolkit::Internal::LayoutItem *)((Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const *)arg1)->Get();
 146     } catch (std::out_of_range& e) {
 147       {
 148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 149       };
 150     } catch (std::exception& e) {
 151       {
 152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 153       };
 154     } catch (...) {
 155       {
 156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 157       };
 158     }
 159   }
 160   jresult = (void *)result;
 161   return jresult;
 162 }
 163
 164
 165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr___deref__(void * jarg1) {
 166   void * jresult ;
 167   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 168   Dali::Toolkit::Internal::LayoutItem *result = 0 ;
 169
 170   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 171   {
 172     try {
 173       result = (Dali::Toolkit::Internal::LayoutItem *)((Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const *)arg1)->operator ->();
 174     } catch (std::out_of_range& e) {
 175       {
 176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 177       };
 178     } catch (std::exception& e) {
 179       {
 180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 181       };
 182     } catch (...) {
 183       {
 184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 185       };
 186     }
 187   }
 188   jresult = (void *)result;
 189   return jresult;
 190 }
 191
 192
 193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr___ref__(void * jarg1) {
 194   void * jresult ;
 195   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 196   Dali::Toolkit::Internal::LayoutItem *result = 0 ;
 197
 198   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 199   {
 200     try {
 201       result = (Dali::Toolkit::Internal::LayoutItem *) &((Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const *)arg1)->operator *();
 202     } catch (std::out_of_range& e) {
 203       {
 204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 205       };
 206     } catch (std::exception& e) {
 207       {
 208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 209       };
 210     } catch (...) {
 211       {
 212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 213       };
 214     }
 215   }
 216   jresult = (void *)result;
 217   return jresult;
 218 }
 219
 220
 221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
 222   void * jresult ;
 223   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 224   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg2 = 0 ;
 225   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *result = 0 ;
 226
 227   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 228   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg2;
 229   if (!arg2) {
 230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const & type is null", 0);
 231     return 0;
 232   }
 233   {
 234     try {
 235       result = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > const &)*arg2);
 236     } catch (std::out_of_range& e) {
 237       {
 238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 239       };
 240     } catch (std::exception& e) {
 241       {
 242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 243       };
 244     } catch (...) {
 245       {
 246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 247       };
 248     }
 249   }
 250   jresult = (void *)result;
 251   return jresult;
 252 }
 253
 254
 255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
 256   void * jresult ;
 257   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 258   Dali::Toolkit::Internal::LayoutItem *arg2 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 259   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *result = 0 ;
 260
 261   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 262   arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2;
 263   {
 264     try {
 265       result = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) &(arg1)->operator =(arg2);
 266     } catch (std::out_of_range& e) {
 267       {
 268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 269       };
 270     } catch (std::exception& e) {
 271       {
 272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 273       };
 274     } catch (...) {
 275       {
 276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 277       };
 278     }
 279   }
 280   jresult = (void *)result;
 281   return jresult;
 282 }
 283
 284
 285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Reset__SWIG_0(void * jarg1) {
 286   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 287
 288   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 289   {
 290     try {
 291       (arg1)->Reset();
 292     } catch (std::out_of_range& e) {
 293       {
 294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 295       };
 296     } catch (std::exception& e) {
 297       {
 298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 299       };
 300     } catch (...) {
 301       {
 302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 303       };
 304     }
 305   }
 306 }
 307
 308
 309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
 310   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 311   Dali::Toolkit::Internal::LayoutItem *arg2 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 312
 313   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 314   arg2 = (Dali::Toolkit::Internal::LayoutItem *)jarg2;
 315   {
 316     try {
 317       (arg1)->Reset(arg2);
 318     } catch (std::out_of_range& e) {
 319       {
 320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 321       };
 322     } catch (std::exception& e) {
 323       {
 324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 325       };
 326     } catch (...) {
 327       {
 328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 329       };
 330     }
 331   }
 332 }
 333
 334
 335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Detach(void * jarg1) {
 336   void * jresult ;
 337   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 338   Dali::Toolkit::Internal::LayoutItem *result = 0 ;
 339
 340   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 341   {
 342     try {
 343       result = (Dali::Toolkit::Internal::LayoutItem *)(arg1)->Detach();
 344     } catch (std::out_of_range& e) {
 345       {
 346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 347       };
 348     } catch (std::exception& e) {
 349       {
 350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 351       };
 352     } catch (...) {
 353       {
 354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 355       };
 356     }
 357   }
 358   jresult = (void *)result;
 359   return jresult;
 360 }
 361
 362
 363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_New(void * jarg1, void * jarg2) {
 364   void * jresult ;
 365   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 366   Dali::Handle *arg2 = 0 ;
 367   Dali::Toolkit::Internal::LayoutItemPtr result;
 368
 369   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 370   arg2 = (Dali::Handle *)jarg2;
 371   if (!arg2) {
 372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
 373     return 0;
 374   }
 375   {
 376     try {
 377       result = (*arg1)->New(*arg2);
 378     } catch (std::out_of_range& e) {
 379       {
 380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 381       };
 382     } catch (std::exception& e) {
 383       {
 384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 385       };
 386     } catch (...) {
 387       {
 388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 389       };
 390     }
 391   }
 392   jresult = new Dali::Toolkit::Internal::LayoutItemPtr((const Dali::Toolkit::Internal::LayoutItemPtr &)result);
 393   return jresult;
 394 }
 395
 396
 397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Initialize(void * jarg1, void * jarg2, char * jarg3) {
 398   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 399   Dali::Handle *arg2 = 0 ;
 400   std::string *arg3 = 0 ;
 401
 402   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 403   arg2 = (Dali::Handle *)jarg2;
 404   if (!arg2) {
 405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
 406     return ;
 407   }
 408   if (!jarg3) {
 409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 410     return ;
 411   }
 412   std::string arg3_str(jarg3);
 413   arg3 = &arg3_str;
 414   {
 415     try {
 416       (*arg1)->Initialize(*arg2,(std::string const &)*arg3);
 417     } catch (std::out_of_range& e) {
 418       {
 419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 420       };
 421     } catch (std::exception& e) {
 422       {
 423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 424       };
 425     } catch (...) {
 426       {
 427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 428       };
 429     }
 430   }
 431
 432   //argout typemap for const std::string&
 433
 434 }
 435
 436
 437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Unparent(void * jarg1) {
 438   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 439
 440   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 441   {
 442     try {
 443       (*arg1)->Unparent();
 444     } catch (std::out_of_range& e) {
 445       {
 446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 447       };
 448     } catch (std::exception& e) {
 449       {
 450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 451       };
 452     } catch (...) {
 453       {
 454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 455       };
 456     }
 457   }
 458 }
 459
 460
 461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_SetAnimateLayout(void * jarg1, unsigned int jarg2) {
 462   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 463   bool arg2 ;
 464
 465   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 466   arg2 = jarg2 ? true : false;
 467   {
 468     try {
 469       (*arg1)->SetAnimateLayout(arg2);
 470     } catch (std::out_of_range& e) {
 471       {
 472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 473       };
 474     } catch (std::exception& e) {
 475       {
 476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 477       };
 478     } catch (...) {
 479       {
 480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 481       };
 482     }
 483   }
 484 }
 485
 486
 487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_IsLayoutAnimated(void * jarg1) {
 488   unsigned int jresult ;
 489   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 490   bool result;
 491
 492   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 493   {
 494     try {
 495       result = (bool)(*arg1)->IsLayoutAnimated();
 496     } catch (std::out_of_range& e) {
 497       {
 498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 499       };
 500     } catch (std::exception& e) {
 501       {
 502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 503       };
 504     } catch (...) {
 505       {
 506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 507       };
 508     }
 509   }
 510   jresult = result;
 511   return jresult;
 512 }
 513
 514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Measure(void * jarg1, void * jarg2, void * jarg3) {
 515   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 516   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
 517   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ;
 518   Dali::Toolkit::MeasureSpec *argp2 ;
 519   Dali::Toolkit::MeasureSpec *argp3 ;
 520
 521   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 522   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
 523   if (!argp2) {
 524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
 525     return ;
 526   }
 527   arg2 = *argp2;
 528   argp3 = (Dali::Toolkit::MeasureSpec *)jarg3;
 529   if (!argp3) {
 530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
 531     return ;
 532   }
 533   arg3 = *argp3;
 534   {
 535     try {
 536       (*arg1)->Measure(arg2,arg3);
 537     } catch (std::out_of_range& e) {
 538       {
 539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 540       };
 541     } catch (std::exception& e) {
 542       {
 543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 544       };
 545     } catch (...) {
 546       {
 547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 548       };
 549     }
 550   }
 551 }
 552
 553
 554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Layout(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
 555   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 556   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ;
 557   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ;
 558   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ;
 559   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ;
 560   Dali::Toolkit::LayoutLength *argp2 ;
 561   Dali::Toolkit::LayoutLength *argp3 ;
 562   Dali::Toolkit::LayoutLength *argp4 ;
 563   Dali::Toolkit::LayoutLength *argp5 ;
 564
 565   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 566   argp2 = (Dali::Toolkit::LayoutLength *)jarg2;
 567   if (!argp2) {
 568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 569     return ;
 570   }
 571   arg2 = *argp2;
 572   argp3 = (Dali::Toolkit::LayoutLength *)jarg3;
 573   if (!argp3) {
 574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 575     return ;
 576   }
 577   arg3 = *argp3;
 578   argp4 = (Dali::Toolkit::LayoutLength *)jarg4;
 579   if (!argp4) {
 580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 581     return ;
 582   }
 583   arg4 = *argp4;
 584   argp5 = (Dali::Toolkit::LayoutLength *)jarg5;
 585   if (!argp5) {
 586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 587     return ;
 588   }
 589   arg5 = *argp5;
 590   {
 591     try {
 592       (*arg1)->Layout(arg2,arg3,arg4,arg5);
 593     } catch (std::out_of_range& e) {
 594       {
 595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 596       };
 597     } catch (std::exception& e) {
 598       {
 599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 600       };
 601     } catch (...) {
 602       {
 603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 604       };
 605     }
 606   }
 607 }
 608
 609
 610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetDefaultSize(void * jarg1, void * jarg2, void * jarg3) {
 611   void * jresult ;
 612   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 613   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ;
 614   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ;
 615   Dali::Toolkit::LayoutLength *argp2 ;
 616   Dali::Toolkit::MeasureSpec *argp3 ;
 617   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 618
 619   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 620   argp2 = (Dali::Toolkit::LayoutLength *)jarg2;
 621   if (!argp2) {
 622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 623     return 0;
 624   }
 625   arg2 = *argp2;
 626   argp3 = (Dali::Toolkit::MeasureSpec *)jarg3;
 627   if (!argp3) {
 628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
 629     return 0;
 630   }
 631   arg3 = *argp3;
 632   {
 633     try {
 634       result = (*arg1)->GetDefaultSize(arg2,arg3);
 635     } catch (std::out_of_range& e) {
 636       {
 637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 638       };
 639     } catch (std::exception& e) {
 640       {
 641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 642       };
 643     } catch (...) {
 644       {
 645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 646       };
 647     }
 648   }
 649   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 650   return jresult;
 651 }
 652
 653
 654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetParent(void * jarg1) {
 655   void * jresult ;
 656   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 657   Dali::Toolkit::Internal::LayoutParent *result = 0 ;
 658
 659   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 660   {
 661     try {
 662       result = (Dali::Toolkit::Internal::LayoutParent *)(*arg1)->GetParent();
 663     } catch (std::out_of_range& e) {
 664       {
 665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 666       };
 667     } catch (std::exception& e) {
 668       {
 669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 670       };
 671     } catch (...) {
 672       {
 673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 674       };
 675     }
 676   }
 677   jresult = (void *)result;
 678   return jresult;
 679 }
 680
 681
 682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_RequestLayout(void * jarg1) {
 683   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 684
 685   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 686   {
 687     try {
 688       (*arg1)->RequestLayout();
 689     } catch (std::out_of_range& e) {
 690       {
 691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 692       };
 693     } catch (std::exception& e) {
 694       {
 695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 696       };
 697     } catch (...) {
 698       {
 699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 700       };
 701     }
 702   }
 703 }
 704
 705
 706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_IsLayoutRequested(void * jarg1) {
 707   unsigned int jresult ;
 708   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 709   bool result;
 710
 711   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 712   {
 713     try {
 714       result = (bool)(*arg1)->IsLayoutRequested();
 715     } catch (std::out_of_range& e) {
 716       {
 717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 718       };
 719     } catch (std::exception& e) {
 720       {
 721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 722       };
 723     } catch (...) {
 724       {
 725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 726       };
 727     }
 728   }
 729   jresult = result;
 730   return jresult;
 731 }
 732
 733
 734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMeasuredWidth(void * jarg1) {
 735   void * jresult ;
 736   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 737   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 738
 739   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 740   {
 741     try {
 742       result = (*arg1)->GetMeasuredWidth();
 743     } catch (std::out_of_range& e) {
 744       {
 745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 746       };
 747     } catch (std::exception& e) {
 748       {
 749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 750       };
 751     } catch (...) {
 752       {
 753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 754       };
 755     }
 756   }
 757   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 758   return jresult;
 759 }
 760
 761
 762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMeasuredHeight(void * jarg1) {
 763   void * jresult ;
 764   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 765   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 766
 767   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 768   {
 769     try {
 770       result = (*arg1)->GetMeasuredHeight();
 771     } catch (std::out_of_range& e) {
 772       {
 773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 774       };
 775     } catch (std::exception& e) {
 776       {
 777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 778       };
 779     } catch (...) {
 780       {
 781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 782       };
 783     }
 784   }
 785   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 786   return jresult;
 787 }
 788
 789
 790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMeasuredWidthAndState(void * jarg1) {
 791   void * jresult ;
 792   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 793   Dali::Toolkit::MeasuredSize result;
 794
 795   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 796   {
 797     try {
 798       result = (*arg1)->GetMeasuredWidthAndState();
 799     } catch (std::out_of_range& e) {
 800       {
 801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 802       };
 803     } catch (std::exception& e) {
 804       {
 805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 806       };
 807     } catch (...) {
 808       {
 809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 810       };
 811     }
 812   }
 813   jresult = new Dali::Toolkit::MeasuredSize((const Dali::Toolkit::MeasuredSize &)result);
 814   return jresult;
 815 }
 816
 817
 818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMeasuredHeightAndState(void * jarg1) {
 819   void * jresult ;
 820   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 821   Dali::Toolkit::MeasuredSize result;
 822
 823   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 824   {
 825     try {
 826       result = (*arg1)->GetMeasuredHeightAndState();
 827     } catch (std::out_of_range& e) {
 828       {
 829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 830       };
 831     } catch (std::exception& e) {
 832       {
 833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 834       };
 835     } catch (...) {
 836       {
 837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 838       };
 839     }
 840   }
 841   jresult = new Dali::Toolkit::MeasuredSize((const Dali::Toolkit::MeasuredSize &)result);
 842   return jresult;
 843 }
 844
 845
 846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetSuggestedMinimumWidth(void * jarg1) {
 847   void * jresult ;
 848   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 849   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 850
 851   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 852   {
 853     try {
 854       result = (*arg1)->GetSuggestedMinimumWidth();
 855     } catch (std::out_of_range& e) {
 856       {
 857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 858       };
 859     } catch (std::exception& e) {
 860       {
 861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 862       };
 863     } catch (...) {
 864       {
 865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 866       };
 867     }
 868   }
 869   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 870   return jresult;
 871 }
 872
 873
 874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetSuggestedMinimumHeight(void * jarg1) {
 875   void * jresult ;
 876   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 877   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 878
 879   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 880   {
 881     try {
 882       result = (*arg1)->GetSuggestedMinimumHeight();
 883     } catch (std::out_of_range& e) {
 884       {
 885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 886       };
 887     } catch (std::exception& e) {
 888       {
 889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 890       };
 891     } catch (...) {
 892       {
 893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 894       };
 895     }
 896   }
 897   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 898   return jresult;
 899 }
 900
 901
 902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_SetMinimumWidth(void * jarg1, void * jarg2) {
 903   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 904   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ;
 905   Dali::Toolkit::LayoutLength *argp2 ;
 906
 907   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 908   argp2 = (Dali::Toolkit::LayoutLength *)jarg2;
 909   if (!argp2) {
 910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 911     return ;
 912   }
 913   arg2 = *argp2;
 914   {
 915     try {
 916       (*arg1)->SetMinimumWidth(arg2);
 917     } catch (std::out_of_range& e) {
 918       {
 919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 920       };
 921     } catch (std::exception& e) {
 922       {
 923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 924       };
 925     } catch (...) {
 926       {
 927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 928       };
 929     }
 930   }
 931 }
 932
 933
 934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_SetMinimumHeight(void * jarg1, void * jarg2) {
 935   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 936   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ;
 937   Dali::Toolkit::LayoutLength *argp2 ;
 938
 939   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 940   argp2 = (Dali::Toolkit::LayoutLength *)jarg2;
 941   if (!argp2) {
 942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 943     return ;
 944   }
 945   arg2 = *argp2;
 946   {
 947     try {
 948       (*arg1)->SetMinimumHeight(arg2);
 949     } catch (std::out_of_range& e) {
 950       {
 951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 952       };
 953     } catch (std::exception& e) {
 954       {
 955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 956       };
 957     } catch (...) {
 958       {
 959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 960       };
 961     }
 962   }
 963 }
 964
 965
 966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMinimumWidth(void * jarg1) {
 967   void * jresult ;
 968   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 969   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 970
 971   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
 972   {
 973     try {
 974       result = (*arg1)->GetMinimumWidth();
 975     } catch (std::out_of_range& e) {
 976       {
 977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 978       };
 979     } catch (std::exception& e) {
 980       {
 981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 982       };
 983     } catch (...) {
 984       {
 985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 986       };
 987     }
 988   }
 989   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 990   return jresult;
 991 }
 992
 993
 994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetMinimumHeight(void * jarg1) {
 995   void * jresult ;
 996   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
 997   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 998
 999   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
1000   {
1001     try {
1002       result = (*arg1)->GetMinimumHeight();
1003     } catch (std::out_of_range& e) {
1004       {
1005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1006       };
1007     } catch (std::exception& e) {
1008       {
1009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1010       };
1011     } catch (...) {
1012       {
1013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1014       };
1015     }
1016   }
1017   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
1018   return jresult;
1019 }
1020
1021
1022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetPadding(void * jarg1) {
1023   void * jresult ;
1024   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
1025   Dali::Extents result;
1026
1027   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
1028   {
1029     try {
1030       result = (*arg1)->GetPadding();
1031     } catch (std::out_of_range& e) {
1032       {
1033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1034       };
1035     } catch (std::exception& e) {
1036       {
1037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1038       };
1039     } catch (...) {
1040       {
1041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1042       };
1043     }
1044   }
1045   jresult = new Dali::Extents((const Dali::Extents &)result);
1046   return jresult;
1047 }
1048
1049
1050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_DoAction(void * jarg1, char * jarg2, void * jarg3) {
1051   unsigned int jresult ;
1052   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
1053   std::string *arg2 = 0 ;
1054   Dali::Property::Map *arg3 = 0 ;
1055   bool result;
1056
1057   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
1058   if (!jarg2) {
1059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1060     return 0;
1061   }
1062   std::string arg2_str(jarg2);
1063   arg2 = &arg2_str;
1064   arg3 = (Dali::Property::Map *)jarg3;
1065   if (!arg3) {
1066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
1067     return 0;
1068   }
1069   {
1070     try {
1071       result = (bool)(*arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
1072     } catch (std::out_of_range& e) {
1073       {
1074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1075       };
1076     } catch (std::exception& e) {
1077       {
1078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1079       };
1080     } catch (...) {
1081       {
1082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1083       };
1084     }
1085   }
1086   jresult = result;
1087
1088   //argout typemap for const std::string&
1089
1090   return jresult;
1091 }
1092
1093
1094 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetTypeName(void * jarg1) {
1095   char * jresult ;
1096   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
1097   std::string *result = 0 ;
1098
1099   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
1100   {
1101     try {
1102       result = (std::string *) &(*arg1)->GetTypeName();
1103     } catch (std::out_of_range& e) {
1104       {
1105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1106       };
1107     } catch (std::exception& e) {
1108       {
1109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1110       };
1111     } catch (...) {
1112       {
1113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1114       };
1115     }
1116   }
1117   jresult = SWIG_csharp_string_callback(result->c_str());
1118   return jresult;
1119 }
1120
1121
1122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_GetTypeInfo(void * jarg1, void * jarg2) {
1123   unsigned int jresult ;
1124   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
1125   Dali::TypeInfo *arg2 = 0 ;
1126   bool result;
1127
1128   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
1129   arg2 = (Dali::TypeInfo *)jarg2;
1130   if (!arg2) {
1131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
1132     return 0;
1133   }
1134   {
1135     try {
1136       result = (bool)(*arg1)->GetTypeInfo(*arg2);
1137     } catch (std::out_of_range& e) {
1138       {
1139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1140       };
1141     } catch (std::exception& e) {
1142       {
1143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1144       };
1145     } catch (...) {
1146       {
1147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1148       };
1149     }
1150   }
1151   jresult = result;
1152   return jresult;
1153 }
1154
1155
1156 /*SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
1157   unsigned int jresult ;
1158   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
1159   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
1160   std::string *arg3 = 0 ;
1161   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
1162   bool result;
1163
1164   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
1165   arg2 = (ConnectionTrackerInterface *)jarg2;
1166   if (!jarg3) {
1167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1168     return 0;
1169   }
1170   std::string arg3_str(jarg3);
1171   arg3 = &arg3_str;
1172   arg4 = (FunctorDelegate *)jarg4;
1173   {
1174     try {
1175       result = (bool)(*arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
1176     } catch (std::out_of_range& e) {
1177       {
1178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1179       };
1180     } catch (std::exception& e) {
1181       {
1182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1183       };
1184     } catch (...) {
1185       {
1186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1187       };
1188     }
1189   }
1190   jresult = result;
1191
1192   //argout typemap for const std::string&
1193
1194   return jresult;
1195 }*/
1196
1197
1198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Reference(void * jarg1) {
1199   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
1200
1201   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
1202   {
1203     try {
1204       (*arg1)->Reference();
1205     } catch (std::out_of_range& e) {
1206       {
1207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1208       };
1209     } catch (std::exception& e) {
1210       {
1211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1212       };
1213     } catch (...) {
1214       {
1215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1216       };
1217     }
1218   }
1219 }
1220
1221
1222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemPtr_Unreference(void * jarg1) {
1223   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
1224
1225   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
1226   {
1227     try {
1228       (*arg1)->Unreference();
1229     } catch (std::out_of_range& e) {
1230       {
1231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1232       };
1233     } catch (std::exception& e) {
1234       {
1235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1236       };
1237     } catch (...) {
1238       {
1239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1240       };
1241     }
1242   }
1243 }
1244
1245
1246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutItemPtr_ReferenceCount(void * jarg1) {
1247   int jresult ;
1248   Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *) 0 ;
1249   int result;
1250
1251   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Internal::LayoutItem > *)jarg1;
1252   {
1253     try {
1254       result = (int)(*arg1)->ReferenceCount();
1255     } catch (std::out_of_range& e) {
1256       {
1257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1258       };
1259     } catch (std::exception& e) {
1260       {
1261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1262       };
1263     } catch (...) {
1264       {
1265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1266       };
1267     }
1268   }
1269   jresult = result;
1270   return jresult;
1271 }
1272
1273 #ifdef __cplusplus
1274 }
1275 #endif
1276