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   // Umar:: To do Later///
 253   //Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 254   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 255   bool result = false;
 256
 257   // Umar:: To do Later///
 258   //arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 259   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 260   if (!arg2) {
 261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 262     return 0;
 263   }
 264   {
 265     try
 266     {
 267       // Umar:: To do Later///
 268       //result = (bool)(arg1)->operator >((Dali::Toolkit::LayoutLength const &)*arg2);
 269     } catch (std::out_of_range& e) {
 270       {
 271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 272       };
 273     } catch (std::exception& e) {
 274       {
 275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 276       };
 277     } catch (...) {
 278       {
 279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 280       };
 281     }
 282   }
 283   jresult = result;
 284   return jresult;
 285 }
 286
 287
 288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Add__SWIG_0(void * jarg1, void * jarg2) {
 289   void * jresult ;
 290   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 291   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 292   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 293
 294   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 295   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 296   if (!arg2) {
 297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 298     return 0;
 299   }
 300   {
 301     try {
 302       result = (arg1)->operator +((Dali::Toolkit::LayoutLength const &)*arg2);
 303     } catch (std::out_of_range& e) {
 304       {
 305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 306       };
 307     } catch (std::exception& e) {
 308       {
 309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 310       };
 311     } catch (...) {
 312       {
 313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 314       };
 315     }
 316   }
 317   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 318   return jresult;
 319 }
 320
 321
 322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Add__SWIG_1(void * jarg1, int jarg2) {
 323   void * jresult ;
 324   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 325   Dali::Toolkit::LayoutLength::IntType arg2 ;
 326   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 327
 328   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 329   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 330   {
 331     try {
 332       result = (arg1)->operator +(arg2);
 333     } catch (std::out_of_range& e) {
 334       {
 335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 336       };
 337     } catch (std::exception& e) {
 338       {
 339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 340       };
 341     } catch (...) {
 342       {
 343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 344       };
 345     }
 346   }
 347   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 348   return jresult;
 349 }
 350
 351
 352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Subtract__SWIG_0(void * jarg1, void * jarg2) {
 353   void * jresult ;
 354   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 355   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 356   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 357
 358   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 359   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 360   if (!arg2) {
 361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 362     return 0;
 363   }
 364   {
 365     try {
 366       result = (arg1)->operator -((Dali::Toolkit::LayoutLength const &)*arg2);
 367     } catch (std::out_of_range& e) {
 368       {
 369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 370       };
 371     } catch (std::exception& e) {
 372       {
 373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 374       };
 375     } catch (...) {
 376       {
 377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 378       };
 379     }
 380   }
 381   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 382   return jresult;
 383 }
 384
 385
 386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Subtract__SWIG_1(void * jarg1, int jarg2) {
 387   void * jresult ;
 388   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 389   Dali::Toolkit::LayoutLength::IntType arg2 ;
 390   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 391
 392   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 393   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 394   {
 395     try {
 396       result = (arg1)->operator -(arg2);
 397     } catch (std::out_of_range& e) {
 398       {
 399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 400       };
 401     } catch (std::exception& e) {
 402       {
 403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 404       };
 405     } catch (...) {
 406       {
 407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 408       };
 409     }
 410   }
 411   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 412   return jresult;
 413 }
 414
 415
 416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_AddAssign__SWIG_0(void * jarg1, void * jarg2) {
 417   void * jresult ;
 418   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 419   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 420   Dali::Toolkit::LayoutLength *result = 0 ;
 421
 422   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 423   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 424   if (!arg2) {
 425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 426     return 0;
 427   }
 428   {
 429     try {
 430       result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator +=((Dali::Toolkit::LayoutLength const &)*arg2);
 431     } catch (std::out_of_range& e) {
 432       {
 433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 434       };
 435     } catch (std::exception& e) {
 436       {
 437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 438       };
 439     } catch (...) {
 440       {
 441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 442       };
 443     }
 444   }
 445   jresult = (void *)result;
 446   return jresult;
 447 }
 448
 449
 450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_AddAssign__SWIG_1(void * jarg1, int jarg2) {
 451   void * jresult ;
 452   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 453   Dali::Toolkit::LayoutLength::IntType arg2 ;
 454   Dali::Toolkit::LayoutLength *result = 0 ;
 455
 456   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 457   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 458   {
 459     try {
 460       result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator +=(arg2);
 461     } catch (std::out_of_range& e) {
 462       {
 463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 464       };
 465     } catch (std::exception& e) {
 466       {
 467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 468       };
 469     } catch (...) {
 470       {
 471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 472       };
 473     }
 474   }
 475   jresult = (void *)result;
 476   return jresult;
 477 }
 478
 479
 480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_SubtractAssign__SWIG_0(void * jarg1, void * jarg2) {
 481   void * jresult ;
 482   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 483   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 484   Dali::Toolkit::LayoutLength *result = 0 ;
 485
 486   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 487   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 488   if (!arg2) {
 489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 490     return 0;
 491   }
 492   {
 493     try {
 494       result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator -=((Dali::Toolkit::LayoutLength const &)*arg2);
 495     } catch (std::out_of_range& e) {
 496       {
 497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 498       };
 499     } catch (std::exception& e) {
 500       {
 501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 502       };
 503     } catch (...) {
 504       {
 505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 506       };
 507     }
 508   }
 509   jresult = (void *)result;
 510   return jresult;
 511 }
 512
 513
 514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_SubtractAssign__SWIG_1(void * jarg1, int jarg2) {
 515   void * jresult ;
 516   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 517   Dali::Toolkit::LayoutLength::IntType arg2 ;
 518   Dali::Toolkit::LayoutLength *result = 0 ;
 519
 520   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 521   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 522   {
 523     try {
 524       result = (Dali::Toolkit::LayoutLength *) &(arg1)->operator -=(arg2);
 525     } catch (std::out_of_range& e) {
 526       {
 527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 528       };
 529     } catch (std::exception& e) {
 530       {
 531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 532       };
 533     } catch (...) {
 534       {
 535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 536       };
 537     }
 538   }
 539   jresult = (void *)result;
 540   return jresult;
 541 }
 542
 543
 544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Divide__SWIG_0(void * jarg1, void * jarg2) {
 545   void * jresult ;
 546   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 547   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 548   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 549
 550   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 551   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 552   if (!arg2) {
 553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 554     return 0;
 555   }
 556   {
 557     try {
 558       result = (arg1)->operator /((Dali::Toolkit::LayoutLength const &)*arg2);
 559     } catch (std::out_of_range& e) {
 560       {
 561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 562       };
 563     } catch (std::exception& e) {
 564       {
 565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 566       };
 567     } catch (...) {
 568       {
 569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 570       };
 571     }
 572   }
 573   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 574   return jresult;
 575 }
 576
 577
 578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Divide__SWIG_1(void * jarg1, int jarg2) {
 579   void * jresult ;
 580   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 581   Dali::Toolkit::LayoutLength::IntType arg2 ;
 582   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 583
 584   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 585   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 586   {
 587     try {
 588       result = (arg1)->operator /(arg2);
 589     } catch (std::out_of_range& e) {
 590       {
 591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 592       };
 593     } catch (std::exception& e) {
 594       {
 595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 596       };
 597     } catch (...) {
 598       {
 599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 600       };
 601     }
 602   }
 603   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 604   return jresult;
 605 }
 606
 607
 608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Multiply__SWIG_0(void * jarg1, void * jarg2) {
 609   void * jresult ;
 610   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 611   Dali::Toolkit::LayoutLength *arg2 = 0 ;
 612   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 613
 614   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 615   arg2 = (Dali::Toolkit::LayoutLength *)jarg2;
 616   if (!arg2) {
 617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::LayoutLength const & type is null", 0);
 618     return 0;
 619   }
 620   {
 621     try {
 622       result = (arg1)->operator *((Dali::Toolkit::LayoutLength const &)*arg2);
 623     } catch (std::out_of_range& e) {
 624       {
 625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 626       };
 627     } catch (std::exception& e) {
 628       {
 629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 630       };
 631     } catch (...) {
 632       {
 633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 634       };
 635     }
 636   }
 637   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 638   return jresult;
 639 }
 640
 641
 642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Multiply__SWIG_1(void * jarg1, int jarg2) {
 643   void * jresult ;
 644   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 645   Dali::Toolkit::LayoutLength::IntType arg2 ;
 646   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 647
 648   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 649   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 650   {
 651     try {
 652       result = (arg1)->operator *(arg2);
 653     } catch (std::out_of_range& e) {
 654       {
 655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 656       };
 657     } catch (std::exception& e) {
 658       {
 659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 660       };
 661     } catch (...) {
 662       {
 663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 664       };
 665     }
 666   }
 667   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 668   return jresult;
 669 }
 670
 671
 672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutLength_Multiply__SWIG_2(void * jarg1, float jarg2) {
 673   void * jresult ;
 674   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 675   float arg2 ;
 676   SwigValueWrapper< Dali::Toolkit::LayoutLength > result;
 677
 678   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 679   arg2 = (float)jarg2;
 680   {
 681     try {
 682       result = (arg1)->operator *(arg2);
 683     } catch (std::out_of_range& e) {
 684       {
 685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 686       };
 687     } catch (std::exception& e) {
 688       {
 689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 690       };
 691     } catch (...) {
 692       {
 693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 694       };
 695     }
 696   }
 697   jresult = new Dali::Toolkit::LayoutLength((const Dali::Toolkit::LayoutLength &)result);
 698   return jresult;
 699 }
 700
 701
 702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_LayoutLength_ConvertToFloat(void * jarg1) {
 703   float jresult ;
 704   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 705   float result;
 706
 707   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 708   {
 709     try {
 710       result = (float)(arg1)->operator float();
 711     } catch (std::out_of_range& e) {
 712       {
 713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 714       };
 715     } catch (std::exception& e) {
 716       {
 717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 718       };
 719     } catch (...) {
 720       {
 721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 722       };
 723     }
 724   }
 725   jresult = result;
 726   return jresult;
 727 }
 728
 729
 730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LayoutLength_mValue_set(void * jarg1, int jarg2) {
 731   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 732   Dali::Toolkit::LayoutLength::IntType arg2 ;
 733
 734   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 735   arg2 = (Dali::Toolkit::LayoutLength::IntType)jarg2;
 736   if (arg1) (arg1)->mValue = arg2;
 737 }
 738
 739
 740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LayoutLength_mValue_get(void * jarg1) {
 741   int jresult ;
 742   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 743   Dali::Toolkit::LayoutLength::IntType result;
 744
 745   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 746   result = (Dali::Toolkit::LayoutLength::IntType) ((arg1)->mValue);
 747   jresult = result;
 748   return jresult;
 749 }
 750
 751
 752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LayoutLength(void * jarg1) {
 753   Dali::Toolkit::LayoutLength *arg1 = (Dali::Toolkit::LayoutLength *) 0 ;
 754
 755   arg1 = (Dali::Toolkit::LayoutLength *)jarg1;
 756   {
 757     try {
 758       delete arg1;
 759     } catch (std::out_of_range& e) {
 760       {
 761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 762       };
 763     } catch (std::exception& e) {
 764       {
 765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 766       };
 767     } catch (...) {
 768       {
 769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 770       };
 771     }
 772   }
 773 }
 774
 775 #ifdef __cplusplus
 776 }
 777 #endif
 778