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

   1 #ifndef CSHARP_FLEX_LAYOUT
   2 #define CSHARP_FLEX_LAYOUT
   3 #endif
   4
   5 #include "common.h"
   6 #include <dali-toolkit/devel-api/layouting/flex-node.h>
   7 #include <iostream>
   8
   9 #ifdef __cplusplus
  10 extern "C" {
  11 #endif
  12
  13 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexLayout_New()
  14 {
  15   Dali::Toolkit::Flex::Node* result = (Dali::Toolkit::Flex::Node*)0;
  16   {
  17     try {
  18       result = new Dali::Toolkit::Flex::Node();
  19     } catch (std::out_of_range& e) {
  20       {
  21         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
  22       };
  23     } catch (std::exception& e) {
  24       {
  25         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
  26       };
  27     } catch (...) {
  28       {
  29         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
  30       };
  31     }
  32   }
  33   return (void *)result;
  34 }
  35
  36
  37 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexLayout(void * jarg1)
  38 {
  39   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
  40
  41   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
  42   {
  43     try {
  44       delete arg1;
  45     } catch (std::out_of_range& e) {
  46       {
  47         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
  48       };
  49     } catch (std::exception& e) {
  50       {
  51         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
  52       };
  53     } catch (...) {
  54       {
  55         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
  56       };
  57     }
  58   }
  59 }
  60
  61
  62 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexDirection(void * jarg1, int jarg2)
  63 {
  64   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
  65   Dali::Toolkit::Flex::FlexDirection arg2 ;
  66
  67   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
  68   arg2 = (Dali::Toolkit::Flex::FlexDirection)jarg2;
  69   {
  70     try {
  71       arg1->Dali::Toolkit::Flex::Node::SetFlexDirection( arg2);
  72     } catch (std::out_of_range& e) {
  73       {
  74         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
  75       };
  76     } catch (std::exception& e) {
  77       {
  78         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
  79       };
  80     } catch (...) {
  81       {
  82         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
  83       };
  84     }
  85   }
  86 }
  87
  88 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_AddChildWithMargin(void * jarg1, void *jarg2, void *jarg3, Dali::Toolkit::Flex::MeasureCallback jarg4, int jarg5)
  89 {
  90   Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1;
  91   Dali::Actor *arg2 = (Dali::Actor *) 0;  arg2 = (Dali::Actor *)jarg2;
  92
  93   {
  94     try {
  95       if(jarg3 == NULL)
  96       {
  97         arg1->Dali::Toolkit::Flex::Node::AddChild((Dali::Actor &)*arg2, Dali::Extents(0,0,0,0), jarg4, jarg5);
  98       }
  99       else
 100       {
 101         Dali::Extents* arg3 = (Dali::Extents *)jarg3;
 102         arg1->Dali::Toolkit::Flex::Node::AddChild((Dali::Actor &)*arg2, *arg3, jarg4, jarg5);
 103       }
 104     } catch (std::out_of_range& e) {
 105       {
 106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 107       };
 108     } catch (std::exception& e) {
 109       {
 110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 111       };
 112     } catch (...) {
 113       {
 114         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 115       };
 116     }
 117   }
 118 }
 119
 120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_AddChild(void * jarg1, void *jarg2, Dali::Toolkit::Flex::MeasureCallback jarg3, int jarg4)
 121 {
 122   return CSharp_Dali_FlexLayout_AddChildWithMargin(jarg1,jarg2,NULL,jarg3,jarg4);
 123 }
 124
 125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_RemoveChild(void * jarg1, void * jarg2)
 126 {
 127   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 128   Dali::Actor* arg2 = (Dali::Actor *)jarg2;
 129
 130   arg1 = (Dali::Toolkit::Flex::Node*)jarg1;
 131   {
 132     try {
 133       arg1->Dali::Toolkit::Flex::Node::RemoveChild(*arg2);
 134     } catch (std::out_of_range& e) {
 135       {
 136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 137       };
 138     } catch (std::exception& e) {
 139       {
 140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 141       };
 142     } catch (...) {
 143       {
 144         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 145       };
 146     }
 147   }
 148 }
 149
 150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_CalculateLayout(void * jarg1, float jarg2, float jarg3, bool isRtl )
 151 {
 152   Dali::Toolkit::Flex::Node * arg1 = (Dali::Toolkit::Flex::Node* )jarg1;
 153   {
 154     try {
 155       arg1->Dali::Toolkit::Flex::Node::CalculateLayout(jarg2, jarg3, isRtl);
 156     } catch (std::out_of_range& e) {
 157       {
 158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 159       };
 160     } catch (std::exception& e) {
 161       {
 162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 163       };
 164     } catch (...) {
 165       {
 166         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 167       };
 168     }
 169   }
 170 }
 171
 172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetWidth(void * jarg1 )
 173 {
 174   Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1 ;
 175   float result = 0.0f;
 176   {
 177     try {
 178       result = arg1->Dali::Toolkit::Flex::Node::GetFlexWidth();
 179     } catch (std::out_of_range& e) {
 180       {
 181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 182       };
 183     } catch (std::exception& e) {
 184       {
 185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 186       };
 187     } catch (...) {
 188       {
 189         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 190       };
 191     }
 192   }
 193   return result;
 194 }
 195
 196
 197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FlexLayout_GetHeight(void * jarg1 )
 198 {
 199   float result = 0.0f;
 200   Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node* )jarg1 ;
 201   {
 202     try {
 203       result = arg1->Dali::Toolkit::Flex::Node::GetFlexHeight();
 204     } catch (std::out_of_range& e) {
 205       {
 206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 207       };
 208     } catch (std::exception& e) {
 209       {
 210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 211       };
 212     } catch (...) {
 213       {
 214         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 215       };
 216     }
 217   }
 218   return result;
 219 }
 220
 221 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_FlexLayout_GetNodeFrame( void * jarg1, int index )
 222 {
 223   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 224   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 225   Dali::Vector4 result;
 226   void* jresult;
 227   {
 228     try {
 229       result = arg1->Dali::Toolkit::Flex::Node::GetNodeFrame(index);
 230     } catch (std::out_of_range& e) {
 231       {
 232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 233       };
 234     } catch (std::exception& e) {
 235       {
 236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 237       };
 238     } catch (...) {
 239       {
 240         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 241       };
 242     }
 243   }
 244
 245   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
 246   return jresult;
 247 }
 248
 249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetMargin(void * jarg1, void * jarg2)
 250 {
 251   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 252
 253   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 254   Dali::Extents* arg2 = (Dali::Extents *)jarg2;
 255   {
 256     try {
 257       arg1->Dali::Toolkit::Flex::Node::SetMargin( *arg2);
 258     } catch (std::out_of_range& e) {
 259       {
 260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 261       };
 262     } catch (std::exception& e) {
 263       {
 264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 265       };
 266     } catch (...) {
 267       {
 268         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 269       };
 270     }
 271   }
 272 }
 273
 274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetPadding(void * jarg1, void * jarg2)
 275 {
 276   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 277
 278   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 279   Dali::Extents* arg2 = (Dali::Extents *)jarg2;
 280   {
 281     try {
 282       arg1->Dali::Toolkit::Flex::Node::SetPadding( *arg2);
 283     } catch (std::out_of_range& e) {
 284       {
 285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 286       };
 287     } catch (std::exception& e) {
 288       {
 289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 290       };
 291     } catch (...) {
 292       {
 293         SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 294       };
 295     }
 296   }
 297 }
 298
 299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexDirection(void * jarg1)
 300 {
 301   int jresult ;
 302   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 303   Dali::Toolkit::Flex::FlexDirection result;
 304
 305   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 306   {
 307     try {
 308       result = (Dali::Toolkit::Flex::FlexDirection)arg1->Dali::Toolkit::Flex::Node::GetFlexDirection();
 309     } catch (std::out_of_range& e) {
 310       {
 311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 312       };
 313     } catch (std::exception& e) {
 314       {
 315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 316       };
 317     } catch (...) {
 318       {
 319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 320       };
 321     }
 322   }
 323   jresult = (int)result;
 324   return jresult;
 325 }
 326
 327
 328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexJustification(void * jarg1, int jarg2)
 329 {
 330   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 331   Dali::Toolkit::Flex::Justification arg2 ;
 332
 333   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 334   arg2 = (Dali::Toolkit::Flex::Justification)jarg2;
 335   {
 336     try {
 337       arg1->Dali::Toolkit::Flex::Node::SetFlexJustification(arg2);
 338     } catch (std::out_of_range& e) {
 339       {
 340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 341       };
 342     } catch (std::exception& e) {
 343       {
 344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 345       };
 346     } catch (...) {
 347       {
 348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 349       };
 350     }
 351   }
 352 }
 353
 354
 355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexJustification(void * jarg1)
 356 {
 357   int jresult ;
 358   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 359   Dali::Toolkit::Flex::Justification result;
 360
 361   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 362   {
 363     try {
 364       result = (Dali::Toolkit::Flex::Justification)arg1->Dali::Toolkit::Flex::Node::GetFlexJustification();
 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 = (int)result;
 380   return jresult;
 381 }
 382
 383
 384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexWrap(void * jarg1, int jarg2)
 385 {
 386
 387   Dali::Toolkit::Flex::Node* arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 388   Dali::Toolkit::Flex::WrapType arg2 = (Dali::Toolkit::Flex::WrapType)jarg2;
 389   {
 390     try {
 391       arg1->Dali::Toolkit::Flex::Node::SetFlexWrap(arg2);
 392     } catch (std::out_of_range& e) {
 393       {
 394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 395       };
 396     } catch (std::exception& e) {
 397       {
 398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 399       };
 400     } catch (...) {
 401       {
 402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 403       };
 404     }
 405   }
 406 }
 407
 408
 409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexWrap(void * jarg1)
 410 {
 411   int jresult ;
 412   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 413   Dali::Toolkit::Flex::WrapType result;
 414
 415   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 416   {
 417     try {
 418       result = (Dali::Toolkit::Flex::WrapType)arg1->Dali::Toolkit::Flex::Node::GetFlexWrap();
 419     } catch (std::out_of_range& e) {
 420       {
 421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 422       };
 423     } catch (std::exception& e) {
 424       {
 425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 426       };
 427     } catch (...) {
 428       {
 429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 430       };
 431     }
 432   }
 433   jresult = (int)result;
 434   return jresult;
 435 }
 436
 437
 438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexAlignment(void * jarg1, int jarg2)
 439 {
 440   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 441   Dali::Toolkit::Flex::Alignment arg2 ;
 442
 443   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 444   arg2 = (Dali::Toolkit::Flex::Alignment)jarg2;
 445   {
 446     try {
 447       arg1->Dali::Toolkit::Flex::Node::SetFlexAlignment(arg2);
 448     } catch (std::out_of_range& e) {
 449       {
 450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 451       };
 452     } catch (std::exception& e) {
 453       {
 454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 455       };
 456     } catch (...) {
 457       {
 458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 459       };
 460     }
 461   }
 462 }
 463
 464
 465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexAlignment(void * jarg1)
 466 {
 467   int jresult ;
 468   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 469   Dali::Toolkit::Flex::Alignment result;
 470
 471   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 472   {
 473     try {
 474       result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexAlignment();
 475     } catch (std::out_of_range& e) {
 476       {
 477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 478       };
 479     } catch (std::exception& e) {
 480       {
 481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 482       };
 483     } catch (...) {
 484       {
 485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 486       };
 487     }
 488   }
 489   jresult = (int)result;
 490   return jresult;
 491 }
 492
 493
 494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FlexLayout_SetFlexItemsAlignment(void * jarg1, int jarg2)
 495 {
 496   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 497   Dali::Toolkit::Flex::Alignment arg2 ;
 498
 499   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 500   arg2 = (Dali::Toolkit::Flex::Alignment)jarg2;
 501   {
 502     try {
 503       arg1->Dali::Toolkit::Flex::Node::SetFlexItemsAlignment(arg2);
 504     } catch (std::out_of_range& e) {
 505       {
 506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 507       };
 508     } catch (std::exception& e) {
 509       {
 510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 511       };
 512     } catch (...) {
 513       {
 514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 515       };
 516     }
 517   }
 518 }
 519
 520
 521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexLayout_GetFlexItemsAlignment(void * jarg1)
 522 {
 523   int jresult ;
 524   Dali::Toolkit::Flex::Node *arg1 = (Dali::Toolkit::Flex::Node *) 0 ;
 525   Dali::Toolkit::Flex::Alignment result;
 526
 527   arg1 = (Dali::Toolkit::Flex::Node *)jarg1;
 528   {
 529     try {
 530       result = (Dali::Toolkit::Flex::Alignment)arg1->Dali::Toolkit::Flex::Node::GetFlexItemsAlignment();
 531     } catch (std::out_of_range& e) {
 532       {
 533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 534       };
 535     } catch (std::exception& e) {
 536       {
 537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 538       };
 539     } catch (...) {
 540       {
 541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 542       };
 543     }
 544   }
 545   jresult = (int)result;
 546   return jresult;
 547 }
 548
 549
 550
 551 #ifdef __cplusplus
 552 }
 553 #endif