dali-csharp-binder/src/flex-layout-wrap.cpp

   1 /*
   2  * Copyright (c) 2021 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 // EXTERNAL INCLUDES
  19 #include <iostream>
  20 #include <dali-toolkit/devel-api/layouting/flex-node.h>
  21
  22 // INTERNAL INCLUDES
  23 #include "common.h"
  24
  25 #ifdef __cplusplus
  26 extern "C" {
  27 #endif
  28
  29 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexLayout_New()
  30 {
  31   Dali::Toolkit::Flex::Node* result = (Dali::Toolkit::Flex::Node*)0;
  32   {
  33     try {
  34       result = new Dali::Toolkit::Flex::Node();
  35     } catch (std::out_of_range& e) {
  36       {
  37         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
  38       };
  39     } catch (std::exception& e) {
  40       {
  41         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
  42       };
  43     } catch (...) {
  44       {
  45         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
  46       };
  47     }
  48   }
  49   return (void *)result;
  50 }
  51
  52
  53 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexLayout(void * jarg1)
  54 {
  55   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
  56
  57   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
  58   {
  59     try {
  60       delete arg1;
  61     } catch (std::out_of_range& e) {
  62       {
  63         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
  64       };
  65     } catch (std::exception& e) {
  66       {
  67         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
  68       };
  69     } catch (...) {
  70       {
  71         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
  72       };
  73     }
  74   }
  75 }
  76
  77
  78 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexDirection(void * jarg1, int jarg2)
  79 {
  80   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
  81   Dali::Toolkit::Flex::FlexDirection arg2 ;
  82
  83   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
  84   arg2 = (Dali::Toolkit::Flex::FlexDirection)jarg2;
  85   {
  86     try {
  87       arg1->Dali::Toolkit::Flex::Node::SetFlexDirection( arg2);
  88     } catch (std::out_of_range& e) {
  89       {
  90         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
  91       };
  92     } catch (std::exception& e) {
  93       {
  94         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
  95       };
  96     } catch (...) {
  97       {
  98         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
  99       };
 100     }
 101   }
 102 }
 103
 104 SWIGEXPORT const Dali::Toolkit::Flex::Node* SWIGSTDCALL CSharp_Dali_FlexLayout_AddChildWithMargin(void * jarg1, void *jarg2, void *jarg3, Dali::Toolkit::Flex::MeasureCallback jarg4, int jarg5)
 105 {
 106   Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1;
 107   Dali::Actor *arg2 = (Dali::Actor *) 0;  arg2 = (Dali::Actor *)jarg2;
 108   const Dali::Toolkit::Flex::Node* result = nullptr;
 109
 110   {
 111     try {
 112       if(jarg3 == NULL)
 113       {
 114         result = arg1->Dali::Toolkit::Flex::Node::AddChild((Dali::Actor &)*arg2, Dali::Extents(0,0,0,0), jarg4, jarg5);
 115       }
 116       else
 117       {
 118         Dali::Extents* arg3 = (Dali::Extents *)jarg3;
 119         result = arg1->Dali::Toolkit::Flex::Node::AddChild((Dali::Actor &)*arg2, *arg3, jarg4, jarg5);
 120       }
 121     } catch (std::out_of_range& e) {
 122       {
 123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 124       };
 125     } catch (std::exception& e) {
 126       {
 127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 128       };
 129     } catch (...) {
 130       {
 131         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 132       };
 133     }
 134   }
 135   return result;
 136 }
 137
 138 SWIGEXPORT const Dali::Toolkit::Flex::Node* SWIGSTDCALL CSharp_Dali_FlexLayout_AddChild(void * jarg1, void *jarg2, Dali::Toolkit::Flex::MeasureCallback jarg3, int jarg4)
 139 {
 140   return CSharp_Dali_FlexLayout_AddChildWithMargin(jarg1,jarg2,NULL,jarg3,jarg4);
 141 }
 142
 143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_RemoveChild(void * jarg1, void * jarg2)
 144 {
 145   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 146   Dali::Actor* arg2 = (Dali::Actor *)jarg2;
 147
 148   arg1 = (Dali::Toolkit::Flex::Node*)jarg1;
 149   {
 150     try {
 151       arg1->Dali::Toolkit::Flex::Node::RemoveChild(*arg2);
 152     } catch (std::out_of_range& e) {
 153       {
 154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 155       };
 156     } catch (std::exception& e) {
 157       {
 158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 159       };
 160     } catch (...) {
 161       {
 162         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 163       };
 164     }
 165   }
 166 }
 167
 168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_CalculateLayout(void * jarg1, float jarg2, float jarg3, bool isRtl )
 169 {
 170   Dali::Toolkit::Flex::Node * arg1 = (Dali::Toolkit::Flex::Node* )jarg1;
 171   {
 172     try {
 173       arg1->Dali::Toolkit::Flex::Node::CalculateLayout(jarg2, jarg3, isRtl);
 174     } catch (std::out_of_range& e) {
 175       {
 176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 177       };
 178     } catch (std::exception& e) {
 179       {
 180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 181       };
 182     } catch (...) {
 183       {
 184         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 185       };
 186     }
 187   }
 188 }
 189
 190 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetWidth(void * jarg1 )
 191 {
 192   Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1 ;
 193   float result = 0.0f;
 194   {
 195     try {
 196       result = arg1->Dali::Toolkit::Flex::Node::GetFlexWidth();
 197     } catch (std::out_of_range& e) {
 198       {
 199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 200       };
 201     } catch (std::exception& e) {
 202       {
 203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 204       };
 205     } catch (...) {
 206       {
 207         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 208       };
 209     }
 210   }
 211   return result;
 212 }
 213
 214
 215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetHeight(void * jarg1 )
 216 {
 217   float result = 0.0f;
 218   Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1 ;
 219   {
 220     try {
 221       result = arg1->Dali::Toolkit::Flex::Node::GetFlexHeight();
 222     } catch (std::out_of_range& e) {
 223       {
 224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 225       };
 226     } catch (std::exception& e) {
 227       {
 228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 229       };
 230     } catch (...) {
 231       {
 232         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 233       };
 234     }
 235   }
 236   return result;
 237 }
 238
 239 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_FlexLayout_GetNodeFrame( void * jarg1, int index )
 240 {
 241   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 242   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 243   Dali::Vector4 result;
 244   void* jresult;
 245   {
 246     try {
 247       result = arg1->Dali::Toolkit::Flex::Node::GetNodeFrame(index);
 248     } catch (std::out_of_range& e) {
 249       {
 250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 251       };
 252     } catch (std::exception& e) {
 253       {
 254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 255       };
 256     } catch (...) {
 257       {
 258         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 259       };
 260     }
 261   }
 262
 263   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
 264   return jresult;
 265 }
 266
 267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetMargin(void * jarg1, void * jarg2)
 268 {
 269   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 270
 271   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 272   Dali::Extents* arg2 = (Dali::Extents *)jarg2;
 273   {
 274     try {
 275       arg1->Dali::Toolkit::Flex::Node::SetMargin( *arg2);
 276     } catch (std::out_of_range& e) {
 277       {
 278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 279       };
 280     } catch (std::exception& e) {
 281       {
 282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 283       };
 284     } catch (...) {
 285       {
 286         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 287       };
 288     }
 289   }
 290 }
 291
 292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetPadding(void * jarg1, void * jarg2)
 293 {
 294   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 295
 296   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 297   Dali::Extents* arg2 = (Dali::Extents *)jarg2;
 298   {
 299     try {
 300       arg1->Dali::Toolkit::Flex::Node::SetPadding( *arg2);
 301     } catch (std::out_of_range& e) {
 302       {
 303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 304       };
 305     } catch (std::exception& e) {
 306       {
 307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 308       };
 309     } catch (...) {
 310       {
 311         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 312       };
 313     }
 314   }
 315 }
 316
 317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexDirection(void * jarg1)
 318 {
 319   int jresult ;
 320   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 321   Dali::Toolkit::Flex::FlexDirection result;
 322
 323   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 324   {
 325     try {
 326       result = (Dali::Toolkit::Flex::FlexDirection)arg1->Dali::Toolkit::Flex::Node::GetFlexDirection();
 327     } CALL_CATCH_EXCEPTION(0);
 328   }
 329   jresult = (int)result;
 330   return jresult;
 331 }
 332
 333
 334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexJustification(void * jarg1, int jarg2)
 335 {
 336   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 337   Dali::Toolkit::Flex::Justification arg2 ;
 338
 339   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 340   arg2 = (Dali::Toolkit::Flex::Justification)jarg2;
 341   {
 342     try {
 343       arg1->Dali::Toolkit::Flex::Node::SetFlexJustification(arg2);
 344     } CALL_CATCH_EXCEPTION();
 345   }
 346 }
 347
 348
 349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexJustification(void * jarg1)
 350 {
 351   int jresult ;
 352   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 353   Dali::Toolkit::Flex::Justification result;
 354
 355   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 356   {
 357     try {
 358       result = (Dali::Toolkit::Flex::Justification)arg1->Dali::Toolkit::Flex::Node::GetFlexJustification();
 359     } CALL_CATCH_EXCEPTION(0);
 360   }
 361   jresult = (int)result;
 362   return jresult;
 363 }
 364
 365
 366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexWrap(void * jarg1, int jarg2)
 367 {
 368
 369   Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 370   Dali::Toolkit::Flex::WrapType arg2 = (Dali::Toolkit::Flex::WrapType)jarg2;
 371   {
 372     try {
 373       arg1->Dali::Toolkit::Flex::Node::SetFlexWrap(arg2);
 374     } CALL_CATCH_EXCEPTION();
 375   }
 376 }
 377
 378
 379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexWrap(void * jarg1)
 380 {
 381   int jresult ;
 382   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 383   Dali::Toolkit::Flex::WrapType result;
 384
 385   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 386   {
 387     try {
 388       result = (Dali::Toolkit::Flex::WrapType)arg1->Dali::Toolkit::Flex::Node::GetFlexWrap();
 389     } CALL_CATCH_EXCEPTION(0);
 390   }
 391   jresult = (int)result;
 392   return jresult;
 393 }
 394
 395
 396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexAlignment(void * jarg1, int jarg2)
 397 {
 398   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 399   Dali::Toolkit::Flex::Alignment arg2 ;
 400
 401   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 402   arg2 = (Dali::Toolkit::Flex::Alignment)jarg2;
 403   {
 404     try {
 405       arg1->Dali::Toolkit::Flex::Node::SetFlexAlignment(arg2);
 406     } CALL_CATCH_EXCEPTION();
 407   }
 408 }
 409
 410
 411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexAlignment(void * jarg1)
 412 {
 413   int jresult ;
 414   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 415   Dali::Toolkit::Flex::Alignment result;
 416
 417   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 418   {
 419     try {
 420       result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexAlignment();
 421     } CALL_CATCH_EXCEPTION(0);
 422   }
 423   jresult = (int)result;
 424   return jresult;
 425 }
 426
 427
 428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexItemsAlignment(void * jarg1, int jarg2)
 429 {
 430   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 431   Dali::Toolkit::Flex::Alignment arg2 ;
 432
 433   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 434   arg2 = (Dali::Toolkit::Flex::Alignment)jarg2;
 435   {
 436     try {
 437       arg1->Dali::Toolkit::Flex::Node::SetFlexItemsAlignment(arg2);
 438     } CALL_CATCH_EXCEPTION();
 439   }
 440 }
 441
 442
 443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexItemsAlignment(void * jarg1)
 444 {
 445   int jresult ;
 446   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 447   Dali::Toolkit::Flex::Alignment result;
 448
 449   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 450   {
 451     try {
 452       result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexItemsAlignment();
 453     } CALL_CATCH_EXCEPTION(0);
 454   }
 455   jresult = (int)result;
 456   return jresult;
 457 }
 458
 459
 460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexAlignmentSelf(void * jarg1, int jarg2)
 461 {
 462   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 463   Dali::Toolkit::Flex::Alignment arg2 ;
 464
 465   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 466   arg2 = (Dali::Toolkit::Flex::Alignment)jarg2;
 467   {
 468     try {
 469       arg1->Dali::Toolkit::Flex::Node::SetFlexAlignmentSelf(arg2);
 470     } CALL_CATCH_EXCEPTION();
 471   }
 472 }
 473
 474
 475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexAlignmentSelf(void * jarg1)
 476 {
 477   int jresult ;
 478   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 479   Dali::Toolkit::Flex::Alignment result;
 480
 481   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 482   {
 483     try {
 484       result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexAlignmentSelf();
 485     } CALL_CATCH_EXCEPTION(0);
 486   }
 487   jresult = (int)result;
 488   return jresult;
 489 }
 490
 491
 492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexPositionType(void * jarg1, int jarg2)
 493 {
 494   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 495   Dali::Toolkit::Flex::PositionType arg2 ;
 496
 497   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 498   arg2 = (Dali::Toolkit::Flex::PositionType)jarg2;
 499   {
 500     try {
 501       arg1->Dali::Toolkit::Flex::Node::SetFlexPositionType(arg2);
 502     } CALL_CATCH_EXCEPTION();
 503   }
 504 }
 505
 506
 507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexPositionType(void * jarg1)
 508 {
 509   int jresult ;
 510   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 511   Dali::Toolkit::Flex::PositionType result;
 512
 513   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 514   {
 515     try {
 516       result = (Dali::Toolkit::Flex::PositionType)arg1->Dali::Toolkit::Flex::Node::GetFlexPositionType();
 517     } CALL_CATCH_EXCEPTION(0);
 518   }
 519   jresult = (int)result;
 520   return jresult;
 521 }
 522
 523
 524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexAspectRatio(void * jarg1, float jarg2)
 525 {
 526   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 527   float arg2 ;
 528
 529   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 530   arg2 = (float)jarg2;
 531   {
 532     try {
 533       arg1->Dali::Toolkit::Flex::Node::SetFlexAspectRatio(arg2);
 534     } CALL_CATCH_EXCEPTION();
 535   }
 536 }
 537
 538
 539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexAspectRatio(void * jarg1)
 540 {
 541   int jresult ;
 542   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 543   float result;
 544
 545   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 546   {
 547     try {
 548       result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexAspectRatio();
 549     } CALL_CATCH_EXCEPTION(0);
 550   }
 551   jresult = (float)result;
 552   return jresult;
 553 }
 554
 555
 556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexBasis(void * jarg1, float jarg2)
 557 {
 558   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 559   float arg2 ;
 560
 561   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 562   arg2 = (float)jarg2;
 563   {
 564     try {
 565       arg1->Dali::Toolkit::Flex::Node::SetFlexBasis(arg2);
 566     } CALL_CATCH_EXCEPTION();
 567   }
 568 }
 569
 570
 571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexBasis(void * jarg1)
 572 {
 573   int jresult ;
 574   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 575   float result;
 576
 577   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 578   {
 579     try {
 580       result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexBasis();
 581     } CALL_CATCH_EXCEPTION(0);
 582   }
 583   jresult = (float)result;
 584   return jresult;
 585 }
 586
 587
 588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexShrink(void * jarg1, float jarg2)
 589 {
 590   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 591   float arg2 ;
 592
 593   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 594   arg2 = (float)jarg2;
 595   {
 596     try {
 597       arg1->Dali::Toolkit::Flex::Node::SetFlexShrink(arg2);
 598     } CALL_CATCH_EXCEPTION();
 599   }
 600 }
 601
 602
 603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexShrink(void * jarg1)
 604 {
 605   int jresult ;
 606   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 607   float result;
 608
 609   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 610   {
 611     try {
 612       result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexShrink();
 613     } CALL_CATCH_EXCEPTION(0);
 614   }
 615   jresult = (float)result;
 616   return jresult;
 617 }
 618
 619
 620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexGrow(void * jarg1, float jarg2)
 621 {
 622   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 623   float arg2 ;
 624
 625   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 626   arg2 = (float)jarg2;
 627   {
 628     try {
 629       arg1->Dali::Toolkit::Flex::Node::SetFlexGrow(arg2);
 630     } CALL_CATCH_EXCEPTION();
 631   }
 632 }
 633
 634
 635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexGrow(void * jarg1)
 636 {
 637   int jresult ;
 638   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 639   float result;
 640
 641   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 642   {
 643     try {
 644       result = (float)arg1->Dali::Toolkit::Flex::Node::GetFlexGrow();
 645     } CALL_CATCH_EXCEPTION(0);
 646   }
 647   jresult = (float)result;
 648   return jresult;
 649 }
 650
 651
 652 #ifdef __cplusplus
 653 }
 654 #endif