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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_Measure(void * jarg1, void * jarg2, void * jarg3) {
 365   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 366   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
 367   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ;
 368   Dali::Toolkit::MeasureSpec *argp2 ;
 369   Dali::Toolkit::MeasureSpec *argp3 ;
 370
 371   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 372   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
 373   if (!argp2) {
 374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
 375     return ;
 376   }
 377   arg2 = *argp2;
 378   argp3 = (Dali::Toolkit::MeasureSpec *)jarg3;
 379   if (!argp3) {
 380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
 381     return ;
 382   }
 383   arg3 = *argp3;
 384   {
 385     try {
 386       (arg1)->Measure(arg2,arg3);
 387     } catch (std::out_of_range& e) {
 388       {
 389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 390       };
 391     } catch (std::exception& e) {
 392       {
 393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 394       };
 395     } catch (...) {
 396       {
 397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 398       };
 399     }
 400   }
 401 }
 402
 403
 404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_Layout(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
 405   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 406   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ;
 407   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ;
 408   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ;
 409   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ;
 410   Dali::Toolkit::LayoutLength *argp2 ;
 411   Dali::Toolkit::LayoutLength *argp3 ;
 412   Dali::Toolkit::LayoutLength *argp4 ;
 413   Dali::Toolkit::LayoutLength *argp5 ;
 414
 415   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 416   argp2 = (Dali::Toolkit::LayoutLength *)jarg2;
 417   if (!argp2) {
 418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 419     return ;
 420   }
 421   arg2 = *argp2;
 422   argp3 = (Dali::Toolkit::LayoutLength *)jarg3;
 423   if (!argp3) {
 424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 425     return ;
 426   }
 427   arg3 = *argp3;
 428   argp4 = (Dali::Toolkit::LayoutLength *)jarg4;
 429   if (!argp4) {
 430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 431     return ;
 432   }
 433   arg4 = *argp4;
 434   argp5 = (Dali::Toolkit::LayoutLength *)jarg5;
 435   if (!argp5) {
 436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 437     return ;
 438   }
 439   arg5 = *argp5;
 440   {
 441     try {
 442       (arg1)->Layout(arg2,arg3,arg4,arg5);
 443     } catch (std::out_of_range& e) {
 444       {
 445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 446       };
 447     } catch (std::exception& e) {
 448       {
 449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 450       };
 451     } catch (...) {
 452       {
 453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 454       };
 455     }
 456   }
 457 }
 458
 459
 460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetDefaultSize(void * jarg1, void * jarg2) {
 461   void * jresult ;
 462   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg1 ;
 463   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
 464   Dali::Toolkit::LayoutLength *argp1 ;
 465   Dali::Toolkit::MeasureSpec *argp2 ;
 466   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 467
 468   argp1 = (Dali::Toolkit::LayoutLength *)jarg1;
 469   if (!argp1) {
 470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 471     return 0;
 472   }
 473   arg1 = *argp1;
 474   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
 475   if (!argp2) {
 476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
 477     return 0;
 478   }
 479   arg2 = *argp2;
 480   {
 481     try {
 482       result = Dali::Toolkit::Internal::LayoutItem::GetDefaultSize(arg1,arg2);
 483     } catch (std::out_of_range& e) {
 484       {
 485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 486       };
 487     } catch (std::exception& e) {
 488       {
 489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 490       };
 491     } catch (...) {
 492       {
 493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 494       };
 495     }
 496   }
 497   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 498   return jresult;
 499 }
 500
 501
 502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetParent(void * jarg1) {
 503   void * jresult ;
 504   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 505   Dali::Toolkit::Internal::LayoutParent *result = 0 ;
 506
 507   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 508   {
 509     try {
 510       result = (Dali::Toolkit::Internal::LayoutParent *)(arg1)->GetParent();
 511     } catch (std::out_of_range& e) {
 512       {
 513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 514       };
 515     } catch (std::exception& e) {
 516       {
 517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 518       };
 519     } catch (...) {
 520       {
 521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 522       };
 523     }
 524   }
 525   jresult = (void *)result;
 526   return jresult;
 527 }
 528
 529
 530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetParentSwigExplicitLayoutItemWrapperImpl(void * jarg1) {
 531   void * jresult ;
 532   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 533   Dali::Toolkit::Internal::LayoutParent *result = 0 ;
 534
 535   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 536   {
 537     try {
 538       result = (Dali::Toolkit::Internal::LayoutParent *)(arg1)->Dali::Toolkit::Internal::LayoutItem::GetParent();
 539     } catch (std::out_of_range& e) {
 540       {
 541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 542       };
 543     } catch (std::exception& e) {
 544       {
 545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 546       };
 547     } catch (...) {
 548       {
 549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 550       };
 551     }
 552   }
 553   jresult = (void *)result;
 554   return jresult;
 555 }
 556
 557
 558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_RequestLayout(void * jarg1) {
 559   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 560
 561   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 562   {
 563     try {
 564       (arg1)->RequestLayout();
 565     } catch (std::out_of_range& e) {
 566       {
 567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 568       };
 569     } catch (std::exception& e) {
 570       {
 571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 572       };
 573     } catch (...) {
 574       {
 575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 576       };
 577     }
 578   }
 579 }
 580
 581
 582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_IsLayoutRequested(void * jarg1) {
 583   unsigned int jresult ;
 584   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 585   bool result;
 586
 587   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 588   {
 589     try {
 590       result = (bool)((Dali::Toolkit::Internal::LayoutItem const *)arg1)->IsLayoutRequested();
 591     } catch (std::out_of_range& e) {
 592       {
 593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 594       };
 595     } catch (std::exception& e) {
 596       {
 597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 598       };
 599     } catch (...) {
 600       {
 601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 602       };
 603     }
 604   }
 605   jresult = result;
 606   return jresult;
 607 }
 608
 609
 610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredWidth(void * jarg1) {
 611   void * jresult ;
 612   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 613   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 614
 615   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 616   {
 617     try {
 618       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredWidth();
 619     } catch (std::out_of_range& e) {
 620       {
 621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 622       };
 623     } catch (std::exception& e) {
 624       {
 625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 626       };
 627     } catch (...) {
 628       {
 629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 630       };
 631     }
 632   }
 633   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 634   return jresult;
 635 }
 636
 637
 638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredHeight(void * jarg1) {
 639   void * jresult ;
 640   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 641   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 642
 643   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 644   {
 645     try {
 646       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredHeight();
 647     } catch (std::out_of_range& e) {
 648       {
 649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 650       };
 651     } catch (std::exception& e) {
 652       {
 653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 654       };
 655     } catch (...) {
 656       {
 657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 658       };
 659     }
 660   }
 661   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 662   return jresult;
 663 }
 664
 665
 666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredWidthAndState(void * jarg1) {
 667   void * jresult ;
 668   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 669   Dali::Toolkit::MeasuredSize result;
 670
 671   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 672   {
 673     try {
 674       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredWidthAndState();
 675     } catch (std::out_of_range& e) {
 676       {
 677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 678       };
 679     } catch (std::exception& e) {
 680       {
 681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 682       };
 683     } catch (...) {
 684       {
 685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 686       };
 687     }
 688   }
 689   jresult = new Dali::Toolkit::MeasuredSize((const Dali::Toolkit::MeasuredSize &)result);
 690   return jresult;
 691 }
 692
 693
 694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMeasuredHeightAndState(void * jarg1) {
 695   void * jresult ;
 696   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 697   Dali::Toolkit::MeasuredSize result;
 698
 699   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 700   {
 701     try {
 702       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMeasuredHeightAndState();
 703     } catch (std::out_of_range& e) {
 704       {
 705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 706       };
 707     } catch (std::exception& e) {
 708       {
 709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 710       };
 711     } catch (...) {
 712       {
 713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 714       };
 715     }
 716   }
 717   jresult = new Dali::Toolkit::MeasuredSize((const Dali::Toolkit::MeasuredSize &)result);
 718   return jresult;
 719 }
 720
 721
 722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetSuggestedMinimumWidth(void * jarg1) {
 723   void * jresult ;
 724   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 725   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 726
 727   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 728   {
 729     try {
 730       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetSuggestedMinimumWidth();
 731     } catch (std::out_of_range& e) {
 732       {
 733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 734       };
 735     } catch (std::exception& e) {
 736       {
 737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 738       };
 739     } catch (...) {
 740       {
 741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 742       };
 743     }
 744   }
 745   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 746   return jresult;
 747 }
 748
 749
 750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetSuggestedMinimumHeight(void * jarg1) {
 751   void * jresult ;
 752   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 753   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 754
 755   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 756   {
 757     try {
 758       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetSuggestedMinimumHeight();
 759     } catch (std::out_of_range& e) {
 760       {
 761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 762       };
 763     } catch (std::exception& e) {
 764       {
 765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 766       };
 767     } catch (...) {
 768       {
 769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 770       };
 771     }
 772   }
 773   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 774   return jresult;
 775 }
 776
 777
 778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetMinimumWidth(void * jarg1, void * jarg2) {
 779   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 780   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ;
 781   Dali::Toolkit::LayoutLength *argp2 ;
 782
 783   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 784   argp2 = (Dali::Toolkit::LayoutLength *)jarg2;
 785   if (!argp2) {
 786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 787     return ;
 788   }
 789   arg2 = *argp2;
 790   {
 791     try {
 792       (arg1)->SetMinimumWidth(arg2);
 793     } catch (std::out_of_range& e) {
 794       {
 795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 796       };
 797     } catch (std::exception& e) {
 798       {
 799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 800       };
 801     } catch (...) {
 802       {
 803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 804       };
 805     }
 806   }
 807 }
 808
 809
 810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetMinimumHeight(void * jarg1, void * jarg2) {
 811   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 812   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg2 ;
 813   Dali::Toolkit::LayoutLength *argp2 ;
 814
 815   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 816   argp2 = (Dali::Toolkit::LayoutLength *)jarg2;
 817   if (!argp2) {
 818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
 819     return ;
 820   }
 821   arg2 = *argp2;
 822   {
 823     try {
 824       (arg1)->SetMinimumHeight(arg2);
 825     } catch (std::out_of_range& e) {
 826       {
 827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 828       };
 829     } catch (std::exception& e) {
 830       {
 831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 832       };
 833     } catch (...) {
 834       {
 835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 836       };
 837     }
 838   }
 839 }
 840
 841
 842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMinimumWidth(void * jarg1) {
 843   void * jresult ;
 844   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 845   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 846
 847   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 848   {
 849     try {
 850       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMinimumWidth();
 851     } catch (std::out_of_range& e) {
 852       {
 853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 854       };
 855     } catch (std::exception& e) {
 856       {
 857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 858       };
 859     } catch (...) {
 860       {
 861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 862       };
 863     }
 864   }
 865   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 866   return jresult;
 867 }
 868
 869
 870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetMinimumHeight(void * jarg1) {
 871   void * jresult ;
 872   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 873   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 874
 875   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 876   {
 877     try {
 878       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetMinimumHeight();
 879     } catch (std::out_of_range& e) {
 880       {
 881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 882       };
 883     } catch (std::exception& e) {
 884       {
 885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 886       };
 887     } catch (...) {
 888       {
 889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 890       };
 891     }
 892   }
 893   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 894   return jresult;
 895 }
 896
 897
 898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_GetPadding(void * jarg1) {
 899   void * jresult ;
 900   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 901   Dali::Extents result;
 902
 903   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 904   {
 905     try {
 906       result = ((Dali::Toolkit::Internal::LayoutItem const *)arg1)->GetPadding();
 907     } catch (std::out_of_range& e) {
 908       {
 909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 910       };
 911     } catch (std::exception& e) {
 912       {
 913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 914       };
 915     } catch (...) {
 916       {
 917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 918       };
 919     }
 920   }
 921   jresult = new Dali::Extents((const Dali::Extents &)result);
 922   return jresult;
 923 }
 924
 925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SetMeasuredDimensions(void * jarg1, void * jarg2, void * jarg3) {
 926   SwigDirector_LayoutItemWrapperImpl *arg1 = (SwigDirector_LayoutItemWrapperImpl *) 0 ;
 927   Dali::Toolkit::MeasuredSize arg2 ;
 928   Dali::Toolkit::MeasuredSize arg3 ;
 929   Dali::Toolkit::MeasuredSize *argp2 ;
 930   Dali::Toolkit::MeasuredSize *argp3 ;
 931
 932   arg1 = (SwigDirector_LayoutItemWrapperImpl *)jarg1;
 933   argp2 = (Dali::Toolkit::MeasuredSize *)jarg2;
 934   if (!argp2) {
 935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasuredSize", 0);
 936     return ;
 937   }
 938   arg2 = *argp2;
 939   argp3 = (Dali::Toolkit::MeasuredSize *)jarg3;
 940   if (!argp3) {
 941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasuredSize", 0);
 942     return ;
 943   }
 944   arg3 = *argp3;
 945   {
 946     try {
 947       (arg1)->SetMeasuredDimensions(arg2,arg3);
 948     } catch (std::out_of_range& e) {
 949       {
 950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 951       };
 952     } catch (std::exception& e) {
 953       {
 954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 955       };
 956     } catch (...) {
 957       {
 958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 959       };
 960     }
 961   }
 962 }
 963
 964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnUnparent(void * jarg1) {
 965   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 966   SwigDirector_LayoutItemWrapperImpl *darg = 0;
 967
 968   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 969   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
 970   {
 971     try {
 972       (darg)->OnUnparent();
 973     } catch (std::out_of_range& e) {
 974       {
 975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 976       };
 977     } catch (std::exception& e) {
 978       {
 979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 980       };
 981     } catch (...) {
 982       {
 983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 984       };
 985     }
 986   }
 987 }
 988
 989
 990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnUnparentSwigExplicitLayoutItemWrapperImpl(void * jarg1) {
 991   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 992   SwigDirector_LayoutItemWrapperImpl *darg = 0;
 993
 994   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
 995   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
 996   {
 997     try {
 998       (darg)->OnUnparentSwigPublic();
 999     } catch (std::out_of_range& e) {
1000       {
1001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1002       };
1003     } catch (std::exception& e) {
1004       {
1005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1006       };
1007     } catch (...) {
1008       {
1009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1010       };
1011     }
1012   }
1013 }
1014
1015
1016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnRegisterChildProperties(void * jarg1, char * jarg2) {
1017   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1018   std::string *arg2 = 0 ;
1019   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1020
1021   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1022   if (!jarg2) {
1023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1024     return ;
1025   }
1026   std::string arg2_str(jarg2);
1027   arg2 = &arg2_str;
1028   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1029   {
1030     try {
1031       (darg)->OnRegisterChildProperties((std::string const &)*arg2);
1032     } catch (std::out_of_range& e) {
1033       {
1034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1035       };
1036     } catch (std::exception& e) {
1037       {
1038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1039       };
1040     } catch (...) {
1041       {
1042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1043       };
1044     }
1045   }
1046
1047   //argout typemap for const std::string&
1048
1049 }
1050
1051
1052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnRegisterChildPropertiesSwigExplicitLayoutItemWrapperImpl(void * jarg1, char * jarg2) {
1053   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1054   std::string *arg2 = 0 ;
1055   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1056
1057   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1058   if (!jarg2) {
1059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1060     return ;
1061   }
1062   std::string arg2_str(jarg2);
1063   arg2 = &arg2_str;
1064   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1065   {
1066     try {
1067       (darg)->OnRegisterChildPropertiesSwigPublic((std::string const &)*arg2);
1068     } catch (std::out_of_range& e) {
1069       {
1070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1071       };
1072     } catch (std::exception& e) {
1073       {
1074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1075       };
1076     } catch (...) {
1077       {
1078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1079       };
1080     }
1081   }
1082
1083   //argout typemap for const std::string&
1084
1085 }
1086
1087
1088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnMeasure(void * jarg1, void * jarg2, void * jarg3) {
1089   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1090   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
1091   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ;
1092   Dali::Toolkit::MeasureSpec *argp2 ;
1093   Dali::Toolkit::MeasureSpec *argp3 ;
1094   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1095
1096   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1097   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
1098   if (!argp2) {
1099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1100     return ;
1101   }
1102   arg2 = *argp2;
1103   argp3 = (Dali::Toolkit::MeasureSpec *)jarg3;
1104   if (!argp3) {
1105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1106     return ;
1107   }
1108   arg3 = *argp3;
1109   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1110   {
1111     try {
1112       (darg)->OnMeasure(arg2,arg3);
1113     } catch (std::out_of_range& e) {
1114       {
1115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1116       };
1117     } catch (std::exception& e) {
1118       {
1119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1120       };
1121     } catch (...) {
1122       {
1123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1124       };
1125     }
1126   }
1127 }
1128
1129
1130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnMeasureSwigExplicitLayoutItemWrapperImpl(void * jarg1, void * jarg2, void * jarg3) {
1131   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1132   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
1133   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ;
1134   Dali::Toolkit::MeasureSpec *argp2 ;
1135   Dali::Toolkit::MeasureSpec *argp3 ;
1136   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1137
1138   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1139   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
1140   if (!argp2) {
1141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1142     return ;
1143   }
1144   arg2 = *argp2;
1145   argp3 = (Dali::Toolkit::MeasureSpec *)jarg3;
1146   if (!argp3) {
1147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1148     return ;
1149   }
1150   arg3 = *argp3;
1151   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1152   {
1153     try {
1154       (darg)->OnMeasureSwigPublic(arg2,arg3);
1155     } catch (std::out_of_range& e) {
1156       {
1157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1158       };
1159     } catch (std::exception& e) {
1160       {
1161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1162       };
1163     } catch (...) {
1164       {
1165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1166       };
1167     }
1168   }
1169 }
1170
1171
1172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnLayout(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
1173   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1174   bool arg2 ;
1175   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ;
1176   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ;
1177   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ;
1178   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg6 ;
1179   Dali::Toolkit::LayoutLength *argp3 ;
1180   Dali::Toolkit::LayoutLength *argp4 ;
1181   Dali::Toolkit::LayoutLength *argp5 ;
1182   Dali::Toolkit::LayoutLength *argp6 ;
1183   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1184
1185   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1186   arg2 = jarg2 ? true : false;
1187   argp3 = (Dali::Toolkit::LayoutLength *)jarg3;
1188   if (!argp3) {
1189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1190     return ;
1191   }
1192   arg3 = *argp3;
1193   argp4 = (Dali::Toolkit::LayoutLength *)jarg4;
1194   if (!argp4) {
1195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1196     return ;
1197   }
1198   arg4 = *argp4;
1199   argp5 = (Dali::Toolkit::LayoutLength *)jarg5;
1200   if (!argp5) {
1201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1202     return ;
1203   }
1204   arg5 = *argp5;
1205   argp6 = (Dali::Toolkit::LayoutLength *)jarg6;
1206   if (!argp6) {
1207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1208     return ;
1209   }
1210   arg6 = *argp6;
1211   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1212   {
1213     try {
1214       (darg)->OnLayout(arg2,arg3,arg4,arg5,arg6);
1215     } catch (std::out_of_range& e) {
1216       {
1217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1218       };
1219     } catch (std::exception& e) {
1220       {
1221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1222       };
1223     } catch (...) {
1224       {
1225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1226       };
1227     }
1228   }
1229 }
1230
1231
1232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnLayoutSwigExplicitLayoutItemWrapperImpl(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
1233   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1234   bool arg2 ;
1235   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ;
1236   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ;
1237   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ;
1238   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg6 ;
1239   Dali::Toolkit::LayoutLength *argp3 ;
1240   Dali::Toolkit::LayoutLength *argp4 ;
1241   Dali::Toolkit::LayoutLength *argp5 ;
1242   Dali::Toolkit::LayoutLength *argp6 ;
1243   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1244
1245   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1246   arg2 = jarg2 ? true : false;
1247   argp3 = (Dali::Toolkit::LayoutLength *)jarg3;
1248   if (!argp3) {
1249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1250     return ;
1251   }
1252   arg3 = *argp3;
1253   argp4 = (Dali::Toolkit::LayoutLength *)jarg4;
1254   if (!argp4) {
1255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1256     return ;
1257   }
1258   arg4 = *argp4;
1259   argp5 = (Dali::Toolkit::LayoutLength *)jarg5;
1260   if (!argp5) {
1261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1262     return ;
1263   }
1264   arg5 = *argp5;
1265   argp6 = (Dali::Toolkit::LayoutLength *)jarg6;
1266   if (!argp6) {
1267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1268     return ;
1269   }
1270   arg6 = *argp6;
1271   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1272   {
1273     try {
1274       (darg)->OnLayoutSwigPublic(arg2,arg3,arg4,arg5,arg6);
1275     } catch (std::out_of_range& e) {
1276       {
1277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1278       };
1279     } catch (std::exception& e) {
1280       {
1281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1282       };
1283     } catch (...) {
1284       {
1285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1286       };
1287     }
1288   }
1289 }
1290
1291
1292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnSizeChanged(void * jarg1, void * jarg2, void * jarg3) {
1293   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1294   Dali::Toolkit::LayoutSize arg2 ;
1295   Dali::Toolkit::LayoutSize arg3 ;
1296   Dali::Toolkit::LayoutSize *argp2 ;
1297   Dali::Toolkit::LayoutSize *argp3 ;
1298   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1299
1300   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1301   argp2 = (Dali::Toolkit::LayoutSize *)jarg2;
1302   if (!argp2) {
1303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1304     return ;
1305   }
1306   arg2 = *argp2;
1307   argp3 = (Dali::Toolkit::LayoutSize *)jarg3;
1308   if (!argp3) {
1309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1310     return ;
1311   }
1312   arg3 = *argp3;
1313   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1314   {
1315     try {
1316       (darg)->OnSizeChanged(arg2,arg3);
1317     } catch (std::out_of_range& e) {
1318       {
1319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1320       };
1321     } catch (std::exception& e) {
1322       {
1323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1324       };
1325     } catch (...) {
1326       {
1327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1328       };
1329     }
1330   }
1331 }
1332
1333
1334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnSizeChangedSwigExplicitLayoutItemWrapperImpl(void * jarg1, void * jarg2, void * jarg3) {
1335   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1336   Dali::Toolkit::LayoutSize arg2 ;
1337   Dali::Toolkit::LayoutSize arg3 ;
1338   Dali::Toolkit::LayoutSize *argp2 ;
1339   Dali::Toolkit::LayoutSize *argp3 ;
1340   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1341
1342   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1343   argp2 = (Dali::Toolkit::LayoutSize *)jarg2;
1344   if (!argp2) {
1345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1346     return ;
1347   }
1348   arg2 = *argp2;
1349   argp3 = (Dali::Toolkit::LayoutSize *)jarg3;
1350   if (!argp3) {
1351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1352     return ;
1353   }
1354   arg3 = *argp3;
1355   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1356   {
1357     try {
1358       (darg)->OnSizeChangedSwigPublic(arg2,arg3);
1359     } catch (std::out_of_range& e) {
1360       {
1361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1362       };
1363     } catch (std::exception& e) {
1364       {
1365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1366       };
1367     } catch (...) {
1368       {
1369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1370       };
1371     }
1372   }
1373 }
1374
1375
1376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnInitialize(void * jarg1) {
1377   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1378   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1379
1380   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1381   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1382   {
1383     try {
1384       (darg)->OnInitialize();
1385     } catch (std::out_of_range& e) {
1386       {
1387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1388       };
1389     } catch (std::exception& e) {
1390       {
1391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1392       };
1393     } catch (...) {
1394       {
1395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1396       };
1397     }
1398   }
1399 }
1400
1401
1402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnInitializeSwigExplicitLayoutItemWrapperImpl(void * jarg1) {
1403   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1404   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1405
1406   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1407   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1408   {
1409     try {
1410       (darg)->OnInitializeSwigPublic();
1411     } catch (std::out_of_range& e) {
1412       {
1413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1414       };
1415     } catch (std::exception& e) {
1416       {
1417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1418       };
1419     } catch (...) {
1420       {
1421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1422       };
1423     }
1424   }
1425 }
1426
1427
1428 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) {
1429   Dali::Toolkit::Internal::LayoutItem *obj = (Dali::Toolkit::Internal::LayoutItem *)objarg;
1430   SwigDirector_LayoutItemWrapperImpl *director = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(obj);
1431   if (director) {
1432     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6);
1433   }
1434 }
1435
1436 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SWIGUpcast(Dali::Toolkit::Internal::LayoutItem *jarg1) {
1437     return (Dali::BaseObject *)jarg1;
1438 }
1439
1440
1441 /*SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
1442   void * jresult ;
1443   Dali::Toolkit::LayoutItem *arg1 = 0 ;
1444   Dali::Toolkit::Internal::LayoutItem *result = 0 ;
1445
1446   arg1 = (Dali::Toolkit::LayoutItem *)jarg1;
1447   if (!arg1) {
1448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutItem & type is null", 0);
1449     return 0;
1450   }
1451   {
1452     try {
1453       result = (Dali::Toolkit::Internal::LayoutItem *) &Dali::Toolkit::GetImplementation(*arg1);
1454     } catch (std::out_of_range& e) {
1455       {
1456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1457       };
1458     } catch (std::exception& e) {
1459       {
1460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1461       };
1462     } catch (...) {
1463       {
1464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1465       };
1466     }
1467   }
1468   jresult = (void *)result;
1469   return jresult;
1470 }*/
1471
1472 #ifdef __cplusplus
1473 }
1474 #endif