dali-csharp-binder/src/layout-length.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include "common.h"
  19
  20 #ifdef __cplusplus
  21 extern "C" {
  22 #endif
  23
  24 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutLength__SWIG_0(int jarg1) {
  25   void * jresult ;
  26   Dali::Toolkit::LayoutLength::IntType arg1 ;
  27   Dali::Toolkit::LayoutLength *result = 0 ;
  28
  29   arg1 = (Dali::Toolkit::LayoutLength::IntType)jarg1;
  30   {
  31     try {
  32       result = (Dali::Toolkit::LayoutLength *)new Dali::Toolkit::LayoutLength(arg1);
  33     } catch (std::out_of_range& e) {
  34       {
  35         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  36       };
  37     } catch (std::exception& e) {
  38       {
  39         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  40       };
  41     } catch (...) {
  42       {
  43         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  44       };
  45     }
  46   }
  47   jresult = (void *)result;
  48   return jresult;
  49 }
  50
  51
  52 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LayoutLength__SWIG_1(void * jarg1) {
  53   void * jresult ;
  54   Dali::Toolkit::LayoutLength *arg1 = 0 ;
  55   Dali::Toolkit::LayoutLength *result = 0 ;
  56
  57   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
  58   if (!arg1) {
  59     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
  60     return 0;
  61   }
  62   {
  63     try {
  64       result = (Dali::Toolkit::LayoutLength *)new Dali::Toolkit::LayoutLength((Dali::Toolkit::LayoutLength const &)*arg1);
  65     } catch (std::out_of_range& e) {
  66       {
  67         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  68       };
  69     } catch (std::exception& e) {
  70       {
  71         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  72       };
  73     } catch (...) {
  74       {
  75         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  76       };
  77     }
  78   }
  79   jresult = (void *)result;
  80   return jresult;
  81 }
  82
  83
  84 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Assign(void * jarg1, void * jarg2) {
  85   void * jresult ;
  86   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
  87   Dali::Toolkit::LayoutLength *arg2 = 0 ;
  88   Dali::Toolkit::LayoutLength *result = 0 ;
  89
  90   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
  91   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
  92   if (!arg2) {
  93     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
  94     return 0;
  95   }
  96   {
  97     try {
  98       result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator =((Dali::Toolkit::LayoutLength const &)*arg2);
  99     } catch (std::out_of_range& e) {
 100       {
 101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 102       };
 103     } catch (std::exception& e) {
 104       {
 105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 106       };
 107     } catch (...) {
 108       {
 109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 110       };
 111     }
 112   }
 113   jresult = (void *)result;
 114   return jresult;
 115 }
 116
 117
 118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutLength_EqualTo__SWIG_0(void * jarg1, void * jarg2) {
 119   unsigned int jresult ;
 120   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 121   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 122   bool result;
 123
 124   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 125   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 126   if (!arg2) {
 127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 128     return 0;
 129   }
 130   {
 131     try {
 132       result = (bool)(arg1)->operator ==((Dali::Toolkit::LayoutLength const &)*arg2);
 133     } catch (std::out_of_range& e) {
 134       {
 135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 136       };
 137     } catch (std::exception& e) {
 138       {
 139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 140       };
 141     } catch (...) {
 142       {
 143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 144       };
 145     }
 146   }
 147   jresult = result;
 148   return jresult;
 149 }
 150
 151
 152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutLength_EqualTo__SWIG_1(void * jarg1, int jarg2) {
 153   unsigned int jresult ;
 154   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 155   Dali::Toolkit::LayoutLength::IntType arg2 ;
 156   bool result;
 157
 158   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 159   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 160   {
 161     try {
 162       result = (bool)(arg1)->operator ==(arg2);
 163     } catch (std::out_of_range& e) {
 164       {
 165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 166       };
 167     } catch (std::exception& e) {
 168       {
 169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 170       };
 171     } catch (...) {
 172       {
 173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 174       };
 175     }
 176   }
 177   jresult = result;
 178   return jresult;
 179 }
 180
 181
 182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutLength_NotEqualTo(void * jarg1, void * jarg2) {
 183   unsigned int jresult ;
 184   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 185   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 186   bool result;
 187
 188   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 189   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 190   if (!arg2) {
 191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 192     return 0;
 193   }
 194   {
 195     try {
 196       result = (bool)(arg1)->operator !=((Dali::Toolkit::LayoutLength const &)*arg2);
 197     } catch (std::out_of_range& e) {
 198       {
 199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 200       };
 201     } catch (std::exception& e) {
 202       {
 203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 204       };
 205     } catch (...) {
 206       {
 207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 208       };
 209     }
 210   }
 211   jresult = result;
 212   return jresult;
 213 }
 214
 215
 216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutLength_LessThan__SWIG_0(void * jarg1, void * jarg2) {
 217   unsigned int jresult ;
 218   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 219   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 220   bool result;
 221
 222   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 223   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 224   if (!arg2) {
 225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 226     return 0;
 227   }
 228   {
 229     try {
 230       result = (bool)(arg1)->operator <((Dali::Toolkit::LayoutLength const &)*arg2);
 231     } catch (std::out_of_range& e) {
 232       {
 233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 234       };
 235     } catch (std::exception& e) {
 236       {
 237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 238       };
 239     } catch (...) {
 240       {
 241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 242       };
 243     }
 244   }
 245   jresult = result;
 246   return jresult;
 247 }
 248
 249
 250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LayoutLength_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
 251   unsigned int jresult ;
 252   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 253   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 254   bool result;
 255
 256   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 257   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 258   if (!arg2) {
 259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 260     return 0;
 261   }
 262   {
 263     try
 264     {
 265       // Umar:: To do Later///
 266       //result = (bool)(arg1)->operator >((Dali::Toolkit::LayoutLength const &)*arg2);
 267     } catch (std::out_of_range& e) {
 268       {
 269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 270       };
 271     } catch (std::exception& e) {
 272       {
 273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 274       };
 275     } catch (...) {
 276       {
 277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 278       };
 279     }
 280   }
 281   jresult = result;
 282   return jresult;
 283 }
 284
 285
 286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Add__SWIG_0(void * jarg1, void * jarg2) {
 287   void * jresult ;
 288   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 289   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 290   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 291
 292   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 293   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 294   if (!arg2) {
 295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 296     return 0;
 297   }
 298   {
 299     try {
 300       result = (arg1)->operator +((Dali::Toolkit::LayoutLength const &)*arg2);
 301     } catch (std::out_of_range& e) {
 302       {
 303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 304       };
 305     } catch (std::exception& e) {
 306       {
 307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 308       };
 309     } catch (...) {
 310       {
 311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 312       };
 313     }
 314   }
 315   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 316   return jresult;
 317 }
 318
 319
 320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Add__SWIG_1(void * jarg1, int jarg2) {
 321   void * jresult ;
 322   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 323   Dali::Toolkit::LayoutLength::IntType arg2 ;
 324   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 325
 326   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 327   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 328   {
 329     try {
 330       result = (arg1)->operator +(arg2);
 331     } catch (std::out_of_range& e) {
 332       {
 333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 334       };
 335     } catch (std::exception& e) {
 336       {
 337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 338       };
 339     } catch (...) {
 340       {
 341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 342       };
 343     }
 344   }
 345   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 346   return jresult;
 347 }
 348
 349
 350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Subtract__SWIG_0(void * jarg1, void * jarg2) {
 351   void * jresult ;
 352   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 353   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 354   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 355
 356   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 357   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 358   if (!arg2) {
 359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 360     return 0;
 361   }
 362   {
 363     try {
 364       result = (arg1)->operator -((Dali::Toolkit::LayoutLength const &)*arg2);
 365     } catch (std::out_of_range& e) {
 366       {
 367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 368       };
 369     } catch (std::exception& e) {
 370       {
 371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 372       };
 373     } catch (...) {
 374       {
 375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 376       };
 377     }
 378   }
 379   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 380   return jresult;
 381 }
 382
 383
 384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Subtract__SWIG_1(void * jarg1, int jarg2) {
 385   void * jresult ;
 386   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 387   Dali::Toolkit::LayoutLength::IntType arg2 ;
 388   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 389
 390   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 391   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 392   {
 393     try {
 394       result = (arg1)->operator -(arg2);
 395     } catch (std::out_of_range& e) {
 396       {
 397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 398       };
 399     } catch (std::exception& e) {
 400       {
 401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 402       };
 403     } catch (...) {
 404       {
 405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 406       };
 407     }
 408   }
 409   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 410   return jresult;
 411 }
 412
 413
 414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_AddAssign__SWIG_0(void * jarg1, void * jarg2) {
 415   void * jresult ;
 416   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 417   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 418   Dali::Toolkit::LayoutLength *result = 0 ;
 419
 420   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 421   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 422   if (!arg2) {
 423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 424     return 0;
 425   }
 426   {
 427     try {
 428       result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator +=((Dali::Toolkit::LayoutLength const &)*arg2);
 429     } catch (std::out_of_range& e) {
 430       {
 431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 432       };
 433     } catch (std::exception& e) {
 434       {
 435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 436       };
 437     } catch (...) {
 438       {
 439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 440       };
 441     }
 442   }
 443   jresult = (void *)result;
 444   return jresult;
 445 }
 446
 447
 448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_AddAssign__SWIG_1(void * jarg1, int jarg2) {
 449   void * jresult ;
 450   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 451   Dali::Toolkit::LayoutLength::IntType arg2 ;
 452   Dali::Toolkit::LayoutLength *result = 0 ;
 453
 454   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 455   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 456   {
 457     try {
 458       result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator +=(arg2);
 459     } catch (std::out_of_range& e) {
 460       {
 461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 462       };
 463     } catch (std::exception& e) {
 464       {
 465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 466       };
 467     } catch (...) {
 468       {
 469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 470       };
 471     }
 472   }
 473   jresult = (void *)result;
 474   return jresult;
 475 }
 476
 477
 478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_SubtractAssign__SWIG_0(void * jarg1, void * jarg2) {
 479   void * jresult ;
 480   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 481   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 482   Dali::Toolkit::LayoutLength *result = 0 ;
 483
 484   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 485   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 486   if (!arg2) {
 487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 488     return 0;
 489   }
 490   {
 491     try {
 492       result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator -=((Dali::Toolkit::LayoutLength const &)*arg2);
 493     } catch (std::out_of_range& e) {
 494       {
 495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 496       };
 497     } catch (std::exception& e) {
 498       {
 499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 500       };
 501     } catch (...) {
 502       {
 503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 504       };
 505     }
 506   }
 507   jresult = (void *)result;
 508   return jresult;
 509 }
 510
 511
 512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_SubtractAssign__SWIG_1(void * jarg1, int jarg2) {
 513   void * jresult ;
 514   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 515   Dali::Toolkit::LayoutLength::IntType arg2 ;
 516   Dali::Toolkit::LayoutLength *result = 0 ;
 517
 518   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 519   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 520   {
 521     try {
 522       result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator -=(arg2);
 523     } catch (std::out_of_range& e) {
 524       {
 525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 526       };
 527     } catch (std::exception& e) {
 528       {
 529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 530       };
 531     } catch (...) {
 532       {
 533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 534       };
 535     }
 536   }
 537   jresult = (void *)result;
 538   return jresult;
 539 }
 540
 541
 542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Divide__SWIG_0(void * jarg1, void * jarg2) {
 543   void * jresult ;
 544   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 545   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 546   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 547
 548   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 549   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 550   if (!arg2) {
 551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 552     return 0;
 553   }
 554   {
 555     try {
 556       result = (arg1)->operator /((Dali::Toolkit::LayoutLength const &)*arg2);
 557     } catch (std::out_of_range& e) {
 558       {
 559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 560       };
 561     } catch (std::exception& e) {
 562       {
 563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 564       };
 565     } catch (...) {
 566       {
 567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 568       };
 569     }
 570   }
 571   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 572   return jresult;
 573 }
 574
 575
 576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Divide__SWIG_1(void * jarg1, int jarg2) {
 577   void * jresult ;
 578   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 579   Dali::Toolkit::LayoutLength::IntType arg2 ;
 580   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 581
 582   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 583   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 584   {
 585     try {
 586       result = (arg1)->operator /(arg2);
 587     } catch (std::out_of_range& e) {
 588       {
 589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 590       };
 591     } catch (std::exception& e) {
 592       {
 593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 594       };
 595     } catch (...) {
 596       {
 597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 598       };
 599     }
 600   }
 601   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 602   return jresult;
 603 }
 604
 605
 606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Multiply__SWIG_0(void * jarg1, void * jarg2) {
 607   void * jresult ;
 608   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 609   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 610   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 611
 612   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 613   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 614   if (!arg2) {
 615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 616     return 0;
 617   }
 618   {
 619     try {
 620       result = (arg1)->operator *((Dali::Toolkit::LayoutLength const &)*arg2);
 621     } catch (std::out_of_range& e) {
 622       {
 623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 624       };
 625     } catch (std::exception& e) {
 626       {
 627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 628       };
 629     } catch (...) {
 630       {
 631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 632       };
 633     }
 634   }
 635   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 636   return jresult;
 637 }
 638
 639
 640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Multiply__SWIG_1(void * jarg1, int jarg2) {
 641   void * jresult ;
 642   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 643   Dali::Toolkit::LayoutLength::IntType arg2 ;
 644   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 645
 646   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 647   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 648   {
 649     try {
 650       result = (arg1)->operator *(arg2);
 651     } catch (std::out_of_range& e) {
 652       {
 653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 654       };
 655     } catch (std::exception& e) {
 656       {
 657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 658       };
 659     } catch (...) {
 660       {
 661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 662       };
 663     }
 664   }
 665   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 666   return jresult;
 667 }
 668
 669
 670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Multiply__SWIG_2(void * jarg1, float jarg2) {
 671   void * jresult ;
 672   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 673   float arg2 ;
 674   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 675
 676   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 677   arg2 = (float)jarg2;
 678   {
 679     try {
 680       result = (arg1)->operator *(arg2);
 681     } catch (std::out_of_range& e) {
 682       {
 683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 684       };
 685     } catch (std::exception& e) {
 686       {
 687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 688       };
 689     } catch (...) {
 690       {
 691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 692       };
 693     }
 694   }
 695   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 696   return jresult;
 697 }
 698
 699
 700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_LayoutLength_ConvertToFloat(void * jarg1) {
 701   float jresult ;
 702   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 703   float result;
 704
 705   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 706   {
 707     try {
 708       result = (float)(arg1)->operator float();
 709     } catch (std::out_of_range& e) {
 710       {
 711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 712       };
 713     } catch (std::exception& e) {
 714       {
 715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 716       };
 717     } catch (...) {
 718       {
 719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 720       };
 721     }
 722   }
 723   jresult = result;
 724   return jresult;
 725 }
 726
 727
 728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutLength_mValue_set(void * jarg1, int jarg2) {
 729   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 730   Dali::Toolkit::LayoutLength::IntType arg2 ;
 731
 732   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 733   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 734   if (arg1) (arg1)->mValue = arg2;
 735 }
 736
 737
 738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutLength_mValue_get(void * jarg1) {
 739   int jresult ;
 740   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 741   Dali::Toolkit::LayoutLength::IntType result;
 742
 743   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 744   result = (Dali::Toolkit::LayoutLength::IntType) ((arg1)->mValue);
 745   jresult = result;
 746   return jresult;
 747 }
 748
 749
 750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LayoutLength(void * jarg1) {
 751   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 752
 753   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 754   {
 755     try {
 756       delete arg1;
 757     } catch (std::out_of_range& e) {
 758       {
 759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 760       };
 761     } catch (std::exception& e) {
 762       {
 763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 764       };
 765     } catch (...) {
 766       {
 767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 768       };
 769     }
 770   }
 771 }
 772
 773 #ifdef __cplusplus
 774 }
 775 #endif
 776