dali-csharp-binder/src/layout-item-wrapper-impl.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 // CLASS HEADER
  19 #include "layout-item-wrapper-impl.h"
  20
  21 // INTERNAL INCLUDES
  22
  23 #ifdef __cplusplus
  24 extern "C" {
  25 #endif
  26
  27 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  28
  29 using namespace Dali::Toolkit;
  30
  31 SwigDirector_LayoutItemWrapperImpl::SwigDirector_LayoutItemWrapperImpl() : Dali::Toolkit::Internal::LayoutItem()
  32 {
  33   swig_init_callbacks();
  34 }
  35
  36 SwigDirector_LayoutItemWrapperImpl::~SwigDirector_LayoutItemWrapperImpl()
  37 {
  38
  39 }
  40
  41 Dali::Toolkit::Internal::LayoutParent *SwigDirector_LayoutItemWrapperImpl::GetParent()
  42 {
  43   Dali::Toolkit::Internal::LayoutParent *c_result = 0;
  44   void * jresult = 0;
  45
  46   if (!swig_callbackGetParent)
  47   {
  48     return Dali::Toolkit::Internal::LayoutItem::GetParent();
  49   }
  50   else
  51   {
  52     jresult = (void *) swig_callbackGetParent();
  53     c_result = (Dali::Toolkit::Internal::LayoutParent *)jresult;
  54   }
  55   return c_result;
  56 }
  57
  58 void SwigDirector_LayoutItemWrapperImpl::OnUnparent()
  59 {
  60   if (!swig_callbackOnUnparent)
  61   {
  62     Dali::Toolkit::Internal::LayoutItem::OnUnparent();
  63     return;
  64   }
  65   else
  66   {
  67     swig_callbackOnUnparent();
  68   }
  69 }
  70
  71 void SwigDirector_LayoutItemWrapperImpl::OnRegisterChildProperties(std::string const &containerType)
  72 {
  73   char * jcontainerType = 0;
  74
  75   if (!swig_callbackOnRegisterChildProperties)
  76   {
  77     Dali::Toolkit::Internal::LayoutItem::OnRegisterChildProperties(containerType);
  78     return;
  79   }
  80   else
  81   {
  82     jcontainerType = SWIG_csharp_string_callback((&containerType)->c_str());
  83     swig_callbackOnRegisterChildProperties(jcontainerType);
  84   }
  85 }
  86
  87 void SwigDirector_LayoutItemWrapperImpl::OnMeasure(Dali::Toolkit::MeasureSpec widthMeasureSpec, Dali::Toolkit::MeasureSpec heightMeasureSpec)
  88 {
  89   void * jwidthMeasureSpec;
  90   void * jheightMeasureSpec;
  91
  92   if (!swig_callbackOnMeasure)
  93   {
  94     Dali::Toolkit::Internal::LayoutItem::OnMeasure(widthMeasureSpec,heightMeasureSpec);
  95     return;
  96   }
  97   else
  98   {
  99     jwidthMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)widthMeasureSpec);
 100     jheightMeasureSpec = (void *)new Dali::Toolkit::MeasureSpec((const Dali::Toolkit::MeasureSpec &)heightMeasureSpec);
 101     swig_callbackOnMeasure(jwidthMeasureSpec, jheightMeasureSpec);
 102   }
 103 }
 104
 105 void SwigDirector_LayoutItemWrapperImpl::OnLayout(bool changed, Dali::Toolkit::LayoutLength left, Dali::Toolkit::LayoutLength top, Dali::Toolkit::LayoutLength right, Dali::Toolkit::LayoutLength bottom)
 106 {
 107   unsigned int jchanged;
 108   void * jleft;
 109   void * jtop;
 110   void * jright;
 111   void * jbottom;
 112
 113   if (!swig_callbackOnLayout)
 114   {
 115     Dali::Toolkit::Internal::LayoutItem::OnLayout(changed,left,top,right,bottom);
 116     return;
 117   }
 118   else
 119   {
 120     jchanged = changed;
 121     jleft = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)left);
 122     jtop = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)top);
 123     jright = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)right);
 124     jbottom = (void *)new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)bottom);
 125     swig_callbackOnLayout(jchanged, jleft, jtop, jright, jbottom);
 126   }
 127 }
 128
 129 void SwigDirector_LayoutItemWrapperImpl::OnSizeChanged(Dali::Toolkit::LayoutSize newSize, Dali::Toolkit::LayoutSize oldSize)
 130 {
 131   void * jnewSize;
 132   void * joldSize;
 133
 134   if (!swig_callbackOnSizeChanged)
 135   {
 136     Dali::Toolkit::Internal::LayoutItem::OnSizeChanged(newSize,oldSize);
 137     return;
 138   }
 139   else
 140   {
 141     jnewSize = (void *)new Dali::Toolkit::LayoutSize((const Dali::Toolkit::LayoutSize &)newSize);
 142     joldSize = (void *)new Dali::Toolkit::LayoutSize((const Dali::Toolkit::LayoutSize &)oldSize);
 143     swig_callbackOnSizeChanged(jnewSize, joldSize);
 144   }
 145 }
 146
 147 void SwigDirector_LayoutItemWrapperImpl::OnInitialize()
 148 {
 149   if (!swig_callbackOnInitialize)
 150   {
 151     Dali::Toolkit::Internal::LayoutItem::OnInitialize();
 152     return;
 153   }
 154   else
 155   {
 156     swig_callbackOnInitialize();
 157   }
 158 }
 159
 160 void SwigDirector_LayoutItemWrapperImpl::SetMeasuredDimensions(Dali::Toolkit::MeasuredSize measuredWidth, Dali::Toolkit::MeasuredSize measuredHeight)
 161 {
 162   Dali::Toolkit::Internal::LayoutItem::SetMeasuredDimensions(measuredWidth, measuredHeight);
 163 }
 164
 165 void SwigDirector_LayoutItemWrapperImpl::swig_connect_director(SWIG_Callback0_t callbackGetParent, SWIG_Callback1_t callbackOnUnparent, SWIG_Callback2_t callbackOnRegisterChildProperties, SWIG_Callback3_t callbackOnMeasure, SWIG_Callback4_t callbackOnLayout, SWIG_Callback5_t callbackOnSizeChanged, SWIG_Callback6_t callbackOnInitialize)
 166 {
 167   swig_callbackGetParent = callbackGetParent;
 168   swig_callbackOnUnparent = callbackOnUnparent;
 169   swig_callbackOnRegisterChildProperties = callbackOnRegisterChildProperties;
 170   swig_callbackOnMeasure = callbackOnMeasure;
 171   swig_callbackOnLayout = callbackOnLayout;
 172   swig_callbackOnSizeChanged = callbackOnSizeChanged;
 173   swig_callbackOnInitialize = callbackOnInitialize;
 174 }
 175
 176 void SwigDirector_LayoutItemWrapperImpl::swig_init_callbacks()
 177 {
 178   swig_callbackGetParent = 0;
 179   swig_callbackOnUnparent = 0;
 180   swig_callbackOnRegisterChildProperties = 0;
 181   swig_callbackOnMeasure = 0;
 182   swig_callbackOnLayout = 0;
 183   swig_callbackOnSizeChanged = 0;
 184   swig_callbackOnInitialize = 0;
 185 }
 186
 187
 188
 189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutItemWrapperImpl() {
 190   void * jresult ;
 191   Dali::Toolkit::Internal::LayoutItem *result = 0 ;
 192
 193   {
 194     try {
 195       result = (Dali::Toolkit::Internal::LayoutItem *)new SwigDirector_LayoutItemWrapperImpl();
 196     } catch (std::out_of_range& e) {
 197       {
 198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 199       };
 200     } catch (std::exception& e) {
 201       {
 202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 203       };
 204     } catch (...) {
 205       {
 206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 207       };
 208     }
 209   }
 210   jresult = (void *)result;
 211   return jresult;
 212 }
 213
 214
 215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_New(void * jarg1) {
 216   void * jresult ;
 217   Dali::Handle *arg1 = 0 ;
 218   Dali::Toolkit::Internal::LayoutItemPtr result;
 219
 220   arg1 = (Dali::Handle *)jarg1;
 221   if (!arg1) {
 222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
 223     return 0;
 224   }
 225   {
 226     try {
 227       result = Dali::Toolkit::Internal::LayoutItem::New(*arg1);
 228     } catch (std::out_of_range& e) {
 229       {
 230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 231       };
 232     } catch (std::exception& e) {
 233       {
 234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 235       };
 236     } catch (...) {
 237       {
 238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 239       };
 240     }
 241   }
 242   jresult = new Dali::Toolkit::Internal::LayoutItemPtr((const Dali::Toolkit::Internal::LayoutItemPtr &)result);
 243   return jresult;
 244 }
 245
 246
 247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_Initialize(void * jarg1, void * jarg2, char * jarg3) {
 248   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 249   Dali::Handle *arg2 = 0 ;
 250   std::string *arg3 = 0 ;
 251
 252   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 253   arg2 = (Dali::Handle *)jarg2;
 254   if (!arg2) {
 255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
 256     return ;
 257   }
 258   if (!jarg3) {
 259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 260     return ;
 261   }
 262   std::string arg3_str(jarg3);
 263   arg3 = &arg3_str;
 264   {
 265     try {
 266       (arg1)->Initialize(*arg2,(std::string const &)*arg3);
 267     } catch (std::out_of_range& e) {
 268       {
 269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 270       };
 271     } catch (std::exception& e) {
 272       {
 273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 274       };
 275     } catch (...) {
 276       {
 277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 278       };
 279     }
 280   }
 281
 282   //argout typemap for const std::string&
 283
 284 }
 285
 286
 287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_Unparent(void * jarg1) {
 288   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 289
 290   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 291   {
 292     try {
 293       (arg1)->Unparent();
 294     } catch (std::out_of_range& e) {
 295       {
 296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 297       };
 298     } catch (std::exception& e) {
 299       {
 300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 301       };
 302     } catch (...) {
 303       {
 304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 305       };
 306     }
 307   }
 308 }
 309
 310
 311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetAnimateLayout(void * jarg1, unsigned int jarg2) {
 312   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 313   bool arg2 ;
 314
 315   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 316   arg2 = jarg2 ? true : false;
 317   {
 318     try {
 319       (arg1)->SetAnimateLayout(arg2);
 320     } catch (std::out_of_range& e) {
 321       {
 322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 323       };
 324     } catch (std::exception& e) {
 325       {
 326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 327       };
 328     } catch (...) {
 329       {
 330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 331       };
 332     }
 333   }
 334 }
 335
 336
 337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_IsLayoutAnimated(void * jarg1) {
 338   unsigned int jresult ;
 339   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 340   bool result;
 341
 342   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 343   {
 344     try {
 345       result = (bool)((Dali::Toolkit::Internal::LayoutItem const *)arg1)->IsLayoutAnimated();
 346     } catch (std::out_of_range& e) {
 347       {
 348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 349       };
 350     } catch (std::exception& e) {
 351       {
 352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 353       };
 354     } catch (...) {
 355       {
 356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 357       };
 358     }
 359   }
 360   jresult = result;
 361   return jresult;
 362 }
 363
 364
 365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_RegisterChildProperties(void * jarg1, char * jarg2) {
 366   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 367   std::string *arg2 = 0 ;
 368
 369   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 370   if (!jarg2) {
 371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 372     return ;
 373   }
 374   std::string arg2_str(jarg2);
 375   arg2 = &arg2_str;
 376   {
 377     try {
 378       (arg1)->RegisterChildProperties((std::string const &)*arg2);
 379     } catch (std::out_of_range& e) {
 380       {
 381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 382       };
 383     } catch (std::exception& e) {
 384       {
 385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 386       };
 387     } catch (...) {
 388       {
 389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 390       };
 391     }
 392   }
 393
 394   //argout typemap for const std::string&
 395
 396 }
 397
 398
 399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_Measure(void * jarg1, void * jarg2, void * jarg3) {
 400   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 401   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
 402   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ;
 403   Dali::Toolkit::MeasureSpec *argp2 ;
 404   Dali::Toolkit::MeasureSpec *argp3 ;
 405
 406   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 407   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
 408   if (!argp2) {
 409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
 410     return ;
 411   }
 412   arg2 = *argp2;
 413   argp3 = (Dali::Toolkit::MeasureSpec *)jarg3;
 414   if (!argp3) {
 415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
 416     return ;
 417   }
 418   arg3 = *argp3;
 419   {
 420     try {
 421       (arg1)->Measure(arg2,arg3);
 422     } catch (std::out_of_range& e) {
 423       {
 424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 425       };
 426     } catch (std::exception& e) {
 427       {
 428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 429       };
 430     } catch (...) {
 431       {
 432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 433       };
 434     }
 435   }
 436 }
 437
 438
 439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_Layout(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
 440   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 441   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ;
 442   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ;
 443   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ;
 444   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ;
 445   Dali::Toolkit::LayoutLength *argp2 ;
 446   Dali::Toolkit::LayoutLength *argp3 ;
 447   Dali::Toolkit::LayoutLength *argp4 ;
 448   Dali::Toolkit::LayoutLength *argp5 ;
 449
 450   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 451   argp2 = (Dali::Toolkit::LayoutLength *)jarg2;
 452   if (!argp2) {
 453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 454     return ;
 455   }
 456   arg2 = *argp2;
 457   argp3 = (Dali::Toolkit::LayoutLength *)jarg3;
 458   if (!argp3) {
 459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 460     return ;
 461   }
 462   arg3 = *argp3;
 463   argp4 = (Dali::Toolkit::LayoutLength *)jarg4;
 464   if (!argp4) {
 465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 466     return ;
 467   }
 468   arg4 = *argp4;
 469   argp5 = (Dali::Toolkit::LayoutLength *)jarg5;
 470   if (!argp5) {
 471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 472     return ;
 473   }
 474   arg5 = *argp5;
 475   {
 476     try {
 477       (arg1)->Layout(arg2,arg3,arg4,arg5);
 478     } catch (std::out_of_range& e) {
 479       {
 480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 481       };
 482     } catch (std::exception& e) {
 483       {
 484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 485       };
 486     } catch (...) {
 487       {
 488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 489       };
 490     }
 491   }
 492 }
 493
 494
 495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetDefaultSize(void * jarg1, void * jarg2) {
 496   void * jresult ;
 497   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg1 ;
 498   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
 499   Dali::Toolkit::LayoutLength *argp1 ;
 500   Dali::Toolkit::MeasureSpec *argp2 ;
 501   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 502
 503   argp1 = (Dali::Toolkit::LayoutLength *)jarg1;
 504   if (!argp1) {
 505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 506     return 0;
 507   }
 508   arg1 = *argp1;
 509   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
 510   if (!argp2) {
 511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
 512     return 0;
 513   }
 514   arg2 = *argp2;
 515   {
 516     try {
 517       result = Dali::Toolkit::Internal::LayoutItem::GetDefaultSize(arg1,arg2);
 518     } catch (std::out_of_range& e) {
 519       {
 520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 521       };
 522     } catch (std::exception& e) {
 523       {
 524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 525       };
 526     } catch (...) {
 527       {
 528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 529       };
 530     }
 531   }
 532   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 533   return jresult;
 534 }
 535
 536
 537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetParent(void * jarg1) {
 538   void * jresult ;
 539   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 540   Dali::Toolkit::Internal::LayoutParent *result = 0 ;
 541
 542   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 543   {
 544     try {
 545       result = (Dali::Toolkit::Internal::LayoutParent *)(arg1)->GetParent();
 546     } catch (std::out_of_range& e) {
 547       {
 548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 549       };
 550     } catch (std::exception& e) {
 551       {
 552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 553       };
 554     } catch (...) {
 555       {
 556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 557       };
 558     }
 559   }
 560   jresult = (void *)result;
 561   return jresult;
 562 }
 563
 564
 565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetParentSwigExplicitLayoutItemWrapperImpl(void * jarg1) {
 566   void * jresult ;
 567   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 568   Dali::Toolkit::Internal::LayoutParent *result = 0 ;
 569
 570   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 571   {
 572     try {
 573       result = (Dali::Toolkit::Internal::LayoutParent *)(arg1)->Dali::Toolkit::Internal::LayoutItem::GetParent();
 574     } catch (std::out_of_range& e) {
 575       {
 576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 577       };
 578     } catch (std::exception& e) {
 579       {
 580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 581       };
 582     } catch (...) {
 583       {
 584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 585       };
 586     }
 587   }
 588   jresult = (void *)result;
 589   return jresult;
 590 }
 591
 592
 593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_RequestLayout(void * jarg1) {
 594   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 595
 596   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 597   {
 598     try {
 599       (arg1)->RequestLayout();
 600     } catch (std::out_of_range& e) {
 601       {
 602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 603       };
 604     } catch (std::exception& e) {
 605       {
 606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 607       };
 608     } catch (...) {
 609       {
 610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 611       };
 612     }
 613   }
 614 }
 615
 616
 617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_IsLayoutRequested(void * jarg1) {
 618   unsigned int jresult ;
 619   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 620   bool result;
 621
 622   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 623   {
 624     try {
 625       result = (bool)((Dali::Toolkit::Internal::LayoutItem const *)arg1)->IsLayoutRequested();
 626     } catch (std::out_of_range& e) {
 627       {
 628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 629       };
 630     } catch (std::exception& e) {
 631       {
 632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 633       };
 634     } catch (...) {
 635       {
 636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 637       };
 638     }
 639   }
 640   jresult = result;
 641   return jresult;
 642 }
 643
 644
 645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredWidth(void * jarg1) {
 646   void * jresult ;
 647   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 648   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 649
 650   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 651   {
 652     try {
 653       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredWidth();
 654     } catch (std::out_of_range& e) {
 655       {
 656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 657       };
 658     } catch (std::exception& e) {
 659       {
 660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 661       };
 662     } catch (...) {
 663       {
 664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 665       };
 666     }
 667   }
 668   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 669   return jresult;
 670 }
 671
 672
 673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredHeight(void * jarg1) {
 674   void * jresult ;
 675   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 676   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 677
 678   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 679   {
 680     try {
 681       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredHeight();
 682     } catch (std::out_of_range& e) {
 683       {
 684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 685       };
 686     } catch (std::exception& e) {
 687       {
 688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 689       };
 690     } catch (...) {
 691       {
 692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 693       };
 694     }
 695   }
 696   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 697   return jresult;
 698 }
 699
 700
 701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredWidthAndState(void * jarg1) {
 702   void * jresult ;
 703   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 704   Dali::Toolkit::MeasuredSize result;
 705
 706   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 707   {
 708     try {
 709       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredWidthAndState();
 710     } catch (std::out_of_range& e) {
 711       {
 712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 713       };
 714     } catch (std::exception& e) {
 715       {
 716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 717       };
 718     } catch (...) {
 719       {
 720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 721       };
 722     }
 723   }
 724   jresult = new Dali::Toolkit::MeasuredSize((const Dali::Toolkit::MeasuredSize &)result);
 725   return jresult;
 726 }
 727
 728
 729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredHeightAndState(void * jarg1) {
 730   void * jresult ;
 731   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 732   Dali::Toolkit::MeasuredSize result;
 733
 734   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 735   {
 736     try {
 737       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredHeightAndState();
 738     } catch (std::out_of_range& e) {
 739       {
 740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 741       };
 742     } catch (std::exception& e) {
 743       {
 744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 745       };
 746     } catch (...) {
 747       {
 748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 749       };
 750     }
 751   }
 752   jresult = new Dali::Toolkit::MeasuredSize((const Dali::Toolkit::MeasuredSize &)result);
 753   return jresult;
 754 }
 755
 756
 757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetSuggestedMinimumWidth(void * jarg1) {
 758   void * jresult ;
 759   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 760   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 761
 762   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 763   {
 764     try {
 765       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetSuggestedMinimumWidth();
 766     } catch (std::out_of_range& e) {
 767       {
 768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 769       };
 770     } catch (std::exception& e) {
 771       {
 772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 773       };
 774     } catch (...) {
 775       {
 776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 777       };
 778     }
 779   }
 780   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 781   return jresult;
 782 }
 783
 784
 785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetSuggestedMinimumHeight(void * jarg1) {
 786   void * jresult ;
 787   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 788   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 789
 790   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 791   {
 792     try {
 793       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetSuggestedMinimumHeight();
 794     } catch (std::out_of_range& e) {
 795       {
 796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 797       };
 798     } catch (std::exception& e) {
 799       {
 800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 801       };
 802     } catch (...) {
 803       {
 804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 805       };
 806     }
 807   }
 808   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 809   return jresult;
 810 }
 811
 812
 813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetMinimumWidth(void * jarg1, void * jarg2) {
 814   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 815   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ;
 816   Dali::Toolkit::LayoutLength *argp2 ;
 817
 818   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 819   argp2 = (Dali::Toolkit::LayoutLength *)jarg2;
 820   if (!argp2) {
 821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 822     return ;
 823   }
 824   arg2 = *argp2;
 825   {
 826     try {
 827       (arg1)->SetMinimumWidth(arg2);
 828     } catch (std::out_of_range& e) {
 829       {
 830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 831       };
 832     } catch (std::exception& e) {
 833       {
 834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 835       };
 836     } catch (...) {
 837       {
 838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 839       };
 840     }
 841   }
 842 }
 843
 844
 845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetMinimumHeight(void * jarg1, void * jarg2) {
 846   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 847   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ;
 848   Dali::Toolkit::LayoutLength *argp2 ;
 849
 850   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 851   argp2 = (Dali::Toolkit::LayoutLength *)jarg2;
 852   if (!argp2) {
 853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 854     return ;
 855   }
 856   arg2 = *argp2;
 857   {
 858     try {
 859       (arg1)->SetMinimumHeight(arg2);
 860     } catch (std::out_of_range& e) {
 861       {
 862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 863       };
 864     } catch (std::exception& e) {
 865       {
 866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 867       };
 868     } catch (...) {
 869       {
 870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 871       };
 872     }
 873   }
 874 }
 875
 876
 877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMinimumWidth(void * jarg1) {
 878   void * jresult ;
 879   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 880   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 881
 882   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 883   {
 884     try {
 885       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMinimumWidth();
 886     } catch (std::out_of_range& e) {
 887       {
 888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 889       };
 890     } catch (std::exception& e) {
 891       {
 892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 893       };
 894     } catch (...) {
 895       {
 896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 897       };
 898     }
 899   }
 900   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 901   return jresult;
 902 }
 903
 904
 905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMinimumHeight(void * jarg1) {
 906   void * jresult ;
 907   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 908   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 909
 910   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 911   {
 912     try {
 913       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMinimumHeight();
 914     } catch (std::out_of_range& e) {
 915       {
 916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 917       };
 918     } catch (std::exception& e) {
 919       {
 920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 921       };
 922     } catch (...) {
 923       {
 924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 925       };
 926     }
 927   }
 928   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 929   return jresult;
 930 }
 931
 932
 933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetPadding(void * jarg1) {
 934   void * jresult ;
 935   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 936   Dali::Extents result;
 937
 938   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 939   {
 940     try {
 941       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetPadding();
 942     } catch (std::out_of_range& e) {
 943       {
 944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 945       };
 946     } catch (std::exception& e) {
 947       {
 948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 949       };
 950     } catch (...) {
 951       {
 952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 953       };
 954     }
 955   }
 956   jresult = new Dali::Extents((const Dali::Extents &)result);
 957   return jresult;
 958 }
 959
 960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetMeasuredDimensions(void * jarg1, void * jarg2, void * jarg3) {
 961   SwigDirector_LayoutItemWrapperImpl *arg1 = (SwigDirector_LayoutItemWrapperImpl *) 0 ;
 962   Dali::Toolkit::MeasuredSize arg2 ;
 963   Dali::Toolkit::MeasuredSize arg3 ;
 964   Dali::Toolkit::MeasuredSize *argp2 ;
 965   Dali::Toolkit::MeasuredSize *argp3 ;
 966
 967   arg1 = (SwigDirector_LayoutItemWrapperImpl *)jarg1;
 968   argp2 = (Dali::Toolkit::MeasuredSize *)jarg2;
 969   if (!argp2) {
 970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasuredSize", 0);
 971     return ;
 972   }
 973   arg2 = *argp2;
 974   argp3 = (Dali::Toolkit::MeasuredSize *)jarg3;
 975   if (!argp3) {
 976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasuredSize", 0);
 977     return ;
 978   }
 979   arg3 = *argp3;
 980   {
 981     try {
 982       (arg1)->SetMeasuredDimensions(arg2,arg3);
 983     } catch (std::out_of_range& e) {
 984       {
 985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 986       };
 987     } catch (std::exception& e) {
 988       {
 989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 990       };
 991     } catch (...) {
 992       {
 993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 994       };
 995     }
 996   }
 997 }
 998
 999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnUnparent(void * jarg1) {
1000   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1001   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1002
1003   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1004   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1005   {
1006     try {
1007       (darg)->OnUnparent();
1008     } catch (std::out_of_range& e) {
1009       {
1010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1011       };
1012     } catch (std::exception& e) {
1013       {
1014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1015       };
1016     } catch (...) {
1017       {
1018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1019       };
1020     }
1021   }
1022 }
1023
1024
1025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnUnparentSwigExplicitLayoutItemWrapperImpl(void * jarg1) {
1026   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1027   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1028
1029   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1030   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1031   {
1032     try {
1033       (darg)->OnUnparentSwigPublic();
1034     } catch (std::out_of_range& e) {
1035       {
1036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1037       };
1038     } catch (std::exception& e) {
1039       {
1040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1041       };
1042     } catch (...) {
1043       {
1044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1045       };
1046     }
1047   }
1048 }
1049
1050
1051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnRegisterChildProperties(void * jarg1, char * jarg2) {
1052   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1053   std::string *arg2 = 0 ;
1054   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1055
1056   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1057   if (!jarg2) {
1058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1059     return ;
1060   }
1061   std::string arg2_str(jarg2);
1062   arg2 = &arg2_str;
1063   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1064   {
1065     try {
1066       (darg)->OnRegisterChildProperties((std::string const &)*arg2);
1067     } catch (std::out_of_range& e) {
1068       {
1069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1070       };
1071     } catch (std::exception& e) {
1072       {
1073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1074       };
1075     } catch (...) {
1076       {
1077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1078       };
1079     }
1080   }
1081
1082   //argout typemap for const std::string&
1083
1084 }
1085
1086
1087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnRegisterChildPropertiesSwigExplicitLayoutItemWrapperImpl(void * jarg1, char * jarg2) {
1088   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1089   std::string *arg2 = 0 ;
1090   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1091
1092   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1093   if (!jarg2) {
1094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1095     return ;
1096   }
1097   std::string arg2_str(jarg2);
1098   arg2 = &arg2_str;
1099   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1100   {
1101     try {
1102       (darg)->OnRegisterChildPropertiesSwigPublic((std::string const &)*arg2);
1103     } catch (std::out_of_range& e) {
1104       {
1105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1106       };
1107     } catch (std::exception& e) {
1108       {
1109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1110       };
1111     } catch (...) {
1112       {
1113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1114       };
1115     }
1116   }
1117
1118   //argout typemap for const std::string&
1119
1120 }
1121
1122
1123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnMeasure(void * jarg1, void * jarg2, void * jarg3) {
1124   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1125   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
1126   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ;
1127   Dali::Toolkit::MeasureSpec *argp2 ;
1128   Dali::Toolkit::MeasureSpec *argp3 ;
1129   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1130
1131   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1132   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
1133   if (!argp2) {
1134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1135     return ;
1136   }
1137   arg2 = *argp2;
1138   argp3 = (Dali::Toolkit::MeasureSpec *)jarg3;
1139   if (!argp3) {
1140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1141     return ;
1142   }
1143   arg3 = *argp3;
1144   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1145   {
1146     try {
1147       (darg)->OnMeasure(arg2,arg3);
1148     } catch (std::out_of_range& e) {
1149       {
1150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1151       };
1152     } catch (std::exception& e) {
1153       {
1154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1155       };
1156     } catch (...) {
1157       {
1158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1159       };
1160     }
1161   }
1162 }
1163
1164
1165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnMeasureSwigExplicitLayoutItemWrapperImpl(void * jarg1, void * jarg2, void * jarg3) {
1166   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1167   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
1168   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ;
1169   Dali::Toolkit::MeasureSpec *argp2 ;
1170   Dali::Toolkit::MeasureSpec *argp3 ;
1171   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1172
1173   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1174   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
1175   if (!argp2) {
1176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1177     return ;
1178   }
1179   arg2 = *argp2;
1180   argp3 = (Dali::Toolkit::MeasureSpec *)jarg3;
1181   if (!argp3) {
1182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1183     return ;
1184   }
1185   arg3 = *argp3;
1186   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1187   {
1188     try {
1189       (darg)->OnMeasureSwigPublic(arg2,arg3);
1190     } catch (std::out_of_range& e) {
1191       {
1192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1193       };
1194     } catch (std::exception& e) {
1195       {
1196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1197       };
1198     } catch (...) {
1199       {
1200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1201       };
1202     }
1203   }
1204 }
1205
1206
1207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnLayout(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
1208   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1209   bool arg2 ;
1210   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ;
1211   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ;
1212   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ;
1213   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg6 ;
1214   Dali::Toolkit::LayoutLength *argp3 ;
1215   Dali::Toolkit::LayoutLength *argp4 ;
1216   Dali::Toolkit::LayoutLength *argp5 ;
1217   Dali::Toolkit::LayoutLength *argp6 ;
1218   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1219
1220   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1221   arg2 = jarg2 ? true : false;
1222   argp3 = (Dali::Toolkit::LayoutLength *)jarg3;
1223   if (!argp3) {
1224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1225     return ;
1226   }
1227   arg3 = *argp3;
1228   argp4 = (Dali::Toolkit::LayoutLength *)jarg4;
1229   if (!argp4) {
1230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1231     return ;
1232   }
1233   arg4 = *argp4;
1234   argp5 = (Dali::Toolkit::LayoutLength *)jarg5;
1235   if (!argp5) {
1236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1237     return ;
1238   }
1239   arg5 = *argp5;
1240   argp6 = (Dali::Toolkit::LayoutLength *)jarg6;
1241   if (!argp6) {
1242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1243     return ;
1244   }
1245   arg6 = *argp6;
1246   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1247   {
1248     try {
1249       (darg)->OnLayout(arg2,arg3,arg4,arg5,arg6);
1250     } catch (std::out_of_range& e) {
1251       {
1252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1253       };
1254     } catch (std::exception& e) {
1255       {
1256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1257       };
1258     } catch (...) {
1259       {
1260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1261       };
1262     }
1263   }
1264 }
1265
1266
1267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnLayoutSwigExplicitLayoutItemWrapperImpl(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
1268   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1269   bool arg2 ;
1270   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ;
1271   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ;
1272   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ;
1273   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg6 ;
1274   Dali::Toolkit::LayoutLength *argp3 ;
1275   Dali::Toolkit::LayoutLength *argp4 ;
1276   Dali::Toolkit::LayoutLength *argp5 ;
1277   Dali::Toolkit::LayoutLength *argp6 ;
1278   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1279
1280   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1281   arg2 = jarg2 ? true : false;
1282   argp3 = (Dali::Toolkit::LayoutLength *)jarg3;
1283   if (!argp3) {
1284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1285     return ;
1286   }
1287   arg3 = *argp3;
1288   argp4 = (Dali::Toolkit::LayoutLength *)jarg4;
1289   if (!argp4) {
1290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1291     return ;
1292   }
1293   arg4 = *argp4;
1294   argp5 = (Dali::Toolkit::LayoutLength *)jarg5;
1295   if (!argp5) {
1296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1297     return ;
1298   }
1299   arg5 = *argp5;
1300   argp6 = (Dali::Toolkit::LayoutLength *)jarg6;
1301   if (!argp6) {
1302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1303     return ;
1304   }
1305   arg6 = *argp6;
1306   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1307   {
1308     try {
1309       (darg)->OnLayoutSwigPublic(arg2,arg3,arg4,arg5,arg6);
1310     } catch (std::out_of_range& e) {
1311       {
1312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1313       };
1314     } catch (std::exception& e) {
1315       {
1316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1317       };
1318     } catch (...) {
1319       {
1320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1321       };
1322     }
1323   }
1324 }
1325
1326
1327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnSizeChanged(void * jarg1, void * jarg2, void * jarg3) {
1328   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1329   Dali::Toolkit::LayoutSize arg2 ;
1330   Dali::Toolkit::LayoutSize arg3 ;
1331   Dali::Toolkit::LayoutSize *argp2 ;
1332   Dali::Toolkit::LayoutSize *argp3 ;
1333   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1334
1335   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1336   argp2 = (Dali::Toolkit::LayoutSize *)jarg2;
1337   if (!argp2) {
1338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1339     return ;
1340   }
1341   arg2 = *argp2;
1342   argp3 = (Dali::Toolkit::LayoutSize *)jarg3;
1343   if (!argp3) {
1344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1345     return ;
1346   }
1347   arg3 = *argp3;
1348   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1349   {
1350     try {
1351       (darg)->OnSizeChanged(arg2,arg3);
1352     } catch (std::out_of_range& e) {
1353       {
1354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1355       };
1356     } catch (std::exception& e) {
1357       {
1358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1359       };
1360     } catch (...) {
1361       {
1362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1363       };
1364     }
1365   }
1366 }
1367
1368
1369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnSizeChangedSwigExplicitLayoutItemWrapperImpl(void * jarg1, void * jarg2, void * jarg3) {
1370   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1371   Dali::Toolkit::LayoutSize arg2 ;
1372   Dali::Toolkit::LayoutSize arg3 ;
1373   Dali::Toolkit::LayoutSize *argp2 ;
1374   Dali::Toolkit::LayoutSize *argp3 ;
1375   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1376
1377   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1378   argp2 = (Dali::Toolkit::LayoutSize *)jarg2;
1379   if (!argp2) {
1380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1381     return ;
1382   }
1383   arg2 = *argp2;
1384   argp3 = (Dali::Toolkit::LayoutSize *)jarg3;
1385   if (!argp3) {
1386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1387     return ;
1388   }
1389   arg3 = *argp3;
1390   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1391   {
1392     try {
1393       (darg)->OnSizeChangedSwigPublic(arg2,arg3);
1394     } catch (std::out_of_range& e) {
1395       {
1396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1397       };
1398     } catch (std::exception& e) {
1399       {
1400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1401       };
1402     } catch (...) {
1403       {
1404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1405       };
1406     }
1407   }
1408 }
1409
1410
1411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnInitialize(void * jarg1) {
1412   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1413   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1414
1415   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1416   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1417   {
1418     try {
1419       (darg)->OnInitialize();
1420     } catch (std::out_of_range& e) {
1421       {
1422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1423       };
1424     } catch (std::exception& e) {
1425       {
1426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1427       };
1428     } catch (...) {
1429       {
1430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1431       };
1432     }
1433   }
1434 }
1435
1436
1437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnInitializeSwigExplicitLayoutItemWrapperImpl(void * jarg1) {
1438   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1439   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1440
1441   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1442   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1443   {
1444     try {
1445       (darg)->OnInitializeSwigPublic();
1446     } catch (std::out_of_range& e) {
1447       {
1448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1449       };
1450     } catch (std::exception& e) {
1451       {
1452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1453       };
1454     } catch (...) {
1455       {
1456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1457       };
1458     }
1459   }
1460 }
1461
1462
1463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_director_connect(void *objarg, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback0_t callback0, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback1_t callback1, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback2_t callback2, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback3_t callback3, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback4_t callback4, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback5_t callback5, SwigDirector_LayoutItemWrapperImpl::SWIG_Callback6_t callback6) {
1464   Dali::Toolkit::Internal::LayoutItem *obj = (Dali::Toolkit::Internal::LayoutItem *)objarg;
1465   SwigDirector_LayoutItemWrapperImpl *director = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(obj);
1466   if (director) {
1467     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6);
1468   }
1469 }
1470
1471 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SWIGUpcast(Dali::Toolkit::Internal::LayoutItem *jarg1) {
1472     return (Dali::BaseObject *)jarg1;
1473 }
1474
1475
1476 /*SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
1477   void * jresult ;
1478   Dali::Toolkit::LayoutItem *arg1 = 0 ;
1479   Dali::Toolkit::Internal::LayoutItem *result = 0 ;
1480
1481   arg1 = (Dali::Toolkit::LayoutItem *)jarg1;
1482   if (!arg1) {
1483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutItem & type is null", 0);
1484     return 0;
1485   }
1486   {
1487     try {
1488       result = (Dali::Toolkit::Internal::LayoutItem *) &Dali::Toolkit::GetImplementation(*arg1);
1489     } catch (std::out_of_range& e) {
1490       {
1491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1492       };
1493     } catch (std::exception& e) {
1494       {
1495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1496       };
1497     } catch (...) {
1498       {
1499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1500       };
1501     }
1502   }
1503   jresult = (void *)result;
1504   return jresult;
1505 }*/
1506
1507 #ifdef __cplusplus
1508 }
1509 #endif