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   if(!darg)
 971   {
 972     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
 973     return;
 974   }
 975   {
 976     try {
 977       (darg)->OnUnparent();
 978     } catch (std::out_of_range& e) {
 979       {
 980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 981       };
 982     } catch (std::exception& e) {
 983       {
 984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 985       };
 986     } catch (...) {
 987       {
 988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 989       };
 990     }
 991   }
 992 }
 993
 994
 995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnUnparentSwigExplicitLayoutItemWrapperImpl(void * jarg1) {
 996   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
 997   SwigDirector_LayoutItemWrapperImpl *darg = 0;
 998
 999   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1000   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1001   if(!darg)
1002   {
1003     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1004     return;
1005   }
1006   {
1007     try {
1008       (darg)->OnUnparentSwigPublic();
1009     } catch (std::out_of_range& e) {
1010       {
1011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1012       };
1013     } catch (std::exception& e) {
1014       {
1015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1016       };
1017     } catch (...) {
1018       {
1019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1020       };
1021     }
1022   }
1023 }
1024
1025
1026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnRegisterChildProperties(void * jarg1, char * jarg2) {
1027   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1028   std::string *arg2 = 0 ;
1029   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1030
1031   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1032   if (!jarg2) {
1033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1034     return ;
1035   }
1036   std::string arg2_str(jarg2);
1037   arg2 = &arg2_str;
1038   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1039   if(!darg)
1040   {
1041     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1042     return;
1043   }
1044   {
1045     try {
1046       (darg)->OnRegisterChildProperties((std::string const &)*arg2);
1047     } catch (std::out_of_range& e) {
1048       {
1049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1050       };
1051     } catch (std::exception& e) {
1052       {
1053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1054       };
1055     } catch (...) {
1056       {
1057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1058       };
1059     }
1060   }
1061
1062   //argout typemap for const std::string&
1063
1064 }
1065
1066
1067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnRegisterChildPropertiesSwigExplicitLayoutItemWrapperImpl(void * jarg1, char * jarg2) {
1068   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1069   std::string *arg2 = 0 ;
1070   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1071
1072   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1073   if (!jarg2) {
1074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1075     return ;
1076   }
1077   std::string arg2_str(jarg2);
1078   arg2 = &arg2_str;
1079   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1080   if(!darg)
1081   {
1082     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1083     return;
1084   }
1085   {
1086     try {
1087       (darg)->OnRegisterChildPropertiesSwigPublic((std::string const &)*arg2);
1088     } catch (std::out_of_range& e) {
1089       {
1090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1091       };
1092     } catch (std::exception& e) {
1093       {
1094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1095       };
1096     } catch (...) {
1097       {
1098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1099       };
1100     }
1101   }
1102
1103   //argout typemap for const std::string&
1104
1105 }
1106
1107
1108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnMeasure(void * jarg1, void * jarg2, void * jarg3) {
1109   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1110   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
1111   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ;
1112   Dali::Toolkit::MeasureSpec *argp2 ;
1113   Dali::Toolkit::MeasureSpec *argp3 ;
1114   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1115
1116   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1117   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
1118   if (!argp2) {
1119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1120     return ;
1121   }
1122   arg2 = *argp2;
1123   argp3 = (Dali::Toolkit::MeasureSpec *)jarg3;
1124   if (!argp3) {
1125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1126     return ;
1127   }
1128   arg3 = *argp3;
1129   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1130   if(!darg)
1131   {
1132     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1133     return;
1134   }
1135   {
1136     try {
1137       (darg)->OnMeasure(arg2,arg3);
1138     } catch (std::out_of_range& e) {
1139       {
1140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1141       };
1142     } catch (std::exception& e) {
1143       {
1144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1145       };
1146     } catch (...) {
1147       {
1148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1149       };
1150     }
1151   }
1152 }
1153
1154
1155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnMeasureSwigExplicitLayoutItemWrapperImpl(void * jarg1, void * jarg2, void * jarg3) {
1156   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1157   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg2 ;
1158   SwigValueWrapper< Dali::Toolkit::MeasureSpec > arg3 ;
1159   Dali::Toolkit::MeasureSpec *argp2 ;
1160   Dali::Toolkit::MeasureSpec *argp3 ;
1161   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1162
1163   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1164   argp2 = (Dali::Toolkit::MeasureSpec *)jarg2;
1165   if (!argp2) {
1166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1167     return ;
1168   }
1169   arg2 = *argp2;
1170   argp3 = (Dali::Toolkit::MeasureSpec *)jarg3;
1171   if (!argp3) {
1172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::MeasureSpec", 0);
1173     return ;
1174   }
1175   arg3 = *argp3;
1176   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1177   if(!darg)
1178   {
1179     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1180     return;
1181   }
1182   {
1183     try {
1184       (darg)->OnMeasureSwigPublic(arg2,arg3);
1185     } catch (std::out_of_range& e) {
1186       {
1187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1188       };
1189     } catch (std::exception& e) {
1190       {
1191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1192       };
1193     } catch (...) {
1194       {
1195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1196       };
1197     }
1198   }
1199 }
1200
1201
1202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnLayout(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
1203   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1204   bool arg2 ;
1205   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg3 ;
1206   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg4 ;
1207   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg5 ;
1208   SwigValueWrapper< Dali::Toolkit::LayoutLength > arg6 ;
1209   Dali::Toolkit::LayoutLength *argp3 ;
1210   Dali::Toolkit::LayoutLength *argp4 ;
1211   Dali::Toolkit::LayoutLength *argp5 ;
1212   Dali::Toolkit::LayoutLength *argp6 ;
1213   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1214
1215   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1216   arg2 = jarg2 ? true : false;
1217   argp3 = (Dali::Toolkit::LayoutLength *)jarg3;
1218   if (!argp3) {
1219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1220     return ;
1221   }
1222   arg3 = *argp3;
1223   argp4 = (Dali::Toolkit::LayoutLength *)jarg4;
1224   if (!argp4) {
1225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1226     return ;
1227   }
1228   arg4 = *argp4;
1229   argp5 = (Dali::Toolkit::LayoutLength *)jarg5;
1230   if (!argp5) {
1231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1232     return ;
1233   }
1234   arg5 = *argp5;
1235   argp6 = (Dali::Toolkit::LayoutLength *)jarg6;
1236   if (!argp6) {
1237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutLength", 0);
1238     return ;
1239   }
1240   arg6 = *argp6;
1241   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1242   if(!darg)
1243   {
1244     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1245     return;
1246   }
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   if(!darg)
1308   {
1309     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1310     return;
1311   }
1312   {
1313     try {
1314       (darg)->OnLayoutSwigPublic(arg2,arg3,arg4,arg5,arg6);
1315     } catch (std::out_of_range& e) {
1316       {
1317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1318       };
1319     } catch (std::exception& e) {
1320       {
1321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1322       };
1323     } catch (...) {
1324       {
1325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1326       };
1327     }
1328   }
1329 }
1330
1331
1332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnSizeChanged(void * jarg1, void * jarg2, void * jarg3) {
1333   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1334   Dali::Toolkit::LayoutSize arg2 ;
1335   Dali::Toolkit::LayoutSize arg3 ;
1336   Dali::Toolkit::LayoutSize *argp2 ;
1337   Dali::Toolkit::LayoutSize *argp3 ;
1338   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1339
1340   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1341   argp2 = (Dali::Toolkit::LayoutSize *)jarg2;
1342   if (!argp2) {
1343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1344     return ;
1345   }
1346   arg2 = *argp2;
1347   argp3 = (Dali::Toolkit::LayoutSize *)jarg3;
1348   if (!argp3) {
1349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1350     return ;
1351   }
1352   arg3 = *argp3;
1353   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1354   if(!darg)
1355   {
1356     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1357     return;
1358   }
1359   {
1360     try {
1361       (darg)->OnSizeChanged(arg2,arg3);
1362     } catch (std::out_of_range& e) {
1363       {
1364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1365       };
1366     } catch (std::exception& e) {
1367       {
1368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1369       };
1370     } catch (...) {
1371       {
1372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1373       };
1374     }
1375   }
1376 }
1377
1378
1379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnSizeChangedSwigExplicitLayoutItemWrapperImpl(void * jarg1, void * jarg2, void * jarg3) {
1380   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1381   Dali::Toolkit::LayoutSize arg2 ;
1382   Dali::Toolkit::LayoutSize arg3 ;
1383   Dali::Toolkit::LayoutSize *argp2 ;
1384   Dali::Toolkit::LayoutSize *argp3 ;
1385   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1386
1387   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1388   argp2 = (Dali::Toolkit::LayoutSize *)jarg2;
1389   if (!argp2) {
1390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1391     return ;
1392   }
1393   arg2 = *argp2;
1394   argp3 = (Dali::Toolkit::LayoutSize *)jarg3;
1395   if (!argp3) {
1396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutSize", 0);
1397     return ;
1398   }
1399   arg3 = *argp3;
1400   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1401   if(!darg)
1402   {
1403     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1404     return;
1405   }
1406   {
1407     try {
1408       (darg)->OnSizeChangedSwigPublic(arg2,arg3);
1409     } catch (std::out_of_range& e) {
1410       {
1411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1412       };
1413     } catch (std::exception& e) {
1414       {
1415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1416       };
1417     } catch (...) {
1418       {
1419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1420       };
1421     }
1422   }
1423 }
1424
1425
1426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnInitialize(void * jarg1) {
1427   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1428   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1429
1430   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1431   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1432   if(!darg)
1433   {
1434     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1435     return;
1436   }
1437   {
1438     try {
1439       (darg)->OnInitialize();
1440     } catch (std::out_of_range& e) {
1441       {
1442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1443       };
1444     } catch (std::exception& e) {
1445       {
1446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1447       };
1448     } catch (...) {
1449       {
1450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1451       };
1452     }
1453   }
1454 }
1455
1456
1457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_OnInitializeSwigExplicitLayoutItemWrapperImpl(void * jarg1) {
1458   Dali::Toolkit::Internal::LayoutItem *arg1 = (Dali::Toolkit::Internal::LayoutItem *) 0 ;
1459   SwigDirector_LayoutItemWrapperImpl *darg = 0;
1460
1461   arg1 = (Dali::Toolkit::Internal::LayoutItem *)jarg1;
1462   darg = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(arg1);
1463   if(!darg)
1464   {
1465     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_LayoutItemWrapperImpl> error. darg is null");
1466     return;
1467   }
1468   {
1469     try {
1470       (darg)->OnInitializeSwigPublic();
1471     } catch (std::out_of_range& e) {
1472       {
1473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1474       };
1475     } catch (std::exception& e) {
1476       {
1477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1478       };
1479     } catch (...) {
1480       {
1481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1482       };
1483     }
1484   }
1485 }
1486
1487
1488 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) {
1489   Dali::Toolkit::Internal::LayoutItem *obj = (Dali::Toolkit::Internal::LayoutItem *)objarg;
1490   SwigDirector_LayoutItemWrapperImpl *director = dynamic_cast<SwigDirector_LayoutItemWrapperImpl *>(obj);
1491   if (director) {
1492     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6);
1493   }
1494 }
1495
1496 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_LayoutItemWrapperImpl_SWIGUpcast(Dali::Toolkit::Internal::LayoutItem *jarg1) {
1497     return (Dali::BaseObject *)jarg1;
1498 }
1499
1500
1501 /*SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
1502   void * jresult ;
1503   Dali::Toolkit::LayoutItem *arg1 = 0 ;
1504   Dali::Toolkit::Internal::LayoutItem *result = 0 ;
1505
1506   arg1 = (Dali::Toolkit::LayoutItem *)jarg1;
1507   if (!arg1) {
1508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutItem & type is null", 0);
1509     return 0;
1510   }
1511   {
1512     try {
1513       result = (Dali::Toolkit::Internal::LayoutItem *) &Dali::Toolkit::GetImplementation(*arg1);
1514     } catch (std::out_of_range& e) {
1515       {
1516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1517       };
1518     } catch (std::exception& e) {
1519       {
1520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1521       };
1522     } catch (...) {
1523       {
1524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1525       };
1526     }
1527   }
1528   jresult = (void *)result;
1529   return jresult;
1530 }*/
1531
1532 #ifdef __cplusplus
1533 }
1534 #endif